leftovers 0.7.0 → 0.8.0

data/lib/leftovers/precompilers.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Precompilers
+    autoload(:ERB, "#{__dir__}/precompilers/erb")
+    autoload(:Haml, "#{__dir__}/precompilers/haml")
+    autoload(:JSON, "#{__dir__}/precompilers/json")
+    autoload(:Precompiler, "#{__dir__}/precompilers/precompiler")
+    autoload(:Slim, "#{__dir__}/precompilers/slim")
+    autoload(:YAML, "#{__dir__}/precompilers/yaml")
+
+    class << self
+      def build(precompilers)
+        precompilers.group_by { |p| build_precompiler(p[:format]) }.map do |format, precompiler|
+          Precompiler.new(
+            format,
+            Leftovers::MatcherBuilders::Path.build(precompiler.flat_map { |p| p[:paths] })
+          )
+        end
+      end
+
+      private
+
+      def build_precompiler(format)
+        case format
+        when 'erb' then ::Leftovers::Precompilers::ERB
+        when 'haml' then ::Leftovers::Precompilers::Haml
+        when 'json' then ::Leftovers::Precompilers::JSON
+        when 'slim' then ::Leftovers::Precompilers::Slim
+        when 'yaml' then ::Leftovers::Precompilers::YAML
+        when Hash then constantize_precompiler(format[:custom])
+          # :nocov:
+        else raise Leftovers::UnexpectedCase, "Unhandled value #{format}"
+          # :nocov:
+        end
+      end
+
+      def constantize_precompiler(precompiler)
+        precompiler = "::#{precompiler}" unless precompiler.start_with?('::')
+
+        Object.const_get(precompiler, false)
+      rescue ::NameError
+        Leftovers.error <<~MESSAGE
+          Tried using #{precompiler}, but it wasn't available.
+          add its path to `requires:` in your .leftovers.yml
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/action.rb

@@ -3,60 +3,69 @@
 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
+      class << self
+        def 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 then build_from_hash_value(action, **pattern)
             # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{pattern.inspect}"
+              # :nocov:
+            end
           end
         end
-      end
 
-      def self.final_transformer(action)
-        ::Leftovers::ProcessorBuilders::TransformSet.build_final(action)
-      end
+        private
 
-      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([
+        def final_transformer(action)
+          ::Leftovers::ProcessorBuilders::TransformSet.build_final(action)
+        end
+
+        def build_nested(nested, transformer, action)
+          ::Leftovers::ProcessorBuilders::Each.build([
             ::Leftovers::ProcessorBuilders::Action.build(nested, action),
             transformer
           ])
         end
 
-        if recursive
+        def build_processor(arguments, keywords, itself, value, transformer)
+          ::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)
+          ])
+        end
+
+        def build_recursive(transformer)
           placeholder = ::Leftovers::ValueProcessors::Placeholder.new
-          transformer = ::Leftovers::ProcessorBuilders::Each.build(
-            [placeholder, transformer]
-          )
+          transformer = ::Leftovers::ProcessorBuilders::Each.build([placeholder, transformer])
+
+          [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)
-        ])
+        def build_from_hash_value( # rubocop:disable 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)
+          transformer = build_nested(nested, transformer, action) if nested
+          placeholder, transformer = build_recursive(transformer) if recursive
+          processor = build_processor(arguments, keywords, itself, value, transformer)
 
-        return processor unless recursive
+          return processor unless recursive
 
-        placeholder.processor = processor
-        placeholder
+          placeholder.processor = processor
+          placeholder
+        end
       end
     end
   end

data/lib/leftovers/processor_builders/add_prefix.rb

@@ -11,7 +11,7 @@ module Leftovers
         when ::String
           ::Leftovers::ValueProcessors::AddPrefix.new(argument, then_processor)
           # :nocov:
-        else raise
+        else raise Leftovers::UnexpectedCase, "Unhandled value #{argument.inspect}"
           # :nocov:
         end
       end

data/lib/leftovers/processor_builders/add_suffix.rb

@@ -11,7 +11,7 @@ module Leftovers
         when ::String
           ::Leftovers::ValueProcessors::AddSuffix.new(argument, then_processor)
           # :nocov:
-        else raise
+        else raise Leftovers::UnexpectedCase, "Unhandled value #{argument.inspect}"
           # :nocov:
         end
       end

data/lib/leftovers/processor_builders/argument.rb

@@ -3,19 +3,16 @@
 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)
