rubocop-callbacksystems 0.1.0

data/lib/rubocop/callbacksystems/project_index/source_file.rb

@@ -0,0 +1,59 @@
+require "uri"
+
+class RuboCop::Callbacksystems::ProjectIndex::SourceFile
+  attr_reader :path
+
+  delegate :hash, to: :identity
+
+  class << self
+    def for_document(document)
+      Rubydex::Location.new(uri: document.uri, start_line: 0, start_column: 0, end_line: 0, end_column: 0)
+        .then { new(it.to_file_path) }
+    end
+  end
+
+  def initialize(path)
+    @path = canonical_path_of(path.to_s)
+    @windows = Gem.win_platform?
+  end
+
+  def eql?(other)
+    other.is_a?(self.class) && identity == other.identity
+  end
+
+  def source
+    Parser::Source::Buffer.new(path).read.source.encode(Encoding::UTF_8).tap do |source|
+      raise EncodingError, "Cannot index invalid UTF-8 source: #{path}" unless source.valid_encoding?
+    end
+  end
+
+  def uri
+    "file://#{URI::DEFAULT_PARSER.escape(uri_path)}"
+  end
+
+  protected
+    def identity
+      @identity ||= normalized_path.then { windows ? it.downcase : it }
+    end
+
+  private
+    attr_reader :windows
+
+    def canonical_path_of(path)
+      File.realpath(path)
+    rescue SystemCallError
+      File.expand_path(path)
+    end
+
+    def normalized_path
+      @normalized_path ||= path.tr("\\", "/")
+    end
+
+    def uri_path
+      if windows && !normalized_path.start_with?("/")
+        "/#{normalized_path}"
+      else
+        normalized_path
+      end
+    end
+end

data/lib/rubocop/callbacksystems/project_index/source_file_match.rb

@@ -0,0 +1,57 @@
+# The source-to-file comparison shared by every cop investigating one ProcessedSource.
+class RuboCop::Callbacksystems::ProjectIndex::SourceFileMatch
+  class << self
+    def for(processed_source)
+      return false unless valid_source?(processed_source.raw_source)
+
+      snapshot = Snapshot.new(processed_source)
+      MUTEX.synchronize do
+        entry = CACHE[processed_source]
+
+        if entry&.fingerprint == snapshot.fingerprint
+          entry.matches
+        else
+          snapshot.matches?.tap { CACHE[processed_source] = Entry.new(snapshot.fingerprint, it) }
+        end
+      end
+    rescue
+      false
+    end
+
+    private
+      CACHE = ObjectSpace::WeakMap.new
+      MUTEX = Mutex.new
+      Entry = Data.define(:fingerprint, :matches)
+
+      def valid_source?(source)
+        source.encoding == Encoding::UTF_8 && source.valid_encoding?
+      end
+  end
+
+  private
+    class Snapshot
+      attr_reader :fingerprint
+
+      def initialize(processed_source)
+        @source = processed_source.raw_source
+        @path = File.expand_path(processed_source.file_path)
+        @file_fingerprint = fingerprint_of(File.stat(path))
+        @fingerprint = [ path, file_fingerprint ].freeze
+      end
+
+      def matches?
+        File.binread(path) == source.b && file_fingerprint == fingerprint_of(File.stat(path))
+      end
+
+      private
+        attr_reader :source, :path, :file_fingerprint
+
+        def fingerprint_of(stat)
+          [ stat.dev, stat.ino, stat.size, *timestamps_of(stat) ].freeze
+        end
+
+        def timestamps_of(stat)
+          [ stat.mtime.to_i, stat.mtime.nsec, stat.ctime.to_i, stat.ctime.nsec ]
+        end
+    end
+end

data/lib/rubocop/callbacksystems/project_index/support.rb

