leftovers 0.2.3 → 0.3.0

data/lib/leftovers/hash_rule.rb

@@ -6,34 +6,36 @@ require_relative 'name_rule'
 
 module Leftovers
   class HashRule
-    def initialize(patterns) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # :nocov:
+    using ::Leftovers::SetCaseEq if defined?(::Leftovers::SetCaseEq)
+    # :nocov:
+
+    def initialize(patterns) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       keys = []
       pairs = []
       Leftovers.each_or_self(patterns) do |pat|
         if pat.is_a?(Hash) && pat[:value]
           pairs << [
-            (NameRule.new(pat[:keyword]) if pat[:keyword]),
-            (ValueRule.new(pat[:value]) if pat[:value])
+            NameRule.wrap(pat[:keyword] || pat[:index]),
+            ValueRule.new(pat[:value])
           ]
         else
-          keys << NameRule.new(pat)
+          keys << NameRule.wrap(pat)
         end
       end
 
-      @keys = (NameRule.new(keys) if keys)
+      @keys = NameRule.wrap(keys, false)
 
       @pairs = (pairs unless pairs.empty?)
 
       freeze
     end
 
-    def match_pair?(key_node, value_node)
-      return true if @keys&.match?(key_node.to_sym, key_node.to_s)
+    def match_pair?(key, value_node)
+      return true if @keys === key
 
       @pairs&.any? do |(key_rule, value_rule)|
-        next unless !key_rule || key_rule.match?(key_node.to_sym, key_node.to_s)
-
-        (!value_rule || value_rule.match?(value_node))
+        key_rule === key && value_rule.match?(value_node)
       end
     end
   end

data/lib/leftovers/merged_config.rb

@@ -9,18 +9,19 @@ module Leftovers
     def initialize
       @configs = []
       @loaded_configs = Set.new
-      self.<< Leftovers::Config.new(:ruby)
-      self.<< project_config
+      self << :ruby
+      self << project_config
       load_bundled_gem_config
     end
 
-    def <<(config)
+    def <<(config) # rubocop:disable Metrics/MethodLength
+      config = Leftovers::Config.new(config) unless config.is_a?(Leftovers::Config)
       return if @loaded_configs.include?(config.name)
 
       unmemoize
       @configs << config
       @loaded_configs << config.name
-      config.gems.each { |gem| self.<< Leftovers::Config.new(gem) }
+      config.gems.each { |gem| self << gem }
     end
 
     def project_config
@@ -45,7 +46,8 @@ module Leftovers
     def test_paths
       @test_paths ||= FastIgnore.new(
         include_rules: @configs.flat_map(&:test_paths),
-        gitignore: false
+        gitignore: false,
+        root: Leftovers.pwd
       )
     end
 
@@ -60,11 +62,10 @@ module Leftovers
     private
 
     def load_bundled_gem_config
-      Leftovers.try_require('bundler')
-      return unless defined?(Bundler)
+      return unless Leftovers.try_require('bundler')
 
       Bundler.locked_gems.specs.each do |spec|
-        self.<< Leftovers::Config.new(spec.name.to_sym)
+        self << spec.name
       end
     end
   end

data/lib/leftovers/name_rule.rb

@@ -3,51 +3,96 @@
 require 'set'
 module Leftovers
   class NameRule
-    attr_reader :sym, :syms, :regexp
+    # :nocov:
+    using ::Leftovers::SetCaseEq if defined?(::Leftovers::SetCaseEq)
+    # :nocov:
 
-    def initialize(patterns) # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+    module TrueReturner
+      def self.===(_value)
+        true
+      end
+    end
+
+    module FalseReturner
+      def self.===(_value)
+        false
+      end
+    end
+
+    attr_reader :syms, :regexp
+
+    def self.wrap(patterns, default = true) # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
       regexps = []
       syms = Set.new
-      Leftovers.each_or_self(patterns) do |pat|
+
+      Leftovers.each_or_self(patterns) do |pat| # rubocop:disable Metrics/BlockLength
+        # can't have these as part of the case statement because case equality
+        next if pat == Leftovers::NameRule::TrueReturner
+        next if pat == Leftovers::NameRule::FalseReturner
+
         case pat
+        when nil
+          nil # do nothing
         when Leftovers::NameRule
