leftovers 0.2.2 → 0.4.2

data/lib/leftovers/ast.rb

@@ -0,0 +1,8 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module AST
+    autoload(:Builder, "#{__dir__}/ast/builder")
+    autoload(:Node, "#{__dir__}/ast/node")
+  end
+end

data/lib/leftovers/ast/builder.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
+require 'parser'
+
 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)
+
+      def n(type, children, source_map) # leftovers:keep
+        ::Leftovers::AST::Node.new(type, children, location: source_map)
       end
 
       # Don't complain about invalid strings
-      def string_value(token)
+      def string_value(token) # leftovers:keep
         value(token)
       end
     end

data/lib/leftovers/ast/node.rb

@@ -4,7 +4,7 @@ require 'parser'
 
 module Leftovers
   module AST
-    class Node < Parser::AST::Node # rubocop:disable Metrics/ClassLength
+    class Node < ::Parser::AST::Node # rubocop:disable Metrics/ClassLength
       def initialize(type, children = [], properties = {})
         # ::AST::Node#initialize freezes itself.
         # so can't use normal memoizations
@@ -17,85 +17,93 @@ module Leftovers
         children.first
       end
 
-      def file
-        @memo[:file]
+      def second
+        children[1]
       end
 
-      def file=(value)
-        @memo[:file] = value
+      def path
+        @memo[:path] ||= loc.expression.source_buffer.name.to_s
       end
 
-      def test
-        @memo[:test]
+      def test_line?
+        @memo[:test_line]
       end
-      alias_method :test?, :test
 
-      def test=(value)
-        @memo[:test] = value
+      def test_line=(value)
+        @memo[:test_line] = value
       end
 
-      def to_scalar_value # rubocop:disable Metrics/MethodLength
-        @memo[:scalar_value] ||= case type
-        when :sym
+      def keep_line=(value)
+        @memo[:keep_line] = value
+      end
+
+      def keep_line?
+        @memo[:keep_line]
+      end
+
+      def to_scalar_value
+        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 ? 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
+      def arguments
+        @memo.fetch(:arguments) do
+          @memo[:arguments] = case type
+          when :send, :csend then children.drop(2)
+          when :casgn then assign_arguments(children[2])
+          when :ivasgn, :cvasgn, :gvasgn then assign_arguments(second)
+          when :array then children
+          when :hash then [self]
+          end
+        end
       end
 
-      def arguments
-        @memo[:arguments] ||= case type
-        when :send, :csend then children.drop(2)
-        when :casgn then [children[2]]
-        else raise "Not argument node (#{type})"
+      def assign_arguments(arguments_list)
+        arguments_list = arguments_list.unwrap_freeze
+        case arguments_list.type
+        when :array
+          arguments_list.children
+        when :hash, :str, :sym
+          [arguments_list]
         end
       end
 
       def positional_arguments
-        @memo[:positional_arguments] ||= kwargs ? arguments[0...-1] : arguments
+        @memo.fetch(:positional_arguments) do
+          @memo[:positional_arguments] = kwargs ? arguments[0...-1] : arguments
+        end
       end
 
       def unwrap_freeze
@@ -106,75 +114,26 @@ module Leftovers
 
       def kwargs
         @memo.fetch(:kwargs) do
-          last_arg = arguments[-1]&.unwrap_freeze
-          @memo[:kwargs] = (last_arg if last_arg&.type == :hash)
-        end
-      end
-
-      def keys
-        each_pair.map { |k, _| k }
-      end
-
-      def key?(key)
-        each_pair.find do |k, _v|
-          next unless k.string_or_symbol?
+          @memo[:kwargs] = begin
+            args = arguments
+            next unless args
 
-          k.to_sym == key
-        end
-      end
-
-      def values
-        @memo[:kwargs] ||= case type
-        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)
-        end
-      end
-
-      def positional_arguments_at(positions)
-        positional_arguments.values_at(*positions).compact
-      end
-
-      def each_pair
-        raise "not hash node (#{type})" unless type == :hash
-
-        return enum_for(:each_pair) unless block_given?
-
-        children.each do |pair|
-          yield(*pair.children) if pair.type == :pair
+            last_arg = args[-1]
+            last_arg if last_arg && last_arg.type == :hash
+          end
         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
-      end
-
-      def [](index) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
-        case type
-        when :send, :csend
-          index.is_a?(Integer) ? arguments[index] : kwargs && kwargs[index]
-        when :array
-          children[index]
-        when :hash
-          each_pair do |key, value|
-            next unless key.string_or_symbol?
-
-            return value if key.to_sym == index
-          end
-
-          nil
+        @memo[:name] ||= case type
+        when :send, :csend, :casgn, :const
+          second
+        when :def, :ivasgn, :ivar, :gvar, :cvar, :gvasgn, :cvasgn, :sym
+          first
+        when :str
+          first.to_sym
+        when :module, :class, :pair
+          first.name
         end
       end
     end

data/lib/leftovers/backports.rb

@@ -1,54 +1,38 @@
 # frozen_string_literal: true
 
 module Leftovers
-  ruby_version = Gem::Version.new(RUBY_VERSION)
-  unless ruby_version >= Gem::Version.new('2.5')
-    module StringDeletePrefixSuffix
-      refine ::String do
-        def delete_prefix!(str)
-          slice!(0..(str.length - 1)) if start_with?(str)
-          self
-        end
-
-        def delete_suffix!(str)
-          slice!(-str.length..-1) if end_with?(str)
-          self
-        end
+  module Backports
+    ruby_version = Gem::Version.new(RUBY_VERSION)
 
