cucumber-salad 0.1.0 → 0.2.0

data/lib/cucumber/salad/conversions.rb

@@ -5,7 +5,7 @@ module Cucumber
         case val
         when 'yes', 'true', true
           true
-        when 'no', 'false', false, nil
+        when 'no', 'false', false, nil, ''
           false
         else
           raise ArgumentError, "can't convert #{val.inspect} to boolean"

data/lib/cucumber/salad/instance_conversions.rb

@@ -0,0 +1,21 @@
+module Cucumber
+  module Salad
+    module InstanceConversions
+      def self.included(base)
+        base.send :include, Cucumber::Salad::Conversions
+      end
+
+      def to_boolean
+        Boolean(self)
+      end
+
+      def to_a
+        List(self)
+      end
+
+      def to_time
+        Timeish(self)
+      end
+    end
+  end
+end

data/lib/cucumber/salad/node_text.rb

@@ -0,0 +1,11 @@
+module Cucumber
+  module Salad
+    class NodeText < String
+      include InstanceConversions
+
+      def initialize(node)
+        super node.text.strip
+      end
+    end
+  end
+end

data/lib/cucumber/salad/table/cell_text.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  module Salad
+    class Table
+      class CellText < String
+        include InstanceConversions
+      end
+    end
+  end
+end

data/lib/cucumber/salad/table/mapping.rb

@@ -0,0 +1,42 @@
+module Cucumber
+  module Salad
+    class Table
+      class Mapping
+        def initialize(settings = {})
+          self.key               = settings[:key]
+          self.value_transformer = transformer(settings[:value_transformer], :pass)
+          self.key_transformer   = transformer(settings[:key_transformer], :keyword)
+        end
+
+        def set(instance, row, key, value)
+          row[transform_key(instance, key)] = transform_value(instance, value)
+        end
+
+        private
+
+        attr_accessor :key, :value_transformer, :key_transformer
+
+        def transform_key(_, k)
+          key || key_transformer.(k)
+        end
+
+        def transform_value(instance, value)
+          instance.instance_exec(value, &value_transformer)
+        end
+
+        def transformer(set, fallback)
+          case set
+          when Symbol
+            Transformations.send(set)
+          when Proc
+            set
+          when nil
+            Transformations.send(fallback)
+          else
+            raise ArgumentError, "can't convert #{set.inspect} to transformer"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/salad/table/transformations.rb

@@ -0,0 +1,15 @@
+module Cucumber
+  module Salad
+    class Table
+      module Transformations
+        def self.keyword
+          ->(val) { val.squeeze(' ').strip.gsub(' ', '_').sub(/\?$/, '').to_sym }
+        end
+
+        def self.pass
+          ->(val) { val }
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/salad/table/void_mapping.rb

@@ -0,0 +1,10 @@
+module Cucumber
+  module Salad
+    class Table
+      class VoidMapping
+        def set(*)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/salad/table.rb

@@ -7,39 +7,70 @@ module Cucumber
       include Conversions
 
       class << self
-        def header_mappings
-          @header_mappings ||=
-           with_parent_mappings(:header) { |h, k|
-             h[k] = k.squeeze(' ').strip.gsub(' ', '_').to_sym
-           }
+        def Array(table)
+          new(table).to_a
+        end
+
+        def Hash(table)
+          new(table).to_h
         end
 
         def map(name, options = {}, &block)
-          header_mappings[name.to_s] = options[:to].to_sym if options[:to]
-          value_mappings[name.to_s]  = block if block_given?
+          case name
+          when :*
+            set_default_mapping options, &block
+          else
+            set_mapping name, options, &block
+          end
         end
 
-        def value_mappings
-          @value_mappings ||=
-           with_parent_mappings(:value) { |h, k|
-             h[k] = ->(value) { value }
-           }
+        def mappings
+          @mappings ||= Hash.
+           new { |h, k| h[k] = Mapping.new }.
+           merge(with_parent_mappings)
+        end
+
+        def skip(name)
+          case name
+          when :*
+            set_default_mapping VoidMapping
+          else
+            raise ArgumentError, "can't convert #{name.inspect} to name"
+          end
         end
 
         private
 
