cucumber 2.0.0.rc.4 → 4.0.0.rc.2

data/lib/cucumber/rb_support/rb_world.rb

@@ -1,142 +0,0 @@
-require 'gherkin/formatter/ansi_escapes'
-
-module Cucumber
-  module RbSupport
-    # Defines the basic DSL methods availlable in all Cucumber step definitions.
-    #
-    # You can, and probably should, extend this DSL with your own methods that
-    # make sense in your domain. For more on that, see {Cucumber::RbSupport::RbDsl#World}
-    module RbWorld
-
-      # @private
-      AnsiEscapes = Gherkin::Formatter::AnsiEscapes
-
-      # Call a Transform with a string from another Transform definition
-      def Transform(arg)
-        rb = @__cucumber_runtime.load_programming_language('rb')
-        rb.execute_transforms([arg]).first
-      end
-
-      # @private
-      attr_writer :__cucumber_runtime, :__natural_language
-
-      # Run a single Gherkin step
-      # @example Call another step
-      #   step "I am logged in"
-      # @example Call a step with quotes in the name
-      #   step %{the user "Dave" is logged in}
-      # @example Passing a table
-      #   step "the following users exist:", table(%{
-      #     | name  | email           |
-      #     | Matt  | matt@matt.com   |
-      #     | Aslak | aslak@aslak.com |
-      #   })
-      # @example Passing a multiline string
-      #   step "the email should contain:", "Dear sir,\nYou've won a prize!\n"
-      # @param [String] name The name of the step
-      # @param [String,Cucumber::Ast::DocString,Cucumber::Ast::Table] multiline_argument
-      def step(name, raw_multiline_arg=nil)
-        location = Core::Ast::Location.of_caller
-        @__cucumber_runtime.invoke(name, MultilineArgument.from(raw_multiline_arg, location))
-      end
-
-      # Run a snippet of Gherkin
-      # @example
-      #   steps %{
-      #     Given the user "Susan" exists
-      #     And I am logged in as "Susan"
-      #   }
-      # @param [String] steps_text The Gherkin snippet to run
-      def steps(steps_text)
-        @__cucumber_runtime.invoke_steps(steps_text, @__natural_language, caller[0])
-      end
-
-      # Parse Gherkin into a {Cucumber::Ast::Table} object.
-      #
-      # Useful in conjunction with the #step method.
-      # @example Create a table
-      #   users = table(%{
-      #     | name  | email           |
-      #     | Matt  | matt@matt.com   |
-      #     | Aslak | aslak@aslak.com |
-      #   })
-      # @param [String] text_or_table The Gherkin string that represents the table
-      def table(text_or_table, file=nil, line_offset=0)
-        @__cucumber_runtime.table(text_or_table, file, line_offset)
-      end
-
-      # Create an {Cucumber::Ast::DocString} object
-      #
-      # Useful in conjunction with the #step method, when
-      # want to specify a content type.
-      # @example Create a multiline string
-      #   code = multiline_string(%{
-      #     puts "this is ruby code"
-      #   %}, 'ruby')
-      def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-        # TODO: rename this method to multiline_string
-        @__cucumber_runtime.doc_string(string_without_triple_quotes, content_type, line_offset)
-      end
-
-      # @deprecated Use {#puts} instead.
-      def announce(*messages)
-        STDERR.puts AnsiEscapes.failed + "WARNING: #announce is deprecated. Use #puts instead:" + caller[0] + AnsiEscapes.reset
-        puts(*messages)
-      end
-
-      # Print a message to the output.
-      #
-      # @note Cucumber might surprise you with the behaviour of this method. Instead
-      #   of sending the output directly to STDOUT, Cucumber will intercept and cache
-      #   the message until the current step has finished, and then display it.
-      #   
-      #   If you'd prefer to see the message immediately, call {Kernel.puts} instead.
-      def puts(*messages)
-        @__cucumber_runtime.puts(*messages)
-      end
-
-      # Pause the tests and ask the operator for input
-      def ask(question, timeout_seconds=60)
-        @__cucumber_runtime.ask(question, timeout_seconds)
-      end
-
-      # Embed an image in the output
-      def embed(file, mime_type, label='Screenshot')
-        @__cucumber_runtime.embed(file, mime_type, label)
-      end
-
-      # Mark the matched step as pending.
-      def pending(message = "TODO")
-        if block_given?
-          begin
-            yield
-          rescue Exception
-            raise Pending, message
-          end
-          raise Pending, "Expected pending '#{message}' to fail. No Error was raised. No longer pending?"
-        else
-          raise Pending, message
-        end
-      end
-
-      # Skips this step and the remaining steps in the scenario
-      def skip_this_scenario(message = "Scenario skipped")
-        raise Core::Test::Result::Skipped, message
-      end
-
-      # Prints the list of modules that are included in the World
-      def inspect
-        modules = [self.class]
-        (class << self; self; end).instance_eval do
-          modules += included_modules
-        end
-        sprintf("#<%s:0x%x>", modules.join('+'), self.object_id)
-      end
-
-      # see {#inspect}
-      def to_s
-        inspect
-      end
-    end
-  end
-end

data/lib/cucumber/rb_support/regexp_argument_matcher.rb

@@ -1,21 +0,0 @@
-require 'gherkin/formatter/argument'
-
-module Cucumber
-  module RbSupport
-    class RegexpArgumentMatcher
-      def self.arguments_from(regexp, step_name)
-        match = regexp.match(step_name)
-        if match
-          n = 0
-          match.captures.map do |val|
-            n += 1
-            offset = match.offset(n)[0]
-            Gherkin::Formatter::Argument.new(offset, val)
-          end
-        else
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/rb_support/snippet.rb

