stud-finder 0.1.0 → 0.3.0

data/lib/stud_finder/complexity.rb

@@ -12,10 +12,13 @@ module StudFinder
 
     COMPLEXITY_COP = 'Metrics/CyclomaticComplexity'
     COMPLEXITY_PATTERN = %r{\[(\d+)/0\]}
+    INVALID_ENCODING_PATTERN = /invalid byte sequence/i
     PARSE_ERROR_COPS = %w[Lint/Syntax].freeze
+    BATCH_SIZE = 500
     RUBOCOP_CONFIG = <<~YAML
       AllCops:
         DisabledByDefault: true
+        NewCops: disable
       Metrics/CyclomaticComplexity:
         Enabled: true
         Max: 0
@@ -28,11 +31,17 @@ module StudFinder
     end
 
     def call
-      stdout, stderr, status = run_rubocop
-      raise Error, fatal_message(stderr) if status.exitstatus == 2
-      raise Error, fatal_message(stderr) unless [0, 1].include?(status.exitstatus)
+      counts = zero_counts
+      skipped = []
+
+      @files.each_slice(BATCH_SIZE) do |batch|
+        result = run_batch(batch)
+        counts.merge!(result.counts) { |_file, old, new| [old, new].max }
+        skipped.concat(result.skipped_files)
+      end
 
-      parse(stdout)
+      skipped.uniq.each { |file| counts.delete(file) }
+      Result.new(counts: counts, skipped_files: skipped.uniq)
     rescue Errno::ENOENT
       raise Error, 'Error: rubocop not found. Install it: gem install rubocop'
     rescue JSON::ParserError => e
@@ -41,23 +50,38 @@ module StudFinder
 
     private
 
-    def run_rubocop
+    def run_batch(batch)
+      stdout, stderr, status = run_rubocop(batch)
+      raise Error, fatal_message(stderr) if status.exitstatus == 2
+      raise Error, fatal_message(stderr) unless [0, 1].include?(status.exitstatus)
+
+      parse(stdout, batch)
+    end
+
+    def run_rubocop(batch)
       Tempfile.create(['stud-finder-rubocop', '.yml']) do |config|
         config.write(RUBOCOP_CONFIG)
         config.close
 
+        # Supplying an explicit temp config prevents RuboCop from loading the
+        # target repo's .rubocop.yml while preserving our Max: 0 complexity rule.
+        # RuboCop 1.88 has --force-default-config, but that option also ignores
+        # explicit --config settings, so it cannot be combined with this custom
+        # analysis config.
         Open3.capture3(
           'rubocop',
           '--config', config.path,
           '--format', 'json',
-          @repo_path
+          '--',
+          *batch,
+          chdir: @repo_path
         )
       end
     end
 
-    def parse(stdout)
+    def parse(stdout, batch)
       payload = JSON.parse(stdout)
-      counts = @files.to_h { |file| [file, 0] }
+      counts = batch.to_h { |file| [file, 0] }
       skipped = []
       file_set = counts.keys.to_h { |file| [file, true] }
 
@@ -66,6 +90,11 @@ module StudFinder
         next unless file_set[relative]
 
         offenses = Array(entry['offenses'])
+        if invalid_encoding_error?(offenses)
+          counts[relative] = 0
+          next
+        end
+
         if parse_error?(offenses)
           skipped << relative
           counts.delete(relative)
@@ -79,6 +108,10 @@ module StudFinder
       Result.new(counts: counts, skipped_files: skipped)
     end
 
+    def zero_counts
+      @files.to_h { |file| [file, 0] }
+    end
+
     def complexity_score(offense)
       return 0 unless offense['cop_name'] == COMPLEXITY_COP
 
@@ -89,6 +122,12 @@ module StudFinder
       offenses.any? { |offense| PARSE_ERROR_COPS.include?(offense['cop_name']) || offense['fatal'] == true }
     end
 
