stud-finder 0.1.0

data/lib/stud_finder/fan_in.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'set'
+
+module StudFinder
+  class FanIn
+    Result = Struct.new(:counts, :fan_out_counts, :edges, 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)
+      @repo_path = File.expand_path(repo_path)
+      @files = files
+      @stderr = stderr
+    end
+
+    def call
+      constants = constant_ownership
+      references = resolved_reference_sets(@files, constants)
+      reverse_constants = constants.invert
+
+      counts = @files.to_h { |file| [file, 0] }
+      fan_out_counts = @files.to_h { |file| [file, 0] }
+      dependents = @files.to_h { |file| [file, []] }
+      dependencies = @files.to_h { |file| [file, []] }
+
+      @files.each do |file|
+        constant = constants[file]
+        counts[file] = constant ? fan_in_count(file, constant, references) : 0
+
+        references[file]&.each do |ref_constant|
+          dep_file = reverse_constants[ref_constant]
+          next unless dep_file && dep_file != file
+
+          fan_out_counts[file] += 1
+          dependencies[file] << dep_file
+          dependents[dep_file] << file
+        end
+      end
+
+      edges = @files.to_h do |file|
+        [file, { dependents: dependents[file].uniq, dependencies: dependencies[file].uniq }]
+      end
+
+      Result.new(counts: counts, fan_out_counts: fan_out_counts, edges: edges)
+    end
+
+    private
+
+    def constant_ownership
+      @files.filter_map do |file|
+        constant = zeitwerk_constant(file) || primary_constant(file)
+        [file, constant] if constant
+      end.to_h
+    end
+
+    def resolved_reference_sets(source_files, constants)
+      known_constants = constants.values.to_set
+      known_namespace_prefixes = namespace_prefixes(known_constants)
+
+      source_files.to_h do |file|
+        [file, resolve_references(references_for(file), known_constants, known_namespace_prefixes)]
+      end
+    end
+
+    def resolve_references(reference_candidates, known_constants,
+                           known_namespace_prefixes = namespace_prefixes(known_constants))
+      reference_candidates.each_with_object(Set.new) do |reference, resolved|
+        constant = resolve_reference(reference, known_constants, known_namespace_prefixes)
+        resolved << constant if constant
+      end
+    end
+
+    def resolve_reference(reference, known_constants, known_namespace_prefixes)
+      unless reference.is_a?(ReferenceCandidate)
+        return reference.find { |candidate| known_constants.include?(candidate) }
+      end
+
+      return reference.candidates.find(&known_constants.method(:include?)) if reference.absolute
+      return reference.candidates.find(&known_constants.method(:include?)) unless reference.name.include?('::')
+
+      leading, tail = reference.name.split('::', 2)
+
+      constant_candidates(reference.namespace, leading, false).each do |root|
+        next unless known_constants.include?(root) || known_namespace_prefixes.include?(root)
+
+        constant = [root, tail].join('::')
+        return constant if known_constants.include?(constant)
+
+        return nil
+      end
+
+      nil
+    end
+
+    def namespace_prefixes(constants)
+      constants.each_with_object(Set.new) do |constant, prefixes|
+        segments = constant.split('::')
+        next if segments.length < 2
+
+        1.upto(segments.length - 1) do |length|
+          prefixes << segments.first(length).join('::')
+        end
+      end
+    end
+
+    def fan_in_count(file, constant, references)
+      references.count { |source_file, source_refs| source_file != file && source_refs.include?(constant) }
+    end
+
+    def primary_constant(file)
+      ast = parse(file)
+      return unless ast
+
+      node = ast.each_node(*CLASS_OR_MODULE_TYPES).find do |candidate|
+        candidate.each_ancestor.none? { |ancestor| CLASS_OR_MODULE_TYPES.include?(ancestor.type) }
+      end
+
+      constant_name(node&.identifier)
+    end
+
+    def references_for(file)
+      ast = parse(file)
+      return Set.new unless ast
+
+      ast.each_node(:const).with_object(Set.new) do |node, references|
+        next if nested_const_part?(node)
+
+        candidates = reference_candidates(node)
+        references << candidates if candidates.any?
+      end
+    end
+
+    def reference_candidates(node)
+      name = constant_name(node)
+      return [] unless name
+
+      namespace = lexical_namespace(node)
+      absolute = absolute_const_reference?(node)
+      reference_candidate_cache[[namespace, name, absolute]] ||=
+        ReferenceCandidate.new(namespace: namespace, name: name, absolute: absolute,
+                               candidates: constant_candidates(namespace, name, absolute))
+    rescue StandardError => e
+      @stderr.puts "Warning: fan_in_reference_resolution_failed: #{e.class}: #{e.message}"
+      []
+    end
+
+    def reference_candidate_cache
+      @reference_candidate_cache ||= {}
+    end
+
+    def constant_candidates(namespace, name, absolute)
+      return [name] if absolute || namespace.nil? || namespace.empty?
+
+      namespace.length.downto(1).map do |length|
+        [namespace.first(length).join('::'), name].join('::')
+      end + [name]
+    end
+
+    def lexical_namespace(node)
+      parent = node.parent
+      declaration_identifier = parent && (parent.class_type? || parent.module_type?) && parent.children[0].equal?(node)
+      superclass_identifier = parent&.class_type? && parent.children[1].equal?(node)
+      scope_to_skip = parent if declaration_identifier || superclass_identifier
+
+      node.each_ancestor.filter_map do |ancestor|
+        next unless CLASS_OR_MODULE_TYPES.include?(ancestor.type) && !ancestor.equal?(scope_to_skip)
+
+        constant_name(ancestor.identifier)
+      end.reverse
+    end
+
+    def absolute_const_reference?(node)
+      parent = node.children.first
+      return false unless parent
+      return true if parent.cbase_type?
+
+      parent.const_type? && absolute_const_reference?(parent)
+    end
+
+    def parse(file)
+      source = File.read(File.join(@repo_path, file))
+      RuboCop::ProcessedSource.new(source, RUBY_VERSION.to_f, file).ast
+    rescue EncodingError, Errno::ENOENT, Parser::SyntaxError
+      nil
+    end
+
+    def constant_name(node)
+      return unless node&.const_type?
+
+      node.const_name
+    rescue StandardError
+      nil
+    end
+
+    def nested_const_part?(node)
+      node.each_ancestor.any?(&:const_type?)
+    end
+
+    def zeitwerk_constant(file)
+      components = path_after_root(file)
+      return unless components
+
+      components = strip_app_concerns_namespace(components)
+      components = components.reject { |component| component == 'concerns' }
+      basename = components.pop&.delete_suffix('.rb')
+      return if basename.nil? || basename.empty?
+
+      constant = (components + [basename]).map { |component| camelize(component) }.join('::')
+      return unless valid_constant_name?(constant)
+
+      constant
+    end
+
+    def strip_app_concerns_namespace(components)
+      concerns_index = components.index('concerns')
+      return components unless concerns_index
+
+      components[(concerns_index + 1)..] || []
+    end
+
+    def camelize(segment)
+      segment.split('_').map(&:capitalize).join
+    end
+
+    def valid_constant_name?(constant)
+      constant.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*\z/)
+    end
+
+    def path_after_root(file)
+      components = file.split('/')
+      index = components.index { |component| PATH_ROOTS.include?(component) }
+      return unless index
+
+      root = components[index]
+      remaining = components[(index + 1)..]
+      root == 'app' ? remaining[1..] : remaining
+    end
+  end
+end