@@ -1,149 +0,0 @@
-module Cucumber
-  module RbSupport
-    module Snippet
-
-      ARGUMENT_PATTERNS = ['"(.*?)"', '(\d+)']
-
-      class BaseSnippet
-
-        def initialize(code_keyword, pattern, multiline_argument)
-          @number_of_arguments = 0
-          @code_keyword = code_keyword
-          @pattern = replace_and_count_capturing_groups(pattern)
-          @multiline_argument = MultilineArgumentSnippet.new(multiline_argument)
-        end
-
-        def to_s
-          "#{step} #{do_block}"
-        end
-
-        def step
-          "#{code_keyword}#{typed_pattern}"
-        end
-
-        def self.cli_option_string(type)
-          "%-7s: %-28s e.g. %s" % [type, description, example]
-        end
-
-        private
-
-        attr_reader :code_keyword, :pattern, :multiline_argument, :number_of_arguments
-
-        def replace_and_count_capturing_groups(pattern)
-          modified_pattern = ::Regexp.escape(pattern).gsub('\ ', ' ').gsub('/', '\/')
-
-          ARGUMENT_PATTERNS.each do |argument_pattern|
-            modified_pattern.gsub!(::Regexp.new(argument_pattern), argument_pattern)
-            @number_of_arguments += modified_pattern.scan(argument_pattern).length
-          end
-
-          modified_pattern
-        end
-
-        def do_block
-          do_block = ""
-          do_block << "do#{arguments}\n"
-          multiline_argument.append_comment_to(do_block)
-          do_block << "  pending # Write code here that turns the phrase above into concrete actions\n"
-          do_block << "end"
-          do_block
-        end
-
-        def arguments
-          block_args = (0...number_of_arguments).map { |n| "arg#{n+1}" }
-          multiline_argument.append_block_argument_to(block_args)
-          block_args.empty? ? "" : " |#{block_args.join(", ")}|"
-        end
-
-        def self.example
-          new("Given", "missing step", MultilineArgument::None.new).step
-        end
-
-      end
-
-      class Regexp < BaseSnippet
-        def typed_pattern
-          "(/^#{pattern}$/)"
-        end
-
-        def self.description
-          "Snippets with parentheses"
-        end
-      end
-
-      class Classic < BaseSnippet
-        def typed_pattern
-          " /^#{pattern}$/"
-        end
-
-        def self.description
-          "Snippets without parentheses. Note that these cause a warning from modern versions of Ruby."
-        end
-      end
-
-      class Percent < BaseSnippet
-        def typed_pattern
-          " %r{^#{pattern}$}"
-        end
-
-        def self.description
-          "Snippets with percent regexp"
-        end
-      end
-
-      module MultilineArgumentSnippet
-
-        def self.new(multiline_argument)
-          builder = Builder.new
-          multiline_argument.describe_to(builder)
-          builder.result
-        end
-
-        class Builder
-          def doc_string(*args)
-            @result = DocString.new
-          end
-
-          def data_table(table, *args)
-            @result = DataTable.new(table)
-          end
-
-          def result
-            @result || None.new
-          end
-        end
-
-        class DocString
-          def append_block_argument_to(array)
-            array << 'string'
-          end
-
-          def append_comment_to(string)
-          end
-        end
-
-        class DataTable
-          def initialize(table)
-            @table = table
-          end
-
-          def append_block_argument_to(array)
-            array << 'table'
-          end
-
-          def append_comment_to(string)
-            string << "  # table is a #{@table.class.to_s}\n"
-          end
-        end
-
-        class None
-          def append_block_argument_to(array)
-          end
-
-          def append_comment_to(string)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/wire_support/configuration.rb

@@ -1,38 +0,0 @@
-require 'yaml'
-require 'erb'
-
-module Cucumber
-  module WireSupport
-    class Configuration
-      attr_reader :host, :port, :unix
-
-      def self.from_file(wire_file)
-        settings = YAML.load(ERB.new(File.read(wire_file)).result)
-        new(settings)
-      end
-
-      def initialize(args)
-        @host = args['host']
-        @port = args['port']
-        @unix = args['unix'] if RUBY_PLATFORM !~ /mingw|mswin/
-        @timeouts = DEFAULT_TIMEOUTS.merge(args['timeout'] || {})
-      end
-
-      def timeout(message = nil)
-        return @timeouts[message.to_s] || 3
-      end
-
-      def to_s
-        return @unix if @unix
-        "#{@host}:#{@port}"
-      end
-
-      DEFAULT_TIMEOUTS = {
-        'connect' => 11,
-        'invoke' => 120,
-        'begin_scenario' => 120,
-        'end_scenario' => 120
-      }
-    end
-  end
-end

data/lib/cucumber/wire_support/connection.rb

@@ -1,61 +0,0 @@
-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)
-      end
-
-      private
-
-      def send_data_to_socket(data)
-        Timeout.timeout(@config.timeout('connect')) { socket.puts(data) }
-      end
-
-      def fetch_data_from_socket(timeout)
-        raw_response =
-          if timeout == :never
-            socket.gets
-          else
-            Timeout.timeout(timeout) { socket.gets }
-          end
-        raise exception({'message' => "Remote Socket with #{@config.host}:#{@config.port} closed."}) if raw_response.nil?
-        WirePacket.parse(raw_response)
-      end
-
-      def socket
-        return @socket if @socket
-        if @config.unix
-          @socket = UNIXSocket.new(@config.unix)
-        else
-          @socket = TCPSocket.new(@config.host, @config.port)
-        end
-      rescue Errno::ECONNREFUSED => exception
-        raise(ConnectionError, "Unable to contact the wire server at #{@config}. Is it up?")
-      end
-    end
-  end
-end

data/lib/cucumber/wire_support/request_handler.rb

@@ -1,32 +0,0 @@
-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