rubocop-sorted_methods_by_call 1.2.1 → 1.2.3

data/lib/rubocop/sorted_methods_by_call/compare.rb

@@ -8,24 +8,11 @@ module RuboCop
     # relative order as they are defined (not necessarily contiguously).
     module Compare
       class << self
-        # +RuboCop::SortedMethodsByCall::Compare.hashes_ordered_equal?(actual, expected)+ -> Bool
+        # Check that each scope's call list is an ordered subsequence of its definition list.
         #
-        # 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.
+        # @param [Hash<Object, Array<Symbol>>] actual Per-scope definition method names.
+        # @param [Hash<Object, Array<Symbol>>] expected Per-scope called method names.
+        # @return [Boolean]
         def hashes_ordered_equal?(actual, expected)
           return false unless actual.is_a?(Hash) && expected.is_a?(Hash)
 
@@ -36,36 +23,19 @@ module RuboCop
           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
+        # Check if +sub+ appears as an ordered (not necessarily contiguous) subsequence of +arr+.
         #
-        # @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.
+        # @param [Array<Symbol>] arr The full sequence to search within.
+        # @param [Array<Symbol>] sub The subsequence to search for.
+        # @return [Boolean]
         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
+          sub.all? do |el|
+            i += 1 while i < arr.length && arr[i] != el
+            (i < arr.length).tap { i += 1 }
           end
-          true
         end
       end
     end

data/lib/rubocop/sorted_methods_by_call/plugin.rb

@@ -16,11 +16,9 @@ module RuboCop
     # 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
+      # Return plugin metadata for lint_roller discovery.
       #
-      # Declares plugin metadata (name, version, homepage, description).
-      #
-      # @return [LintRoller::About] Metadata describing this plugin.
+      # @return [About]
       def about
         LintRoller::About.new(
           name: 'rubocop-sorted_methods_by_call',
@@ -30,30 +28,23 @@ module RuboCop
         )
       end
 
-      # +RuboCop::SortedMethodsByCall::Plugin#supported?+ -> Boolean
-      #
-      # Indicates that this plugin supports RuboCop as the lint engine.
+      # Check if the plugin is supported for the given lint_roller context.
       #
-      # @param [Object] context LintRoller context (engine, versions, etc.).
-      # @return [Boolean] true for RuboCop engine; false otherwise.
+      # @param [Object] context The lint_roller context to check.
+      # @return [Object]
       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.
+      # Return the RuboCop rules configuration path.
       #
-      # @see config/default.yml
+      # @param [Object] _context The lint_roller context (unused).
+      # @return [Rules]
       def rules(_context)
         LintRoller::Rules.new(
           type: :path,
           config_format: :rubocop,
-          value: Pathname.new(__dir__).join('../../../config/default.yml')
+          value: Pathname.new(__dir__ || '').realpath.join('../../../config/default.yml')
         )
       end
     end

data/lib/rubocop/sorted_methods_by_call/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module SortedMethodsByCall
-    VERSION = '1.2.1'
+    VERSION = '1.2.3'
   end
 end

data/rbs_collection.lock.yaml