+    def invalid_encoding_error?(offenses)
+      offenses.any? do |offense|
+        parse_error?([offense]) && offense.fetch('message', '').match?(INVALID_ENCODING_PATTERN)
+      end
+    end
+
     def normalize_path(path)
       absolute = File.expand_path(path, @repo_path)
       absolute.start_with?("#{@repo_path}/") ? absolute.delete_prefix("#{@repo_path}/") : path

data/lib/stud_finder/coverage/cobertura.rb

@@ -19,7 +19,7 @@ module StudFinder
       def call
         reported = parse_report
         @missing_files = @files.reject { |file| reported.key?(file) }
-        @files.to_h { |file| [file, reported.fetch(file, 0.0)] }
+        reported.slice(*@files)
       end
 
       private

data/lib/stud_finder/coverage/lcov.rb

@@ -20,7 +20,7 @@ module StudFinder
       def call
         reported = parse_report
         @missing_files = @files.reject { |file| reported.key?(file) }
-        @files.to_h { |file| [file, reported.fetch(file, 0.0)] }
+        reported.slice(*@files)
       end
 
       private

data/lib/stud_finder/coverage/resultset.rb

@@ -21,7 +21,7 @@ module StudFinder
       def call
         reported = parse_report
         @missing_files = @files.reject { |file| reported.key?(file) }
-        @files.to_h { |file| [file, reported.fetch(file, 0.0)] }
+        reported.slice(*@files)
       end
 
       private

data/lib/stud_finder/dispersion_warnings.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module StudFinder
+  module DispersionWarnings
+    module_function
+
+    def build(files:, pcts:, raw_sources:)
+      raw_sources.filter_map do |signal, raw_source|
+        "insufficient_dispersion_#{signal}" if insufficient_dispersion?(files, pcts.fetch(signal), raw_source)
+      end
+    end
+
+    def insufficient_dispersion?(files, pct_map, raw_source)
+      values = files.map { |file| pct_map.fetch(file, 0.0).to_f }
+      raw_values = files.map { |file| raw_source.fetch(file, 0).to_f }
+
+      values.any? && values.all?(&:zero?) && raw_values.any? { |value| !value.zero? }
+    end
+  end
+end

data/lib/stud_finder/edges.rb

@@ -54,6 +54,7 @@ module StudFinder
                             score: format_score(row[:score]), class: row[:classification],
                             fan_in: row[:fan_in], fan_out: row[:fan_out],
                             instability: format_score(row[:instability]))
+        @stdout.puts "  escalation: #{row[:escalation]}" if row[:escalation] && !row[:escalation].empty?
       end
       @stdout.puts
     end

data/lib/stud_finder/fan_in.rb

@@ -2,22 +2,26 @@
 
 require 'rubocop'
 require 'set'
+require_relative 'rails_inference'
 
 module StudFinder
+  # rubocop:disable Metrics/ClassLength
   class FanIn
-    Result = Struct.new(:counts, :fan_out_counts, :edges, keyword_init: true)
+    Result = Struct.new(:counts, :fan_out_counts, :edges, :warnings, keyword_init: true)
     ReferenceCandidate = Struct.new(:namespace, :name, :absolute, :candidates, keyword_init: true)
 
     PATH_ROOTS = %w[app lib test].freeze
     CLASS_OR_MODULE_TYPES = %i[class module].freeze
 
-    def initialize(repo_path:, files:, stderr: $stderr)
+    def initialize(repo_path:, files:, stderr: $stderr, rails_inference: true)
       @repo_path = File.expand_path(repo_path)
       @files = files
       @stderr = stderr
+      @rails_inference = rails_inference
     end
 
     def call
+      @warnings = []
       constants = constant_ownership
       references = resolved_reference_sets(@files, constants)
       reverse_constants = constants.invert
@@ -45,7 +49,7 @@ module StudFinder
         [file, { dependents: dependents[file].uniq, dependencies: dependencies[file].uniq }]
       end
 
