leftovers 0.2.3 → 0.4.3

data/lib/leftovers/core_ext.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-class Array
-  def leftovers_append(other)
-    case other
-    when Array, Set then concat(other)
-    when nil then self
-    else self.<< other
-    end
-  end
-end

data/lib/leftovers/hash_rule.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-require_relative 'value_rule'
-require_relative 'name_rule'
-
-module Leftovers
-  class HashRule
-    def initialize(patterns) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
-      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])
-          ]
-        else
-          keys << NameRule.new(pat)
-        end
-      end
-
-      @keys = (NameRule.new(keys) if keys)
-
-      @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)
-
-      @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))
-      end
-    end
-  end
-end

data/lib/leftovers/name_rule.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-module Leftovers
-  class NameRule
-    attr_reader :sym, :syms, :regexp
-
-    def initialize(patterns) # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
-      regexps = []
-      syms = Set.new
-      Leftovers.each_or_self(patterns) do |pat|
-        case pat
-        when Leftovers::NameRule
-          syms.merge(pat.sym) if pat.sym
-          syms.merge(pat.syms) if pat.syms
-          regexps.concat(pat.regexp) if pat.regexp
-        when String
-          syms.merge(pat.split(/\s+/).map(&:to_sym))
-        when Hash
-          if pat[:match]
-            regexps << /\A#{pattern[:match]}\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/
-          end
-        end
-      end
-
-      if syms.length <= 0
-        @sym = syms.first
-        @syms = nil
-      else
-        @sym = nil
-        @syms = syms
-      end
-
-      @regexp = if regexps.empty?
-        nil
-      else
-        Regexp.union(regexps)
-      end
-
-      freeze
-    end
-
-    def match?(sym, string)
-      @sym&.==(sym) || @syms&.include?(sym) || @regexp&.match?(string)
-    end
-  end
-end

data/lib/leftovers/rule.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'name_rule'
-require_relative 'argument_rule'
-require 'fast_ignore'
-
-module Leftovers
-  class Rule
-    def self.wrap(rules)
-      case rules
-      when Array then rules.flat_map { |r| wrap(r) }
-      when nil then [].freeze
-      else new(**rules)
-      end
-    end
-
-    attr_reader :skip
-    alias_method :skip?, :skip
-
-    def initialize( # rubocop:disable Metrics/ParameterLists, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
-      name: nil,
-      names: nil,
-      calls: nil,
-      call: nil,
-      skip: false,
-      defines: nil,
-      define: nil,
-      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}"
-      end
-
-      @name_matcher = NameRule.new(name || names)
-      @path = FastIgnore.new(include_rules: path || paths, gitignore: false) if path || paths
-      @skip = skip
-
-      begin
-        @calls = ArgumentRule.wrap(calls)
-      rescue ArgumentError => e
-        raise e, "#{e.message} for calls for #{name}", e.backtrace
-      end
-
-      begin
-        @defines = ArgumentRule.wrap(defines, definer: true)
-      rescue ArgumentError => e
-        raise e, "#{e.message} for defines for #{name}", e.backtrace
-      end
-    end
-
-    def filename?(file)
-      return true unless @path
-
-      @path.allowed?(file)
-    end
-
-    def match?(name, name_s, file)
-      @name_matcher.match?(name, name_s) && filename?(file)
-    end
-
-    def calls(node)
-      @calls.flat_map { |m| m.matches(node) }
-    end
-
-    def definitions(node)
-      @defines.flat_map { |m| m.matches(node) }
-    end
-  end
-end

