leftovers 0.5.4 → 0.7.0

data/lib/leftovers/file.rb

@@ -5,7 +5,11 @@ require 'pathname'
 module Leftovers
   class File < Pathname
     def relative_path
-      @relative_path ||= relative_path_from(Leftovers.pwd)
+      @relative_path ||= begin
+        relative_path_from(Leftovers.pwd)
+      rescue ArgumentError
+        self
+      end
     end
 
     def test?
@@ -14,20 +18,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

@@ -5,15 +5,19 @@ require 'parser'
 
 module Leftovers
   class FileCollector < ::Parser::AST::Processor # rubocop:disable Metrics/ClassLength
-    attr_reader :calls, :definitions
+    attr_reader :calls
+    attr_accessor :default_method_privacy
 
     def initialize(ruby, file) # rubocop:disable Lint/MissingSuper
       @calls = []
-      @definitions = []
+      @definitions_to_add = {}
       @allow_lines = Set.new.compare_by_identity
       @test_lines = Set.new.compare_by_identity
+      @dynamic_lines = {}
       @ruby = ruby
       @file = file
+      @default_method_privacy = :public
+      @definition_sets_to_add = []
     end
 
     def filename
@@ -37,7 +41,6 @@ module Leftovers
       definitions.flatten!
       definitions.compact!
       definitions.uniq!
-      definitions.reject! { |v| v == :keep }
     end
 
     def collect
@@ -58,19 +61,29 @@ 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
 
     # grab method definitions
     def on_def(node)
+      node.privacy = default_method_privacy
+      add_definition(node)
+      super
+    end
+
+    def on_defs(node)
       add_definition(node)
       super
     end
@@ -136,6 +149,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
@@ -169,24 +192,41 @@ module Leftovers
       add_call(original_method.children.first)
     end
 
-    private
+    def add_definition(node, name: node.name, loc: node.loc.name)
+      @definitions_to_add[name] =
+        ::Leftovers::DefinitionToAdd.new(node, name: name, location: loc)
+    end
 
-    def test_line?(loc)
-      @file.test? ||
-        @test_lines.include?(loc.line)
+    def add_definition_set(definition_node_set)
+      @definition_sets_to_add << definition_node_set.definitions.map do |definition_node|
+        ::Leftovers::DefinitionToAdd.new(definition_node, location: definition_node.loc)
+      end
     end
 
-    def test_node?(node, loc)
-      test_line?(loc) || ::Leftovers.config.test_only === node
+    def set_privacy(name, to)
+      @definitions_to_add[name]&.privacy = to
     end
 
-    def add_definition(node, name: node.name, loc: node.loc.name)
-      return if @allow_lines.include?(loc.line)
-      return if Leftovers.config.keep === node
+    def definitions
+      @definitions ||= @definitions_to_add.each_value.map { |d| d.to_definition(self) }.compact +
+        @definition_sets_to_add.map do |definition_set|
+          next nil if definition_set.any? { |d| d.keep?(self) }
+
+          ::Leftovers::DefinitionSet.new(definition_set.map { |d| d.to_definition(self) })
+        end.compact
+    end
+
+    def test_line?(line)
+      @file.test? ||
+        @test_lines.include?(line)
+    end
 
-      definitions << Leftovers::Definition.new(name, location: loc, test: test_node?(node, loc))
+    def keep_line?(line)
+      @allow_lines.include?(line)
     end
 
+    private
+
     def add_call(name)
       calls << name
     end
@@ -217,17 +257,35 @@ module Leftovers
 
     def collect_op_asgn(node)
       node = node.children.first
-      # :nocov: # don't need else, it's exhaustive for callers
       case node.type
-      # :nocov:
       when :send then collect_send_op_asgn(node)
       when :ivasgn, :gvasgn, :cvasgn then collect_var_op_asgn(node)
+      when :lvasgn then nil # we don't care about lvasgn
+      # :nocov:
+      else
+        raise "Unrecognized op_asgn node type #{node.type}"
+        # :nocov:
       end
     end
 
-    def collect_dynamic(node) # rubocop:disable Metrics/AbcSize
+    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)
       node.keep_line = @allow_lines.include?(node.loc.line)
-      node.test_line = test_line?(node.loc) unless node.keep_line?
 
       Leftovers.config.dynamic.process(node, self)
     rescue StandardError => e

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

data/lib/leftovers/matcher_builders/node.rb

@@ -10,7 +10,7 @@ module Leftovers
             ::Leftovers::MatcherBuilders::NodeName.build(pat)
           when ::Hash
             build_from_hash(**pat)
-          # :nocov:
+            # :nocov:
           else raise
             # :nocov:
           end
