leftovers 0.6.0 → 0.9.0

data/lib/leftovers/config_loader/array_schema.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ArraySchema < 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)
+        validate_array(node) && validate_length(node) && validate_values(node)
+      end
+
+      def to_ruby(node)
+        node.children.map do |value|
+          value_schema.to_ruby(value)
+        end
+      end
+
+      private
+
+      def validate_array(node)
+        self.class.error(node, 'be an array') unless node.array?
+
+        node.valid?
+      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/attribute.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class Attribute
+      attr_reader(
+        :name,
+        :aliases, :schema # leftovers:test_only
+      )
+
+      attr_accessor :require_group
+
+      def initialize(name, schema, aliases: nil, require_group: nil, suggest: true)
+        @name = name
+        @schema = schema
+        @aliases = aliases
+        @require_group = require_group
+        @suggest = suggest
+      end
+
+      def without_require_group
+        new = dup
+        new.require_group = nil
+        new
+      end
+
+      def suggest?
+        @suggest
+      end
+
+      def attributes
+        [self]
+      end
+
+      def name?(name)
+        name = name.to_sym
+
+        @name == name || Leftovers.each_or_self(@aliases).include?(name)
+      end
+
+      def to_ruby(value)
+        [key_to_ruby, @schema.to_ruby(value)]
+      end
+
+      def validate_value(value)
+        @schema.validate(value)
+      end
+
+      private
+
+      def key_to_ruby
+        name == :unless ? :unless_arg : name
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/built_in_precompiler_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class BuiltInPrecompilerSchema < StringEnumSchema
+      value :erb
+      value :yaml
+      value :json
+      value :slim
+      value :haml
+    end
+  end
+end

