capybara-ui 0.10.0 → 1.0.0

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

@@ -0,0 +1,28 @@
+module Capybara
+  module UI
+    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
+end

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

@@ -0,0 +1,202 @@
+module Capybara
+  module UI
+    # 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 < Capybara::UI::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 < Capybara::UI::List
+    #   end
+    #
+    # ==== Narrowing items
+    #
+    # You can define the root selector for your list items using the ::item macro:
+    #
+    #   class PortugueseColors < Capybara::UI::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 < Capybara::UI::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 (Capybara::UI::ListItem):
+        #
+        #   class Numbers < Capybara::UI::List
+        #     root 'ul'
+        #     item 'li'
+        #   end
+        #
+        # ==== Extending the list item class
+        #
+        # You can define the list item class for the current List:
+        #
+        #   class Number < Capybara::UI::Widget
+        #     # ...
+        #   end
+        #
+        #   class Numbers < Capybara::UI::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 < Capybara::UI::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
+end

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

@@ -0,0 +1,24 @@
+module Capybara
+  module UI
+    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
+end

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

@@ -0,0 +1,48 @@
+module Capybara
+  module UI
+    module WidgetParts
+      module Container
+        include Capybara::UI
+
+        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
+end

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

@@ -0,0 +1,119 @@
+module Capybara
+  module UI
+    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
+                Capybara::UI::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, Capybara::UI::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
+end

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

@@ -0,0 +1,64 @@
+module Capybara
+  module UI
+    # 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 Capybara::UI::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
+end