leftovers 0.7.0 → 0.10.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

@@ -3,27 +3,53 @@
 module Leftovers
   class ConfigLoader
     class Attribute
-      def initialize(name, value_schema, aliases: nil, require_group: nil)
+      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
-        @value_schema = value_schema
+        @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
-        { @name => @value_schema }
+        [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 aliases
-        ::Leftovers.each_or_self(@aliases).map do |aka|
-          [aka, @name]
-        end.to_h
+      def validate_value(value)
+        @schema.validate(value)
       end
 
-      def require_groups
-        return {} unless @require_group
+      private
 
-        { @require_group => [@name, *::Leftovers.each_or_self(@aliases)] }
+      def key_to_ruby
+        name == :unless ? :unless_arg : name
       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

@@ -6,16 +6,44 @@ module Leftovers
       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
-      attribute :slim_paths, ValueOrArraySchema[StringSchema], aliases: :slim_path
-      attribute :yaml_paths, ValueOrArraySchema[StringSchema], aliases: :yaml_path
-      attribute :json_paths, ValueOrArraySchema[StringSchema], aliases: :json_path
-      attribute :erb_paths, ValueOrArraySchema[StringSchema], aliases: :erb_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

@@ -12,6 +12,7 @@ module Leftovers
       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

@@ -2,12 +2,12 @@
 
 module Leftovers
   class ConfigLoader
-    class HasArgumentSchema < ObjectSchema
+    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_schema = ScalarArgumentSchema
+      self.or_value_schema = ScalarArgumentSchema
     end
   end
 end

data/lib/leftovers/config_loader/has_receiver_schema.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class HasReceiverSchema < ValueOrObjectSchema
+      inherit_attributes_from HasValueSchema, except: :unless
+
+      attribute :literal, ValueOrArraySchema[ScalarValueSchema],
+                require_group: :matcher
+      attribute :unless, ValueOrArraySchema[HasReceiverSchema], require_group: :matcher
+
+      self.or_value_schema = ScalarValueSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/has_value_schema.rb

@@ -2,17 +2,21 @@
 
 module Leftovers
   class ConfigLoader
-    class HasValueSchema < ObjectSchema
+    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 :has_receiver, ValueOrArraySchema[HasReceiverSchema], require_group: :matcher
       attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
       attribute :unless, ValueOrArraySchema[HasValueSchema], require_group: :matcher
 
-      self.or_schema = ScalarValueSchema
+      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

@@ -2,12 +2,12 @@
 
 module Leftovers
   class ConfigLoader
-    class KeepTestOnlySchema < ObjectSchema
+    class KeepTestOnlySchema < ValueOrObjectSchema
       inherit_attributes_from StringPatternSchema, except: :unless
       inherit_attributes_from RulePatternSchema, except: :unless
       attribute :unless, ValueOrArraySchema[KeepTestOnlySchema], require_group: :matcher
 
-      self.or_schema = StringSchema
+      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/object_schema.rb

@@ -2,93 +2,49 @@
 
 module Leftovers
   class ConfigLoader
-    class ObjectSchema < Schema # rubocop:disable Metrics/ClassLength
+    class ObjectSchema < Schema
       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
+          attributes_and_schemas_to_inherit_from << InheritSchemaAttributes.new(
+            schema, require_group: require_group, except: except
+          )
         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' } }
+          attributes_and_schemas_to_inherit_from.flat_map(&:attributes)
         end
 
-        def aliases
-          attributes_and_schemas_to_inherit_from.map(&:aliases)
-            .reduce { |a, e| a.merge(e) { raise 'Duplicate aliases' } }
+        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_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
-          )
+          attributes.group_by(&:require_group).tap { |rg| rg.delete(nil) }.values
         end
 
         def validate(node)
           if node.hash?
             validate_attributes(node)
-          elsif or_schema
-            validate_or_schema(node)
           else
-            validate_is_hash(node)
+            error(node, 'be a hash')
+
+            node.valid?
           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
+          node.pairs.map { |(key, value)| attribute_for_key(key).to_ruby(value) }.to_h
         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)
@@ -97,20 +53,8 @@ module Leftovers
           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?
+        def attribute_for_key(node)
+          attributes.find { |attr| attr.name?(node) }
         end
 
         def validate_attribute_keys(node)
@@ -118,52 +62,45 @@ module Leftovers
           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
+            .group_by { |key| attribute_for_key(key) }
+            .each_value { |keys| error_message_for_non_unique_keys(node, keys) if keys.length > 1 }
 
-              error_message_for_non_unique_keys(node, keys)
-            end
+          node.valid?
         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
+          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 valid_keys.include?(key.to_sym)
+          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?
-          for_name = " for #{node.name}" if node.name
-
-          key.error = "unrecognized key #{key}#{for_name}#{did_you_mean}"
+          key.error = "unrecognized key #{key}#{" for #{node.name}" if node.name}#{did_you_mean}"
 
           false
         end
 
         def suggester
-          @suggester ||= Suggester.new(attributes.keys)
+          @suggester ||= Suggester.new(suggestions)
         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
+          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 |_name, group|
-            next if node.keys.any? { |key| group.include?(key.to_sym) }
+          missing_groups = require_groups.map do |group|
+            next if node.keys.any? { |key| group.any? { |attr| attr.name?(key) } }
 
-            "include at least one of #{(attributes.keys & group).join(', ')}"
+            "include at least one of #{suggestions(group).join(', ')}"
           end.compact
 
           error(node, missing_groups.join(' and ')) unless missing_groups.empty?
@@ -171,17 +108,8 @@ module Leftovers
           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
+          node.pairs.each { |(k, v)| attribute_for_key(k).validate_value(v) if k.valid? }
         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

@@ -5,8 +5,6 @@ module Leftovers
     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/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

@@ -2,10 +2,10 @@
 
 module Leftovers
   class ConfigLoader
-    class RequireSchema < ObjectSchema
-      attribute :quiet, StringSchema, aliases: :name, require_group: :quiet
+    class RequireSchema < ValueOrObjectSchema
+      attribute :quiet, StringSchema, require_group: :quiet
 
-      self.or_schema = StringSchema
+      self.or_value_schema = StringSchema
     end
   end
 end

data/lib/leftovers/config_loader/rule_pattern_schema.rb

@@ -9,10 +9,12 @@ module Leftovers
       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 :has_receiver, ValueOrArraySchema[HasReceiverSchema], 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_value_schema.rb

@@ -8,6 +8,14 @@ module Leftovers
           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

data/lib/leftovers/config_loader/schema.rb

@@ -6,6 +6,8 @@ module Leftovers
       class << self
         def error(node, requirement)
           node.error = "#{node.name_}must #{requirement}"
+
+          false
         end
 
         def validate(node)
@@ -15,6 +17,16 @@ module Leftovers
         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

data/lib/leftovers/config_loader/string_enum_schema.rb

@@ -28,7 +28,7 @@ module Leftovers
         end
 
         def to_ruby(node)
-          aliases[node.to_sym]&.to_s || node.to_ruby
+          aliases[node.to_sym] || node.to_sym
         end
 
         def validate(node)