leftovers 0.6.0 → 0.9.0

data/lib/leftovers/ast/def_node.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class DefNode < ::Leftovers::AST::Node
+      alias_method :name, :first
+      alias_method :to_sym, :first
+
+      def to_s
+        name.to_s
+      end
+      alias_method :to_literal_s, :to_s
+    end
+  end
+end

data/lib/leftovers/ast/defs_node.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class DefsNode < ::Leftovers::AST::Node
+      alias_method :name, :second
+      alias_method :to_sym, :second
+
+      def to_s
+        name.to_s
+      end
+      alias_method :to_literal_s, :to_s
+    end
+  end
+end

data/lib/leftovers/ast/false_node.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class FalseNode < ::Leftovers::AST::Node
+      def to_scalar_value
+        false
+      end
+
+      def scalar?
+        true
+      end
+
+      def to_s
+        'false'
+      end
+      alias_method :to_literal_s, :to_s
+
+      def to_sym
+        :false
+      end
+    end
+  end
+end

data/lib/leftovers/ast/has_arguments.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    module HasArguments
+      def positional_arguments
+        @memo.fetch(:positional_arguments) do
+          @memo[:positional_arguments] = begin
+            if kwargs
+              arguments[0...-1]
+            else
+              arguments
+            end
+          end
+        end
+      end
+
+      def kwargs
+        @memo.fetch(:kwargs) do
+          @memo[:kwargs] = begin
+            args = arguments
+            next unless args
+
+            last_arg = args[-1]
+            last_arg if last_arg&.hash?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/ast/hash_node.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class HashNode < ::Leftovers::AST::Node
+      include Leftovers::AST::HasArguments
+
+      def arguments
+        @memo[:arguments] ||= [self]
+      end
+
+      def hash?
+        true
+      end
+    end
+  end
+end

data/lib/leftovers/ast/module_node.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class ModuleNode < ::Leftovers::AST::Node
+      def name
+        first.name
+      end
+      alias_method :to_sym, :name
+
+      def to_s
+        name.to_s
+      end
+    end
+  end
+end

data/lib/leftovers/ast/nil_node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class NilNode < ::Leftovers::AST::Node
+      def to_scalar_value
+        nil
+      end
+
+      def scalar?
+        true
+      end
+
+      def to_s
+        ''
+      end
+
+      def to_sym
+        :nil
+      end
+    end
+  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
       def initialize(type, children = [], properties = {})
         # ::AST::Node#initialize freezes itself.
         # so can't use normal memoizations
@@ -13,6 +13,16 @@ module Leftovers
         super
       end
 
+      # This is called by ::Parser::AST internals
+      def updated(type = nil, children = nil, properties = nil) # leftovers:keep
+        maybe_copy = super
+
+        class_for_type = Leftovers::AST::Builder.node_class(maybe_copy.type)
+        return maybe_copy if maybe_copy.instance_of?(class_for_type)
+
+        class_for_type.new(maybe_copy.type, maybe_copy.children, location: maybe_copy.loc)
+      end
+
       def first
         children.first
       end
@@ -22,133 +32,71 @@ module Leftovers
       end
 
       def path
-        @memo[:path] ||= loc.expression.source_buffer.name.to_s
+        loc.expression.source_buffer.name
       end
 
-      def test_line?
-        @memo[:test_line]
+      def privacy=(value)
+        @memo[:privacy] = value
       end
 
-      def test_line=(value)
-        @memo[:test_line] = value
-      end
-
-      def keep_line=(value)
-        @memo[:keep_line] = value
-      end
-
-      def keep_line?
-        @memo[:keep_line]
+      def privacy
+        @memo[:privacy] || :public
       end
 
       def to_scalar_value
-        case type
-        when :sym, :int, :float, :str
-          first
-        when :true
-          true
-        when :false
-          false
-        when :nil
-          nil
-        end
+        nil
       end
 
       def scalar?
-        case type
-        when :sym, :int, :float, :str, :true, :false, :nil
-          true
-        else false
-        end
+        false
       end
 
       def to_s
-        @memo[:to_s] ||= name ? name.to_s : to_scalar_value.to_s
+        ''
       end
 
       def to_sym
-        case type
-        when :sym then first
-        when :nil, :true, :false then type
-        else to_s.to_sym
-        end
+        :''
       end
 
-      def string_or_symbol?
-        type == :str || type == :sym
+      def to_literal_s
+        nil
+      end
+
+      def hash?
+        false
       end
 
       def proc?
-        return unless type == :block
+        false
+      end
+
+      def sym?
+        false
+      end
 
-        name = first.name
-        name == :lambda || name == :proc
+      def as_arguments_list
+        @memo[:as_arguments_list] ||= [self]
       end
 
       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 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
