leftovers 0.1.0

data/lib/leftovers/node.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'parser'
+
+module Parser
+  module AST
+    class Node # rubocop:disable Metrics/ClassLength
+      def initialize(type, children = [], properties = {})
+        # ::AST::Node#initialize freezes itself.
+        # so can't use normal memoizations
+        @memo = {}
+
+        super
+      end
+
+      def first
+        children.first
+      end
+
+      def file
+        @memo[:file]
+      end
+
+      def file=(value)
+        @memo[:file] = value
+      end
+
+      def test
+        @memo[:test]
+      end
+      alias_method :test?, :test
+
+      def test=(value)
+        @memo[:test] = value
+      end
+
+      def to_scalar_value # rubocop:disable Metrics/MethodLength
+        @memo[:scalar_value] ||= case type
+        when :sym
+          first
+        when :str
+          first.to_s.freeze
+        when :true
+          true
+        when :false
+          false
+        when :nil
+          nil
+        else
+          raise "Not scalar node, (#{type})"
+        end
+      end
+
+      def to_s # rubocop:disable Metrics/MethodLength
+        @memo[:to_s] ||= if scalar?
+          to_scalar_value
+        elsif named?
+          name
+        else
+          raise "No to_s, (#{type})"
+        end.to_s.freeze
+      end
+
+      def to_sym
+        case type
+        when :str, :sym then first
+        when :nil, :true, :false then type
+        else to_s.to_sym
+        end
+      end
+
+      SCALAR_TYPES = %i{sym str true false nil}.freeze
+      def scalar?
+        SCALAR_TYPES.include?(type)
+      end
+
+      def string_or_symbol?
+        type == :str || type == :sym
+      end
+
+      def send?
+        type == :send || type == :csend
+      end
+
+      def named?
+        send? || type == :casgn
+      end
+
+      def arguments
+        @memo[:arguments] ||= case type
+        when :send, :csend then children.drop(2)
+        when :casgn then [children[2]]
+        else raise "Not argument node (#{type})"
+        end
+      end
+
+      def positional_arguments
+        @memo[:positional_arguments] ||= kwargs ? arguments[0...-1] : arguments
+      end
+
+      def unwrap_freeze
+        return self unless type == :send && name == :freeze
+
+        first
+      end
+
+      def kwargs
+        @memo.fetch(:kwargs) do
+          last_arg = arguments[-1]&.unwrap_freeze
+          @memo[:kwargs] = (last_arg if last_arg&.type == :hash)
+        end
+      end
+
+      def keys
+        each_pair.map { |k, _| k }
+      end
+
+      def key?(key)
+        each_pair.find do |k, _v|
+          next unless k.string_or_symbol?
+
+          k.to_sym == key
+        end
+      end
+
+      def values
+        @memo[:kwargs] ||= case type
+        when :hash then each_pair.map { |_, v| v }
+        when :array then children
+        else []
+        end
+      end
+
+      def values_at_match(matcher)
+        each_pair.with_object([]) do |(key, value), values|
+          values << value if matcher.match?(key.to_sym, key.to_s)
+        end
+      end
+
+      def positional_arguments_at(positions)
+        positional_arguments.values_at(*positions).compact
+      end
+
+      def each_pair
+        raise "not hash node (#{type})" unless type == :hash
+
+        return enum_for(:each_pair) unless block_given?
+
+        children.each do |pair|
+          yield(*pair.children) if pair.type == :pair
+        end
+      end
+
+      def name
+        return "Not named node (#{type})" unless named?
+
+        @memo[:name] ||= children[1]
+      end
+
+      def name_s
+        @memo[:name_s] ||= name.to_s.freeze
+      end
+
+      def [](index) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+        case type
+        when :send, :csend
+          index.is_a?(Integer) ? arguments[index] : kwargs && kwargs[index]
+        when :array
+          children[index]
+        when :hash
+          each_pair do |key, value|
+            next unless key.string_or_symbol?
+
+            return value if key.to_sym == index
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/rake_task.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'shellwords'
+require_relative 'cli'
+
+module Leftovers
+  class RakeTask
+    include ::Rake::DSL
+
+    def self.generate_task(name = :leftovers, *default_argv) # rubocop:disable
+      new(name, default_argv)
+
+      name
+    end
+
+    def initialize(name, default_argv)
+      @name = name
+      @default_argv = default_argv
+
+      describe_task
+      define_task
+    end
+
+    private
+
+    def escaped_argv(argv = @default_argv)
+      return if argv.empty?
+
+      Shellwords.shelljoin(argv)
+    end
+
+    def describe_task
+      return desc('Run leftovers') if @default_argv.empty?
+
+      desc("Run leftovers (default args: #{escaped_argv})")
+    end
+
+    def define_task
+      task(@name, :'*args') do |_, task_argv|
+        argv = argv_or_default(task_argv)
+        write_cli_cmd(argv)
+        run(argv)
+      end
+    end
+
+    def write_cli_cmd(argv)
+      $stdout.puts("\e[2mleftovers #{escaped_argv(argv)}\e[0m")
+    end
+
+    def run(argv)
+      Leftovers::CLI.new(argv: argv, stdout: $stdout, stderr: $stderr)
+    rescue SystemExit => e
+      raise unless e.status == 0
+    end
+
+    def argv_or_default(task_argv)
+      task_argv = task_argv.to_a.compact
+      task_argv.empty? ? @default_argv : task_argv
+    end
+  end
+end

