casecumber 1.0.2.1

data/lib/cucumber/step_argument.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  class StepArgument
+    attr_reader :val, :byte_offset
+
+    def initialize(val, byte_offset)
+      @val, @byte_offset = val, byte_offset
+    end
+  end
+end

data/lib/cucumber/step_definition_light.rb

@@ -0,0 +1,20 @@
+module Cucumber
+  # Only used for keeping track of available and invoked step definitions
+  # in a way that also works for other programming languages (i.e. cuke4duke)
+  # Used for reporting purposes only (usage formatter).
+  class StepDefinitionLight
+    attr_reader :regexp_source, :file_colon_line
+    
+    def initialize(regexp_source, file_colon_line)
+      @regexp_source, @file_colon_line = regexp_source, file_colon_line
+    end
+    
+    def eql?(o)
+      regexp_source == o.regexp_source && file_colon_line == o.file_colon_line
+    end
+    
+    def hash
+      regexp_source.hash + 31*file_colon_line.hash
+    end
+  end
+end

data/lib/cucumber/step_definitions.rb

@@ -0,0 +1,14 @@
+require 'json'
+module Cucumber
+  class StepDefinitions
+    def initialize(configuration = Configuration.default)
+      configuration = Configuration.parse(configuration)
+      @support_code = Runtime::SupportCode.new(nil, false)
+      @support_code.load_files_from_paths(configuration.autoload_code_paths)
+    end
+    
+    def to_json
+      @support_code.step_definitions.map{|stepdef| stepdef.to_hash}.to_json
+    end
+  end
+end

data/lib/cucumber/step_match.rb

@@ -0,0 +1,115 @@
+module Cucumber
+  class StepMatch #:nodoc:
+    attr_reader :step_definition, :step_arguments
+
+    # Creates a new StepMatch. The +name_to_report+ argument is what's reported, unless it's is,
+    # in which case +name_to_report+ is used instead.
+    # 
+    def initialize(step_definition, name_to_match, name_to_report, step_arguments)
+      raise "name_to_match can't be nil" if name_to_match.nil?
+      raise "step_arguments can't be nil (but it can be an empty array)" if step_arguments.nil?
+      @step_definition, @name_to_match, @name_to_report, @step_arguments = step_definition, name_to_match, name_to_report, step_arguments
+    end
+
+    def args
+      @step_arguments.map{|g| g.val}
+    end
+
+    def name
+      @name_to_report
+    end
+
+    def invoke(multiline_arg)
+      multiline_arg = Ast::DocString.new(multiline_arg) if String === multiline_arg
+      all_args = args
+      all_args << multiline_arg.to_step_definition_arg if multiline_arg
+      @step_definition.invoke(all_args)
+    end
+
+    # Formats the matched arguments of the associated Step. This method
+    # is usually called from visitors, which render output.
+    #
+    # The +format+ can either be a String or a Proc.
+    #
+    # If it is a String it should be a format string according to
+    # <tt>Kernel#sprinf</tt>, for example:
+    #
+    #   '<span class="param">%s</span></tt>'
+    #
+    # If it is a Proc, it should take one argument and return the formatted
+    # argument, for example:
+    #
+    #   lambda { |param| "[#{param}]" }
+    #
+    def format_args(format = lambda{|a| a}, &proc)
+      @name_to_report || replace_arguments(@name_to_match, @step_arguments, format, &proc)
+    end
+
+    def file_colon_line
+      @step_definition.file_colon_line
+    end
+
+    def backtrace_line
+      "#{file_colon_line}:in `#{@step_definition.regexp_source}'"
+    end
+
+    def text_length
+      @step_definition.regexp_source.unpack('U*').length
+    end
+
+    def replace_arguments(string, step_arguments, format, &proc)
+      s = string.dup
+      offset = past_offset = 0
+      step_arguments.each do |step_argument|
+        next if step_argument.byte_offset.nil? || step_argument.byte_offset < past_offset
+        
+        replacement = if block_given?
+          proc.call(step_argument.val)
+        elsif Proc === format
+          format.call(step_argument.val)
+        else
+          format % step_argument.val
+        end
+
+        s[step_argument.byte_offset + offset, step_argument.val.length] = replacement
+        offset += replacement.unpack('U*').length - step_argument.val.unpack('U*').length
+        past_offset = step_argument.byte_offset + step_argument.val.length
+      end
+      s
+    end
+
+    def inspect #:nodoc:
+      sprintf("#<%s:0x%x>", self.class, self.object_id)
+    end
+  end
+  
+  class NoStepMatch #:nodoc:
+    attr_reader :step_definition, :name
+
+    def initialize(step, name)
+      @step = step
+      @name = name
+    end
+    
+    def format_args(format)
+      @name
+    end
+
+    def file_colon_line
+      raise "No file:line for #{@step}" unless @step.file_colon_line
+      @step.file_colon_line
+    end
+
+    def backtrace_line
+      @step.backtrace_line
+    end
+
+    def text_length
+      @step.text_length
+    end
+
+    def step_arguments
+      []
+    end
+  end
+end

