leftovers 0.3.0 → 0.4.0

data/lib/leftovers/argument_rule.rb

@@ -1,229 +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 Leftovers::ConfigError, "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 Leftovers::ConfigError, '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 = Leftovers.array_wrap(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) # rubocop:disable Metrics/MethodLength
-      Leftovers.array_wrap(conditions).each do |cond|
-        unless cond.is_a?(Hash) && cond.keys == [:has_argument]
-          raise Leftovers::ConfigError, <<~MESSAGE
-            Invalid condition #{cond.inspect}. Valid condition keys are: has_argument
-          MESSAGE
-        end
-
-        cond[:has_argument] = HashRule.new(cond[:has_argument])
-      end
-    end
-
-    def prepare_key(key, keys)
-      raise Leftovers::ConfigError, '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 Leftovers::ConfigError, '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
-        else
-          raise Leftovers::ConfigError, <<~MESSAGE
-            Invalid value for argument: #{arg.inspect}. Must by a string ('*', '**', or a keyword), or a hash with the name match rules, or an integer, or an array of these
-          MESSAGE
-        end
-      end
-
-      @positions = positions unless @all_positions || positions.empty? || @all_positions
-      @keywords = NameRule.wrap(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_node)
-      method_node.positional_arguments.each.with_index(1).any? do |value, index|
-        condition[:has_argument].match_pair?(index, value)
-      end || method_node.kwargs&.each_pair&.any? do |key, value|
-        condition[:has_argument].match_pair?(key.to_sym, value)
-      end
-    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
-      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) # rubocop:disable Metrics/MethodLength
-      invalid = options.keys - keys
-
-      return if invalid.empty?
-
-      raise(
-        Leftovers::ConfigError,
-        "unknown keyword#{'s' if invalid.length > 1}: #{invalid.join(', ')}"
-      )
-    end
-  end
-end

data/lib/leftovers/core_ext.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-class Array
-  def leftovers_append(other) # rubocop:disable Metrics/MethodLength
-    return self if other.nil?
-
-    if other.respond_to?(:to_a)
-      concat(other.to_a)
-    else
-      self << other
-    end
-  end
-end

data/lib/leftovers/hash_rule.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-require_relative 'value_rule'
-require_relative 'name_rule'
-
-module Leftovers
-  class HashRule
-    # :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.wrap(pat[:keyword] || pat[:index]),
-            ValueRule.new(pat[:value])
-          ]
-        else
-          keys << NameRule.wrap(pat)
-        end
-      end
-
-      @keys = NameRule.wrap(keys, false)
-
-      @pairs = (pairs unless pairs.empty?)
-
-      freeze
-    end
-
-    def match_pair?(key, value_node)
-      return true if @keys === key
-
-      @pairs&.any? do |(key_rule, value_rule)|
-        key_rule === key && value_rule.match?(value_node)
-      end
-    end
-  end
-end

data/lib/leftovers/name_rule.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-module Leftovers
-  class NameRule
-    # :nocov:
-    using ::Leftovers::SetCaseEq if defined?(::Leftovers::SetCaseEq)
-    # :nocov:
-
-    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| # 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
-          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#{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
-
-      syms = syms.first if syms.length <= 1
-
-      regexp = if regexps.empty?
-        nil
-      else
-        Regexp.union(regexps).freeze
-      end
-
-      if syms && regexp
-        new(syms, regexp)
-      else
-        syms || regexp || (
-          default ? ::Leftovers::NameRule::TrueReturner : ::Leftovers::NameRule::FalseReturner
-        )
-      end
-    end
-
-    def initialize(syms, regexp)
-      @syms = syms
-      @regexp = regexp
-
-      freeze
-    end
-
-    def ===(sym)
-      @syms === sym || @regexp === sym
-    end
-  end
-end

data/lib/leftovers/rule.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'name_rule'
-require_relative 'argument_rule'
-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) }
-      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 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.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, Leftovers::ConfigError => e
-        raise e, "#{e.message} for calls", e.backtrace
-      end
-
-      begin
-        @defines = ArgumentRule.wrap(defines, definer: true)
-      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)
-      return true unless @path
-
-      @path.allowed?(file)
-    end
-
-    def match?(name, file)
-      @name_matcher === name && 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