leftovers 0.5.4 → 0.7.0

data/lib/leftovers/config_loader/schema.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class Schema
+      class << self
+        def error(node, requirement)
+          node.error = "#{node.name_}must #{requirement}"
+        end
+
+        def validate(node)
+          node.valid?
+        end
+
+        def to_ruby(node)
+          node.to_ruby
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/string_enum_schema.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class StringEnumSchema < Schema
+      class << self
+        def value(value, aliases: nil)
+          values << value
+          Leftovers.each_or_self(aliases) do |alias_name|
+            self.aliases[alias_name] = value
+          end
+        end
+
+        def aliases
+          @aliases ||= {}
+        end
+
+        def aliases_for(value)
+          aliases.select { |_k, v| v == value }.keys
+        end
+
+        def values
+          @values ||= []
+        end
+
+        def each_value(&block)
+          @values.each(&block)
+        end
+
+        def to_ruby(node)
+          aliases[node.to_sym]&.to_s || node.to_ruby
+        end
+
+        def validate(node)
+          if node.string?
+            node.error = error_message_with_suggestions(node) unless valid_value?(node.to_sym)
+          else
+            error(node, 'be a string')
+          end
+
+          super
+        end
+
+        private
+
+        def valid_value?(val)
+          values.include?(val) || aliases.key?(val)
+        end
+
+        def suggester
+          @suggester ||= Suggester.new(values)
+        end
+
+        def error_message_with_suggestions(node)
+          suggestions = suggester.suggest(node.to_ruby)
+
+          "unrecognized value #{node} for #{node.name}\nDid you mean: #{suggestions.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/string_pattern_schema.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class StringPatternSchema < ObjectSchema
+      attribute :match, StringSchema, aliases: :matches, require_group: :matcher
+      attribute :has_prefix, StringSchema, require_group: :matcher
+      attribute :has_suffix, StringSchema, require_group: :matcher
+      attribute :unless, ValueOrArraySchema[StringPatternSchema], require_group: :matcher
+
+      self.or_schema = StringSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/string_schema.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class StringSchema < Schema
+      class << self
+        def validate(node)
+          error(node, 'be a string') unless node.string?
+          super
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/string_value_processor_schema.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class StringValueProcessorSchema < ObjectSchema
+      inherit_attributes_from ValueProcessorSchema
+
+      self.or_schema = StringSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/suggester.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class Suggester
+      def initialize(words)
+        @words = words
+        @did_you_mean = ::DidYouMean::SpellChecker.new(dictionary: words) if defined?(::DidYouMean)
+      end
+
+      def suggest(word)
+        suggestions = did_you_mean.correct(word) if did_you_mean
+        suggestions = words if !suggestions || suggestions.empty?
+        suggestions
+      end
+
+      private
+
+      attr_reader :words, :did_you_mean
+    end
+  end
+end

