leftovers 0.8.0 → 0.11.0

data/lib/leftovers/config_loader/has_value_schema.rb

@@ -3,12 +3,16 @@
 module Leftovers
   class ConfigLoader
     class HasValueSchema < ValueOrObjectSchema
+      attribute :names, ValueOrArraySchema[StringPatternSchema], aliases: :name,
+        require_group: :matcher
       inherit_attributes_from StringPatternSchema, except: :unless
+      attribute :has_arguments, ValueOrArraySchema[HasArgumentSchema], aliases: :has_argument,
+        require_group: :matcher
 
       attribute :at, ValueOrArraySchema[ArgumentPositionSchema], require_group: :matcher
       attribute :has_value, ValueOrArraySchema[HasValueSchema], require_group: :matcher
 
-      attribute :has_receiver, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+      attribute :has_receiver, ValueOrArraySchema[HasReceiverSchema], require_group: :matcher
       attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
       attribute :unless, ValueOrArraySchema[HasValueSchema], require_group: :matcher
 

data/lib/leftovers/config_loader/keyword_argument_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class KeywordArgumentSchema < ValueOrObjectSchema
+      inherit_attributes_from StringPatternSchema, except: :unless
+      attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
+      attribute :unless, ValueOrArraySchema[KeywordArgumentSchema], require_group: :matcher
+
+      self.or_value_schema = StringSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/regexp_schema.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class RegexpSchema < StringSchema
+      class << self
+        def validate(node)
+          validate_string(node) && validate_regexp(node)
+        end
+
+        def validate_string(node)
+          error(node, 'be a string with a valid ruby regexp') unless node.string?
+
+          node.valid?
+        end
+
+        def validate_regexp(node)
+          /#{node.to_ruby}/
+        rescue RegexpError, ArgumentError => e
+          error(node, "be a string with a valid ruby regexp (#{e.message})")
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/rule_pattern_schema.rb

@@ -9,10 +9,12 @@ module Leftovers
       attribute :document, TrueSchema, require_group: :matcher
       attribute :has_arguments, ValueOrArraySchema[HasArgumentSchema], aliases: :has_argument,
         require_group: :matcher
-      attribute :has_receiver, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+      attribute :has_receiver, ValueOrArraySchema[HasReceiverSchema], require_group: :matcher
       attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
       attribute :privacy, ValueOrArraySchema[PrivacySchema], require_group: :matcher
       attribute :unless, ValueOrArraySchema[RulePatternSchema], require_group: :matcher
+      attribute :all, ArraySchema[RulePatternSchema], require_group: :matcher
+      attribute :any, ArraySchema[RulePatternSchema], require_group: :matcher
     end
   end
 end

data/lib/leftovers/config_loader/scalar_value_schema.rb

@@ -8,6 +8,14 @@ module Leftovers
           error(node, 'be any scalar value') unless node.scalar?
           super
         end
+
+        def to_ruby(node)
+          if node.to_ruby.nil?
+            :_leftovers_nil_value
+          else
+            node.to_ruby
+          end
+        end
       end
     end
   end

data/lib/leftovers/config_loader/schema.rb

@@ -17,6 +17,16 @@ module Leftovers
         def to_ruby(node)
           node.to_ruby
         end
+
+        def ===(other) # leftovers:test_only
+          # :nocov:
+          if other.is_a?(Module)
+            self >= other
+          else
+            other.is_a?(self)
+          end
+          # :nocov:
+        end
       end
     end
   end

data/lib/leftovers/config_loader/string_enum_schema.rb

@@ -28,7 +28,7 @@ module Leftovers
         end
 
         def to_ruby(node)
-          aliases[node.to_sym]&.to_s || node.to_ruby
+          aliases[node.to_sym] || node.to_sym
         end
 
         def validate(node)

data/lib/leftovers/config_loader/string_pattern_schema.rb

@@ -3,7 +3,7 @@
 module Leftovers
   class ConfigLoader
     class StringPatternSchema < ValueOrObjectSchema