-        def delete_prefix(str)
-          dup.delete_prefix!(str)
-        end
-
-        def delete_suffix(str)
-          dup.delete_suffix!(str)
+    unless ruby_version >= Gem::Version.new('2.5')
+      require 'set'
+      module SetCaseEq
+        refine ::Set do
+          def ===(value)
+            include?(value)
+          end
         end
       end
-    end
 
-    require 'yaml'
-    module YAMLSymbolizeNames
-      refine YAML.singleton_class do
-        alias_method :safe_load_without_symbolize_names, :safe_load
-        def safe_load(path, *args, symbolize_names: false, **kwargs)
-          if symbolize_names
-            symbolize_names!(safe_load_without_symbolize_names(path, *args, **kwargs))
-          else
-            safe_load_without_symbolize_names(path, *args, **kwargs)
+      module StringDeletePrefixSuffix
+        refine ::String do
+          def delete_prefix!(str)
+            slice!(0..(str.length - 1)) if start_with?(str)
+            self
           end
-        end
 
-        private
+          def delete_suffix!(str)
+            slice!(-str.length..-1) if end_with?(str)
+            self
+          end
+
+          def delete_prefix(str)
+            dup.delete_prefix!(str)
+          end
 
-        def symbolize_names!(obj) # rubocop:disable Metrics/MethodLength
-          case obj
-          when Hash
-            obj.keys.each do |key| # rubocop:disable Style/HashEachMethods # each_key never finishes.
-              obj[key.to_sym] = symbolize_names!(obj.delete(key))
-            end
-          when Array
-            obj.map! { |ea| symbolize_names!(ea) }
+          def delete_suffix(str)
+            dup.delete_suffix!(str)
           end
-          obj
         end
       end
     end

data/lib/leftovers/cli.rb

@@ -1,30 +1,33 @@
 # frozen_string_literal: true
 
 require 'optparse'
-require_relative '../leftovers'
-require_relative 'version'
-
 module Leftovers
   class CLI
-    attr_reader :argv, :stdout, :stderr
-
-    def initialize(argv: [], stdout: StringIO.new, stderr: StringIO.new)
+    def initialize(argv: [], stdout: $stdout, stderr: $stderr)
       @argv = argv
       @stdout = stdout
       @stderr = stderr
+    end
 
-      parse_options
+    def run
+      catch(:leftovers_exit) do
+        Leftovers.reset
+        parse_options
 
-      exit Leftovers.run(stdout: stdout, stderr: stderr)
+        Leftovers.run(stdout: stdout, stderr: stderr)
+      end
     end
 
+    private
+
+    attr_reader :argv, :stdout, :stderr
+
     def parse_options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       opts = OptionParser.new
       Leftovers.parallel = true
       Leftovers.progress = true
 
       opts.banner = 'Usage: leftovers [options]'
-      opts.on('-q', '--quiet', 'Silences output') { Leftovers.quiet = true }
       opts.on('--[no-]parallel', 'Run in parallel or not, default --parallel') do |p|
         Leftovers.parallel = p
       end
@@ -32,16 +35,16 @@ module Leftovers
         Leftovers.progress = p
       end
       opts.on('-v', '--version', 'Returns the current version') do
-        stdout.puts(Leftovers::Version)
-        exit
+        stdout.puts(Leftovers::VERSION)
+        Leftovers.exit
       end
       opts.on('--dry-run', 'Output files that will be looked at') do
-        stdout.puts(Leftovers::FileList.new.to_a.map(&:relative_path).join("\n"))
-        exit
+        Leftovers::FileList.new.each { |f| stdout.puts f.relative_path }
+        Leftovers.exit
       end
       opts.on('-h', '--help', 'Shows this message') do
         stdout.puts(opts.help)
-        exit
+        Leftovers.exit
       end
 
       opts.parse(argv)

data/lib/leftovers/collector.rb

@@ -3,16 +3,12 @@
 require 'fast_ignore'
 require 'set'
 require 'parallel'
-require_relative 'file_collector'
-require_relative 'file_list'
 
 module Leftovers
   class Collector
-    attr_reader :calls
-    attr_reader :test_calls
-    attr_reader :definitions
+    attr_reader :calls, :test_calls, :definitions
 
-    def initialize # rubocop:disable Metrics/MethodLength
+    def initialize
       @calls = []
       @test_calls = []
       @definitions = []
@@ -31,14 +27,14 @@ module Leftovers
 
     def collect_file_list(list)
       if Leftovers.parallel?
-        Parallel.each(list, finish: method(:finish_parallel), &method(:collect_file))
+        Parallel.each(list, finish: method(:finish_file), &method(:collect_file))
       else
-        list.each { |file| finish_parallel(nil, nil, collect_file(file)) }
+        list.each { |file| finish_file(nil, nil, collect_file(file)) }
       end
     end
 
     def collect_file(file)
-      file_collector = Leftovers::FileCollector.new(file.ruby, file)
+      file_collector = ::Leftovers::FileCollector.new(file.ruby, file)
       file_collector.collect
 
       file_collector.to_h
@@ -46,11 +42,11 @@ module Leftovers
 
     def print_progress
       Leftovers.print(
-        "checked #{@count} files, collected #{@count_calls} calls, #{@count_definitions} definitions\r" # rubocop:disable Layout/LineLength
+        "\e[2Kchecked #{@count} files, collected #{@count_calls} calls, #{@count_definitions} definitions\r" # rubocop:disable Layout/LineLength
       )
     end
 
-    def finish_parallel(_, _, result) # rubocop:disable Metrics/MethodLength
+    def finish_file(_item, _index, result)
       @count += 1
       @count_calls += result[:calls].length
       @count_definitions += result[:definitions].length