@@ -0,0 +1,120 @@
+---
+path: ".gem_rbs_collection"
+gems:
+- name: ast
+  version: '2.4'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3f5e8df1ce89ea06067fa42263012c968b4e583e
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: diff-lcs
+  version: '1.5'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3f5e8df1ce89ea06067fa42263012c968b4e583e
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: fileutils
+  version: '0'
+  source:
+    type: stdlib
+- name: json
+  version: '0'
+  source:
+    type: stdlib
+- name: lint_roller
+  version: '1.1'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3f5e8df1ce89ea06067fa42263012c968b4e583e
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: logger
+  version: '0'
+  source:
+    type: stdlib
+- name: monitor
+  version: '0'
+  source:
+    type: stdlib
+- name: optparse
+  version: '0'
+  source:
+    type: stdlib
+- name: parallel
+  version: '1.20'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3f5e8df1ce89ea06067fa42263012c968b4e583e
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: parser
+  version: '3.2'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3f5e8df1ce89ea06067fa42263012c968b4e583e
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: prism
+  version: 1.9.0
+  source:
+    type: rubygems
+- name: rainbow
+  version: '3.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3f5e8df1ce89ea06067fa42263012c968b4e583e
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rake
+  version: '13.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3f5e8df1ce89ea06067fa42263012c968b4e583e
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: regexp_parser
+  version: '2.8'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3f5e8df1ce89ea06067fa42263012c968b4e583e
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: ripper
+  version: '0'
+  source:
+    type: stdlib
+- name: rubocop
+  version: '1.57'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3f5e8df1ce89ea06067fa42263012c968b4e583e
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rubocop-ast
+  version: '1.46'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3f5e8df1ce89ea06067fa42263012c968b4e583e
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: yard
+  version: '0.9'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3f5e8df1ce89ea06067fa42263012c968b4e583e
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,19 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# You can specify local directories as sources also.
+# - type: local
+#   path: path/to/your/local/repository
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+# gems:
+#   # If you want to avoid installing rbs files for gems, you can specify them here.
+#   - name: GEM_NAME
+#     ignore: true

data/sig/rubocop/cop/auto_corrector.rbs

@@ -0,0 +1,11 @@
+# Patch: the RBS collection places AutoCorrector at RuboCop::AutoCorrector
+# (matching older rubocop), but the actual rubocop gem defines it inside
+# the Cop module.  Re-export at the correct path so steep can find it
+# when the Ruby code says `extend ::RuboCop::Cop::AutoCorrector`.
+module RuboCop
+  module Cop
+    module AutoCorrector
+      def support_autocorrect?: () -> true
+    end
+  end
+end

data/sig/rubocop/cop/sorted_methods_by_call/waterfall.rbs