-      attribute :match, StringSchema, aliases: :matches, require_group: :matcher
+      attribute :match, RegexpSchema, aliases: :matches, require_group: :matcher
       attribute :has_prefix, StringSchema, require_group: :matcher
       attribute :has_suffix, StringSchema, require_group: :matcher
       attribute :unless, ValueOrArraySchema[StringPatternSchema], require_group: :matcher

data/lib/leftovers/config_loader/transform_schema.rb

@@ -11,14 +11,20 @@ module Leftovers
         )
       end
 
-      attribute :add_prefix, StringValueProcessorSchema, require_group: :processor
-      attribute :add_suffix, StringValueProcessorSchema, require_group: :processor
+      attribute :add_prefix, ValueOrArraySchema[StringValueProcessorSchema],
+                require_group: :processor
+      attribute :add_suffix, ValueOrArraySchema[StringValueProcessorSchema],
+                require_group: :processor
 
       attribute :split, StringSchema, require_group: :processor
-      attribute :delete_prefix, StringSchema, require_group: :processor
-      attribute :delete_suffix, StringSchema, require_group: :processor
-      attribute :delete_before, StringSchema, require_group: :processor
-      attribute :delete_after, StringSchema, require_group: :processor
+      attribute :delete_prefix, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :delete_suffix, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :delete_before, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :delete_before_last, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :delete_after, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :delete_after_last, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :transforms, ValueOrArraySchema[TransformSchema], require_group: :processor,
+        aliases: :transform
 
       self.or_value_schema = ArgumentlessTransformSchema
     end

data/lib/leftovers/config_loader/value_matcher_condition_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ValueMatcherConditionSchema < ObjectSchema
+      attribute :has_arguments, ValueOrArraySchema[HasArgumentSchema], aliases: :has_argument
+      attribute :has_receiver, ValueOrArraySchema[HasReceiverSchema]
+      attribute :unless, ValueOrArraySchema[ValueMatcherConditionSchema]
+      attribute :all, ArraySchema[ValueMatcherConditionSchema]
+      attribute :any, ArraySchema[ValueMatcherConditionSchema]
+    end
+  end
+end

data/lib/leftovers/config_loader/value_matcher_schema.rb

@@ -9,9 +9,12 @@ module Leftovers
         require_group: :matcher
       attribute :itself, TrueSchema, require_group: :matcher
       attribute :nested, ValueOrArraySchema[ValueMatcherSchema]
-      attribute :value, StringSchema, require_group: :matcher
+      attribute :value, ValueOrArraySchema[StringSchema], require_group: :matcher, aliases: :values
+      attribute :receiver, TrueSchema, require_group: :matcher
       attribute :recursive, TrueSchema
 
+      inherit_attributes_from ValueMatcherConditionSchema
+
       self.or_value_schema = ScalarArgumentSchema
     end
   end

data/lib/leftovers/config_loader/value_or_array_schema.rb

@@ -2,21 +2,7 @@
 
 module Leftovers
   class ConfigLoader
-    class ValueOrArraySchema < Schema
-      class << self
-        def [](value_schema)
-          new(value_schema)
-        end
-      end
-
-      attr_reader :value_schema
-
-      def initialize(value_schema)
-        @value_schema = value_schema
-
-        super()
-      end
-
+    class ValueOrArraySchema < ArraySchema
       def validate(node)
         if node.array?
           validate_length(node) && validate_values(node)
@@ -27,11 +13,7 @@ module Leftovers
 
       def to_ruby(node)
         if node.array?
-          Leftovers.unwrap_array(
-            node.children.map do |value|
-              value_schema.to_ruby(value)
-            end
-          )
+          Leftovers.unwrap_array(super)
         else
           value_schema.to_ruby(node)
         end
@@ -47,20 +29,6 @@ module Leftovers
 
         false
       end
