rubocop-sorted_methods_by_call 1.0.0

data/lib/rubocop/cop/sorted_methods_by_call/waterfall.rb

@@ -0,0 +1,491 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SortedMethodsByCall
+      # +RuboCop::Cop::SortedMethodsByCall::Waterfall+ enforces "waterfall" ordering:
+      # define a method after any method that calls it (within the same scope).
+      #
+      # - Scopes: class/module/sclass (top-level can be enabled in config)
+      # - Offense: when a callee is defined above its caller
+      # - Autocorrect: UNSAFE; reorders methods within a contiguous visibility section
+      #
+      # Example (good):
+      #   def foo
+      #     bar
+      #   end
+      #
+      #   def bar
+      #     123
+      #   end
+      #
+      # Example (bad):
+      #   def bar
+      #     123
+      #   end
+      #
+      #   def foo
+      #     bar
+      #   end
+      #
+      # Autocorrect (unsafe, opt-in via SafeAutoCorrect: false): topologically sorts the contiguous
+      # block of defs to satisfy edges (caller -> callee). Skips cycles and non-contiguous groups.
+      class Waterfall < ::RuboCop::Cop::Base # rubocop:disable Metrics/ClassLength
+        include ::RuboCop::Cop::RangeHelp
+        extend ::RuboCop::Cop::AutoCorrector
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall::MSG+ -> String
+        #
+        # Template message for offenses.
+        MSG = 'Define %<callee>s after its caller %<caller>s (waterfall order).'
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#on_begin+ -> void
+        #
+        # Entry point for root :begin nodes (top-level). Whether it is analyzed
+        # depends on configuration (e.g., CheckTopLevel). By default, only class/module scopes are analyzed.
+        #
+        # @param [RuboCop::AST::Node] node
+        # @return [void]
+        def on_begin(node)
+          analyze_scope(node)
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#on_class+ -> void
+        #
+        # Entry point for class scopes.
+        #
+        # @param [RuboCop::AST::Node] node
+        # @return [void]
+        def on_class(node)
+          analyze_scope(node)
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#on_module+ -> void
+        #
+        # Entry point for module scopes.
+        #
+        # @param [RuboCop::AST::Node] node
+        # @return [void]
+        def on_module(node)
+          analyze_scope(node)
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#on_sclass+ -> void
+        #
+        # Entry point for singleton class scopes (class << self).
+        #
+        # @param [RuboCop::AST::Node] node
+        # @return [void]
+        def on_sclass(node)
+          analyze_scope(node)
+        end
+
+        private
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#analyze_scope+ -> void
+        #
+        # Collects defs in the current scope, builds caller->callee edges
+        # for local sends, finds the first backward edge (callee defined before caller),
+        # and registers an offense. If autocorrection is requested, attempts to reorder
+        # methods within the same visibility section.
+        #
+        # @param [RuboCop::AST::Node] scope_node
+        # @return [void]
+        def analyze_scope(scope_node)
+          body_nodes = scope_body_nodes(scope_node)
+          return if body_nodes.empty?
+
+          def_nodes = body_nodes.select { |n| %i[def defs].include?(n.type) }
+          return if def_nodes.size <= 1
+
+          names = def_nodes.map(&:method_name)
+          names_set = names.to_set
+          index_of = names.each_with_index.to_h
+
+          edges = []
+          def_nodes.each do |def_node|
+            local_calls(def_node, names_set).each do |callee|
+              next if callee == def_node.method_name # self-recursion
+
+              edges << [def_node.method_name, callee]
+            end
+          end
+
+          allow_recursion = cop_config.fetch('AllowedRecursion') { true }
+          adj = build_adj(names, edges)
+
+          violation = first_backward_edge(edges, index_of, adj, allow_recursion)
+          return unless violation
+
+          caller_name, callee_name = violation
+          callee_node = def_nodes[index_of[callee_name]]
+
+          add_offense(callee_node,
+                      message: format(MSG, callee: "##{callee_name}", caller: "##{caller_name}")) do |corrector|
+            try_autocorrect(corrector, body_nodes, def_nodes, edges)
+          end
+
+          # Recurse into nested scopes
+          body_nodes.each { |n| analyze_scope(n) if n.class_type? || n.module_type? || n.sclass_type? }
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#scope_body_nodes+ -> Array<RuboCop::AST::Node>
+        #
+        # Normalizes a scope node to its immediate "body" items we iterate over.
+        #
+        # @param [RuboCop::AST::Node] node
+        # @return [Array<RuboCop::AST::Node>]
+        def scope_body_nodes(node)
+          case node.type
+          when :begin
+            node.children
+          when :class, :module, :sclass
+            body = node.body
+            return [] unless body
+
+            body.begin_type? ? body.children : [body]
+          else
+            []
+          end
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#local_calls+ -> Array<Symbol>
+        #
+        # Returns the set of local method names (receiver is nil/self) invoked inside
+        # a given def node whose names exist in the provided name set.
+        #
+        # @param [RuboCop::AST::Node] def_node
+        # @param [Set<Symbol>] names_set
+        # @return [Array<Symbol>]
+        def local_calls(def_node, names_set)
+          body = def_node.body
+          return [] unless body
+
+          res = []
+          body.each_node(:send) do |send|
+            recv = send.receiver
+            next unless recv.nil? || recv&.self_type?
+
+            mname = send.method_name
+            res << mname if names_set.include?(mname)
+          end
+          res.uniq
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#find_violation+ -> [Symbol, Symbol], nil
+        #
+        # Finds the first backward edge (caller->callee where callee is defined above caller)
+        # using the provided index map.
+        #
+        # @param [Array<Array(Symbol, Symbol)>] edges
+        # @param [Hash{Symbol=>Integer}] index_of
+        # @return [[Symbol, Symbol], nil] tuple [caller, callee] or nil if none found
+        def find_violation(edges, index_of)
+          edges.find do |caller, callee|
+            index_of.key?(caller) && index_of.key?(callee) && index_of[callee] < index_of[caller]
+          end
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#try_autocorrect+ -> void
+        #
+        # UNSAFE: Reorders method definitions inside the target visibility section only
+        # (does not cross private/protected/public boundaries). Skips if defs are not
+        # contiguous within the section or if a cycle prevents a consistent topo order.
+        #
+        # @param [RuboCop::Cop::Corrector] corrector
+        # @param [Array<RuboCop::AST::Node>] body_nodes
+        # @param [Array<RuboCop::AST::Node>] def_nodes
+        # @param [Array<Array(Symbol, Symbol)>] edges
+        # @return [void]
+        #
+        # @note Applied only when user asked for autocorrections; with SafeAutoCorrect: false, this runs under -A.
+        # @note Also preserves contiguous leading doc comments above each method.
+        def try_autocorrect(corrector, body_nodes, def_nodes, edges)
+          # Group method definitions into visibility sections
+          sections = extract_visibility_sections(body_nodes)
+
+          # Find the section that contains our violating methods
+          caller_name, callee_name = first_backward_edge(
+            edges,
+            def_nodes.map(&:method_name).each_with_index.to_h,
+            build_adj(def_nodes.map(&:method_name), edges),
+            cop_config.fetch('AllowedRecursion') { true }
+          )
+
+          # No violation -> nothing to do
+          return unless caller_name && callee_name
+
+          #            Find a visibility section that contains both names
+          target_section = sections.find do |section|
+            names_in_section = section[:defs].to_set(&:method_name)
+            names_in_section.include?(caller_name) && names_in_section.include?(callee_name)
+          end
+
+          # If violation spans multiple sections, skip autocorrect
+          return unless target_section
+
+          defs = target_section[:defs]
+          return unless defs.size > 1
+
+          # Apply topological sort only within this visibility section
+          defs = target_section[:defs]
+          names = defs.map(&:method_name)
+          idx_of = names.each_with_index.to_h
+
+          # Filter edges to only those within this section
+          # Filter edges to only those within this section
+          section_names = names.to_set
+          section_edges = edges.select { |u, v| section_names.include?(u) && section_names.include?(v) }
+
+          sorted_names = topo_sort(names, section_edges, idx_of)
+          return unless sorted_names
+
+          # Capture each def with its leading contiguous comment block
+          ranges_by_name = defs.to_h { |d| [d.method_name, range_with_leading_comments(d)] }
+          sorted_def_sources = sorted_names.map { |name| ranges_by_name[name].source }
+
+          # Reconstruct the section: keep the visibility modifier (if any) above the first def
+          visibility_node   = target_section[:visibility]
+          visibility_source = visibility_node&.source.to_s
+
+          new_content = if visibility_source.empty?
+                          sorted_def_sources.join("\n\n")
+                        else
+                          "#{visibility_source}\n\n#{sorted_def_sources.join("\n\n")}"
+                        end
+
+          # Expand the replaced region:
+          # - if a visibility node exists, start from its begin_pos (so we replace it)
+          # - otherwise, start from the earliest leading doc-comment of the defs
+          section_begin =
+            if visibility_node
+              visibility_node.source_range.begin_pos
+            else
+              defs.map { |d| range_with_leading_comments(d).begin_pos }.min
+            end
+
+          # Always end at the end of the last def
+          section_end = defs.last.source_range.end_pos
+
+          region = Parser::Source::Range.new(processed_source.buffer, section_begin, section_end)
+          corrector.replace(region, new_content)
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#build_adj+ -> Hash{Symbol=>Array<Symbol>}
+        #
+        # Builds an adjacency list for edges restricted to known names.
+        #
+        # @param [Array<Symbol>] names
+        # @param [Array<Array(Symbol, Symbol)>] edges
+        # @return [Hash{Symbol=>Array<Symbol>}]
+        def build_adj(names, edges)
+          allowed = names.to_set
+          adj = Hash.new { |h, k| h[k] = [] }
+          edges.each do |u, v|
+            next unless allowed.include?(u) && allowed.include?(v)
+            next if u == v
+
+            adj[u] << v
+          end
+          adj
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#first_backward_edge+ -> [Symbol, Symbol], nil
+        #
+        # Returns the first backward edge found, optionally skipping mutual recursion
+        # if so configured.
+        #
+        # @param [Array<Array(Symbol, Symbol)>] edges
+        # @param [Hash{Symbol=>Integer}] index_of
+        # @param [Hash{Symbol=>Array<Symbol>}] adj
+        # @param [Boolean] allow_recursion whether to ignore cycles
+        # @return [[Symbol, Symbol], nil]
+        def first_backward_edge(edges, index_of, adj, allow_recursion)
+          edges.find do |caller, callee|
+            next unless index_of.key?(caller) && index_of.key?(callee)
+            # If mutual recursion allowed and there is a path callee -> caller, skip
+            next if allow_recursion && path_exists?(callee, caller, adj)
+
+            index_of[callee] < index_of[caller]
+          end
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#path_exists?+ -> Boolean
+        #
+        # Tests whether a path exists in the adjacency graph from +src+ to +dst+ (BFS).
+        #
+        # @param [Symbol] src
+        # @param [Symbol] dst
+        # @param [Hash{Symbol=>Array<Symbol>}] adj
+        # @param [Integer] limit traversal step limit (guard)
+        # @return [Boolean]
+        def path_exists?(src, dst, adj, limit = 200)
+          return true if src == dst
+
+          visited = {}
+          q = [src]
+          steps = 0
+          until q.empty?
+            steps += 1
+            return false if steps > limit
+
+            u = q.shift
+            next if visited[u]
+
+            visited[u] = true
+            return true if u == dst
+
+            adj[u].each { |v| q << v unless visited[v] }
+          end
+          false
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#extract_visibility_sections+ -> Array<Hash>
+        #
+        # Splits the body into contiguous sections of defs grouped by visibility modifier
+        # (private/protected/public). Returns metadata for each section including:
+        #   :visibility  -> visibility modifier node or nil
+        #   :defs        -> array of def/defs nodes
+        #   :start_pos   -> Integer (begin_pos)
+        #   :end_pos     -> Integer (end_pos)
+        #
+        # @param [Array<RuboCop::AST::Node>] body_nodes
+        # @return [Array<Hash{Symbol=>untyped}>]
+        def extract_visibility_sections(body_nodes)
+          sections = []
+          current_visibility = nil
+          current_defs = []
+          section_start = nil
+
+          body_nodes.each_with_index do |node, idx|
+            case node.type
+            when :def, :defs
+              current_defs << node
+              section_start ||= node.source_range.begin_pos
+            when :send
+              # Check if this is a visibility modifier (private/protected/public)
+              if node.receiver.nil? && %i[private protected public].include?(node.method_name) && node.arguments.empty?
+                # End current section if it has defs
+                unless current_defs.empty?
+                  sections << {
+                    visibility: current_visibility,
+                    defs: current_defs.dup,
+                    start_pos: section_start,
+                    end_pos: body_nodes[idx - 1].source_range.end_pos
+                  }
+                  current_defs = []
+                  section_start = nil
+                end
+                current_visibility = node
+              else
+                # Non-visibility send - breaks contiguity
+                unless current_defs.empty?
+                  sections << {
+                    visibility: current_visibility,
+                    defs: current_defs.dup,
+                    start_pos: section_start,
+                    end_pos: body_nodes[idx - 1].source_range.end_pos
+                  }
+                  current_defs = []
+                  section_start = nil
+                  current_visibility = nil
+                end
+              end
+            else
+              # Any other node type breaks contiguity
+              unless current_defs.empty?
+                sections << {
+                  visibility: current_visibility,
+                  defs: current_defs.dup,
+                  start_pos: section_start,
+                  end_pos: body_nodes[idx - 1].source_range.end_pos
+                }
+                current_defs = []
+                section_start = nil
+                current_visibility = nil
+              end
+            end
+          end
+
+          # Handle trailing defs
+          unless current_defs.empty?
+            sections << {
+              visibility: current_visibility,
+              defs: current_defs,
+              start_pos: section_start,
+              end_pos: current_defs.last.source_range.end_pos
+            }
+          end
+
+          sections
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#topo_sort+ -> Array<Symbol>, nil
+        #
+        # Performs a stable topological sort using current order as a tie-breaker.
+        #
+        # @param [Array<Symbol>] names
+        # @param [Array<Array(Symbol, Symbol)>] edges
+        # @param [Hash{Symbol=>Integer}] idx_of
+        # @return [Array<Symbol>, nil] sorted names or nil if a cycle prevents a full order
+        def topo_sort(names, edges, idx_of)
+          indegree = Hash.new(0)
+          adj = Hash.new { |h, k| h[k] = [] }
+
+          edges.each do |caller, callee|
+            next unless names.include?(caller) && names.include?(callee)
+            next if caller == callee
+
+            adj[caller] << callee
+            indegree[callee] += 1
+            indegree[caller] ||= 0
+          end
+          names.each { |n| indegree[n] ||= 0 }
+
+          queue = names.select { |n| indegree[n].zero? }.sort_by { |n| idx_of[n] }
+          result = []
+
+          until queue.empty?
+            n = queue.shift
+            result << n
+            adj[n].each do |m|
+              indegree[m] -= 1
+              queue << m if indegree[m].zero?
+            end
+            queue.sort_by! { |x| idx_of[x] }
+          end
+
+          return nil unless result.size == names.size
+
+          result
+        end
+
+        # +RuboCop::Cop::SortedMethodsByCall::Waterfall#range_with_leading_comments+ -> Parser::Source::Range
+        #
+        # Returns a range that starts at the first contiguous comment line immediately
+        # above the def/defs node, and ends at the end of the def. This preserves
+        # YARD/RDoc doc comments when methods are moved during autocorrect.
+        #
+        # @param [RuboCop::AST::Node] node The def/defs node.
+        # @return [Parser::Source::Range] Range covering leading comments + method body.
+        def range_with_leading_comments(node)
+          buffer = processed_source.buffer
+          expr   = node.source_range
+
+          start_line = expr.line
+          lineno = start_line - 1
+          while lineno >= 1
+            line = buffer.source_line(lineno)
+            break unless line =~ /\A\s*#/
+
+            start_line = lineno
+            lineno -= 1
+          end
+
+          start_pos = buffer.line_range(start_line).begin_pos
+          Parser::Source::Range.new(buffer, start_pos, expr.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/sorted_methods_by_call/compare.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module SortedMethodsByCall
+    # +RuboCop::SortedMethodsByCall::Compare+ provides helpers to compare
+    # definition orders and call orders using “ordered subsequence” semantics.
+    # It’s used by the cop to check that called methods appear in the same
+    # relative order as they are defined (not necessarily contiguously).
+    module Compare
+      class << self
+        # +RuboCop::SortedMethodsByCall::Compare.hashes_ordered_equal?(actual, expected)+ -> Bool
+        #
+        # For each scope key, checks that every call in +expected[k]+ exists in +actual[k]+ and
+        # appears in the same relative order (i.e., +expected[k]+ is a subsequence of +actual[k]+).
+        # Returns false if a call is unknown (not present in +actual[k]+) or out of order.
+        #
+        # @example
+        #   defs  = { main: %i[abc foo bar a hello] }
+        #   calls = { main: %i[foo bar hello] }
+        #   RuboCop::SortedMethodsByCall::Compare.hashes_ordered_equal?(defs, calls) #=> true
+        #
+        #   calls2 = { main: %i[bar foo] }
+        #   RuboCop::SortedMethodsByCall::Compare.hashes_ordered_equal?(defs, calls2) #=> false
+        #
+        # @param [Hash{Object=>Array<Symbol>}] actual   Actual definitions per scope.
+        # @param [Hash{Object=>Array<Symbol>}] expected Expected calls per scope.
+        # @return [Bool] true if for every scope +k+, +expected[k]+ is a subsequence of +actual[k]+
+        #   and contains no unknown methods.
+        def hashes_ordered_equal?(actual, expected)
+          return false unless actual.is_a?(Hash) && expected.is_a?(Hash)
+
+          (actual.keys | expected.keys).all? do |k|
+            defs = Array(actual[k])
+            calls = Array(expected[k])
+            (calls - defs).empty? && subsequence?(defs, calls)
+          end
+        end
+
+        # +RuboCop::SortedMethodsByCall::Compare.subsequence?(arr, sub)+ -> Bool
+        #
+        # Returns true if +sub+ is a subsequence of +arr+ (order preserved),
+        # not necessarily contiguous. An empty +sub+ returns true.
+        #
+        # @example
+        #   arr = %i[abc foo bar a hello]
+        #   RuboCop::SortedMethodsByCall::Compare.subsequence?(arr, %i[foo bar hello]) #=> true
+        #   RuboCop::SortedMethodsByCall::Compare.subsequence?(arr, %i[bar foo])       #=> false
+        #
+        # @param [Array<#==>] arr Base sequence (typically Array<Symbol>).
+        # @param [Array<#==>, nil] sub Candidate subsequence (typically Array<Symbol>).
+        # @return [Bool] true if +sub+ appears in +arr+ in order.
+        def subsequence?(arr, sub)
+          return true if sub.nil? || sub.empty?
+
+          i = 0
+          sub.each do |el|
+            found = false
+            while i < arr.length
+              if arr[i] == el
+                found = true
+                i += 1
+                break
+              end
+              i += 1
+            end
+            return false unless found
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/sorted_methods_by_call/extensions/util.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module SortedMethodsByCall
+    module Util # :nodoc:
+      # +RuboCop::SortedMethodsByCall::Util.deep_merge(hash, other)+ -> Hash
+      #
+      # Merges two hashes without overwriting values that share the same key.
+      # When a key exists in both hashes, values are accumulated into an array
+      # ("buckets"). Scalars are wrapped to arrays automatically.
+      #
+      # - Non-destructive: returns a new Hash; does not mutate +hash+.
+      # - If +other+ is not a Hash, the original +hash+ is returned as-is.
+      #
+      # @example Accumulate values into buckets
+      #   base  = { main: :abc, class_T: :hi }
+      #   other = { class_T: :h1 }
+      #   RuboCop::SortedMethodsByCall::Util.deep_merge(base, other)
+      #   #=> { main: [:abc], class_T: [:hi, :h1] }
+      #
+      # @param [Hash] hash  The base hash to merge from.
+      # @param [Hash] other The hash to merge into +hash+.
+      # @return [Hash] A new hash with accumulated values per key.
+      # @see Hash#merge
+      def self.deep_merge(h, other)
+        return h unless other.is_a?(Hash)
+
+        h.merge(other) { |_, a, b| Array(a) + Array(b) }
+      end
+    end
+  end
+end

data/lib/rubocop/sorted_methods_by_call/plugin.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+require_relative 'version'
+
+module RuboCop
+  module SortedMethodsByCall
+    # +RuboCop::SortedMethodsByCall::Plugin+ integrates this extension with RuboCop's
+    # plugin system via lint_roller. It declares metadata and tells RuboCop where
+    # to find the plugin's default configuration.
+    #
+    # The plugin is discovered by RuboCop when you configure:
+    #   plugins:
+    #     - rubocop-sorted_methods_by_call
+    #
+    # It will automatically apply rules (config/default.yml) and make the cops
+    # available to the engine.
+    class Plugin < LintRoller::Plugin
+      # +RuboCop::SortedMethodsByCall::Plugin#about+ -> LintRoller::About
+      #
+      # Declares plugin metadata (name, version, homepage, description).
+      #
+      # @return [LintRoller::About] Metadata describing this plugin.
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-sorted_methods_by_call',
+          version: VERSION,
+          homepage: 'https://github.com/unurgunite/rubocop-sorted_methods_by_call',
+          description: 'Enforces waterfall ordering: define methods after the methods that call them.'
+        )
+      end
+
+      # +RuboCop::SortedMethodsByCall::Plugin#supported?+ -> Boolean
+      #
+      # Indicates that this plugin supports RuboCop as the lint engine.
+      #
+      # @param [Object] context LintRoller context (engine, versions, etc.).
+      # @return [Boolean] true for RuboCop engine; false otherwise.
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      # +RuboCop::SortedMethodsByCall::Plugin#rules+ -> LintRoller::Rules
+      #
+      # Returns the plugin rules for RuboCop. This points RuboCop to the default
+      # configuration file shipped with the gem (config/default.yml).
+      #
+      # @param [Object] _context LintRoller context (unused).
+      # @return [LintRoller::Rules] Rule declaration for RuboCop to load.
+      #
+      # @see config/default.yml
+      def rules(_context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: Pathname.new(__dir__).join('../../../config/default.yml')
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/sorted_methods_by_call/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module SortedMethodsByCall
+    VERSION = '1.0.0'
+  end
+end

data/lib/rubocop-sorted_methods_by_call.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'rubocop/sorted_methods_by_call/plugin'
+require_relative 'rubocop/sorted_methods_by_call/version'
+require_relative 'rubocop/cop/sorted_methods_by_call/waterfall'

data/test_project/.rubocop.test.yml

@@ -0,0 +1,13 @@
+plugins:
+  - rubocop-sorted_methods_by_call
+
+inherit_from: ../.rubocop.yml
+
+SortedMethodsByCall/Waterfall:
+  Enabled: true
+
+AllCops:
+  Exclude:
+    - 'rubocop-sorted_methods_by_call.gemspec'
+    - 'Gemfile'
+    - 'Gemfile.lock'

data/test_project/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'rubocop-sorted_methods_by_call', path: '../rubocop-sorted_methods_by_call'