-      Result.new(counts: counts, fan_out_counts: fan_out_counts, edges: edges)
+      Result.new(counts: counts, fan_out_counts: fan_out_counts, edges: edges, warnings: @warnings)
     end
 
     private
@@ -90,6 +94,10 @@ module StudFinder
         constant = [root, tail].join('::')
         return constant if known_constants.include?(constant)
 
+        # Ruby locks qualified lookup into the first matching namespace root. If
+        # the tail is absent, it raises instead of falling back to an outer
+        # constant; incomplete ownership can rarely undercount, but avoids
+        # non-Ruby overcounts.
         return nil
       end
 
@@ -131,20 +139,40 @@ module StudFinder
 
         candidates = reference_candidates(node)
         references << candidates if candidates.any?
+      end.merge(rails_reference_candidates(ast))
+    end
+
+    def rails_reference_candidates(ast)
+      return Set.new unless @rails_inference
+
+      RailsInference.new(ast).call.each_with_object(Set.new) do |inference, references|
+        candidates = reference_candidate(inference.node, inference.name, inference.absolute)
+        references << candidates if candidates.any?
       end
+    rescue StandardError => e
+      code = 'fan_in_rails_inference_failed'
+      @warnings << code unless @warnings.include?(code)
+      @stderr.puts "Warning: #{code}: #{e.class}: #{e.message}"
+      Set.new
     end
 
     def reference_candidates(node)
       name = constant_name(node)
       return [] unless name
 
+      reference_candidate(node, name, absolute_const_reference?(node))
+    end
+
+    def reference_candidate(node, name, absolute)
       namespace = lexical_namespace(node)
-      absolute = absolute_const_reference?(node)
+      candidates = name.include?('::') && !absolute ? [] : constant_candidates(namespace, name, absolute)
       reference_candidate_cache[[namespace, name, absolute]] ||=
         ReferenceCandidate.new(namespace: namespace, name: name, absolute: absolute,
-                               candidates: constant_candidates(namespace, name, absolute))
+                               candidates: candidates)
     rescue StandardError => e
-      @stderr.puts "Warning: fan_in_reference_resolution_failed: #{e.class}: #{e.message}"
+      code = 'fan_in_reference_resolution_failed'
+      @warnings << code unless @warnings.include?(code)
+      @stderr.puts "Warning: #{code}: #{e.class}: #{e.message}"
       []
     end
 
@@ -240,4 +268,5 @@ module StudFinder
       root == 'app' ? remaining[1..] : remaining
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/stud_finder/file_collector.rb

@@ -14,6 +14,7 @@ module StudFinder
       '**/*.min.js',
       'tmp/**',
       'log/**',
+      'coverage/**',
       'spec/**',
       'test/**',
       '__tests__/**',