-
-      def validate_length(node)
-        self.class.error(node, 'not be empty') if node.children.empty?
-
-        node.valid?
-      end
-
-      def validate_values(node)
-        node.children.each do |value|
-          value_schema.validate(value)
-        end
-
-        node.children.all?(&:valid?)
-      end
     end
   end
 end

data/lib/leftovers/config_loader/value_processor_schema.rb

@@ -5,8 +5,8 @@ module Leftovers
     class ValueProcessorSchema < ValueOrObjectSchema
       inherit_attributes_from ValueMatcherSchema
 
-      attribute :transforms, ValueOrArraySchema[TransformSchema]
-      inherit_attributes_from TransformSchema, require_group: nil
+      attribute :transforms, ValueOrArraySchema[TransformSchema], aliases: :transform
+      inherit_attributes_from TransformSchema, require_group: nil, except: :transforms
 
       self.or_value_schema = ScalarArgumentSchema
     end

data/lib/leftovers/config_loader.rb

@@ -4,34 +4,42 @@ require 'yaml'
 
 module Leftovers
   class ConfigLoader
-    autoload(:ArgumentPositionSchema, "#{__dir__}/config_loader/argument_position_schema")
     autoload(:ArgumentlessTransformSchema, "#{__dir__}/config_loader/argumentless_transform_schema")
+    autoload(:ArgumentPositionSchema, "#{__dir__}/config_loader/argument_position_schema")
+    autoload(:ArraySchema, "#{__dir__}/config_loader/array_schema")
     autoload(:Attribute, "#{__dir__}/config_loader/attribute")
     autoload(:BuiltInPrecompilerSchema, "#{__dir__}/config_loader/built_in_precompiler_schema")
     autoload(:DocumentSchema, "#{__dir__}/config_loader/document_schema")
     autoload(:DynamicSchema, "#{__dir__}/config_loader/dynamic_schema")
-    autoload(:InheritSchemaAttributes, "#{__dir__}/config_loader/inherit_schema_attributes")
     autoload(:HasArgumentSchema, "#{__dir__}/config_loader/has_argument_schema")
     autoload(:HasValueSchema, "#{__dir__}/config_loader/has_value_schema")
+    autoload(:HasReceiverSchema, "#{__dir__}/config_loader/has_receiver_schema")
+    autoload(:InheritSchemaAttributes, "#{__dir__}/config_loader/inherit_schema_attributes")
     autoload(:KeepTestOnlySchema, "#{__dir__}/config_loader/keep_test_only_schema")
+    autoload(:KeywordArgumentSchema, "#{__dir__}/config_loader/keyword_argument_schema")
     autoload(:Node, "#{__dir__}/config_loader/node")
     autoload(:ObjectSchema, "#{__dir__}/config_loader/object_schema")
-    autoload(:PrecompileSchema, "#{__dir__}/config_loader/precompile_schema")
     autoload(:PrecompilerSchema, "#{__dir__}/config_loader/precompiler_schema")
+    autoload(:PrecompileSchema, "#{__dir__}/config_loader/precompile_schema")
     autoload(:PrivacyProcessorSchema, "#{__dir__}/config_loader/privacy_processor_schema")
     autoload(:PrivacySchema, "#{__dir__}/config_loader/privacy_schema")
+    autoload(:RegexpSchema, "#{__dir__}/config_loader/regexp_schema")
     autoload(:RequireSchema, "#{__dir__}/config_loader/require_schema")
     autoload(:RulePatternSchema, "#{__dir__}/config_loader/rule_pattern_schema")
     autoload(:ScalarArgumentSchema, "#{__dir__}/config_loader/scalar_argument_schema")
     autoload(:ScalarValueSchema, "#{__dir__}/config_loader/scalar_value_schema")
     autoload(:Schema, "#{__dir__}/config_loader/schema")