data/lib/leftovers/config_loader/transform_schema.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class TransformSchema < ObjectSchema
+      ArgumentlessTransformSchema.each_value do |transform|
+        attribute(
+          transform, TrueSchema,
+          aliases: ArgumentlessTransformSchema.aliases_for(transform),
+          require_group: :processor
+        )
+      end
+
+      attribute :add_prefix, ValueOrArraySchema[StringValueProcessorSchema],
+                require_group: :processor
+      attribute :add_suffix, ValueOrArraySchema[StringValueProcessorSchema],
+                require_group: :processor
+
+      attribute :split, StringSchema, require_group: :processor
+      attribute :delete_prefix, StringSchema, require_group: :processor
+      attribute :delete_suffix, StringSchema, require_group: :processor
+      attribute :delete_before, StringSchema, require_group: :processor
+      attribute :delete_after, StringSchema, require_group: :processor
+
+      self.or_schema = ArgumentlessTransformSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/true_schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class TrueSchema < Schema
+      class << self
+        def validate(node)
+          error(node, 'be true') unless to_ruby(node)
+          super
+        end
+
+        def to_ruby(node)
+          node.to_ruby == true || node.to_ruby == 'true'
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/value_matcher_schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ValueMatcherSchema < ObjectSchema
+      attribute :arguments, ValueOrArraySchema[ArgumentPositionSchema], aliases: :argument,
+        require_group: :matcher
+      attribute :keywords, ValueOrArraySchema[StringPatternSchema], aliases: :keyword,
+        require_group: :matcher
+      attribute :itself, TrueSchema, require_group: :matcher
+      attribute :nested, ValueOrArraySchema[ValueMatcherSchema]
+      attribute :value, StringSchema, require_group: :matcher
+      attribute :recursive, TrueSchema
+
+      self.or_schema = ScalarArgumentSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/value_or_array_schema.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ValueOrArraySchema < Schema
+      class << self
+        def [](value_schema)
+          new(value_schema)
+        end
+      end
+
+      attr_reader :value_schema
+
+      def initialize(value_schema)
+        @value_schema = value_schema
+
+        super()
+      end
+
+      def validate(node)
+        if node.array?
+          validate_length(node) && validate_values(node)
+        else
+          validate_or_schema(node)
+        end
+      end
+
+      def to_ruby(node)
+        if node.array?
+          node.children.map do |value|
+            value_schema.to_ruby(value)
+          end
+        else
+          value_schema.to_ruby(node)
+        end
+      end
+
+      private
+
+      def validate_or_schema(node)
+        value_schema.validate(node)
+        return true if node.valid?
+
+        node.error += ' or an array'
+
+        false
+      end
+
+      def validate_length(node)
+        self.class.error(node, 'not be empty') if node.children.empty?
+
+        node.valid?
+      end
+
+      def validate_values(node)
+        node.children.each do |value|
+          value_schema.validate(value)
+        end
+
+        node.children.all?(&:valid?)
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/value_processor_schema.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ValueProcessorSchema < ObjectSchema
+      inherit_attributes_from ValueMatcherSchema
+
+      attribute :transforms, ValueOrArraySchema[TransformSchema]
+      inherit_attributes_from TransformSchema, require_group: nil
+
+      self.or_schema = ScalarArgumentSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/value_type_schema.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ValueTypeSchema < StringEnumSchema
+      value :String
+      value :Symbol
+      value :Integer
+      value :Float
+      value :Array
+      value :Hash
+      value :Proc
+      value :Method
+      value :Constant
+    end
+  end
+end

data/lib/leftovers/config_loader.rb

