betterlint 1.4.9 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d607b36a006c41af535225cf9ea3c32771dae29a2cc6bee9092f50d8fc6cab0c
-  data.tar.gz: 9cea34ee8efe8657ba6387b08001a95301e61af4a0e0be69a653de02e7d41cbb
+  metadata.gz: 583f9b1d4c78270257202f26d509a0f262e41da066da447d88b868f1631f73fe
+  data.tar.gz: 246b11e285e7631a944b358f41603c438bf8677539189a6fa5de7817c464995a
 SHA512:
-  metadata.gz: efb8a0837eef49c7a41152194b21fa6e004923a4705812365234375bfc05140bda6bdf25742c4e1e8d6ad002b2940885b8a9c46dfbfa56864bf4bfbe3a18b583
-  data.tar.gz: e4d1fdb860e7f9806f1f0e0593999ac998a34345a159de8c2e1030b3464f42473e9ef8d9d3911720898fba489d42690d29ff47b777921bff7ebc80afabdab14e
+  metadata.gz: ad19a059466a165bfe7bd9ec1a6dc8db2e86f9ec2c9f0e32bde0f09a5ce7703d60a60e9c79981cb0c073dac33789b99d636185bbbd5ffaab3065f9d21d161b17
+  data.tar.gz: '092f3ca327562d77edc0def71aa2ee62d86d3e0175c341e3fa4f38c9af380b888203e4642655b6e66aa5bc0483f35a1152ac5d38b65efcfc19406e20b6823b8c'

data/lib/rubocop/cop/betterment/unscoped_find.rb

@@ -17,7 +17,7 @@ module RuboCop
           See here for more information on this error:
           https://github.com/Betterment/betterlint/blob/main/README.md#bettermentunscopedfind
         MSG
-        METHOD_PATTERN = /^find_by_(.+?)(!)?$/.freeze
+        METHOD_PATTERN = /^find_by_(.+?)(!)?$/
         FINDS = %i(find find_by find_by! where).freeze
 
         def_node_matcher :custom_scope_find?, <<-PATTERN

data/lib/rubocop/cop/betterment/utils/hardcoded_attribute.rb

@@ -1,74 +1,76 @@
 module RuboCop
   module Cop
-    module Utils
-      class HardcodedAttribute
-        extend RuboCop::NodePattern::Macros
+    module Betterment
+      module Utils
+        class HardcodedAttribute
+          extend RuboCop::NodePattern::Macros
 
-        attr_reader :node, :let_node, :let_name
+          attr_reader :node, :let_node, :let_name
 
-        def initialize(node)
-          @node = node
-          @let_node = node.parent&.parent&.parent
-          @let_name = extract_let_name(@let_node)
-        end
+          def initialize(node)
+            @node = node
+            @let_node = node.parent&.parent&.parent
+            @let_name = extract_let_name(@let_node)
+          end
 
-        def correctable?
-          key == :id && !let_name.nil?
-        end
+          def correctable?
+            key == :id && !let_name.nil?
+          end
 
-        def replacement
-          "#{let_name}.#{key}"
-        end
+          def replacement
+            "#{let_name}.#{key}"
+          end
 
-        def each_integer_reference
-          each_possible_reference(:int) do |ref|
-            yield ref if ref.value == value
+          def each_integer_reference
+            each_possible_reference(:int) do |ref|
+              yield ref if ref.value == value
+            end
           end
-        end
 
-        def each_string_reference
-          each_possible_reference(:str) do |ref|
-            yield ref if ref.value.match?(value_pattern)
+          def each_string_reference
+            each_possible_reference(:str) do |ref|
+              yield ref if ref.value.match?(value_pattern)
+            end
           end
-        end
 
-        def each_range_within_string(reference)
-          reference.source.enum_for(:scan, value_pattern).each do
-            yield create_range(reference, Regexp.last_match)
+          def each_range_within_string(reference)
+            reference.source.enum_for(:scan, value_pattern).each do
+              yield create_range(reference, Regexp.last_match)
+            end
           end
-        end
 
-        private
+          private
 
-        def create_range(node, match)
-          range = node.source_range
-          begin_pos = range.begin_pos + match.begin(0)
-          end_pos = range.begin_pos + match.end(0)
-          range.with(begin_pos: begin_pos, end_pos: end_pos)
-        end
+          def create_range(node, match)
+            range = node.source_range
+            begin_pos = range.begin_pos + match.begin(0)
+            end_pos = range.begin_pos + match.end(0)
+            range.with(begin_pos: begin_pos, end_pos: end_pos)
+          end
 
-        def key
-          node.key.value
-        end
+          def key
+            node.key.value
+          end
 
-        def value
-          node.value.value.to_i
-        end
+          def value
+            node.value.value.to_i
+          end
 