-    autoload(:Suggester, "#{__dir__}/config_loader/suggester")
     autoload(:StringEnumSchema, "#{__dir__}/config_loader/string_enum_schema")
     autoload(:StringPatternSchema, "#{__dir__}/config_loader/string_pattern_schema")
     autoload(:StringSchema, "#{__dir__}/config_loader/string_schema")
     autoload(:StringValueProcessorSchema, "#{__dir__}/config_loader/string_value_processor_schema")
+    autoload(:Suggester, "#{__dir__}/config_loader/suggester")
     autoload(:TransformSchema, "#{__dir__}/config_loader/transform_schema")
     autoload(:TrueSchema, "#{__dir__}/config_loader/true_schema")
+    autoload(
+      :ValueMatcherConditionSchema,
+      "#{__dir__}/config_loader/value_matcher_condition_schema"
+    )
     autoload(:ValueMatcherSchema, "#{__dir__}/config_loader/value_matcher_schema")
     autoload(:ValueOrArraySchema, "#{__dir__}/config_loader/value_or_array_schema")
     autoload(:ValueOrObjectSchema, "#{__dir__}/config_loader/value_or_object_schema")

data/lib/leftovers/definition_collection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class DefinitionCollection
+    def initialize
+      @definitions_to_add = {}
+      @definition_sets_to_add = []
+    end
+
+    def add_definition_node(definition_node)
+      add(definition_node, loc: definition_node.loc)
+    end
+
+    def add(node, name: node.name, loc: node.loc.name)
+      @definitions_to_add[name] = ::Leftovers::DefinitionToAdd.new(node, name: name, location: loc)
+    end
+
+    def add_definition_set(definition_node_set)
+      @definition_sets_to_add << definition_node_set.definitions.map do |definition_node|
+        ::Leftovers::DefinitionToAdd.new(definition_node, location: definition_node.loc)
+      end
+    end
+
+    def set_privacy(name, to)
+      @definitions_to_add[name]&.privacy = to
+    end
+
+    def to_definitions(file_collector)
+      @definitions_to_add.each_value.map { |d| d.to_definition(file_collector) } +
+        @definition_sets_to_add.map do |definition_set|
+          next if definition_set.any? { |d| d.keep?(file_collector) }
+
+          ::Leftovers::DefinitionSet.new(definition_set.map { |d| d.to_definition(file_collector) })
+        end
+    end
+  end
+end

data/lib/leftovers/definition_node.rb

@@ -1,25 +1,19 @@
 # frozen-string-literal: true
 
 module Leftovers
-  class DefinitionNode
-    attr_reader :name, :loc, :node
+  class DefinitionNode < ::Leftovers::AST::Node
+    attr_reader :name, :path
+    alias_method :to_sym, :name
 
     def initialize(node, name:, location: node.loc.expression)
-      @node = node
       @name = name
-      @loc = location
+      @path = node.path
+      @location = location
+      super(:leftovers_definition)
     end
 
-    def kwargs
-      nil
-    end
-
-    def positional_arguments
-      nil
-    end
-
-    def path
-      node.path
+    def to_s
+      name.to_s
     end
   end
 end

data/lib/leftovers/definition_node_set.rb

@@ -4,8 +4,16 @@ module Leftovers
   class DefinitionNodeSet
     attr_reader :definitions
 
-    def initialize(definitions)
-      @definitions = definitions
+    def initialize
+      @definitions = []
+    end
+
+    def add_definition_node(definition_node)
+      @definitions << definition_node
+    end
+
+    def add_definition_set(definition_node_set)
+      @definitions.concat(definition_node_set.definitions)
     end
   end
 end

data/lib/leftovers/file.rb

@@ -15,7 +15,7 @@ module Leftovers
     def test?
       return @test if defined?(@test)
 
-      @test = Leftovers.config.test_paths.allowed?(relative_path)
+      @test = Leftovers.config.test_paths === relative_path
     end
 
     def ruby

data/lib/leftovers/file_collector/comments_processor.rb

@@ -49,7 +49,7 @@ module Leftovers
           match = comment.text.match(LEFTOVERS_CALL_RE)
           return unless match
 