data/lib/leftovers/reporter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+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
+      )
+    end
+  end
+end

data/lib/leftovers/rule.rb

@@ -0,0 +1,74 @@
+# 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

@@ -0,0 +1,171 @@
+# 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

data/lib/leftovers/value_rule.rb

@@ -0,0 +1,56 @@
+# 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
+
+      Array.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

data/lib/leftovers/version.rb

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

data/lib/leftovers.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative './leftovers/core_ext'
+require_relative './leftovers/backports'
+require_relative './leftovers/collector'
+require_relative './leftovers/merged_config'
+require_relative './leftovers/reporter'
+
+module Leftovers
+  module_function
+
+  class << self
+    attr_accessor :parallel
+    alias_method :parallel?, :parallel
+
+    attr_accessor :quiet
+    alias_method :quiet?, :quiet
+
+    attr_accessor :progress
+    alias_method :progress?, :progress
+  end
+
+  def stdout
+    @stdout ||= StringIO.new
+  end
+
+  def stderr
+    @stderr ||= StringIO.new
+  end
+
+  def config
+    @config ||= Leftovers::MergedConfig.new
+  end
+
+  def collector
+    @collector ||= Leftovers::Collector.new
+  end
+
+  def reporter
+    @reporter ||= Leftovers::Reporter.new
+  end
+
+  def leftovers # rubocop:disable Metrics/MethodLength
+    @leftovers ||= begin
+      collector.collect
+      collector.definitions.reject do |definition|
+        definition.skipped? || definition.in_collection?
+      end
+    end
+  end
+
+  def run(stdout: StringIO.new, stderr: StringIO.new) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    reset
+    @stdout = stdout
+    @stderr = stderr
+    return 0 if leftovers.empty?
+
+    only_test = []
+    none = []
+    leftovers.sort.each do |definition|
+      if !definition.test? && definition.in_test_collection?
+        only_test << definition
+      else
+        none << definition
+      end
+    end
+
+    unless only_test.empty?
+      puts "\e[31mOnly directly called in tests:\e[0m"
+      only_test.each { |definition| reporter.call(definition) }
+    end
+
+    unless none.empty?
+      puts "\e[31mNot directly called at all:\e[0m"
+      none.each { |definition| reporter.call(definition) }
+    end
+
+    1
+  end
+
+  def reset # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    remove_instance_variable(:@config) if defined?(@config)
+    remove_instance_variable(:@collector) if defined?(@collector)
+    remove_instance_variable(:@reporter) if defined?(@reporter)
+    remove_instance_variable(:@leftovers) if defined?(@leftovers)
+    remove_instance_variable(:@try_require) if defined?(@try_require)
+    remove_instance_variable(:@stdout) if defined?(@stdout)
+    remove_instance_variable(:@stderr) if defined?(@stderr)
+    remove_instance_variable(:@parallel) if defined?(@parallel)
+    remove_instance_variable(:@quiet) if defined?(@quiet)
+    remove_instance_variable(:@pwd) if defined?(@pwd)
+  end
+
+  def warn(message)
+    stderr.puts("\e[2K#{message}") unless quiet?
+  end
+
+  def puts(message)
+    stdout.puts("\e[2K#{message}") unless quiet?
+  end
+
+  def print(message)
+    stdout.print(message) unless quiet?
+  end
+
+  def newline
+    stdout.puts('')
+  end
+
+  def pwd
+    @pwd ||= Pathname.new(Dir.pwd + '/')
+  end
+
+  def try_require(*requirables, message: nil) # rubocop:disable Metrics/MethodLength
+    @try_require ||= {}
+    requirables.each do |requirable|
+      begin
+        return @try_require[requirable] if @try_require.key?(requirable)
+
+        @try_require[requirable] = require requirable
+      rescue LoadError
+        warn message if message
+        @try_require[requirable] = false
+      end
+    end
+  end
+end