leftovers 0.3.0 → 0.4.0

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,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'node'
+require 'parser'
 
 module Leftovers
   module AST
@@ -9,12 +9,12 @@ module Leftovers
       #
       # @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,11 +4,7 @@ require 'parser'
 
 module Leftovers
   module AST
-    class Node < Parser::AST::Node # rubocop:disable Metrics/ClassLength
-      # :nocov:
-      using ::Leftovers::SetCaseEq if defined?(::Leftovers::SetCaseEq)
-      # :nocov:
-
+    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
@@ -21,25 +17,31 @@ module Leftovers
         children.first
       end
 
-      # TODO: move file to loc.
-      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
+      def test?
         @memo[:test]
       end
-      alias_method :test?, :test
 
       def test=(value)
         @memo[:test] = value
       end
 
-      def to_scalar_value # rubocop:disable Metrics/MethodLength
+      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
@@ -61,7 +63,7 @@ module Leftovers
       end
 
       def to_s
-        @memo[:to_s] ||= name&.to_s || to_scalar_value.to_s || ''
+        @memo[:to_s] ||= name ? name.to_s : to_scalar_value.to_s
       end
 
       def to_sym
@@ -76,20 +78,32 @@ module Leftovers
         type == :str || type == :sym
       end
 
-      def arguments # rubocop:disable Metrics/MethodLength
-        @memo[:arguments] ||= case type
-        when :send, :csend then children.drop(2)
-        when :casgn then [children[2]]
-        when :ivasgn, :cvasgn, :gvasgn then [children[1]]
-        else
-          # :nocov: # these are all the nodes with collect_rules
-          raise "Not argument node (#{type})"
-          # :nocov:
+      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
       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
@@ -100,69 +114,28 @@ 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
+          @memo[:kwargs] = begin
+            args = arguments
+            next unless args
 
-      def keys
-        each_pair.map { |k, _| k }
-      end
-
-      def values
-        # :nocov:
-        @memo[:kwargs] ||= case type
-        # :nocov:
-        when :hash then each_pair.map { |_, v| v }
-        when :array then children
-        end
-      end
-
-      def values_at_match(matcher)
-        each_pair.with_object([]) do |(key, value), values|
-          values << value if matcher === key.to_sym
-        end
-      end
-
-      def positional_arguments_at(positions)
-        positional_arguments.values_at(*positions).compact
-      end
-
-      def each_pair
-        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 # rubocop:disable Metrics/MethodLength
+      def name
         @memo[:name] ||= case type
         when :send, :csend, :casgn, :const
-          children[1]
-        when :def, :ivasgn, :ivar, :gvar, :cvar, :gvasgn, :cvasgn
+          second
+        when :def, :ivasgn, :ivar, :gvar, :cvar, :gvasgn, :cvasgn, :sym
           first
-        when :module, :class
+        when :str
+          first.to_sym
+        when :module, :class, :pair
           first.name
         end
       end
-
-      def [](index) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
-        # :nocov:
-        case type
-        # :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?
-
-            return value if key.to_sym == index
-          end
-
-          nil
-        end
-      end
     end
   end
 end

data/lib/leftovers/backports.rb

@@ -1,34 +1,38 @@
 # frozen_string_literal: true
 
 module Leftovers
-  ruby_version = Gem::Version.new(RUBY_VERSION)
-  unless ruby_version >= Gem::Version.new('2.5')
-    require 'set'
-    module SetCaseEq
-      refine ::Set do
-        def ===(value)
-          include?(value)
+  module Backports
+    ruby_version = Gem::Version.new(RUBY_VERSION)
+
+    unless ruby_version >= Gem::Version.new('2.5')
+      require 'set'
+      module SetCaseEq
+        refine ::Set do
+          def ===(value)
+            include?(value)
+          end
         end
       end
-    end
-    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 StringDeletePrefixSuffix
+        refine ::String do
+          def delete_prefix!(str)
+            slice!(0..(str.length - 1)) if start_with?(str)
+            self
+          end
 
-        def delete_prefix(str)
-          dup.delete_prefix!(str)
-        end
+          def delete_suffix!(str)
+            slice!(-str.length..-1) if end_with?(str)
+            self
+          end
+
+          def delete_prefix(str)
+            dup.delete_prefix!(str)
+          end
 
-        def delete_suffix(str)
-          dup.delete_suffix!(str)
+          def delete_suffix(str)
+            dup.delete_suffix!(str)
+          end
         end
       end
     end