+      def self.build(patterns, processor)
+        ::Leftovers::ProcessorBuilders::EachAction.each_or_self(patterns) do |pat|
+          case pat
+          when ::Integer then ::Leftovers::ValueProcessors::PositionalArgument.new(pat, processor)
+          when '*' then ::Leftovers::ValueProcessors::EachPositionalArgument.new(processor)
+          when '**' then ::Leftovers::ValueProcessors::EachKeywordArgument.new(processor)
           when ::String, ::Hash
-            ::Leftovers::ProcessorBuilders::KeywordArgument.build(pattern, then_processor)
+            ::Leftovers::ProcessorBuilders::KeywordArgument.build(pat, processor)
             # :nocov:
-          else raise
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{pat.inspect}"
             # :nocov:
           end
         end

data/lib/leftovers/processor_builders/dynamic.rb

@@ -17,8 +17,11 @@ module Leftovers
         )
           matcher = ::Leftovers::MatcherBuilders::Node.build(**matcher_rules)
 
+          call_action = build_action(call, return_type: :sym)
+          define_action = build_action(define, return_type: :definition_node)
+
           ::Leftovers::ProcessorBuilders::EachDynamic.build([
-            build_call_define_processor(matcher, call, define),
+            build_call_define_processor(matcher, call_action, define_action),
             build_set_privacy_processor(matcher, set_privacy),
             build_set_default_privacy_processor(matcher, set_default_privacy)
           ])
@@ -41,10 +44,7 @@ module Leftovers
           ::Leftovers::DynamicProcessors::SetDefaultPrivacy.new(matcher, set_default_privacy)
         end
 
-        def build_call_define_processor(matcher, call, define) # rubocop:disable Metrics/MethodLength
-          call_action = build_action(call, return_type: :sym)
-          define_action = build_action(define, return_type: :definition_node)
-
+        def build_call_define_processor(matcher, call_action, define_action)
           if call_action && define_action
             # this nonsense saves a method call and array instantiation per method
             ::Leftovers::DynamicProcessors::CallDefinition.new(matcher, call_action, define_action)

data/lib/leftovers/processor_builders/each.rb

@@ -6,7 +6,7 @@ module Leftovers
       def self.each_or_self(value, &block)
         case value
         # :nocov:
-        when nil then raise
+        when nil then raise Leftovers::UnexpectedCase, "Unhandled value #{value.inspect}"
         # :nocov:
         when Array then build(value.map(&block))
         else build([yield(value)])
@@ -18,7 +18,7 @@ module Leftovers
 
         case processors.length
         # :nocov:
-        when 0 then raise
+        when 0 then raise Leftovers::UnexpectedCase, "Unhandled value #{processors.inspect}"
         # :nocov:
         when 1 then processors.first
         else ::Leftovers::ValueProcessors::Each.new(processors)

data/lib/leftovers/processor_builders/each_action.rb

@@ -3,48 +3,48 @@
 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)])
+      class << self
+        def each_or_self(value, &block)
+          case value
+          when nil then nil
+          when Array then build(value.map(&block))
+          else build([yield(value)])
+          end
         end
-      end
 
-      def self.build(processors)
-        processors = compact(processors)
+        def 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)
+          case processors.length
+          # :nocov:
+          when 0 then raise Leftovers::UnexpectedCase, "Unhandled value #{processors.inspect}"
+          # :nocov:
+          when 1 then processors.first
+          else ::Leftovers::ValueProcessors::Each.new(processors)
+          end
         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
+        private
+
+        def flatten(value)
+          case value
+          when ::Leftovers::ValueProcessors::Each
+            value.processors.flat_map { |v| flatten(v) }
+          when Array
+            value.flat_map { |v| flatten(v) }
+          else
+            value
+          end
         end
-      end
 
-      def self.compact(processors)
-        return processors if processors.length <= 1
+        def compact(processors)
+          return processors if processors.length <= 1
 
-        processors = flatten(processors)
-        processors.compact!
+          processors = flatten(processors)
+          processors.compact!
 
-        processors
+          processors
+        end
       end
     end
   end

data/lib/leftovers/processor_builders/each_dynamic.rb

@@ -16,23 +16,19 @@ module Leftovers
 
         case processors.length
         # :nocov:
-        when 0 then raise
+        when 0 then raise Leftovers::UnexpectedCase, "Unhandled value #{processors.inspect}"
         # :nocov:
         when 1 then processors.first
         else ::Leftovers::DynamicProcessors::Each.new(processors)
         end
       end
 