data/lib/cucumber/step_mother.rb

@@ -0,0 +1,10 @@
+require 'cucumber/runtime'
+
+module Cucumber
+  class StepMother < Runtime
+    def initialize(*args)
+      warn("StepMother has been deprecated and will be gently put to sleep at the next major release. Please use Runtime instead. #{caller[0]}")
+      super
+    end
+  end
+end

data/lib/cucumber/wire_support/configuration.rb

@@ -0,0 +1,31 @@
+require 'yaml'
+require 'erb'
+
+module Cucumber
+  module WireSupport
+    class Configuration
+      attr_reader :host, :port
+      
+      def initialize(wire_file)
+        params = YAML.load(ERB.new(File.read(wire_file)).result)
+        @host = params['host']
+        @port = params['port']
+        @timeouts = default_timeouts.merge(params['timeout'] || {})
+      end
+      
+      def timeout(message = nil)
+        return @timeouts[message.to_s] || 3
+      end
+      
+      private
+      
+      def default_timeouts
+        {
+          'invoke' => 120,
+          'begin_scenario' => 120,
+          'end_scenario' => 120
+        }
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/connection.rb

@@ -0,0 +1,55 @@
+require 'timeout'
+require 'cucumber/wire_support/wire_protocol'
+
+module Cucumber
+  module WireSupport
+    class Connection
+      class ConnectionError < StandardError; end
+        
+      include WireProtocol
+      
+      def initialize(config)
+        @config = config
+      end
+      
+      def call_remote(request_handler, message, params)
+        packet = WirePacket.new(message, params)
+
+        begin
+          send_data_to_socket(packet.to_json)
+          response = fetch_data_from_socket(@config.timeout(message))
+          response.handle_with(request_handler)
+        rescue Timeout::Error => e
+          backtrace = e.backtrace ; backtrace.shift # because Timeout puts some wierd stuff in there
+          raise Timeout::Error, "Timed out calling wire server with message '#{message}'", backtrace
+        end
+      end
+      
+      def exception(params)
+        WireException.new(params, @config.host, @config.port)
+      end
+
+      private
+      
+      def send_data_to_socket(data)
+        Timeout.timeout(@config.timeout) { socket.puts(data) }
+      end
+
+      def fetch_data_from_socket(timeout)
+        raw_response = 
+          if timeout == :never
+            socket.gets
+          else
+            Timeout.timeout(timeout) { socket.gets }
+          end
+        WirePacket.parse(raw_response)
+      end
+      
+      def socket
+        @socket ||= TCPSocket.new(@config.host, @config.port)
+      rescue Errno::ECONNREFUSED => exception
+        raise(ConnectionError, "Unable to contact the wire server at #{@config.host}:#{@config.port}. Is it up?")
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/request_handler.rb

