leftovers 0.2.2 → 0.4.2

data/lib/config/selenium.yml

@@ -1,21 +0,0 @@
-rules:
-  skip: true
-  name:
-    - before_navigate_to
-    - before_navigate_back
-    - after_navigate_back
-    - before_navigate_forward
-    - after_navigate_forward
-    - before_find
-    - after_find
-    - before_click
-    - before_change_value_of
-    - after_change_value_of
-    - before_execute_script
-    - after_execute_script
-    - before_quit
-    - before_close
-    - after_navigate_to
-    - after_click
-    - after_quit
-    - after_close

data/lib/leftovers/argument_rule.rb

@@ -1,219 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'definition'
-require_relative 'definition_set'
-require_relative 'name_rule'
-require_relative 'transform_rule'
-require_relative 'hash_rule'
-
-module Leftovers
-  class ArgumentRule # rubocop:disable Metrics/ClassLength
-    def self.wrap(rules, definer: false) # rubocop:disable Metrics/MethodLength
-      case rules
-      when Array
-        rules.flat_map { |r| wrap(r, definer: definer) }
-      when Hash
-        [new(**rules, definer: definer)]
-      else
-        []
-      end
-    end
-
-    ADDITIONAL_VALID_KEYS = Leftovers::TransformRule::VALID_TRANSFORMS + %i{if unless}
-    def initialize( # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength, Metrics/CyclomaticComplexity
-      argument: nil,
-      arguments: nil,
-      key: nil,
-      keys: nil,
-      itself: false,
-      linked_transforms: nil,
-      transforms: nil,
-      definer: false,
-      **options
-    )
-      assert_valid_keys(options, ADDITIONAL_VALID_KEYS)
-      prepare_argument(argument, arguments)
-      @key = prepare_key(key, keys)
-      @itself = itself
-
-      unless @positions || @keywords || @all_positions || @all_keywords || @key || @itself
-        raise ArgumentError, "require at least one of 'argument(s)', 'key(s)', itself"
-      end
-
-      @if = prepare_condition(options.delete(:if))
-      @unless = prepare_condition(options.delete(:unless))
-      @transforms = prepare_transform(options, transforms, linked_transforms)
-      @definer = definer
-    end
-
-    def prepare_transform(options, transforms, linked_transforms) # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/AbcSize
-      if linked_transforms && transforms
-        raise ArgumentError, 'Only use one of linked_transforms/transforms'
-      end
-      return if !linked_transforms && !transforms && options.empty?
-
-      if !(linked_transforms || transforms)
-        @transform = TransformRule.new(options)
-      else
-        @linked = !!linked_transforms
-
-        transforms = (linked_transforms || transforms).map do |transform|
-          transform = { transform.to_sym => true } if transform.is_a?(String)
-          Leftovers::TransformRule.new(options.merge(transform))
-        end
-
-        if transforms.length <= 1
-          @transform = transforms.first
-        else
-          @transforms = transforms
-        end
-      end
-    end
-
-    def prepare_condition(conditions)
-      Leftovers.array_wrap(conditions).each do |cond|
-        cond[:has_argument] = HashRule.new(cond[:has_argument]) if cond[:has_argument]
-      end
-    end
-
-    def prepare_key(key, keys)
-      raise ArgumentError, 'Only use one of key/keys' if key && keys
-
-      key || keys
-    end
-
-    def prepare_argument(argument, arguments) # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
-      raise ArgumentError, 'Only use one of argument/arguments' if argument && arguments
-
-      positions = Set.new
-      keywords = []
-
-      Leftovers.each_or_self(argument || arguments) do |arg|
-        case arg
-        when '*'
-          @all_positions = true
-        when '**'
-          @all_keywords = true
-        when Integer
-          positions << arg - 1
-        when String, Symbol, Hash
-          keywords << arg
-        end
-      end
-
-      @positions = positions unless @all_positions || positions.empty? || @all_positions
-      @keywords = NameRule.new(keywords) unless @all_keywords || keywords.empty?
-    end
-
-    def matches(method_node) # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/AbcSize
-      return [].freeze unless all_conditions_match?(method_node)
-
-      result = []
-
-      if @all_positions
-        result.leftovers_append values(method_node.positional_arguments, method_node)
-      elsif @positions
-        result.leftovers_append(
-          values(method_node.positional_arguments_at(@positions).compact, method_node)
-        )
-      end
-
-      if @keywords || @all_keywords || @key
-        result.leftovers_append hash_values(method_node.kwargs, method_node)
-      end
-      result << method_value(method_node) if @itself
-
-      result
-    end
-
-    def values(value_nodes, method_node)
-      value_nodes.flat_map { |value_node| value(value_node, method_node) }.compact
-    end
-
-    def all_conditions_match?(method_node)
-      @if.all? { |c| condition_match?(c, method_node) } &&
-        @unless.all? { |c| !condition_match?(c, method_node) }
-    end
-
-    def condition_match?(condition, method_name)
-      return unless condition[:has_argument]
-
-      hash_node = method_name.kwargs
-      return false unless hash_node
-
-      hash_node.each_pair.any? { |key, value| condition[:has_argument].match_pair?(key, value) }
-    end
-
-    def hash_values(hash_node, method_node) # rubocop:disable Metrics/MethodLength
-      return unless hash_node
-
-      value_nodes = []
-      value_nodes.concat hash_node.keys if @key
-
-      if @all_keywords
-        value_nodes.concat(hash_node.values)
-      elsif @keywords
-        value_nodes.concat(hash_node.values_at_match(@keywords))
-      end
-
-      values(value_nodes, method_node)
-    end
-
-    def value(value_node, method_node) # rubocop:disable Metrics/MethodLength
-      return unless value_node
-
-      value_node = value_node.unwrap_freeze
-
-      case value_node.type
-      when :array
-        values(value_node.values, method_node)
-      when :hash
-        hash_values(value_node, method_node)
-      when :str, :sym
-        symbol_values(value_node, method_node)
-      end
-    end
-
-    SPLIT = /[.:]+/.freeze
-    def symbol_values(symbol_node, method_node) # rubocop:disable Metrics/MethodLength
-      subnodes = Array(transform(symbol_node.to_s, method_node))
-        .flat_map { |s| s.to_s.split(SPLIT).map(&:to_sym) }
-
-      return subnodes unless @definer
-
-      location = symbol_node.loc.expression
-      if @linked
-        Leftovers::DefinitionSet.new(subnodes, location: location, method_node: method_node)
-      else
-        subnodes.map do |subnode|
-          Leftovers::Definition.new(subnode, location: location, method_node: method_node)
-        end
-      end
-    end
-
-    def method_value(method_node)
-      value = transform(method_node.to_s, method_node)
-
-      return value unless @definer
-
-      Leftovers::Definition.new(value, method_node: method_node)
-    end
-
-    def transform(string, method_node)
-      return string unless @transform || @transforms
-      return @transform.transform(string, method_node) if @transform
-
-      @transforms.map do |transform|
-        transform.transform(string, method_node)
-      end
-    end
-
-    def assert_valid_keys(options, keys)
-      invalid = options.keys - keys
-
-      return if invalid.empty?
-
-      raise ArgumentError, "unknown keyword#{'s' if invalid.length > 1}: #{invalid.join(', ')}"
-    end
-  end
-end

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
-    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