leftovers 0.5.5 → 0.8.0

data/lib/config/ruby.yml

@@ -14,14 +14,10 @@ test_paths:
   - /tests/
   - /test/
 
-erb_paths:
-  - '*.erb'
-
-haml_paths:
-  - '*.haml'
-
-slim_paths:
-  - '*.slim'
+precompile:
+  - { paths: '*.erb', format: 'erb' }
+  - { paths: ['*.yml', '*.yaml'], format: 'yaml' }
+  - { paths: '*.json', format: 'json' }
 
 keep:
   - initialize # called by new
@@ -91,3 +87,75 @@ dynamic:
       - instance_variable_set
       - class_variable_set
     defines: 0
+
+  # Module
+  - name: public
+    unless:
+      has_argument: 0
+    set_default_privacy: public
+
+  - name:
+      - public
+      - public_class_method
+      - public_constant
+    has_argument: 0
+    set_privacy:
+      argument: '*'
+      to: public
+
+  - name:
+      - public
+      - public_class_method
+    has_argument: 0
+    unless:
+      has_argument: 1
+    set_privacy:
+      argument: 0
+      nested:
+        argument: '*'
+      to: public
+
+  - name: protected
+    unless:
+      has_argument: 0
+    set_default_privacy: protected
+
+  - name: protected
+    has_argument: 0
+    set_privacy:
+      argument: '*'
+      to: protected
+
+  - name: protected
+    has_argument: 0
+    unless:
+      has_argument: 1
+    set_privacy:
+      argument: 0
+      nested:
+        argument: '*'
+      to: protected
+
+  - name: private
+    unless:
+      has_argument: 0
+    set_default_privacy: private
+
+  - name:
+      - private
+      - private_class_method
+      - private_constant
+    has_argument: 0
+    set_privacy:
+      argument: '*'
+      to: private
+
+  - name: private
+    has_argument: 0
+    unless:
+      has_argument: 1
+    set_privacy:
+      argument: 0
+      nested:
+        argument: '*'
+      to: private

data/lib/config/slim.yml

@@ -1,4 +1,6 @@
 include_paths:
   - '*.slim'
-slim_paths:
-  - '*.slim'
+requires: 'slim'
+precompile:
+  paths: '*.slim'
+  format: slim

data/lib/leftovers/ast/node.rb

@@ -25,14 +25,6 @@ module Leftovers
         @memo[:path] ||= loc.expression.source_buffer.name.to_s
       end
 
-      def test_line?
-        @memo[:test_line]
-      end
-
-      def test_line=(value)
-        @memo[:test_line] = value
-      end
-
       def keep_line=(value)
         @memo[:keep_line] = value
       end
@@ -41,6 +33,14 @@ module Leftovers
         @memo[:keep_line]
       end
 
+      def privacy=(value)
+        @memo[:privacy] = value
+      end
+
+      def privacy
+        @memo[:privacy] || :public
+      end
+
       def to_scalar_value
         case type
         when :sym, :int, :float, :str
@@ -58,7 +58,8 @@ module Leftovers
         case type
         when :sym, :int, :float, :str, :true, :false, :nil
           true
-        else false
+        else
+          false
         end
       end
 
@@ -78,6 +79,10 @@ module Leftovers
         type == :str || type == :sym
       end
 
+      def string_or_symbol_or_def?
+        type == :str || type == :sym || type == :def || type == :defs
+      end
+
       def proc?
         return unless type == :block
 
@@ -140,9 +145,9 @@ module Leftovers
 
       def name
         @memo[:name] ||= case type
-        when :send, :csend, :casgn, :const
+        when :send, :csend, :casgn, :const, :defs
           second
-        when :def, :ivasgn, :ivar, :gvar, :cvar, :gvasgn, :cvasgn, :sym
+        when :def, :ivasgn, :ivar, :gvar, :cvar, :gvasgn, :cvasgn, :sym, :lvar
           first
         when :str
           first.to_sym

data/lib/leftovers/cli.rb

@@ -57,6 +57,11 @@ module Leftovers
       end
 
       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

@@ -28,7 +28,9 @@ module Leftovers
 
     def collect_file_list(list)
       if Leftovers.parallel?
