leftovers 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52698685d049f76cfbe3034d85b9de65aec3c06b44434119a6581b399778a648
-  data.tar.gz: daa5a40d80c7a180eb81a4dd59bc841788da04db541cfc93f2ae02577b1fd251
+  metadata.gz: 07755634c2f0119263912ecb6d90a64d37eea60aca5958f1c5f70555b5f63cb6
+  data.tar.gz: ac46e0dc82c7ed6aa10ca1775ecd1d080a4496fd6cbac942631e065892d8742c
 SHA512:
-  metadata.gz: 98ab99b3d471cdf3d42cf2c2e4940fc985313d68ce6a1ffe7b2f2909b0bcd95c1019a5fccdb306177a8283c0837baf068942a9f390fc38ccdeed9f5ecf8019f7
-  data.tar.gz: 1dcea67041a8afec49b80ff6b168d18fa28fcba7c6bbd546d0f004f76152f12116d9538cc0920e32721228a8a41233ad8788678d77fd55279f79b000e744ac55
+  metadata.gz: eb18eaa912ee5df99a96cb34eb9960e258aeec4e23fb00da879b7ea48cc8e42aaaa27d12dd21beb732e68257690ef2f1a8f71ab27f5402fd47c54768a4f895d4
+  data.tar.gz: d13c59bb909652a4bd0a1b4d46a66fc2faf40625e995dcfea43e60aed2a5fd617d2faf1b02408337837fed630474d0ec5c8c46113013d249648c7271783be74b

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# v0.3.0
+- Add simplecov, fix a handful of bugs it found
+- update fast_ignore
+
+# v0.2.4
+- use the right name for selenium-webdriver gem, so the bundler magic can work
+- handle yaml syntax errors.
+
 # v0.2.3
 - restore ability to handle syntax errors. I really need to add coverage to this project
 - Fix bug with delete_after on an empty string

data/exe/leftovers

@@ -3,4 +3,4 @@
 
 require_relative '../lib/leftovers/cli'
 
-Leftovers::CLI.new(argv: ARGV)
+exit Leftovers::CLI.new(argv: ARGV).run

data/leftovers.gemspec

@@ -35,12 +35,15 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry', '~> 0.1'
   spec.add_development_dependency 'rake', '>= 13'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rubocop', '~> 0.74'
+  spec.add_development_dependency 'rubocop', '~> 0.82'
   spec.add_development_dependency 'rubocop-performance', '~> 1.4'
   spec.add_development_dependency 'rubocop-rspec', '~> 1.35'
+  spec.add_development_dependency 'simplecov', '>= 0.18.5'
+  spec.add_development_dependency 'simplecov-console'
+  spec.add_development_dependency 'tty_string', '>= 0.2.1'
 
   spec.add_development_dependency 'spellr', '>= 0.8.1'
-  spec.add_dependency 'fast_ignore', '>= 0.10.0'
+  spec.add_dependency 'fast_ignore', '>= 0.11.0'
   spec.add_dependency 'parallel'
   spec.add_dependency 'parser'
 end

data/lib/config/rails.yml

@@ -82,6 +82,7 @@ rules:
       - arguments:
           - '*'
           - 'in'
+          - within
           - inclusion
           - scope
           - if

data/lib/config/ruby.yml

@@ -1,13 +1,14 @@
 ---
 include_paths:
-  - '*.rb'
-  - Gemfile
-  - '*.erb'
+  - '#!:ruby'
   - '*.gemspec'
   - .irbrc
   - irb.rc
   - _irbrc
   - $irbrc
+  - Gemfile
+  - '*.erb'
+  - '*.rb'
 
 test_paths:
   - /tests/
@@ -61,7 +62,8 @@ rules:
   - name: attr_writer
     defines:
       argument: '*'
-      add_suffix: '='
+      transforms:
+        - add_suffix: '='
   - name: attr_accessor
     defines:
       - argument: '*'
@@ -70,7 +72,8 @@ rules:
           - add_suffix: '='
     calls:
       argument: '*'
-      add_prefix: '@'
+      transforms:
+        add_prefix: '@'
   - name: define_method
     defines:
       argument: 1