@@ -0,0 +1,46 @@
+module RuboCop::Callbacksystems::ProjectIndex::Support
+  include RuboCop::Cop::ProjectIndexHelp
+
+  def external_dependency_checksum
+    RuboCop::Callbacksystems::ProjectIndex::Reading.for(project_index).checksum if project_index
+  end
+
+  private
+    def project_index_reliable?
+      project_index && RuboCop::Callbacksystems::ProjectIndex::Freshness.reliable?(project_index) &&
+        source_matches_index? && RuboCop::Callbacksystems::ProjectIndex::Reading.for(project_index).reliable?
+    end
+
+    def source_matches_index?
+      source_matches_disk? ||
+        RuboCop::Callbacksystems::ProjectIndex::Freshness.current_source?(project_index, processed_source)
+    end
+
+    def source_matches_disk?
+      RuboCop::Callbacksystems::ProjectIndex::SourceFileMatch.for(processed_source)
+    end
+
+    def confined_declaration_of(nested_class)
+      resolve_constant_in_index(nested_class.identifier).then do |declaration|
+        declaration if confined_to_current_file?(declaration, nested_class:)
+      end
+    end
+
+    def confined_to_current_file?(declaration, nested_class:)
+      declaration.is_a?(Rubydex::Class) && project_declaration_reliable?(declaration) &&
+        definitions_in_other_files(declaration.definitions).empty? && declaration.definitions.one? &&
+        RuboCop::Callbacksystems::ProjectIndex::ConfinementCache
+          .for(nested_class, declaration:, project_index:).confined?
+    end
+
+    def project_declaration_reliable?(declaration)
+      !project_index_diagnostics.within_definitions?(
+        declaration.definitions,
+        named: [ "InvalidMethodVisibility" ]
+      )
+    end
+
+    def project_index_diagnostics
+      RuboCop::Callbacksystems::ProjectIndex::Diagnostics.for(project_index)
+    end
+end

data/lib/rubocop/callbacksystems/source/comment_blocks.rb

@@ -0,0 +1,43 @@
+# The unit the comment cops reason about: consecutive own-line `#` lines starting at the same column, two or more of
+# them, leaving out what addresses the tooling rather than the reader.
+class RuboCop::Callbacksystems::Source::CommentBlocks
+  include Enumerable
+  include RuboCop::Callbacksystems::Helpers
+
+  delegate :each, to: :blocks
+
+  def initialize(processed_source, reject_tooling_runs: false)
+    @processed_source = processed_source
+    @reject_tooling_runs = reject_tooling_runs
+  end
+
+  private
+    attr_reader :processed_source, :reject_tooling_runs
+
+    def blocks
+      comment_runs.flat_map { blocks_in(it) }
+    end
+
+    def comment_runs
+      own_line_comments.chunk_while { |previous, comment| continues?(previous, comment) }
+    end
+
+    def own_line_comments
+      processed_source.comments.select { it.inline? && own_line_comment?(it) }
+    end
+
+    def continues?(previous, comment)
+      comment.source_range.line == previous.source_range.line + 1 &&
+        comment.source_range.column == previous.source_range.column
+    end
+
+    def blocks_in(run)
+      if reject_tooling_runs && run.any? { tooling_comment?(it) }
+        []
+      else
+        run.reject { tooling_comment?(it) }
+          .chunk_while { |previous, comment| continues?(previous, comment) }
+          .select(&:many?)
+      end
+    end
+end

data/lib/rubocop/callbacksystems/source/comments.rb

