leftovers 0.3.0 → 0.4.0

data/lib/leftovers/merged_config.rb

@@ -1,20 +1,21 @@
 # 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
+      return unless load_defaults
+
       self << :ruby
       self << project_config
       load_bundled_gem_config
     end
 
-    def <<(config) # rubocop:disable Metrics/MethodLength
+    def <<(config)
       config = Leftovers::Config.new(config) unless config.is_a?(Leftovers::Config)
       return if @loaded_configs.include?(config.name)
 
@@ -22,6 +23,9 @@ 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
     end
 
     def project_config
@@ -32,7 +36,8 @@ module Leftovers
       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
@@ -51,12 +56,12 @@ module Leftovers
       )
     end
 
-    def skip_rules
-      @skip_rules ||= rules.select(&:skip?)
+    def dynamic
+      @dynamic ||= ::Leftovers::ProcessorBuilders::EachDynamic.build(@configs.map(&:dynamic))
     end
 
-    def rules
-      @rules ||= @configs.flat_map(&:rules)
+    def keep
+      @keep ||= ::Leftovers::MatcherBuilders::Or.build(@configs.map(&:keep))
     end
 
     private

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

data/lib/leftovers/processor_builders/each_dynamic.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module EachDynamic
+      def self.each_or_self(value, &block)
+        case value
+        when nil then ::Leftovers::DynamicProcessors::Null
+        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::DynamicProcessors::Each.new(processors)
+        end
+      end
+
+      def self.flatten(value) # rubocop:disable Metrics/MethodLength
+        case value
+        when ::Leftovers::DynamicProcessors::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.reject! do |p|
+          p == ::Leftovers::DynamicProcessors::Null
+        end
+
+        processors
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/each_for_definition_set.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module EachForDefinitionSet
+      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::EachForDefinitionSet.new(processors)
+        end
+      end
+
+      def self.compact(processors)
+        processors.flatten!
+        processors.compact!
+
+        processors
+      end
+    end
+  end
+end