data/lib/leftovers/cli.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 require 'optparse'
-require_relative '../leftovers'
-require_relative 'version'
-
 module Leftovers
   class CLI
     def initialize(argv: [], stdout: $stdout, stderr: $stderr)

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 = []
@@ -38,7 +34,7 @@ module Leftovers
     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
@@ -50,7 +46,7 @@ module Leftovers
       )
     end
 
-    def finish_file(_, _, result) # rubocop:disable Metrics/MethodLength
+    def finish_file(_, _, result)
       @count += 1
       @count_calls += result[:calls].length
       @count_definitions += result[:definitions].length

data/lib/leftovers/config.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
 require 'yaml'
-require_relative 'rule'
 
 module Leftovers
   class Config
     # :nocov:
-    using ::Leftovers::SetCaseEq if defined?(::Leftovers::SetCaseEq)
+    using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
     # :nocov:
 
     attr_reader :name
@@ -33,11 +32,16 @@ module Leftovers
       @test_paths ||= Array(yaml[:test_paths])
     end
 
-    def rules
-      @rules ||= Rule.wrap(yaml[:rules])
-    rescue Leftovers::ConfigError => e
-      warn "\e[31mConfig Error: (#{path}): #{e.message}\e[0m"
-      Leftovers.exit 1
+    def dynamic
+      @dynamic ||= ::Leftovers::ProcessorBuilders::Dynamic.build(yaml[:dynamic])
+    end
+
+    def keep
+      @keep ||= ::Leftovers::MatcherBuilders::Node.build(yaml[:keep])
+    end
+
+    def requires
+      @requires ||= Array(yaml[:requires])
     end
 
     private
@@ -50,31 +54,21 @@ module Leftovers
       @path ||= ::File.expand_path("../config/#{name}.yml", __dir__)
     end
 
-    def yaml # rubocop:disable Metrics/MethodLength
+    def yaml
+      @yaml ||= ::Leftovers::ConfigValidator.validate_and_process!(parse_yaml, path)
+    end
+
+    def parse_yaml
       # :nocov:
-      @yaml ||= if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
-        Psych.safe_load(content, symbolize_names: true, filename: path) || {}
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
+        Psych.safe_load(content, filename: path) || {}
       else
-        symbolize_names!(Psych.safe_load(content, [], [], false, path)) || {}
+        Psych.safe_load(content, [], [], false, path) || {}
       end
       # :nocov:
     rescue ::Psych::SyntaxError => e
       warn "\e[31mConfig SyntaxError: #{e.message}\e[0m"
       Leftovers.exit 1
     end
-
-    # :nocov:
-    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) }
-      end
-      obj
-    end
-    # :nocov:
   end
 end

data/lib/leftovers/config_validator.rb

@@ -0,0 +1,60 @@
+# frozen-string-literal: true
+
+require 'json_schemer'
+
+module Leftovers
+  module ConfigValidator
+    autoload(:ErrorProcessor, "#{__dir__}/config_validator/error_processor")
+    autoload(:SCHEMA_HASH, "#{__dir__}/config_validator/schema_hash")
+
+    def self.default_schema
+      @default_schema ||= ::JSONSchemer.schema(::Leftovers::ConfigValidator::SCHEMA_HASH)
+    end
+
+    def self.validate(obj, validator = default_schema)
+      validator.validate(obj)
+    end
+
+    def self.validate_and_process!(yaml, path)
+      errors = validate(yaml)
+      print_validation_errors_and_exit(errors, path) unless errors.first.nil?
+      post_process!(yaml)
+    end
+
+    def self.print_validation_errors_and_exit(errors, path)
+      ::Leftovers::ConfigValidator::ErrorProcessor.process(errors).each do |message|
+        warn "\e[31mConfig SchemaError: (#{path}): #{message}\e[0m"
+      end
+
+      ::Leftovers.exit 1
+    end
+
+    def self.post_process!(obj)
+      case obj
+      when Hash
+        obj.keys.each do |key| # rubocop:disable Style/HashEachMethods # each_key never finishes.
+          obj[symbolize_name(key)] = post_process!(obj.delete(key))
+        end
+      when Array
+        obj.map! { |ea| post_process!(ea) }
+      end
+      obj
+    end
+
+    def self.symbolize_name(name) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      case name
+      when 'matches' then :match
+      when 'defines' then :define
+      when 'calls' then :call
+      when 'name' then :names
+      when 'keyword' then :keywords
+      when 'argument' then :arguments
+      when 'has_argument' then :has_arguments
+      when 'path' then :paths
+      when 'unless' then :unless_arg
+      when 'require' then :requires
+      else name.to_sym
+      end
+    end
+  end
+end