@@ -0,0 +1,141 @@
+# Comments indexed by their position in one source, so asking whether a node contains comments does not walk every
+# comment in the file for every node the cops inspect.
+class RuboCop::Callbacksystems::Source::Comments
+  include RuboCop::Callbacksystems::Helpers
+
+  class << self
+    def for(processed_source)
+      CACHE_LOCK.synchronize { CACHE[processed_source.comments] ||= new(processed_source.comments) }
+    end
+
+    private
+      CACHE = ObjectSpace::WeakMap.new
+      CACHE_LOCK = Mutex.new
+  end
+
+  def initialize(comments)
+    @comments = comments.sort_by { it.source_range.begin_pos }
+  end
+
+  def any_within?(node_or_range)
+    first_within(range_of(node_or_range)).present?
+  end
+
+  def tooling_within?(node_or_range)
+    within(node_or_range).any? { tooling_comment?(it) }
+  end
+
+  def within(node_or_range)
+    range = range_of(node_or_range)
+    CommentsWithin.new(comments, range, from: first_index_at(range.begin_pos)).to_a
+  end
+
+  def own_line_comment_on(line)
+    own_line_comments_by_line[line]
+  end
+
+  def trailing_comment_on(line)
+    trailing_comments_by_line[line]
+  end
+
+  def any_on_lines?(lines)
+    if lines.begin <= lines.end
+      CommentsOnLines.new(comments, lines, from: first_index_on(lines.begin)).any?
+    else
+      false
+    end
+  end
+
+  def on_lines(lines)
+    if lines.begin <= lines.end
+      CommentsOnLines.new(comments, lines, from: first_index_on(lines.begin)).to_a
+    else
+      []
+    end
+  end
+
+  private
+    attr_reader :comments
+
+    def first_within(range)
+      comments[first_index_at(range.begin_pos)]&.then { it if range.contains?(it.source_range) }
+    end
+
+    def first_index_at(position)
+      begin_positions.bsearch_index { it >= position } || comments.size
+    end
+
+    def begin_positions
+      @begin_positions ||= comments.map { it.source_range.begin_pos }
+    end
+
+    def range_of(node_or_range)
+      node_or_range.respond_to?(:source_range) ? node_or_range.source_range : node_or_range
+    end
+
+    def own_line_comments_by_line
+      @own_line_comments_by_line ||= comments.select { own_line_comment?(it) }.index_by { it.loc.line }
+    end
+
+    def trailing_comments_by_line
+      @trailing_comments_by_line ||= comments.reject { own_line_comment?(it) }.index_by { it.loc.line }
+    end
+
+    def first_index_on(line)
+      line_numbers.bsearch_index { it >= line } || comments.size
+    end
+
+    def line_numbers
+      @line_numbers ||= comments.map { it.loc.line }
+    end
+
+    class CommentsWithin
+      include Enumerable
+
+      def initialize(comments, range, from:)
+        @comments = comments
+        @range = range
+        @from = from
+      end
+
+      def each
+        if block_given?
+          index = from
+          while comments[index] && comments[index].source_range.begin_pos <= range.end_pos
+            yield comments[index] if range.contains?(comments[index].source_range)
+            index += 1
+          end
+        else
+          to_enum(__method__)
+        end
+      end
+
+      private
+        attr_reader :comments, :range, :from
+    end
+
+    class CommentsOnLines
+      include Enumerable
+
+      def initialize(comments, lines, from:)
+        @comments = comments
+        @lines = lines
+        @from = from
+      end
+
+      def each
+        if block_given?
+          index = from
+          while comments[index] && comments[index].loc.line <= lines.end
+            yield comments[index]
+            index += 1
+          end
+        else
+          to_enum(__method__)
+        end
+      end
+
+      private
+        attr_reader :comments, :lines, :from
+    end
+end

data/lib/rubocop/callbacksystems/source/file_ast.rb

@@ -0,0 +1,15 @@
+module RuboCop::Callbacksystems::Source::FileAst
+  extend self
+
+  def ast(path, ruby_version:)
+    processed_source(path, ruby_version:)&.ast
+  end
+
+  def processed_source(path, ruby_version:)
+    return unless path && File.exist?(path)
+
+    RuboCop::AST::ProcessedSource.new(File.read(path), ruby_version, path)
+  rescue SystemCallError, EncodingError
+    nil
+  end
+end

data/lib/rubocop/callbacksystems/source/files_checksum.rb

@@ -0,0 +1,43 @@
+require "digest"
+
+module RuboCop::Callbacksystems::Source::FilesChecksum
+  extend self
+
+  def for(patterns, root: Dir.pwd, include_contents: true)
+    Contents.new(Array(patterns), File.expand_path(root), include_contents:).checksum
+  end
+
+  private
+    class Contents
+      def initialize(patterns, root, include_contents:)
+        @patterns = patterns
+        @root = root
+        @include_contents = include_contents
+      end
+
+      def checksum
+        Digest::SHA256.new.tap { |digest| matching.each { append(it, to: digest) } }.hexdigest
+      end
+
+      private
+        attr_reader :patterns, :root, :include_contents
+
+        def matching
+          patterns.flat_map { Dir.glob(File.join(root, it)) }.select { File.file?(it) }.uniq.sort
+        end
+
+        def append(path, to:)
+          to << relative_path_for(path) << "\0"
+          to.file(path) if include_contents?
+          to << "\0"
+        end
+
+        def relative_path_for(path)
+          path.delete_prefix("#{root}/")
+        end
+
+        def include_contents?
+          include_contents
+        end
+    end
+end

data/lib/rubocop/callbacksystems/source/single_line_call.rb

