kbaum-cucumber 0.4.5.pre

data/lib/cucumber/webrat/element_locator.rb

@@ -0,0 +1,93 @@
+warning = "\nWARNING: #{caller.detect{|l| l =~ /features/}}: cucumber/webrat/element_locator.rb is deprecated and will be removed in Cucumber 0.5.0.\nUse cucumber/web/tableish instead.\n"
+at_exit do
+  warn warning
+end
+require 'webrat'
+
+module Webrat
+  class Element
+    # Returns an Array of Array of String where each String is a
+    # "cell" in the table-like structure represented by this Element.
+    #
+    # Supported elements are table, dl, ol and ul. Different conversion
+    # strategies are used depending on the kind of element:
+    #
+    # * table    : Each tr becomes a row. The innerHTML of each td or th inside becomes a cell. The number 
+    #              of columns is determined by the number of cells in the first row.
+    # * dl       : Each dt becomes a row with 2 cells. The innerHTML of the dt itself and the next dd become cells.
+    # * ul or ol : Each li becomes a row with one cell, the innerHTML of the li.
+    #
+    def to_table
+      case element.name
+      when 'table'
+        table_from_table
+      when 'dl'
+        table_from_dl
+      when /ul|ol/
+        table_from_list
+      else
+        raise "#to_table not supported for #{element.name} elements"
+      end
+    end
+    
+    def table_from_table #:nodoc:
+      col_count = nil
+      element.css('tr').map do |row|
+        cols = row.css('th,td')
+        col_count ||= cols.length
+        cols[0...col_count].map do |col|
+          col.inner_html
+        end
+      end
+    end
+
+    def table_from_dl #:nodoc:
+      element.css('dt').map do |dt|
+        next_node = dt.next_sibling
+        while next_node.name != 'dd'
+          next_node = next_node.next_sibling
+        end
+        [dt.inner_html, next_node.inner_html]
+      end
+    end
+
+    def table_from_list #:nodoc:
+      element.css('li').map do |li|
+        [li.inner_html]
+      end
+    end
+
+    alias to_a to_table # Backwards compatibility with Cucumber
+  end
+  
+  module Locators
+    class ElementLocator < Locator #:nodoc:
+      def locate
+        Element.load(@session, table_element)
+      end
+
+      def table_element
+        @dom.css(@value)[0]
+      end
+
+      def error_message
+        "Could not find anything matching '#{@value}'"
+      end
+    end
+
+    # Returns a Webrat DOM element located by +css_selector+.
+    def element_at(css_selector)
+      ElementLocator.new(@session, dom, css_selector).locate!
+    end
+    
+    alias table_at element_at # Backwards compatibility with Cucumber
+  end
+  
+  module Methods #:nodoc:
+    delegate_to_session :element_at, :table_at
+  end
+  
+  class Session #:nodoc:
+    def_delegators :current_scope, :element_at, :table_at
+  end
+end

data/lib/cucumber/webrat/table_locator.rb

@@ -0,0 +1 @@
+require 'cucumber/webrat/element_locator'

data/lib/cucumber/wire_support/connection.rb

@@ -0,0 +1,42 @@
+require 'timeout'
+require 'cucumber/wire_support/wire_protocol'
+
+module Cucumber
+  module WireSupport
+    class Connection
+      include WireProtocol
+      
+      def initialize(config)
+        @host, @port = config['host'], config['port']
+      end
+      
+      def call_remote(response_handler, message, params)
+        timeout = 3
+        packet = WirePacket.new(message, params)
+
+        begin
+          send_data_to_socket(packet.to_json, timeout)
+          response = fetch_data_from_socket(timeout)
+          response.handle_with(response_handler)
+        rescue Timeout::Error
+          raise "Timed out calling server with message #{message}"
+        end
+      end
+
+      private
+      
+      def send_data_to_socket(data, timeout)
+        Timeout.timeout(timeout) { socket.puts(data) }
+      end
+
+      def fetch_data_from_socket(timeout)
+        raw_response = Timeout.timeout(timeout) { socket.gets }
+        WirePacket.parse(raw_response)
+      end
+
+      def socket
+        @socket ||= TCPSocket.new(@host, @port)
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/request_handler.rb

@@ -0,0 +1,19 @@
+module Cucumber
+  module WireSupport
+    class RequestHandler
+      def initialize(connection, message, &block)
+        @connection = connection
+        @message = message
+        instance_eval(&block) if block
+      end
+
+      def execute(request_params)
+        @connection.call_remote(self, @message, request_params)
+      end
+
+      def handle_fail(params)
+        raise WireException.new(params)
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/wire_exception.rb