+        nil
       end
 
       def positional_arguments
-        @memo.fetch(:positional_arguments) do
-          @memo[:positional_arguments] = kwargs ? arguments[0...-1] : arguments
-        end
+        nil
       end
 
       def receiver
-        case type
-        when :const, :csend, :send
-          first
-        end
-      end
-
-      def unwrap_freeze
-        return self unless type == :send && name == :freeze
-
-        first
+        nil
       end
 
       def kwargs
-        @memo.fetch(:kwargs) do
-          @memo[:kwargs] = begin
-            args = arguments
-            next unless args
-
-            last_arg = args[-1]
-            last_arg if last_arg && last_arg.type == :hash
-          end
-        end
+        nil
       end
 
       def name
-        @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
+        nil
       end
     end
   end

data/lib/leftovers/ast/numeric_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class NumericNode < ::Leftovers::AST::Node
+      alias_method :to_scalar_value, :first
+
+      def scalar?
+        true
+      end
+
+      def to_s
+        to_scalar_value.to_s
+      end
+      alias_method :to_literal_s, :to_s
+
+      def to_sym
+        to_s.to_sym
+      end
+    end
+  end
+end

data/lib/leftovers/ast/send_node.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class SendNode < ::Leftovers::AST::Node
+      include Leftovers::AST::HasArguments
+
+      alias_method :receiver, :first
+      alias_method :name, :second
+      alias_method :to_sym, :second
+
+      def to_s
+        name.to_s
+      end
+
+      def arguments
+        @memo[:arguments] ||= children.drop(2)
+      end
+
+      def as_arguments_list
+        first.as_arguments_list if name == :freeze
+      end
+    end
+  end
+end

data/lib/leftovers/ast/str_node.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class StrNode < ::Leftovers::AST::Node
+      alias_method :to_scalar_value, :first
+
+      def name
+        first.to_sym
+      end
+
+      alias_method :to_s, :first
+      alias_method :to_literal_s, :to_s
+
+      def to_sym
+        to_s.to_sym
+      end
+
+      def scalar?
+        true
+      end
+    end
+  end
+end

data/lib/leftovers/ast/sym_node.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class SymNode < ::Leftovers::AST::Node
+      alias_method :name, :first
+      alias_method :to_scalar_value, :first
+      alias_method :to_sym, :first
+
+      def scalar?
+        true
+      end
+
+      def to_s
+        name.to_s
+      end
+
+      alias_method :to_literal_s, :to_s
+
+      def sym?
+        true
+      end
+    end
+  end
+end

data/lib/leftovers/ast/true_node.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class TrueNode < ::Leftovers::AST::Node
+      def to_scalar_value
+        true
+      end
+
+      def scalar?
+        true
+      end
+
+      def to_s
+        'true'
+      end
+      alias_method :to_literal_s, :to_s
+
+      def to_sym
+        :true
+      end
+    end
+  end
+end

data/lib/leftovers/ast/var_node.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class VarNode < ::Leftovers::AST::Node
+      alias_method :name, :first
+      alias_method :to_sym, :first
+
+      def to_s
+        name.to_s
+      end
+    end
+  end
+end

data/lib/leftovers/ast/vasgn_node.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module AST
+    class VasgnNode < ::Leftovers::AST::Node
+      include Leftovers::AST::HasArguments
+
+      alias_method :name, :first
+      alias_method :to_sym, :first
+
+      def to_s
+        name.to_s
+      end
+
+      def arguments
+        second.as_arguments_list
+      end
+    end
+  end
+end

data/lib/leftovers/ast.rb

@@ -2,7 +2,25 @@
 
 module Leftovers
   module AST
+    autoload(:ArrayNode, "#{__dir__}/ast/array_node")
+    autoload(:BlockNode, "#{__dir__}/ast/block_node")
     autoload(:Builder, "#{__dir__}/ast/builder")
+    autoload(:CasgnNode, "#{__dir__}/ast/casgn_node")
+    autoload(:ConstNode, "#{__dir__}/ast/const_node")
+    autoload(:DefNode, "#{__dir__}/ast/def_node")
+    autoload(:DefsNode, "#{__dir__}/ast/defs_node")
+    autoload(:FalseNode, "#{__dir__}/ast/false_node")
+    autoload(:HashNode, "#{__dir__}/ast/hash_node")
+    autoload(:HasArguments, "#{__dir__}/ast/has_arguments")
+    autoload(:ModuleNode, "#{__dir__}/ast/module_node")
+    autoload(:NilNode, "#{__dir__}/ast/nil_node")
     autoload(:Node, "#{__dir__}/ast/node")
