Class: Test::Diff::SequenceMatcher

Inherits:
Object
  • Object
show all
Defined in:
lib/test-unit-ext/diff.rb

Instance Method Summary collapse

Constructor Details

#initialize(from, to, &junk_predicate) ⇒ SequenceMatcher

Returns a new instance of SequenceMatcher.



6
7
8
9
10
11
 
# File 'lib/test-unit-ext/diff.rb', line 6

def initialize(from, to, &junk_predicate)
  @from = from
  @to = to
  @junk_predicate = junk_predicate
  update_to_indexes
end

Instance Method Details

#blocks ⇒ Object 



27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/test-unit-ext/diff.rb', line 27

def blocks
  _blocks = []
  prev_from_index = prev_to_index = prev_size = 0
  matches.sort.each do |from_index, to_index, size|
    if prev_from_index + prev_size == from_index and
        prev_to_index + prev_size == to_index
      prev_size += size
    else
      unless prev_size.zero?
        _blocks << [prev_from_index, prev_to_index, prev_size]
      end
      prev_from_index = from_index
      prev_to_index = to_index
      prev_size = size
    end
  end
  unless prev_size.zero?
    _blocks << [prev_from_index, prev_to_index, prev_size]
  end

  _blocks << [@from.size, @to.size, 0]
  _blocks
end

#grouped_operations(context_size = nil) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/test-unit-ext/diff.rb', line 73

def grouped_operations(context_size=nil)
  context_size ||= 3
  _operations = operations
  _operations = [[:equal, 0, 0, 0, 0]] if _operations.empty?
  expand_edge_equal_operations!(_operations, context_size)

  group_window = context_size * 2
  groups = []
  group = []
  _operations.each do |tag, from_start, from_end, to_start, to_end|
    if tag == :equal and from_end - from_start > group_window
      group << [tag,
                from_start,
                [from_end, from_start + context_size].min,
                to_start,
                [to_end, to_start + context_size].min]
      groups << group
      group = []
      from_start = [from_start, from_end - context_size].max
      to_start = [to_start, to_end - context_size].max
    end
    group << [tag, from_start, from_end, to_start, to_end]
  end
  groups << group unless group.empty?
  groups
end

#longest_match(from_start, from_end, to_start, to_end) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/test-unit-ext/diff.rb', line 13

def longest_match(from_start, from_end, to_start, to_end)
  best_info = find_best_match_position(from_start, from_end,
                                       to_start, to_end)
  unless @junks.empty?
    args = [from_start, from_end, to_start, to_end]
    best_info = adjust_best_info_with_junk_predicate(false, best_info,
                                                     *args)
    best_info = adjust_best_info_with_junk_predicate(true, best_info,
                                                     *args)
  end

  best_info
end

#operations ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/test-unit-ext/diff.rb', line 51

def operations
  from_index = to_index = 0
  operations = []
  blocks.each do |match_from_index, match_to_index, size|
    tag = determine_tag(from_index, to_index,
                        match_from_index, match_to_index)
    if tag
      operations << [tag,
                     from_index, match_from_index,
                     to_index, match_to_index]
    end

    from_index, to_index = match_from_index + size, match_to_index + size
    if size > 0
      operations << [:equal,
                     match_from_index, from_index,
                     match_to_index, to_index]
    end
  end
  operations
end

#ratio ⇒ Object 



100
101
102
103
104
105
106
107
108
 
# File 'lib/test-unit-ext/diff.rb', line 100

def ratio
  matches = blocks.inject(0) {|result, block| result + block[-1]}
  length = @from.length + @to.length
  if length.zero?
    1.0
  else
    2.0 * matches / length
  end
end