-        def value_pattern
-          /\b#{value}\b/
-        end
+          def value_pattern
+            /\b#{value}\b/
+          end
 
-        def each_possible_reference(type, &block)
-          let_node.parent.each_descendant(:block) do |block_node|
-            block_node.each_descendant(type, &block) unless block_node == let_node
+          def each_possible_reference(type, &block)
+            let_node.parent.each_descendant(:block) do |block_node|
+              block_node.each_descendant(type, &block) unless block_node == let_node
+            end
           end
-        end
 
-        # @!method extract_let_name(node)
-        def_node_matcher :extract_let_name, <<~PATTERN
-          (block (send nil? {:let | :let!} (sym $_let_name)) _block_args _block_body)
-        PATTERN
+          # @!method extract_let_name(node)
+          def_node_matcher :extract_let_name, <<~PATTERN
+            (block (send nil? {:let | :let!} (sym $_let_name)) _block_args _block_body)
+          PATTERN
+        end
       end
     end
   end

data/lib/rubocop/cop/betterment/utils/method_return_table.rb

@@ -1,45 +1,47 @@
 module RuboCop
   module Cop
-    module Utils
-      module MethodReturnTable
-        class << self
-          def populate_index(node)
-            raise "not a class" unless node.class_type?
-
-            get_methods_for_class(node).each do |method|
-              track_method(method.method_name, Utils::Parser.get_return_values(method))
+    module Betterment
+      module Utils
+        module MethodReturnTable
+          class << self
+            def populate_index(node)
+              raise "not a class" unless node.class_type?
+
+              get_methods_for_class(node).each do |method|
+                track_method(method.method_name, Utils::Parser.get_return_values(method))
+              end
+
+              node.descendants.each do |descendant|
+                lhs, rhs = *descendant
+                next unless descendant.equals_asgn? && (descendant.type != :casgn) && rhs&.send_type?
+
+                track_method(lhs, [rhs])
+              end
             end
 
-            node.descendants.each do |descendant|
-              lhs, rhs = *descendant
-              next unless descendant.equals_asgn? && (descendant.type != :casgn) && rhs&.send_type?
-
-              track_method(lhs, [rhs])
+            def indexed_methods
+              @indexed_methods ||= {}
             end
-          end
-
-          def indexed_methods
-            @indexed_methods ||= {}
-          end
 
-          def get_method(method_name)
-            indexed_methods[method_name]
-          end
+            def get_method(method_name)
+              indexed_methods[method_name]
+            end
 
-          def has_method?(method_name)
-            indexed_methods.include?(method_name)
-          end
+            def has_method?(method_name)
+              indexed_methods.include?(method_name)
+            end
 
-          private
+            private
 
-          def track_method(method_name, returns)
-            indexed_methods[method_name] = returns
-          end
+            def track_method(method_name, returns)
+              indexed_methods[method_name] = returns
+            end
 
-          def get_methods_for_class(node)
-            return [] unless node.children && node.class_type?
+            def get_methods_for_class(node)
+              return [] unless node.children && node.class_type?
 
-            node.descendants.select(&:def_type?)
+              node.descendants.select(&:def_type?)
+            end
           end
         end
       end

data/lib/rubocop/cop/betterment/utils/parser.rb

@@ -1,113 +1,115 @@
 module RuboCop
   module Cop
-    module Utils
-      module Parser
-        def self.get_root_token(node) # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize
-          return nil unless node
-
-          return get_root_token(node.receiver) if node.receiver
-
-          # rubocop:disable InternalAffairs/NodeDestructuring
-          if node.send_type?
-            name = node.method_name
-          elsif node.variable?
-            name, = *node
-          elsif node.literal?
-            _, name = *node
-          elsif node.const_type?
-            name = node.const_name.to_sym
-          elsif node.sym_type?
-            name = node.value
-          elsif node.self_type?
-            name = :self
-          elsif node.block_pass_type?
-            name, = *node.children
-          else
-            name = nil
-          end
-          # rubocop:enable InternalAffairs/NodeDestructuring
-
-          name
-        end
-
-        def self.get_return_values(node) # rubocop:disable Metrics/AbcSize
-          return [] unless node
-          return explicit_returns(node) + get_return_values(node.body) if node.def_type?
-          return [node] if node.literal? || node.variable?
-
-          case node.type
-            when :begin
-              get_return_values(node.children.last)
-            when :block
-              get_return_values(node.body)
-            when :if
-              if_rets = get_return_values(node.if_branch)
-              else_rets = get_return_values(node.else_branch)
-              if_rets + else_rets
-            when :case
-              cases = []
-              node.each_when do |block|
-                cases += get_return_values(block.body)
-              end
-
-              cases + get_return_values(node.else_branch)
-            when :send
-              [node]
+    module Betterment
+      module Utils
+        module Parser
+          def self.get_root_token(node) # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize
+            return nil unless node
+
+            return get_root_token(node.receiver) if node.receiver
+
+            # rubocop:disable InternalAffairs/NodeDestructuring
+            if node.send_type?
+              name = node.method_name
+            elsif node.variable?
+              name, = *node
+            elsif node.literal?
+              _, name = *node
+            elsif node.const_type?
+              name = node.const_name.to_sym
+            elsif node.sym_type?
+              name = node.value
+            elsif node.self_type?
+              name = :self
+            elsif node.block_pass_type?
+              name, = *node.children
             else
