leftovers 0.6.0 → 0.9.0

data/lib/leftovers/config_loader/schema.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class Schema
+      class << self
+        def error(node, requirement)
+          node.error = "#{node.name_}must #{requirement}"
+
+          false
+        end
+
+        def validate(node)
+          node.valid?
+        end
+
+        def to_ruby(node)
+          node.to_ruby
+        end
+
+        def ===(other) # leftovers:test_only
+          # :nocov:
+          if other.is_a?(Module)
+            self >= other
+          else
+            other.is_a?(self)
+          end
+          # :nocov:
+        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] || node.to_sym
+        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 < ValueOrObjectSchema
+      attribute :match, RegexpSchema, 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_value_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 < ValueOrObjectSchema
+      inherit_attributes_from ValueProcessorSchema
+
+      self.or_value_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,32 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class TransformSchema < ValueOrObjectSchema
+      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, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :delete_suffix, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :delete_before, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :delete_before_last, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :delete_after, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :delete_after_last, ValueOrArraySchema[StringSchema], require_group: :processor
+      attribute :transforms, ValueOrArraySchema[TransformSchema], require_group: :processor,
+        aliases: :transform
+
+      self.or_value_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_condition_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ValueMatcherConditionSchema < ObjectSchema
+      attribute :has_arguments, ValueOrArraySchema[HasArgumentSchema], aliases: :has_argument
+      attribute :has_receiver, ValueOrArraySchema[HasValueSchema]
+      attribute :unless, ValueOrArraySchema[ValueMatcherConditionSchema]
+      attribute :all, ArraySchema[ValueMatcherConditionSchema]
+      attribute :any, ArraySchema[ValueMatcherConditionSchema]
+    end
+  end
+end

data/lib/leftovers/config_loader/value_matcher_schema.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ValueMatcherSchema < ValueOrObjectSchema
+      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, ValueOrArraySchema[StringSchema], require_group: :matcher, aliases: :values
+      attribute :receiver, TrueSchema, require_group: :matcher
+      attribute :recursive, TrueSchema
+
+      inherit_attributes_from ValueMatcherConditionSchema
+
+      self.or_value_schema = ScalarArgumentSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/value_or_array_schema.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ValueOrArraySchema < ArraySchema
+      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?
+          Leftovers.unwrap_array(super)
+        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
+    end
+  end
+end

