leftovers 0.5.5 → 0.6.0

data/lib/leftovers/config_validator/schema_hash.rb

@@ -44,19 +44,21 @@ module Leftovers
         'name' => {
           'anyOf' => [
             { '$ref' => '#/definitions/string' },
-            { 'allOf' => [
-              { '$ref' => '#/definitions/stringPattern' },
-              {
-                'type' => 'object',
-                'properties' => {
-                  'match' => true, 'matches' => true,
-                  'has_prefix' => true, 'has_suffix' => true,
-                  'unless' => { '$ref' => '#/definitions/nameList' }
-                },
-                'minProperties' => 1,
-                'additionalProperties' => false
-              }
-            ] }
+            {
+              'allOf' => [
+                { '$ref' => '#/definitions/stringPattern' },
+                {
+                  'type' => 'object',
+                  'properties' => {
+                    'match' => true, 'matches' => true,
+                    'has_prefix' => true, 'has_suffix' => true,
+                    'unless' => { '$ref' => '#/definitions/nameList' }
+                  },
+                  'minProperties' => 1,
+                  'additionalProperties' => false
+                }
+              ]
+            }
           ]
         },
         'nameList' => {
@@ -107,40 +109,42 @@ module Leftovers
             { 'type' => 'number' },
             { 'type' => 'boolean' },
             { 'type' => 'null' },
-            { 'allOf' => [
-              { '$ref' => '#/definitions/stringPattern' },
-              {
-                'type' => 'object',
-                'properties' => {
-                  'match' => true, 'matches' => true,
-                  'has_prefix' => true, 'has_suffix' => true,
-                  'at' => { '$ref' => '#/definitions/argumentPositionList' },
-                  'has_value' => { '$ref' => '#/definitions/hasValueList' },
-                  'has_receiver' => { '$ref' => '#/definitions/hasValueList' },
-                  'type' => { '$ref' => '#/definitions/valueTypeList' },
-                  'unless' => { '$ref' => '#/definitions/hasValueList' }
-                },
-                'minProperties' => 1,
-                'additionalProperties' => false,
-                'allOf' => [
-                  # incompatible groups
-                  { 'not' => { 'required' => %w{match at} } },
-                  { 'not' => { 'required' => %w{match has_value} } },
-                  { 'not' => { 'required' => %w{match type} } },
-                  { 'not' => { 'required' => %w{matches at} } },
-                  { 'not' => { 'required' => %w{matches has_value} } },
-                  { 'not' => { 'required' => %w{matches type} } },
-                  { 'not' => { 'required' => %w{has_prefix at} } },
-                  { 'not' => { 'required' => %w{has_prefix has_value} } },
-                  { 'not' => { 'required' => %w{has_prefix type} } },
-                  { 'not' => { 'required' => %w{has_suffix at} } },
-                  { 'not' => { 'required' => %w{has_suffix has_value} } },
-                  { 'not' => { 'required' => %w{has_suffix type} } },
-                  { 'not' => { 'required' => %w{at type} } },
-                  { 'not' => { 'required' => %w{has_value type} } }
-                ]
-              }
-            ] }
+            {
+              'allOf' => [
+                { '$ref' => '#/definitions/stringPattern' },
+                {
+                  'type' => 'object',
+                  'properties' => {
+                    'match' => true, 'matches' => true,
+                    'has_prefix' => true, 'has_suffix' => true,
+                    'at' => { '$ref' => '#/definitions/argumentPositionList' },
+                    'has_value' => { '$ref' => '#/definitions/hasValueList' },
+                    'has_receiver' => { '$ref' => '#/definitions/hasValueList' },
+                    'type' => { '$ref' => '#/definitions/valueTypeList' },
+                    'unless' => { '$ref' => '#/definitions/hasValueList' }
+                  },
+                  'minProperties' => 1,
+                  'additionalProperties' => false,
+                  'allOf' => [
+                    # incompatible groups
+                    { 'not' => { 'required' => %w{match at} } },
+                    { 'not' => { 'required' => %w{match has_value} } },
+                    { 'not' => { 'required' => %w{match type} } },
+                    { 'not' => { 'required' => %w{matches at} } },
+                    { 'not' => { 'required' => %w{matches has_value} } },
+                    { 'not' => { 'required' => %w{matches type} } },
+                    { 'not' => { 'required' => %w{has_prefix at} } },
+                    { 'not' => { 'required' => %w{has_prefix has_value} } },
+                    { 'not' => { 'required' => %w{has_prefix type} } },
+                    { 'not' => { 'required' => %w{has_suffix at} } },
+                    { 'not' => { 'required' => %w{has_suffix has_value} } },
+                    { 'not' => { 'required' => %w{has_suffix type} } },
+                    { 'not' => { 'required' => %w{at type} } },
+                    { 'not' => { 'required' => %w{has_value type} } }
+                  ]
+                }
+              ]
+            }
           ]
         },
         'hasValueList' => {
@@ -187,6 +191,7 @@ module Leftovers
           'type' => 'object',
           'properties' => {
             'name' => { '$ref' => '#/definitions/nameList' },
+            'document' => { '$ref' => '#/definitions/true' },
             'names' => { '$ref' => '#/definitions/nameList' },
             'path' => { '$ref' => '#/definitions/stringList' },
             'paths' => { '$ref' => '#/definitions/stringList' },
@@ -253,37 +258,39 @@ module Leftovers
                 swapcase
               }
             },
