leftovers 0.5.4 → 0.7.0

data/lib/leftovers/merged_config.rb

@@ -24,9 +24,7 @@ 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
+      require_requires(config)
     end
 
     def project_config
@@ -43,6 +41,8 @@ module Leftovers
       @test_paths
       @haml_paths
       @slim_paths
+      @yaml_paths
+      @json_paths
       @erb_paths
       @dynamic
       @keep
@@ -64,35 +64,27 @@ module Leftovers
     end
 
     def test_paths
-      @test_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:test_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+      @test_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:test_paths))
     end
 
     def haml_paths
-      @haml_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:haml_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+      @haml_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:haml_paths))
     end
 
     def slim_paths
-      @slim_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:slim_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+      @slim_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:slim_paths))
+    end
+
+    def yaml_paths
+      @yaml_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:yaml_paths))
+    end
+
+    def json_paths
+      @json_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:json_paths))
     end
 
     def erb_paths
-      @erb_paths ||= FastIgnore.new(
-        include_rules: @configs.flat_map(&:erb_paths),
-        gitignore: false,
-        root: Leftovers.pwd
-      )
+      @erb_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:erb_paths))
     end
 
     def dynamic
@@ -109,6 +101,16 @@ module Leftovers
 
     private
 
+    def require_requires(config)
+      config.requires.each do |req|
+        if req.is_a?(Hash) && req[:quiet]
+          Leftovers.try_require(req[:quiet])
+        else
+          Leftovers.try_require(req, message: "cannot require '#{req}' from #{config.name}.yml")
+        end
+      end
+    end
+
     def load_bundled_gem_config
       return unless Leftovers.try_require('bundler')
 

data/lib/leftovers/processor_builders/add_prefix.rb

@@ -6,7 +6,7 @@ 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)

data/lib/leftovers/processor_builders/add_suffix.rb

@@ -6,7 +6,7 @@ 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)

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)
+
+          ::Leftovers::ProcessorBuilders::EachDynamic.build([
+            build_call_define_processor(matcher, call, define),
+            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, define) # rubocop:disable Metrics/MethodLength
+          call_action = build_action(call, return_type: :sym)
+          define_action = build_action(define, return_type: :definition_node)
+
+          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/transform.rb

@@ -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)

data/lib/leftovers/processor_builders/transform_set.rb

@@ -21,24 +21,24 @@ module Leftovers
 
       def self.each_builder(action)
         case action
-        when :call
+        when :sym
           ::Leftovers::ProcessorBuilders::Each
-        when :define
+        when :definition_node
           ::Leftovers::ProcessorBuilders::EachForDefinitionSet
         # :nocov:
-        else raise
+        else raise "Unknown action #{action}"
           # :nocov:
         end
       end
 
       def self.build_final(action)
         case action
-        when :call
-          ::Leftovers::ValueProcessors::ReturnString
-        when :define
-          ::Leftovers::ValueProcessors::ReturnDefinition
+        when :sym
+          ::Leftovers::ValueProcessors::ReturnSym
+        when :definition_node
+          ::Leftovers::ValueProcessors::ReturnDefinitionNode
         # :nocov:
-        else raise
+        else raise "Unknown action #{action}"
           # :nocov:
         end
       end

data/lib/leftovers/todo_reporter.rb

@@ -64,54 +64,29 @@ module Leftovers
     end
 
     def todo_data(only_test, none)
-      none_test = none.select(&:test?)
-      none_non_test = none.reject(&:test?)
       [
-        test_only_data(none_test),
-        keep_data(only_test, none_non_test)
+        list_data(
+          :test_only, 'Only directly called in tests', only_test
+        ),
+        list_data(
+          :keep, 'Not directly called at all', none
+        )
       ].compact.join
     end
 
-    def test_only_data(list)
+    def list_data(key, title, list)
       return if list.empty?
 
       <<~YML
-        test_only:
-        #{generate_list('Defined in tests:', list).chomp}
-      YML
-    end
-
-    def keep_data(only_test, none_non_test)
-      return if only_test.empty? && none_non_test.empty?
-
-      <<~YML.chomp
-        keep:
-        #{keep_test_called_data(only_test)}#{keep_never_called_data(none_non_test)}
-      YML
-    end
-
-    def keep_test_called_data(list)
-      return if list.empty?
-
-      generate_list('Only directly called in tests:', list)
-    end
-
-    def keep_never_called_data(list)
-      return if list.empty?
-
-      generate_list('Not directly called at all:', list)
-    end
-
-    def generate_list(title, list)
-      <<~YML
-          # #{title}
+        #{key}:
+          # #{title}:
         #{print_definition_list(list)}
 
       YML
     end
 
     def print_definition_list(definition_list)
