Class: Applitools::Selenium::VgMatchWindowData

Inherits:
MatchWindowData
  • Object
show all
Defined in:
lib/applitools/selenium/visual_grid/vg_match_window_data.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#selector_regions ⇒ Object

Returns the value of attribute selector_regions.



4
5
6
 
# File 'lib/applitools/selenium/visual_grid/vg_match_window_data.rb', line 4

def selector_regions
  @selector_regions
end

#target ⇒ Object

Returns the value of attribute target.



4
5
6
 
# File 'lib/applitools/selenium/visual_grid/vg_match_window_data.rb', line 4

def target
  @target
end

Instance Method Details

#convert_content_regions_coordinates ⇒ Object 



120
121
122
123
124
 
# File 'lib/applitools/selenium/visual_grid/vg_match_window_data.rb', line 120

def convert_content_regions_coordinates
  return unless @need_convert_content_regions_coordinates
  self.content_regions = @content_regions
  @need_convert_content_regions_coordinates = false
end

#convert_floating_regions_coordinates ⇒ Object 



102
103
104
105
106
 
# File 'lib/applitools/selenium/visual_grid/vg_match_window_data.rb', line 102

def convert_floating_regions_coordinates
  return unless @need_convert_floating_regions_coordinates
  self.floating_regions = @floating_regions
  @need_convert_floating_regions_coordinates = false
end

#convert_ignored_regions_coordinates ⇒ Object 



96
97
98
99
100
 
# File 'lib/applitools/selenium/visual_grid/vg_match_window_data.rb', line 96

def convert_ignored_regions_coordinates
  return unless @need_convert_ignored_regions_coordinates
  self.ignored_regions = @ignored_regions.map(&:with_padding).map(&:to_hash)
  @need_convert_ignored_regions_coordinates = false
end

#convert_layout_regions_coordinates ⇒ Object 



108
109
110
111
112
 
# File 'lib/applitools/selenium/visual_grid/vg_match_window_data.rb', line 108

def convert_layout_regions_coordinates
  return unless @need_convert_layout_regions_coordinates
  self.layout_regions = @layout_regions
  @need_convert_layout_regions_coordinates = false
end

#convert_strict_regions_coordinates ⇒ Object 



114
115
116
117
118
 
# File 'lib/applitools/selenium/visual_grid/vg_match_window_data.rb', line 114

def convert_strict_regions_coordinates
  return unless @need_convert_strict_regions_coordinates
  self.strict_regions = @strict_regions
  @need_convert_strict_regions_coordinates = false
end

#obtain_regions_coordinates(regions, driver) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/applitools/selenium/visual_grid/vg_match_window_data.rb', line 77

def obtain_regions_coordinates(regions, driver)
  result = []
  regions.each do |r|
    case r
    when Proc
      region = r.call(driver)
      region = selector_regions[target.regions[region]]
      result << Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
    when Applitools::Region
      result << r
    when Applitools::Selenium::VGRegion
      region = r.region
      region = selector_regions[target.regions[region]]
      result << Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
    end
  end
  result
end

#read_target(target, driver, selector_regions) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
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
 
# File 'lib/applitools/selenium/visual_grid/vg_match_window_data.rb', line 5

def read_target(target, driver, selector_regions)
  self.target = target
  self.selector_regions = selector_regions
  # options
  target_options_to_read.each do |field|
    a_value = target.options[field.to_sym]
    send("#{field}=", a_value) unless a_value.nil?
  end
  # ignored regions
  if target.respond_to? :ignored_regions
    target.ignored_regions.each do |r|
      @need_convert_ignored_regions_coordinates = true unless @need_convert_ignored_regions_coordinates
      case r
      when Proc
        region, padding_proc = r.call(driver, true)
        region = selector_regions[target.regions[region]]
        retrieved_region = Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
        @ignored_regions << padding_proc.call(retrieved_region) if padding_proc.is_a? Proc
      when Applitools::Region
        @ignored_regions << r
      when Applitools::Selenium::VGRegion
        region = selector_regions[target.regions[r.region]]
        retrieved_region = Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
        @ignored_regions << r.padding_proc.call(retrieved_region)
      end
    end
  end

  if target.respond_to? :layout_regions
    @layout_regions = obtain_regions_coordinates(target.layout_regions, driver)
    @need_convert_layout_regions_coordinates = true unless @layout_regions.empty?
  end

  if target.respond_to? :content_regions
    @content_regions = obtain_regions_coordinates(target.content_regions, driver)
    @need_convert_content_regions_coordinates = true unless @content_regions.empty?
  end

  if target.respond_to? :strict_regions
    @strict_regions = obtain_regions_coordinates(target.strict_regions, driver)
    @need_convert_strict_regions_coordinates = true unless @strict_regions.empty?
  end

  # # floating regions
  return unless target.respond_to? :floating_regions
  target.floating_regions.each do |r|
    case r
    when Proc
      region, padding_proc = r.call(driver, true)
      region = selector_regions[target.regions[region]]
      retrieved_region = Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
      floating_region = padding_proc.call(retrieved_region) if padding_proc.is_a? Proc
      raise Applitools::EyesError.new "Wrong floating region: #{region.class}" unless
          floating_region.is_a? Applitools::FloatingRegion
      @floating_regions << floating_region
      @need_convert_floating_regions_coordinates = true
    when Applitools::FloatingRegion
      @floating_regions << r
      @need_convert_floating_regions_coordinates = true
    when Applitools::Selenium::VGRegion
      region = r.region
      region = selector_regions[target.regions[region]]
      retrieved_region = Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
      floating_region = r.padding_proc.call(retrieved_region) if r.padding_proc.is_a? Proc
      raise Applitools::EyesError.new "Wrong floating region: #{region.class}" unless
          floating_region.is_a? Applitools::FloatingRegion
      @floating_regions << floating_region
      @need_convert_floating_regions_coordinates = true
    end
  end
end