leftovers 0.7.0 → 0.10.0

data/lib/leftovers/config_loader/string_pattern_schema.rb

@@ -2,13 +2,13 @@
 
 module Leftovers
   class ConfigLoader
-    class StringPatternSchema < ObjectSchema
-      attribute :match, StringSchema, aliases: :matches, require_group: :matcher
+    class StringPatternSchema < ValueOrObjectSchema
+      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
 
-      self.or_schema = StringSchema
+      self.or_value_schema = StringSchema
     end
   end
 end

data/lib/leftovers/config_loader/string_value_processor_schema.rb

@@ -2,10 +2,10 @@
 
 module Leftovers
   class ConfigLoader
-    class StringValueProcessorSchema < ObjectSchema
+    class StringValueProcessorSchema < ValueOrObjectSchema
       inherit_attributes_from ValueProcessorSchema
 
-      self.or_schema = StringSchema
+      self.or_value_schema = StringSchema
     end
   end
 end

data/lib/leftovers/config_loader/transform_schema.rb

@@ -2,7 +2,7 @@
 
 module Leftovers
   class ConfigLoader
-    class TransformSchema < ObjectSchema
+    class TransformSchema < ValueOrObjectSchema
       ArgumentlessTransformSchema.each_value do |transform|
         attribute(
           transform, TrueSchema,
@@ -17,12 +17,16 @@ module Leftovers
                 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_schema = ArgumentlessTransformSchema
+      self.or_value_schema = ArgumentlessTransformSchema
     end
   end
 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

@@ -2,17 +2,20 @@
 
 module Leftovers
   class ConfigLoader
-    class ValueMatcherSchema < ObjectSchema
+    class ValueMatcherSchema < ValueOrObjectSchema
       attribute :arguments, ValueOrArraySchema[ArgumentPositionSchema], aliases: :argument,
         require_group: :matcher
       attribute :keywords, ValueOrArraySchema[StringPatternSchema], aliases: :keyword,
         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
 
-      self.or_schema = ScalarArgumentSchema
+      inherit_attributes_from ValueMatcherConditionSchema
+
+      self.or_value_schema = ScalarArgumentSchema
     end
   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,9 +13,7 @@ module Leftovers
 
       def to_ruby(node)
         if node.array?
-          node.children.map do |value|
-            value_schema.to_ruby(value)
-          end
+          Leftovers.unwrap_array(super)
         else
           value_schema.to_ruby(node)
         end
@@ -45,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_or_object_schema.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ValueOrObjectSchema < ObjectSchema
+      class << self
+        attr_accessor :or_value_schema
+
+        def validate(node)
+          if node.hash?
+            super(node)
+          else
+            validate_or_value_schema(node)
+          end
+        end
+
+        def to_ruby(node)
+          if node.hash?
+            super
+          else
+            or_value_schema.to_ruby(node)
+          end
+        end
+
+        private
+
+        def validate_or_value_schema(node)
+          or_value_schema.validate(node)
+          return true if node.valid?
+
+          if node.string? && attribute_for_key(node)
+            node.error = "#{node.name_}#{node.to_sym} must be a hash key"
+          else
+            node.error += " or a hash with any of #{suggestions.join(', ')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/value_processor_schema.rb

@@ -2,13 +2,13 @@
 
 module Leftovers
   class ConfigLoader
-    class ValueProcessorSchema < ObjectSchema
+    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_schema = ScalarArgumentSchema
+      self.or_value_schema = ScalarArgumentSchema
     end
   end
 end

data/lib/leftovers/config_loader.rb

@@ -1,36 +1,48 @@
 # frozen-string-literal: true
 
 require 'yaml'
-require 'leftovers'
 
 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(: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(: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")
     autoload(:ValueProcessorSchema, "#{__dir__}/config_loader/value_processor_schema")
     autoload(:ValueTypeSchema, "#{__dir__}/config_loader/value_type_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,65 +15,19 @@ 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 # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      precompiled = []
-      precompile = false
+    def ruby
+      read = self.read
 
-      if haml?
-        precompiled << ::Leftovers::Haml.precompile(read, self)
-        precompile = true
-      end
-
-      if json?
-        precompiled << ::Leftovers::JSON.precompile(read, self)
-        precompile = true
-      end
-
-      if erb?
-        precompiled << ::Leftovers::ERB.precompile(read, self)
-        precompile = true
-      end
-
-      if slim?
-        precompiled << ::Leftovers::Slim.precompile(read, self)
-        precompile = true
-      end
-
-      if yaml?
-        precompiled << ::Leftovers::YAML.precompile(read, self)
-        precompile = true
-      end
-
-      if precompile
-        precompiled.join("\n")
-      else
-        read
-      end
-    end
-
-    private
-
-    def erb?
-      Leftovers.config.erb_paths.allowed?(relative_path)
-    end
+      precompiled = ::Leftovers.config.precompilers.map do |precompiler|
+        precompiler.precompile(read, self)
+      end.compact
 
-    def haml?
-      Leftovers.config.haml_paths.allowed?(relative_path)
-    end
-
-    def yaml?
-      Leftovers.config.yaml_paths.allowed?(relative_path)
-    end
-
-    def json?
-      Leftovers.config.json_paths.allowed?(relative_path)
-    end
+      return read if precompiled.empty?
 
-    def slim?
-      Leftovers.config.slim_paths.allowed?(relative_path)
+      precompiled.join("\n")
     end
   end
 end

data/lib/leftovers/file_collector/comments_processor.rb

@@ -0,0 +1,57 @@
+# frozen-string-literal: true
+
+module Leftovers
+  class FileCollector
+    module CommentsProcessor
+      METHOD_NAME_RE = /[[:alpha:]_][[:alnum:]_]*\b[?!=]?/.freeze
+      NON_ALNUM_METHOD_NAME_RE = Regexp.union(%w{
+        []= [] ** ~ +@ -@ * / % + - >> << &
+        ^ | <=> <= >= < > === == != =~ !~ !
+      }.map { |op| /#{Regexp.escape(op)}/ })
+      CONSTANT_NAME_RE = /[[:upper:]][[:alnum:]_]*\b/.freeze
+      NAME_RE = Regexp.union(METHOD_NAME_RE, NON_ALNUM_METHOD_NAME_RE, CONSTANT_NAME_RE)
+      NAME_LIST_RE = /#{NAME_RE}(?:[, :]+#{NAME_RE})*/.freeze
+      LEFTOVERS_CALL_RE = /\bleftovers:call(?:s|e(?:d|rs?))? (#{NAME_LIST_RE})/.freeze
+      LEFTOVERS_ALLOW_RE = /\bleftovers:(?:keeps?|skip(?:s|ped|)|allow(?:s|ed|))\b/.freeze
+      LEFTOVERS_TEST_RE = /\bleftovers:(?:for_tests?|tests?|testing|test_only)\b/.freeze
+      LEFTOVERS_DYNAMIC_RE = /\bleftovers:dynamic[: ](#{NAME_LIST_RE})/.freeze
+
+      class << self
+        def process(comments, collector)
+          comments.each do |comment|
+            process_leftovers_keep_comment(comment, collector)
+            process_leftovers_test_comment(comment, collector)
+            process_leftovers_dynamic_comment(comment, collector)
+            process_leftovers_call_comment(comment, collector)
+          end
+        end
+
+        def process_leftovers_keep_comment(comment, collector)
+          return unless comment.text.match?(LEFTOVERS_ALLOW_RE)
+
+          collector.allow_lines << comment.loc.line
+        end
+
+        def process_leftovers_test_comment(comment, collector)
+          return unless comment.text.match?(LEFTOVERS_TEST_RE)
+
+          collector.test_lines << comment.loc.line
+        end
+
+        def process_leftovers_dynamic_comment(comment, collector)
+          match = comment.text.match(LEFTOVERS_DYNAMIC_RE)
+          return unless match
+
+          collector.dynamic_lines[comment.loc.line] = match[1].scan(NAME_RE)
+        end
+
+        def process_leftovers_call_comment(comment, collector)
+          match = comment.text.match(LEFTOVERS_CALL_RE)
+          return unless match
+
+          match[1].scan(NAME_RE).each { |s| collector.calls << s.to_sym }
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/file_collector/node_processor.rb

@@ -0,0 +1,131 @@
+# frozen-string-literal: true
+
+require 'parser'
+
+module Leftovers
+  class FileCollector
+    class NodeProcessor < ::Parser::AST::Processor
+      def initialize(collector) # rubocop:disable Lint/MissingSuper # there isn't one to call
+        @collector = collector
+      end
+
+      def on_def(node)
+        node.privacy = @collector.default_method_privacy
+        @collector.add_definition(node)
+        super
+      end
+
+      def on_defs(node)
+        @collector.add_definition(node)
+        super
+      end
+
+      def on_ivasgn(node)
+        @collector.collect_variable_assign(node)
+        super
+      end
+
+      def on_gvasgn(node)
+        @collector.collect_variable_assign(node)
+        super
+      end
+
+      def on_cvasgn(node)
+        @collector.collect_variable_assign(node)
+        super
+      end
+
+      def on_ivar(node)
+        @collector.calls << node.name
+        super
+      end
+
+      def on_gvar(node)
+        @collector.calls << node.name
+        super
+      end
+
+      def on_cvar(node)
+        @collector.calls << node.name
+        super
+      end
+
+      def on_op_asgn(node)
+        @collector.collect_op_asgn(node)
+        super
+      end
+
+      def on_and_asgn(node)
+        @collector.collect_op_asgn(node)
+        super
+      end
+
+      def on_or_asgn(node)
+        @collector.collect_op_asgn(node)
+        super
+      end
+
+      def on_send(node)
+        super
+        @collector.collect_send(node)
+      end
+
+      def on_csend(node)
+        super
+        @collector.collect_send(node)
+      end
+
+      def on_const(node)
+        super
+        @collector.calls << node.name
+      end
+
+      def on_array(node)
+        super
+        @collector.collect_commented_dynamic(node)
+      end
+
+      def on_hash(node)
+        super
+        @collector.collect_commented_dynamic(node)
+      end
+
+      # grab e.g. :to_s in each(&:to_s)
+      def on_block_pass(node)
+        super
+        return unless node.first.sym?
+
+        @collector.calls << node.first.to_sym
+      end
+
+      # grab class Constant or module Constant
+      def on_class(node)
+        # don't call super so we don't interpret the class name as being called by its definition
+        process_all(node.children.drop(1))
+
+        node = node.children.first
+
+        @collector.add_definition(node)
+      end
+      alias_method :on_module, :on_class
+
+      # grab Constant = Class.new or CONSTANT = 'string'.freeze
+      def on_casgn(node)
+        super
+
+        @collector.add_definition(node)
+        @collector.collect_dynamic(node)
+      end
+
+      # grab calls to `alias new_method original_method`
+      def on_alias(node)
+        super
+        new_method, original_method = node.children
+        @collector.add_definition(
+          new_method, name: new_method.children.first, loc: new_method.loc.expression
+        )
+        @collector.calls << original_method.children.first
+      end
+    end
+  end
+end