Class: Ace::GitCommit::Molecules::PathResolver

Inherits:
Object
  • Object
show all
Defined in:
lib/ace/git_commit/molecules/path_resolver.rb

Overview

PathResolver handles path resolution and filtering for commits

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(git_executor) ⇒ PathResolver 



18
19
20
21
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 18

def initialize(git_executor)
  @git = git_executor
  @last_error = nil
end

Instance Attribute Details

#last_error ⇒ Object (readonly)

Returns the value of attribute last_error.



10
11
12
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 10

def last_error
  @last_error
end

Instance Method Details

#all_paths_exist?(paths) ⇒ Boolean

Check if all paths exist or have git changes (deleted/renamed files)



130
131
132
133
134
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 130

def all_paths_exist?(paths)
  return true if paths.nil? || paths.empty?
  result = validate_paths(paths)
  result[:invalid].empty?
end

#files_in_path(path) ⇒ Array<String>

Get all tracked files within specified path



67
68
69
70
71
72
73
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 67

def files_in_path(path)
  result = @git.execute("ls-files", path)
  result.strip.split("\n").reject(&:empty?)
rescue GitError => e
  @last_error = e.message
  []
end

#filter_by_paths(all_files, allowed_paths) ⇒ Array<String>

Filter files to only those within specified paths



56
57
58
59
60
61
62
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 56

def filter_by_paths(all_files, allowed_paths)
  return all_files if allowed_paths.nil? || allowed_paths.empty?

  all_files.select do |file|
    allowed_paths.any? { |path| file_in_path?(file, path) }
  end
end

#glob_pattern?(path) ⇒ Boolean

Check if path contains glob pattern characters



139
140
141
142
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 139

def glob_pattern?(path)
  # Check for common glob metacharacters
  path.include?("*") || path.include?("?") || path.include?("[") || path.include?("{")
end

#modified_files_in_paths(paths, staged: false) ⇒ Array<String>

Get modified files within specified paths



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 79

def modified_files_in_paths(paths, staged: false)
  return [] if paths.nil? || paths.empty?

  args = ["diff", "--name-only"]
  args << "--cached" if staged

  modified = []
  paths.each do |path|
    result = @git.execute(*args, path)
    files = result.strip.split("\n").reject(&:empty?)
    modified.concat(files)
  end

  modified.uniq.sort
rescue GitError => e
  @last_error = e.message
  []
end

#resolve_paths(paths) ⇒ Array<String>

Resolve paths to actual file lists Expands directories, glob patterns to files within them



27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 27

def resolve_paths(paths)
  return [] if paths.nil? || paths.empty?

  resolved = []
  paths.each do |path|
    if glob_pattern?(path)
      # Expand glob pattern to matching tracked files
      files = expand_glob_pattern(path)
      resolved.concat(files)
    elsif File.directory?(path)
      # Get all tracked files in directory
      files = files_in_path(path)
      resolved.concat(files)
    elsif File.exist?(path)
      # Single file
      resolved << path
    else
      # Path doesn't exist - we'll validate later
      resolved << path
    end
  end

  resolved.uniq.sort
end

#simple_glob_pattern?(pattern) ⇒ Boolean

Check if pattern is a simple (non-recursive) glob pattern Simple globs like *.rb only match at current directory level



148
149
150
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 148

def simple_glob_pattern?(pattern)
  glob_pattern?(pattern) && !pattern.include?("**")
end

#suggest_recursive_pattern(pattern) ⇒ String?

Suggest a recursive alternative for simple glob patterns



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 155

def suggest_recursive_pattern(pattern)
  return nil unless simple_glob_pattern?(pattern)

  # For patterns starting with *, prepend **/ for recursive matching
  # e.g., "*.rb" -> "**/*.rb"
  return "**/#{pattern}" if pattern.start_with?("*")

  # For patterns with subdirectory like "dir/*.rb", insert **/ before the glob part
  # e.g., "dir/*.rb" -> "dir/**/*.rb"
  if pattern.include?("/")
    # Find the last directory separator before the glob portion
    last_slash = pattern.rindex("/")
    dir_part = pattern[0..last_slash]
    glob_part = pattern[(last_slash + 1)..]
    return "#{dir_part}**/#{glob_part}" if glob_part.include?("*")
  end

  nil
end

#validate_paths(paths) ⇒ Hash

Validate that paths exist or have git changes (deleted/renamed files)



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 101

def validate_paths(paths)
  return {valid: [], invalid: []} if paths.nil? || paths.empty?

  valid = []
  invalid = []
  git_changed_paths = nil # Lazy load
  git_changed_set = nil   # Pre-computed Set for O(1) lookups

  paths.each do |path|
    if File.exist?(path)
      valid << path
    else
      # Check if path has git changes (deleted, renamed)
      git_changed_paths ||= paths_with_git_changes
      git_changed_set ||= git_changed_paths.map { |p| p.chomp("/") }.to_set
      if path_has_git_changes?(path, git_changed_paths, git_changed_set)
        valid << path
      else
        invalid << path
      end
    end
  end

  {valid: valid, invalid: invalid}
end

#within_repository?(path) ⇒ Boolean

Check if path is within repository boundaries



178
179
180
181
182
183
184
185
186
187
 
# File 'lib/ace/git_commit/molecules/path_resolver.rb', line 178

def within_repository?(path)
  return false unless File.exist?(path)

  expanded = File.expand_path(path)
  repo_root = @git.execute("rev-parse", "--show-toplevel").strip
  expanded.start_with?(File.expand_path(repo_root))
rescue GitError => e
  @last_error = e.message
  false
end