leftovers 0.6.0 → 0.9.0

data/lib/leftovers/precompilers/yaml.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Leftovers
+  module Precompilers
+    module YAML
+      class Builder < ::Psych::TreeBuilder
+        def initialize
+          @constants = []
+
+          super
+        end
+
+        def add_constant_for_tag(tag, value = nil)
+          match = %r{\A!ruby/[^:]*(?::(.*))?\z}.match(tag)
+          return unless match
+
+          @constants << (match[1] || value)
+        end
+
+        def start_mapping(_anchor, tag, *rest) # leftovers:keep
+          add_constant_for_tag(tag)
+          tag = nil
+
+          super
+        end
+
+        def start_sequence(_anchor, tag, *rest) # leftovers:keep
+          add_constant_for_tag(tag)
+          tag = nil
+
+          super
+        end
+
+        def scalar(value, _anchor, tag, *rest) # leftovers:keep
+          add_constant_for_tag(tag, value)
+          tag = nil
+
+          super
+        end
+
+        def to_ruby_file
+          <<~FILE
+            __leftovers_document(#{to_ruby_argument(root.to_ruby.first)})
+            #{@constants.join("\n")}
+          FILE
+        end
+
+        private
+
+        def to_ruby_argument(value)
+          ruby = value.inspect
+          return ruby unless value.is_a?(Array)
+
+          ruby.delete_prefix!('[')
+          ruby.delete_suffix!(']')
+
+          ruby
+        end
+      end
+
+      def self.precompile(yaml)
+        builder = ::Leftovers::Precompilers::YAML::Builder.new
+        parser = ::Psych::Parser.new(builder)
+        parser.parse(yaml)
+
+        builder.to_ruby_file
+      rescue ::Psych::SyntaxError => e
+        message = [e.problem, e.context].compact.join(' ')
+        raise ::Leftovers::PrecompileError.new(message, line: e.line, column: e.column)
+      end
+    end
+  end
+end

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,87 @@
 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, final_processor)
+          ::Leftovers::ProcessorBuilders::Each.each_or_self(patterns) do |pattern|
+            case pattern
+            when ::String, ::Integer
+              ::Leftovers::ProcessorBuilders::Argument.build(pattern, final_processor)
+            when ::Hash then build_from_hash_value(**pattern, final_processor: final_processor)
             # :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
