Class: Ace::Git::Molecules::DiffFilter

Inherits:
Object
  • Object
show all
Defined in:
lib/ace/git/molecules/diff_filter.rb

Overview

Apply filtering to diff output based on configuration Migrated from ace-git-diff

Class Method Summary collapse

Class Method Details

.filter(diff, config) ⇒ String

Filter diff content based on configuration

Parameters:

Returns:

  • (String) —

    Filtered diff content



14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/ace/git/molecules/diff_filter.rb', line 14

def filter(diff, config)
  return "" if diff.nil? || diff.empty?
  return diff if config.exclude_patterns.empty?

  # Convert glob patterns to regex
  regex_patterns = Atoms::PatternFilter.glob_to_regex(config.exclude_patterns)

  # Apply pattern filtering
  filtered = Atoms::PatternFilter.filter_diff_by_patterns(diff, regex_patterns)

  # Check if exceeds max lines
  if config.max_lines && Atoms::DiffParser.exceeds_limit?(filtered, config.max_lines)
    truncate(filtered, config.max_lines)
  else
    filtered
  end
end

.filter_by_includes(diff, include_patterns) ⇒ String

Apply include patterns (only show matching files)

Parameters:

  • diff (String) —

    Raw diff content

  • include_patterns (Array<String>) —

    Glob patterns to include

Returns:

  • (String) —

    Filtered diff content



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/ace/git/molecules/diff_filter.rb', line 47

def filter_by_includes(diff, include_patterns)
  return diff if diff.nil? || diff.empty? || include_patterns.nil? || include_patterns.empty?

  lines = diff.split("\n")
  filtered_lines = []
  include_current_file = false

  lines.each do |line|
    # Check if this is a file header
    if Atoms::PatternFilter.file_header?(line)
      file_path = Atoms::PatternFilter.extract_file_path(line)
      # Include file if it matches any include pattern
      include_current_file = Atoms::PatternFilter.matches_include?(file_path, include_patterns)
      filtered_lines << line if include_current_file
    elsif include_current_file
      filtered_lines << line
    end
  end

  filtered_lines.join("\n")
end

.filter_by_patterns(diff, exclude_patterns) ⇒ String

Apply only path-based filtering (no size limits)

Parameters:

  • diff (String) —

    Raw diff content

  • exclude_patterns (Array<String>) —

    Glob patterns to exclude

Returns:

  • (String) —

    Filtered diff content



36
37
38
39
40
41
 
# File 'lib/ace/git/molecules/diff_filter.rb', line 36

def filter_by_patterns(diff, exclude_patterns)
  return diff if diff.nil? || diff.empty? || exclude_patterns.empty?

  regex_patterns = Atoms::PatternFilter.glob_to_regex(exclude_patterns)
  Atoms::PatternFilter.filter_diff_by_patterns(diff, regex_patterns)
end

.stats(original, filtered) ⇒ Hash

Get filtering statistics

Parameters:

  • original (String) —

    Original diff

  • filtered (String) —

    Filtered diff

Returns:

  • (Hash) —

    Statistics about filtering



87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/ace/git/molecules/diff_filter.rb', line 87

def stats(original, filtered)
  original_stats = Atoms::DiffParser.count_changes(original)
  filtered_stats = Atoms::DiffParser.count_changes(filtered)

  {
    original: original_stats,
    filtered: filtered_stats,
    files_removed: original_stats[:files] - filtered_stats[:files],
    lines_removed: Atoms::DiffParser.count_lines(original) - Atoms::DiffParser.count_lines(filtered)
  }
end

.truncate(diff, max_lines) ⇒ String

Truncate diff to maximum number of lines

Parameters:

  • diff (String) —

    Diff content

  • max_lines (Integer) —

    Maximum lines to keep

Returns:

  • (String) —

    Truncated diff with note



73
74
75
76
77
78
79
80
81
 
# File 'lib/ace/git/molecules/diff_filter.rb', line 73

def truncate(diff, max_lines)
  return diff if diff.nil? || diff.empty?

  lines = diff.split("\n")
  return diff if lines.length <= max_lines

  truncated = lines[0...max_lines].join("\n")
  truncated + "\n\n... (diff truncated at #{max_lines} lines)"
end