@@ -0,0 +1,71 @@
+module RuboCop
+  module Cop
+    module SortedMethodsByCall
+      class Waterfall < ::RuboCop::Cop::Base
+        extend ::RuboCop::Cop::AutoCorrector
+
+        include ::RuboCop::Cop::RangeHelp
+
+        type data = Hash[Symbol, untyped]
+        type section = Hash[Symbol, untyped]
+
+        VISIBILITY_METHODS: Array[Symbol]
+
+        MSG: String
+        SIBLING_MSG: String
+        MSG_CROSS_VISIBILITY_NOTE: String
+        MSG_SIBLING_CYCLE_NOTE: String
+
+        def on_begin: (::RuboCop::AST::Node node) -> void
+        def on_class: (::RuboCop::AST::Node node) -> void
+        def on_module: (::RuboCop::AST::Node node) -> void
+        def on_sclass: (::RuboCop::AST::Node node) -> void
+
+        private
+
+        def analyze_scope: (::RuboCop::AST::Node scope_node) -> void
+        def scope_data: (::RuboCop::AST::Node scope_node) -> data?
+        def register_violation: (data data) -> void
+        def auto_correct_violation: (::RuboCop::Cop::Corrector corrector, data data) -> void
+        def scope_body_nodes: (untyped node) -> Array[::RuboCop::AST::Node]
+        def method_def_nodes: (Array[::RuboCop::AST::Node] body_nodes) -> Array[::RuboCop::AST::DefNode]
+        def method_name_index: (Array[::RuboCop::AST::DefNode] def_nodes) -> [ Array[Symbol], Set[Symbol], Hash[Symbol, Integer] ]
+        def build_direct_edges: (Array[::RuboCop::AST::DefNode] def_nodes, Set[Symbol] names_set) -> Array[ [Symbol, Symbol] ]
+        def build_sibling_edges: (Array[::RuboCop::AST::DefNode] def_nodes, Set[Symbol] names_set, Array[ [Symbol, Symbol] ] direct_edges, Array[Symbol] names) -> Array[ [Symbol, Symbol] ]
+        def sibling_edges_for_method: (::RuboCop::AST::DefNode def_node, Set[Symbol] names_set, Set[ [Symbol, Symbol] ] direct_pair_set, Hash[Symbol, Array[Symbol]] adj_for_siblings) -> Array[ [Symbol, Symbol] ]
+        def find_violation: (Array[ [Symbol, Symbol] ] direct_edges, Array[ [Symbol, Symbol] ] sibling_edges, Hash[Symbol, Integer] index_of, Hash[Symbol, Array[Symbol]] adj_direct) -> [ Symbol, [Symbol, Symbol]? ]?
+        def first_backward_edge: (Array[ [Symbol, Symbol] ] edges, Hash[Symbol, Integer] index_of, Hash[Symbol, Array[Symbol]] adj_direct, bool allow_recursion) -> [Symbol, Symbol]?
+        def build_offense_message: (violation_type: Symbol, violation: [Symbol, Symbol], names: Array[Symbol], edges_for_sort: Array[ [Symbol, Symbol] ], body_nodes: Array[::RuboCop::AST::Node]) -> String
+        def base_message_for: (Symbol violation_type, Symbol caller_name, Symbol callee_name) -> String
+        def add_sibling_cycle_note_if_needed: (String base_message, Symbol violation_type, Symbol caller_name, Symbol callee_name, Hash[Symbol, Array[Symbol]] adj_all) -> String
+        def add_cross_visibility_note_if_needed: (String base_message, Array[::RuboCop::AST::Node] body_nodes, Symbol caller_name, Symbol callee_name) -> String
+        def try_autocorrect: (::RuboCop::Cop::Corrector corrector, Array[::RuboCop::AST::Node] body_nodes, Array[::RuboCop::AST::DefNode] def_nodes, Array[ [Symbol, Symbol] ] edges, ?[Symbol, Symbol]? initial_violation) -> void
+        def correction_order: (Array[::RuboCop::AST::DefNode] defs, data data, [Symbol, Symbol] violation) -> Array[Symbol]?
+        def auto_correct_data: (Array[::RuboCop::AST::DefNode] def_nodes, Array[ [Symbol, Symbol] ] edges, [Symbol, Symbol]? initial_violation) -> data?
+        def edges_for_section: (data data, Array[Symbol] section_names, Symbol caller_name, Symbol callee_name) -> Array[ [Symbol, Symbol] ]
+        def filter_names: (Array[ [Symbol, Symbol] ] edges, Array[Symbol] names) -> Array[ [Symbol, Symbol] ]
+        def reject_reciprocal: (Array[ [Symbol, Symbol] ] edges) -> Array[ [Symbol, Symbol] ]
+        def section_containing: (Array[section] sections, *Symbol method_names) -> section?
+        def replace_sorted_section: (::RuboCop::Cop::Corrector corrector, Array[::RuboCop::AST::DefNode] defs, Array[Symbol] sorted_names) -> void
+        def bounds: (Hash[Symbol, untyped] ranges, Array[::RuboCop::AST::DefNode] defs) -> ::Parser::Source::Range
+        def local_calls: (::RuboCop::AST::DefNode def_node, Set[Symbol] names_set) -> Array[Symbol]
+        def build_adj: (Array[Symbol] names, Array[ [Symbol, Symbol] ] edges) -> Hash[Symbol, Array[Symbol]]
+        def path_exists?: (Symbol src, Symbol dst, Hash[Symbol, Array[Symbol]] adj, ?Integer limit) -> bool
+        def extract_visibility_sections: (Array[::RuboCop::AST::Node] body_nodes) -> Array[section]
+        def not_def_node?: (untyped node) -> bool
+        def vis_node: (Array[::RuboCop::AST::Node] group) -> ::RuboCop::AST::Node?
+        def make_section: (::RuboCop::AST::Node? vis, Array[::RuboCop::AST::DefNode] defs) -> section
+        def bare_visibility_send?: (untyped node) -> bool
+        def section_for_method: (Array[section] sections, Symbol method_name) -> section?
+        def visibility_label: (section? section) -> String
+        def topo_sort: (Array[Symbol] names, Array[ [Symbol, Symbol] ] edges, Hash[Symbol, Integer] idx_of) -> Array[Symbol]?
+        def kahn_sort: (Hash[Symbol, Integer] indegree, Hash[Symbol, Array[Symbol]] adj, Array[Symbol] queue, Hash[Symbol, Integer] idx_of) -> Array[Symbol]
+        def graph: (Array[Symbol] names, Array[ [Symbol, Symbol] ] edges) -> [ Hash[Symbol, Integer], Hash[Symbol, Array[Symbol]] ]
+        def range_with_leading_comments: (::RuboCop::AST::Node node) -> ::Parser::Source::Range
+        def analyze_nested_scopes: (Array[::RuboCop::AST::Node] body_nodes) -> void
+        def allowed_recursion?: -> bool
+        def skip_cyclic_sibling_edges?: -> bool
+      end
+    end
+  end
+end