data/lib/leftovers/config_loader/value_or_object_schema.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ValueOrObjectSchema < ObjectSchema
+      class << self
+        attr_accessor :or_value_schema
+
+        def validate(node)
+          if node.hash?
+            super(node)
+          else
+            validate_or_value_schema(node)
+          end
+        end
+
+        def to_ruby(node)
+          if node.hash?
+            super
+          else
+            or_value_schema.to_ruby(node)
+          end
+        end
+
+        private
+
+        def validate_or_value_schema(node)
+          or_value_schema.validate(node)
+          return true if node.valid?
+
+          if node.string? && attribute_for_key(node)
+            node.error = "#{node.name_}#{node.to_sym} must be a hash key"
+          else
+            node.error += " or a hash with any of #{suggestions.join(', ')}"
+          end
+        end
+      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 < ValueOrObjectSchema
+      inherit_attributes_from ValueMatcherSchema
+
+      attribute :transforms, ValueOrArraySchema[TransformSchema], aliases: :transform
+      inherit_attributes_from TransformSchema, require_group: nil, except: :transforms
+
+      self.or_value_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,93 @@
+# frozen-string-literal: true
+
+require 'yaml'
+
+module Leftovers
+  class ConfigLoader
+    autoload(:ArgumentlessTransformSchema, "#{__dir__}/config_loader/argumentless_transform_schema")
+    autoload(:ArgumentPositionSchema, "#{__dir__}/config_loader/argument_position_schema")
+    autoload(:ArraySchema, "#{__dir__}/config_loader/array_schema")
+    autoload(:Attribute, "#{__dir__}/config_loader/attribute")
+    autoload(:BuiltInPrecompilerSchema, "#{__dir__}/config_loader/built_in_precompiler_schema")
+    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(:InheritSchemaAttributes, "#{__dir__}/config_loader/inherit_schema_attributes")
+    autoload(:KeepTestOnlySchema, "#{__dir__}/config_loader/keep_test_only_schema")
+    autoload(:KeywordArgumentSchema, "#{__dir__}/config_loader/keyword_argument_schema")
+    autoload(:Node, "#{__dir__}/config_loader/node")
+    autoload(:ObjectSchema, "#{__dir__}/config_loader/object_schema")
+    autoload(:PrecompilerSchema, "#{__dir__}/config_loader/precompiler_schema")
+    autoload(:PrecompileSchema, "#{__dir__}/config_loader/precompile_schema")
+    autoload(:PrivacyProcessorSchema, "#{__dir__}/config_loader/privacy_processor_schema")
+    autoload(:PrivacySchema, "#{__dir__}/config_loader/privacy_schema")
+    autoload(:RegexpSchema, "#{__dir__}/config_loader/regexp_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(: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(:Suggester, "#{__dir__}/config_loader/suggester")
+    autoload(:TransformSchema, "#{__dir__}/config_loader/transform_schema")
+    autoload(:TrueSchema, "#{__dir__}/config_loader/true_schema")
+    autoload(
+      :ValueMatcherConditionSchema,
+      "#{__dir__}/config_loader/value_matcher_condition_schema"
+    )
+    autoload(:ValueMatcherSchema, "#{__dir__}/config_loader/value_matcher_schema")
+    autoload(:ValueOrArraySchema, "#{__dir__}/config_loader/value_or_array_schema")
+    autoload(:ValueOrObjectSchema, "#{__dir__}/config_loader/value_or_object_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_collection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class DefinitionCollection
+    def initialize
+      @definitions_to_add = {}
+      @definition_sets_to_add = []
+    end
+
+    def add_definition_node(definition_node)
+      add(definition_node, loc: definition_node.loc)
+    end
+
+    def add(node, name: node.name, loc: node.loc.name)
+      @definitions_to_add[name] = ::Leftovers::DefinitionToAdd.new(node, name: name, location: loc)
+    end
+
+    def add_definition_set(definition_node_set)
+      @definition_sets_to_add << definition_node_set.definitions.map do |definition_node|
+        ::Leftovers::DefinitionToAdd.new(definition_node, location: definition_node.loc)
+      end
+    end
+
+    def set_privacy(name, to)
+      @definitions_to_add[name]&.privacy = to
+    end
+
+    def to_definitions(file_collector)
+      @definitions_to_add.each_value.map { |d| d.to_definition(file_collector) } +
+        @definition_sets_to_add.map do |definition_set|
+          next if definition_set.any? { |d| d.keep?(file_collector) }
+
+          ::Leftovers::DefinitionSet.new(definition_set.map { |d| d.to_definition(file_collector) })
+        end
+    end
+  end
+end

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,19 @@
+# frozen-string-literal: true
+
+module Leftovers
+  class DefinitionNodeSet
+    attr_reader :definitions
+
+    def initialize
+      @definitions = []
+    end
+
+    def add_definition_node(definition_node)
+      @definitions << definition_node
+    end
+
+    def add_definition_set(definition_node_set)
+      @definitions.concat(definition_node_set.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/file.rb

@@ -5,71 +5,29 @@ require 'pathname'
 module Leftovers
   class File < Pathname
     def relative_path
-      @relative_path ||= relative_path_from(Leftovers.pwd)
+      @relative_path ||= begin
+        relative_path_from(Leftovers.pwd)
+      rescue ArgumentError
+        self
+      end
     end
 
     def test?
       return @test if defined?(@test)
 
-      @test = Leftovers.config.test_paths.allowed?(relative_path)
+      @test = Leftovers.config.test_paths === relative_path
     end
 
-    def ruby # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      precompiled = []
-      precompile = false
-
-      if haml?
-        precompiled << ::Leftovers::Haml.precompile(read, self)
-        precompile = true
-      end
-
-      if json?
-        precompiled << ::Leftovers::JSON.precompile(read, self)
-        precompile = true
-      end
+    def ruby
+      read = self.read
 
-      if erb?
-        precompiled << ::Leftovers::ERB.precompile(read, self)
-        precompile = true
-      end
+      precompiled = ::Leftovers.config.precompilers.map do |precompiler|
+        precompiler.precompile(read, self)
+      end.compact
 
-      if slim?
-        precompiled << ::Leftovers::Slim.precompile(read, self)
-        precompile = true
-      end
-
-      if yaml?
-        precompiled << ::Leftovers::YAML.precompile(read, self)
-        precompile = true
-      end
-
-      if precompile
-        precompiled.join("\n")
-      else
-        read
-      end
-    end
-
-    private
-
-    def erb?
-      Leftovers.config.erb_paths.allowed?(relative_path)
-    end
-
-    def haml?
-      Leftovers.config.haml_paths.allowed?(relative_path)
-    end
-
-    def yaml?
-      Leftovers.config.yaml_paths.allowed?(relative_path)
-    end
-
-    def json?
-      Leftovers.config.json_paths.allowed?(relative_path)
-    end
+      return read if precompiled.empty?
 
-    def slim?
-      Leftovers.config.slim_paths.allowed?(relative_path)
+      precompiled.join("\n")
     end
   end
 end