-      definition_list.map { |definition| print_definition(definition) }.join("\n")
+      definition_list.map { |definition| print_definition(definition) }.sort.join("\n")
     end
 
     def print_definition(definition)

data/lib/leftovers/value_processors/delete_prefix.rb

@@ -3,12 +3,6 @@
 module Leftovers
   module ValueProcessors
     class DeletePrefix
-      # :nocov:
-      if defined?(::Leftovers::Backports::StringDeletePrefixSuffix)
-        using ::Leftovers::Backports::StringDeletePrefixSuffix
-      end
-      # :nocov:
-
       def initialize(prefix, then_processor)
         @prefix = prefix
         @then_processor = then_processor

data/lib/leftovers/value_processors/delete_suffix.rb

@@ -3,12 +3,6 @@
 module Leftovers
   module ValueProcessors
     class DeleteSuffix
-      # :nocov:
-      if defined?(::Leftovers::Backports::StringDeletePrefixSuffix)
-        using ::Leftovers::Backports::StringDeletePrefixSuffix
-      end
-      # :nocov:
-
       def initialize(suffix, then_processor)
         @suffix = suffix
         @then_processor = then_processor

data/lib/leftovers/value_processors/each_for_definition_set.rb

@@ -11,10 +11,7 @@ module Leftovers
 
       def process(str, node, method_node)
         definitions = @then_processors.map do |then_processor|
-          processed = then_processor.process(str, node, method_node)
-          return if processed == :keep # rubocop:disable Lint/NonLocalExitFromIterator
-
-          processed
+          then_processor.process(str, node, method_node)
         end
 
         definitions.flatten!
@@ -22,7 +19,7 @@ module Leftovers
 
         return definitions.first if definitions.length <= 1
 
-        ::Leftovers::DefinitionSet.new(definitions)
+        ::Leftovers::DefinitionNodeSet.new(definitions)
       end
     end
   end

data/lib/leftovers/value_processors/each_positional_argument.rb

@@ -14,7 +14,7 @@ module Leftovers
         return unless positional_arguments
 
         positional_arguments.map do |argument_node|
-          str = argument_node.to_s if argument_node.string_or_symbol?
+          str = argument_node.to_s if argument_node.string_or_symbol_or_def?
 
           @then_processor.process(str, argument_node, method_node)
         end

data/lib/leftovers/value_processors/keyword.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module ValueProcessors
     class Keyword
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher, then_processor)
         @matcher = matcher
         @then_processor = then_processor

data/lib/leftovers/value_processors/keyword_argument.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module ValueProcessors
     class KeywordArgument
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher, then_processor)
         @matcher = matcher
         @then_processor = then_processor

data/lib/leftovers/value_processors/return_definition_node.rb

@@ -0,0 +1,14 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ValueProcessors
+    module ReturnDefinitionNode
+      def self.process(str, node, _method_node)
+        return unless str
+        return if str.empty?
+
+        Leftovers::DefinitionNode.new(node, name: str.to_sym)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/{return_string.rb → return_sym.rb}

@@ -2,7 +2,7 @@
 
 module Leftovers
   module ValueProcessors
-    module ReturnString
+    module ReturnSym
       def self.process(str, _node, _method_node)
         return unless str
         return if str.empty?

data/lib/leftovers/value_processors.rb

@@ -28,8 +28,8 @@ module Leftovers
     autoload(:Pluralize, "#{__dir__}/value_processors/pluralize")
     autoload(:PositionalArgument, "#{__dir__}/value_processors/positional_argument")
     autoload(:ReplaceValue, "#{__dir__}/value_processors/replace_value")
-    autoload(:ReturnDefinition, "#{__dir__}/value_processors/return_definition")
-    autoload(:ReturnString, "#{__dir__}/value_processors/return_string")
+    autoload(:ReturnDefinitionNode, "#{__dir__}/value_processors/return_definition_node")
+    autoload(:ReturnSym, "#{__dir__}/value_processors/return_sym")
     autoload(:Singularize, "#{__dir__}/value_processors/singularize")
     autoload(:Split, "#{__dir__}/value_processors/split")
     autoload(:Swapcase, "#{__dir__}/value_processors/swapcase")

data/lib/leftovers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leftovers
-  VERSION = '0.5.4'
+  VERSION = '0.7.0'
 end