data/lib/leftovers.rb

@@ -7,15 +7,15 @@ require_relative './leftovers/merged_config'
 require_relative './leftovers/reporter'
 
 module Leftovers # rubocop:disable Metrics/ModuleLength
+  class Error < StandardError; end
+  class ConfigError < Error; end
+
   module_function
 
   class << self
     attr_accessor :parallel
     alias_method :parallel?, :parallel
 
-    attr_accessor :quiet
-    alias_method :quiet?, :quiet
-
     attr_accessor :progress
     alias_method :progress?, :progress
   end
@@ -50,7 +50,6 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
   end
 
   def run(stdout: StringIO.new, stderr: StringIO.new) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-    reset
     @stdout = stdout
     @stderr = stderr
     return 0 if leftovers.empty?
@@ -87,20 +86,19 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
     remove_instance_variable(:@stdout) if defined?(@stdout)
     remove_instance_variable(:@stderr) if defined?(@stderr)
     remove_instance_variable(:@parallel) if defined?(@parallel)
-    remove_instance_variable(:@quiet) if defined?(@quiet)
     remove_instance_variable(:@pwd) if defined?(@pwd)
   end
 
   def warn(message)
-    stderr.puts("\e[2K#{message}") unless quiet?
+    stderr.puts("\e[2K#{message}")
   end
 
   def puts(message)
-    stdout.puts("\e[2K#{message}") unless quiet?
+    stdout.puts("\e[2K#{message}")
   end
 
   def print(message)
-    stdout.print(message) unless quiet?
+    stdout.print(message)
   end
 
   def newline
@@ -111,18 +109,25 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
     @pwd ||= Pathname.new(Dir.pwd + '/')
   end
 
-  def try_require(*requirables, message: nil) # rubocop:disable Metrics/MethodLength
+  def exit(status = 0)
+    throw :leftovers_exit, status
+  end
+
+  def try_require(requirable, message: nil) # rubocop:disable Metrics/MethodLength
     @try_require ||= {}
-    requirables.each do |requirable|
-      begin
-        return @try_require[requirable] if @try_require.key?(requirable)
-
-        @try_require[requirable] = require requirable
-      rescue LoadError
-        warn message if message
-        @try_require[requirable] = false
+
+    @try_require[requirable] = begin
+      if @try_require.key?(requirable)
+        @try_require[requirable]
+      else
+        require requirable
+        true
       end
+    rescue LoadError
+      false
     end
+    warn message if !@try_require[requirable] && message
+    @try_require[requirable]
   end
 
   def each_or_self(value, &block)

data/lib/leftovers/argument_rule.rb

@@ -37,7 +37,7 @@ module Leftovers
       @itself = itself
 
       unless @positions || @keywords || @all_positions || @all_keywords || @key || @itself
-        raise ArgumentError, "require at least one of 'argument(s)', 'key(s)', itself"
+        raise Leftovers::ConfigError, "require at least one of 'argument(s)', 'key(s)', itself"
       end
 
       @if = prepare_condition(options.delete(:if))
@@ -48,7 +48,7 @@ module Leftovers
 
     def prepare_transform(options, transforms, linked_transforms) # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/AbcSize
       if linked_transforms && transforms
-        raise ArgumentError, 'Only use one of linked_transforms/transforms'
+        raise Leftovers::ConfigError, 'Only use one of linked_transforms/transforms'
       end
       return if !linked_transforms && !transforms && options.empty?
 
@@ -57,7 +57,7 @@ module Leftovers
       else
         @linked = !!linked_transforms
 
-        transforms = (linked_transforms || transforms).map do |transform|
+        transforms = Leftovers.array_wrap(linked_transforms || transforms).map do |transform|
           transform = { transform.to_sym => true } if transform.is_a?(String)
           Leftovers::TransformRule.new(options.merge(transform))
         end
@@ -70,20 +70,26 @@ module Leftovers
       end
     end
 
-    def prepare_condition(conditions)
+    def prepare_condition(conditions) # rubocop:disable Metrics/MethodLength
       Leftovers.array_wrap(conditions).each do |cond|