data/lib/leftovers/config_loader/document_schema.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class DocumentSchema < ObjectSchema
+      attribute :include_paths, ValueOrArraySchema[StringSchema], aliases: :include_path
+      attribute :exclude_paths, ValueOrArraySchema[StringSchema], aliases: :exclude_path
+      attribute :test_paths, ValueOrArraySchema[StringSchema], aliases: :test_path
+      attribute :haml_paths, ValueOrArraySchema[StringSchema], aliases: :haml_path, suggest: false
+      attribute :slim_paths, ValueOrArraySchema[StringSchema], aliases: :slim_path, suggest: false
+      attribute :yaml_paths, ValueOrArraySchema[StringSchema], aliases: :yaml_path, suggest: false
+      attribute :json_paths, ValueOrArraySchema[StringSchema], aliases: :json_path, suggest: false
+      attribute :erb_paths, ValueOrArraySchema[StringSchema], aliases: :erb_path, suggest: false
+      attribute :precompile, ValueOrArraySchema[PrecompileSchema]
+      attribute :requires, ValueOrArraySchema[RequireSchema], aliases: :require
+      attribute :gems, ValueOrArraySchema[StringSchema], aliases: :gem
+      attribute :keep, ValueOrArraySchema[KeepTestOnlySchema]
+      attribute :test_only, ValueOrArraySchema[KeepTestOnlySchema]
+      attribute :dynamic, ValueOrArraySchema[DynamicSchema]
+
+      PRECOMPILERS = %i{haml_paths slim_paths json_paths yaml_paths erb_paths}.freeze
+
+      def self.to_ruby(node) # rubocop:disable Metrics
+        read_hash = super
+        write_hash = read_hash.dup
+
+        read_hash.each do |key, value|
+          next unless PRECOMPILERS.include?(key)
+
+          value = { paths: value, format: key.to_s.delete_suffix('_paths').to_sym }
+          yaml = { 'precompile' => [value.transform_keys(&:to_s).transform_values(&:to_s)] }
+            .to_yaml.delete_prefix("---\n")
+
+          Leftovers.warn(<<~MESSAGE)
+            \e[33m`#{key}:` is deprecated\e[0m
+            Replace with:
+            \e[32m#{yaml}\e[0m
+          MESSAGE
+
+          write_hash[:precompile] = Leftovers.each_or_self(write_hash[:precompile]).to_a
+          write_hash[:precompile] << value
+          write_hash.delete(key)
+        end
+
+        write_hash
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/dynamic_schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class DynamicSchema < ObjectSchema
+      inherit_attributes_from RulePatternSchema
+
+      attribute :call, ValueOrArraySchema[ValueProcessorSchema], aliases: :calls,
+        require_group: :processor
+      attribute :define, ValueOrArraySchema[ValueProcessorSchema], aliases: :defines,
+        require_group: :processor
+      attribute :set_privacy, ValueOrArraySchema[PrivacyProcessorSchema],
+                require_group: :processor
+      attribute :set_default_privacy, PrivacySchema, require_group: :processor
+      attribute :eval, ValueOrArraySchema[ValueProcessorSchema], require_group: :processor
+    end
+  end
+end

data/lib/leftovers/config_loader/has_argument_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class HasArgumentSchema < ValueOrObjectSchema
+      attribute :at, ValueOrArraySchema[ArgumentPositionSchema], require_group: :matcher
+      attribute :has_value, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+      attribute :unless, ValueOrArraySchema[HasArgumentSchema], require_group: :matcher
+
+      self.or_value_schema = ScalarArgumentSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/has_value_schema.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class HasValueSchema < ValueOrObjectSchema
+      attribute :names, ValueOrArraySchema[StringPatternSchema], aliases: :name,
+        require_group: :matcher
+      inherit_attributes_from StringPatternSchema, except: :unless
+      attribute :has_arguments, ValueOrArraySchema[HasArgumentSchema], aliases: :has_argument,
+        require_group: :matcher
+
+      attribute :at, ValueOrArraySchema[ArgumentPositionSchema], require_group: :matcher
+      attribute :has_value, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+
+      attribute :has_receiver, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+      attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
+      attribute :unless, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+
+      self.or_value_schema = ScalarValueSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/inherit_schema_attributes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class InheritSchemaAttributes
+      def initialize(schema, require_group: true, except: nil)
+        @schema = schema
+        @use_require_groups = require_group
+        @except = Leftovers.each_or_self(except)
+      end
+
+      def attributes
+        @schema.attributes.map do |attr|
+          next if @except.include?(attr.name)
+          next attr.without_require_group unless @use_require_groups
+
+          attr
+        end.compact
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/keep_test_only_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class KeepTestOnlySchema < ValueOrObjectSchema
+      inherit_attributes_from StringPatternSchema, except: :unless
+      inherit_attributes_from RulePatternSchema, except: :unless
+      attribute :unless, ValueOrArraySchema[KeepTestOnlySchema], require_group: :matcher
+
+      self.or_value_schema = StringSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/keyword_argument_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class KeywordArgumentSchema < ValueOrObjectSchema
+      inherit_attributes_from StringPatternSchema, except: :unless
+      attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
+      attribute :unless, ValueOrArraySchema[KeywordArgumentSchema], require_group: :matcher
+
+      self.or_value_schema = StringSchema
+    end
+  end
+end

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,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/regexp_schema.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class RegexpSchema < StringSchema
+      class << self
+        def validate(node)
+          validate_string(node) && validate_regexp(node)
+        end
+
+        def validate_string(node)
+          error(node, 'be a string with a valid ruby regexp') unless node.string?
+
+          node.valid?
+        end
+
+        def validate_regexp(node)
+          /#{node.to_ruby}/
+        rescue RegexpError, ArgumentError => e
+          error(node, "be a string with a valid ruby regexp (#{e.message})")
+        else
+          true
+        end
+      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,20 @@
+# 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
+      attribute :all, ArraySchema[RulePatternSchema], require_group: :matcher
+      attribute :any, ArraySchema[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,22 @@
+# 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
+
+        def to_ruby(node)
+          if node.to_ruby.nil?
+            :_leftovers_nil_value
+          else
+            node.to_ruby
+          end
+        end
+      end
+    end
+  end
+end