data/lib/leftovers/yaml.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Leftovers
+  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
+        <<~RUBY
+          __leftovers_document(#{to_ruby_argument(root.to_ruby.first)})
+          #{@constants.join("\n")}
+        RUBY
+      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, name)
+      builder = ::Leftovers::YAML::Builder.new
+      parser = ::Psych::Parser.new(builder)
+      parser.parse(yaml, name.relative_path)
+
+      builder.to_ruby_file
+    rescue ::Psych::SyntaxError => e
+      Leftovers.warn "#{e.class}: #{e.message}"
+      ''
+    end
+  end
+end

data/lib/leftovers.rb

@@ -4,19 +4,22 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
   class Error < ::StandardError; end
 
   autoload(:AST, "#{__dir__}/leftovers/ast")
-  autoload(:Backports, "#{__dir__}/leftovers/backports")
   autoload(:CLI, "#{__dir__}/leftovers/cli")
   autoload(:Collector, "#{__dir__}/leftovers/collector")
-  autoload(:ConfigValidator, "#{__dir__}/leftovers/config_validator")
+  autoload(:ConfigLoader, "#{__dir__}/leftovers/config_loader")
   autoload(:Config, "#{__dir__}/leftovers/config")
+  autoload(:Definition, "#{__dir__}/leftovers/definition")
   autoload(:DefinitionNode, "#{__dir__}/leftovers/definition_node")
+  autoload(:DefinitionNodeSet, "#{__dir__}/leftovers/definition_node_set")
   autoload(:DefinitionSet, "#{__dir__}/leftovers/definition_set")
-  autoload(:Definition, "#{__dir__}/leftovers/definition")
+  autoload(:DefinitionToAdd, "#{__dir__}/leftovers/definition_to_add")
   autoload(:ERB, "#{__dir__}/leftovers/erb")
   autoload(:FileCollector, "#{__dir__}/leftovers/file_collector")
   autoload(:FileList, "#{__dir__}/leftovers/file_list")
   autoload(:File, "#{__dir__}/leftovers/file")
   autoload(:Haml, "#{__dir__}/leftovers/haml")
+  autoload(:YAML, "#{__dir__}/leftovers/yaml")
+  autoload(:JSON, "#{__dir__}/leftovers/json")
   autoload(:MatcherBuilders, "#{__dir__}/leftovers/matcher_builders")
   autoload(:Matchers, "#{__dir__}/leftovers/matchers")
   autoload(:MergedConfig, "#{__dir__}/leftovers/merged_config")
@@ -30,6 +33,19 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
   autoload(:ValueProcessors, "#{__dir__}/leftovers/value_processors")
   autoload(:VERSION, "#{__dir__}/leftovers/version")
 
+  MEMOIZED_IVARS = %i{
+    @config
+    @collector
+    @reporter
+    @leftovers
+    @try_require_cache
+    @stdout
+    @stderr
+    @parallel
+    @pwd
+    @progress
+  }.freeze
+
   class << self
     attr_accessor :parallel, :progress
     attr_writer :reporter
@@ -81,16 +97,10 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
       reporter.report(only_test: only_test, none: none)
     end
 
-    def reset # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-      remove_instance_variable(:@config) if defined?(@config)
-      remove_instance_variable(:@collector) if defined?(@collector)
-      remove_instance_variable(:@reporter) if defined?(@reporter)
-      remove_instance_variable(:@leftovers) if defined?(@leftovers)
-      remove_instance_variable(:@try_require_cache) if defined?(@try_require_cache)
-      remove_instance_variable(:@stdout) if defined?(@stdout)
-      remove_instance_variable(:@stderr) if defined?(@stderr)
-      remove_instance_variable(:@parallel) if defined?(@parallel)
-      remove_instance_variable(:@pwd) if defined?(@pwd)
+    def reset
+      MEMOIZED_IVARS.each do |ivar|
+        remove_instance_variable(ivar) if instance_variable_get(ivar)
+      end
     end
 
     def resolution_instructions_link
@@ -102,7 +112,7 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
     end
 
     def error(message)
-      warn(message)
+      warn("\e[31m#{message}\e[0m")
       exit 1
     end
 
@@ -136,7 +146,7 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
 
       case value
       when nil then nil
-      when Array then value.each(&block)
+      when Array then value.each { |i| each_or_self(i, &block) }
       else yield(value)
       end
     end
@@ -147,12 +157,10 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
       @try_require_cache ||= {}
 
       @try_require_cache.fetch(requirable) do
-        begin
-          require requirable
-          @try_require_cache[requirable] = true
-        rescue LoadError
-          @try_require_cache[requirable] = false
-        end
+        require requirable
+        @try_require_cache[requirable] = true
+      rescue LoadError
+        @try_require_cache[requirable] = false
       end
     end
   end