-      def self.flatten(value) # rubocop:disable Metrics/MethodLength
+      def self.flatten(value)
         case value
         when ::Leftovers::DynamicProcessors::Each
-          ret = value.processors.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
+          value.processors.flat_map { |v| flatten(v) }
         when Array
-          ret = value.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
+          value.flat_map { |v| flatten(v) }
         else
           value
         end

data/lib/leftovers/processor_builders/each_for_definition_set.rb

@@ -3,33 +3,37 @@
 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)])
+      class << self
+        def each_or_self(value, &block)
+          case value
+          # :nocov:
+          when nil then raise Leftovers::UnexpectedCase, "Unhandled value #{value.inspect}"
+          # :nocov:
+          when Array then build(value.map(&block))
+          else build([yield(value)])
+          end
         end
-      end
 
-      def self.build(processors)
-        processors = compact(processors)
+        def 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)
+          case processors.length
+          # :nocov:
+          when 0 then raise Leftovers::UnexpectedCase, "Unhandled value #{processors.inspect}"
+          # :nocov:
+          when 1 then processors.first
+          else ::Leftovers::ValueProcessors::EachForDefinitionSet.new(processors)
+          end
         end
-      end
 
-      def self.compact(processors)
-        processors.flatten!
-        processors.compact!
+        private
 
-        processors
+        def compact(processors)
+          processors.flatten!
+          processors.compact!
+
+          processors
+        end
       end
     end
   end

data/lib/leftovers/processor_builders/keyword.rb

@@ -3,19 +3,18 @@
 module Leftovers
   module ProcessorBuilders
     module Keyword
-      def self.build(value, then_processor) # rubocop:disable Metrics/MethodLength
+      def self.build(value, then_processor)
         return unless value && then_processor
 
         case value
-        when true, '**'
-          ::Leftovers::ValueProcessors::EachKeyword.new(then_processor)
+        when true, '**' then ::Leftovers::ValueProcessors::EachKeyword.new(then_processor)
         when ::String, ::Hash, ::Array
           ::Leftovers::ValueProcessors::Keyword.new(
             ::Leftovers::MatcherBuilders::NodePairName.build(value),
             then_processor
           )
         # :nocov:
-        else raise
+        else raise Leftovers::UnexpectedCase, "Unhandled value #{value.inspect}"
           # :nocov:
         end
       end

data/lib/leftovers/processor_builders/transform.rb

@@ -3,7 +3,7 @@
 module Leftovers
   module ProcessorBuilders
     module Transform
-      def self.build(transform, argument, then_processor) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+      def self.build(transform, argument, then_processor) # rubocop:disable Metrics
         case transform.to_s
         when 'original', nil
           then_processor
@@ -46,7 +46,7 @@ module Leftovers
         when 'delete_suffix'
           ::Leftovers::ValueProcessors::DeleteSuffix.new(argument, then_processor)
         # :nocov:
-        else raise
+        else raise Leftovers::UnexpectedCase, "Unhandled value #{transform.to_s.inspect}"
           # :nocov:
         end
       end

data/lib/leftovers/processor_builders/transform_chain.rb

@@ -3,20 +3,28 @@
 module Leftovers
   module ProcessorBuilders
     module TransformChain
-      def self.build(transforms, next_transform) # rubocop:disable Metrics/MethodLength
-        case transforms
-        when ::Hash
+      class << self
+        def build(transforms, next_transform)
+          case transforms
+          when ::Hash then build_from_hash(transforms, next_transform)
+          when ::String
+            ::Leftovers::ProcessorBuilders::Transform.build(transforms, true, next_transform)
+          # :nocov:
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{transforms.inspect}"
+            # :nocov:
+          end
+        end
+
+        private
+
+        def build_from_hash(transforms, next_transform)
           transforms.reverse_each do |(transform, transform_arg)|
             next_transform = ::Leftovers::ProcessorBuilders::Transform.build(
               transform, transform_arg, next_transform
             )
           end
+
           next_transform
-        when ::String
-          ::Leftovers::ProcessorBuilders::Transform.build(transforms, true, next_transform)
-        # :nocov:
-        else raise
-          # :nocov:
         end
       end
     end

data/lib/leftovers/processor_builders/transform_set.rb

@@ -3,43 +3,47 @@
 module Leftovers
   module ProcessorBuilders
     module TransformSet
