stud-finder 0.1.0 → 0.4.0

data/lib/stud_finder/newness.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'pathname'
+require 'set'
+
+module StudFinder
+  # rubocop:disable Metrics/ClassLength
+  class Newness
+    DEFAULT_DAYS = 30
+    DEFAULT_MIN_COMMITS = 3
+    SECONDS_PER_DAY = 86_400
+    SHALLOW_CLONE_WARNING = {
+      code: 'shallow_clone_newness_disabled',
+      message: 'shallow git clone detected; newness rules disabled (use fetch-depth: 0 in CI for full newness behavior)'
+    }.freeze
+
+    History = Struct.new(:first_commit_epoch, :total_commits, keyword_init: true)
+
+    class Error < StandardError; end
+
+    def initialize(repo_path:, files:, days: DEFAULT_DAYS, min_commits: DEFAULT_MIN_COMMITS, enabled: true,
+                   now: Time.now)
+      @repo_path = File.expand_path(repo_path)
+      @files = files
+      @days = days
+      @min_commits = min_commits
+      @enabled = enabled
+      @now = now.to_i
+    end
+
+    def call
+      return self.class.disabled_metadata(@files) unless @enabled
+      return self.class.disabled_metadata(@files) if self.class.shallow_repository?(@repo_path)
+
+      history = git_history
+      @files.to_h do |file|
+        first_epoch = history.first_commit_epoch[file]
+        total_commits = history.total_commits.fetch(file, 0)
+        age_days = age_days(first_epoch)
+        is_new = new_file?(age_days, total_commits)
+
+        [file, { new_file: is_new, age_days: age_days || 0, total_commits: total_commits, escalation: '',
+                 metadata_available: true }]
+      end
+    end
+
+    def self.apply(rows:, edges:, metadata:, branch_threshold: 'branch', coverage: nil)
+      rows = rows.map do |row|
+        file_metadata = metadata.fetch(row[:path], nil)
+        nf = newness_fields(file_metadata)
+        # Preserve floor escalation from the scorer (complexity_floor / fan_in_floor); newness rules
+        # may still override it below for new files (trunk_adjacent or recency_floor always win).
+        existing_escalation = row.fetch(:escalation, '')
+        nf = nf.merge(escalation: existing_escalation) unless existing_escalation.to_s.empty?
+        row.merge(nf).merge(evidence: evidence(file_metadata, coverage&.key?(row[:path])))
+      end
+      # Rule 2: scorer "trunk" now means high composite risk, not fan-in-only structural coupling.
+      trunk_paths = rows.select { |row| row[:classification] == 'trunk' }.to_set { |row| row[:path] }
+
+      rows.map do |row|
+        next row unless row[:new_file]
+
+        dependencies = edges.fetch(row[:path], {}).fetch(:dependencies, [])
+        if dependencies.any? { |path| trunk_paths.include?(path) }
+          row.merge(classification: 'trunk', escalation: 'trunk_adjacent')
+        elsif row[:classification] == 'leaf' || %w[complexity_floor fan_in_floor].include?(row[:escalation].to_s)
+          row.merge(classification: branch_threshold, escalation: 'recency_floor')
+        else
+          row
+        end
+      end
+    end
+
+    def self.disabled_metadata(files)
+      files.to_h do |file|
+        [file, { new_file: false, age_days: 0, total_commits: 0, escalation: '', metadata_available: false }]
+      end
+    end
+
+    def self.shallow_repository?(repo_path)
+      repo_path = File.expand_path(repo_path)
+      stdout, _stderr, status = Open3.capture3('git', 'rev-parse', '--is-shallow-repository', chdir: repo_path)
+      return stdout.strip == 'true' if status.success?
+
+      git_shallow_file?(repo_path)
+    rescue Errno::ENOENT
+      git_shallow_file?(repo_path)
+    end
+
+    def self.newness_fields(metadata)
+      metadata ||= { new_file: false, age_days: 0, total_commits: 0, metadata_available: false }
+      {
+        new_file: metadata.fetch(:new_file, false),
+        age_days: metadata.fetch(:age_days, 0),
+        total_commits: metadata.fetch(:total_commits, 0),
+        newness_metadata_available: metadata.fetch(:metadata_available, false),
+        escalation: ''
+      }
+    end
+
+    def self.evidence(metadata, explicit_coverage)
+      return nil unless metadata&.fetch(:metadata_available, false)
+
+      age_component = [metadata.fetch(:age_days, 0) / 30.0, 1.0].min
+      commits_component = [metadata.fetch(:total_commits, 0) / 3.0, 1.0].min
+      coverage_component = explicit_coverage ? 1.0 : 0.0
+
+      ((age_component + commits_component + coverage_component) / 3.0).round(4)
+    end
+
+    def self.git_shallow_file?(repo_path)
+      return true if File.exist?(File.join(repo_path, '.git', 'shallow'))
+
+      stdout, _stderr, status = Open3.capture3('git', 'rev-parse', '--git-dir', chdir: repo_path)
+      status.success? && File.exist?(File.join(File.expand_path(stdout.strip, repo_path), 'shallow'))
+    rescue Errno::ENOENT
+      false
+    end
+    private_class_method :git_shallow_file?
+
+    private
+
+    def empty_history
+      History.new(first_commit_epoch: {}, total_commits: {})
+    end
+
+    def git_history
+      # Use committer time (%ct), not author time, because newness is about when code landed in this repo.
+      # Cherry-picked or imported files can carry old author dates while still being newly introduced here.
+      stdout, _stderr, status = Open3.capture3(
+        'git', '-C', @repo_path, 'log',
+        '--format=%x1e%ct',
+        '--name-status',
+        '--find-renames',
+        '--diff-filter=ACMRD'
+      )
+      raise Error, "Error: #{@repo_path} is not a git repository." unless status.success?
+
+      parse_history(stdout)
+    rescue Errno::ENOENT
+      raise Error, 'Error: git not found in PATH.'
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def parse_history(stdout)
+      wanted = @files.to_set
+      first_commit_epoch = {}
+      total_commits = Hash.new(0)
+      aliases = {}
+      current_epoch = nil
+      touched = Set.new
+      lineage_boundaries = Set.new
+
+      flush_commit = lambda do
+        touched.each do |file|
+          total_commits[file] += 1
+          first_commit_epoch[file] = [first_commit_epoch[file], current_epoch].compact.min if current_epoch
+        end
+        touched.clear
+      end
+
+      stdout.each_line(chomp: true) do |line|
+        if line.start_with?("\x1e")
+          flush_commit.call if current_epoch
+          current_epoch = line.delete_prefix("\x1e").to_i
+          next
+        end
+
+        deleted_path = deleted_path_for_status(line)
+        if deleted_path
+          canonical = trackable_canonical_path(deleted_path, aliases)
+          lineage_boundaries << deleted_path if canonical && wanted.include?(canonical)
+          next
+        end
+
+        paths_for_status(line).each do |path|
+          canonical = trackable_canonical_path(path, aliases)
+          next unless canonical && wanted.include?(canonical)
+          next if lineage_boundaries.include?(path)
+
+          touched << canonical
+        end
+
+        old_path, new_path = rename_paths_for_status(line)
+        next unless old_path && new_path
+
+        new_rebased = rebase_to_analysis_root(new_path)
+        next unless new_rebased
+
+        canonical_new = canonical_path(new_rebased, aliases)
+        next unless wanted.include?(canonical_new) && !lineage_boundaries.include?(old_path) &&
+                    !lineage_boundaries.include?(new_path)
+
+        touched << canonical_new
+        aliases[alias_key_for(old_path)] = canonical_new
+      end
+      flush_commit.call if current_epoch
+
+      History.new(first_commit_epoch: first_commit_epoch, total_commits: total_commits)
+    end
+
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    def paths_for_status(line)
+      return [] if line.nil? || line.empty?
+
+      parts = line.split("\t")
+      status = parts.first.to_s
+      if status.start_with?('R') || status.start_with?('C')
+        [parts[2]].compact
+      else
+        [parts[1]].compact
+      end
+    end
+
+    def rename_paths_for_status(line)
+      return [nil, nil] if line.nil? || line.empty?
+
+      parts = line.split("\t")
+      return [nil, nil] unless parts.first.to_s.start_with?('R')
+
+      [parts[1], parts[2]]
+    end
+
+    def deleted_path_for_status(line)
+      return nil if line.nil? || line.empty?
+
+      parts = line.split("\t")
+      return nil unless parts.first == 'D'
+
+      parts[1]
+    end
+
+    def trackable_canonical_path(raw_path, aliases)
+      rebased = rebase_to_analysis_root(raw_path)
+      return nil unless !rebased.nil? || aliases.key?(raw_path)
+
+      canonical_path(rebased || raw_path, aliases)
+    end
+
+    def alias_key_for(old_path)
+      rebase_to_analysis_root(old_path) || old_path
+    end
+
+    def canonical_path(path, aliases)
+      canonical = path
+      seen = Set.new
+      while aliases.key?(canonical) && !seen.include?(canonical)
+        seen << canonical
+        canonical = aliases[canonical]
+      end
+      canonical
+    end
+
+    # git log emits paths relative to the repository root even when -C points at
+    # an analysis subdirectory. Rebase those records to the analysis root so they
+    # can be compared with FileCollector paths (for example, app/models/user.rb
+    # becomes models/user.rb when scanning <repo>/app).
+    def rebase_to_analysis_root(path)
+      return nil if path.nil? || path.empty?
+      return path unless analysis_root_prefix
+
+      path.start_with?(analysis_root_prefix) ? path.delete_prefix(analysis_root_prefix) : nil
+    end
+
+    def analysis_root_prefix
+      return @analysis_root_prefix if defined?(@analysis_root_prefix)
+
+      @analysis_root_prefix = begin
+        toplevel = git_toplevel
+        analysis_abs = File.realpath(@repo_path)
+        if toplevel.nil? || analysis_abs == toplevel
+          nil
+        else
+          prefix = Pathname.new(analysis_abs).relative_path_from(Pathname.new(toplevel)).to_s
+          prefix.empty? || prefix == '.' || prefix.start_with?('..') ? nil : "#{prefix}/"
+        end
+      end
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def git_toplevel
+      return @git_toplevel if defined?(@git_toplevel)
+
+      stdout, _stderr, status = Open3.capture3('git', '-C', @repo_path, 'rev-parse', '--show-toplevel')
+      @git_toplevel = status.success? ? File.realpath(stdout.strip) : nil
+    end
+
+    def age_days(first_epoch)
+      return nil unless first_epoch
+
+      [((@now - first_epoch) / SECONDS_PER_DAY).floor, 0].max
+    end
+
+    def new_file?(age_days, total_commits)
+      within_age_window = @days.positive? && !age_days.nil? && age_days < @days
+      low_commit_count = @min_commits.positive? && total_commits < @min_commits
+      unknown_lineage = age_days.nil?
+
+      unknown_lineage || within_age_window || low_commit_count
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/stud_finder/rails_inference.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module StudFinder
+  # Extracts conservative Rails-style implicit constant references from Ruby ASTs.
+  class RailsInference
+    Inference = Struct.new(:node, :name, :absolute, keyword_init: true)
+
+    ASSOCIATIONS = %i[belongs_to has_one has_many has_and_belongs_to_many].freeze
+    COLLECTION_ASSOCIATIONS = %i[has_many has_and_belongs_to_many].freeze
+    STRING_CONSTANTIZERS = %i[constantize safe_constantize].freeze
+    SAFE_CLASS_BODY_WRAPPERS = %i[with_options included class_eval class_exec].freeze
+    IRREGULAR_SINGULARS = {
+      'people' => 'person',
+      'children' => 'child',
+      'men' => 'man',
+      'women' => 'woman',
+      'mice' => 'mouse',
+      'geese' => 'goose'
+    }.freeze
+
+    def initialize(ast)
+      @ast = ast
+    end
+
+    def call
+      return [] unless @ast
+
+      @ast.each_node(:send).filter_map do |node|
+        association_inference(node) || string_constant_inference(node)
+      end
+    end
+
+    private
+
+    def association_inference(node)
+      _receiver, method_name, *args = *node
+      return unless class_body_call?(node)
+      return unless implicit_receiver?(node.receiver)
+
+      if ASSOCIATIONS.include?(method_name)
+        return association_reference(node, method_name, args)
+      elsif method_name == :composed_of
+        explicit_class = class_name_option(args)
+        return reference(node, explicit_class) if explicit_class.is_a?(String)
+      end
+
+      nil
+    end
+
+    def string_constant_inference(node)
+      receiver, method_name, = *node
+      literal = string_literal(receiver)
+      return unless literal
+
+      if STRING_CONSTANTIZERS.include?(method_name)
+        reference(node, literal, absolute: true)
+      elsif method_name == :const_get
+        reference(node, literal)
+      end
+    end
+
+    def association_reference(node, method_name, args)
+      association_name = symbol_name(args.first)
+      return unless association_name
+      return if method_name == :belongs_to && polymorphic_belongs_to?(args)
+
+      explicit_class = class_name_option(args)
+      return if explicit_class == :dynamic
+
+      collection = COLLECTION_ASSOCIATIONS.include?(method_name)
+      name = explicit_class || inferred_association_class(association_name, collection: collection)
+      reference(node, name) if name
+    end
+
+    def reference(node, name, absolute: nil)
+      absolute = name.start_with?('::') if absolute.nil?
+      Inference.new(node: node, name: name.delete_prefix('::'), absolute: absolute)
+    end
+
+    def class_body_call?(node)
+      seen_class_or_module = false
+
+      node.each_ancestor do |ancestor|
+        return false if ancestor.def_type? || ancestor.defs_type?
+        return false if ancestor.block_type? && !safe_class_body_wrapper?(ancestor)
+
+        if ancestor.class_type? || ancestor.module_type?
+          seen_class_or_module = true
+          break
+        end
+      end
+
+      seen_class_or_module
+    end
+
+    def safe_class_body_wrapper?(node)
+      send_node = node.send_node
+      send_node && SAFE_CLASS_BODY_WRAPPERS.include?(send_node.method_name)
+    end
+
+    def implicit_receiver?(receiver)
+      receiver.nil? || receiver.self_type?
+    end
+
+    def symbol_name(node)
+      return unless node&.sym_type?
+
+      node.value.to_s
+    end
+
+    def class_name_option(args)
+      pair = option_pair(args, 'class_name')
+      return unless pair
+
+      string_literal(pair.value) || :dynamic
+    end
+
+    def polymorphic_belongs_to?(args)
+      pair = option_pair(args, 'polymorphic')
+      return false unless pair
+
+      !pair.value&.false_type?
+    end
+
+    def option_pair(args, name)
+      hash = args.find(&:hash_type?)
+      return unless hash
+
+      hash.pairs.find { |candidate| hash_key_name(candidate.key) == name }
+    end
+
+    def hash_key_name(node)
+      return node.value.to_s if node&.sym_type?
+      return node.value if node&.str_type?
+
+      nil
+    end
+
+    def string_literal(node)
+      return node.value if node&.str_type?
+
+      nil
+    end
+
+    def inferred_association_class(name, collection:)
+      source = collection ? singularize(name) : name
+      camelize(source)
+    end
+
+    # Minimal heuristic only, not Rails inflection. Wrong guesses simply do not
+    # resolve to owned constants in FanIn.
+    def singularize(word)
+      lower = word.downcase
+      return IRREGULAR_SINGULARS.fetch(lower) if IRREGULAR_SINGULARS.key?(lower)
+
+      case word
+      when /(ses|xes|zes|ches|shes)\z/
+        word.delete_suffix('es')
+      when /ies\z/
+        "#{word[0...-3]}y"
+      when /s\z/
+        word.delete_suffix('s')
+      else
+        word
+      end
+    end
+
+    def camelize(segment)
+      segment.split('_').map(&:capitalize).join
+    end
+  end
+end