leftovers 0.1.0

data/lib/leftovers/definition.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class Definition
+    attr_reader :name
+    alias_method :names, :name
+    alias_method :full_name, :name
+    attr_reader :name_s
+    alias_method :to_s, :name_s
+    attr_reader :test
+    alias_method :test?, :test
+
+    def initialize( # rubocop:disable Metrics/MethodLength
+      name,
+      method_node: nil,
+      location: method_node.loc.expression,
+      file: method_node.file,
+      test: method_node.test?
+    )
+      @name = name
+      @name_s = name.to_s.freeze
+
+      @location = location
+      @file = file
+      @test = test
+
+      freeze
+    end
+
+    def <=>(other)
+      (path <=> other.path).nonzero? ||
+        (line <=> other.line).nonzero? ||
+        (column <=> other.column)
+    end
+
+    def path
+      @file.relative_path
+    end
+
+    def line
+      @location.line
+    end
+
+    def column
+      @location.column
+    end
+
+    def full_location
+      "#{path}:#{@location.line}:#{@location.column}"
+    end
+
+    def highlighted_source(highlight = "\e[31m", normal = "\e[0m") # rubocop:disable Metrics/AbcSize
+      @location.source_line.to_s[0...(@location.column_range.begin)].lstrip +
+        highlight + @location.source.to_s + normal +
+        @location.source_line.to_s[(@location.column_range.end)..-1].rstrip
+    end
+
+    def in_collection?
+      Leftovers.collector.calls.include?(@name) || (@test && in_test_collection?)
+    end
+
+    def in_test_collection?
+      Leftovers.collector.test_calls.include?(@name)
+    end
+
+    def skipped?
+      Leftovers.config.skip_rules.any? { |r| r.match?(@name, @name_s, path) }
+    end
+  end
+end

data/lib/leftovers/definition_set.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'definition'
+module Leftovers
+  class DefinitionSet < Leftovers::Definition
+    def initialize( # rubocop:disable Metrics/MethodLength
+      names,
+      method_node: nil,
+      location: method_node.loc.expression,
+      file: method_node.file,
+      test: method_node.test?
+    )
+      @definitions = names.map do |name|
+        Leftovers::Definition.new(name, test: test, location: location, file: file)
+      end
+
+      @test = test
+      @location = location
+      @file = file
+
+      freeze
+    end
+
+    def names
+      @definitions.map(&:names)
+    end
+
+    def to_s
+      @definitions.map(&:to_s).join(', ')
+    end
+
+    def in_collection?
+      @definitions.any?(&:in_collection?)
+    end
+
+    def in_test_collection?
+      @definitions.any?(&:in_test_collection?)
+    end
+
+    def skipped?
+      @definitions.any?(&:skipped?)
+    end
+  end
+end

data/lib/leftovers/erb.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Leftovers
+  class ERB < ::ERB::Compiler
+    def self.precompile(erb)
+      @compiler ||= new('-')
+      @compiler.compile(erb).first
+    end
+
+    def add_insert_cmd(out, content)
+      out.push("#{content}\n")
+    end
+
+    def add_put_cmd(out, _content)
+      out
+    end
+  end
+end

data/lib/leftovers/file.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'erb'
+require_relative 'haml'
+require 'pathname'
+
+module Leftovers
+  class File < Pathname
+    def relative_path
+      @relative_path ||= relative_path_from(Leftovers.pwd)
+    end
+
+    def test?
+      return @test if defined?(@test)
+
+      @test = Leftovers.config.test_paths.allowed?(relative_path)
+    end
+
+    def ruby # rubocop:disable Metrics/MethodLength
+      case extname
+      when '.haml'
+        Leftovers::Haml.precompile(read)
+      when '.rhtml', '.rjs', '.erb'
+        Leftovers::ERB.precompile(read)
+      else
+        read
+      end
+    end
+  end
+end

