leftovers 0.1.0

data/lib/config/rspec.yml

@@ -0,0 +1,56 @@
+test_paths:
+  - /spec/
+
+rules:
+  - skip: true
+    name:
+      # matchers
+      - diffable?
+      - actual
+      # formatters:
+      - start
+      - example_group_started
+      - example_started
+      - example_passed
+      - example_failed
+      - example_pending
+      - message
+      - stop
+      - start_dump
+      - dump_pending
+      - dump_failures
+      - dump_summary
+      - seed
+      - close
+  - name:
+      - have_attributes
+      - has_attributes?
+      - receive_messages
+    calls:
+      - keys: '*'
+  - name:
+    - receive
+    - respond_to
+    calls:
+      argument: 1
+  - name: define_negated_matcher
+    defines:
+      argument: 1
+    calls:
+      argument: 2
+  - name:
+      has_prefix: be_
+    calls:
+      itself: true
+      delete_prefix: be_
+      add_suffix: '?'
+  - name:
+      has_prefix: have_
+    calls:
+      itself: true
+      add_suffix: '?'
+      delete_prefix: have_
+      add_prefix: has_
+  - name: let
+    defines:
+      argument: 1

data/lib/config/ruby.yml

@@ -0,0 +1,77 @@
+---
+include_paths:
+  - '*.rb'
+  - Gemfile
+  - '*.erb'
+  - '*.gemspec'
+  - .irbrc
+  - irb.rc
+  - _irbrc
+  - $irbrc
+
+test_paths:
+  - /tests/
+  - /test/
+
+rules:
+  - skip: true
+    name:
+      - initialize # called by new
+      - inspect # called by repl
+      - respond_to_missing? # called by respond_to?
+      - method_missing # called by method dispatch
+      - to_s # called by #{}
+      - to_ary
+      - to_str
+      - <=> # called by Comparable
+      - each # called by Enumerable
+      - marshal_dump # called by Marshal.dump
+      - marshal_load # called by Marshal.load
+      - _dump # called by Marshal.dump
+      - _load # called by Marshal.load
+  - name:
+      - send
+      - public_send
+      - __send__
+      - method
+      - respond_to?
+      - instance_method
+    calls:
+      argument: 1
+  - name: attr_reader
+    defines:
+      argument: '*'
+    calls:
+      argument: '*'
+      add_prefix: '@'
+  - name: attr_writer
+    defines:
+      argument: '*'
+      add_suffix: '='
+  - name: attr_accessor
+    defines:
+      - argument: '*'
+        transforms:
+          - original
+          - add_suffix: '='
+    calls:
+      argument: '*'
+      add_prefix: '@'
+  - name: define_method
+    defines:
+      argument: 1
+  - name: alias_method
+    defines:
+      argument: 1
+    calls:
+      argument: 2
+  - name:
+      - instance_variable_get
+      - class_variable_set
+    calls:
+      argument: 1
+  - name:
+      - instance_variable_set
+      - class_variable_set
+    defines:
+      argument: 1

data/lib/config/selenium.yml

@@ -0,0 +1,21 @@
+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/config/simplecov.yml

@@ -0,0 +1,2 @@
+include_paths:
+  - .simplecov

data/lib/config/will_paginate.yml

@@ -0,0 +1,14 @@
+rules:
+  skip: true
+  name:
+    # WillPaginate::ViewHelpers::LinkRenderer
+    - page_number
+    - gap
+    - previous_page
+    - next_page
+    - previous_or_next_page
+    - html_container
+    - url
+    - prepare
+    - to_html
+    - container_attributes

data/lib/leftovers/argument_rule.rb

@@ -0,0 +1,216 @@
+# 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)
+      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 = []
+
+      Array.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
+      return Array::EMPTY unless all_conditions_match?(method_node)
+
+      result = []
+
+      if @all_positions
+        result.gather values(method_node.positional_arguments, method_node)
+      elsif @positions
+        result.gather values(method_node.positional_arguments_at(@positions).compact, method_node)
+      end
+
+      if @keywords || @all_keywords || @key
+        result.gather 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 = symbol_node.to_s.split(SPLIT).flat_map { |s| transform(s, method_node) }
+
+      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.to_sym 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/backports.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Leftovers
+  ruby_version = Gem::Version.new(RUBY_VERSION)
+  unless ruby_version >= Gem::Version.new('2.5')
+    module StringDeletePrefixSuffix
+      refine ::String do
+        def delete_prefix!(str)
+          slice!(0..(str.length - 1)) if start_with?(str)
+          self
+        end
+
+        def delete_suffix!(str)
+          slice!(-str.length..-1) if end_with?(str)
+          self
+        end
+
+        def delete_prefix(str)
+          dup.delete_prefix!(str)
+        end
+
+        def delete_suffix(str)
+          dup.delete_suffix!(str)
+        end
+      end
+    end
+
+    require 'yaml'
+    module YAMLSymbolizeNames
+      refine YAML.singleton_class do
+        alias_method :safe_load_without_symbolize_names, :safe_load
+        def safe_load(path, *args, symbolize_names: false, **kwargs)
+          if symbolize_names
+            symbolize_names!(safe_load_without_symbolize_names(path, *args, **kwargs))
+          else
+            safe_load_without_symbolize_names(path, *args, **kwargs)
+          end
+        end
+
+        private
+
+        def symbolize_names!(obj) # rubocop:disable Metrics/MethodLength
+          case obj
+          when Hash
+            obj.keys.each do |key| # rubocop:disable Style/HashEachMethods # each_key never finishes.
+              obj[key.to_sym] = symbolize_names!(obj.delete(key))
+            end
+          when Array
+            obj.map! { |ea| symbolize_names!(ea) }
+          end
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/cli.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require_relative '../leftovers'
+require_relative 'version'
+
+module Leftovers
+  class CLI
+    attr_reader :argv, :stdout, :stderr
+
+    def initialize(argv: [], stdout: StringIO.new, stderr: StringIO.new)
+      @argv = argv
+      @stdout = stdout
+      @stderr = stderr
+
+      parse_options
+
+      exit Leftovers.run(stdout: stdout, stderr: stderr)
+    end
+
+    def parse_options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      opts = OptionParser.new
+      Leftovers.parallel = true
+      Leftovers.progress = true
+
+      opts.banner = 'Usage: leftovers [options]'
+      opts.on('-q', '--quiet', 'Silences output') { Leftovers.quiet = true }
+      opts.on('--[no-]parallel', 'Run in parallel or not, default --parallel') do |p|
+        Leftovers.parallel = p
+      end
+      opts.on('--[no-]progress', 'Show progress counts or not, default --progress') do |p|
+        Leftovers.progress = p
+      end
+      opts.on('-v', '--version', 'Returns the current version') do
+        stdout.puts(Leftovers::Version)
+        exit
+      end
+      opts.on('--dry-run', 'Output files that will be looked at') do
+        stdout.puts(Leftovers::FileList.new.to_a.map(&:relative_path).join("\n"))
+        exit
+      end
+      opts.on('-h', '--help', 'Shows this message') do
+        stdout.puts(opts.help)
+        exit
+      end
+
+      opts.parse(argv)
+    end
+  end
+end