@@ -19,9 +19,12 @@ module Leftovers
 
       def self.build_from_hash( # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
         names: nil, match: nil, has_prefix: nil, has_suffix: nil,
+        document: false,
         paths: nil,
         has_arguments: nil,
         has_receiver: nil,
+        type: nil,
+        privacy: nil,
         unless_arg: nil
       )
         ::Leftovers::MatcherBuilders::And.build([
@@ -29,9 +32,12 @@ module Leftovers
             names,
             { match: match, has_prefix: has_prefix, has_suffix: has_suffix }.compact
           ]),
+          ::Leftovers::MatcherBuilders::Document.build(document),
           ::Leftovers::MatcherBuilders::NodePath.build(paths),
           ::Leftovers::MatcherBuilders::NodeHasArgument.build(has_arguments),
           ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver),
+          ::Leftovers::MatcherBuilders::NodePrivacy.build(privacy),
+          ::Leftovers::MatcherBuilders::NodeType.build(type),
           ::Leftovers::MatcherBuilders::Unless.build(
             (::Leftovers::MatcherBuilders::Node.build(unless_arg) if unless_arg)
           )

data/lib/leftovers/matcher_builders/node_has_argument.rb

@@ -26,12 +26,10 @@ module Leftovers
 
         ::Leftovers.each_or_self(at) do |k|
           case k
-          when '*'
+          when '*', ::Integer
             positions << k
           when ::String, ::Hash
             keys << k
-          when ::Integer
-            positions << k
           # :nocov:
           else raise
             # :nocov:
@@ -62,7 +60,8 @@ module Leftovers
         elsif positions
           ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher)
           # :nocov:
-        else raise
+        else
+          raise
           # :nocov:
         end
 

data/lib/leftovers/matcher_builders/node_has_keyword_argument.rb

@@ -6,7 +6,7 @@ module Leftovers
       class << self
         def build(keywords, value_matcher) # rubocop:disable Metrics/MethodLength
           value_matcher = ::Leftovers::MatcherBuilders::NodePairValue.build(value_matcher)
-          keyword_matcher = if ::Leftovers.each_or_self(keywords).any? { |x| x == '**' }
+          keyword_matcher = if ::Leftovers.each_or_self(keywords).include?('**')
             ::Leftovers::Matchers::NodeType.new(:pair)
           else
             ::Leftovers::MatcherBuilders::NodePairName.build(keywords)

data/lib/leftovers/matcher_builders/node_has_positional_argument.rb

@@ -14,7 +14,7 @@ module Leftovers
               end
             end
           elsif positions
-            pos = 0 if ::Leftovers.each_or_self(positions).any? { |x| x == '*' }
+            pos = 0 if ::Leftovers.each_or_self(positions).include?('*')
             pos ||= ::Leftovers.each_or_self(positions).min
 
             ::Leftovers::Matchers::NodeHasPositionalArgument.new(pos)

data/lib/leftovers/matcher_builders/node_privacy.rb

@@ -0,0 +1,13 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodePrivacy
+      def self.build(privacy_settings)
+        ::Leftovers::MatcherBuilders::Or.each_or_self(privacy_settings) do |privacy|
+          ::Leftovers::Matchers::NodePrivacy.new(privacy)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_type.rb

@@ -14,12 +14,12 @@ module Leftovers
           when 'Float' then ::Leftovers::Matchers::NodeType.new(:float)
           when 'Array' then ::Leftovers::Matchers::NodeType.new(:array)
           when 'Hash' then ::Leftovers::Matchers::NodeType.new(:hash)
-
           when 'Proc' then ::Leftovers::Matchers::Predicate.new(:proc?)
-          # when 'Method' then ::Leftovers::Matchers::NodeType.new(Set[:send, :csend, :def])
-          # when 'Constant' then ::Leftovers::Matchers::NodeType.new(Set[:const, :class, :module])
+          when 'Method' then ::Leftovers::Matchers::NodeType.new(Set[:send, :csend, :def, :defs])
+          when 'Constant'
+            ::Leftovers::Matchers::NodeType.new(Set[:const, :class, :module, :casgn])
           # :nocov:
-          else raise
+          else raise "Unknown type #{type}"
             # :nocov:
           end
         end

data/lib/leftovers/matcher_builders/node_value.rb

@@ -7,7 +7,7 @@ module Leftovers
         def build(pattern) # rubocop:disable Metrics/MethodLength
           ::Leftovers::MatcherBuilders::Or.each_or_self(pattern) do |pat|
             case pat
-            when ::Integer, true, false, nil
+            when ::Integer, ::Float, true, false, nil
               ::Leftovers::Matchers::NodeScalarValue.new(pat)
             when ::String
               ::Leftovers::MatcherBuilders::NodeName.build(pat)

data/lib/leftovers/matcher_builders/string_pattern.rb

@@ -3,15 +3,24 @@
 module Leftovers
   module MatcherBuilders
     module StringPattern