@@ -0,0 +1,181 @@
+# The one-line form of a call and whether the call belongs on it. Cops measuring this apart end up giving the same call
+# contradictory advice, so they read it here.
+class RuboCop::Callbacksystems::Source::SingleLineCall
+  include RuboCop::Callbacksystems::Helpers
+
+  attr_reader :node
+
+  def initialize(node, max_line_length)
+    @node = node
+    @max_line_length = max_line_length
+  end
+
+  def fits?
+    multiline? && !stays_multiline? && chain_collapsible? && fits_on_one_line?
+  end
+
+  def source
+    @source ||= CollapsedSource.new(node).value
+  end
+
+  private
+    attr_reader :max_line_length
+    delegate :operator_method?, to: :node, private: true
+
+    def multiline?
+      !node.single_line?
+    end
+
+    def stays_multiline?
+      block_call? || operator_method? || link_in_chain? || chain_contains_blocks? || carries_heredoc?(node)
+    end
+
+    def block_call?
+      any_block_type?(node.parent)
+    end
+
+    def link_in_chain?
+      node.parent&.call_type? && node.equal?(node.parent.receiver)
+    end
+
+    def chain_contains_blocks?(current = node.receiver)
+      ReceiverPath.new(current).any? { any_block_type?(it) }
+    end
+
+    def chain_collapsible?
+      chain_sends.all? { send_args_single_line?(it) }
+    end
+
+    def chain_sends
+      [ node, *ReceiverPath.new(node.receiver).take_while(&:call_type?) ]
+    end
+
+    def send_args_single_line?(send_node)
+      send_node.arguments.all? { argument_single_line?(it) }
+    end
+
+    def argument_single_line?(arg)
+      return arg.children.all?(&:single_line?) if implicit_hash?(arg)
+
+      arg.single_line?
+    end
+
+    def implicit_hash?(arg)
+      arg.hash_type? && !arg.loc.begin
+    end
+
+    def fits_on_one_line?
+      source.exclude?("\n") && fits_on_line?(node, source, max_line_length)
+    end
+
+    # The receiver nodes leading inward from a call, walked without depending on Ruby's call stack.
+    class ReceiverPath
+      include Enumerable
+
+      def initialize(node)
+        @node = node
+      end
+
+      def each
+        if block_given?
+          current = node
+          while current
+            yield current
+            current = current.call_type? ? current.receiver : nil
+          end
+        else
+          to_enum(__method__)
+        end
+      end
+
+      private
+        attr_reader :node
+    end
+
+    # The collapsed source of a receiver call chain, assembled from its innermost call outward in one pass.
+    class CollapsedSource
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(node)
+        @node = node
+      end
+
+      def value
+        fragments.join
+      end
+
+      private
+        attr_reader :node
+
+        def fragments
+          calls.reverse_each.with_index.map do |call, index|
+            CallFragment.new(call, leading_receiver: index.zero?).value
+          end
+        end
+
+        def calls
+          current = node
+          [ current ].then do |chain|
+            while current.receiver&.call_type? && !current.receiver.operator_method?
+              current = current.receiver
+              chain << current
+            end
+            chain
+          end
+        end
+    end
+
+    class CallFragment
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(call, leading_receiver:)
+        @call = call
+        @leading_receiver = leading_receiver
+      end
+
+      def value
+        [ receiver_source, dot_source, call.method_name, arguments_suffix ].compact.join
+      end
+
+      private
+        attr_reader :call, :leading_receiver
+
+        # An index or operator call has no selector to rebuild from, so it stays as written.
+        def receiver_source
+          call.receiver.source.strip if leading_receiver && call.receiver
+        end
+
+        def dot_source
+          call.loc.dot.source if call.receiver
+        end
+
+        def arguments_suffix
+          if parenthesized_once_collapsed?
+            "(#{arguments_joined})"
+          elsif call.arguments?
+            " #{arguments_joined}"
+          else
+            ""
+          end
+        end
+
+        def parenthesized_once_collapsed?
+          # A backslash continuation is what lets a builder call go without parentheses, so they come back on collapse.
+          call.parenthesized? || (call.arguments? && builder_method?(call))
+        end
+
+        def arguments_joined
+          call.arguments.flat_map { sources_of(it) }.join(", ")
+        end
+
+        def sources_of(argument)
+          return argument.children.map { it.source.strip } if implicit_hash?(argument)
+
+          [ argument.source.strip ]
+        end
+
+        def implicit_hash?(argument)
+          argument.hash_type? && !argument.loc.begin
+        end
+    end
+end