data/lib/leftovers/transform_rule.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  class TransformRule # rubocop:disable Metrics/ClassLength
-    # :nocov:
-    using ::Leftovers::StringDeletePrefixSuffix if defined?(::Leftovers::StringDeletePrefixSuffix)
-    # :nocov:
-
-    RUBY_STRING_METHODS = %i{
-      downcase
-      upcase
-      capitalize
-      swapcase
-    }.freeze
-
-    ACTIVESUPPORT_STRING_METHODS = %i{
-      pluralize
-      singularize
-      camelize
-      camelcase
-      underscore
-      titleize
-      titlecase
-      demodulize
-      deconstantize
-      parameterize
-    }.freeze
-
-    CUSTOM_TRANSFORMS = %i{
-      original
-      delete_before
-      delete_after
-      add_prefix
-      add_suffix
-      delete_prefix
-      delete_suffix
-      replace_with
-    }.freeze
-
-    VALID_TRANSFORMS = RUBY_STRING_METHODS + ACTIVESUPPORT_STRING_METHODS + CUSTOM_TRANSFORMS
-    # more possible transformations
-    # gsub sub tr tr_s
-    def initialize(transforms)
-      @transforms = prepare_transforms(transforms)
-
-      freeze
-    end
-
-    def transform(original_string, method_node)
-      string = original_string
-      @transforms.each { |proc| string = proc.call(string, method_node) }
-
-      string.to_sym
-    end
-
-    private
-
-    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}"
-          MESSAGE
-        end
-
-        key, value = prepare_hash_value(key, value) if value.is_a?(Hash)
-
-        instance_variable_set(:"@#{key}", value.freeze)
-        method(key)
-      end
-    end
-
-    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}
-      MESSAGE
-
-      hash = hash.map do |k, v|
-        raise ArgumentError, <<~MESSAGE unless HASH_VALUE_KEYS.include?(k)
-          invalid transform value argument (#{method}: { #{k}: #{v} }).
-          Hash values are only valid for #{HASH_VALUE_TRANSFORMS}
-        MESSAGE
-
-        [k, v.to_sym]
-      end.to_h
-
-      ["#{method}_dynamic", hash]
-    end
-
-    RUBY_STRING_METHODS.each do |method|
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{method}(string, _method_node)
-          string.#{method}
-        end
-      RUBY
-    end
-
-    # leftovers:call activesupport_available?
-    ACTIVESUPPORT_STRING_METHODS.each do |method|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{method}(string, _method_node)
-          return string unless activesupport_available?(:#{method})
-
-          string.#{method}
-        end
-      RUBY
-    end
-
-    def original(string, _method_node)
-      string
-    end
-
-    def delete_prefix(string, _method_node)
-      string.delete_prefix(@delete_prefix)
-    end
-
-    def delete_suffix(string, _method_node)
-      string.delete_suffix(@delete_suffix)
-    end
-
-    def delete_before(string, _method_node)
-      string.split(@delete_before, 2)[1] || string
-    end
-
-    def delete_after(string, _method_node)
-      string.split(@delete_after, 2).first || string
-    end
-
-    def replace_with(_string, _method_node)
-      @replace_with
-    end
-
-    def add_prefix(string, _method_node)
-      "#{@add_prefix}#{string}"
-    end
-
-    def add_suffix(string, _method_node)
-      "#{string}#{@add_suffix}"
-    end
-
-    def add_prefix_dynamic(string, method_node)
-      "#{dynamic_value(@add_prefix_dynamic, method_node)}#{@add_prefix_dynamic[:joiner]}#{string}"
-    end
-
-    def add_suffix_dynamic(string, method_node)
-      "#{string}#{@add_suffix_dynamic[:joiner]}#{dynamic_value(@add_suffix_dynamic, method_node)}"
-    end
-
-    def dynamic_value(value, method_node)
-      method_node.kwargs[value[:from_argument]].to_s 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
-      )
-
-      Leftovers.try_require(::File.join(Leftovers.pwd, 'config', 'initializers', 'inflections.rb'))
-
-      defined?(ActiveSupport)
-    end
-  end
-end

data/lib/leftovers/value_rule.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Leftovers
-  class ValueRule
-    def initialize(values) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
-      literal_values = Set.new
-      value_types = Set.new
-
-      Leftovers.each_or_self(values) do |value|
-        case value
-        when Hash
-          raise ArgumentError, "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
-              else v.to_s.downcase.to_sym
-              end
-            end
-          )
-        else
-          (literal_values << value) if value
-        end
-      end
-
-      if literal_values.length <= 1
-        @literal_value = literal_values.first
-        @literal_values = nil
-      else
-        @literal_value = nil
-        @literal_values = literal_values
-      end
-
-      if value_types.length <= 1
-        @value_type = value_types.first
-        @value_types = nil
-      else
-        @value_type = nil
-        @value_types = value_types
-      end
-
-      freeze
-    end
-
-    def match?(value_node) # rubocop:disable Metrics/CyclomaticComplexity
-      return true if @value_type&.== value_node.type
-      return true if @value_types&.include?(value_node.type)
-      return false unless (@literal_value || @literal_values) && value_node.scalar?
-      return true if @literal_value&.== value_node.to_scalar_value
-
-      @literal_values&.include?(value_node.to_scalar_value)
-    end
-  end
-end