-          match[1].scan(NAME_RE).each { |s| collector.add_call(s.to_sym) }
+          match[1].scan(NAME_RE).each { |s| collector.calls << s.to_sym }
         end
       end
     end

data/lib/leftovers/file_collector/node_processor.rb

@@ -36,17 +36,17 @@ module Leftovers
       end
 
       def on_ivar(node)
-        @collector.add_call(node.name)
+        @collector.calls << node.name
         super
       end
 
       def on_gvar(node)
-        @collector.add_call(node.name)
+        @collector.calls << node.name
         super
       end
 
       def on_cvar(node)
-        @collector.add_call(node.name)
+        @collector.calls << node.name
         super
       end
 
@@ -77,7 +77,7 @@ module Leftovers
 
       def on_const(node)
         super
-        @collector.add_call(node.name)
+        @collector.calls << node.name
       end
 
       def on_array(node)
@@ -93,9 +93,9 @@ module Leftovers
       # grab e.g. :to_s in each(&:to_s)
       def on_block_pass(node)
         super
-        return unless node.first.string_or_symbol?
+        return unless node.first.sym?
 
-        @collector.add_call(node.first.to_sym)
+        @collector.calls << node.first.to_sym
       end
 
       # grab class Constant or module Constant
@@ -124,7 +124,7 @@ module Leftovers
         @collector.add_definition(
           new_method, name: new_method.children.first, loc: new_method.loc.expression
         )
-        @collector.add_call(original_method.children.first)
+        @collector.calls << original_method.children.first
       end
     end
   end

data/lib/leftovers/file_collector.rb

@@ -12,14 +12,13 @@ module Leftovers
 
     def initialize(ruby, file)
       @calls = []
-      @definitions_to_add = {}
+      @definition_collection = Leftovers::DefinitionCollection.new
       @allow_lines = Set.new.compare_by_identity
       @test_lines = Set.new.compare_by_identity
       @dynamic_lines = {}
       @ruby = ruby
       @file = file
       @default_method_privacy = :public
-      @definition_sets_to_add = []
     end
 
     def filename
@@ -37,8 +36,8 @@ module Leftovers
       list
     end
 
-    def collect
-      ast, comments = Leftovers::Parser.parse_with_comments(@ruby, @file.relative_path)
+    def collect(ruby = @ruby, line = 1)
+      ast, comments = Leftovers::Parser.parse_with_comments(ruby, @file.relative_path, line)
       CommentsProcessor.process(comments, self)
       NodeProcessor.new(self).process(ast)
     rescue ::Parser::SyntaxError => e
@@ -48,44 +47,41 @@ module Leftovers
       )
     end
 
-    # grab method definitions
-    def add_definition(node, name: node.name, loc: node.loc.name)
-      @definitions_to_add[name] = ::Leftovers::DefinitionToAdd.new(node, name: name, location: loc)
+    def collect_subfile(string, location)
+      string = (' ' * location.column) + string # match indentation
+      collect(string, location.line)
     end
 
-    def add_definition_set(definition_node_set)
-      @definition_sets_to_add << definition_node_set.definitions.map do |definition_node|
-        ::Leftovers::DefinitionToAdd.new(definition_node, location: definition_node.loc)
-      end
+    def test_line?(line)
+      @file.test? || @test_lines.include?(line)
     end
 
-    def set_privacy(name, to)
-      @definitions_to_add[name]&.privacy = to
+    def keep_line?(line)
+      @allow_lines.include?(line)
     end
 
-    def definitions
-      @definitions ||= @definitions_to_add.each_value.map { |d| d.to_definition(self) } +
-        @definition_sets_to_add.map do |definition_set|
-          next if definition_set.any? { |d| d.keep?(self) }
+    def add_definition_set(definition_node_set)
+      @definition_collection.add_definition_set(definition_node_set)
+    end
 
-          ::Leftovers::DefinitionSet.new(definition_set.map { |d| d.to_definition(self) })
-        end
+    def set_privacy(node, to)
+      @definition_collection.set_privacy(node, to)
     end
 
