Class: Chop::Diff

Inherits:
Struct
  • Object
show all
Defined in:
lib/chop/diff.rb

Direct Known Subclasses

DefinitionList, Table

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(selector = nil, table = nil, session = Capybara.current_session, timeout = Capybara.default_max_wait_time, block = nil, &other_block) ⇒ Diff

Returns a new instance of Diff.



45
46
47
48
49
50
51
52
 
# File 'lib/chop/diff.rb', line 45

def initialize selector = nil, table = nil, session = Capybara.current_session, timeout = Capybara.default_max_wait_time, block = nil, &other_block
  super
  self.selector ||= default_selector
  self.header_transformations = []
  self.transformations = []
  instance_eval &block if block.respond_to?(:call)
  instance_eval &other_block if block_given?
end

Instance Attribute Details

#block ⇒ Object

Returns the value of attribute block

Returns:

  • (Object) —

    the current value of block



8
9
10
 
# File 'lib/chop/diff.rb', line 8

def block
  @block
end

#header_transformations ⇒ Object

Returns the value of attribute header_transformations.



41
42
43
 
# File 'lib/chop/diff.rb', line 41

def header_transformations
  @header_transformations
end

#regex_fields ⇒ Object

Returns the value of attribute regex_fields.



43
44
45
 
# File 'lib/chop/diff.rb', line 43

def regex_fields
  @regex_fields
end

#regex_templates_enabled ⇒ Object

Returns the value of attribute regex_templates_enabled.



43
44
45
 
# File 'lib/chop/diff.rb', line 43

def regex_templates_enabled
  @regex_templates_enabled
end

#selector ⇒ Object

Returns the value of attribute selector

Returns:

  • (Object) —

    the current value of selector



8
9
10
 
# File 'lib/chop/diff.rb', line 8

def selector
  @selector
end

#session ⇒ Object

Returns the value of attribute session

Returns:

  • (Object) —

    the current value of session



8
9
10
 
# File 'lib/chop/diff.rb', line 8

def session
  @session
end

#table ⇒ Object

Returns the value of attribute table

Returns:

  • (Object) —

    the current value of table



8
9
10
 
# File 'lib/chop/diff.rb', line 8

def table
  @table
end

#timeout ⇒ Object

Returns the value of attribute timeout

Returns:

  • (Object) —

    the current value of timeout



8
9
10
 
# File 'lib/chop/diff.rb', line 8

def timeout
  @timeout
end

#transformations ⇒ Object

Returns the value of attribute transformations.



41
42
43
 
# File 'lib/chop/diff.rb', line 41

def transformations
  @transformations
end

Class Method Details

.diff!(selector, table, session: Capybara.current_session, timeout: Capybara.default_max_wait_time, errors: [], **kwargs, &block) ⇒ Object 



9
10
11
12
13
14
15
 
# File 'lib/chop/diff.rb', line 9

def self.diff! selector, table, session: Capybara.current_session, timeout: Capybara.default_max_wait_time, errors: [], **kwargs, &block
  errors += session.driver.invalid_element_errors
  errors += [Cucumber::MultilineArgument::DataTable::Different]
  synchronize_with_retry(session, timeout, errors) do
    new(selector, table, session, timeout, block).diff!(**kwargs)
  end
end

.synchronize_with_retry(session, timeout, errors) ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/chop/diff.rb', line 17

def self.synchronize_with_retry(session, timeout, errors)
  interval = session.config.default_retry_interval
  timer = Capybara::Helpers.timer(expire_in: timeout)
  begin
    yield
  rescue *errors => e
    raise e if timer.expired?
    sleep interval
    retry
  end
end

Instance Method Details

#allow_not_found ⇒ Object 



135
136
137
 
# File 'lib/chop/diff.rb', line 135

def allow_not_found
  @allow_not_found = true
end

#cell_to_image_filename(cell) ⇒ Object 



29
30
31
32
33
 
# File 'lib/chop/diff.rb', line 29

def cell_to_image_filename cell
  cell.all("img").map do |img|
    File.basename(img[:src] || "").split("?")[0].sub(/-[0-9a-f]{64}/, '')
  end.first