data/sig/rubocop/sorted_methods_by_call/compare.rbs

@@ -0,0 +1,8 @@
+module RuboCop
+  module SortedMethodsByCall
+    module Compare
+      def self?.hashes_ordered_equal?: (Hash[untyped, Array[Symbol]] actual, Hash[untyped, Array[Symbol]] expected) -> bool
+      def self?.subsequence?: (Array[Symbol] arr, Array[Symbol] sub) -> bool
+    end
+  end
+end

data/sig/rubocop/sorted_methods_by_call/plugin.rbs

@@ -0,0 +1,9 @@
+module RuboCop
+  module SortedMethodsByCall
+    class Plugin < ::LintRoller::Plugin
+      def about: -> ::LintRoller::About
+      def supported?: (::LintRoller::Context context) -> bool
+      def rules: (::LintRoller::Context _context) -> ::LintRoller::Rules
+    end
+  end
+end

data/sig/rubocop/sorted_methods_by_call/version.rbs

@@ -0,0 +1,5 @@
+module RuboCop
+  module SortedMethodsByCall
+    VERSION: String
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-sorted_methods_by_call
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.3
 platform: ruby
 authors:
 - unurgunite
@@ -131,16 +131,27 @@ files:
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".ruby-version"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
 - LICENSE.txt
 - README.md
+- SECURITY.md
+- Steepfile
 - config/default.yml
+- docscribe.yml
 - lib/rubocop-sorted_methods_by_call.rb
 - lib/rubocop/cop/sorted_methods_by_call/waterfall.rb
 - lib/rubocop/sorted_methods_by_call/compare.rb
-- lib/rubocop/sorted_methods_by_call/extensions/util.rb
 - lib/rubocop/sorted_methods_by_call/plugin.rb
 - lib/rubocop/sorted_methods_by_call/version.rb
+- rbs_collection.lock.yaml
+- rbs_collection.yaml
+- sig/rubocop/cop/auto_corrector.rbs
+- sig/rubocop/cop/sorted_methods_by_call/waterfall.rbs
+- sig/rubocop/sorted_methods_by_call/compare.rbs
+- sig/rubocop/sorted_methods_by_call/plugin.rbs
+- sig/rubocop/sorted_methods_by_call/version.rbs
 homepage: https://github.com/unurgunite/rubocop-sorted_methods_by_call
 licenses: []
 metadata:
@@ -164,7 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.2
+rubygems_version: 4.0.13
 specification_version: 4
 summary: RuboCop extension for method sorting in AST by stack trace.
 test_files: []

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

@@ -1,32 +0,0 @@
-# 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] h  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