-        def with_parent_mappings(name, &init)
-          m = "#{name}_mappings"
+        def set_default_mapping(options, &block)
+          case options
+          when Hash
+            @mappings = Hash.
+             new { |h, k|
+              h[k] = Mapping.new(key_transformer:   options[:to],
+                                 value_transformer: block) }.
+             merge(mappings)
+          when Class
+            @mappings = Hash.new { |h, k| h[k] = options.new }.merge(mappings)
+          else
+            raise ArgumentError, "can't convert #{options.inspect} to mapping"
+          end
+        end
+
+        def set_mapping(name, options, &block)
+          mappings[name] = Mapping.
+           new(key: options[:to], value_transformer: block)
+        end
 
-          if superclass.respond_to?(m)
-            superclass.send(m).dup
+        def with_parent_mappings
+          if superclass.respond_to?(:mappings)
+            superclass.send(:mappings).dup
           else
-            Hash.new(&init)
+            {}
           end
         end
       end
 
-      def_delegators 'self.class', :header_mappings, :value_mappings
+      def_delegators 'self.class', :mappings
 
       def initialize(table)
         self.table = table
@@ -53,20 +84,25 @@ module Cucumber
         @rows ||= table.hashes.map { |h| new_row(h) }
       end
 
+      def single_row
+        @single_row ||= new_row(table.rows_hash)
+      end
+
+      alias_method :to_a, :rows
+      alias_method :to_h, :single_row
+
       private
 
       attr_accessor :table
 
-      def key_for(header)
-        header_mappings[header]
-      end
-
       def new_row(hash)
-        hash.each_with_object({}) { |(k, v), h| h[key_for(k)] = value_for(k, v) }
+        hash.each_with_object({}) { |(k, v), h|
+          mapping_for(k).set(self, h, k, CellText.new(v))
+        }
       end
 
-      def value_for(key, value)
-        instance_exec(value, &value_mappings[key])
+      def mapping_for(header)
+        mappings[header]
       end
     end
   end

data/lib/cucumber/salad/version.rb

@@ -1,5 +1,5 @@
 module Cucumber
   module Salad
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/cucumber/salad/widgets/action.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  module Salad
+    module Widgets
+      class Action < Atom
+        def_delegators :root, :click
+      end
+    end
+  end
+end

data/lib/cucumber/salad/widgets/{text.rb → atom.rb}

@@ -1,7 +1,7 @@
 module Cucumber
   module Salad
     module Widgets
-      class Text < Widget
+      class Atom < Widget
         def to_a
           [to_s]
         end
@@ -11,7 +11,7 @@ module Cucumber
         end
 
         def to_s
-          root.text.strip
+          node_text(root)
         end
       end
     end

data/lib/cucumber/salad/widgets/auto_table.rb

