leftovers 0.6.0 → 0.7.0

data/lib/leftovers/config_loader/value_type_schema.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ValueTypeSchema < StringEnumSchema
+      value :String
+      value :Symbol
+      value :Integer
+      value :Float
+      value :Array
+      value :Hash
+      value :Proc
+      value :Method
+      value :Constant
+    end
+  end
+end

data/lib/leftovers/config_loader.rb

@@ -0,0 +1,82 @@
+# 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(:Attribute, "#{__dir__}/config_loader/attribute")
+    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(:KeepTestOnlySchema, "#{__dir__}/config_loader/keep_test_only_schema")
+    autoload(:Node, "#{__dir__}/config_loader/node")
+    autoload(:ObjectSchema, "#{__dir__}/config_loader/object_schema")
+    autoload(:PrivacyProcessorSchema, "#{__dir__}/config_loader/privacy_processor_schema")
+    autoload(:PrivacySchema, "#{__dir__}/config_loader/privacy_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(:TransformSchema, "#{__dir__}/config_loader/transform_schema")
+    autoload(:TrueSchema, "#{__dir__}/config_loader/true_schema")
+    autoload(:ValueMatcherSchema, "#{__dir__}/config_loader/value_matcher_schema")
+    autoload(:ValueOrArraySchema, "#{__dir__}/config_loader/value_or_array_schema")
+    autoload(:ValueProcessorSchema, "#{__dir__}/config_loader/value_processor_schema")
+    autoload(:ValueTypeSchema, "#{__dir__}/config_loader/value_type_schema")
+
+    def self.load(name, path: nil, content: nil)
+      new(name, path: path, content: content).load
+    end
+
+    attr_reader :name
+
+    def initialize(name, path: nil, content: nil)
+      @name = name
+      @path = path
+      @content = content
+    end
+
+    def load
+      document = ::Leftovers::ConfigLoader::Node.new(parse, file)
+      DocumentSchema.validate(document)
+
+      all_errors = document.all_errors
+      return DocumentSchema.to_ruby(document) if all_errors.empty?
+
+      Leftovers.error(all_errors.join("\n"))
+    end
+
+    private
+
+    def path
+      @path ||= ::File.expand_path("../config/#{name}.yml", __dir__)
+    end
+
+    def file
+      @file ||= ::Leftovers::File.new(path)
+    end
+
+    def content
+      @content ||= file.exist? ? file.read : ''
+    end
+
+    def parse
+      parsed = Psych.parse(content)
+      parsed ||= Psych.parse('{}')
+      parsed.children.first
+    rescue ::Psych::SyntaxError => e
+      message = [e.problem, e.context].compact.join(' ')
+      Leftovers.error "Config SyntaxError: #{file.relative_path}:#{e.line}:#{e.column} #{message}"
+    end
+  end
+end

data/lib/leftovers/definition_node.rb

@@ -1,19 +1,15 @@
 # frozen-string-literal: true
 
-# To give to matchers before creating a Definition
-
 module Leftovers
   class DefinitionNode
-    attr_reader :path, :name
+    attr_reader :name, :loc, :node
 
-    def initialize(name, path)
+    def initialize(node, name:, location: node.loc.expression)
+      @node = node
       @name = name
-      @path = path
-
-      freeze
+      @loc = location
     end
 
-    # these are the methods checked by things in lib/leftovers/matchers
     def kwargs
       nil
     end
@@ -22,15 +18,8 @@ module Leftovers
       nil
     end
 
-    # these two i'm not sure are possible with the current config flags
-    # :nocov:
-    def scalar?
-      false
-    end
-
-    def type
-      :leftovers_definition
+    def path
+      node.path
     end
-    # :nocov:
   end
 end

data/lib/leftovers/definition_node_set.rb

@@ -0,0 +1,11 @@
+# frozen-string-literal: true
+
+module Leftovers
+  class DefinitionNodeSet
+    attr_reader :definitions
+
+    def initialize(definitions)
+      @definitions = definitions
+    end
+  end
+end

data/lib/leftovers/definition_to_add.rb

@@ -0,0 +1,31 @@
+# frozen-string-literal: true
+
+module Leftovers
+  class DefinitionToAdd
+    attr_reader :node, :name, :location
+
+    def initialize(node, name: node.name, location: node.loc.name)
+      @node = node
+      @name = name
+      @location = location
+    end
+
+    def privacy=(value)
+      @node.privacy = value
+    end
+
+    def keep?(file_collector)
+      @keep ||= file_collector.keep_line?(location.line) || ::Leftovers.config.keep === node
+    end
+
+    def test?(file_collector)
+      file_collector.test_line?(location.line) || ::Leftovers.config.test_only === node
+    end
+
+    def to_definition(file_collector)
+      return if keep?(file_collector)
+
+      Leftovers::Definition.new(name, location: location, test: test?(file_collector))
+    end
+  end
+end

data/lib/leftovers/dynamic_processors/call.rb

@@ -11,10 +11,11 @@ module Leftovers
       def process(node, file)
         return unless @matcher === node
 
-        call = @processor.process(nil, node, node)
-        return unless call
+        calls = @processor.process(nil, node, node)
 
-        file.calls << call
+        ::Leftovers.each_or_self(calls) do |call|
+          file.calls << call
+        end
       end
     end
   end

data/lib/leftovers/dynamic_processors/call_definition.rb

@@ -9,18 +9,25 @@ module Leftovers
         @definition_processor = definition_processor
       end
 
-      def process(node, file)
+      def process(node, file) # rubocop:disable Metrics/MethodLength
         return unless @matcher === node
 
-        call = @call_processor.process(nil, node, node)
-        (file.calls << call) if call
+        calls = @call_processor.process(nil, node, node)
 
-        return if node.keep_line?
+        ::Leftovers.each_or_self(calls) do |call|
+          file.calls << call
+        end
 
-        definition = @definition_processor.process(nil, node, node)
-        return unless definition
+        return if node.keep_line?
 
-        file.definitions << definition
+        definitions = @definition_processor.process(nil, node, node)
+        ::Leftovers.each_or_self(definitions) do |definition|
+          if definition.is_a?(DefinitionNodeSet)
+            file.add_definition_set(definition)
+          else
+            file.add_definition(definition, loc: definition.loc)
+          end
+        end
       end
     end
   end

data/lib/leftovers/dynamic_processors/definition.rb

@@ -12,10 +12,15 @@ module Leftovers
         return if node.keep_line?
         return unless @matcher === node
 
-        definition = @processor.process(nil, node, node)
-        return unless definition
+        definitions = @processor.process(nil, node, node)
 
-        file.definitions << definition
+        ::Leftovers.each_or_self(definitions) do |definition|
+          if definition.is_a?(DefinitionNodeSet)
+            file.add_definition_set(definition)
+          else
+            file.add_definition(definition, loc: definition.loc)
+          end
+        end
       end
     end
   end

data/lib/leftovers/dynamic_processors/set_default_privacy.rb

@@ -0,0 +1,18 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    class SetDefaultPrivacy
+      def initialize(matcher, to)
+        @matcher = matcher
+        @to = to
+      end
+
+      def process(node, file)
+        return unless @matcher === node
+
+        file.default_method_privacy = @to
+      end
+    end
+  end
+end

data/lib/leftovers/dynamic_processors/set_privacy.rb

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    class SetPrivacy
+      def initialize(matcher, processor, to)
+        @matcher = matcher
+        @processor = processor
+        @to = to
+      end
+
+      def process(node, file)
+        return unless @matcher === node
+
+        set_privacy = @processor.process(nil, node, node)
+
+        ::Leftovers.each_or_self(set_privacy) do |name|
+          file.set_privacy(name, @to)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/dynamic_processors.rb

@@ -7,5 +7,7 @@ module Leftovers
     autoload(:Definition, "#{__dir__}/dynamic_processors/definition")
     autoload(:Each, "#{__dir__}/dynamic_processors/each")
     autoload(:Null, "#{__dir__}/dynamic_processors/null")
+    autoload(:SetDefaultPrivacy, "#{__dir__}/dynamic_processors/set_default_privacy")
+    autoload(:SetPrivacy, "#{__dir__}/dynamic_processors/set_privacy")
   end
 end

data/lib/leftovers/file.rb

@@ -5,7 +5,11 @@ require 'pathname'
 module Leftovers
   class File < Pathname
     def relative_path
-      @relative_path ||= relative_path_from(Leftovers.pwd)
+      @relative_path ||= begin
+        relative_path_from(Leftovers.pwd)
+      rescue ArgumentError
+        self
+      end
     end
 
     def test?

data/lib/leftovers/file_collector.rb

@@ -5,16 +5,19 @@ require 'parser'
 
 module Leftovers
   class FileCollector < ::Parser::AST::Processor # rubocop:disable Metrics/ClassLength
-    attr_reader :calls, :definitions
+    attr_reader :calls
+    attr_accessor :default_method_privacy
 
     def initialize(ruby, file) # rubocop:disable Lint/MissingSuper
       @calls = []
-      @definitions = []
+      @definitions_to_add = {}
       @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
@@ -38,7 +41,6 @@ module Leftovers
       definitions.flatten!
       definitions.compact!
       definitions.uniq!
-      definitions.reject! { |v| v == :keep }
     end
 
     def collect
@@ -76,6 +78,12 @@ module Leftovers
 
     # grab method definitions
     def on_def(node)
+      node.privacy = default_method_privacy
+      add_definition(node)
+      super
+    end
+
+    def on_defs(node)
       add_definition(node)
       super
     end
@@ -184,24 +192,41 @@ module Leftovers
       add_call(original_method.children.first)
     end
 
-    private
+    def add_definition(node, name: node.name, loc: node.loc.name)
+      @definitions_to_add[name] =
+        ::Leftovers::DefinitionToAdd.new(node, name: name, location: loc)
+    end
 
-    def test_line?(loc)
-      @file.test? ||
-        @test_lines.include?(loc.line)
+    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 test_node?(node, loc)
-      test_line?(loc) || ::Leftovers.config.test_only === node
+    def set_privacy(name, to)
+      @definitions_to_add[name]&.privacy = to
     end
 
-    def add_definition(node, name: node.name, loc: node.loc.name)
-      return if @allow_lines.include?(loc.line)
-      return if Leftovers.config.keep === node
+    def definitions
+      @definitions ||= @definitions_to_add.each_value.map { |d| d.to_definition(self) }.compact +
+        @definition_sets_to_add.map do |definition_set|
+          next nil if definition_set.any? { |d| d.keep?(self) }
 
-      definitions << Leftovers::Definition.new(name, location: loc, test: test_node?(node, loc))
+          ::Leftovers::DefinitionSet.new(definition_set.map { |d| d.to_definition(self) })
+        end.compact
     end
 
+    def test_line?(line)
+      @file.test? ||
+        @test_lines.include?(line)
+    end
+
+    def keep_line?(line)
+      @allow_lines.include?(line)
+    end
+
+    private
+
     def add_call(name)
       calls << name
     end
@@ -232,11 +257,14 @@ module Leftovers
 
     def collect_op_asgn(node)
       node = node.children.first
-      # :nocov: # don't need else, it's exhaustive for callers
       case node.type
-      # :nocov:
       when :send then collect_send_op_asgn(node)
       when :ivasgn, :gvasgn, :cvasgn then collect_var_op_asgn(node)
+      when :lvasgn then nil # we don't care about lvasgn
+      # :nocov:
+      else
+        raise "Unrecognized op_asgn node type #{node.type}"
+        # :nocov:
       end
     end
 
@@ -256,9 +284,8 @@ module Leftovers
       )
     end
 