-        cond[:has_argument] = HashRule.new(cond[:has_argument]) if cond[:has_argument]
+        unless cond.is_a?(Hash) && cond.keys == [:has_argument]
+          raise Leftovers::ConfigError, <<~MESSAGE
+            Invalid condition #{cond.inspect}. Valid condition keys are: has_argument
+          MESSAGE
+        end
+
+        cond[:has_argument] = HashRule.new(cond[:has_argument])
       end
     end
 
     def prepare_key(key, keys)
-      raise ArgumentError, 'Only use one of key/keys' if key && keys
+      raise Leftovers::ConfigError, 'Only use one of key/keys' if key && keys
 
       key || keys
     end
 
     def prepare_argument(argument, arguments) # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
-      raise ArgumentError, 'Only use one of argument/arguments' if argument && arguments
+      raise Leftovers::ConfigError, 'Only use one of argument/arguments' if argument && arguments
 
       positions = Set.new
       keywords = []
@@ -98,11 +104,15 @@ module Leftovers
           positions << arg - 1
         when String, Symbol, Hash
           keywords << arg
+        else
+          raise Leftovers::ConfigError, <<~MESSAGE
+            Invalid value for argument: #{arg.inspect}. Must by a string ('*', '**', or a keyword), or a hash with the name match rules, or an integer, or an array of these
+          MESSAGE
         end
       end
 
       @positions = positions unless @all_positions || positions.empty? || @all_positions
-      @keywords = NameRule.new(keywords) unless @all_keywords || keywords.empty?
+      @keywords = NameRule.wrap(keywords) unless @all_keywords || keywords.empty?
     end
 
     def matches(method_node) # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/AbcSize
@@ -135,13 +145,12 @@ module Leftovers
         @unless.all? { |c| !condition_match?(c, method_node) }
     end
 
-    def condition_match?(condition, method_name)
-      return unless condition[:has_argument]
-
-      hash_node = method_name.kwargs
-      return false unless hash_node
-
-      hash_node.each_pair.any? { |key, value| condition[:has_argument].match_pair?(key, value) }
+    def condition_match?(condition, method_node)
+      method_node.positional_arguments.each.with_index(1).any? do |value, index|
+        condition[:has_argument].match_pair?(index, value)
+      end || method_node.kwargs&.each_pair&.any? do |key, value|
+        condition[:has_argument].match_pair?(key.to_sym, value)
+      end
     end
 
     def hash_values(hash_node, method_node) # rubocop:disable Metrics/MethodLength
@@ -160,8 +169,6 @@ module Leftovers
     end
 
     def value(value_node, method_node) # rubocop:disable Metrics/MethodLength
-      return unless value_node
-
       value_node = value_node.unwrap_freeze
 
       case value_node.type
@@ -208,12 +215,15 @@ module Leftovers
       end
     end
 
-    def assert_valid_keys(options, keys)
+    def assert_valid_keys(options, keys) # rubocop:disable Metrics/MethodLength
       invalid = options.keys - keys
 
       return if invalid.empty?
 
-      raise ArgumentError, "unknown keyword#{'s' if invalid.length > 1}: #{invalid.join(', ')}"
+      raise(
+        Leftovers::ConfigError,
+        "unknown keyword#{'s' if invalid.length > 1}: #{invalid.join(', ')}"
+      )
     end
   end
 end

data/lib/leftovers/ast/builder.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require_relative 'node'
+
 module Leftovers
   module AST
     class Builder < ::Parser::Builders::Default
       # Generates {Node} from the given information.
       #
       # @return [Node] the generated node
+
       def n(type, children, source_map)
         Leftovers::AST::Node.new(type, children, location: source_map)
       end

data/lib/leftovers/ast/node.rb

@@ -5,6 +5,10 @@ require 'parser'
 module Leftovers
   module AST
     class Node < Parser::AST::Node # rubocop:disable Metrics/ClassLength
+      # :nocov:
+      using ::Leftovers::SetCaseEq if defined?(::Leftovers::SetCaseEq)
+      # :nocov:
+
       def initialize(type, children = [], properties = {})
         # ::AST::Node#initialize freezes itself.
         # so can't use normal memoizations