@@ -0,0 +1,66 @@
+module Cucumber
+  module Salad
+    module Widgets
+      class AutoTable < BaseTable
+        protected
+
+        def ensure_table_loaded
+          root.find(data_row_selector)
+        rescue Capybara::Ambiguous
+        end
+
+        private
+
+        def data_cell_selector
+          'td'
+        end
+
+        def data_row(node)
+          Row.new(root: node, cell_selector: data_cell_selector)
+        end
+
+        def data_row_selector
+          'tbody tr'
+        end
+
+        def data_rows
+          @data_rows ||= root.all(data_row_selector).map { |n| data_row(n) }
+        end
+
+        def header_selector
+          'thead th'
+        end
+
+        def headers
+          @headers ||= root.all(header_selector).map { |n| node_text(n).downcase }
+        end
+
+        def values
+          @values ||= data_rows.map(&:values)
+        end
+
+        class Row < Widget
+          def initialize(settings)
+            s = settings.dup
+
+            self.cell_selector = s.delete(:cell_selector)
+
+            super s
+          end
+
+          def values
+            root.all(cell_selector).map { |n| node_text(n) }
+          end
+
+          private
+
+          attr_accessor :cell_selector
+
+          def node_text(node)
+            NodeText.new(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/salad/widgets/base_table.rb

@@ -0,0 +1,13 @@
+module Cucumber
+  module Salad
+    module Widgets
+      class BaseTable < Widget
+        def to_table
+          ensure_table_loaded
+
+          headers.any? ? [headers, *values] : values
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/salad/widgets/form.rb

@@ -2,9 +2,15 @@ module Cucumber
   module Salad
     module Widgets
       class Form < Widget
+        def self.default_locator(type = nil, &block)
+          alias_method :name_to_locator, type if type
+
+          define_method :name_to_locator, &block if block
+        end
+
         def self.check_box(name, label = nil)
           define_method "#{name}=" do |val|
-            l = label || name_to_label(name)
+            l = label || name_to_locator(name)
 
             if val
               root.check l
@@ -19,7 +25,7 @@ module Cucumber
           label, = args
 
           define_method "#{name}=" do |val|
-            l = label || name_to_label(name)
+            l = label || name_to_locator(name)
             w = opts.fetch(:writer) { ->(v) { v } }
 
             root.select w.(val).to_s, from: l
@@ -32,14 +38,19 @@ module Cucumber
 
         def self.text(name, label = nil)
           define_method "#{name}=" do |val|
-            l = label || name_to_label(name)
+            l = label || name_to_locator(name)
 
             root.fill_in l, with: val.to_s
           end
         end
 
-        def initialize(*super_args)
-          super(*super_args)
+        def initialize(settings = {})
+          s    = settings.dup
+          data = s.delete(:data) || {}
+
+          super s
+
+          fill_all data
 
           if block_given?
             yield self
@@ -57,16 +68,20 @@ module Cucumber
         end
 
         def submit
-          root.find('[name = "commit"]').click
+          root.find('[type = "submit"]').click
 
           self
         end
 
         private
 
-        def name_to_label(name)
+        def label(name)
           name.to_s.humanize
         end
+
+        def name_to_locator(name)
+          label(name)
+        end
       end
     end
   end

data/lib/cucumber/salad/widgets/list.rb

@@ -2,13 +2,11 @@ module Cucumber
   module Salad
     module Widgets
       class List < Widget
-        DEFAULT_TYPE = Text
-
-        extend Forwardable
+        DEFAULT_TYPE = Atom
 
         include Enumerable
 
-        def_delegators :items, :size, :include?, :each, :empty?
+        def_delegators :items, :size, :include?, :each, :empty?, :first
 
         def self.item(selector, type = DEFAULT_TYPE, &item_for)
           define_method :item_selector do
@@ -19,7 +17,7 @@ module Cucumber
             define_method :item_for, &item_for
           else
             define_method :item_factory do
-              lookup(type)
+              type
             end
           end
         end

data/lib/cucumber/salad/widgets/table.rb

@@ -1,79 +1,68 @@
 module Cucumber
   module Salad
     module Widgets
-      class Table < Widget
-        def self.row_class
-          Row
-        end
-
-        def to_table
-          [headers, *rows.map { |r| Array(r) }]
-        end
+      class Table < BaseTable
+        class ColumnDefinition
+          attr_reader :header
+
+          def initialize(selector, header, transform)
+            self.selector  = selector
+            self.header    = header
+            self.transform = transform
+          end
 
-        private
+          def ensure_loaded(container)
+            container.find(selector)
+          rescue Capybara::Ambiguous
+          end
 
-        def header_for(node)
-          node.text.strip.downcase
-        end
+          def values(container)
+            container.all(selector).map { |n| transform.(node_text(n)).to_s }
+          end
 
-        def header_selector
-          'thead th'
-        end
+          private
 
-        def headers
-          items(header_selector, :header_for)
-        end
+          attr_accessor :selector
+          attr_writer :header, :transform
 
-        def items(selector, builder)
-          root.all(selector).map { |e| send(builder, e) }
-        end
+          def node_text(node)
+            NodeText.new(node)
+          end
 
-        def row_factory
-          self.class.row_class
+          def transform
+            @transform ||= ->(v) { v }
+          end
         end
 
-        def row_for(node)
-          row_factory.new(root: node)
+        class << self
+          attr_accessor :column_selector, :header_selector
         end
 
-        def row_selector
-          'tbody tr'
+        def self.column(selector, header = nil, &transform)
+          column_definitions << ColumnDefinition.new(selector, header, transform)
         end
 
-        def rows
-          items(row_selector, :row_for)
+        def self.column_definitions
+          @column_definitions ||= []
         end
 
-        class Row < Widget
-          def self.cell(name, selector, type = Text, &block)
-            widget name, selector, type, &block
+        protected
 
-            cells << name
-          end
-
-          def self.cells
-            @cells ||= []
-          end
-
-          def to_a
-            declared_row || generated_row
-          end
-
-          protected
+        def ensure_table_loaded
+          column_definitions.first.ensure_loaded(self)
+        end
 
-          def cell_selector
-            'td'
-          end
+        private
 
-          def declared_row
-            cells = self.class.cells
+        def_delegators 'self.class', :column_selector, :column_definitions,
+                                     :header_selector
 
-            cells.map { |c| send(c).to_s } if cells.present?
-          end
+        def headers
+          @headers ||= column_definitions.map(&:header)
+        end
 
-          def generated_row
-            root.all(cell_selector).map { |c| c.text.strip }
-          end
+        def values
+          @values ||= column_definitions.map { |d| d.values(root) }.transpose
         end
       end
     end

data/lib/cucumber/salad/widgets/widget.rb

@@ -2,8 +2,20 @@ module Cucumber
   module Salad
     module Widgets
       class Widget
+        extend Forwardable
+
         include Salad::Conversions
 
+        def self.action(name, selector, options = {})
+          wname = "#{name}_action"
+
+          widget wname, selector, type: options[:type] || Action
+
+          define_method name do
+            send(wname).click
+          end
+        end
+
         def self.root(selector)
           define_method :default_root_selector do
             selector
@@ -12,14 +24,13 @@ module Cucumber
           private :default_root_selector
         end
 
-        def self.widget(name, selector, type = Text, &block)
-          body = if block_given?
-                   ->{ block.(find(selector)) }
-                 else
-                   ->{ lookup(type).new(root: root.find(selector)) }
-                 end
+        def self.widget(name, selector, options = {}, &block)
+          type = options.fetch(:type, Atom)
+          t    = block_given? ? Class.new(type, &block) : type
 
-          define_method name, &body
+          define_method name do
+            t.new(root: root.find(selector))
+          end
         end
 
         def initialize(settings = {})
@@ -33,6 +44,12 @@ module Cucumber
            Nokogiri::XML(xml, &:noblanks).to_xhtml
         end
 
+        protected
+
+        def node_text(node)
+          NodeText.new(node)
+        end
+
         private
 
         attr_writer :root_selector
@@ -42,14 +59,6 @@ module Cucumber
                 "#{self.class.name}: default root selector undefined"
         end
 
-        def lookup(type)
-          if Class === type
-            type
-          else
-            self.class.const_get(type.to_s.classify)
-          end
-        end
-
         def page
           Capybara.current_session
         end

data/lib/cucumber/salad/widgets.rb

@@ -1,3 +1,6 @@
 require 'cucumber/salad/widgets/widget'
-require 'cucumber/salad/widgets/text'
+require 'cucumber/salad/widgets/atom'
 require 'cucumber/salad/widgets/list'
+require 'cucumber/salad/widgets/base_table'
+require 'cucumber/salad/widgets/auto_table'
+require 'cucumber/salad/widgets/table'

data/lib/cucumber/salad.rb

@@ -1,5 +1,11 @@
 require 'chronic'
 
 require 'cucumber/salad/conversions'
+require 'cucumber/salad/instance_conversions'
+require 'cucumber/salad/node_text'
 require 'cucumber/salad/widgets'
 require 'cucumber/salad/table'
+require 'cucumber/salad/table/mapping'
+require 'cucumber/salad/table/void_mapping'
+require 'cucumber/salad/table/transformations'
+require 'cucumber/salad/table/cell_text'

metadata

@@ -2,14 +2,14 @@
 name: cucumber-salad
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - David Leal
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-20 00:00:00.000000000 Z
+date: 2013-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,6 +43,22 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
     none: false
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    none: false
+  name: capybara
+  type: :runtime
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    none: false
 - !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -68,13 +84,22 @@ extra_rdoc_files: []
 files:
 - lib/cucumber/salad.rb
 - lib/cucumber/salad/conversions.rb
+- lib/cucumber/salad/instance_conversions.rb
+- lib/cucumber/salad/node_text.rb
 - lib/cucumber/salad/table.rb
+- lib/cucumber/salad/table/cell_text.rb
+- lib/cucumber/salad/table/mapping.rb
+- lib/cucumber/salad/table/transformations.rb
+- lib/cucumber/salad/table/void_mapping.rb
 - lib/cucumber/salad/version.rb
 - lib/cucumber/salad/widgets.rb
+- lib/cucumber/salad/widgets/action.rb
+- lib/cucumber/salad/widgets/atom.rb
+- lib/cucumber/salad/widgets/auto_table.rb
+- lib/cucumber/salad/widgets/base_table.rb
 - lib/cucumber/salad/widgets/form.rb
 - lib/cucumber/salad/widgets/list.rb
 - lib/cucumber/salad/widgets/table.rb
-- lib/cucumber/salad/widgets/text.rb
 - lib/cucumber/salad/widgets/widget.rb
 homepage: https://github.com/mojotech/cucumber-salad
 licenses: []