leftovers 0.2.3 → 0.4.3

data/lib/leftovers/matchers/node_type.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodeType
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(type_matcher)
+        @type_matcher = type_matcher
+
+        freeze
+      end
+
+      def ===(node)
+        @type_matcher === node.type
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/not.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class Not
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(matcher)
+        @matcher = matcher
+
+        freeze
+      end
+
+      def ===(value)
+        !(@matcher === value)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/or.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class Or
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      attr_reader :lhs, :rhs
+
+      def initialize(lhs, rhs)
+        @lhs = lhs
+        @rhs = rhs
+
+        freeze
+      end
+
+      def ===(value)
+        @lhs === value || @rhs === value
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/merged_config.rb

@@ -1,37 +1,48 @@
 # frozen_string_literal: true
 
 require 'set'
-require_relative 'config'
 require 'fast_ignore'
 
 module Leftovers
   class MergedConfig
-    def initialize
+    def initialize(load_defaults: false)
       @configs = []
       @loaded_configs = Set.new
-      self.<< Leftovers::Config.new(:ruby)
-      self.<< project_config
+      return unless load_defaults
+
+      self << :ruby
+      self << project_config
+      self << project_todo
       load_bundled_gem_config
     end
 
     def <<(config)
+      config = Leftovers::Config.new(config) unless config.is_a?(Leftovers::Config)
       return if @loaded_configs.include?(config.name)
 
       unmemoize
       @configs << config
       @loaded_configs << config.name
-      config.gems.each { |gem| self.<< Leftovers::Config.new(gem) }
+      config.gems.each { |gem| self << gem }
+      config.requires.each do |req|
+        Leftovers.try_require(req, message: "cannot require '#{req}' from #{config.name}.yml")
+      end
     end
 
     def project_config
       Leftovers::Config.new(:'.leftovers.yml', path: Leftovers.pwd + '.leftovers.yml')
     end
 
+    def project_todo
+      Leftovers::Config.new(:'.leftovers_todo.yml', path: Leftovers.pwd + '.leftovers_todo.yml')
+    end
+
     def unmemoize
       remove_instance_variable(:@exclude_paths) if defined?(@exclude_paths)
       remove_instance_variable(:@include_paths) if defined?(@include_paths)
       remove_instance_variable(:@test_paths) if defined?(@test_paths)
-      remove_instance_variable(:@rules) if defined?(@rules)
+      remove_instance_variable(:@dynamic) if defined?(@dynamic)
+      remove_instance_variable(:@keep) if defined?(@keep)
     end
 
     def exclude_paths
@@ -45,26 +56,30 @@ module Leftovers
     def test_paths
       @test_paths ||= FastIgnore.new(
         include_rules: @configs.flat_map(&:test_paths),
-        gitignore: false
+        gitignore: false,
+        root: Leftovers.pwd
       )
     end
 
-    def skip_rules
-      @skip_rules ||= rules.select(&:skip?)
+    def dynamic
+      @dynamic ||= ::Leftovers::ProcessorBuilders::EachDynamic.build(@configs.map(&:dynamic))
+    end
+
+    def keep
+      @keep ||= ::Leftovers::MatcherBuilders::Or.build(@configs.map(&:keep))
     end
 
-    def rules
-      @rules ||= @configs.flat_map(&:rules)
+    def test_only
+      @test_only ||= ::Leftovers::MatcherBuilders::Or.build(@configs.map(&:test_only))
     end
 
     private
 
     def load_bundled_gem_config
-      Leftovers.try_require('bundler')
-      return unless defined?(Bundler)
+      return unless Leftovers.try_require('bundler')
 
       Bundler.locked_gems.specs.each do |spec|
-        self.<< Leftovers::Config.new(spec.name.to_sym)
+        self << spec.name
       end
     end
   end

data/lib/leftovers/parser.rb

@@ -3,9 +3,6 @@
 require 'parser'
 require 'parser/current'
 
-require_relative 'ast/builder'
-require_relative 'ast/node'
-
 module Leftovers
   module Parser
     class << self