@@ -0,0 +1,82 @@
+# frozen-string-literal: true
+
+require 'yaml'
+require 'leftovers'
+
+module Leftovers
+  class ConfigLoader
+    autoload(:ArgumentPositionSchema, "#{__dir__}/config_loader/argument_position_schema")
+    autoload(:ArgumentlessTransformSchema, "#{__dir__}/config_loader/argumentless_transform_schema")
+    autoload(:Attribute, "#{__dir__}/config_loader/attribute")
+    autoload(:DocumentSchema, "#{__dir__}/config_loader/document_schema")
+    autoload(:DynamicSchema, "#{__dir__}/config_loader/dynamic_schema")
+    autoload(:HasArgumentSchema, "#{__dir__}/config_loader/has_argument_schema")
+    autoload(:HasValueSchema, "#{__dir__}/config_loader/has_value_schema")
+    autoload(:KeepTestOnlySchema, "#{__dir__}/config_loader/keep_test_only_schema")
+    autoload(:Node, "#{__dir__}/config_loader/node")
+    autoload(:ObjectSchema, "#{__dir__}/config_loader/object_schema")
+    autoload(:PrivacyProcessorSchema, "#{__dir__}/config_loader/privacy_processor_schema")
+    autoload(:PrivacySchema, "#{__dir__}/config_loader/privacy_schema")
+    autoload(:RequireSchema, "#{__dir__}/config_loader/require_schema")
+    autoload(:RulePatternSchema, "#{__dir__}/config_loader/rule_pattern_schema")
+    autoload(:ScalarArgumentSchema, "#{__dir__}/config_loader/scalar_argument_schema")
+    autoload(:ScalarValueSchema, "#{__dir__}/config_loader/scalar_value_schema")
+    autoload(:Schema, "#{__dir__}/config_loader/schema")
+    autoload(:Suggester, "#{__dir__}/config_loader/suggester")
+    autoload(:StringEnumSchema, "#{__dir__}/config_loader/string_enum_schema")
+    autoload(:StringPatternSchema, "#{__dir__}/config_loader/string_pattern_schema")
+    autoload(:StringSchema, "#{__dir__}/config_loader/string_schema")
+    autoload(:StringValueProcessorSchema, "#{__dir__}/config_loader/string_value_processor_schema")
+    autoload(:TransformSchema, "#{__dir__}/config_loader/transform_schema")
+    autoload(:TrueSchema, "#{__dir__}/config_loader/true_schema")
+    autoload(:ValueMatcherSchema, "#{__dir__}/config_loader/value_matcher_schema")
+    autoload(:ValueOrArraySchema, "#{__dir__}/config_loader/value_or_array_schema")
+    autoload(:ValueProcessorSchema, "#{__dir__}/config_loader/value_processor_schema")
+    autoload(:ValueTypeSchema, "#{__dir__}/config_loader/value_type_schema")
+
+    def self.load(name, path: nil, content: nil)
+      new(name, path: path, content: content).load
+    end
+
+    attr_reader :name
+
+    def initialize(name, path: nil, content: nil)
+      @name = name
+      @path = path
+      @content = content
+    end
+
+    def load
+      document = ::Leftovers::ConfigLoader::Node.new(parse, file)
+      DocumentSchema.validate(document)
+
+      all_errors = document.all_errors
+      return DocumentSchema.to_ruby(document) if all_errors.empty?
+
+      Leftovers.error(all_errors.join("\n"))
+    end
+
+    private
+
+    def path
+      @path ||= ::File.expand_path("../config/#{name}.yml", __dir__)
+    end
+
+    def file
+      @file ||= ::Leftovers::File.new(path)
+    end
+
+    def content
+      @content ||= file.exist? ? file.read : ''
+    end
+
+    def parse
+      parsed = Psych.parse(content)
+      parsed ||= Psych.parse('{}')
+      parsed.children.first
+    rescue ::Psych::SyntaxError => e
+      message = [e.problem, e.context].compact.join(' ')
+      Leftovers.error "Config SyntaxError: #{file.relative_path}:#{e.line}:#{e.column} #{message}"
+    end
+  end
+end

data/lib/leftovers/definition.rb

@@ -10,7 +10,7 @@ module Leftovers
     def initialize(
       name,
       location: method_node.loc.expression,
-      test: method_node.test_line?
+      test: method_node.test_line? || ::Leftovers.config.test_only === method_node
     )
       @name = name
       @path = location.source_buffer.name.to_s

data/lib/leftovers/definition_node.rb

@@ -1,19 +1,15 @@
 # frozen-string-literal: true
 
-# To give to matchers before creating a Definition
-
 module Leftovers
   class DefinitionNode
-    attr_reader :path, :name
+    attr_reader :name, :loc, :node
 
-    def initialize(name, path)
+    def initialize(node, name:, location: node.loc.expression)
+      @node = node
       @name = name
-      @path = path
-
-      freeze
+      @loc = location
     end
 
-    # these are the methods checked by things in lib/leftovers/matchers
     def kwargs
       nil
     end
@@ -22,15 +18,8 @@ module Leftovers
       nil
     end
 
-    # these two i'm not sure are possible with the current config flags
-    # :nocov:
-    def scalar?
-      false
-    end
-
-    def type
-      :leftovers_definition
+    def path
+      node.path
     end
-    # :nocov:
   end
 end

data/lib/leftovers/definition_node_set.rb

@@ -0,0 +1,11 @@
+# frozen-string-literal: true
+
+module Leftovers
+  class DefinitionNodeSet
+    attr_reader :definitions
+
+    def initialize(definitions)
+      @definitions = definitions
+    end
+  end
+end

data/lib/leftovers/definition_to_add.rb