@@ -145,7 +146,7 @@ module StudFinder
         return line.match?(/\A\s*#\s*This file is auto-generated/i)
       end
       false
-    rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+    rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError, ArgumentError
       false
     end
   end

data/lib/stud_finder/js_fan_in.rb

@@ -11,6 +11,10 @@ module StudFinder
 
     TOOL_MISSING = 'js_tools_missing'
     TIMEOUT = 'js_depcruise_timeout'
+    DEPCRUISE_NO_CONFIG = 'js_depcruise_no_config'
+    DEPCRUISE_FAILED = 'js_depcruise_failed'
+
+    FALLBACK_SUCCESS_MESSAGE = 'configured depcruise failed; retried with --no-config; fan_in may be undercounted'
 
     def initialize(repo_path:, files:, js_timeout: 60, stderr: $stderr)
       @repo_path = File.expand_path(repo_path)
@@ -25,16 +29,17 @@ module StudFinder
       depcruise = depcruise_binary
       return missing_tools unless depcruise
 
-      stdout, _stderr, status = run_depcruise(depcruise)
-      return missing_tools unless status.success?
+      stdout, stderr, status, warnings = run_depcruise(depcruise)
+      return depcruise_failed(stderr) unless status.success?
 
       counts, fan_out_counts, edges = parse(stdout)
-      Result.new(counts: counts, fan_out_counts: fan_out_counts, edges: edges, warnings: [])
+      warnings.each { |warning| warn(warning.fetch(:code), warning.fetch(:message)) }
+      Result.new(counts: counts, fan_out_counts: fan_out_counts, edges: edges, warnings: warnings)
     rescue Timeout::Error
       warn(TIMEOUT)
       Result.new(counts: zero_counts, fan_out_counts: zero_counts, edges: empty_edges, warnings: [TIMEOUT])
-    rescue JSON::ParserError, KeyError, TypeError
-      missing_tools
+    rescue JSON::ParserError, KeyError, TypeError => e
+      depcruise_failed("malformed dependency-cruiser JSON: #{e.message}")
     end
 
     private
@@ -60,7 +65,19 @@ module StudFinder
 
     def run_depcruise(depcruise)
       Timeout.timeout(@js_timeout) do
-        Open3.capture3(depcruise, '--output-type', 'json', '.', chdir: @repo_path)
+        primary_stdout, primary_stderr, primary_status = Open3.capture3(depcruise, '--output-type', 'json', '.',
+                                                                        chdir: @repo_path)
+        return [primary_stdout, primary_stderr, primary_status, []] if primary_status.success?
+
+        retry_stdout, retry_stderr, retry_status = Open3.capture3(
+          depcruise, '--output-type', 'json', '.', '--no-config', chdir: @repo_path
+        )
+        if retry_status.success?
+          [retry_stdout, retry_stderr, retry_status,
+           [{ code: DEPCRUISE_NO_CONFIG, message: fallback_success_message(primary_stderr) }]]
+        else
+          [primary_stdout, primary_stderr, primary_status, []]
+        end
       end
     end
 
@@ -106,6 +123,29 @@ module StudFinder
       Result.new(counts: zero_counts, fan_out_counts: zero_counts, edges: empty_edges, warnings: [TOOL_MISSING])
     end
 
+    def depcruise_failed(stderr)
+      detail = first_line(stderr)
+      message = detail.empty? ? nil : detail
+      warn(DEPCRUISE_FAILED, message)
+      Result.new(
+        counts: zero_counts,
+        fan_out_counts: zero_counts,
+        edges: empty_edges,
+        warnings: [{ code: DEPCRUISE_FAILED, message: message }]
+      )
+    end
+
+    def fallback_success_message(primary_stderr)
+      detail = first_line(primary_stderr)
+      return FALLBACK_SUCCESS_MESSAGE if detail.empty?
+
+      "#{FALLBACK_SUCCESS_MESSAGE}: #{detail}"
+    end
+
+    def first_line(text)
+      text.to_s.lines.first.to_s.strip
+    end
+
     def zero_counts
       @files.to_h { |file| [file, 0] }
     end
@@ -114,8 +154,9 @@ module StudFinder
       @files.to_h { |file| [file, { dependents: [], dependencies: [] }] }
     end
 
-    def warn(code)
-      @stderr.puts "Warning: #{code}"
+    def warn(code, message = nil)
+      suffix = message.to_s.empty? ? '' : ": #{message}"
+      @stderr.puts "Warning: #{code}#{suffix}"
     end
   end
 end

data/lib/stud_finder/loc_counter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module StudFinder
+  class LocCounter
+    def initialize(repo_path:, files:)
+      @repo_path = File.expand_path(repo_path)
+      @files = files
+    end
+
+    def call
+      @files.to_h { |file| [file, non_blank_lines(file)] }
+    end
+
+    private
+
+    def non_blank_lines(file)
+      File.foreach(File.join(@repo_path, file)).count { |line| !line.strip.empty? }
+    rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError, ArgumentError
+      0
+    end
+  end
+end