-      def self.build(transforms, action)
-        each_builder(action).each_or_self(transforms) do |transform|
-          case transform
-          when ::Hash
-            next build(transform[:transforms], action) if transform[:transforms]
+      class << self
+        def build(transforms, action)
+          each_builder(action).each_or_self(transforms) do |transform|
+            case transform
+            when ::Hash
+              next build(transform[:transforms], action) if transform[:transforms]
 
-            ::Leftovers::ProcessorBuilders::TransformChain.build(transform, build_final(action))
-          when ::String
-            ::Leftovers::ProcessorBuilders::TransformChain.build(transform, build_final(action))
-          # :nocov:
-          else raise
+              ::Leftovers::ProcessorBuilders::TransformChain.build(transform, build_final(action))
+            when ::String
+              ::Leftovers::ProcessorBuilders::TransformChain.build(transform, build_final(action))
             # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{transform.inspect}"
+              # :nocov:
+            end
           end
         end
-      end
 
-      def self.each_builder(action)
-        case action
-        when :sym
-          ::Leftovers::ProcessorBuilders::Each
-        when :definition_node
-          ::Leftovers::ProcessorBuilders::EachForDefinitionSet
-        # :nocov:
-        else raise "Unknown action #{action}"
+        def build_final(action)
+          case action
+          when :sym
+            ::Leftovers::ValueProcessors::ReturnSym
+          when :definition_node
+            ::Leftovers::ValueProcessors::ReturnDefinitionNode
           # :nocov:
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{action.inspect}"
+            # :nocov:
+          end
         end
-      end
 
-      def self.build_final(action)
-        case action
-        when :sym
-          ::Leftovers::ValueProcessors::ReturnSym
-        when :definition_node
-          ::Leftovers::ValueProcessors::ReturnDefinitionNode
-        # :nocov:
-        else raise "Unknown action #{action}"
+        private
+
+        def each_builder(action)
+          case action
+          when :sym
+            ::Leftovers::ProcessorBuilders::Each
+          when :definition_node
+            ::Leftovers::ProcessorBuilders::EachForDefinitionSet
           # :nocov:
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{action.inspect}"
+            # :nocov:
+          end
         end
       end
     end

data/lib/leftovers/rake_task.rb

@@ -8,7 +8,7 @@ module Leftovers
   class RakeTask
     include ::Rake::DSL
 
-    def self.generate_task(name = :leftovers, *default_argv) # rubocop:disable
+    def self.generate_task(name = :leftovers, *default_argv)
       new(name, default_argv)
 
       name

data/lib/leftovers/value_processors/add_dynamic_prefix.rb

@@ -10,20 +10,13 @@ module Leftovers
         freeze
       end
 
-      def process(str, node, method_node) # rubocop:disable Metrics/MethodLength
+      def process(str, node, method_node)
         return unless str
 
         prefixes = @prefix_processor.process(nil, method_node, method_node)
-        if prefixes.is_a?(Array)
-          prefixes.flatten!
-          prefixes.compact!
-          prefixes.uniq!
 
-          prefixes.map do |prefix|
-            @then_processor.process("#{prefix}#{str}", node, method_node)
-          end
-        else
-          @then_processor.process("#{prefixes}#{str}", node, method_node)
+        Leftovers.map_or_self(prefixes) do |prefix|
+          @then_processor.process("#{prefix}#{str}", node, method_node)
         end
       end
     end

data/lib/leftovers/value_processors/add_dynamic_suffix.rb

@@ -10,20 +10,13 @@ module Leftovers
         freeze
       end
 
-      def process(str, node, method_node) # rubocop:disable Metrics/MethodLength
+      def process(str, node, method_node)
         return unless str
 
         suffixes = @suffix_processor.process(nil, method_node, method_node)
-        if suffixes.is_a?(Array)
-          suffixes.flatten!
-          suffixes.compact!
-          suffixes.uniq!
 
-          suffixes.map do |suffix|
-            @then_processor.process("#{str}#{suffix}", node, method_node)
-          end
-        else
-          @then_processor.process("#{str}#{suffixes}", node, method_node)
+        Leftovers.map_or_self(suffixes) do |suffix|
+          @then_processor.process("#{str}#{suffix}", node, method_node)
         end
       end
     end

data/lib/leftovers/value_processors/each.rb

@@ -12,7 +12,7 @@ module Leftovers
       end
 
       def process(str, node, method_node)
-        @processors.flat_map do |processor|
+        Leftovers.map_or_self(@processors) do |processor|
           processor.process(str, node, method_node)
         end
       end