-      def self.build(match: nil, has_prefix: nil, has_suffix: nil)
-        if match
+      def self.build(match: nil, has_prefix: nil, has_suffix: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        has_prefix = ::Regexp.escape(has_prefix) if has_prefix
+        has_suffix = ::Regexp.escape(has_suffix) if has_suffix
+
+        if match && has_prefix && has_suffix
+          /\A(?=#{match}\z)(?=#{has_prefix}).*#{has_suffix}\z/
+        elsif match && has_prefix
+          /\A(?=#{match}\z)#{has_prefix}/
+        elsif match && has_suffix
+          /\A(?=#{match}\z).*#{has_suffix}\z/
+        elsif match
           /\A#{match}\z/
         elsif has_prefix && has_suffix
-          /\A#{::Regexp.escape(has_prefix)}.*#{::Regexp.escape(has_suffix)}\z/
+          /\A(?=#{has_prefix}).*#{has_suffix}\z/
         elsif has_prefix
-          /\A#{::Regexp.escape(has_prefix)}/
+          /\A#{has_prefix}/
         elsif has_suffix
-          /#{::Regexp.escape(has_suffix)}\z/
+          /#{has_suffix}\z/
         end
       end
     end

data/lib/leftovers/matcher_builders.rb

@@ -4,6 +4,7 @@ module Leftovers
   module MatcherBuilders
     autoload(:AndNot, "#{__dir__}/matcher_builders/and_not")
     autoload(:And, "#{__dir__}/matcher_builders/and")
+    autoload(:Document, "#{__dir__}/matcher_builders/document")
     autoload(:Name, "#{__dir__}/matcher_builders/name")
     autoload(:Node, "#{__dir__}/matcher_builders/node")
     autoload(:NodeHasArgument, "#{__dir__}/matcher_builders/node_has_argument")
@@ -14,6 +15,7 @@ module Leftovers
     autoload(:NodePairName, "#{__dir__}/matcher_builders/node_pair_name")
     autoload(:NodePairValue, "#{__dir__}/matcher_builders/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matcher_builders/node_path")
+    autoload(:NodePrivacy, "#{__dir__}/matcher_builders/node_privacy")
     autoload(:NodeType, "#{__dir__}/matcher_builders/node_type")
     autoload(:NodeValue, "#{__dir__}/matcher_builders/node_value")
     autoload(:Or, "#{__dir__}/matcher_builders/or")

data/lib/leftovers/matchers/all.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class All
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matchers)
         @matchers = matchers
 

data/lib/leftovers/matchers/and.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class And
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(lhs, rhs)
         @lhs = lhs
         @rhs = rhs

data/lib/leftovers/matchers/any.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class Any
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       attr_reader :matchers
 
       def initialize(matchers)

data/lib/leftovers/matchers/node_has_any_keyword_argument.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeHasAnyKeywordArgument
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(pair_matcher)
         @pair_matcher = pair_matcher
 
@@ -17,9 +13,7 @@ module Leftovers
         kwargs = node.kwargs
         return false unless kwargs
 
-        kwargs.children.any? do |pair|
-          @pair_matcher === pair
-        end
+        kwargs.children.any?(@pair_matcher)
       end
 
       freeze

data/lib/leftovers/matchers/node_has_any_positional_argument_with_value.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeHasAnyPositionalArgumentWithValue
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher)
         @matcher = matcher
 
@@ -17,9 +13,7 @@ module Leftovers
         args = node.positional_arguments
         return false unless args
 
-        args.any? do |value|
-          @matcher === value
-        end
+        args.any?(@matcher)
       end
 
       freeze

data/lib/leftovers/matchers/node_has_positional_argument_with_value.rb

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

data/lib/leftovers/matchers/node_name.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeName
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(name_matcher)
         @name_matcher = name_matcher
 

data/lib/leftovers/matchers/node_pair_value.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodePairValue
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(value_matcher)
         @value_matcher = value_matcher
 

data/lib/leftovers/matchers/node_path.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodePath
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(path_matcher)
         @path_matcher = path_matcher
 

data/lib/leftovers/matchers/node_privacy.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodePrivacy
+      def initialize(privacy_matcher)
+        @privacy_matcher = privacy_matcher
+
+        freeze
+      end
+
+      def ===(node)
+        @privacy_matcher === node.privacy
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_scalar_value.rb

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

data/lib/leftovers/matchers/node_type.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeType
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(type_matcher)
         @type_matcher = type_matcher
 

data/lib/leftovers/matchers/not.rb

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

data/lib/leftovers/matchers/or.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class Or
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       attr_reader :lhs, :rhs
 
       def initialize(lhs, rhs)

data/lib/leftovers/matchers.rb

@@ -19,6 +19,7 @@ module Leftovers
     autoload(:NodeName, "#{__dir__}/matchers/node_name")
     autoload(:NodePairValue, "#{__dir__}/matchers/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matchers/node_path")
+    autoload(:NodePrivacy, "#{__dir__}/matchers/node_privacy")
     autoload(:NodeScalarValue, "#{__dir__}/matchers/node_scalar_value")
     autoload(:NodeType, "#{__dir__}/matchers/node_type")
     autoload(:Not, "#{__dir__}/matchers/not")