@@ -0,0 +1,32 @@
+module Cucumber
+  module WireSupport
+    class RequestHandler
+      def initialize(connection)
+        @connection = connection
+        @message = underscore(self.class.name.split('::').last)
+      end
+
+      def execute(request_params = nil)
+        @connection.call_remote(self, @message, request_params)
+      end
+
+      def handle_fail(params)
+        raise @connection.exception(params)
+      end
+      
+      def handle_success(params)
+      end
+      
+      private
+      
+      # Props to Rails
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/wire_exception.rb

@@ -0,0 +1,32 @@
+module Cucumber
+  module WireSupport
+    # Proxy for an exception that occured at the remote end of the wire
+    class WireException < StandardError
+      module CanSetName
+        attr_writer :exception_name
+        def to_s
+          @exception_name
+        end
+      end
+      
+      def initialize(args, host, port)
+        super args['message']
+        if args['exception']
+          self.class.extend(CanSetName)
+          self.class.exception_name = "#{args['exception']} from #{host}:#{port}"
+        end
+        if args['backtrace']
+          @backtrace = if args['backtrace'].is_a?(String)
+              args['backtrace'].split("\n") # TODO: change cuke4nuke to pass an array instead of a big string
+            else
+              args['backtrace']
+            end
+        end
+      end
+      
+      def backtrace
+        @backtrace || super
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/wire_language.rb

@@ -0,0 +1,54 @@
+require 'socket'
+require 'json'
+require 'cucumber/wire_support/connection'
+require 'cucumber/wire_support/configuration'
+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 initialize(step_mother)
+        @connections = []
+      end
+      
+      def alias_adverbs(adverbs)
+      end
+
+      def load_code_file(wire_file)
+        config = Configuration.new(wire_file)
+        @connections << Connection.new(config)
+      end
+      
+      def snippet_text(code_keyword, step_name, multiline_arg_class)
+        snippets = @connections.map do |remote| 
+          remote.snippet_text(code_keyword, step_name, multiline_arg_class.to_s)
+        end
+        snippets.flatten.join("\n")
+      end
+      
+      def step_matches(step_name, formatted_step_name)
+        @connections.map{ |c| c.step_matches(step_name, formatted_step_name)}.flatten
+      end
+      
+      protected
+      
+      def begin_scenario(scenario)
+        @connections.each { |c| c.begin_scenario(scenario) }
+        @current_scenario = scenario
+      end
+      
+      def end_scenario
+        scenario = @current_scenario
+        @connections.each { |c| c.end_scenario(scenario) }
+        @current_scenario = nil
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/wire_packet.rb

@@ -0,0 +1,32 @@
+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 = nil)
+        @message, @params = message, params
+      end
+      
+      def to_json
+        packet = [@message]
+        packet << @params if @params
+        packet.to_json
+      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,44 @@
+require 'cucumber/step_argument'
+require 'cucumber/wire_support/wire_protocol/requests'
+
+module Cucumber
+  module WireSupport
+    module WireProtocol
+      def step_matches(name_to_match, name_to_report)
+        handler = Requests::StepMatches.new(self)
+        handler.execute(name_to_match, name_to_report)
+      end
+
+      def snippet_text(step_keyword, step_name, multiline_arg_class_name)
+        handler = Requests::SnippetText.new(self)
+        handler.execute(step_keyword, step_name, multiline_arg_class_name)
+      end
+      
+      def invoke(step_definition_id, args)
+        handler = Requests::Invoke.new(self)
+        handler.execute(step_definition_id, args)
+      end
+      
+      def diff_failed
+        handler = Requests::DiffFailed.new(self)
+        handler.execute
+      end
+      
+      def diff_ok
+        handler = Requests::DiffOk.new(self)
+        handler.execute
+      end
+      
+      def begin_scenario(scenario)
+        handler = Requests::BeginScenario.new(self)
+        handler.execute(scenario)
+      end
+
+      def end_scenario(scenario)
+        handler = Requests::EndScenario.new(self)
+        handler.execute(scenario)
+      end
+      
+    end
+  end
+end