-        Parallel.each(list, finish: method(:finish_file), &method(:collect_file))
+        Parallel.each(list, finish: method(:finish_file)) do |file|
+          collect_file(file)
+        end
       else
         list.each { |file| finish_file(nil, nil, collect_file(file)) }
       end
@@ -43,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/config.rb

@@ -1,13 +1,7 @@
 # frozen_string_literal: true
 
-require 'yaml'
-
 module Leftovers
   class Config
-    # :nocov:
-    using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-    # :nocov:
-
     attr_reader :name
 
     def initialize(name, path: nil, content: nil)
@@ -32,16 +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 erb_paths
-      @erb_paths ||= Array(yaml[:erb_paths])
+    def precompile
+      @precompile ||= Leftovers.each_or_self(yaml[:precompile]).to_a
     end
 
     def dynamic
@@ -62,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,11 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ArgumentPositionSchema < ValueOrObjectSchema
+      inherit_attributes_from StringPatternSchema
+
+      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

data/lib/leftovers/config_loader/attribute.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class Attribute
+      attr_reader(
+        :name,
+        :aliases, :schema # leftovers:test_only
+      )
+
+      attr_accessor :require_group
+
+      def initialize(name, schema, aliases: nil, require_group: nil, suggest: true)
+        @name = name
+        @schema = schema
+        @aliases = aliases
+        @require_group = require_group
+        @suggest = suggest
+      end
+
+      def without_require_group
+        new = dup
+        new.require_group = nil
+        new
+      end
+
+      def suggest?
+        @suggest
+      end
+
+      def attributes
+        [self]
+      end
+
+      def name?(name)
+        name = name.to_sym
+
+        @name == name || Leftovers.each_or_self(@aliases).include?(name)
+      end
+
+      def to_ruby(value)
+        [key_to_ruby, @schema.to_ruby(value)]
+      end
+
+      def validate_value(value)
+        @schema.validate(value)
+      end
+
+      private
+
+      def key_to_ruby
+        name == :unless ? :unless_arg : name
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/built_in_precompiler_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class BuiltInPrecompilerSchema < StringEnumSchema
+      value :erb
+      value :yaml
+      value :json
+      value :slim
+      value :haml
+    end
+  end
+end

