rubocop-metz 0.5.3

data/lib/rubocop/cop/metz/controllers_too_many_direct_collaborators.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require_relative "../../../metz/file_classifier"
+require_relative "../../../metz/cop_metadata"
+
+module RuboCop
+  module Cop
+    module Metz
+      class ControllerClassConstants
+        def initialize(method_node)
+          @class_node = method_node.each_ancestor(:class).first
+        end
+
+        def names
+          return [] unless class_node
+
+          (class_names + own_names + qualified_own_names).uniq
+        end
+
+        private
+
+        attr_reader :class_node
+
+        def class_names
+          return [] unless own_name
+
+          [own_name, lexically_qualified_name].compact.uniq
+        end
+
+        def own_name
+          @own_name ||= constant_name(class_node.children.first)
+        end
+
+        def lexically_qualified_name
+          return own_name if own_name.include?("::")
+          return nil if namespace.empty?
+
+          (namespace + [own_name]).join("::")
+        end
+
+        def namespace
+          @namespace ||= class_node.each_ancestor(:class, :module).to_a.reverse.filter_map do |ancestor|
+            constant_name(ancestor.children.first)
+          end
+        end
+
+        def own_names
+          @own_names ||= direct_body_children.flat_map { |child| own_names_for(child) }.uniq
+        end
+
+        def direct_body_children
+          body = class_node.children[2]
+          return [] unless body
+
+          body.begin_type? ? body.children : [body]
+        end
+
+        def own_names_for(node)
+          return casgn_name(node) if node.casgn_type?
+          return class_or_module_names(node) if node.class_type? || node.module_type?
+
+          []
+        end
+
+        def casgn_name(node)
+          return [] unless controller_constant_assignment?(node.children.first)
+
+          [node.children[1].to_s]
+        end
+
+        def controller_constant_assignment?(scope)
+          return true if scope.nil? || scope.self_type?
+          return false unless scope.const_type?
+
+          class_names.include?(scope.const_name)
+        end
+
+        def class_or_module_names(node)
+          name = constant_name(node.children.first)
+
+          name ? [name, name.split("::").last] : []
+        end
+
+        def qualified_own_names
+          own_names.flat_map do |name|
+            class_names.map { |class_name| "#{class_name}::#{name}" }
+          end
+        end
+
+        def constant_name(node)
+          node&.const_type? ? node.const_name : nil
+        end
+      end
+
+      class ControllerCollaboratorCollector
+        CORE_COLLABORATOR_ALLOWLIST = %w[
+          Rails Arel Time Date DateTime File FileUtils Pathname Hash Array String Integer Float
+          Symbol Set SecureRandom JSON YAML URI CGI ERB
+        ].freeze
+
+        def initialize(method_node)
+          @method_node = method_node
+          @same_class_constants = ControllerClassConstants.new(method_node).names
+        end
+
+        def call
+          method_node.each_descendant(:const).with_object({}) do |const_node, ordered|
+            record(ordered, const_node)
+          end
+        end
+
+        private
+
+        attr_reader :method_node, :same_class_constants
+
+        def record(ordered, const_node)
+          name = const_node.const_name
+          return if name.nil? || ignored?(const_node, name)
+
+          ordered[name] ||= const_node
+        end
+
+        def ignored?(const_node, name)
+          nested_inside_const?(const_node) ||
+            rescue_exception_class?(const_node) ||
+            raise_exception_class?(const_node) ||
+            allowed_core_constant?(name) ||
+            same_class_constants.include?(name)
+        end
+
+        def nested_inside_const?(const_node)
+          parent = const_node.parent
+          parent&.const_type? && parent.children.first.equal?(const_node)
+        end
+
+        def rescue_exception_class?(const_node)
+          resbody_node = const_node.each_ancestor(:resbody).first
+          return false unless resbody_node
+
+          descendant_of?(const_node, resbody_node.children.first)
+        end
+
+        def raise_exception_class?(const_node)
+          send_node = const_node.each_ancestor(:send).find { |ancestor| raise_or_fail?(ancestor) }
+          return false unless send_node
+
+          descendant_of?(const_node, send_node.arguments.first)
+        end
+
+        def raise_or_fail?(send_node)
+          send_node.receiver.nil? && %i[raise fail].include?(send_node.method_name)
+        end
+
+        def descendant_of?(node, ancestor)
+          return false unless ancestor
+
+          current = node
+          current = current.parent while current && !current.equal?(ancestor)
+          current.equal?(ancestor)
+        end
+
+        def allowed_core_constant?(name)
+          root_name = name.delete_prefix("::").split("::").first
+
+          CORE_COLLABORATOR_ALLOWLIST.include?(root_name)
+        end
+      end
+
+      # Flags Rails controller methods that reach into more than
+      # `MaxCollaborators` distinct top-level collaborators. A "direct
+      # collaborator" is an application constant referenced inside a method
+      # body -- whether bare (`User`), as the receiver of `.new` (`User.new`),
+      # or as the receiver of another message (`Mailer.confirmation(...)`).
+      # Exception classes at `rescue`/`raise`/`fail` sites, constants owned by
+      # the controller class, and core framework/stdlib constants do not
+      # count. Multiple references
+      # to the same constant count once. The cop is path-classified through
+      # `Metz::FileClassifier.controller?` and is silent on any file that is
+      # not under `app/controllers/`.
+      class ControllersTooManyDirectCollaborators < RuboCop::Cop::Base
+        extend ::Metz::CopMetadata
+
+        MSG = "Controller method `%<method>s` reaches into %<count>d " \
+              "direct collaborators (%<list>s); " \
+              "Max is %<max>d. Reduce by funneling work through a single coordinator."
+
+        why_it_matters "Controllers that touch many collaborators turn into orchestration soup, " \
+                       "hiding intent and resisting change."
+        fix_safety :manual
+        suggested_next_moves [
+          "Introduce a single coordinator/service object that owns the multi-step workflow.",
+          "Push side-effecting calls into a service the controller invokes once.",
+          "Move auxiliary lookups into model scopes or named queries on the primary resource."
+        ]
+
+        def on_def(node)
+          collaborators = collect_collaborators(node)
+          return if collaborators.size <= max_collaborators
+
+          report_offense(node, collaborators)
+        end
+
+        def relevant_file?(file)
+          return super if file.nil? || file.empty? || file == "(string)"
+
+          !file_name_matches_any?(file, "Exclude", false) &&
+            ::Metz::FileClassifier.controller?(file)
+        end
+
+        private
+
+        def collect_collaborators(method_node)
+          ControllerCollaboratorCollector.new(method_node).call
+        end
+
+        def report_offense(method_node, collaborators)
+          add_offense(collaborators.values.first, message: build_message(method_node, collaborators))
+        end
+
+        def build_message(method_node, collaborators)
+          format(MSG,
+                 method: method_node.method_name,
+                 count: collaborators.size,
+                 list: collaborators.keys.join(", "),
+                 max: max_collaborators)
+        end
+
+        def max_collaborators
+          cop_config["MaxCollaborators"] || 1
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metz/demeter_train_wreck/type_inference.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require_relative "../demeter_train_wreck" unless defined?(RuboCop::Cop::Metz::DemeterTrainWreck)
+
+module RuboCop
+  module Cop
+    module Metz
+      class DemeterTrainWreck
+        # Static type-inference data for `Metz/DemeterTrainWreck`. Hosts the
+        # `METHOD_RETURN_TYPES` map (per `docs/demeter-design.md` §5), the
+        # AST-node-to-value-object literal map, the pass-through method set,
+        # the operator method set, and the reverse-lookup table that powers
+        # the unknown-receiver heuristic from §1 of the design doc.
+        module TypeInference # rubocop:disable Metrics/ModuleLength
+          # The inference tables are conservative: unknown or missing return-type
+          # data is treated as advisory noise reduction (`nil`/`:unknown`) so
+          # the cop stays quiet when certainty is incomplete.
+
+          PASS_THROUGH = %i[tap then yield_self itself dup clone freeze].to_set.freeze
+
+          OPERATOR_METHODS = (
+            %i[+ - * / % **] +
+              %i[== != < > <= >= <=> === =~ !~] +
+              %i[& | ^ << >>]
+          ).to_set.freeze
+
+          # rubocop:disable Lint/BooleanSymbol
+          LITERAL_MAP = {
+            str: :string, dstr: :string, xstr: :string,
+            sym: :symbol, dsym: :symbol,
+            int: :integer, float: :float,
+            array: :array, hash: :hash,
+            true: :boolean, false: :boolean, nil: :nil_value,
+            regexp: :regexp, irange: :range, erange: :range
+          }.freeze
+          # rubocop:enable Lint/BooleanSymbol
+
+          METHOD_RETURN_TYPES = {
+            string: {
+              upcase: :string, downcase: :string, capitalize: :string,
+              swapcase: :string, strip: :string, lstrip: :string, rstrip: :string,
+              chomp: :string, chop: :string, reverse: :string,
+              sub: :string, gsub: :string, tr: :string, tr_s: :string,
+              squeeze: :string, delete: :string, delete_prefix: :string,
+              delete_suffix: :string, slice: :string, succ: :string, next: :string,
+              center: :string, ljust: :string, rjust: :string,
+              inspect: :string, dump: :string, encode: :string, force_encoding: :string,
+              to_s: :string, freeze: :string, dup: :string, clone: :string,
+              :+ => :string, :* => :string,
+              :[] => :string,
+              to_sym: :symbol, intern: :symbol,
+              to_i: :integer, hex: :integer, oct: :integer, ord: :integer,
+              to_f: :float,
+              split: :array, chars: :array, bytes: :array, lines: :array,
+              scan: :array, unpack: :array, codepoints: :array, grapheme_clusters: :array,
+              each_char: :enumerator, each_byte: :enumerator, each_line: :enumerator,
+              size: :integer, length: :integer, bytesize: :integer, count: :integer,
+              start_with?: :boolean, end_with?: :boolean, include?: :boolean,
+              empty?: :boolean, match?: :boolean, ascii_only?: :boolean,
+              valid_encoding?: :boolean, frozen?: :boolean,
+              :== => :boolean, :=== => :boolean, :!= => :boolean,
+              :< => :boolean, :> => :boolean, :<= => :boolean, :>= => :boolean,
+              :<=> => :integer, casecmp: :integer, casecmp?: :boolean,
+              hash: :integer
+            }.freeze,
+            symbol: {
+              to_s: :string, id2name: :string, inspect: :string,
+              upcase: :symbol, downcase: :symbol, capitalize: :symbol,
+              swapcase: :symbol, succ: :symbol, next: :symbol,
+              to_proc: :proc, to_sym: :symbol,
+              length: :integer, size: :integer,
+              empty?: :boolean, match?: :boolean,
+              :== => :boolean, :=== => :boolean, :<=> => :integer,
+              :[] => :string
+            }.freeze,
+            integer: {
+              to_s: :string, inspect: :string, chr: :string,
+              to_i: :integer, to_int: :integer, abs: :integer, succ: :integer, pred: :integer,
+              magnitude: :integer, bit_length: :integer, digits: :array,
+              to_f: :float, fdiv: :float,
+              zero?: :boolean, positive?: :boolean, negative?: :boolean,
+              even?: :boolean, odd?: :boolean, integer?: :boolean,
+              :+ => :integer, :- => :integer, :* => :integer, :/ => :integer,
+              :% => :integer, :** => :integer, :<=> => :integer,
+              :== => :boolean, :=== => :boolean,
+              :< => :boolean, :> => :boolean, :<= => :boolean, :>= => :boolean,
+              divmod: :array, coerce: :array,
+              times: :enumerator, upto: :enumerator, downto: :enumerator
+            }.freeze,
+            float: {
+              to_s: :string, inspect: :string,
+              to_i: :integer, to_int: :integer, truncate: :integer,
+              ceil: :integer, floor: :integer, round: :integer,
+              to_f: :float, abs: :float, magnitude: :float,
+              zero?: :boolean, positive?: :boolean, negative?: :boolean,
+              nan?: :boolean, infinite?: :boolean, finite?: :boolean,
+              :+ => :float, :- => :float, :* => :float, :/ => :float,
+              :== => :boolean, :<=> => :integer
+            }.freeze,
+            array: {
+              first: :unknown, last: :unknown, sample: :unknown, min: :unknown, max: :unknown,
+              sum: :unknown, fetch: :unknown, dig: :unknown,
+              :[] => :unknown, at: :unknown,
+              map: :array, collect: :array, select: :array, filter: :array,
+              reject: :array, sort: :array, sort_by: :array, reverse: :array,
+              compact: :array, flatten: :array, uniq: :array, take: :array,
+              drop: :array, take_while: :array, drop_while: :array,
+              each_slice: :enumerator, each_cons: :enumerator,
+              zip: :array, product: :array, combination: :enumerator, permutation: :enumerator,
+              partition: :array, group_by: :hash, tally: :hash, to_h: :hash,
+              chunk_while: :enumerator, slice_when: :enumerator,
+              min_by: :unknown, max_by: :unknown, find: :unknown, detect: :unknown,
+              join: :string, inspect: :string, to_s: :string, pack: :string,
+              size: :integer, length: :integer, count: :integer,
+              empty?: :boolean, any?: :boolean, all?: :boolean, none?: :boolean,
+              one?: :boolean, include?: :boolean, member?: :boolean, frozen?: :boolean,
+              :== => :boolean, :<=> => :integer,
+              :+ => :array, :- => :array,
+              :& => :array, :| => :array,
+              to_a: :array, to_ary: :array, dup: :array, clone: :array, freeze: :array,
+              each: :enumerator, each_with_index: :enumerator
+            }.freeze,
+            hash: {
+              keys: :array, values: :array, to_a: :array, entries: :array,
+              map: :array, collect: :array, flat_map: :array, sort: :array, sort_by: :array,
+              select: :hash, filter: :hash, reject: :hash, compact: :hash,
+              merge: :hash, merge!: :hash, transform_keys: :hash, transform_values: :hash,
+              invert: :hash, to_h: :hash, slice: :hash, except: :hash, dup: :hash, clone: :hash,
+              fetch: :unknown, dig: :unknown, :[] => :unknown, store: :unknown, assoc: :unknown,
+              min_by: :unknown, max_by: :unknown, find: :unknown,
+              size: :integer, length: :integer, count: :integer,
+              empty?: :boolean, any?: :boolean, all?: :boolean,
+              include?: :boolean, member?: :boolean,
+              key?: :boolean, has_key?: :boolean, value?: :boolean, has_value?: :boolean,
+              frozen?: :boolean,
+              :== => :boolean,
+              inspect: :string, to_s: :string,
+              each: :enumerator, each_pair: :enumerator, each_key: :enumerator,
+              each_value: :enumerator, each_with_index: :enumerator,
+              keys_at: :array, values_at: :array
+            }.freeze,
+            boolean: {
+              :& => :boolean, :| => :boolean, :^ => :boolean, :! => :boolean,
+              inspect: :string, to_s: :string,
+              :== => :boolean, :=== => :boolean
+            }.freeze,
+            regexp: {
+              match?: :boolean, source: :string, options: :integer,
+              casefold?: :boolean, named_captures: :hash, names: :array,
+              inspect: :string, to_s: :string
+            }.freeze,
+            range: {
+              first: :unknown, last: :unknown, min: :unknown, max: :unknown,
+              begin: :unknown, end: :unknown,
+              size: :integer, count: :integer,
+              include?: :boolean, cover?: :boolean, exclude_end?: :boolean,
+              to_a: :array, to_ary: :array, entries: :array,
+              map: :array, select: :array, reject: :array,
+              each: :enumerator, step: :enumerator,
+              inspect: :string, to_s: :string
+            }.freeze,
+            nil_value: {
+              to_s: :string, inspect: :string, to_a: :array, to_h: :hash,
+              to_i: :integer, to_f: :float,
+              nil?: :boolean, :& => :boolean, :| => :boolean, :^ => :boolean,
+              :== => :boolean
+            }.freeze,
+            enumerator: {
+              to_a: :array, to_h: :hash, first: :unknown, next: :unknown, peek: :unknown,
+              map: :array, select: :array, reject: :array, sort: :array,
+              count: :integer, size: :integer,
+              with_index: :enumerator, with_object: :enumerator,
+              include?: :boolean, any?: :boolean, all?: :boolean
+            }.freeze,
+            proc: {
+              call: :unknown, :[] => :unknown,
+              arity: :integer, lambda?: :boolean, curry: :proc, to_proc: :proc
+            }.freeze,
+            set: {
+              add: :set, add?: :set, delete: :set, delete?: :set,
+              merge: :set, replace: :set, clear: :set,
+              union: :set, intersection: :set, difference: :set,
+              subtract: :set, flatten: :set, classify: :hash, divide: :set,
+              keep_if: :set, delete_if: :set, reject!: :set, select!: :set, filter!: :set,
+              :+ => :set, :- => :set, :& => :set, :| => :set, :^ => :set,
+              dup: :set, clone: :set, freeze: :set,
+              size: :integer, length: :integer, count: :integer, hash: :integer,
+              empty?: :boolean, include?: :boolean, member?: :boolean,
+              subset?: :boolean, superset?: :boolean, disjoint?: :boolean,
+              proper_subset?: :boolean, proper_superset?: :boolean,
+              intersect?: :boolean, frozen?: :boolean,
+              any?: :boolean, all?: :boolean, none?: :boolean, one?: :boolean,
+              :== => :boolean, :=== => :boolean,
+              to_a: :array, to_ary: :array, sort: :array,
+              map: :array, collect: :array, select: :array, filter: :array,
+              reject: :array, partition: :array, group_by: :hash,
+              min: :unknown, max: :unknown, min_by: :unknown, max_by: :unknown,
+              first: :unknown, find: :unknown, detect: :unknown,
+              to_set: :set, sort_by: :array, tally: :hash,
+              each: :enumerator, each_with_index: :enumerator, each_with_object: :enumerator,
+              inspect: :string, to_s: :string, join: :string
+            }.freeze
+          }.freeze
+
+          REVERSE_LOOKUP = METHOD_RETURN_TYPES.each_with_object({}) do |(_, methods), table|
+            methods.each do |method, return_type|
+              table[method] = table.key?(method) && table[method] != return_type ? :unknown : return_type
+            end
+          end.freeze
+
+          def self.next_type(type, method)
+            METHOD_RETURN_TYPES.dig(type, method)
+          end
+
+          def self.reverse_lookup(method)
+            REVERSE_LOOKUP[method]
+          end
+
+          def self.literal_type(node)
+            LITERAL_MAP[node.type]
+          end
+
+          def self.pass_through?(method)
+            PASS_THROUGH.include?(method)
+          end
+
+          def self.operator?(method)
+            OPERATOR_METHODS.include?(method)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metz/demeter_train_wreck.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require_relative "../../../metz/cop_metadata"
+require_relative "on_send_csend_bridge"
+
+module RuboCop
+  module Cop
+    module Metz
+      # Flags Law-of-Demeter-violating object-graph traversal chains while
+      # staying quiet on long value-object chains. Walks the send chain
+      # downward via `node.receiver`, skipping pass-through methods, allowed
+      # constant receivers, and operator/setter sends. Recognises core
+      # value-object methods through `TypeInference::METHOD_RETURN_TYPES`
+      # and uses a reverse-lookup heuristic on the method name to escape
+      # an unknown innermost receiver.
+      class DemeterTrainWreck < RuboCop::Cop::Base
+        extend ::Metz::CopMetadata
+        include OnSendCsendBridge
+
+        MSG = "Object-graph traversal of %<count>d exceeds Max (%<max>d). " \
+              "Consider delegating or wrapping intermediate calls."
+
+        why_it_matters "Long object-graph chains tighten coupling and break the Law of Demeter."
+        fix_safety :unsafe
+        suggested_next_moves [
+          "Introduce `delegate :name, to: :account` (or equivalent) to flatten the chain.",
+          "Wrap intermediate links in a small query/decorator object that exposes the value you actually need.",
+          "Push the behaviour onto the inner collaborator so callers ask for one message instead of traversing four."
+        ]
+
+        def on_send(node)
+          return if part_of_outer_chain?(node)
+          return if outermost_skippable?(node)
+
+          analyze(node)
+        end
+
+        private
+
+        def analyze(node)
+          links = chain_links(node)
+          return if links.size <= max
+          return if allowed_receiver_root?(links.first)
+
+          hops = count_graph_traversals(links)
+          add_offense(node, message: build_message(hops)) if hops > max
+        end
+
+        def build_message(hops)
+          format(self.class::MSG, count: hops, max: max)
+        end
+
+        def chain_links(node)
+          links = []
+          collect_chain(links, node)
+          links.reject { |send_node| skip_link?(send_node) }
+        end
+
+        def collect_chain(links, start)
+          current = start
+          while current
+            links.unshift(current) if current.type?(:send, :csend)
+            current = inner_node(current)
+          end
+        end
+
+        def inner_node(node)
+          return node.receiver if node.type?(:send, :csend)
+
+          node.send_node if node.type?(:block, :numblock, :itblock)
+        end
+
+        def skip_link?(send_node)
+          operator_send?(send_node) || send_node.setter_method?
+        end
+
+        def outermost_skippable?(node)
+          operator_send?(node) || node.setter_method?
+        end
+
+        def operator_send?(node)
+          node.type?(:send, :csend) && TypeInference.operator?(node.method_name)
+        end
+
+        def part_of_outer_chain?(node)
+          unit = wrapping_block(node) || node
+          parent = unit.parent
+          parent&.type?(:send, :csend) && parent.receiver.equal?(unit)
+        end
+
+        def wrapping_block(node)
+          parent = node.parent
+          return nil unless parent&.type?(:block, :numblock, :itblock)
+
+          parent.send_node.equal?(node) ? parent : nil
+        end
+
+        def count_graph_traversals(links)
+          type = infer_initial_type(links.first.receiver)
+          hops = 0
+          links.each { |send_node| type, hops = advance(type, hops, send_node) }
+          hops
+        end
+
+        def advance(type, hops, send_node)
+          method = send_node.method_name
+          return [type, hops] if TypeInference.pass_through?(method)
+
+          resolve(method, type, hops)
+        end
+
+        def resolve(method, type, hops)
+          next_type = TypeInference.next_type(type, method) ||
+                      TypeInference.reverse_lookup(method)
+          next_type ? [next_type, hops] : [:unknown, hops + 1]
+        end
+
+        def infer_initial_type(node)
+          return :unknown if node.nil?
+
+          TypeInference.literal_type(node) || :unknown
+        end
+
+        def allowed_receiver_root?(innermost_send)
+          receiver = innermost_send.receiver
+          return false unless receiver&.const_type?
+
+          allowed_receivers.include?(receiver.const_name)
+        end
+
+        def max
+          cop_config["Max"] || 4
+        end
+
+        def allowed_receivers
+          @allowed_receivers ||= Array(cop_config["AllowedReceivers"]).to_set
+        end
+      end
+    end
+  end
+end
+
+require_relative "demeter_train_wreck/type_inference"