-              []
+              name = nil
+            end
+            # rubocop:enable InternalAffairs/NodeDestructuring
+
+            name
           end
-        end
 
-        def self.explicit_returns(node)
-          node.descendants.select(&:return_type?).filter_map do |x|
-            x&.children&.first
+          def self.get_return_values(node) # rubocop:disable Metrics/AbcSize
+            return [] unless node
+            return explicit_returns(node) + get_return_values(node.body) if node.def_type?
+            return [node] if node.literal? || node.variable?
+
+            case node.type
+              when :begin
+                get_return_values(node.children.last)
+              when :block
+                get_return_values(node.body)
+              when :if
+                if_rets = get_return_values(node.if_branch)
+                else_rets = get_return_values(node.else_branch)
+                if_rets + else_rets
+              when :case
+                cases = []
+                node.each_when do |block|
+                  cases += get_return_values(block.body)
+                end
+
+                cases + get_return_values(node.else_branch)
+              when :send
+                [node]
+              else
+                []
+            end
           end
-        end
 
-        def self.params_from_arguments(arguments) # rubocop:disable Metrics/PerceivedComplexity
-          parameter_names = []
+          def self.explicit_returns(node)
+            node.descendants.select(&:return_type?).filter_map do |x|
+              x&.children&.first
+            end
+          end
 
-          arguments.each do |arg|
-            if arg.hash_type?
-              arg.children.each do |pair|
-                value = pair.value
-                parameter_names << value.value if value.sym_type? || value.str_type?
+          def self.params_from_arguments(arguments) # rubocop:disable Metrics/PerceivedComplexity
+            parameter_names = []
+
+            arguments.each do |arg|
+              if arg.hash_type?
+                arg.children.each do |pair|
+                  value = pair.value
+                  parameter_names << value.value if value.sym_type? || value.str_type?
+                end
+              elsif arg.sym_type? || arg.str_type?
+                parameter_names << arg.value
               end
-            elsif arg.sym_type? || arg.str_type?
-              parameter_names << arg.value
             end
+
+            parameter_names
           end
 
-          parameter_names
-        end
+          def self.get_extracted_parameters(node, param_aliases: []) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+            return [] unless node.send_type?
 
-        def self.get_extracted_parameters(node, param_aliases: []) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          return [] unless node.send_type?
+            parameter_names = []
+            param_aliases << :params
 
-          parameter_names = []
-          param_aliases << :params
+            if node.method?(:[]) && param_aliases.include?(get_root_token(node))
+              return node.arguments.select { |x|
+                x.sym_type? || x.str_type?
+              }.map(&:value)
+            end
 
-          if node.method?(:[]) && param_aliases.include?(get_root_token(node))
-            return node.arguments.select { |x|
-                     x.sym_type? || x.str_type?
-                   }.map(&:value)
-          end
+            children = node.descendants.select do |child|
+              child.send_type? && param_aliases.include?(child.method_name)
+            end
 
-          children = node.descendants.select do |child|
-            child.send_type? && param_aliases.include?(child.method_name)
-          end
+            children.each do |child|
+              ancestors = child.ancestors.select do |ancestor|
+                ancestor.send_type? && ancestor.method?(:permit)
+              end
 
-          children.each do |child|
-            ancestors = child.ancestors.select do |ancestor|
-              ancestor.send_type? && ancestor.method?(:permit)
+              ancestors.each do |ancestor|
+                parameter_names += params_from_arguments(ancestor.arguments)
+              end
             end
 
-            ancestors.each do |ancestor|
-              parameter_names += params_from_arguments(ancestor.arguments)
-            end
+            parameter_names.map(&:to_sym)
           end
-
-          parameter_names.map(&:to_sym)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: betterlint
 version: !ruby/object:Gem::Version
-  version: 1.4.9
+  version: 1.5.0
 platform: ruby
 authors:
 - Development
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-08 00:00:00.000000000 Z
+date: 2023-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -122,14 +122,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Betterment rubocop configuration