capybara-ui 0.10.0

data/lib/capybara-ui/widgets/form.rb

@@ -0,0 +1,26 @@
+module CapybaraUI
+  class Form < FieldGroup
+    root 'form'
+
+    action :submit, '[type = submit]'
+
+    # Submit form with +attributes+.
+    #
+    # @param attributes [Hash] the form fields and their values
+    #
+    # @return the current widget
+    def submit_with(attributes)
+      set attributes
+      submit
+    end
+
+    def to_table
+      info = self.
+        class.
+        field_names.
+        each_with_object({}) { |e, a| a[e.to_s] = widget(e).to_cell }
+
+      [info]
+    end
+  end
+end

data/lib/capybara-ui/widgets/list.rb

@@ -0,0 +1,200 @@
+module CapybaraUI
+  # 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 < CapybaraUI::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
+  #
+  # Note 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 < CapybaraUI::List
+  #   end
+  #
+  # ==== Narrowing items
+  #
+  # You can define the root selector for your list items using the ::item macro:
+  #
+  #   class PortugueseColors < CapybaraUI::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 < CapybaraUI::List
+  #     root '#not-a-list-colors'
+  #     item '.child'
+  #   end
+  class List < Widget
+    include Enumerable
+
+    def_delegators :items, :each, :first, :last
+
+    root 'ul' unless filter?
+
+    class << self
+      # 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 (CapybaraUI::ListItem):
+      #
+      #   class Numbers < CapybaraUI::List
+      #     root 'ul'
+      #     item 'li'
+      #   end
+      #
+      # ==== Extending the list item class
+      #
+      # You can define the list item class for the current List:
+      #
+      #   class Number < CapybaraUI::Widget
+      #     # ...
+      #   end
+      #
+      #   class Numbers < CapybaraUI::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 < CapybaraUI::List
+      #     root 'ul'
+      #
+      #     item 'li' do
+      #       def upcase
+      #         text.upcase
+      #       end
+      #     end
+      #
+      #     widget(:numbers).first.upcase #=> "ONE"
+      #   end
+      def item(selector, type = ListItem, &block)
+        self.item_factory = WidgetClass.new(selector, type, &block)
+      end
+
+      attr_writer :item_factory
+
+      def item_factory
+        @item_factory ||= WidgetClass.new('li', ListItem)
+      end
+    end
+
+    def count
+      items.count
+    end
+
+    # TODO: Convert value to primitive data structures.
+    def empty?
+      items.empty?
+    end
+
+    def exclude?(element)
+      ! include?(element)
+    end
+
+    def include?(element)
+      value.include?(element)
+    end
+
+    def length
+      items.length
+    end
+
+    def size
+      items.size
+    end
+
+    def to_row
+      items.map(&:to_cell)
+    end
+
+    def to_table
+      items.map(&:to_row)
+    end
+
+    def value
+      items.map(&:value)
+    end
+
+    protected
+
+    def_delegator 'self.class', :item_factory
+
+    def item_for(node)
+      item_factory.new(node)
+    end
+
+    def item_filter
+      item_factory.filter
+    end
+
+    def items
+      item_filter.nodes(self).map { |node| item_for(node) }
+    end
+  end
+end

data/lib/capybara-ui/widgets/list_item.rb

@@ -0,0 +1,22 @@
+module CapybaraUI
+  class ListItem < Widget
+    # Returns this ListItem's contents formatted as a row, for comparison with a
+    # Cucumber::Ast::Table. By default, it simply returns an array with a single
+    # element--the widget's text.
+    #
+    # In general, this method will be called by List#to_table.
+    #
+    # === Overriding
+    #
+    # Feel free to override this method to return whatever you need it to.
+    # Usually, if the default return value isn't what you want, you'll probably
+    # want to return a Hash where both keys and values are strings, so that you
+    # don't need to worry about column order when you pass the table to
+    # Cucumber::Ast::Table#diff!.
+    #
+    # See List#to_table for more information.
+    def to_row
+      [to_cell]
+    end
+  end
+end

data/lib/capybara-ui/widgets/parts/container.rb

@@ -0,0 +1,46 @@
+module CapybaraUI
+  module WidgetParts
+    module Container
+      include CapybaraUI
+
+      def has_widget?(name, *args)
+        deprecate('has_widget? and its alias widget?', 'visible?')
+        widget_class(name).present_in?(self, *args)
+      end
+
+      alias_method :widget?, :has_widget?
+
+      def visible?(name, *args)
+        widget_class(name).present_in?(self, *args)
+      end
+
+      def not_visible?(name, *args)
+        widget_class(name).not_present_in?(self, *args)
+      end
+
+      def widget(name, *args)
+        first, rest = [*name, *args]
+
+        widget_class(first).find_in(self, *rest)
+      end
+
+      def widgets(name, *args)
+        first, rest = [*name, *args]
+
+        widget_class(first).find_all_in(self, *rest)
+      end
+
+      private
+
+      attr_writer :widget_lookup_scope
+
+      def widget_class(name)
+        WidgetName.new(name).to_class(widget_lookup_scope)
+      end
+
+      def widget_lookup_scope
+        @widget_lookup_scope || self.class
+      end
+    end
+  end
+end