+        def build_from_hash_value( # rubocop:disable Metrics/ParameterLists
+          final_processor:,
+          arguments: nil,
+          keywords: nil,
+          itself: nil,
+          receiver: nil,
+          value: nil,
+          nested: nil,
+          recursive: nil,
+
+          has_arguments: nil,
+          has_receiver: nil,
+          unless_arg: nil, all: nil, any: nil,
+          **transform_args
+        )
+          processor = ::Leftovers::ProcessorBuilders::TransformSet.build(
+            transform_args, final_processor
+          )
+          processor = build_nested(nested, processor) if nested
+          recursive_placeholder, processor = build_recursive(processor) if recursive
+          processor = build_sources(arguments, keywords, itself, receiver, value, processor)
+          processor = build_matcher(has_arguments, has_receiver, unless_arg, all, any, processor)
+          return processor unless recursive
+
+          recursive_placeholder.processor = processor
+          recursive_placeholder
+        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([
-            ::Leftovers::ProcessorBuilders::Action.build(nested, action),
-            transformer
+        def build_nested(nested, processor)
+          ::Leftovers::ProcessorBuilders::Each.build([
+            ::Leftovers::ProcessorBuilders::Action.build(nested, processor),
+            processor
           ])
         end
 
-        if recursive
-          placeholder = ::Leftovers::ValueProcessors::Placeholder.new
-          transformer = ::Leftovers::ProcessorBuilders::Each.build(
-            [placeholder, transformer]
-          )
+        def build_sources(arguments, keywords, itself, receiver, value, processor) # rubocop:disable Metrics/ParameterLists
+          ::Leftovers::ProcessorBuilders::Each.build([
+            ::Leftovers::ProcessorBuilders::Argument.build(arguments, processor),
+            ::Leftovers::ProcessorBuilders::Keyword.build(keywords, processor),
+            ::Leftovers::ProcessorBuilders::Itself.build(itself, processor),
+            ::Leftovers::ProcessorBuilders::Receiver.build(receiver, processor),
+            ::Leftovers::ProcessorBuilders::Value.build(value, processor)
+          ])
         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_recursive(processor)
+          recursive_placeholder = ::Leftovers::Processors::Placeholder.new
+          processor = ::Leftovers::ProcessorBuilders::Each.build([recursive_placeholder, processor])
 
-        return processor unless recursive
+          [recursive_placeholder, processor]
+        end
 
-        placeholder.processor = processor
-        placeholder
+        def build_matcher(has_arguments, has_receiver, unless_arg, all, any, processor) # rubocop:disable Metrics/ParameterLists
+          matcher = Leftovers::MatcherBuilders::Node.build_from_hash(
+            has_arguments: has_arguments,
+            has_receiver: has_receiver,
+            unless_arg: unless_arg,
+            all: all,
+            any: any
+          )
+
+          return processor unless matcher
+
+          ::Leftovers::Processors::MatchMatchedNode.new(matcher, processor)
+        end
       end
     end
   end

data/lib/leftovers/processor_builders/add_prefix.rb

@@ -3,16 +3,24 @@
 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:
+      class << self
+        def build(argument, then_processor)
+          case argument
+          when ::Hash then build_hash(argument, then_processor)
+          when ::String then ::Leftovers::Processors::AddPrefix.new(argument, then_processor)
+            # :nocov:
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{argument.inspect}"
+            # :nocov:
+          end
+        end
+
+        private
+
+        def build_hash(argument, then_processor)
+          dynamic_prefix = ::Leftovers::ProcessorBuilders::Action.build(
+            argument, ::Leftovers::Processors::AppendSym
+          )
+          ::Leftovers::Processors::AddDynamicPrefix.new(dynamic_prefix, then_processor)
         end
       end
     end

data/lib/leftovers/processor_builders/add_suffix.rb

@@ -3,16 +3,24 @@
 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:
+      class << self
+        def build(argument, then_processor)
+          case argument
+          when ::Hash then build_hash(argument, then_processor)
+          when ::String then ::Leftovers::Processors::AddSuffix.new(argument, then_processor)
+            # :nocov:
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{argument.inspect}"
+            # :nocov:
+          end
+        end
+
+        private
+
+        def build_hash(argument, then_processor)
+          dynamic_suffix = ::Leftovers::ProcessorBuilders::Action.build(
+            argument, ::Leftovers::Processors::AppendSym
+          )
+          ::Leftovers::Processors::AddDynamicSuffix.new(dynamic_suffix, then_processor)
         end
       end
     end

data/lib/leftovers/processor_builders/argument.rb

@@ -3,22 +3,36 @@
 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:
+      class << self
+        def build(patterns, processor) # rubocop:disable Metrics/MethodLength
+          ::Leftovers::ProcessorBuilders::Each.each_or_self(patterns) do |pat|
+            case pat
+            when ::Integer then ::Leftovers::Processors::PositionalArgument.new(pat, processor)
+            when '*' then ::Leftovers::Processors::EachPositionalArgument.new(processor)
+            when '**' then ::Leftovers::Processors::EachKeywordArgument.new(processor)
+            when /\A(\d+)\+\z/
+              ::Leftovers::Processors::EachPositionalArgumentFrom.new(pat.to_i, processor)
+            when ::String
+              ::Leftovers::ProcessorBuilders::KeywordArgument.build(pat, processor)
+            when ::Hash
+              build_hash(processor, pat)
+              # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{pat.inspect}"
+              # :nocov:
+            end
           end
         end
+
+        private
+
+        def build_hash(then_processor, pat)
+          ::Leftovers::Processors::KeywordArgument.new(
+            ::Leftovers::MatcherBuilders::NodePairKey.build(
+              ::Leftovers::MatcherBuilders::Node.build_from_hash(**pat)
+            ),
+            then_processor
+          )
+        end
       end
     end
   end

data/lib/leftovers/processor_builders/dynamic.rb

@@ -3,25 +3,65 @@
 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:
+      class << self
+        def build(dynamic_rules)
+          ::Leftovers::ProcessorBuilders::Each.each_or_self(dynamic_rules) do |dynamic|
+            build_processors(**dynamic)
           end
         end
+
+        private
+
+        def build_processors( # rubocop:disable Metrics/ParameterLists
+          call: nil, define: nil,
+          set_privacy: nil, set_default_privacy: nil,
+          eval: nil, **matcher_rules
+        )
+          matcher = ::Leftovers::MatcherBuilders::Node.build(**matcher_rules)
+
+          processor = ::Leftovers::ProcessorBuilders::Each.build([
+            build_call_action(call),
+            build_define_action(define),
+            build_set_privacy_action(set_privacy),
+            build_set_default_privacy_action(set_default_privacy),
+            build_eval_action(eval)
+          ])
+
+          ::Leftovers::Processors::MatchMatchedNode.new(matcher, processor)
+        end
+
+        def build_call_action(call)
+          ::Leftovers::ProcessorBuilders::Action.build(
+            call, ::Leftovers::Processors::AddCall
+          )
+        end
+
+        def build_define_action(define)
+          ::Leftovers::ProcessorBuilders::Action.build(
+            define, ::Leftovers::Processors::AddDefinitionNode
+          )
+        end
+
+        def build_eval_action(eval)
+          ::Leftovers::ProcessorBuilders::Action.build(
+            eval, ::Leftovers::Processors::Eval
+          )
+        end
+
+        def build_set_privacy_action(set_privacies)
+          ::Leftovers::ProcessorBuilders::Each.each_or_self(set_privacies) do |set_privacy|
+            processor = ::Leftovers::Processors::SetPrivacy.new(set_privacy.delete(:to))
+            ::Leftovers::ProcessorBuilders::Action.build_from_hash_value(
+              **set_privacy, final_processor: processor
+            )
+          end
+        end
+
+        def build_set_default_privacy_action(set_default_privacy)
+          return unless set_default_privacy
+
+          ::Leftovers::Processors::SetDefaultPrivacy.new(set_default_privacy)
+        end
       end
     end
   end

data/lib/leftovers/processor_builders/each.rb

@@ -2,34 +2,106 @@
 
 module Leftovers
   module ProcessorBuilders
-    module Each
+    class Each
+      def self.build(processors)
+        self[:each].build(processors)
+      end
+
       def self.each_or_self(value, &block)
+        self[:each].each_or_self(value, &block)
+      end
+
+      def self.[](processor_name)
+        @each ||= {
+          each: new(::Leftovers::Processors::Each),
+          each_for_definition_set: new(::Leftovers::Processors::EachForDefinitionSet)
+        }
+
+        @each.fetch(processor_name)
+      end
+
+      def initialize(processor_class = ::Leftovers::Processors::Each)
+        @processor_class = processor_class
+      end
+
+      def each_or_self(value, &block)
         case value
-        # :nocov:
-        when nil then raise
-        # :nocov:
+        when nil then nil
         when Array then build(value.map(&block))
         else build([yield(value)])
         end
       end
 
-      def self.build(processors)
+      def build(processors)
         processors = compact(processors)
 
         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)
+        else @processor_class.new(processors)
         end
       end
 
-      def self.compact(processors)
-        processors.flatten!
-        processors.compact!
+      def flatten(processors)
+        case processors
+        when ::Leftovers::Processors::Each, @processor_class
+          flatten(processors.processors)
+        when Array
+          processors.flat_map { |v| flatten(v) }
+        when ::Leftovers::Processors::MatchCurrentNode, ::Leftovers::Processors::MatchMatchedNode
+          flatten_matchers(processors)
+        else
+          [processors]
+        end
+      end
+
+      def flatten_matchers(processor)
+        then_processors = flatten(processor.then_processor)
+        return [processor] if then_processors.length <= 1
+
+        then_processors.map do |then_processor|
+          processor.class.new(processor.matcher, then_processor)
+        end
+      end
+
+      def compact_matchers_with_same_processor(matchers)
+        matchers.group_by(&:then_processor).map do |then_processor, group|
+          next group.first unless group.length > 1
+
+          group.first.class.new(
+            ::Leftovers::MatcherBuilders::Or.build(group.map(&:matcher)),
+            then_processor
+          )
+        end
+      end
+
+      def compact_matchers_with_same_matcher(matchers)
+        matchers.group_by(&:matcher).map do |matcher, group|
+          next group.first unless group.length > 1
+
+          group.first.class.new(matcher, build(group.map(&:then_processor)))
+        end
+      end
+
+      def compact_matchers(matchers)
+        return [] unless matchers
+
+        matchers = compact_matchers_with_same_processor(matchers)
+        compact_matchers_with_same_matcher(matchers)
+      end
+
+      def compact(processors)
+        processors = flatten(processors).compact
+
+        return processors if processors.length <= 1
+
+        group = processors.group_by(&:class)
 
-        processors
+        compact_matchers(group.delete(::Leftovers::Processors::MatchCurrentNode)) +
+          compact_matchers(group.delete(::Leftovers::Processors::MatchMatchedNode)) +
+          group.values.flatten(1)
       end
     end
   end

data/lib/leftovers/processor_builders/itself.rb

@@ -4,9 +4,9 @@ module Leftovers
   module ProcessorBuilders
     module Itself
       def self.build(value, then_processor)
-        return unless value && then_processor
+        return unless value
 
-        ::Leftovers::ValueProcessors::Itself.new(then_processor)
+        ::Leftovers::Processors::Itself.new(then_processor)
       end
     end
   end

data/lib/leftovers/processor_builders/keyword.rb

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

data/lib/leftovers/processor_builders/keyword_argument.rb

@@ -4,8 +4,10 @@ module Leftovers
   module ProcessorBuilders
     module KeywordArgument
       def self.build(pattern, then_processor)
-        ::Leftovers::ValueProcessors::KeywordArgument.new(
-          ::Leftovers::MatcherBuilders::NodePairName.build(pattern),
+        ::Leftovers::Processors::KeywordArgument.new(
+          ::Leftovers::MatcherBuilders::NodePairKey.build(
+            ::Leftovers::MatcherBuilders::NodeName.build(pattern)
+          ),
           then_processor
         )
       end

data/lib/leftovers/processor_builders/receiver.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module Receiver
+      def self.build(value, then_processor)
+        return unless value
+
+        ::Leftovers::Processors::Receiver.new(then_processor)
+      end
+    end
+  end
+end