class Dependabot::DependencyGroup

def contains?(dependency)
  return true if @dependencies.include?(dependency)
  return false if matches_excluded_pattern?(dependency.name)
  matches_pattern?(dependency.name) && matches_dependency_type?(dependency)
end

def experimental_rules_enabled?
  Dependabot::Experiments.enabled?(:grouped_updates_experimental_rules)
end

def initialize(name:, rules:, applies_to: "version-updates")
  @name = name
  # For backwards compatibility, if no applies_to is provided, default to "version-updates"
  @applies_to = T.let(applies_to || "version-updates", String)
  @rules = rules
  @dependencies = T.let([], T::Array[Dependabot::Dependency])
end

def matches_dependency_type?(dependency)
  return true unless rules.key?("dependency-type") # If no dependency-type is set, match by default
  rules["dependency-type"] == if dependency.production?
                                "production"
                              else
                                "development"
                              end
end

def matches_excluded_pattern?(dependency_name)
  return false unless rules.key?("exclude-patterns") # If there are no exclusions, fail by default
  T.unsafe(rules["exclude-patterns"]).any? { |rule| WildcardMatcher.match?(rule, dependency_name) }
end

def matches_pattern?(dependency_name)
  return true unless rules.key?("patterns") # If no patterns are defined, we pass this check by default
  T.unsafe(rules["patterns"]).any? { |rule| WildcardMatcher.match?(rule, dependency_name) }
end

def to_config_yaml
  {
    "groups" => { name => rules }
  }.to_yaml.delete_prefix("---\n")
end

def to_h
  { "name" => name }
end