data/lib/leftovers/config_loader/document_schema.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class DocumentSchema < ObjectSchema
+      attribute :include_paths, ValueOrArraySchema[StringSchema], aliases: :include_path
+      attribute :exclude_paths, ValueOrArraySchema[StringSchema], aliases: :exclude_path
+      attribute :test_paths, ValueOrArraySchema[StringSchema], aliases: :test_path
+      attribute :haml_paths, ValueOrArraySchema[StringSchema], aliases: :haml_path, suggest: false
+      attribute :slim_paths, ValueOrArraySchema[StringSchema], aliases: :slim_path, suggest: false
+      attribute :yaml_paths, ValueOrArraySchema[StringSchema], aliases: :yaml_path, suggest: false
+      attribute :json_paths, ValueOrArraySchema[StringSchema], aliases: :json_path, suggest: false
+      attribute :erb_paths, ValueOrArraySchema[StringSchema], aliases: :erb_path, suggest: false
+      attribute :precompile, ValueOrArraySchema[PrecompileSchema]
+      attribute :requires, ValueOrArraySchema[RequireSchema], aliases: :require
+      attribute :gems, ValueOrArraySchema[StringSchema], aliases: :gem
+      attribute :keep, ValueOrArraySchema[KeepTestOnlySchema]
+      attribute :test_only, ValueOrArraySchema[KeepTestOnlySchema]
+      attribute :dynamic, ValueOrArraySchema[DynamicSchema]
+
+      PRECOMPILERS = %i{haml_paths slim_paths json_paths yaml_paths erb_paths}.freeze
+
+      def self.to_ruby(node) # rubocop:disable Metrics
+        read_hash = super
+        write_hash = read_hash.dup
+
+        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")
+
+          Leftovers.warn(<<~MESSAGE)
+            \e[33m`#{key}:` is deprecated\e[0m
+            Replace with:
+            \e[32m#{yaml}\e[0m
+          MESSAGE
+
+          write_hash[:precompile] = Leftovers.each_or_self(write_hash[:precompile]).to_a
+          write_hash[:precompile] << value
+          write_hash.delete(key)
+        end
+
+        write_hash
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/dynamic_schema.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class DynamicSchema < ObjectSchema
+      inherit_attributes_from RulePatternSchema
+
+      attribute :call, ValueOrArraySchema[ValueProcessorSchema], aliases: :calls,
+        require_group: :processor
+      attribute :define, ValueOrArraySchema[ValueProcessorSchema], aliases: :defines,
+        require_group: :processor
+      attribute :set_privacy, ValueOrArraySchema[PrivacyProcessorSchema],
+                require_group: :processor
+      attribute :set_default_privacy, PrivacySchema, require_group: :processor
+    end
+  end
+end

data/lib/leftovers/config_loader/has_argument_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class HasArgumentSchema < ValueOrObjectSchema
+      attribute :at, ValueOrArraySchema[ArgumentPositionSchema], require_group: :matcher
+      attribute :has_value, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+      attribute :unless, ValueOrArraySchema[HasArgumentSchema], require_group: :matcher
+
+      self.or_value_schema = ScalarArgumentSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/has_value_schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class HasValueSchema < ValueOrObjectSchema
+      inherit_attributes_from StringPatternSchema, except: :unless
+
+      attribute :at, ValueOrArraySchema[ArgumentPositionSchema], require_group: :matcher
+      attribute :has_value, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+
+      attribute :has_receiver, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+      attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
+      attribute :unless, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+
+      self.or_value_schema = ScalarValueSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/inherit_schema_attributes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class InheritSchemaAttributes
+      def initialize(schema, require_group: true, except: nil)
+        @schema = schema
+        @use_require_groups = require_group
+        @except = Leftovers.each_or_self(except)
+      end
+
+      def attributes
+        @schema.attributes.map do |attr|
+          next if @except.include?(attr.name)
+          next attr.without_require_group unless @use_require_groups
+
+          attr
+        end.compact
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/keep_test_only_schema.rb

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

data/lib/leftovers/config_loader/node.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class Node
+      class_loader = Psych::ClassLoader::Restricted.new([], [])
+      ToRuby = Psych::Visitors::ToRuby.new(
+        Psych::ScalarScanner.new(class_loader),
+        class_loader
+      )
+
+      attr_reader :node, :file, :name
+      attr_accessor :error
+
+      def initialize(node, file, name = nil)
+        @node = node
+        @file = file
+        @name = name
+      end
+
+      def name_
+        "#{name} " if name
+      end
+
+      def valid?
+        !error
+      end
+
+      def error_message
+        "Config SchemaError: #{location} #{@error}" if @error
+      end
+
+      def all_errors
+        Array(error_message) + children.flat_map(&:all_errors)
+      end
+
+      def to_s
+        to_ruby.to_s
+      end
+
+      def hash?
+        node.is_a?(Psych::Nodes::Mapping)
+      end
+
+      def location
+        "#{file.relative_path}:#{node.start_line + 1}:#{node.start_column}"
+      end
+
+      def children
+        @children ||= if hash?
+          prepare_hash_children
+        elsif array?
+          node.children.map { |value| self.class.new(value, file, "#{name} value") }
+        else
+          []
+        end
+      end
+
+      def keys
+        @keys ||= pairs.map(&:first)
+      end
+
+      def pairs
+        @pairs ||= children.each_slice(2).to_a
+      end
+
+      def each_key(&block)
+        keys.each(&block)
+      end
+
+      def to_ruby
+        @to_ruby ||= ToRuby.accept(node)
+      end
+
+      def to_sym
+        to_ruby.to_sym if string?
+      end
+
+      def string?
+        to_ruby.is_a?(String)
+      end
+
+      def scalar?
+        !array? and !hash?
+      end
+
+      def array?
+        node.is_a?(Psych::Nodes::Sequence)
+      end
+
+      def integer?
+        to_ruby.is_a?(Integer)
+      end
+
+      private
+
+      def prepare_hash_children
+        node.children.each_slice(2).flat_map do |key, value|
+          key = self.class.new(key, file, name)
+          value = self.class.new(value, file, key.to_ruby)
+          [key, value]
+        end
+      end
+    end
+  end
+end