teammates-macker.xml

<?xml version="1.0"?>
<macker>
    <ruleset name="Architectural rules for TEAMMATES">
        <var name="ui" value="teammates.ui" />
        <var name="logic" value="teammates.logic" />
        <var name="storage" value="teammates.storage" />
        <var name="common" value="teammates.common" />
        <var name="test" value="teammates.test" />
        <var name="testCases" value="teammates.test.cases" />
        <var name="e2e" value="teammates.e2e" />
        <var name="e2eCases" value="teammates.e2e.cases" />
        <var name="client" value="teammates.client" />

        <ruleset name="Architectural rules for production code">
            <ruleset name="PackageDiagram: UI should not touch Storage">
                <access-rule>
                    <deny>
                        <from class="${ui}.**" />
                        <to class="${storage}.**" />
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="PackageDiagram: Logic should not touch UI">
                <access-rule>
                    <deny>
                        <from class="${logic}.**" />
                        <to class="${ui}.**" />
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="PackageDiagram: Storage should not touch Logic">
                <access-rule>
                    <deny>
                        <from class="${storage}.**" />
                        <to class="${logic}.**" />
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="PackageDiagram: Storage should not touch UI">
                <access-rule>
                    <deny>
                        <from class="${storage}.**" />
                        <to class="${ui}.**" />
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="PackageDiagram: Common should not have dependencies to any packages except storage::entity">
                <access-rule>
                    <deny>
                        <from class="${common}.**" />
                        <to class="teammates.**" >
                            <exclude class="${common}.**" /> <!-- allow dependency within the package -->
                        </to>
                        <allow>
                            <from class="${common}.datatransfer.**" />
                            <to class="${storage}.entity.**" />
                        </allow>
                        <allow>
                            <from>
                                <!-- violations that need fixing -->
                                <include class="${common}.datatransfer.questions.FeedbackConstantSumQuestionDetails" />
                                <include class="${common}.datatransfer.questions.FeedbackMcqQuestionDetails" />
                                <include class="${common}.datatransfer.questions.FeedbackMsqQuestionDetails" />
                                <include class="${common}.datatransfer.questions.FeedbackRankOptionsQuestionDetails" />
                                <include class="${common}.datatransfer.questions.FeedbackRankRecipientsQuestionDetails" />
                                <include class="${common}.datatransfer.questions.FeedbackRankRecipientsQuestionDetails**$**" />
                            </from>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>

            <ruleset name="UiComponent: Only *Action can touch Logic API">
                <access-rule>
                    <deny>
                        <from class="${ui}.**" />
                        <to class="${logic}.**" />
                        <allow>
                            <from>
                                <include class="${ui}.controller.**" />
                                <include class="${ui}.webapi.action.**" />
                                <include class="${ui}.automated.**" />
                            </from>
                            <to class="${logic}.api.**" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="UiComponent: API output is only used in Web API package">
                <access-rule>
                    <deny>
                        <from class="${ui}.**" >
                            <exclude class="${ui}.webapi.output.**" /> <!-- allow dependency within the package -->
                            <exclude class="${ui}.webapi.request.**" />
                        </from>
                        <to class="${ui}.webapi.output.**" />
                        <allow>
                            <from>
                                <include class="${ui}.webapi.action.**" />
                                <include class="${e2e}.util.BackDoor" />
                            </from>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="UiComponent: API request DTO is only used in Web API package">
                <access-rule>
                    <deny>
                        <from class="${ui}.**" >
                            <exclude class="${ui}.webapi.request.**" /> <!-- allow dependency within the package -->
                        </from>
                        <to class="${ui}.webapi.request.**" />
                        <allow>
                            <from>
                                <include class="${ui}.webapi.action.**" />
                            </from>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="UiComponent: API output should not have dependencies to anything within the UI component">
                <access-rule>
                    <deny>
                        <from class="${ui}.webapi.output.**" />
                        <to class="${ui}.**" />
                        <allow>
                            <to class="${ui}.webapi.output.**" /> <!-- allow dependency within the package -->
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="UiComponent: Controller should be self-contained">
                <access-rule>
                    <deny>
                        <from class="${ui}.**" />
                        <to class="${ui}.webapi.action.**" />
                        <allow>
                            <from class="${ui}.webapi.action.**" /> <!-- allow dependency within the package -->
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="UiComponent: Automated actions should be self-contained">
                <access-rule>
                    <deny>
                        <from class="${ui}.**" />
                        <to class="${ui}.automated.**" />
                        <allow>
                            <from class="${ui}.automated.**" /> <!-- allow dependency within the package -->
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="UiComponent: Automated actions should not have dependencies to anything within the UI component">
                <access-rule>
                    <deny>
                        <from class="${ui}.automated.**" />
                        <to class="${ui}.**" />
                        <allow>
                            <to class="${ui}.automated.**" /> <!-- allow dependency within the package -->
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>

            <ruleset name="LogicComponent: Logic classes can only access storage::api">
                <access-rule>
                    <deny>
                        <from class="${logic}.**" />
                        <to class="${storage}.**" />
                        <allow>
                            <from>
                                <include class="${logic}.core.**" />
                            </from>
                            <to class="${storage}.api.**" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="LogicComponent: Each logic can only access its corresponding DB (e.g. AccountsLogic -> AccountsDb)">
                <foreach var="logicModule" class="${logic}.core.(*)Logic">
                    <pattern name="DbModule" class="${storage}.api.${logicModule}Db" />

                    <access-rule>
                        <message>${logicModule} can only access ${logicModule}Db</message>
                        <deny>
                            <from class="${logic}.core.${logicModule}Logic" />
                            <to class="${storage}.api.**" />
                            <allow>
                                <!-- Allow access from DataBundleLogic -->
                                <from class="${logic}.core.DataBundleLogic" />
                            </allow>
                            <allow>
                                <to pattern="DbModule" />
                            </allow>
                        </deny>
                    </access-rule>
                </foreach>
            </ruleset>
            <ruleset name="LogicComponent: logic::core should not access logic::api">
                <access-rule>
                    <deny>
                        <from class="${logic}.core.**" />
                        <to class="${logic}.api.**" />
                    </deny>
                </access-rule>
            </ruleset>

            <ruleset name="StorageComponent: storage::search should not touch storage::entity">
                <access-rule>
                    <deny>
                        <from class="${storage}.search.**" />
                        <to class="${storage}.entity.**" />
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="StorageComponent: storage::entity should not depend on anything within the storage component">
                <access-rule>
                    <deny>
                        <from class="${storage}.entity.**" />
                        <to class="${storage}.**" />
                        <allow>
                            <to class="${storage}.entity.**" /> <!-- allow dependency within the package -->
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>

            <ruleset name="CommonComponent: Assumption class can only be used by production code; non-production code should use JUnit instead">
                <access-rule>
                    <deny>
                        <to>
                            <include class="teammates.common.util.Assumption" />
                        </to>
                        <from>
                            <include class="${test}.**" />
                            <include class="${e2e}.**" />
                            <include class="${client}.**" />
                        </from>
                    </deny>
                </access-rule>
            </ruleset>
        </ruleset>

        <ruleset name="Architectural rules for test code">
            <ruleset name="TestDriverComponent: Test cases should not be dependent on each other">
                <access-rule>
                    <deny>
                        <from class="${testCases}.**" />
                        <to class="${testCases}.**" />
                        <allow>
                            <!-- allow dependency from inner class -->
                            <from class="${testCases}.**$**" />
                        </allow>
                        <allow>
                            <to>
                                <!-- allow dependency to inner class -->
                                <include class="${testCases}.**$**" />
                                <!-- allow dependency to base class -->
                                <include class="${testCases}.**Base**" />
                            </to>
                        </allow>
                        <allow>
                            <!-- allow dependency from Feedback*QuestionUiTest to FeedbackQuestionUiTest -->
                            <from class="${testCases}.browsertests.Feedback*QuestionUiTest" />
                            <to class="${testCases}.browsertests.FeedbackQuestionUiTest" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="TestDriverComponent: Only certain test cases can test storage:entity">
                <access-rule>
                    <deny>
                        <from class="${test}.**" />
                        <to class="${storage}.entity.**" />
                        <allow>
                            <from>
                                <include class="${testCases}.datatransfer.**" />
                                <include class="${testCases}.storage.**" />
                            </from>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="TestDriverComponent: Only certain test cases can access GaeSimulation/Logic">
                <access-rule>
                    <deny>
                        <from class="${test}.**" />
                        <to>
                            <include class="${test}.driver.GaeSimulation" />
                            <include class="${logic}.api.Logic" />
                        </to>
                        <allow>
                            <from>
                                <include class="${testCases}.storage.**" />
                                <include class="${testCases}.logic.**" />
                                <include class="${testCases}.action.**" />
                                <include class="${testCases}.webapi.**" />
                                <include class="${testCases}.automated.**" />
                                <include class="${testCases}.search.**" />
                                <include class="${testCases}.BaseComponentTestCase" />
                                <include class="${testCases}.BaseTestCaseWithMinimalGaeEnvironment" />
                            </from>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
        </ruleset>

        <ruleset name="Architectural rules for E2E code">
            <ruleset name="PackageDiagram: E2E component should be self-contained">
                <access-rule>
                    <deny>
                        <to class="${e2e}.**" />
                        <allow>
                            <from class="${e2e}.**" />
                        </allow>

                        <!-- to remove after front-end migration is done -->
                        <allow>
                            <from class="${test}.pageobjects.**" />
                            <to class="${e2e}.**" />
                        </allow>
                        <allow>
                            <from class="${testCases}.browsertests.**" />
                            <to class="${e2e}.**" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="PackageDiagram: E2E cannot touch production code except for common components">
                <access-rule>
                    <deny>
                        <from class="${e2e}.**" />
                        <to>
                            <include class="${ui}.**" />
                            <include class="${logic}.**" />
                            <include class="${storage}.**" />
                        </to>
                        <allow>
                            <to class="${ui}.webapi.output.**" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="E2EComponent: E2E test cases should not be dependent on each other">
                <access-rule>
                    <deny>
                        <from class="${e2eCases}.**" />
                        <to class="${e2eCases}.**" />
                        <allow>
                            <!-- allow dependency from inner class -->
                            <from class="${e2eCases}.**$**" />
                        </allow>
                        <allow>
                            <to>
                                <!-- allow dependency to inner class -->
                                <include class="${e2eCases}.**$**" />
                                <!-- allow dependency to base class -->
                                <include class="${e2eCases}.**Base**" />
                            </to>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="E2EComponent: Only E2E tests can access page object classes">
                <access-rule>
                    <deny>
                        <from class="${e2e}.**" >
                            <exclude class="${e2e}.pageobjects.**" /> <!-- allow dependency within the package -->
                        </from>
                        <to class="${e2e}.pageobjects.**" />
                        <allow>
                            <from>
                                <include class="${e2eCases}.e2e.**" />
                            </from>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="E2EComponent: e2e::util should not have dependencies to anything within the e2e package">
                <access-rule>
                    <deny>
                        <from class="${e2e}.util.**" />
                        <to class="${e2e}.**" />
                        <allow>
                            <to class="${e2e}.util.**" /> <!-- allow dependency within the package -->
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
        </ruleset>

        <ruleset name="Architectural rules for client code">
            <ruleset name="PackageDiagram: Client scripts should be self-contained">
                <access-rule>
                    <deny>
                        <to class="${client}.**" />
                        <allow>
                            <from class="${client}.**" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="PackageDiagram: Client should not touch UI">
                <access-rule>
                    <deny>
                        <from class="${client}.**" />
                        <to class="${ui}.**" />
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="PackageDiagram: client::remoteapi should not depend on client::scripts">
                <access-rule>
                    <deny>
                        <from class="${client}.remoteapi.**" />
                        <to class="${client}.scripts.**" />
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="PackageDiagram: client::util should not have dependencies to anything within the client package">
                <access-rule>
                    <deny>
                        <from class="${client}.util.**" />
                        <to class="${client}.**" />
                        <allow>
                            <to class="${client}.util.**" /> <!-- allow dependency within the package -->
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
        </ruleset>

        <ruleset name="Architectural rules for external API calls">
            <ruleset name="Java Logging API can only be accessed via Logger">
                <access-rule>
                    <deny>
                        <to class="java.util.logging.**" />
                        <allow>
                            <from class="${common}.util.Logger" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="Search API can only be accessed via storage::api, storage::search and client scripts">
                <access-rule>
                    <deny>
                        <to class="com.google.appengine.api.search.**" />
                        <allow>
                            <from>
                                <include class="${storage}.api.**" />
                                <include class="${storage}.search.**" />
                                <include class="${client}.scripts.**" />
                            </from>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="Google Cloud Storage API can only be accessed via GoogleCloudStorageHelper">
                <access-rule>
                    <deny>
                        <to class="com.google.appengine.tools.cloudstorage.**" />
                        <allow>
                            <from>
                                <include class="${common}.util.GoogleCloudStorageHelper" />
                                <include class="${client}.**" />
                            </from>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="Blobstore API and data types can only be accessed via GoogleCloudStorageHelper and entity classes">
                <access-rule>
                    <deny>
                        <to class="com.google.appengine.api.blobstore.**" />
                        <allow>
                            <from class="${common}.util.GoogleCloudStorageHelper" />
                        </allow>
                        <allow>
                            <from class="${storage}.entity.**" />
                            <to class="com.google.appengine.api.blobstore.BlobKey" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="Task Queue API can only be accessed via TaskQueuesLogic">
                <access-rule>
                    <deny>
                        <to class="com.google.appengine.api.taskqueue.**" />
                        <allow>
                            <from class="${logic}.core.TaskQueuesLogic" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="Remote API can only be accessed via RemoteApiClient">
                <access-rule>
                    <deny>
                        <to class="com.google.appengine.tools.remoteapi.**" />
                        <allow>
                            <from class="${client}.remoteapi.RemoteApiClient" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="Objectify API can only be accessed via storage::api, Objectify base test case and client scripts">
                <access-rule>
                    <deny>
                        <to>
                            <include class="com.googlecode.objectify.**" />
                        </to>
                        <allow>
                            <from>
                                <include class="${storage}.api.**" />
                                <include class="${storage}.entity.**" />
                                <include class="${testCases}.BaseTestCaseWithObjectifyAccess" />
                                <include class="${client}.remoteapi.**" />
                                <include class="${client}.scripts.**" />
                            </from>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="Google Cloud Datastore specific data type can only be accessed in storage::entity">
                <!-- Remove the rule after Objectify V6 as V6 does not have Text data type anymore -->
                <access-rule>
                    <deny>
                        <to class="com.google.appengine.api.datastore.Text" />
                        <allow>
                            <from class="${storage}.entity.**" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="Servlet API can only be accessed via Servlet classes, GaeSimulation, and selected utility classes">
                <access-rule>
                    <deny>
                        <to class="javax.servlet.**" />
                        <allow>
                            <from>
                                <include class="${common}.util.ActivityLogEntry" />
                                <include class="${common}.util.GoogleCloudStorageHelper" />
                                <include class="${common}.util.HttpRequestHelper" />
                                <include class="${storage}.api.OfyHelper" />
                                <include class="${ui}.automated.**" />
                                <include class="${ui}.controller.**" />
                                <include class="${ui}.webapi.action.**" />
                                <include class="${test}.driver.GaeSimulation" />
                                <include class="${test}.driver.MockFilterChain" />
                                <include class="${test}.driver.MockHttpServletRequest" />
                                <include class="${test}.driver.MockHttpServletRequest$**" />
                                <include class="${test}.driver.MockHttpServletResponse" />
                                <include class="${test}.driver.MockPart" />
                            </from>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="java.util.Date/java.util.Calendar should not be used">
                <access-rule>
                    <deny>
                        <to>
                            <include class="java.util.Date" />
                            <include class="java.util.Calendar" />
                        </to>
                        <allow>
                            <!-- allow data type translator in BaseEntity -->
                            <!-- this exception can be removed after upgrading to Objectify V6 -->
                            <from class="${storage}.entity.BaseEntity$InstantTranslatorFactory**" />
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
            <ruleset name="Assertion API can only be accessed via BaseTestCase and few selected classes">
                <access-rule>
                    <deny>
                        <to>
                            <include class="org.junit.Assert" />
                        </to>
                        <allow>
                            <from>
                                <include class="${testCases}.BaseTestCase" />
                                <include class="${test}.driver.AssertHelper" />
                                <include class="${test}.driver.CsvChecker" />
                                <include class="${test}.driver.EmailChecker" />
                                <include class="${e2e}.pageobjects.**" />
                                <include class="${e2e}.util.HtmlHelper" />
                            </from>
                        </allow>

                        <!-- to remove after front-end migration is done -->
                        <allow>
                            <from>
                                <include class="${test}.pageobjects.**" />
                                <include class="${test}.driver.GaeSimulation" />
                            </from>
                        </allow>
                    </deny>
                </access-rule>
            </ruleset>
        </ruleset>
    </ruleset>
</macker>