leftovers 0.6.0 → 0.7.0

data/lib/leftovers/config_loader/node.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class Node
+      class_loader = Psych::ClassLoader::Restricted.new([], [])
+      ToRuby = Psych::Visitors::ToRuby.new(
+        Psych::ScalarScanner.new(class_loader),
+        class_loader
+      )
+
+      attr_reader :node, :file, :name
+      attr_accessor :error
+
+      def initialize(node, file, name = nil)
+        @node = node
+        @file = file
+        @name = name
+      end
+
+      def name_
+        "#{name} " if name
+      end
+
+      def valid?
+        !error
+      end
+
+      def error_message
+        "Config SchemaError: #{location} #{@error}" if @error
+      end
+
+      def all_errors
+        Array(error_message) + children.flat_map(&:all_errors)
+      end
+
+      def to_s
+        to_ruby.to_s
+      end
+
+      def hash?
+        node.is_a?(Psych::Nodes::Mapping)
+      end
+
+      def location
+        "#{file.relative_path}:#{node.start_line + 1}:#{node.start_column}"
+      end
+
+      def children
+        @children ||= if hash?
+          prepare_hash_children
+        elsif array?
+          node.children.map { |value| self.class.new(value, file, "#{name} value") }
+        else
+          []
+        end
+      end
+
+      def keys
+        @keys ||= pairs.map(&:first)
+      end
+
+      def pairs
+        @pairs ||= children.each_slice(2).to_a
+      end
+
+      def each_key(&block)
+        keys.each(&block)
+      end
+
+      def to_ruby
+        @to_ruby ||= ToRuby.accept(node)
+      end
+
+      def to_sym
+        to_ruby.to_sym if string?
+      end
+
+      def string?
+        to_ruby.is_a?(String)
+      end
+
+      def scalar?
+        !array? and !hash?
+      end
+
+      def array?
+        node.is_a?(Psych::Nodes::Sequence)
+      end
+
+      def integer?
+        to_ruby.is_a?(Integer)
+      end
+
+      private
+
+      def prepare_hash_children
+        node.children.each_slice(2).flat_map do |key, value|
+          key = self.class.new(key, file, name)
+          value = self.class.new(value, file, key.to_ruby)
+          [key, value]
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/object_schema.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ObjectSchema < Schema # rubocop:disable Metrics/ClassLength
+      class << self
+        def inherit_attributes_from(schema, require_group: true, except: nil)
+          attributes_and_schemas_to_inherit_from << schema
+
+          inherit_except[schema] = Leftovers.each_or_self(except)
+
+          return if require_group
+
+          skip_require_group << schema
+        end
+
+        def attributes
+          nonexcluded_attributes = attributes_and_schemas_to_inherit_from.map do |attr_or_schema|
+            attr_or_schema.attributes.dup.tap do |attributes_copy|
+              inherit_except[attr_or_schema]&.each { |e| attributes_copy.delete(e) }
+            end
+          end
+
+          nonexcluded_attributes.reduce { |a, e| a.merge(e) { raise 'Duplicate attributes' } }
+        end
+
+        def aliases
+          attributes_and_schemas_to_inherit_from.map(&:aliases)
+            .reduce { |a, e| a.merge(e) { raise 'Duplicate aliases' } }
+        end
+
+        def require_groups
+          (attributes_and_schemas_to_inherit_from - skip_require_group)
+            .map(&:require_groups).each_with_object({}) do |require_groups, hash|
+              require_groups.each do |group, keys|
+                hash[group] ||= []
+                hash[group] += keys
+              end
+            end
+        end
+
+        attr_accessor :or_schema
+
+        def attribute(name, value_schema, aliases: nil, require_group: nil)
+          attributes_and_schemas_to_inherit_from << Attribute.new(
+            name,
+            value_schema,
+            aliases: aliases,
+            require_group: require_group
+          )
+        end
+
+        def validate(node)
+          if node.hash?
+            validate_attributes(node)
+          elsif or_schema
+            validate_or_schema(node)
+          else
+            validate_is_hash(node)
+          end
+        end
+
+        def to_ruby(node)
+          if node.hash?
+            node.pairs.map { |(key, value)| pair_to_ruby(key, value) }.to_h
+          else
+            or_schema.to_ruby(node)
+          end
+        end
+
+        private
+
+        def inherit_except
+          @inherit_except ||= {}
+        end
+
+        def skip_require_group
+          @skip_require_group ||= []
+        end
+
+        def attributes_and_schemas_to_inherit_from
+          @attributes_and_schemas_to_inherit_from ||= []
+        end
+
+        def pair_to_ruby(key, value)
+          key_sym = key.to_sym
+          key_sym = aliases[key_sym] || key_sym
+          key_sym = :unless_arg if key_sym == :unless
+          [key_sym, schema_for_attribute(key).to_ruby(value)]
+        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 validate_or_schema(node)
+          or_schema.validate(node)
+          return true if node.valid?
+
+          if node.string? && valid_keys.include?(node.to_sym)
+            node.error = "#{node.name_}#{node.to_sym} must be a hash key"
+          else
+            node.error += " or a hash with any of #{attributes.keys.join(', ')}"
+          end
+        end
+
+        def validate_is_hash(node)
+          error(node, 'be a hash')
+          node.valid?
+        end
+
+        def validate_attribute_keys(node)
+          node.each_key { |key| validate_recognized_key(key, node) }
+          node.keys.all?(&:valid?)
+        end
+
+        def valid_keys
+          attributes.keys + aliases.keys
+        end
+
+        def validate_alias_uniqueness_of_keys(node)
+          node.keys.select(&:valid?)
+            .group_by { |key| aliases[key.to_sym] || key.to_sym }
+            .each_value do |keys|
+              next unless keys.length > 1
+
+              error_message_for_non_unique_keys(node, keys)
+            end
+        end
+
+        def error_message_for_non_unique_keys(node, keys)
+          keys.each do |key|
+            key.error = "#{node.name_}must only use one of #{keys.uniq.join(' or ')}"
+          end
+        end
+
+        def validate_recognized_key(key, node)
+          return true if valid_keys.include?(key.to_sym)
+
+          suggestions = suggestions_for_unrecognized_key(key, node)
+          did_you_mean = "\nDid you mean: #{suggestions.join(', ')}" unless suggestions.empty?
+          for_name = " for #{node.name}" if node.name
+
+          key.error = "unrecognized key #{key}#{for_name}#{did_you_mean}"
+
+          false
+        end
+
+        def suggester
+          @suggester ||= Suggester.new(attributes.keys)
+        end
+
+        def suggestions_for_unrecognized_key(key, node)
+          existing_keys = node.keys.flat_map { |k| [k.to_sym, aliases[k.to_sym]] }.compact
+          suggester.suggest(key.to_ruby) - existing_keys
+        end
+
+        def validate_required_keys(node)
+          missing_groups = require_groups.map do |_name, group|
+            next if node.keys.any? { |key| group.include?(key.to_sym) }
+
+            "include at least one of #{(attributes.keys & group).join(', ')}"
+          end.compact
+
+          error(node, missing_groups.join(' and ')) unless missing_groups.empty?
+
+          node.valid?
+        end
+
+        def schema_for_attribute(key)
+          key_sym = key.to_sym
+          attributes[key_sym] || attributes.fetch(aliases[key_sym])
+        end
+
+        def validate_valid_attribute_values(node)
+          node.pairs.each do |(key, value)|
+            next unless key.valid?
+
+            schema_for_attribute(key).validate(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/privacy_processor_schema.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class PrivacyProcessorSchema < ObjectSchema
+      inherit_attributes_from ValueProcessorSchema
+      attribute :to, PrivacySchema, require_group: :privacy_setting
+
+      self.or_schema = nil
+    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 < ObjectSchema
+      attribute :quiet, StringSchema, aliases: :name, require_group: :quiet
+
+      self.or_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,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