Class: Dill::List

Inherits:
Widget show all
Includes:
Enumerable
Defined in:
lib/dill/widgets/list.rb

Overview

Use a List when you want to treat repeating elements as a unit.

Usage

Consider the following HTML:

<ul id="colors">
  <li>Red <span class="pt">Vermelho</span></li>
  <li>Green <span class="pt">Verde</span></li>
  <li>Blue <span class="pt">Azul</span></li>
</ul>

You can then define the following widget:

class Colors < Dill::List
  root '#colors'
  item 'li'
end

Now you’ll be able to iterate over each item:

# prints:
# Red Vermelho
# Green Verde
# Blue Azul
widget(:colors).each do |e|
  puts e
end

This is the same as doing the following in Capybara:

all('#colors li').each do |e|
  puts e.text.strip
end

Not that, by default, the root selector of a List is ul and the list item selector is li. So you could wrap the <ul> above simply by using the following:

class Colors < Dill::List
end

Narrowing items

You can define the root selector for your list items using the ::item macro:

class PortugueseColors < Dill::List
  root '#colors
  item '.pt'
end

If you iterate over this list you get the following:

# prints:
# Vermelho
# Verde
# Azul
widget(:portuguese_colors).each do |e|
  puts e
end

You can make a list out of any repeating elements, as long as you can define parent and child selectors.

<div id="not-a-list-colors">
  <div class=".child">Red</div>
  <div class=".child">Green</div>
  <div class=".child">Blue</div>
</div>

You can define the following widget:

class NotAListColors < Dill::List
  root '#not-a-list-colors'
  item '.child'
end

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Widget

#absent?, action, #click, #diff, find_in, #gone?, #has_action?, #initialize, #inspect, #present?, present_in?, root, #root, #text, #to_cell, #to_s, widget, widget_delegator

Methods included from WidgetParts::Container

#has_no_widget?, #has_widget?, #widget

Methods included from WidgetParts::Struct

included

Constructor Details

This class inherits a constructor from Dill::Widget

Class Attribute Details

.item_factory ⇒ Object 



140
141
142
 
# File 'lib/dill/widgets/list.rb', line 140

def item_factory
  @item_factory ||= WidgetClass.new('li', ListItem)
end

Class Method Details

.item(selector, type = ListItem, &block) ⇒ Object

Configures the List item selector and class.

Usage

Given the following HTML:

<ul>
  <li>One</li>
  <li>Two</li>
  <li>Three</li>
</ul>

In its most basic form, allows you to configure the list item selector, using the default list item class (Dill::ListItem):

class Numbers < Dill::List
  root 'ul'
  item 'li'
end

Extending the list item class

You can define the list item class for the current List:

class Number < Dill::Widget
  # ...
end

class Numbers < Dill::List
  root 'ul'
  item 'li', Number
end

widget(:numbers).first.class < Number #=> true

Alternatively, you can extend the list item type inline. This is useful when you want to add small extensions to the default list item class. The extensions will apply only to list items of the current List.

class Numbers < Dill::List
  root 'ul'

  item 'li' do
    def upcase
      text.upcase
    end
  end

  widget(:numbers).first.upcase #=> "ONE"
end



134
135
136
 
# File 'lib/dill/widgets/list.rb', line 134

def item(selector, type = ListItem, &block)
  self.item_factory = WidgetClass.new(selector, type, &block)
end

.selector ⇒ Object 



144
145
146
147
148
149
150
151
152
 
# File 'lib/dill/widgets/list.rb', line 144

def selector
  begin
    super
  rescue Widget::MissingSelector
    root 'ul'

    super
  end
end

Instance Method Details

#count ⇒ Object 



155
156
157
 
# File 'lib/dill/widgets/list.rb', line 155

def count
  items.count
end

#empty? ⇒ Boolean

TODO: Convert value to primitive data structures.

Returns:

  • (Boolean) 


160
161
162
 
# File 'lib/dill/widgets/list.rb', line 160

def empty?
  items.empty?
end

#exclude?(element) ⇒ Boolean

Returns:

  • (Boolean) 


164
165
166
 
# File 'lib/dill/widgets/list.rb', line 164

def exclude?(element)
  ! include?(element)
end

#include?(element) ⇒ Boolean

Returns:

  • (Boolean) 


168
169
170
 
# File 'lib/dill/widgets/list.rb', line 168

def include?(element)
  value.include?(element)
end

#length ⇒ Object 



172
173
174
 
# File 'lib/dill/widgets/list.rb', line 172

def length
  items.length
end

#size ⇒ Object 



176
177
178
 
# File 'lib/dill/widgets/list.rb', line 176

def size
  items.size
end

#to_row ⇒ Object 



180
181
182
 
# File 'lib/dill/widgets/list.rb', line 180

def to_row
  items.map(&:to_cell)
end

#to_table ⇒ Object 



184
185
186
 
# File 'lib/dill/widgets/list.rb', line 184

def to_table
  items.map(&:to_row)
end

#value ⇒ Object 



188
189
190
 
# File 'lib/dill/widgets/list.rb', line 188

def value
  items.map(&:value)
end