| Creator: 	Project.<init>.tasks()
      | Rules:
         ⤷ PersonRules#createHelloTask(ModelMap<Task>, Person)
    + buildEnvironment
          | Type:   	org.gradle.api.tasks.diagnostics.BuildEnvironmentReportTask
          | Value:  	task ':buildEnvironment'
          | Creator: 	Project.<init>.tasks.buildEnvironment()
          | Rules:
             ⤷ copyToTaskContainer
    + components

			rules = append(rules, rule)
			continue
		}
		if obj.ExistingObject && rule.ExistingObjectReplication.Status == Disabled {
			continue
		}
		if !strings.HasPrefix(obj.Name, rule.Prefix()) {
			continue
		}
		if rule.Filter.TestTags(obj.UserTags) {
			rules = append(rules, rule)
		}
	}
	sort.Slice(rules, func(i, j int) bool {

        rules.rules[0].action == ruleAction
        rules.rules[0].spec == Specs.satisfyAll()
    }

    def "add rule source rule that applies to module"() {
        String notation = "${GROUP}:${MODULE}"

        when:
        rules.withModule(notation, ruleSource)

        then:
        1 * adapter.createFromRuleSource(ComponentSelection, ruleSource) >> ruleAction

        and:

                }
            }

            class Rules extends RuleSource {
                @Mutate
                void addTasks(ModelMap<Task> tasks) {
                    tasks.named("taskWithThrowingRuleApplied", ThrowingRule)
                    tasks.create("taskWithThrowingRuleApplied")
                }
            }

            apply type: Rules
        '''

        then:
        fails "tasks"

                @Model
                void p1(Thing t) {
                }

                @Rules
                void rules(CalculateName rules, Thing t) {
                }
            }

            class CalculateName extends RuleSource {
                @Rules
                void rules(SpecializeName rules, Thing t) {
                }
            }

            class SpecializeName extends RuleSource {

action: DENY
groups:
- rules:
  - matches:
    - destinationPorts:
      - 80
  - matches:
    - namespaces:
      - exact: from-mix-ns
      principals:
      - exact: from-mix-principal
- rules:
  - matches:
    - destinationPorts:
      - 80
  - matches:
    - namespaces:
      - exact: to-mix-ns
      principals:
      - exact: to-mix-principal
- rules:
  - matches:
    - destinationPorts:
      - 80

            }
        }
        apply plugin: Rules
        """

        expect:
        succeeds "validate"
    }


    def "can create a ModelMap of List<String>"() {
        buildFile << """
            class Rules extends RuleSource {
                @Model void things(ModelMap<List<String>> things) { }
            }
            apply plugin: Rules

            model {

    private static final String MESSAGE = "The following model rules could not be applied due to unbound inputs and/or subjects:";
    private final List<? extends UnboundRule> rules;

    public UnboundModelRulesException(List<? extends UnboundRule> rules) {
        super(toMessage(rules));
        this.rules = rules;
    }

    private static String toMessage(Iterable<? extends UnboundRule> rules) {
        StringWriter string = new StringWriter();

groups:
- rules:
  - matches:
    - notPrincipals:
      - exact: not-principal
      - prefix: not-principal-prefix-
      - suffix: -suffix-not-principal
      - presence: {}
      principals:
      - exact: principal
      - prefix: principal-prefix-
      - suffix: -suffix-principal
      - presence: {}
- rules:
  - matches:
    - namespaces:
      - exact: ns
      - prefix: ns-prefix-
      - suffix: -ns-suffix

    }

    def "informative error message when two plugins declare model at the same path and model is already created"() {
        when:
        buildScript '''
            class MyPlugin {
                static class Rules extends RuleSource {
                    @Model