@@ -23,7 +20,7 @@ module Leftovers
 
       # mostly copied from https://github.com/whitequark/parser/blob/master/lib/parser/base.rb
       # but with our builder
-      def parser # rubocop:disable Metrics/MethodLength
+      def parser
         p = ::Parser::CurrentRuby.new(Leftovers::AST::Builder.new)
         p.diagnostics.all_errors_are_fatal = true
         p.diagnostics.ignore_warnings = true

data/lib/leftovers/processor_builders.rb

@@ -0,0 +1,22 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    autoload(:Action, "#{__dir__}/processor_builders/action")
+    autoload(:AddPrefix, "#{__dir__}/processor_builders/add_prefix")
+    autoload(:AddSuffix, "#{__dir__}/processor_builders/add_suffix")
+    autoload(:Argument, "#{__dir__}/processor_builders/argument")
+    autoload(:Dynamic, "#{__dir__}/processor_builders/dynamic")
+    autoload(:EachAction, "#{__dir__}/processor_builders/each_action")
+    autoload(:EachDynamic, "#{__dir__}/processor_builders/each_dynamic")
+    autoload(:EachForDefinitionSet, "#{__dir__}/processor_builders/each_for_definition_set")
+    autoload(:Each, "#{__dir__}/processor_builders/each")
+    autoload(:Itself, "#{__dir__}/processor_builders/itself")
+    autoload(:Keyword, "#{__dir__}/processor_builders/keyword")
+    autoload(:KeywordArgument, "#{__dir__}/processor_builders/keyword_argument")
+    autoload(:TransformChain, "#{__dir__}/processor_builders/transform_chain")
+    autoload(:TransformSet, "#{__dir__}/processor_builders/transform_set")
+    autoload(:Transform, "#{__dir__}/processor_builders/transform")
+    autoload(:Value, "#{__dir__}/processor_builders/value")
+  end
+end

data/lib/leftovers/processor_builders/action.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module Action
+      def self.build(patterns, action)
+        ::Leftovers::ProcessorBuilders::EachAction.each_or_self(patterns) do |pattern|
+          case pattern
+          when ::String, ::Integer
+            ::Leftovers::ProcessorBuilders::Argument.build(pattern, final_transformer(action))
+          when ::Hash
+            build_from_hash_value(action, **pattern)
+          # :nocov:
+          else raise
+            # :nocov:
+          end
+        end
+      end
+
+      def self.final_transformer(action)
+        ::Leftovers::ProcessorBuilders::TransformSet.build_final(action)
+      end
+
+      def self.build_from_hash_value( # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+        action,
+        arguments: nil,
+        keywords: nil,
+        itself: nil,
+        value: nil,
+        nested: nil,
+        recursive: nil,
+        **transform_args
+      )
+        transformer = ::Leftovers::ProcessorBuilders::TransformSet.build(transform_args, action)
+        if nested
+          transformer = ::Leftovers::ProcessorBuilders::Each.build([
+            ::Leftovers::ProcessorBuilders::Action.build(nested, action),
+            transformer
+          ])
+        end
+
+        if recursive
+          placeholder = ::Leftovers::ValueProcessors::Placeholder.new
+          transformer = ::Leftovers::ProcessorBuilders::Each.build(
+            [placeholder, transformer]
+          )
+        end
+
+        processor = ::Leftovers::ProcessorBuilders::EachAction.build([
+          ::Leftovers::ProcessorBuilders::Argument.build(arguments, transformer),
+          ::Leftovers::ProcessorBuilders::Keyword.build(keywords, transformer),
+          ::Leftovers::ProcessorBuilders::Itself.build(itself, transformer),
+          ::Leftovers::ProcessorBuilders::Value.build(value, transformer)
+        ])
+
+        return processor unless recursive
+
+        placeholder.processor = processor
+        placeholder
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/add_prefix.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module AddPrefix
+      def self.build(argument, then_processor)
+        case argument
+        when ::Hash
+          dynamic_prefix = ::Leftovers::ProcessorBuilders::Action.build(argument, :call)
+          ::Leftovers::ValueProcessors::AddDynamicPrefix.new(dynamic_prefix, then_processor)
+        when ::String
+          ::Leftovers::ValueProcessors::AddPrefix.new(argument, then_processor)
+          # :nocov:
+        else raise
+          # :nocov:
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/add_suffix.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module AddSuffix
+      def self.build(argument, then_processor)
+        case argument
+        when ::Hash
+          dynamic_suffix = ::Leftovers::ProcessorBuilders::Action.build(argument, :call)
+          ::Leftovers::ValueProcessors::AddDynamicSuffix.new(dynamic_suffix, then_processor)
+        when ::String
+          ::Leftovers::ValueProcessors::AddSuffix.new(argument, then_processor)
+          # :nocov:
+        else raise
+          # :nocov:
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/argument.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module Argument
+      def self.build(patterns, then_processor) # rubocop:disable Metrics/MethodLength
+        ::Leftovers::ProcessorBuilders::EachAction.each_or_self(patterns) do |pattern|
+          case pattern
+          when ::Integer
+            ::Leftovers::ValueProcessors::PositionalArgument.new(pattern, then_processor)
+          when '*'
+            ::Leftovers::ValueProcessors::EachPositionalArgument.new(then_processor)
+          when '**'
+            ::Leftovers::ValueProcessors::EachKeywordArgument.new(then_processor)
+          when ::String, ::Hash
+            ::Leftovers::ProcessorBuilders::KeywordArgument.build(pattern, then_processor)
+            # :nocov:
+          else raise
+            # :nocov:
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/dynamic.rb