data/lib/capybara-ui/widgets/parts/struct.rb

@@ -0,0 +1,117 @@
+module CapybaraUI
+  module WidgetParts
+    module Struct
+      def self.included(target)
+        target.extend ClassMethods
+      end
+
+      module ClassMethods
+        def attribute(name, selector, &block)
+          child = widget(name, selector, &block)
+
+          class_eval <<-WIDGET
+            def #{name}
+              widget(:#{name}).value
+            end
+          WIDGET
+
+          child
+        end
+
+        def boolean(name, selector, &block)
+          child = widget(name, selector, &block)
+
+          class_eval <<-WIDGET
+            def #{name}?
+              widget(:#{name}).value
+            end
+          WIDGET
+
+          child.class_eval <<-VALUE
+            def value
+              CapybaraUI::Conversions::Boolean(text)
+            end
+          VALUE
+
+          child
+        end
+
+        def date(name, selector, &block)
+          child = attribute(name, selector, &block)
+
+          child.class_eval <<-VALUE
+            def value
+              Date.parse(text)
+            end
+          VALUE
+
+          child
+        end
+
+        def float(name, selector, &block)
+          child = attribute(name, selector, &block)
+
+          child.class_eval <<-VALUE
+            def value
+              Float(text)
+            end
+          VALUE
+
+          child
+        end
+
+        def integer(name, selector, &block)
+          child = attribute(name, selector, &block)
+
+          child.class_eval <<-VALUE
+            def value
+              Integer(text)
+            end
+          VALUE
+
+          child
+        end
+
+        def list(name, selector, options = {}, &block)
+          child = widget(name, selector, CapybaraUI::List) do
+            item options[:item_selector], options[:item_class] || ListItem
+          end
+
+          class_eval <<-WIDGET
+            def #{name}
+              widget(:#{name}).value
+            end
+          WIDGET
+
+          child.class_eval(&block) if block_given?
+
+          child
+        end
+
+        def string(name, *args, &block)
+          child = attribute(name, *args, &block)
+
+          child.class_eval <<-VALUE
+            def value
+              text
+            end
+          VALUE
+
+          child
+        end
+
+        def time(name, *args, &block)
+          child = attribute(name, *args, &block)
+
+          child.class_eval <<-VALUE
+            def value
+              Time.parse(text)
+            end
+          VALUE
+
+          child
+        end
+      end
+    end
+  end
+end

data/lib/capybara-ui/widgets/radio_button.rb

@@ -0,0 +1,62 @@
+module CapybaraUI
+  # A radio button.
+  class RadioButton < Field
+    widget :checked, -> {
+      case Capybara.current_driver
+      when :rack_test
+        ['[checked]']
+      else
+        ['input:checked']
+      end
+    }
+    widget :checked_label_by_value, -> (val) { [:xpath, ".//label[input[@type='radio' and @value='#{val}']]"] }
+    widget :checked_label_by_id, -> (id) { [:xpath, ".//label[@for='#{id}']"] }
+    widget :button_by_value, -> (val) { "[value='#{val}']" }
+
+    def self.root(selector)
+      super(["#{selector}"])
+    end
+
+    # @return [String] The text of the checked button's label.
+    def get
+      if visible?(:checked_label_by_value, value)
+        widget(:checked_label_by_value, value).text
+      elsif visible?(:checked_label_by_id, id)
+        widget(:checked_label_by_id, id).text
+      else
+        nil
+      end
+    end
+
+    # @return [String] The value of the checked button.
+    def value
+      visible?(:checked) ? widget(:checked).root.value : nil
+    end
+
+    # @return [String] The id of the checked button.
+    def id
+      visible?(:checked) ? widget(:checked).id : nil
+    end
+
+    # First attempts to choose the button by id or label text
+    # Then attempts to choose the button by value
+    def set(str)
+      root.choose(str)
+    rescue
+      begin
+        widget(:button_by_value, str).root.set(true)
+      rescue CapybaraUI::MissingWidget => e
+        raise InvalidRadioButton.new(e.message).
+          tap { |x| x.set_backtrace e.backtrace }
+      end
+    end
+
+    # @return the text of the checked button, or an empty string if
+    # no button is checked.
+    def_delegator :get, :to_s
+
+    def to_cell
+      get
+    end
+  end
+end