@@ -17,6 +21,7 @@ module Leftovers
         children.first
       end
 
+      # TODO: move file to loc.
       def file
         @memo[:file]
       end
@@ -35,62 +40,51 @@ module Leftovers
       end
 
       def to_scalar_value # rubocop:disable Metrics/MethodLength
-        @memo[:scalar_value] ||= case type
-        when :sym
+        case type
+        when :sym, :int, :float, :str
           first
-        when :str
-          first.to_s.freeze
         when :true
           true
         when :false
           false
         when :nil
           nil
-        else
-          raise "Not scalar node, (#{type})"
         end
       end
 
-      def to_s # rubocop:disable Metrics/MethodLength
-        @memo[:to_s] ||= if scalar?
-          to_scalar_value
-        elsif named?
-          name
-        else
-          raise "No to_s, (#{type})"
-        end.to_s.freeze
+      def scalar?
+        case type
+        when :sym, :int, :float, :str, :true, :false, :nil
+          true
+        else false
+        end
+      end
+
+      def to_s
+        @memo[:to_s] ||= name&.to_s || to_scalar_value.to_s || ''
       end
 
       def to_sym
         case type
-        when :str, :sym then first
+        when :sym then first
         when :nil, :true, :false then type
         else to_s.to_sym
         end
       end
 
-      SCALAR_TYPES = %i{sym str true false nil}.freeze
-      def scalar?
-        SCALAR_TYPES.include?(type)
-      end
-
       def string_or_symbol?
         type == :str || type == :sym
       end
 
-      def send?
-        type == :send || type == :csend
-      end
-
-      def named?
-        send? || type == :casgn
-      end
-
-      def arguments
+      def arguments # rubocop:disable Metrics/MethodLength
         @memo[:arguments] ||= case type
         when :send, :csend then children.drop(2)
         when :casgn then [children[2]]
-        else raise "Not argument node (#{type})"
+        when :ivasgn, :cvasgn, :gvasgn then [children[1]]
+        else
+          # :nocov: # these are all the nodes with collect_rules
+          raise "Not argument node (#{type})"
+          # :nocov:
         end
       end
 
@@ -115,25 +109,18 @@ module Leftovers
         each_pair.map { |k, _| k }
       end
 
-      def key?(key)
-        each_pair.find do |k, _v|
-          next unless k.string_or_symbol?
-
-          k.to_sym == key
-        end
-      end
-
       def values
+        # :nocov:
         @memo[:kwargs] ||= case type
+        # :nocov:
         when :hash then each_pair.map { |_, v| v }
         when :array then children
-        else []
         end
       end
 
       def values_at_match(matcher)
         each_pair.with_object([]) do |(key, value), values|
-          values << value if matcher.match?(key.to_sym, key.to_s)
+          values << value if matcher === key.to_sym
         end
       end
 
@@ -142,8 +129,6 @@ module Leftovers
       end
 
       def each_pair
-        raise "not hash node (#{type})" unless type == :hash
-
         return enum_for(:each_pair) unless block_given?
 
         children.each do |pair|
@@ -151,22 +136,23 @@ module Leftovers
         end
       end
 
-      def name
-        return "Not named node (#{type})" unless named?
-
-        @memo[:name] ||= children[1]
-      end
-
-      def name_s
-        @memo[:name_s] ||= name.to_s.freeze
+      def name # rubocop:disable Metrics/MethodLength
+        @memo[:name] ||= case type
+        when :send, :csend, :casgn, :const
+          children[1]
+        when :def, :ivasgn, :ivar, :gvar, :cvar, :gvasgn, :cvasgn
+          first
+        when :module, :class
+          first.name
+        end
       end
 
       def [](index) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+        # :nocov:
         case type
-        when :send, :csend
-          index.is_a?(Integer) ? arguments[index] : kwargs && kwargs[index]
-        when :array
-          children[index]
+        # :nocov:
+        when :send, :csend, :casgn, :cvasgn, :ivasgn, :gvasgn
+          index.is_a?(Integer) ? arguments[index - 1] : kwargs && kwargs[index]
         when :hash
           each_pair do |key, value|
             next unless key.string_or_symbol?