data/lib/stud_finder/file_collector.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'pathname'
+
+module StudFinder
+  class FileCollector
+    DEFAULT_EXCLUDES = [
+      'db/schema.rb',
+      'db/migrate/**',
+      'node_modules/**',
+      '**/node_modules/**',
+      'vendor/**',
+      '**/*.min.js',
+      'tmp/**',
+      'log/**',
+      'spec/**',
+      'test/**',
+      '__tests__/**',
+      '**/__tests__/**',
+      '**/*.test.js',
+      '**/*.test.ts',
+      '**/*.test.jsx',
+      '**/*.test.tsx',
+      '**/*.spec.js',
+      '**/*.spec.ts',
+      '**/*.spec.jsx',
+      '**/*.spec.tsx'
+    ].freeze
+
+    EXTENSIONS = %w[.rb .js .ts .jsx .tsx].freeze
+    LANGUAGES = {
+      '.rb' => :ruby,
+      '.js' => :javascript,
+      '.jsx' => :javascript,
+      '.ts' => :typescript,
+      '.tsx' => :typescript
+    }.freeze
+
+    FNM_FLAGS = File::FNM_PATHNAME | File::FNM_DOTMATCH
+
+    Result = Struct.new(:files, :languages, :default_excluded_count, :custom_excluded_count, keyword_init: true)
+
+    class Error < StandardError; end
+
+    def initialize(path:, excludes: [], min_files: 20, stderr: $stderr)
+      @path = File.expand_path(path)
+      @excludes = excludes
+      @min_files = min_files
+      @stderr = stderr
+    end
+
+    def collect
+      validate!
+
+      default_excluded = 0
+      custom_excluded = 0
+      languages = {}
+      files = Dir.glob(File.join(@path, '**', '*'), File::FNM_DOTMATCH)
+                 .select { |file| File.file?(file) }
+                 .sort
+                 .filter_map do |file|
+        extension = File.extname(file)
+        next unless EXTENSIONS.include?(extension)
+
+        relative = relative_path(file)
+
+        if default_excluded?(relative, file)
+          default_excluded += 1
+          next
+        end
+
+        if excluded_by_patterns?(relative, @excludes)
+          custom_excluded += 1
+          next
+        end
+
+        languages[relative] = LANGUAGES.fetch(extension)
+        relative
+      end
+
+      if files.length < 5
+        raise Error,
+              "Error: only #{files.length} supported files found after excludes. Too few for meaningful analysis."
+      end
+
+      if files.length < @min_files
+        @stderr.puts "Warning: only #{files.length} files found. Percentile ranks are unreliable at this scale. " \
+                     'Results are advisory only.'
+      end
+
+      Result.new(files: files, languages: languages, default_excluded_count: default_excluded,
+                 custom_excluded_count: custom_excluded)
+    end
+
+    private
+
+    def validate!
+      raise Error, "Error: #{@path} does not exist." unless File.exist?(@path)
+      raise Error, "Error: #{@path} is not a directory." unless File.directory?(@path)
+      raise Error, 'Error: git not found in PATH.' unless git_available?
+
+      _stdout, _stderr, status = Open3.capture3('git', '-C', @path, 'rev-parse', '--is-inside-work-tree')
+      return if status.success?
+
+      raise Error, "Error: #{@path} is not a git repository."
+    end
+
+    def git_available?
+      ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? do |dir|
+        git = File.join(dir, 'git')
+        File.file?(git) && File.executable?(git)
+      end
+    end
+
+    def relative_path(file)
+      Pathname.new(file).relative_path_from(Pathname.new(@path)).to_s
+    end
+
+    def default_excluded?(relative, file)
+      excluded_by_patterns?(relative, DEFAULT_EXCLUDES) || auto_generated?(file)
+    end
+
+    def excluded_by_patterns?(relative, patterns)
+      patterns.any? { |pattern| glob_match?(pattern, relative) }
+    end
+
+    def glob_match?(pattern, relative)
+      File.fnmatch(pattern, relative, FNM_FLAGS) ||
+        globstar_directory_match?(pattern, relative) ||
+        (pattern.end_with?('/**') && relative.start_with?("#{pattern.delete_suffix('/**')}/"))
+    end
+
+    def globstar_directory_match?(pattern, relative)
+      return false unless pattern.start_with?('**/') && pattern.end_with?('/**')
+
+      directory = pattern.delete_prefix('**/').delete_suffix('/**')
+      relative.start_with?("#{directory}/") || relative.include?("/#{directory}/")
+    end
+
+    def auto_generated?(file)
+      File.foreach(file) do |line|
+        next if line.strip.empty?
+
+        return line.match?(/\A\s*#\s*This file is auto-generated/i)
+      end
+      false
+    rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+      false
+    end
+  end
+end

data/lib/stud_finder/js_complexity.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'timeout'
+
+module StudFinder
+  class JsComplexity
+    Result = Struct.new(:counts, :warnings, keyword_init: true)
+
+    ESLINT_MISSING = 'js_eslint_missing'
+    ESLINT_FAILED = 'js_eslint_failed'
+    ESLINT_MALFORMED = 'js_eslint_malformed'
+    TS_PARSER_MISSING = 'js_ts_parser_missing'
+    TIMEOUT = 'js_eslint_timeout'
+    BATCH_SIZE = 500
+    TS_EXTENSIONS = %w[.ts .tsx].freeze
+
+    def initialize(repo_path:, files:, js_timeout: 60, stderr: $stderr)
+      @repo_path = File.expand_path(repo_path)
+      @files = files
+      @js_timeout = js_timeout
+      @stderr = stderr
+      @warnings = []
+    end
+
+    def call
+      eslint = eslint_binary
+      return missing_eslint unless eslint
+
+      major = eslint_major(eslint)
+      return missing_eslint unless major
+
+      ts_parser = ts_parser_available?
+      warn_once(TS_PARSER_MISSING) if ts_files? && !ts_parser
+
+      counts = zero_counts
+      analyzable_files(ts_parser).each_slice(BATCH_SIZE) do |batch|
+        counts.merge!(run_batch(eslint, major, ts_parser, batch)) { |_file, old, new| [old, new].max }
+      end
+
+      Result.new(counts: counts, warnings: @warnings)
+    end
+
+    private
+
+    def eslint_binary
+      local = File.join(@repo_path, 'node_modules/.bin/eslint')
+      return local if File.executable?(local)
+
+      ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).each do |dir|
+        candidate = File.join(dir, 'eslint')
+        return 'eslint' if File.file?(candidate) && File.executable?(candidate)
+      end
+
+      nil
+    end
+
+    def eslint_major(eslint)
+      stdout, _stderr, status = Open3.capture3(eslint, '--version')
+      return nil unless status.success?
+
+      stdout[/v?(\d+)/, 1]&.to_i
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def ts_parser_available?
+      script = <<~JS
+        const parserPath = require.resolve('@typescript-eslint/parser', { paths: [process.cwd()] });
+        require(parserPath);
+      JS
+      _stdout, _stderr, status = Open3.capture3('node', '-e', script, chdir: @repo_path)
+      status.success?
+    rescue Errno::ENOENT
+      false
+    end
+
+    def ts_files?
+      @files.any? { |file| TS_EXTENSIONS.include?(File.extname(file)) }
+    end
+
+    def analyzable_files(ts_parser)
+      return @files if ts_parser
+
+      @files.reject { |file| TS_EXTENSIONS.include?(File.extname(file)) }
+    end
+
+    def run_batch(eslint, major, ts_parser, batch)
+      temp_config = nil
+      args = [eslint]
+      if major >= 9
+        temp_config = write_flat_config(ts_parser)
+        args.push('--config', temp_config)
+      else
+        args.concat(v8_flags(ts_parser))
+      end
+      args.push('--rule', '{"complexity":["error",0]}', '--format', 'json')
+      args.concat(batch)
+
+      stdout, _stderr, status = Timeout.timeout(@js_timeout) do
+        Open3.capture3(*args, chdir: @repo_path)
+      end
+      return degraded_batch(batch, ESLINT_FAILED) if status.exitstatus == 2
+
+      parse_output(stdout, batch)
+    rescue Timeout::Error
+      degraded_batch(batch, TIMEOUT)
+    ensure
+      File.delete(temp_config) if temp_config && File.exist?(temp_config)
+    end
+
+    def v8_flags(ts_parser)
+      flags = ['--no-eslintrc', '--resolve-plugins-relative-to', '.',
+               '--parser-options=ecmaVersion:2022,sourceType:module']
+      flags.push('--parser', '@typescript-eslint/parser') if ts_parser
+      flags
+    end
+
+    def write_flat_config(ts_parser)
+      path = "/tmp/stud-finder-eslint-#{Process.pid}-#{object_id}.config.mjs"
+      parser_setup = if ts_parser
+                       <<~JS
+                         import { createRequire } from 'node:module';
+                         const require = createRequire(#{JSON.generate(File.join(@repo_path, 'package.json'))});
+                         const tsParser = require('@typescript-eslint/parser');
+                       JS
+                     else
+                       ''
+                     end
+      parser_option = ts_parser ? ', parser: tsParser' : ''
+      File.write(path, <<~JS)
+        #{parser_setup}
+        export default [{
+          files: ['**/*.{js,jsx,ts,tsx}'],
+          languageOptions: { ecmaVersion: 2022, sourceType: 'module'#{parser_option} },
+          rules: { complexity: ['error', 0] }
+        }];
+      JS
+      path
+    end
+
+    def parse_output(stdout, batch)
+      return degraded_batch(batch, ESLINT_MALFORMED) unless stdout.strip.start_with?('[')
+
+      parse_json(stdout)
+    rescue JSON::ParserError, KeyError, NoMethodError, TypeError
+      degraded_batch(batch, ESLINT_MALFORMED)
+    end
+
+    def parse_json(stdout)
+      payload = JSON.parse(stdout)
+      raise TypeError, 'expected ESLint JSON array' unless payload.is_a?(Array)
+
+      payload.each_with_object({}) do |file_result, counts|
+        file = normalize_path(file_result.fetch('filePath'))
+        complexities = Array(file_result['messages']).filter_map do |message|
+          message['message'].to_s[/complexity of (\d+)/, 1]&.to_i
+        end
+        counts[file] = complexities.max if complexities.any?
+      end
+    end
+
+    def parse_text(stdout)
+      stdout.each_line.with_object({}) do |line, counts|
+        match = line.match(/(.+): line \d+.*complexity of (\d+)/)
+        next unless match
+
+        file = normalize_path(match[1])
+        counts[file] = [counts.fetch(file, 0), match[2].to_i].max
+      end
+    end
+
+    def normalize_path(path)
+      expanded = File.expand_path(path, @repo_path)
+      prefix = "#{@repo_path}/"
+      return expanded.delete_prefix(prefix) if expanded.start_with?(prefix)
+
+      path.delete_prefix('./')
+    end
+
+    def missing_eslint
+      warn_once(ESLINT_MISSING)
+      Result.new(counts: zero_counts, warnings: @warnings)
+    end
+
+    def degraded_batch(batch, code)
+      warn_once(code)
+      batch.to_h { |file| [file, 0] }
+    end
+
+    def zero_counts
+      @files.to_h { |file| [file, 0] }
+    end
+
+    def warn_once(code)
+      return if @warnings.include?(code)
+
+      @warnings << code
+      @stderr.puts "Warning: #{code}"
+    end
+  end
+end