Class: Ace::Git::Organisms::RepoStatusLoader

Inherits:
Object
  • Object
show all
Defined in:
lib/ace/git/organisms/repo_status_loader.rb

Overview

Orchestrates loading complete repository status Combines branch info, task pattern detection, and PR metadata

Class Method Summary collapse

Class Method Details

.load(options = {}) ⇒ Models::RepoStatus

Load complete repository status

Parameters:

  • options (Hash) (defaults to: {}) —

    Options for status loading

Options Hash (options):

  • :include_pr (Boolean) —

    Whether to fetch PR metadata (default: true)

  • :include_pr_activity (Boolean) —

    Whether to fetch PR activity (default: true)

  • :include_commits (Boolean) —

    Whether to fetch recent commits (default: true)

  • :commits_limit (Integer) —

    Number of recent commits to fetch (default: 3)

  • :timeout (Integer) —

    Timeout for network operations like PR fetch (default: network_timeout)

Returns:



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/ace/git/organisms/repo_status_loader.rb', line 18

def load(options = {})
  include_pr = options.fetch(:include_pr, true)
  include_pr_activity = options.fetch(:include_pr_activity, true)
  include_commits = options.fetch(:include_commits, true)
  commits_limit = options.fetch(:commits_limit, Ace::Git.commits_limit)
  timeout = options.fetch(:timeout, Ace::Git.network_timeout)

  # Get repository type and state
  repo_type = Atoms::RepositoryChecker.repository_type
  repo_state = Atoms::RepositoryStateDetector.detect

  # Check if we can proceed
  unless Atoms::RepositoryChecker.usable?
    return Models::RepoStatus.new(
      branch: nil,
      repository_type: repo_type,
      repository_state: repo_state
    )
  end

  # Get branch information
  branch_info = Molecules::BranchReader.full_info

  # Extract task pattern from branch name
  task_pattern = nil
  if branch_info[:name] && branch_info[:name] != "HEAD"
    task_pattern = Atoms::TaskPatternExtractor.extract(branch_info[:name])
  end

  # Fetch git status (always, it's fast and local)
  git_status_sb = fetch_git_status

  # Fetch recent commits if requested
  recent_commits = nil
  if include_commits && commits_limit > 0
    recent_commits = fetch_recent_commits(limit: commits_limit)
  end

  # Fetch PR data (metadata and activity) - parallelized for performance
  pr_metadata = nil
  pr_activity = nil
  if !branch_info[:detached]
    if include_pr && include_pr_activity
      # Both requested: use parallel fetch for ~50% speedup
      pr_data = fetch_pr_data_parallel(
        current_branch: branch_info[:name],
        timeout: timeout
      )
      pr_metadata = pr_data[:pr_metadata]
      pr_activity = pr_data[:pr_activity]
    elsif include_pr
      # Only PR metadata requested
      pr_metadata = fetch_pr_metadata(timeout: timeout)
    elsif include_pr_activity
      # Only activity requested
      pr_activity = fetch_pr_activity(
        current_branch: branch_info[:name],
        timeout: timeout
      )
    end
  end

  # Build and return status
  Models::RepoStatus.from_data(
    branch_info: branch_info,
    task_pattern: task_pattern,
    pr_metadata: pr_metadata,
    pr_activity: pr_activity,
    git_status_sb: git_status_sb,
    recent_commits: recent_commits,
    repo_type: repo_type,
    repo_state: repo_state
  )
end

.load_for_pr(pr_identifier, options = {}) ⇒ Models::RepoStatus

Load status for a specific PR

Parameters:

  • pr_identifier (String) —

    PR identifier

  • options (Hash) (defaults to: {}) —

    Options

Returns:



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/ace/git/organisms/repo_status_loader.rb', line 97

def load_for_pr(pr_identifier, options = {})
  timeout = options.fetch(:timeout, Ace::Git.network_timeout)

  # Get basic status (skip PR activity since we're fetching a specific PR)
  status = load(include_pr: false, include_pr_activity: false)

  # Fetch specific PR metadata
  begin
    result = Molecules::PrMetadataFetcher.fetch_metadata(pr_identifier, timeout: timeout)
    pr_metadata = result[:success] ? result[:metadata] : nil
  rescue Ace::Git::Error
    pr_metadata = nil
  end

  # Return status with PR data
  Models::RepoStatus.from_data(
    branch_info: {
      name: status.branch,
      tracking: status.tracking,
      ahead: status.ahead,
      behind: status.behind
    },
    task_pattern: status.task_pattern,
    pr_metadata: pr_metadata,
    repo_type: status.repository_type,
    repo_state: status.repository_state
  )
end

.load_minimal ⇒ Models::RepoStatus

Load minimal status (branch only, no PR)

Returns:



128
129
130
 
# File 'lib/ace/git/organisms/repo_status_loader.rb', line 128

def load_minimal
  load(include_pr: false, include_pr_activity: false, include_commits: false)
end