leftovers 0.7.0 → 0.8.0

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/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/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)

data/lib/leftovers/config_loader/string_pattern_schema.rb

@@ -2,13 +2,13 @@
 
 module Leftovers
   class ConfigLoader
-    class StringPatternSchema < ObjectSchema
+    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_schema = StringSchema
+      self.or_value_schema = StringSchema
     end
   end
 end

data/lib/leftovers/config_loader/string_value_processor_schema.rb

@@ -2,10 +2,10 @@
 
 module Leftovers
   class ConfigLoader
-    class StringValueProcessorSchema < ObjectSchema
+    class StringValueProcessorSchema < ValueOrObjectSchema
       inherit_attributes_from ValueProcessorSchema
 
-      self.or_schema = StringSchema
+      self.or_value_schema = StringSchema
     end
   end
 end

data/lib/leftovers/config_loader/transform_schema.rb

@@ -2,7 +2,7 @@
 
 module Leftovers
   class ConfigLoader
-    class TransformSchema < ObjectSchema
+    class TransformSchema < ValueOrObjectSchema
       ArgumentlessTransformSchema.each_value do |transform|
         attribute(
           transform, TrueSchema,
@@ -11,10 +11,8 @@ module Leftovers
         )
       end
 
-      attribute :add_prefix, ValueOrArraySchema[StringValueProcessorSchema],
-                require_group: :processor
-      attribute :add_suffix, ValueOrArraySchema[StringValueProcessorSchema],
-                require_group: :processor
+      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
@@ -22,7 +20,7 @@ module Leftovers
       attribute :delete_before, StringSchema, require_group: :processor
       attribute :delete_after, StringSchema, require_group: :processor
 
-      self.or_schema = ArgumentlessTransformSchema
+      self.or_value_schema = ArgumentlessTransformSchema
     end
   end
 end

data/lib/leftovers/config_loader/value_matcher_schema.rb

@@ -2,7 +2,7 @@
 
 module Leftovers
   class ConfigLoader
-    class ValueMatcherSchema < ObjectSchema
+    class ValueMatcherSchema < ValueOrObjectSchema
       attribute :arguments, ValueOrArraySchema[ArgumentPositionSchema], aliases: :argument,
         require_group: :matcher
       attribute :keywords, ValueOrArraySchema[StringPatternSchema], aliases: :keyword,
@@ -12,7 +12,7 @@ module Leftovers
       attribute :value, StringSchema, require_group: :matcher
       attribute :recursive, TrueSchema
 
-      self.or_schema = ScalarArgumentSchema
+      self.or_value_schema = ScalarArgumentSchema
     end
   end
 end

data/lib/leftovers/config_loader/value_or_array_schema.rb

@@ -27,9 +27,11 @@ module Leftovers
 
       def to_ruby(node)
         if node.array?
-          node.children.map do |value|
-            value_schema.to_ruby(value)
-          end
+          Leftovers.unwrap_array(
+            node.children.map do |value|
+              value_schema.to_ruby(value)
+            end
+          )
         else
           value_schema.to_ruby(node)
         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

@@ -2,13 +2,13 @@
 
 module Leftovers
   class ConfigLoader
-    class ValueProcessorSchema < ObjectSchema
+    class ValueProcessorSchema < ValueOrObjectSchema
       inherit_attributes_from ValueMatcherSchema
 
       attribute :transforms, ValueOrArraySchema[TransformSchema]
       inherit_attributes_from TransformSchema, require_group: nil
 
-      self.or_schema = ScalarArgumentSchema
+      self.or_value_schema = ScalarArgumentSchema
     end
   end
 end

data/lib/leftovers/config_loader.rb

@@ -1,20 +1,23 @@
 # frozen-string-literal: true
 
 require 'yaml'
-require 'leftovers'
 
 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")
@@ -31,6 +34,7 @@ module Leftovers
     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")
 

data/lib/leftovers/file.rb

@@ -18,62 +18,16 @@ module Leftovers
       @test = Leftovers.config.test_paths.allowed?(relative_path)
     end
 
-    def ruby # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      precompiled = []
-      precompile = false
+    def ruby
+      read = self.read
 
-      if haml?
-        precompiled << ::Leftovers::Haml.precompile(read, self)
-        precompile = true
-      end
-
-      if json?
-        precompiled << ::Leftovers::JSON.precompile(read, self)
-        precompile = true
-      end
-
-      if erb?
-        precompiled << ::Leftovers::ERB.precompile(read, self)
-        precompile = true
-      end
-
-      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
+      precompiled = ::Leftovers.config.precompilers.map do |precompiler|
+        precompiler.precompile(read, self)
+      end.compact
 
-    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

data/lib/leftovers/file_collector/comments_processor.rb

@@ -0,0 +1,57 @@
+# frozen-string-literal: true
+
+module Leftovers
+  class FileCollector
+    module CommentsProcessor
+      METHOD_NAME_RE = /[[:alpha:]_][[:alnum:]_]*\b[?!=]?/.freeze
+      NON_ALNUM_METHOD_NAME_RE = Regexp.union(%w{
+        []= [] ** ~ +@ -@ * / % + - >> << &
+        ^ | <=> <= >= < > === == != =~ !~ !
+      }.map { |op| /#{Regexp.escape(op)}/ })
+      CONSTANT_NAME_RE = /[[:upper:]][[:alnum:]_]*\b/.freeze
+      NAME_RE = Regexp.union(METHOD_NAME_RE, NON_ALNUM_METHOD_NAME_RE, CONSTANT_NAME_RE)
+      NAME_LIST_RE = /#{NAME_RE}(?:[, :]+#{NAME_RE})*/.freeze
+      LEFTOVERS_CALL_RE = /\bleftovers:call(?:s|e(?:d|rs?))? (#{NAME_LIST_RE})/.freeze
+      LEFTOVERS_ALLOW_RE = /\bleftovers:(?:keeps?|skip(?:s|ped|)|allow(?:s|ed|))\b/.freeze
+      LEFTOVERS_TEST_RE = /\bleftovers:(?:for_tests?|tests?|testing|test_only)\b/.freeze
+      LEFTOVERS_DYNAMIC_RE = /\bleftovers:dynamic[: ](#{NAME_LIST_RE})/.freeze
+
+      class << self
+        def process(comments, collector)
+          comments.each do |comment|
+            process_leftovers_keep_comment(comment, collector)
+            process_leftovers_test_comment(comment, collector)
+            process_leftovers_dynamic_comment(comment, collector)
+            process_leftovers_call_comment(comment, collector)
+          end
+        end
+
+        def process_leftovers_keep_comment(comment, collector)
+          return unless comment.text.match?(LEFTOVERS_ALLOW_RE)
+
+          collector.allow_lines << comment.loc.line
+        end
+
+        def process_leftovers_test_comment(comment, collector)
+          return unless comment.text.match?(LEFTOVERS_TEST_RE)
+
+          collector.test_lines << comment.loc.line
+        end
+
+        def process_leftovers_dynamic_comment(comment, collector)
+          match = comment.text.match(LEFTOVERS_DYNAMIC_RE)
+          return unless match
+
+          collector.dynamic_lines[comment.loc.line] = match[1].scan(NAME_RE)
+        end
+
+        def process_leftovers_call_comment(comment, collector)
+          match = comment.text.match(LEFTOVERS_CALL_RE)
+          return unless match
+
+          match[1].scan(NAME_RE).each { |s| collector.add_call(s.to_sym) }
+        end
+      end
+    end
+  end
+end