leftovers 0.5.5 → 0.8.0

data/lib/leftovers/config_loader/object_schema.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ObjectSchema < Schema
+      class << self
+        def inherit_attributes_from(schema, require_group: true, except: nil)
+          attributes_and_schemas_to_inherit_from << InheritSchemaAttributes.new(
+            schema, require_group: require_group, except: except
+          )
+        end
+
+        def attributes
+          attributes_and_schemas_to_inherit_from.flat_map(&:attributes)
+        end
+
+        def attribute(name, value_schema, aliases: nil, require_group: nil, suggest: true)
+          attributes_and_schemas_to_inherit_from << Attribute.new(
+            name, value_schema,
+            aliases: aliases, require_group: require_group, suggest: suggest
+          )
+        end
+
+        def require_groups
+          attributes.group_by(&:require_group).tap { |rg| rg.delete(nil) }.values
+        end
+
+        def validate(node)
+          if node.hash?
+            validate_attributes(node)
+          else
+            error(node, 'be a hash')
+
+            node.valid?
+          end
+        end
+
+        def to_ruby(node)
+          node.pairs.map { |(key, value)| attribute_for_key(key).to_ruby(value) }.to_h
+        end
+
+        private
+
+        def attributes_and_schemas_to_inherit_from
+          @attributes_and_schemas_to_inherit_from ||= []
+        end
+
+        def validate_attributes(node)
+          validate_attribute_keys(node) && validate_required_keys(node)
+          validate_alias_uniqueness_of_keys(node)
+          validate_valid_attribute_values(node)
+
+          node.children.all?(&:valid?)
+        end
+
+        def attribute_for_key(node)
+          attributes.find { |attr| attr.name?(node) }
+        end
+
+        def validate_attribute_keys(node)
+          node.each_key { |key| validate_recognized_key(key, node) }
+          node.keys.all?(&:valid?)
+        end
+
+        def validate_alias_uniqueness_of_keys(node)
+          node.keys.select(&:valid?)
+            .group_by { |key| attribute_for_key(key) }
+            .each_value { |keys| error_message_for_non_unique_keys(node, keys) if keys.length > 1 }
+
+          node.valid?
+        end
+
+        def error_message_for_non_unique_keys(node, keys)
+          keys.each { |k| k.error = "#{node.name_}must only use one of #{keys.uniq.join(' or ')}" }
+        end
+
+        def validate_recognized_key(key, node)
+          return true if attribute_for_key(key)
+
+          suggestions = suggestions_for_unrecognized_key(key, node)
+          did_you_mean = "\nDid you mean: #{suggestions.join(', ')}" unless suggestions.empty?
+          key.error = "unrecognized key #{key}#{" for #{node.name}" if node.name}#{did_you_mean}"
+
+          false
+        end
+
+        def suggester
+          @suggester ||= Suggester.new(suggestions)
+        end
+
+        def suggestions_for_unrecognized_key(key, node)
+          suggester.suggest(key.to_ruby) - node.keys.map { |k| attribute_for_key(k)&.name }.compact
+        end
+
+        def suggestions(attributes = self.attributes)
+          attributes.select(&:suggest?).map(&:name)
+        end
+
+        def validate_required_keys(node)
+          missing_groups = require_groups.map do |group|
+            next if node.keys.any? { |key| group.any? { |attr| attr.name?(key) } }
+
+            "include at least one of #{suggestions(group).join(', ')}"
+          end.compact
+
+          error(node, missing_groups.join(' and ')) unless missing_groups.empty?
+
+          node.valid?
+        end
+
+        def validate_valid_attribute_values(node)
+          node.pairs.each { |(k, v)| attribute_for_key(k).validate_value(v) if k.valid? }
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/precompile_schema.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class PrecompileSchema < ObjectSchema
+      attribute :paths, ValueOrArraySchema[StringSchema],
+                aliases: %i{path include_paths include_path}, require_group: :paths
+
+      attribute :format, PrecompilerSchema, require_group: :precompiler
+    end
+  end
+end

data/lib/leftovers/config_loader/precompiler_schema.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class PrecompilerSchema < ValueOrObjectSchema
+      attribute :custom, StringSchema, require_group: :custom
+
+      self.or_value_schema = BuiltInPrecompilerSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/privacy_processor_schema.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class PrivacyProcessorSchema < ObjectSchema
+      inherit_attributes_from ValueProcessorSchema
+      attribute :to, PrivacySchema, require_group: :privacy_setting
+    end
+  end
+end

data/lib/leftovers/config_loader/privacy_schema.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class PrivacySchema < StringEnumSchema
+      value :public
+      value :protected
+      value :private
+
+      def self.to_ruby(node)
+        super.to_sym
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/require_schema.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class RequireSchema < ValueOrObjectSchema
+      attribute :quiet, StringSchema, require_group: :quiet
+
+      self.or_value_schema = StringSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/rule_pattern_schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class RulePatternSchema < ObjectSchema
+      attribute :names, ValueOrArraySchema[StringPatternSchema], aliases: :name,
+        require_group: :matcher
+      attribute :paths, ValueOrArraySchema[StringSchema], aliases: :path, require_group: :matcher
+      attribute :document, TrueSchema, require_group: :matcher
+      attribute :has_arguments, ValueOrArraySchema[HasArgumentSchema], aliases: :has_argument,
+        require_group: :matcher
+      attribute :has_receiver, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+      attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
+      attribute :privacy, ValueOrArraySchema[PrivacySchema], require_group: :matcher
+      attribute :unless, ValueOrArraySchema[RulePatternSchema], require_group: :matcher
+    end
+  end
+end

data/lib/leftovers/config_loader/scalar_argument_schema.rb

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

data/lib/leftovers/config_loader/scalar_value_schema.rb

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

data/lib/leftovers/config_loader/schema.rb

@@ -0,0 +1,23 @@
+# 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
+      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 < ValueOrObjectSchema
+      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_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,26 @@
+# 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, StringValueProcessorSchema, require_group: :processor
+      attribute :add_suffix, 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_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_schema.rb

@@ -0,0 +1,18 @@
+# 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, StringSchema, require_group: :matcher
+      attribute :recursive, TrueSchema
+
+      self.or_value_schema = ScalarArgumentSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/value_or_array_schema.rb

@@ -0,0 +1,66 @@
+# 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?
+          Leftovers.unwrap_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_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]
+      inherit_attributes_from TransformSchema, require_group: nil
+
+      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,86 @@
+# frozen-string-literal: true
+
+require 'yaml'
+
+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(:BuiltInPrecompilerSchema, "#{__dir__}/config_loader/built_in_precompiler_schema")
+    autoload(:DocumentSchema, "#{__dir__}/config_loader/document_schema")
+    autoload(:DynamicSchema, "#{__dir__}/config_loader/dynamic_schema")
+    autoload(:InheritSchemaAttributes, "#{__dir__}/config_loader/inherit_schema_attributes")
+    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(:PrecompileSchema, "#{__dir__}/config_loader/precompile_schema")
+    autoload(:PrecompilerSchema, "#{__dir__}/config_loader/precompiler_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(: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