-          syms.merge(pat.sym) if pat.sym
-          syms.merge(pat.syms) if pat.syms
-          regexps.concat(pat.regexp) if pat.regexp
+          pat.syms.is_a?(Set) ? syms.merge(pat.syms) : syms << pat.syms
+          regexps << pat.regexp
         when String
           syms.merge(pat.split(/\s+/).map(&:to_sym))
+        when Symbol
+          syms << pat
+        when Integer
+          syms << pat
+        when Set
+          syms.merge(pat)
+        when Regexp
+          regexps << pat
         when Hash
           if pat[:match]
-            regexps << /\A#{pattern[:match]}\z/
+            regexps << /\A#{pat[:match]}\z/
+          elsif pat[:matches]
+            regexps << /\A#{pat[:matches]}\z/
           elsif pat[:has_prefix] && pat[:has_suffix]
             regexps << /\A#{Regexp.escape(pat[:has_prefix])}.*#{Regexp.escape(pat[:has_suffix])}\z/
           elsif pat[:has_prefix]
             regexps << /\A#{Regexp.escape(pat[:has_prefix])}/
           elsif pat[:has_suffix]
             regexps << /#{Regexp.escape(pat[:has_suffix])}\z/
+          else
+            raise Leftovers::ConfigError, "Invalid value for name #{pat}, "\
+              'valid keys are matches, has_prefix, has_suffix'
           end
+        else
+          raise Leftovers::ConfigError, "Invalid value type for name #{pat}, "\
+            'valid types are a String, or an object with keys matches, has_prefix, has_suffix'
         end
       end
 
-      if syms.length <= 0
-        @sym = syms.first
-        @syms = nil
+      syms = syms.first if syms.length <= 1
+
+      regexp = if regexps.empty?
+        nil
       else
-        @sym = nil
-        @syms = syms
+        Regexp.union(regexps).freeze
       end
 
-      @regexp = if regexps.empty?
-        nil
+      if syms && regexp
+        new(syms, regexp)
       else
-        Regexp.union(regexps)
+        syms || regexp || (
+          default ? ::Leftovers::NameRule::TrueReturner : ::Leftovers::NameRule::FalseReturner
+        )
       end
+    end
+
+    def initialize(syms, regexp)
+      @syms = syms
+      @regexp = regexp
 
       freeze
     end
 
-    def match?(sym, string)
-      @sym&.==(sym) || @syms&.include?(sym) || @regexp&.match?(string)
+    def ===(sym)
+      @syms === sym || @regexp === sym
     end
   end
 end

data/lib/leftovers/rake_task.rb

@@ -49,9 +49,9 @@ module Leftovers
     end
 
     def run(argv)
-      Leftovers::CLI.new(argv: argv)
-    rescue SystemExit => e
-      raise unless e.status == 0
+      exitstatus = Leftovers::CLI.new(argv: argv).run
+
+      exit exitstatus unless exitstatus == 0
     end
 
     def argv_or_default(task_argv)

data/lib/leftovers/reporter.rb