@@ -0,0 +1,10 @@
+module Cucumber
+  module WireSupport
+    # Proxy for an exception that occured at the remote end of the wire
+    class WireException < StandardError
+      def initialize(args)
+        super args['message']
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/wire_language.rb

@@ -0,0 +1,52 @@
+require 'socket'
+require 'json'
+require 'cucumber/wire_support/connection'
+require 'cucumber/wire_support/wire_packet'
+require 'cucumber/wire_support/wire_exception'
+require 'cucumber/wire_support/wire_step_definition'
+
+module Cucumber
+  module WireSupport
+    
+    # The wire-protocol (lanugage independent) implementation of the programming language API.
+    class WireLanguage
+      include LanguageSupport::LanguageMethods
+      
+      def load_code_file(wire_file)
+        config = YAML.load_file(wire_file)
+        @connections << Connection.new(config)
+      end
+      
+      def step_matches(step_name, formatted_step_name)
+        @connections.map{ |remote| remote.step_matches(step_name, formatted_step_name)}.flatten
+      end
+      
+      def initialize(step_mother)
+        @connections = []
+      end
+      
+      def alias_adverbs(adverbs)
+      end
+
+      def snippet_text(step_keyword, step_name, multiline_arg_class)
+        "Snippets are not implemented for the wire yet"
+      end
+      
+      protected
+      
+      def begin_scenario(scenario)
+        @connections.each { |remote| remote.begin_scenario(scenario) }
+      end
+      
+      def end_scenario
+        @connections.each { |remote| remote.end_scenario }
+      end
+      
+      private
+      
+      def step_definitions
+        @step_definitions ||= {}
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/wire_packet.rb

@@ -0,0 +1,34 @@
+module Cucumber
+  module WireSupport
+    # Represents the packet of data sent over the wire as JSON data, containing
+    # a message and a hash of arguments
+    class WirePacket
+      class << self
+        def parse(raw)
+          attributes = JSON.parse(raw.strip)
+          message = attributes[0]
+          params  = attributes[1]
+          new(message, params)
+        end
+      end
+      
+      attr_reader :message, :params
+      
+      def initialize(message, params)
+        @message, @params = message, params
+      end
+      
+      def to_json
+        [@message, @params].to_json
+      end
+      
+      def raise_if_bad
+        raise WireException.new(@params) if @message == 'fail' || @message == 'step_failed'
+      end
+      
+      def handle_with(handler)
+        handler.send("handle_#{@message}", @params)
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/wire_protocol.rb

@@ -0,0 +1,64 @@
+require 'cucumber/step_argument'
+require 'cucumber/wire_support/request_handler'
+
+module Cucumber
+  module WireSupport
+    module WireProtocol
+      def step_matches(name_to_match, name_to_report)
+        @name_to_match, @name_to_report = name_to_match, name_to_report
+        make_request(:step_matches, :name_to_match => name_to_match) do
+          def handle_step_matches(params)
+            params.map do |raw_step_match|
+              step_definition = WireStepDefinition.new(raw_step_match['id'], @connection)
+              step_args = raw_step_match['args'].map do |raw_arg|
+                StepArgument.new(raw_arg['val'], raw_arg['pos'])
+              end
+              @connection.step_match(step_definition, step_args) # convoluted!
+            end
+          end
+        end
+      end
+
+      def step_match(step_definition, step_args)
+        StepMatch.new(step_definition, @name_to_match, @name_to_report, step_args)
+      end
+      
+      def invoke(step_definition_id, args)
+        request_params = { :id => step_definition_id, :args => args }
+        
+        make_request(:invoke, request_params) do
+          def handle_success(params)
+          end
+        
+          def handle_step_failed(params)
+            handle_fail(params)
+          end
+        end
+      end
+      
+      def begin_scenario(scenario)
+        make_request(:begin_scenario) do
+          def handle_success(params)
+          end
+        end
+      end
+
+      def end_scenario
+        make_request(:end_scenario) do
+          def handle_success(params)
+          end
+        end
+      end
+      
+      private
+      
+      def handler(request_message, &block)
+        RequestHandler.new(self, request_message, &block)
+      end
+      
+      def make_request(request_message, params = nil, &block)
+        handler(request_message, &block).execute(params)
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/wire_step_definition.rb