data/lib/rubocop/cop/metz/methods_too_long.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require_relative "../../../metz/cop_metadata"
+
+module RuboCop
+  module Cop
+    module Metz
+      # Flags methods whose body exceeds the configured `Max` line count.
+      # Wraps the semantics of core's `Metrics/MethodLength` with a stricter
+      # default of 5 lines.
+      class MethodsTooLong < RuboCop::Cop::Base
+        include RuboCop::Cop::CodeLength
+        include RuboCop::Cop::AllowedMethods
+        include RuboCop::Cop::AllowedPattern
+        extend ::Metz::CopMetadata
+
+        why_it_matters "Long methods hide multiple responsibilities and resist understanding at a glance."
+        fix_safety :manual
+        suggested_next_moves [
+          "Extract cohesive blocks into private helper methods named after their intent.",
+          "Replace conditional branches with polymorphism or small lookup objects.",
+          "Move data shaping onto value objects or query methods so the action reads as a list of steps."
+        ]
+
+        LABEL = "Method"
+
+        def on_def(node)
+          return if allowed?(node.method_name)
+
+          check_code_length(node)
+        end
+        alias on_defs on_def
+
+        def on_block(node)
+          return unless node.method?(:define_method)
+          return if defined_method_allowed?(node.send_node.first_argument)
+
+          check_code_length(node)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def cop_label
+          LABEL
+        end
+
+        def allowed?(method_name)
+          allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+        end
+
+        def defined_method_allowed?(method_name)
+          method_name.respond_to?(:basic_literal?) &&
+            method_name.basic_literal? &&
+            allowed?(method_name.value)
+        end
+      end
+    end
+  end
+end