leftovers 0.8.0 → 0.11.0

data/lib/leftovers/ast/const_node.rb

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

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,15 +32,7 @@ module Leftovers
       end
 
       def path
-        @memo[:path] ||= loc.expression.source_buffer.name.to_s
-      end
-
-      def keep_line=(value)
-        @memo[:keep_line] = value
-      end
-
-      def keep_line?
-        @memo[:keep_line]
+        loc.expression.source_buffer.name
       end
 
       def privacy=(value)
@@ -42,118 +44,59 @@ module Leftovers
       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 string_or_symbol_or_def?
-        type == :str || type == :sym || type == :def || type == :defs
+      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, :defs
-          second
-        when :def, :ivasgn, :ivar, :gvar, :cvar, :gvasgn, :cvasgn, :sym, :lvar
-          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,7 @@ 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 ''

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_loader/argument_position_schema.rb

@@ -3,7 +3,9 @@
 module Leftovers
   class ConfigLoader
     class ArgumentPositionSchema < ValueOrObjectSchema
-      inherit_attributes_from StringPatternSchema
+      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

data/lib/leftovers/config_loader/array_schema.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ArraySchema < Schema
+      class << self
+        def [](value_schema)
+          new(value_schema)
+        end
+      end
+
+      attr_reader :value_schema
+
+      def initialize(value_schema)
+        @value_schema = value_schema
+
+        super()
+      end
+
+      def validate(node)
+        validate_array(node) && validate_length(node) && validate_values(node)
+      end
+
+      def to_ruby(node)
+        node.children.map do |value|
+          value_schema.to_ruby(value)
+        end
+      end
+
+      private
+
+      def validate_array(node)
+        self.class.error(node, 'be an array') unless node.array?
+
+        node.valid?
+      end
+
+      def validate_length(node)
+        self.class.error(node, 'not be empty') if node.children.empty?
+
+        node.valid?
+      end
+
+      def validate_values(node)
+        node.children.each do |value|
+          value_schema.validate(value)
+        end
+
+        node.children.all?(&:valid?)
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/document_schema.rb

@@ -27,8 +27,9 @@ module Leftovers
         read_hash.each do |key, value|
           next unless PRECOMPILERS.include?(key)
 
-          value = { paths: value, format: key.to_s.delete_suffix('_paths') }
-          yaml = { 'precompile' => [value.transform_keys(&:to_s)] }.to_yaml.delete_prefix("---\n")
+          value = { paths: value, format: key.to_s.delete_suffix('_paths').to_sym }
+          yaml = { 'precompile' => [value.transform_keys(&:to_s).transform_values(&:to_s)] }
+            .to_yaml.delete_prefix("---\n")
 
           Leftovers.warn(<<~MESSAGE)
             \e[33m`#{key}:` is deprecated\e[0m

data/lib/leftovers/config_loader/dynamic_schema.rb

@@ -12,6 +12,7 @@ module Leftovers
       attribute :set_privacy, ValueOrArraySchema[PrivacyProcessorSchema],
                 require_group: :processor
       attribute :set_default_privacy, PrivacySchema, require_group: :processor
+      attribute :eval, ValueOrArraySchema[ValueProcessorSchema], require_group: :processor
     end
   end
 end

data/lib/leftovers/config_loader/has_receiver_schema.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class HasReceiverSchema < ValueOrObjectSchema
+      inherit_attributes_from HasValueSchema, except: :unless
+
+      attribute :literal, ValueOrArraySchema[ScalarValueSchema],
+                require_group: :matcher
+      attribute :unless, ValueOrArraySchema[HasReceiverSchema], require_group: :matcher
+
+      self.or_value_schema = ScalarValueSchema
+    end
+  end
+end