@@ -0,0 +1,21 @@
+module Cucumber
+  module WireSupport
+    class WireStepDefinition
+      def initialize(id, connection)
+        @id, @connection = id, connection
+      end
+      
+      def invoke(args)
+        @connection.invoke(@id, args)
+      end
+
+      def regexp_source
+        "/FIXME/"
+      end
+
+      def file_colon_line
+        "FIXME:0"
+      end
+    end
+  end
+end

data/spec/cucumber/ast/background_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/ast'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  module Ast
+    describe Background do
+
+      before do
+        extend(RbSupport::RbDsl)
+        @step_mother = StepMother.new
+        @step_mother.load_natural_language('en')
+        @rb = @step_mother.load_programming_language('rb')
+
+        $x = $y = nil
+        Before do
+          $x = 2
+        end
+        Given /y is (\d+)/ do |n|
+          $y = $x * n.to_i
+        end
+
+        @visitor = TreeWalker.new(@step_mother)
+
+        @feature = mock('feature', :visit? => true).as_null_object
+      end
+
+      it "should execute Before blocks before background steps" do
+        background = Background.new(
+          comment=Comment.new(''),
+          line=2,
+          keyword="", 
+          name="",
+          steps=[
+            Step.new(7, "Given", "y is 5")
+          ])
+
+        scenario = Scenario.new(
+          background,
+          comment=Comment.new(""), 
+          tags=Tags.new(98,[]),
+          line=99,
+          keyword="", 
+          name="", 
+          steps=[]
+        )
+        background.feature = @feature
+        @visitor.visit_background(background)
+        $x.should == 2
+        $y.should == 10
+      end
+    end
+  end
+end

data/spec/cucumber/ast/feature_element_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/step_mother'
+require 'cucumber/ast'
+
+module Cucumber
+  module Ast
+    describe FeatureElement do
+      include FeatureElement
+
+      describe "with multiline names" do
+        it "should select the longest line as the text length" do
+          @keyword = "key"  
+          @name = "short\nvery longer\ntiny"
+          text_length.should == 11 + Ast::Step::INDENT - 1
+        end
+      
+        it "should add keyword to first lines length" do
+          @keyword = "key"  
+          @name = "short\nvery longer\ntiny"
+        
+          first_line_length.should == (@keyword.jlength) + (first_line_name_length = 5)
+        end
+      end
+    
+      describe "with empty name" do
+        it "should only return the length of the keyword" do
+          @name = ""
+          @keyword = "key"
+        
+          text_length.should == 3
+        end
+      end
+
+      it "should support checking if its name matches a list of regexps" do
+        @name = 'test'
+        matches_scenario_names?([/es/]).should be_true
+      end
+    end
+  end
+end
+

data/spec/cucumber/ast/feature_factory.rb

@@ -0,0 +1,62 @@
+require 'cucumber/ast'
+require 'cucumber/step_mother'
+
+module Cucumber
+  module Ast
+    module FeatureFactory
+      class MyWorld
+        def flunk
+          raise "I flunked"
+        end
+      end
+      
+      def create_feature(dsl)
+        dsl.Given /^a (.*) step with an inline arg:$/ do |what, table|
+        end
+        dsl.Given /^a (.*) step$/ do |what|
+          flunk if what == 'failing'
+        end
+        dsl.World do
+          MyWorld.new
+        end
+
+        table = Ast::Table.new([
+          %w{1 22 333},
+          %w{4444 55555 666666}
+        ])
+        py_string = Ast::PyString.new(21, 22, %{
+           I like
+          Cucumber sandwich
+        }, 10)
+        
+        background = Ast::Background.new(Ast::Comment.new(""), 2, "Background:", "",
+          [
+            Step.new(3, "Given", "a passing step")
+          ]
+        )
+        
+        f = Ast::Feature.new(
+          background,
+          Ast::Comment.new("# My feature comment\n"),
+          Ast::Tags.new(6, ['one', 'two']),
+          "Pretty printing",
+          [Ast::Scenario.new(
+            background,
+            Ast::Comment.new("    # My scenario comment  \n# On two lines \n"),
+            Ast::Tags.new(8, ['three', 'four']),
+            9,
+            "Scenario:", "A Scenario",
+            [
+              Step.new(10, "Given", "a passing step with an inline arg:", table),
+              Step.new(11, "Given", "a happy step with an inline arg:", py_string),
+              Step.new(12, "Given", "a failing step")
+            ]
+          )]
+        )
+        f.file = 'features/pretty_printing.feature'
+        f.features = Features.new
+        f
+      end
+    end
+  end
+end