Class: Dill::List

Inherits:
Widget show all
Includes:
Enumerable
Defined in:
lib/dill/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

Attributes inherited from Widget

#root

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Widget

#!=, #!~, #<, #<=, #==, #=~, #>, #>=, action, #click, #diff, find_in, #has_action?, #initialize, #inspect, #match, present_in?, #reload, root, #text, #to_cell, #to_f, #to_i, widget, widget_delegator

Methods included from WidgetContainer

#has_widget?, #widget

Constructor Details

This class inherits a constructor from Dill::Widget

Class Attribute Details

.item_factory ⇒ Object 



140
141
142
 
# File 'lib/dill/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/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
 
# File 'lib/dill/list.rb', line 144

def selector
  super ||
    begin
      root 'ul'

      super
    end
end

Instance Method Details

#to_table ⇒ Object 



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

def to_table
  items.map(&:to_row)
end