@@ -0,0 +1,27 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module Dynamic
+      def self.build(dynamic_rules) # rubocop:disable Metrics/MethodLength
+        ::Leftovers::ProcessorBuilders::EachDynamic.each_or_self(dynamic_rules) do |dynamic|
+          call = ::Leftovers::ProcessorBuilders::Action.build(dynamic.delete(:call), :call)
+          define = ::Leftovers::ProcessorBuilders::Action.build(dynamic.delete(:define), :define)
+          matcher = ::Leftovers::MatcherBuilders::Node.build(**dynamic)
+
+          # this nonsense saves a method call and array instantiation per method
+          if call && define
+            ::Leftovers::DynamicProcessors::CallDefinition.new(matcher, call, define)
+          elsif define
+            ::Leftovers::DynamicProcessors::Definition.new(matcher, define)
+          elsif call
+            ::Leftovers::DynamicProcessors::Call.new(matcher, call)
+          # :nocov:
+          else raise
+            # :nocov:
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/each.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module Each
+      def self.each_or_self(value, &block)
+        case value
+        # :nocov:
+        when nil then raise
+        # :nocov:
+        when Array then build(value.map(&block))
+        else build([yield(value)])
+        end
+      end
+
+      def self.build(processors)
+        processors = compact(processors)
+
+        case processors.length
+        # :nocov:
+        when 0 then raise
+        # :nocov:
+        when 1 then processors.first
+        else ::Leftovers::ValueProcessors::Each.new(processors)
+        end
+      end
+
+      def self.compact(processors)
+        processors.flatten!
+        processors.compact!
+
+        processors
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/each_action.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module EachAction
+      def self.each_or_self(value, &block)
+        case value
+        when nil then nil
+        when Array then build(value.map(&block))
+        else build([yield(value)])
+        end
+      end
+
+      def self.build(processors)
+        processors = compact(processors)
+
+        case processors.length
+        # :nocov:
+        when 0 then raise
+        # :nocov:
+        when 1 then processors.first
+        else ::Leftovers::ValueProcessors::Each.new(processors)
+        end
+      end
+
+      def self.flatten(value) # rubocop:disable Metrics/MethodLength
+        case value
+        when ::Leftovers::ValueProcessors::Each
+          ret = value.processors.map { |v| flatten(v) }
+          ret.flatten!(1)
+          ret
+        when Array
+          ret = value.map { |v| flatten(v) }
+          ret.flatten!(1)
+          ret
+        else
+          value
+        end
+      end
+
+      def self.compact(processors)
+        return processors if processors.length <= 1
+
+        processors = flatten(processors)
+        processors.compact!
+
+        processors
+      end
+    end
+  end
+end