data/lib/leftovers/collector.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'fast_ignore'
+require 'set'
+require 'parallel'
+require_relative 'file_collector'
+require_relative 'file_list'
+
+module Leftovers
+  class Collector
+    attr_reader :calls
+    attr_reader :test_calls
+    attr_reader :definitions
+
+    def initialize # rubocop:disable Metrics/MethodLength
+      @calls = []
+      @test_calls = []
+      @definitions = []
+      @count = 0
+      @count_calls = 0
+      @count_definitions = 0
+    end
+
+    def collect
+      collect_file_list(Leftovers::FileList.new)
+      print_progress
+      Leftovers.newline
+      @calls = @calls.to_set.freeze
+      @test_calls = @test_calls.to_set.freeze
+    end
+
+    def collect_file_list(list)
+      if Leftovers.parallel?
+        Parallel.each(list, finish: method(:finish_parallel), &method(:collect_file))
+      else
+        list.each { |file| finish_parallel(nil, nil, collect_file(file)) }
+      end
+    end
+
+    def collect_file(file)
+      file_collector = Leftovers::FileCollector.new(file.ruby, file)
+      file_collector.collect
+
+      file_collector.to_h
+    end
+
+    def print_progress
+      Leftovers.print(
+        "checked #{@count} files, collected #{@count_calls} calls, #{@count_definitions} definitions\r" # rubocop:disable Layout/LineLength
+      )
+    end
+
+    def finish_parallel(_, _, result) # rubocop:disable Metrics/MethodLength
+      @count += 1
+      @count_calls += result[:calls].length
+      @count_definitions += result[:definitions].length
+      print_progress if Leftovers.progress?
+      if result[:test?]
+        @test_calls.concat(result[:calls])
+      else
+        @calls.concat(result[:calls])
+      end
+
+      @definitions.concat(result[:definitions])
+    end
+  end
+end

data/lib/leftovers/config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative 'rule'
+
+module Leftovers
+  class Config
+    # :nocov:
+    using ::Leftovers::YAMLSymbolizeNames if defined?(::Leftovers::YAMLSymbolizeNames)
+    # :nocov:
+
+    attr_reader :name
+
+    def initialize(
+      name,
+      path: ::File.join(__dir__, '..', 'config', "#{name}.yml"),
+      content: (::File.exist?(path) ? ::File.read(path) : '')
+    )
+      @name = name.to_sym
+      @path = path
+      @content = content
+    end
+
+    def gems
+      @gems ||= Array(yaml[:gems]).map(&:to_sym)
+    end
+
+    def exclude_paths
+      @exclude_paths ||= Array(yaml[:exclude_paths])
+    end
+
+    def include_paths
+      @include_paths ||= Array(yaml[:include_paths])
+    end
+
+    def test_paths
+      @test_paths ||= Array(yaml[:test_paths])
+    end
+
+    def rules
+      @rules ||= Rule.wrap(yaml[:rules])
+    end
+
+    private
+
+    def yaml
+      @yaml ||= YAML.safe_load(@content, symbolize_names: true) || {}
+    rescue Psych::SyntaxError => e
+      warn "\e[31mError with config #{path}: #{e.message}\e[0m"
+      exit 1
+    end
+  end
+end

data/lib/leftovers/core_ext.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'set'
+
+class Array
+  # concat, # push, # add, #
+  EMPTY = [].freeze
+
+  def gather(other)
+    case other
+    when Array, Set then concat(other)
+    when nil then self
+    else self.<< other
+    end
+  end
+
+  def self.wrap(value)
+    case value
+    when nil then EMPTY
+    when Array then value
+    else [value]
+    end
+  end
+
+  def self.each_or_self(value, &block)
+    case value
+    when nil then nil
+    when Array then value.each(&block)
+    else block.call(value)
+    end
+  end
+end