-    def test_line?(line)
-      @file.test? || @test_lines.include?(line)
+    def add_definition(node, name: node.name, loc: node.loc.name)
+      @definition_collection.add(node, name: name, loc: loc)
     end
 
-    def keep_line?(line)
-      @allow_lines.include?(line)
+    def add_definition_node(definition_node)
+      @definition_collection.add_definition_node(definition_node)
     end
 
-    def add_call(name)
-      calls << name
+    def definitions
+      @definitions ||= @definition_collection.to_definitions(self)
     end
 
     def collect_send(node)
-      add_call(node.name)
+      calls << node.name
       collect_dynamic(node)
     end
 
@@ -98,9 +94,9 @@ module Leftovers
       node = node.first
       case node.type
       # just collects the :call=, super will collect the :call
-      when :send, :csend then add_call(:"#{node.name}=")
+      when :send, :csend then calls << :"#{node.name}="
       # just collects the call, super will collect the definition
-      when :ivasgn, :gvasgn, :cvasgn then add_call(node.name)
+      when :ivasgn, :gvasgn, :cvasgn then calls << node.name
       when :lvasgn then nil # we don't care about lvasgn
       # :nocov:
       else raise Leftovers::UnexpectedCase, "Unhandled value #{node.type.inspect}"
@@ -115,9 +111,7 @@ module Leftovers
     end
 
     def collect_dynamic(node)
-      node.keep_line = @allow_lines.include?(node.loc.line)
-
-      Leftovers.config.dynamic.process(node, self)
+      Leftovers.config.dynamic.process(nil, node, node, self)
     rescue StandardError => e
       raise ::Leftovers::Error, "#{e.class}: #{e.message}\n" \
         "when processing #{node} at #{filename}:#{node.loc.line}:#{node.loc.column}", e.backtrace
@@ -126,7 +120,7 @@ module Leftovers
     private
 
     def build_send_wrapper_for(node, name)
-      ::Leftovers::AST::Node.new(
+      ::Leftovers::AST::SendNode.new(
         :send, [nil, name.to_sym, *node.arguments], location: node.location
       )
     end

data/lib/leftovers/file_list.rb

@@ -4,11 +4,12 @@ require 'fast_ignore'
 
 module Leftovers
   class FileList < ::FastIgnore
-    def initialize
+    def initialize(**arguments)
       super(
         ignore_rules: Leftovers.config.exclude_paths,
         include_rules: Leftovers.config.include_paths,
-        root: Leftovers.pwd
+        root: Leftovers.pwd,
+        **arguments
       )
     end
 

data/lib/leftovers/matcher_builders/and.rb

@@ -3,15 +3,32 @@
 module Leftovers
   module MatcherBuilders
     module And
-      def self.build(matchers)
-        matchers = matchers.compact
-        case matchers.length
-        # :nocov:
-        when 0 then nil
-        # :nocov:
-        when 1 then matchers.first
-        when 2 then ::Leftovers::Matchers::And.new(matchers.first, matchers[1])
-        else ::Leftovers::Matchers::All.new(matchers.dup)
+      class << self
+        def build(matchers)
+          matchers = flatten(matchers).compact
+          case matchers.length
+          when 0 then nil
+          when 1 then matchers.first
+          when 2 then ::Leftovers::Matchers::And.new(matchers.first, matchers[1])
+          else ::Leftovers::Matchers::All.new(matchers.dup)
+          end
+        end
+
+        private
+
+        def flatten(value)
+          case value
+          when ::Leftovers::Matchers::And
+            [*flatten(value.lhs), *flatten(value.rhs)]
+          # :nocov: # not sure how to make this happen
+          when ::Leftovers::Matchers::All
+            flatten(value.matchers)
+          # :nocov:
+          when Array
+            value.flat_map { |v| flatten(v) }
+          else
+            [value]
+          end
         end
       end
     end