@@ -0,0 +1,31 @@
+# frozen-string-literal: true
+
+module Leftovers
+  class DefinitionToAdd
+    attr_reader :node, :name, :location
+
+    def initialize(node, name: node.name, location: node.loc.name)
+      @node = node
+      @name = name
+      @location = location
+    end
+
+    def privacy=(value)
+      @node.privacy = value
+    end
+
+    def keep?(file_collector)
+      @keep ||= file_collector.keep_line?(location.line) || ::Leftovers.config.keep === node
+    end
+
+    def test?(file_collector)
+      file_collector.test_line?(location.line) || ::Leftovers.config.test_only === node
+    end
+
+    def to_definition(file_collector)
+      return if keep?(file_collector)
+
+      Leftovers::Definition.new(name, location: location, test: test?(file_collector))
+    end
+  end
+end

data/lib/leftovers/dynamic_processors/call.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module DynamicProcessors
     class Call
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher, processor)
         @matcher = matcher
         @processor = processor
@@ -15,10 +11,11 @@ module Leftovers
       def process(node, file)
         return unless @matcher === node
 
-        call = @processor.process(nil, node, node)
-        return unless call
+        calls = @processor.process(nil, node, node)
 
-        file.calls << call
+        ::Leftovers.each_or_self(calls) do |call|
+          file.calls << call
+        end
       end
     end
   end

data/lib/leftovers/dynamic_processors/call_definition.rb

@@ -3,28 +3,31 @@
 module Leftovers
   module DynamicProcessors
     class CallDefinition
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher, call_processor, definition_processor)
         @matcher = matcher
         @call_processor = call_processor
         @definition_processor = definition_processor
       end
 
-      def process(node, file)
+      def process(node, file) # rubocop:disable Metrics/MethodLength
         return unless @matcher === node
 
-        call = @call_processor.process(nil, node, node)
-        (file.calls << call) if call
+        calls = @call_processor.process(nil, node, node)
 
-        return if node.keep_line?
+        ::Leftovers.each_or_self(calls) do |call|
+          file.calls << call
+        end
 
-        definition = @definition_processor.process(nil, node, node)
-        return unless definition
+        return if node.keep_line?
 
-        file.definitions << definition
+        definitions = @definition_processor.process(nil, node, node)
+        ::Leftovers.each_or_self(definitions) do |definition|
+          if definition.is_a?(DefinitionNodeSet)
+            file.add_definition_set(definition)
+          else
+            file.add_definition(definition, loc: definition.loc)
+          end
+        end
       end
     end
   end

data/lib/leftovers/dynamic_processors/definition.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module DynamicProcessors
     class Definition
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher, processor)
         @matcher = matcher
         @processor = processor
@@ -16,10 +12,15 @@ module Leftovers
         return if node.keep_line?
         return unless @matcher === node
 
-        definition = @processor.process(nil, node, node)
-        return unless definition
+        definitions = @processor.process(nil, node, node)
 
-        file.definitions << definition
+        ::Leftovers.each_or_self(definitions) do |definition|
+          if definition.is_a?(DefinitionNodeSet)
+            file.add_definition_set(definition)
+          else
+            file.add_definition(definition, loc: definition.loc)
+          end
+        end
       end
     end
   end

data/lib/leftovers/dynamic_processors/set_default_privacy.rb

@@ -0,0 +1,18 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    class SetDefaultPrivacy
+      def initialize(matcher, to)
+        @matcher = matcher
+        @to = to
+      end
+
+      def process(node, file)
+        return unless @matcher === node
+
+        file.default_method_privacy = @to
+      end
+    end
+  end
+end

data/lib/leftovers/dynamic_processors/set_privacy.rb

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    class SetPrivacy
+      def initialize(matcher, processor, to)
+        @matcher = matcher
+        @processor = processor
+        @to = to
+      end
+
+      def process(node, file)
+        return unless @matcher === node
+
+        set_privacy = @processor.process(nil, node, node)
+
+        ::Leftovers.each_or_self(set_privacy) do |name|
+          file.set_privacy(name, @to)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/dynamic_processors.rb

@@ -7,5 +7,7 @@ module Leftovers
     autoload(:Definition, "#{__dir__}/dynamic_processors/definition")
     autoload(:Each, "#{__dir__}/dynamic_processors/each")
     autoload(:Null, "#{__dir__}/dynamic_processors/null")
+    autoload(:SetDefaultPrivacy, "#{__dir__}/dynamic_processors/set_default_privacy")
+    autoload(:SetPrivacy, "#{__dir__}/dynamic_processors/set_privacy")
   end
 end