data/lib/leftovers/file_collector.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require 'fast_ignore'
+require 'set'
+require 'parser'
+require 'parser/current'
+require_relative 'node'
+require_relative 'definition'
+
+module Leftovers
+  class FileCollector < Parser::AST::Processor # rubocop:disable Metrics/ClassLength
+    attr_reader :calls
+    attr_reader :definitions
+
+    def initialize(ruby, file) # rubocop:disable Metrics/MethodLength
+      @calls = []
+      @definitions = []
+      @allow_lines = Set.new.compare_by_identity
+      @test_lines = Set.new.compare_by_identity
+      @ruby = ruby
+      @file = file
+    end
+
+    def filename
+      @filename ||= @file.relative_path
+    end
+
+    def to_h
+      {
+        test?: @file.test?,
+        calls: calls,
+        definitions: definitions
+      }
+    end
+
+    def collect
+      ast, comments = Parser::CurrentRuby.parse_with_comments(@ruby)
+      process_comments(comments)
+      process(ast)
+    rescue Parser::SyntaxError => e
+      Leftovers.warn "#{e.class}: #{e.message} #{filename}:#{e.diagnostic.location.line}:#{e.diagnostic.location.column}" # rubocop:disable Layout/LineLength
+    end
+
+    METHOD_NAME_RE = /[[:alpha:]_][[:alnum:]_]*\b[\?!=]?/.freeze
+    NON_ALNUM_METHOD_NAME_RE = Regexp.union(%w{
+      []= [] ** ~ +@ -@ * / % + - >> << &
+      ^ | <=> <= >= < > === == != =~ !~ !
+    }.map { |op| /#{Regexp.escape(op)}/ })
+    CONSTANT_NAME_RE = /[[:upper:]][[:alnum:]_]*\b/.freeze
+    NAME_RE = Regexp.union(METHOD_NAME_RE, NON_ALNUM_METHOD_NAME_RE, CONSTANT_NAME_RE)
+    LEFTOVERS_CALL_RE = /\bleftovers:call(?:s|ed|er|ers|) (#{NAME_RE}(?:[, :]+#{NAME_RE})*)/.freeze
+    LEFTOVERS_ALLOW_RE = /\bleftovers:(?:keeps?|skip(?:s|ped|)|allow(?:s|ed|))\b/.freeze
+    LEFTOVERS_TEST_RE = /\bleftovers:(?:for_tests?|tests?|testing)\b/.freeze
+    def process_comments(comments) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      comments.each do |comment|
+        @allow_lines << comment.loc.line if comment.text.match?(LEFTOVERS_ALLOW_RE)
+
+        @test_lines << comment.loc.line if comment.text.match?(LEFTOVERS_TEST_RE)
+
+        next unless (match = comment.text.match(LEFTOVERS_CALL_RE))
+        next unless match[1]
+
+        match[1].scan(NAME_RE).each { |s| add_call(s.to_sym) }
+      end
+    end
+
+    # grab method definitions
+    def on_def(node)
+      add_definition(node.children.first, node.loc.name)
+
+      super
+    end
+
+    def on_ivasgn(node)
+      add_definition(node.children.first, node.loc.name)
+
+      super
+    end
+    alias_method :on_gvasgn, :on_ivasgn
+    alias_method :on_cvasgn, :on_ivasgn
+
+    def on_ivar(node)
+      add_call(node.children.first)
+
+      super
+    end
+    alias_method :on_gvar, :on_ivar
+    alias_method :on_cvar, :on_ivar
+
+    def on_op_asgn(node)
+      collect_op_asgn(node)
+
+      super
+    end
+
+    def on_and_asgn(node)
+      collect_op_asgn(node)
+
+      super
+    end
+
+    def on_or_asgn(node)
+      collect_op_asgn(node)
+
+      super
+    end
+
+    # grab method calls
+    def on_send(node)
+      super
+
+      add_call(node.children[1])
+
+      collect_rules(node)
+    end
+    alias_method :on_csend, :on_send
+
+    def on_const(node)
+      super
+
+      add_call(node.children[1])
+    end
+
+    # grab e.g. :to_s in each(&:to_s)
+    def on_block_pass(node)
+      super
+
+      add_call(node.children.first.to_sym) if node.children.first&.string_or_symbol?
+    end
+
+    # grab class Constant or module Constant
+    def on_class(node)
+      # don't call super so we don't process the class name
+      # !!! (# wtf does this mean dana? what would happen instead?)
+      process_all(node.children.drop(1))
+
+      node = node.children.first
+
+      add_definition(node.children[1], node.loc.name)
+    end
+    alias_method :on_module, :on_class
+
+    # grab Constant = Class.new or CONSTANT = 'string'.freeze
+    def on_casgn(node)
+      super
+
+      add_definition(node.children[1], node.loc.name)
+
+      collect_rules(node)
+    end
+
+    # grab calls to `alias new_method original_method`
+    def on_alias(node)
+      super
+
+      new_method, original_method = node.children
+
+      add_definition(new_method.children.first, new_method.loc.expression)
+      add_call(original_method.children.first)
+    end
+
+    private
+
+    def test?(loc)
+      @file.test? || @test_lines.include?(loc.line)
+    end
+
+    def add_definition(name, loc)
+      return if @allow_lines.include?(loc.line)
+
+      definitions << Leftovers::Definition.new(name, location: loc, file: @file, test: test?(loc))
+    end
+
+    def add_call(name)
+      calls << name
+    end
+
+    # just collects the call, super will collect the definition
+    def collect_var_op_asgn(node)
+      name = node.children.first
+
+      return unless name
+
+      add_call(name)
+    end
+
+    def collect_send_op_asgn(node)
+      name = node.children[1]
+
+      return unless name
+
+      add_call(:"#{name}=")
+    end
+
+    def collect_op_asgn(node)
+      node = node.children.first
+      case node.type
+      when :send then collect_send_op_asgn(node)
+      when :ivasgn, :gvasgn, :cvasgn then collect_var_op_asgn(node)
+      end
+    end
+
+    def collect_rules(node) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      Leftovers.config.rules.each do |rule|
+        next unless rule.match?(node.name, node.name_s, filename)
+
+        next if rule.skip?
+
+        calls.concat(rule.calls(node))
+
+        next if @allow_lines.include?(node.loc.line)
+
+        node.file = @file
+        node.test = test?(node.loc)
+        definitions.concat(rule.definitions(node))
+      end
+    end
+  end
+end

data/lib/leftovers/file_list.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'fast_ignore'
+require_relative 'file'
+
+module Leftovers
+  class FileList
+    include Enumerable
+
+    def each # rubocop:disable Metrics/MethodLength
+      FastIgnore.new(
+        ignore_rules: Leftovers.config.exclude_paths,
+        include_rules: Leftovers.config.include_paths,
+        include_shebangs: :ruby
+      ).each do |file|
+        yield(Leftovers::File.new(file))
+      end
+    end
+
+    def to_a
+      enum_for(:each).to_a
+    end
+  end
+end

data/lib/leftovers/haml.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Haml
+    module_function
+
+    def precompile(file) # rubocop:disable Metrics/MethodLength
+      Leftovers.try_require('haml', message: <<~MESSAGE)
+        Skipped parsing a haml file, because the haml gem was not available
+        `gem install Haml`
+      MESSAGE
+      if defined?(::Haml)
+        begin
+          ::Haml::Engine.new(file).precompiled
+        rescue ::Haml::SyntaxError => e
+          Leftovers.warn "#{e.class}: #{e.message} #{filename}:#{e.line}"
+          ''
+        end
+      else
+        ''
+      end
+    end
+  end
+end

data/lib/leftovers/hash_rule.rb

@@ -0,0 +1,40 @@
+# 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 = []
+      Array.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/merged_config.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'config'
+require 'fast_ignore'
+
+module Leftovers
+  class MergedConfig
+    def initialize
+      @configs = []
+      @loaded_configs = Set.new
+      self.<< Leftovers::Config.new(:ruby)
+      self.<< project_config
+      load_bundled_gem_config
+    end
+
+    def <<(config)
+      return if @loaded_configs.include?(config.name)
+
+      unmemoize
+      @configs << config
+      @loaded_configs << config.name
+      config.gems.each { |gem| self.<< Leftovers::Config.new(gem) }
+    end
+
+    def project_config
+      Leftovers::Config.new(:'.leftovers.yml', path: Leftovers.pwd + '.leftovers.yml')
+    end
+
+    def unmemoize
+      remove_instance_variable(:@exclude_paths) if defined?(@exclude_paths)
+      remove_instance_variable(:@include_paths) if defined?(@include_paths)
+      remove_instance_variable(:@test_paths) if defined?(@test_paths)
+      remove_instance_variable(:@rules) if defined?(@rules)
+    end
+
+    def exclude_paths
+      @exclude_paths ||= @configs.flat_map(&:exclude_paths)
+    end
+
+    def include_paths
+      @include_paths ||= @configs.flat_map(&:include_paths)
+    end
+
+    def test_paths
+      @test_paths ||= FastIgnore.new(
+        include_rules: @configs.flat_map(&:test_paths),
+        gitignore: false
+      )
+    end
+
+    def skip_rules
+      @skip_rules ||= rules.select(&:skip?)
+    end
+
+    def rules
+      @rules ||= @configs.flat_map(&:rules)
+    end
+
+    private
+
+    def load_bundled_gem_config
+      Leftovers.try_require('bundler')
+      return unless defined?(Bundler)
+
+      Bundler.locked_gems.specs.each do |spec|
+        self.<< Leftovers::Config.new(spec.name.to_sym)
+      end
+    end
+  end
+end

data/lib/leftovers/name_rule.rb

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