<ruleset xmlns="http://codenarc.org/ruleset/1.0"
                    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                    xsi:schemaLocation="http://codenarc.org/ruleset/1.0 http://codenarc.org/ruleset-schema.xsd"
                    xsi:noNamespaceSchemaLocation="http://codenarc.org/ruleset-schema.xsd">
                <ruleset-ref path="rulesets/naming.xml"/>
            </ruleset>

[[sec:rules_in_settings]]
=== Declaring rules in a central place

NOTE: Declaring component metadata rules in settings is an incubating feature

Instead of declaring rules for each subproject individually, it is possible to declare rules in the `settings.gradle(.kts)` file for the whole build.
Rules declared in settings are the _conventional_ rules applied to each project: if the project doesn't declare any rules, the rules from the settings script will be used.

      | Rules:
         ⤷ components { ... } @ build.gradle line 37, column 5
         ⤷ MyPlugin#mutateMyComponents(ModelMap<MyComponentInternal>)
    + my
          | Type:   	MyComponent
          | Creator: 	components { ... } @ build.gradle line 37, column 5 > create(my)
          | Rules:
             ⤷ MyPlugin#mutateMyComponents(ModelMap<MyComponentInternal>) > all()

        }
    }

    static String customRuleSet() {
        """
            <ruleset name="custom"
                xmlns="http://pmd.sf.net/ruleset/1.0.0"
                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xsi:schemaLocation="http://pmd.sf.net/ruleset/1.0.0 http://pmd.sf.net/ruleset_xml_schema.xsd"

			enableJobSuccessPolicy: true,
			completions:            10,
			succeededIndexes:       orderedIntervals{},
			successPolicy: &batch.SuccessPolicy{
				Rules: []batch.SuccessPolicyRule{{
					SucceededIndexes: ptr.To(""),
				}},
			},
		},

- Method rules($SomeRuleSource.name, java.lang.String, java.lang.Integer) is not a valid rule method: Rule parameter #1 should not be annotated with @Each."""
    }

    static class InvalidEachAndPathAnnotation extends RuleSource {
        @Rules
        void valid(SomeRuleSource rules, @Path("value") String value, Integer input) {}

        @Rules

        permissions:
        - andRules:
            rules:
            - orRules:
                rules:
                - destinationPort: 80
            - notRule:
                orRules:
                  rules:
                  - destinationPort: 8000
            - orRules:
                rules:
                - destinationIp:
                    addressPrefix: 10.10.10.10

}

type Set[T any] struct {
	rules Rules[T]
}

func NewSet[T any](rules Rules[T]) Set[T] {
	return Set[T]{
		rules: rules,
	}
}

func (s Set[T]) Copy() Set[T] {
	return NewSet(s.rules)
}

type Rules[T any] interface {
	Hash(T) int
	Equivalent(T, T) bool
	SameRules(Rules[T]) bool
}

type testRules struct{}

func newTestRules() Rules[int] {
	return testRules{}
}

        1 * instantiator.newInstance(JacocoViolationRuleImpl.class) >> new JacocoViolationRuleImpl()
        violationRulesContainer.rules.size() == 2
        violationRulesContainer.rules[1] == rule
    }

    def "returned rules are unmodifiable"() {
        when:
        violationRulesContainer.rules << new JacocoViolationRuleImpl()

        then:
        thrown(UnsupportedOperationException)
    }

import org.gradle.internal.rules.ClosureBackedRuleAction
import org.gradle.internal.rules.NoInputsRuleAction
import org.gradle.internal.rules.SpecRuleAction
import org.gradle.util.AttributeTestUtil
import spock.lang.Specification

class ComponentSelectionRulesProcessorTest extends Specification {
    def processor = new ComponentSelectionRulesProcessor()
    def rules = []
    ComponentSelectionInternal componentSelection