-            { 'allOf' => [
-              { '$ref' => '#/definitions/transformProperties' },
-              {
-                'type' => 'object',
-                'properties' => {
-                  'original' => true,
-                  'pluralize' => true,
-                  'singularize' => true,
-                  'camelize' => true,
-                  'camelcase' => true,
-                  'underscore' => true,
-                  'titleize' => true,
-                  'titlecase' => true,
-                  'demodulize' => true,
-                  'deconstantize' => true,
-                  'parameterize' => true,
-                  'downcase' => true,
-                  'upcase' => true,
-                  'capitalize' => true,
-                  'swapcase' => true,
-                  'add_prefix' => true,
-                  'add_suffix' => true,
-                  'split' => true,
-                  'delete_prefix' => true,
-                  'delete_suffix' => true,
-                  'delete_before' => true,
-                  'delete_after' => true
-                },
-                'additionalProperties' => false
-              }
-            ] }
+            {
+              'allOf' => [
+                { '$ref' => '#/definitions/transformProperties' },
+                {
+                  'type' => 'object',
+                  'properties' => {
+                    'original' => true,
+                    'pluralize' => true,
+                    'singularize' => true,
+                    'camelize' => true,
+                    'camelcase' => true,
+                    'underscore' => true,
+                    'titleize' => true,
+                    'titlecase' => true,
+                    'demodulize' => true,
+                    'deconstantize' => true,
+                    'parameterize' => true,
+                    'downcase' => true,
+                    'upcase' => true,
+                    'capitalize' => true,
+                    'swapcase' => true,
+                    'add_prefix' => true,
+                    'add_suffix' => true,
+                    'split' => true,
+                    'delete_prefix' => true,
+                    'delete_suffix' => true,
+                    'delete_before' => true,
+                    'delete_after' => true
+                  },
+                  'additionalProperties' => false
+                }
+              ]
+            }
           ]
         },
         'transformList' => {
@@ -315,59 +322,63 @@ module Leftovers
           'anyOf' => [
             { '$ref' => '#/definitions/string' },
             { 'type' => 'integer', 'minimum' => 0 },
-            { 'allOf' => [
-              { '$ref' => '#/definitions/transformProperties' },
-              {
-                'type' => 'object',
-                'properties' => {
-                  'argument' => { '$ref' => '#/definitions/argumentPositionList' },
-                  'arguments' => { '$ref' => '#/definitions/argumentPositionList' },
-                  'keyword' => { '$ref' => '#/definitions/keywordList' },
-                  'keywords' => { '$ref' => '#/definitions/keywordList' },
-                  'itself' => { '$ref' => '#/definitions/true' },
-                  'value' => { '$ref' => '#/definitions/string' },
-                  'nested' => { '$ref' => '#/definitions/actionList' },
-                  'recursive' => { '$ref' => '#/definitions/true' },
-                  'transforms' => { '$ref' => '#/definitions/transformList' },
-                  'pluralize' => true,
-                  'singularize' => true,
-                  'camelize' => true,
-                  'camelcase' => true,
-                  'underscore' => true,
-                  'titleize' => true,
-                  'titlecase' => true,
-                  'demodulize' => true,
-                  'deconstantize' => true,
-                  'parameterize' => true,
-                  'downcase' => true,
-                  'upcase' => true,
-                  'capitalize' => true,
-                  'swapcase' => true,
-                  'add_prefix' => true,
-                  'add_suffix' => true,
-                  'split' => true,
-                  'delete_prefix' => true,
-                  'delete_suffix' => true,
-                  'delete_before' => true,
-                  'delete_after' => true
-                },
-                'additionalProperties' => false,
-                'allOf' => [
-                  # synonyms
-                  { 'not' => { 'required' => %w{keyword keywords} } },
-                  { 'not' => { 'required' => %w{argument arguments} } },
-                  # any of
-                  { 'anyOf' => [
-                    { 'required' => ['argument'] },
-                    { 'required' => ['arguments'] },
-                    { 'required' => ['keyword'] },
-                    { 'required' => ['keywords'] },
-                    { 'required' => ['itself'] },
-                    { 'required' => ['value'] }
-                  ] }
-                ]
-              }
-            ] }
+            {
+              'allOf' => [
+                { '$ref' => '#/definitions/transformProperties' },
+                {
+                  'type' => 'object',
+                  'properties' => {
+                    'argument' => { '$ref' => '#/definitions/argumentPositionList' },
+                    'arguments' => { '$ref' => '#/definitions/argumentPositionList' },
+                    'keyword' => { '$ref' => '#/definitions/keywordList' },
+                    'keywords' => { '$ref' => '#/definitions/keywordList' },
+                    'itself' => { '$ref' => '#/definitions/true' },
+                    'value' => { '$ref' => '#/definitions/string' },
+                    'nested' => { '$ref' => '#/definitions/actionList' },
+                    'recursive' => { '$ref' => '#/definitions/true' },
+                    'transforms' => { '$ref' => '#/definitions/transformList' },
+                    'pluralize' => true,
+                    'singularize' => true,
+                    'camelize' => true,
+                    'camelcase' => true,
+                    'underscore' => true,
+                    'titleize' => true,
+                    'titlecase' => true,
+                    'demodulize' => true,
+                    'deconstantize' => true,
+                    'parameterize' => true,
+                    'downcase' => true,
+                    'upcase' => true,
+                    'capitalize' => true,
+                    'swapcase' => true,
+                    'add_prefix' => true,
+                    'add_suffix' => true,
+                    'split' => true,
+                    'delete_prefix' => true,
+                    'delete_suffix' => true,
+                    'delete_before' => true,
+                    'delete_after' => true
+                  },
+                  'additionalProperties' => false,
+                  'allOf' => [
+                    # synonyms
+                    { 'not' => { 'required' => %w{keyword keywords} } },
+                    { 'not' => { 'required' => %w{argument arguments} } },
+                    # any of
+                    {
+                      'anyOf' => [
+                        { 'required' => ['argument'] },
+                        { 'required' => ['arguments'] },
+                        { 'required' => ['keyword'] },
+                        { 'required' => ['keywords'] },
+                        { 'required' => ['itself'] },
+                        { 'required' => ['value'] }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
           ]
         },
         'actionList' => {
@@ -395,10 +406,12 @@ module Leftovers
             { 'not' => { 'required' => %w{call calls} } },
             { 'not' => { 'required' => %w{define defines} } },
             # At least one of
-            { 'anyOf' => [
-              { 'required' => ['call'] }, { 'required' => ['calls'] },
-              { 'required' => ['define'] }, { 'required' => ['defines'] }
-            ] }
+            {
+              'anyOf' => [
+                { 'required' => ['call'] }, { 'required' => ['calls'] },
+                { 'required' => ['define'] }, { 'required' => ['defines'] }
+              ]
+            }
           ]
         },
         'ruleMatcherList' => {
@@ -414,13 +427,15 @@ module Leftovers
         'ruleMatcher' => {
           'allOf' => [
             { '$ref' => '#/definitions/rulePattern' },
-            { 'anyOf' => [
-              { 'required' => ['name'] }, { 'required' => ['names'] },
-              { 'required' => ['path'] }, { 'required' => ['paths'] },
-              { 'required' => ['has_argument'] }, { 'required' => ['has_arguments'] },
-              { 'required' => ['has_receiver'] },
-              { 'required' => ['unless'] }
-            ] },
+            {
+              'anyOf' => [
+                { 'required' => ['name'] }, { 'required' => ['names'] },
+                { 'required' => ['path'] }, { 'required' => ['paths'] },
+                { 'required' => ['has_argument'] }, { 'required' => ['has_arguments'] },
+                { 'required' => ['has_receiver'] },
+                { 'required' => ['unless'] }
+              ]
+            },
             {
               'type' => 'object',
               'properties' => {
@@ -441,19 +456,23 @@ module Leftovers
           'allOf' => [
             { '$ref' => '#/definitions/rulePattern' },
             { '$ref' => '#/definitions/dynamicAction' },
-            { 'anyOf' => [
-              { 'required' => ['name'] }, { 'required' => ['names'] },
-              { 'required' => ['path'] }, { 'required' => ['paths'] },
-              { 'required' => ['has_argument'] }, { 'required' => ['has_arguments'] },
-              { 'required' => ['has_receiver'] },
-              { 'required' => ['unless'] }
-            ] },
+            {
+              'anyOf' => [
+                { 'required' => ['name'] }, { 'required' => ['names'] },
+                { 'required' => ['document'] },
+                { 'required' => ['path'] }, { 'required' => ['paths'] },
+                { 'required' => ['has_argument'] }, { 'required' => ['has_arguments'] },
+                { 'required' => ['has_receiver'] },
+                { 'required' => ['unless'] }
+              ]
+            },
             {
               'type' => 'object',
               'properties' => {
                 # unfortunately this repetition is necessary to use additionalProperties: false
                 'name' => true, 'names' => true,
                 'path' => true, 'paths' => true,
+                'document' => true,
                 'has_argument' => true, 'has_arguments' => true,
                 'has_receiver' => true,
                 'unless' => { '$ref' => '#/definitions/ruleMatcherList' },
@@ -518,6 +537,8 @@ module Leftovers
         'test_paths' => { '$ref' => '#/definitions/stringList' },
         'haml_paths' => { '$ref' => '#/definitions/stringList' },
         'slim_paths' => { '$ref' => '#/definitions/stringList' },
+        'yaml_paths' => { '$ref' => '#/definitions/stringList' },
+        'json_paths' => { '$ref' => '#/definitions/stringList' },
         'erb_paths' => { '$ref' => '#/definitions/stringList' },
         'requires' => { '$ref' => '#/definitions/stringList' },
         'gems' => { '$ref' => '#/definitions/stringList' },

data/lib/leftovers/config_validator.rb

@@ -1,5 +1,6 @@
 # frozen-string-literal: true
 
+require 'set'
 require 'json_schemer'
 
 module Leftovers

data/lib/leftovers/definition.rb

@@ -10,7 +10,7 @@ module Leftovers
     def initialize(
       name,
       location: method_node.loc.expression,
-      test: method_node.test_line?
+      test: method_node.test_line? || ::Leftovers.config.test_only === method_node
     )
       @name = name
       @path = location.source_buffer.name.to_s

data/lib/leftovers/dynamic_processors/call.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module DynamicProcessors
     class Call
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher, processor)
         @matcher = matcher
         @processor = processor

data/lib/leftovers/dynamic_processors/call_definition.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module DynamicProcessors
     class CallDefinition
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher, call_processor, definition_processor)
         @matcher = matcher
         @call_processor = call_processor

data/lib/leftovers/dynamic_processors/definition.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module DynamicProcessors
     class Definition
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher, processor)
         @matcher = matcher
         @processor = processor

data/lib/leftovers/file.rb

@@ -14,20 +14,62 @@ module Leftovers
       @test = Leftovers.config.test_paths.allowed?(relative_path)
     end
 
-    def ruby
-      precompiler&.precompile(read, self) || read
+    def ruby # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      precompiled = []
+      precompile = false
+
+      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 precompiler
-      if Leftovers.config.haml_paths.allowed?(relative_path)
-        ::Leftovers::Haml
-      elsif Leftovers.config.slim_paths.allowed?(relative_path)
-        ::Leftovers::Slim
-      elsif Leftovers.config.erb_paths.allowed?(relative_path)
-        ::Leftovers::ERB
-      end
+    def erb?
+      Leftovers.config.erb_paths.allowed?(relative_path)
+    end
+
+    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
+
+    def slim?
+      Leftovers.config.slim_paths.allowed?(relative_path)
     end
   end
 end

data/lib/leftovers/file_collector.rb

@@ -12,6 +12,7 @@ module Leftovers
       @definitions = []
       @allow_lines = Set.new.compare_by_identity
       @test_lines = Set.new.compare_by_identity
+      @dynamic_lines = {}
       @ruby = ruby
       @file = file
     end
@@ -58,14 +59,18 @@ module Leftovers
     LEFTOVERS_CALL_RE = /\bleftovers:call(?:s|ed|er|ers|) (#{NAME_RE}(?:[, :]+#{NAME_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_RE})\b/.freeze
+
     def process_comments(comments) # rubocop:disable Metrics/AbcSize
       comments.each do |comment|
         @allow_lines << comment.loc.line if comment.text.match?(LEFTOVERS_ALLOW_RE)
         @test_lines << comment.loc.line if comment.text.match?(LEFTOVERS_TEST_RE)
+        dynamic_match = comment.text.match(LEFTOVERS_DYNAMIC_RE)
+        @dynamic_lines[comment.loc.line] = dynamic_match[1] if dynamic_match
 
-        next unless (match = comment.text.match(LEFTOVERS_CALL_RE))
+        next unless (call_match = comment.text.match(LEFTOVERS_CALL_RE))
 
-        match[1].scan(NAME_RE).each { |s| add_call(s.to_sym) }
+        call_match[1].scan(NAME_RE).each { |s| add_call(s.to_sym) }
       end
     end
 
@@ -136,6 +141,16 @@ module Leftovers
       add_call(node.name)
     end
 
+    def on_array(node)
+      super
+      collect_commented_dynamic(node)
+    end
+
+    def on_hash(node)
+      super
+      collect_commented_dynamic(node)
+    end
+
     # grab e.g. :to_s in each(&:to_s)
     def on_block_pass(node)
       super
@@ -225,6 +240,22 @@ module Leftovers
       end
     end
 
+    def collect_commented_dynamic(node)
+      fake_method_name = @dynamic_lines[node.loc.line]
+      return unless fake_method_name
+
+      node = build_send_wrapper_for(node, fake_method_name)
+      collect_dynamic(node)
+    end
+
+    def build_send_wrapper_for(node, name)
+      ::Leftovers::AST::Node.new(
+        :send,
+        [nil, name.to_sym, *node.arguments],
+        location: node.location
+      )
+    end
+
     def collect_dynamic(node) # rubocop:disable Metrics/AbcSize
       node.keep_line = @allow_lines.include?(node.loc.line)
       node.test_line = test_line?(node.loc) unless node.keep_line?

data/lib/leftovers/json.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Leftovers
+  module JSON
+    class << self
+      def precompile(json, name)
+        "__leftovers_document(#{to_ruby_argument(::JSON.parse(json))})"
+      rescue ::JSON::ParserError => e
+        Leftovers.warn "#{e.class}: (#{name.relative_path}): #{e.message}"
+        ''
+      end
+
+      private
+
+      def to_ruby_argument(value)
+        ruby = value.inspect
+        return ruby unless value.is_a?(Array)
+
+        ruby.delete_prefix!('[')
+        ruby.delete_suffix!(']')
+
+        ruby
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/document.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module Document
+      def self.build(true_arg)
+        return unless true_arg
+
+        ::Leftovers::Matchers::NodeName.new(:__leftovers_document)
+      end
+    end
+  end
+end