end

#cells(&block) ⇒ Object 



127
128
129
 
# File 'lib/chop/diff.rb', line 127

def cells &block
  self.cells_finder = block
end

#diff!(cucumber_table = table, **kwargs) ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/chop/diff.rb', line 164

def diff! cucumber_table = table, **kwargs
  actual = to_a
  # FIXME should just delegate to Cucumber's #diff!. Cucumber needs to handle empty tables better.
  if !cucumber_table.raw.flatten.empty? && !actual.flatten.empty?
    if regex_templates_enabled
      cucumber_table = Chop::RegexTemplates.apply(cucumber_table, actual, regex_fields)
    end
    cucumber_table.diff! actual, **kwargs
  elsif cucumber_table.raw.flatten != actual.flatten
    raise Cucumber::MultilineArgument::DataTable::Different.new(cucumber_table)
  end
end

#field(key) ⇒ Object 



107
108
109
110
111
112
113
 
# File 'lib/chop/diff.rb', line 107

def field key
  hash_transformation do |hashes|
    hashes.map! do |row|
      row.merge key => yield(row[key])
    end
  end
end

#hash_transformation(&block) ⇒ Object 



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/chop/diff.rb', line 91

def hash_transformation &block
  transformation do |rows|
    header = rows[0]
    keys = header.to_a.map.with_index do |cell, index|
      key = cell.text.parameterize.underscore
      next key if key.present?
      next cell.text if cell.text.present?
      index + 1
    end
    body = rows[1..-1]
    hashes = body.map { |row| HashWithIndifferentAccess[keys.zip(row)] }
    yield hashes
    [header] + hashes.map(&:values)
  end
end

#header(index = nil, &block) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/chop/diff.rb', line 58

def header index=nil, &block
  if index
    header_transformation do |row|
      if index.is_a?(Symbol)
        index = row.index do |cell|
          text_finder.call(cell).parameterize.underscore.to_sym == index
        end
      end
      row[index] = yield(row[index])
      row
    end
  else
    if block.arity.zero?
      @new_header = yield
    else
      header_transformation do |row|
        yield(row)
      end
    end
  end
end

#header_transformation(&block) ⇒ Object 



54
55
56
 
# File 'lib/chop/diff.rb', line 54

def header_transformation &block
  header_transformations << block
end

#image(*keys) ⇒ Object 



115
116
117
118
119
120
121
 
# File 'lib/chop/diff.rb', line 115

def image *keys
  keys.each do |key|
    field(key) do |cell|
      cell_to_image_filename(cell)
    end
  end
end

#regex(*fields) ⇒ Object

Enable embedded-regex templates within cells. Optionally restrict application to specific fields (by header name or 1-based index).



86
87
88
89
 
# File 'lib/chop/diff.rb', line 86

def regex *fields
  self.regex_templates_enabled = true
  self.regex_fields = fields unless fields.empty?
end

#rows(&block) ⇒ Object 



123
124
125
 
# File 'lib/chop/diff.rb', line 123

def rows &block
  self.rows_finder = block
end

#text(&block) ⇒ Object 



131
132
133
 
# File 'lib/chop/diff.rb', line 131

def text &block
  self.text_finder = block
end

#to_a ⇒ Object 



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/chop/diff.rb', line 139

def to_a
  rows = rows_finder.call(root).map { |row| cells_finder.call(row).to_a }
  rows = normalize(rows)

  header = @new_header ? normalize([@new_header]).first : rows.shift || []
  header = header_transformations.reduce(header) do |header, transformation|
    header = transformation.call(header)
    normalize([header]).first
  end

  if header
    rows = [header] + rows
    rows = normalize(rows)
  end

  rows = transformations.reduce(rows) do |rows, transformation|
    rows = transformation.call(rows)
    normalize(rows)
  end

  rows.map do |row|
    row.map { |cell| text_finder.call(cell) }
  end
end

#transformation(&block) ⇒ Object 



80
81
82
 
# File 'lib/chop/diff.rb', line 80

def transformation &block
  transformations << block
end