+    autoload(:NumericNode, "#{__dir__}/ast/numeric_node")
+    autoload(:SendNode, "#{__dir__}/ast/send_node")
+    autoload(:StrNode, "#{__dir__}/ast/str_node")
+    autoload(:SymNode, "#{__dir__}/ast/sym_node")
+    autoload(:TrueNode, "#{__dir__}/ast/true_node")
+    autoload(:VasgnNode, "#{__dir__}/ast/vasgn_node")
+    autoload(:VarNode, "#{__dir__}/ast/var_node")
   end
 end

data/lib/leftovers/cli.rb

@@ -42,6 +42,12 @@ module Leftovers
         Leftovers.exit
       end
 
+      opts.on('--view-compiled', 'Output the compiled content of the files') do
+        Leftovers::FileList.new(argv_rules: argv)
+          .each { |f| stdout.puts "\e[0;2m#{f.relative_path}\e[0m\n#{f.ruby}" }
+        Leftovers.exit
+      end
+
       opts.on('--write-todo', 'Outputs the unused items in a todo file to gradually fix') do
         Leftovers.reporter = Leftovers::TodoReporter.new
       end
@@ -56,7 +62,12 @@ module Leftovers
         Leftovers.exit
       end
 
-      opts.parse(argv)
+      opts.parse!(argv)
+    rescue OptionParser::InvalidOption => e
+      stderr.puts("\e[31mCLI Error: #{e.message}\e[0m")
+      stderr.puts ''
+      stderr.puts(opts.help)
+      Leftovers.exit 1
     end
   end
 end

data/lib/leftovers/collector.rb

@@ -45,7 +45,8 @@ module Leftovers
 
     def print_progress
       Leftovers.print(
-        "\e[2Kchecked #{@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"
       )
     end
 

data/lib/leftovers/comparable_instance.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ComparableInstance
+    def eql?(other)
+      frozen? && other.frozen? &&
+        self.class == other.class &&
+        instance_variables.all? do |var|
+          instance_variable_get(var) == other.instance_variable_get(var)
+        end
+    end
+    alias_method :==, :eql?
+
+    def hash
+      self.class.hash
+    end
+  end
+end

data/lib/leftovers/config.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'yaml'
-
 module Leftovers
   class Config
     attr_reader :name
@@ -28,24 +26,8 @@ module Leftovers
       @test_paths ||= Array(yaml[:test_paths])
     end
 
-    def haml_paths
-      @haml_paths ||= Array(yaml[:haml_paths])
-    end
-
-    def slim_paths
-      @slim_paths ||= Array(yaml[:slim_paths])
-    end
-
-    def yaml_paths
-      @yaml_paths ||= Array(yaml[:yaml_paths])
-    end
-
-    def json_paths
-      @json_paths ||= Array(yaml[:json_paths])
-    end
-
-    def erb_paths
-      @erb_paths ||= Array(yaml[:erb_paths])
+    def precompile
+      @precompile ||= Leftovers.each_or_self(yaml[:precompile]).to_a
     end
 
     def dynamic
@@ -66,29 +48,8 @@ module Leftovers
 
     private
 
-    def content
-      @content ||= ::File.exist?(path) ? ::File.read(path) : ''
-    end
-
-    def path
-      @path ||= ::File.expand_path("../config/#{name}.yml", __dir__)
-    end
-
     def yaml
-      @yaml ||= ::Leftovers::ConfigValidator.validate_and_process!(parse_yaml, path)
-    end
-
-    def parse_yaml
-      # :nocov:
-      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
-        Psych.safe_load(content, filename: path) || {}
-      else
-        Psych.safe_load(content, [], [], false, path) || {}
-      end
-      # :nocov:
-    rescue ::Psych::SyntaxError => e
-      warn "\e[31mConfig SyntaxError: #{e.message}\e[0m"
-      Leftovers.exit 1
+      @yaml ||= ::Leftovers::ConfigLoader.load(name, path: @path, content: @content)
     end
   end
 end

data/lib/leftovers/config_loader/argument_position_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ArgumentPositionSchema < ValueOrObjectSchema
+      inherit_attributes_from StringPatternSchema, except: :unless
+      attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
+      attribute :unless, ValueOrArraySchema[KeywordArgumentSchema], require_group: :matcher
+
+      self.or_value_schema = ScalarArgumentSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/argumentless_transform_schema.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ArgumentlessTransformSchema < StringEnumSchema
+      value :original
+      value :pluralize
+      value :singularize
+      value :camelize, aliases: :camelcase
+      value :underscore
+      value :titleize, aliases: :titlecase
+      value :demodulize
+      value :deconstantize
+      value :parameterize
+      value :downcase
+      value :upcase
+      value :capitalize
+      value :swapcase
+    end
+  end
+end