@@ -4,7 +4,7 @@ module Leftovers
   class Reporter
     def call(definition)
       Leftovers.puts(
-        "\e[36m#{definition.full_location}\e[0m #{definition.full_name} \e[2m#{definition.highlighted_source("\e[33m", "\e[0;2m")}\e[0m" # rubocop:disable Layout/LineLength
+        "\e[36m#{definition.full_location}\e[0m #{definition} \e[2m#{definition.highlighted_source("\e[33m", "\e[0;2m")}\e[0m" # rubocop:disable Layout/LineLength
       )
     end
   end

data/lib/leftovers/rule.rb

@@ -6,6 +6,10 @@ require 'fast_ignore'
 
 module Leftovers
   class Rule
+    # :nocov:
+    using ::Leftovers::SetCaseEq if defined?(::Leftovers::SetCaseEq)
+    # :nocov:
+
     def self.wrap(rules)
       case rules
       when Array then rules.flat_map { |r| wrap(r) }
@@ -28,29 +32,33 @@ module Leftovers
       path: nil,
       paths: nil
     )
-      raise ArgumentError, 'Only use one of name/names' if name && names
-      raise ArgumentError, 'Only use one of path/paths' if path && paths
-      raise ArgumentError, 'Only use one of call/calls' if call && calls
-      raise ArgumentError, 'Only use one of define/defines' if define && defines
-      if skip && (defines || calls)
-        raise ArgumentError, "skip can't exist with defines or calls for #{name || names}"
+      raise Leftovers::ConfigError, 'Only use one of name/names' if name && names
+      raise Leftovers::ConfigError, 'Only use one of path/paths' if path && paths
+      raise Leftovers::ConfigError, 'Only use one of call/calls' if call && calls
+      raise Leftovers::ConfigError, 'Only use one of define/defines' if define && defines
+      if skip && (defines || calls || define || call)
+        raise Leftovers::ConfigError, "skip can't exist with defines or calls"
       end
 
-      @name_matcher = NameRule.new(name || names)
-      @path = FastIgnore.new(include_rules: path || paths, gitignore: false) if path || paths
+      @name_matcher = NameRule.wrap(name || names)
+      if path || paths
+        @path = FastIgnore.new(include_rules: path || paths, gitignore: false, root: Leftovers.pwd)
+      end
       @skip = skip
 
       begin
         @calls = ArgumentRule.wrap(calls)
-      rescue ArgumentError => e
-        raise e, "#{e.message} for calls for #{name}", e.backtrace
+      rescue ArgumentError, Leftovers::ConfigError => e
+        raise e, "#{e.message} for calls", e.backtrace
       end
 
       begin
         @defines = ArgumentRule.wrap(defines, definer: true)
-      rescue ArgumentError => e
-        raise e, "#{e.message} for defines for #{name}", e.backtrace
+      rescue ArgumentError, Leftovers::ConfigError => e
+        raise e, "#{e.message} for defines", e.backtrace
       end
+    rescue ArgumentError, Leftovers::ConfigError => e
+      raise e, "#{e.message} for #{Array(name || names).map(&:to_s).join(', ')}", e.backtrace
     end
 
     def filename?(file)
@@ -59,8 +67,8 @@ module Leftovers
       @path.allowed?(file)
     end
 
-    def match?(name, name_s, file)
-      @name_matcher.match?(name, name_s) && filename?(file)
+    def match?(name, file)
+      @name_matcher === name && filename?(file)
     end
 
     def calls(node)

data/lib/leftovers/transform_rule.rb

@@ -37,9 +37,7 @@ module Leftovers
       replace_with
     }.freeze
 
-    VALID_TRANSFORMS = RUBY_STRING_METHODS + ACTIVESUPPORT_STRING_METHODS + CUSTOM_TRANSFORMS
-    # more possible transformations
-    # gsub sub tr tr_s
+    VALID_TRANSFORMS = CUSTOM_TRANSFORMS + RUBY_STRING_METHODS + ACTIVESUPPORT_STRING_METHODS
     def initialize(transforms)
       @transforms = prepare_transforms(transforms)
 
@@ -58,9 +56,9 @@ module Leftovers
     def prepare_transforms(transforms) # rubocop:disable Metrics/MethodLength
       transforms.map do |key, value|
         unless VALID_TRANSFORMS.include?(key)
-          raise ArgumentError, <<~MESSAGE
-            invalid transform key: (#{key}: #{value}).
-            Valid transform keys are #{ALL_VALID_TRANSFORMS}"
+          raise Leftovers::ConfigError, <<~MESSAGE
+            invalid transform key: (#{key}: #{value})
+            Valid transform keys are #{VALID_TRANSFORMS.join(', ')}
           MESSAGE
         end
 
@@ -74,18 +72,18 @@ module Leftovers
     HASH_VALUE_TRANSFORMS = %i{add_prefix add_suffix}.freeze
     HASH_VALUE_KEYS = %i{from_argument joiner}.freeze
     def prepare_hash_value(method, hash) # rubocop:disable Metrics/MethodLength
-      raise ArgumentError, <<~MESSAGE unless HASH_VALUE_TRANSFORMS.include?(method)
-        invalid transform value (#{key}: #{value}).
-        Hash values are only valid for #{HASH_VALUE_TRANSFORMS}
+      raise Leftovers::ConfigError, <<~MESSAGE unless HASH_VALUE_TRANSFORMS.include?(method)
+        invalid transform value (#{method}: #{hash.inspect}).
+        Hash values are only valid for #{HASH_VALUE_TRANSFORMS.join(', ')}
       MESSAGE
 
       hash = hash.map do |k, v|
-        raise ArgumentError, <<~MESSAGE unless HASH_VALUE_KEYS.include?(k)
+        raise Leftovers::ConfigError, <<~MESSAGE unless HASH_VALUE_KEYS.include?(k)
           invalid transform value argument (#{method}: { #{k}: #{v} }).
-          Hash values are only valid for #{HASH_VALUE_TRANSFORMS}
+          Valid keys are #{HASH_VALUE_KEYS.join(', ')}
         MESSAGE
 
-        [k, v.to_sym]
+        [k, (v.respond_to?(:to_sym) ? v.to_sym : v)]
       end.to_h
 
       ["#{method}_dynamic", hash]
@@ -143,26 +141,26 @@ module Leftovers
     end
 
     def add_prefix_dynamic(string, method_node)
-      "#{dynamic_value(@add_prefix_dynamic, method_node)}#{@add_prefix_dynamic[:joiner]}#{string}"
+      prefix = dynamic_value(@add_prefix_dynamic, method_node)
+      "#{prefix}#{@add_prefix_dynamic[:joiner] if prefix}#{string}"
     end
 
     def add_suffix_dynamic(string, method_node)
-      "#{string}#{@add_suffix_dynamic[:joiner]}#{dynamic_value(@add_suffix_dynamic, method_node)}"
+      suffix = dynamic_value(@add_suffix_dynamic, method_node)
+      "#{string}#{@add_suffix_dynamic[:joiner] if suffix}#{suffix}"
     end
 
     def dynamic_value(value, method_node)
-      method_node.kwargs[value[:from_argument]].to_s if value[:from_argument]
+      method_node[value[:from_argument]] if value[:from_argument]
     end
 
     def activesupport_available?(method) # rubocop:disable Metrics/MethodLength
-      Leftovers.try_require(
-        'active_support/core_ext/string', 'active_support/inflections',
-        message: <<~MESSAGE
-          Tried transforming a string using an activesupport method (#{method}), but the activesupport gem was not available
-          `gem install activesupport`
-        MESSAGE
-      )
-
+      message = <<~MESSAGE
+        Tried transforming a string using an activesupport method (#{method}), but the activesupport gem was not available
+        `gem install activesupport`
+      MESSAGE
+      Leftovers.try_require('active_support/core_ext/string', message: message)
+      Leftovers.try_require('active_support/inflections', message: message)
       Leftovers.try_require(::File.join(Leftovers.pwd, 'config', 'initializers', 'inflections.rb'))
 
       defined?(ActiveSupport)

data/lib/leftovers/value_rule.rb

@@ -9,19 +9,20 @@ module Leftovers
       Leftovers.each_or_self(values) do |value|
         case value
         when Hash
-          raise ArgumentError, "invalid value #{value.inspect}" unless value[:type]
+          raise Leftovers::ConfigError, "invalid value #{value.inspect}" unless value[:type]
 
           value_types.merge(
             Array(value[:type]).map do |v|
               case v
-              when 'String', :String then :str
-              when 'Symbol', :Symbol then :sym
+              when 'String' then :str
+              when 'Symbol' then :sym
+              when 'Integer' then :int
               else v.to_s.downcase.to_sym
               end
             end
           )
         else
-          (literal_values << value) if value
+          literal_values << value
         end
       end
 

data/lib/leftovers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leftovers
-  VERSION = '0.2.3'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leftovers
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Dana Sherson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-22 00:00:00.000000000 Z
+date: 2020-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.74'
+        version: '0.82'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.74'
+        version: '0.82'
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +136,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.35'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.18.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.18.5
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty_string
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: spellr
   requirement: !ruby/object:Gem::Requirement
@@ -156,14 +198,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -226,7 +268,7 @@ files:
 - lib/config/rollbar.yml
 - lib/config/rspec.yml
 - lib/config/ruby.yml
-- lib/config/selenium.yml
+- lib/config/selenium-webdriver.yml
 - lib/config/sidekiq.yml
 - lib/config/simplecov.yml
 - lib/config/will_paginate.yml