-    def collect_dynamic(node) # rubocop:disable Metrics/AbcSize
+    def collect_dynamic(node)
       node.keep_line = @allow_lines.include?(node.loc.line)
-      node.test_line = test_line?(node.loc) unless node.keep_line?
 
       Leftovers.config.dynamic.process(node, self)
     rescue StandardError => e

data/lib/leftovers/matcher_builders/node.rb

@@ -23,6 +23,8 @@ module Leftovers
         paths: nil,
         has_arguments: nil,
         has_receiver: nil,
+        type: nil,
+        privacy: nil,
         unless_arg: nil
       )
         ::Leftovers::MatcherBuilders::And.build([
@@ -34,6 +36,8 @@ module Leftovers
           ::Leftovers::MatcherBuilders::NodePath.build(paths),
           ::Leftovers::MatcherBuilders::NodeHasArgument.build(has_arguments),
           ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver),
+          ::Leftovers::MatcherBuilders::NodePrivacy.build(privacy),
+          ::Leftovers::MatcherBuilders::NodeType.build(type),
           ::Leftovers::MatcherBuilders::Unless.build(
             (::Leftovers::MatcherBuilders::Node.build(unless_arg) if unless_arg)
           )

data/lib/leftovers/matcher_builders/node_privacy.rb

@@ -0,0 +1,13 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodePrivacy
+      def self.build(privacy_settings)
+        ::Leftovers::MatcherBuilders::Or.each_or_self(privacy_settings) do |privacy|
+          ::Leftovers::Matchers::NodePrivacy.new(privacy)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_type.rb

@@ -14,12 +14,12 @@ module Leftovers
           when 'Float' then ::Leftovers::Matchers::NodeType.new(:float)
           when 'Array' then ::Leftovers::Matchers::NodeType.new(:array)
           when 'Hash' then ::Leftovers::Matchers::NodeType.new(:hash)
-
           when 'Proc' then ::Leftovers::Matchers::Predicate.new(:proc?)
-          # when 'Method' then ::Leftovers::Matchers::NodeType.new(Set[:send, :csend, :def])
-          # when 'Constant' then ::Leftovers::Matchers::NodeType.new(Set[:const, :class, :module])
+          when 'Method' then ::Leftovers::Matchers::NodeType.new(Set[:send, :csend, :def, :defs])
+          when 'Constant'
+            ::Leftovers::Matchers::NodeType.new(Set[:const, :class, :module, :casgn])
           # :nocov:
-          else raise
+          else raise "Unknown type #{type}"
             # :nocov:
           end
         end

data/lib/leftovers/matcher_builders/node_value.rb

@@ -7,7 +7,7 @@ module Leftovers
         def build(pattern) # rubocop:disable Metrics/MethodLength
           ::Leftovers::MatcherBuilders::Or.each_or_self(pattern) do |pat|
             case pat
-            when ::Integer, true, false, nil
+            when ::Integer, ::Float, true, false, nil
               ::Leftovers::Matchers::NodeScalarValue.new(pat)
             when ::String
               ::Leftovers::MatcherBuilders::NodeName.build(pat)

data/lib/leftovers/matcher_builders/string_pattern.rb

@@ -3,15 +3,24 @@
 module Leftovers
   module MatcherBuilders
     module StringPattern
-      def self.build(match: nil, has_prefix: nil, has_suffix: nil)
-        if match
+      def self.build(match: nil, has_prefix: nil, has_suffix: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        has_prefix = ::Regexp.escape(has_prefix) if has_prefix
+        has_suffix = ::Regexp.escape(has_suffix) if has_suffix
+
+        if match && has_prefix && has_suffix
+          /\A(?=#{match}\z)(?=#{has_prefix}).*#{has_suffix}\z/
+        elsif match && has_prefix
+          /\A(?=#{match}\z)#{has_prefix}/
+        elsif match && has_suffix
+          /\A(?=#{match}\z).*#{has_suffix}\z/
+        elsif match
           /\A#{match}\z/
         elsif has_prefix && has_suffix
-          /\A#{::Regexp.escape(has_prefix)}.*#{::Regexp.escape(has_suffix)}\z/
+          /\A(?=#{has_prefix}).*#{has_suffix}\z/
         elsif has_prefix
-          /\A#{::Regexp.escape(has_prefix)}/
+          /\A#{has_prefix}/
         elsif has_suffix
-          /#{::Regexp.escape(has_suffix)}\z/
+          /#{has_suffix}\z/
         end
       end
     end

data/lib/leftovers/matcher_builders.rb

@@ -15,6 +15,7 @@ module Leftovers
     autoload(:NodePairName, "#{__dir__}/matcher_builders/node_pair_name")
     autoload(:NodePairValue, "#{__dir__}/matcher_builders/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matcher_builders/node_path")
+    autoload(:NodePrivacy, "#{__dir__}/matcher_builders/node_privacy")
     autoload(:NodeType, "#{__dir__}/matcher_builders/node_type")
     autoload(:NodeValue, "#{__dir__}/matcher_builders/node_value")
     autoload(:Or, "#{__dir__}/matcher_builders/or")

data/lib/leftovers/matchers/node_privacy.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodePrivacy
+      def initialize(privacy_matcher)
+        @privacy_matcher = privacy_matcher
+
+        freeze
+      end
+
+      def ===(node)
+        @privacy_matcher === node.privacy
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers.rb

@@ -19,6 +19,7 @@ module Leftovers
     autoload(:NodeName, "#{__dir__}/matchers/node_name")
     autoload(:NodePairValue, "#{__dir__}/matchers/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matchers/node_path")
+    autoload(:NodePrivacy, "#{__dir__}/matchers/node_privacy")
     autoload(:NodeScalarValue, "#{__dir__}/matchers/node_scalar_value")
     autoload(:NodeType, "#{__dir__}/matchers/node_type")
     autoload(:Not, "#{__dir__}/matchers/not")

data/lib/leftovers/merged_config.rb

@@ -4,7 +4,7 @@ require 'set'
 require 'fast_ignore'
 
 module Leftovers
-  class MergedConfig # rubocop:disable Metrics/ClassLength
+  class MergedConfig
     def initialize(load_defaults: false)
       @configs = []
       @loaded_configs = Set.new
@@ -24,9 +24,7 @@ module Leftovers
       @configs << config
       @loaded_configs << config.name
       config.gems.each { |gem| self << gem }
-      config.requires.each do |req|
-        Leftovers.try_require(req, message: "cannot require '#{req}' from #{config.name}.yml")
-      end
+      require_requires(config)
     end
 
     def project_config
@@ -66,51 +64,27 @@ module Leftovers
     end
 
     def test_paths
-      @test_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:test_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+      @test_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:test_paths))
     end
 
     def haml_paths
-      @haml_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:haml_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+      @haml_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:haml_paths))
     end
 
     def slim_paths
-      @slim_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:slim_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+      @slim_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:slim_paths))
     end
 
     def yaml_paths
-      @yaml_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:yaml_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+      @yaml_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:yaml_paths))
     end
 
     def json_paths
-      @json_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:json_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+      @json_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:json_paths))
     end
 
     def erb_paths
-      @erb_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:erb_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+      @erb_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:erb_paths))
     end
 
     def dynamic
@@ -127,6 +101,16 @@ module Leftovers
 
     private
 
+    def require_requires(config)
+      config.requires.each do |req|
+        if req.is_a?(Hash) && req[:quiet]
+          Leftovers.try_require(req[:quiet])
+        else
+          Leftovers.try_require(req, message: "cannot require '#{req}' from #{config.name}.yml")
+        end
+      end
+    end
+
     def load_bundled_gem_config
       return unless Leftovers.try_require('bundler')