leftovers 0.5.5 → 0.8.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,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

@@ -6,12 +6,12 @@ module Leftovers
       def self.build(argument, then_processor)
         case argument
         when ::Hash
-          dynamic_prefix = ::Leftovers::ProcessorBuilders::Action.build(argument, :call)
+          dynamic_prefix = ::Leftovers::ProcessorBuilders::Action.build(argument, :sym)
           ::Leftovers::ValueProcessors::AddDynamicPrefix.new(dynamic_prefix, then_processor)
         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

@@ -6,12 +6,12 @@ module Leftovers
       def self.build(argument, then_processor)
         case argument
         when ::Hash
-          dynamic_suffix = ::Leftovers::ProcessorBuilders::Action.build(argument, :call)
+          dynamic_suffix = ::Leftovers::ProcessorBuilders::Action.build(argument, :sym)
           ::Leftovers::ValueProcessors::AddDynamicSuffix.new(dynamic_suffix, then_processor)
         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

@@ -3,22 +3,57 @@
 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::EachDynamic.each_or_self(dynamic_rules) do |dynamic|
+            build_processors(**dynamic)
+          end
+        end
+
+        private
+
+        def build_processors(
+          call: nil, define: nil, set_privacy: nil, set_default_privacy: nil, **matcher_rules
+        )
+          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_action, define_action),
+            build_set_privacy_processor(matcher, set_privacy),
+            build_set_default_privacy_processor(matcher, set_default_privacy)
+          ])
+        end
+
+        def build_action(processor_rules, return_type:)
+          ::Leftovers::ProcessorBuilders::Action.build(processor_rules, return_type)
+        end
+
+        def build_set_privacy_processor(matcher, set_privacy)
+          ::Leftovers::ProcessorBuilders::EachDynamic.each_or_self(set_privacy) do |action_values|
+            to = action_values.delete(:to)
+            action = build_action(action_values, return_type: :sym)
+
+            ::Leftovers::DynamicProcessors::SetPrivacy.new(matcher, action, to)
+          end
+        end
+
+        def build_set_default_privacy_processor(matcher, set_default_privacy)
+          ::Leftovers::DynamicProcessors::SetDefaultPrivacy.new(matcher, set_default_privacy)
+        end
+
+        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)
+          elsif define_action
+            ::Leftovers::DynamicProcessors::Definition.new(matcher, define_action)
+          elsif call_action
+            ::Leftovers::DynamicProcessors::Call.new(matcher, call_action)
+          else
+            ::Leftovers::DynamicProcessors::Null
           end
         end
       end

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
@@ -19,9 +19,9 @@ module Leftovers
           ::Leftovers::ValueProcessors::Pluralize.new(then_processor)
         when 'singularize'
           ::Leftovers::ValueProcessors::Singularize.new(then_processor)
-        when 'camelize', 'camelcase'
+        when 'camelize'
           ::Leftovers::ValueProcessors::Camelize.new(then_processor)
-        when 'titleize', 'titlecase'
+        when 'titleize'
           ::Leftovers::ValueProcessors::Titleize.new(then_processor)
         when 'demodulize'
           ::Leftovers::ValueProcessors::Demodulize.new(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