cucumber 2.1.0 → 2.2.0

data/lib/cucumber/rb_support/regexp_argument_matcher.rb

@@ -1,21 +0,0 @@
-require 'cucumber/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]
-            Cucumber::Gherkin::Formatter::Argument.new(offset, val)
-          end
-        else
-          nil
-        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

data/lib/cucumber/wire_support/wire_exception.rb

@@ -1,32 +0,0 @@
-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, config)
-        super args['message']
-        if args['exception']
-          self.class.extend(CanSetName)
-          self.class.exception_name = "#{args['exception']} from #{config}"
-        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

@@ -1,68 +0,0 @@
-require 'multi_json'
-require 'socket'
-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 (language independent) implementation of the programming
-    # language API.
-    class WireLanguage
-      include LanguageSupport::LanguageMethods
-
-      def initialize(_=nil)
-        @connections = []
-      end
-
-      def load_code_file(wire_file)
-        config = Configuration.from_file(wire_file)
-        @connections << Connection.new(config)
-      end
-
-      def snippet_text(code_keyword, step_name, multiline_arg, snippet_type)
-        snippets = @connections.map do |remote|
-          remote.snippet_text(code_keyword, step_name, MultilineArgClassName.new(multiline_arg).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
-
-      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
-
-      class MultilineArgClassName
-        def initialize(arg)
-          arg.describe_to(self)
-          @result = ""
-        end
-
-        def data_table(*)
-          @result = "Cucumber::MultilineArgument::DataTable"
-        end
-
-        def doc_string(*)
-          @result = "Cucumber::MultilineArgument::DocString"
-        end
-
-        def to_s
-          @result
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/wire_support/wire_packet.rb

@@ -1,34 +0,0 @@
-require 'multi_json'
-
-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 = MultiJson.load(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
-        MultiJson.dump(packet)
-      end
-
-      def handle_with(handler)
-        handler.send("handle_#{@message}", @params)
-      end
-    end
-  end
-end

data/lib/cucumber/wire_support/wire_protocol.rb

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

data/lib/cucumber/wire_support/wire_protocol/requests.rb

@@ -1,133 +0,0 @@
-require 'cucumber/wire_support/request_handler'
-require 'cucumber/gherkin/formatter/argument'
-
-module Cucumber
-  module WireSupport
-    module WireProtocol
-      module Requests
-        class StepMatches < RequestHandler
-          def execute(name_to_match, name_to_report)
-            @name_to_match, @name_to_report = name_to_match, name_to_report
-            request_params = {
-              :name_to_match => name_to_match
-            }
-            super(request_params)
-          end
-
-          def handle_success(params)
-            params.map do |raw_step_match|
-              create_step_match(raw_step_match)
-            end
-          end
-
-          alias :handle_step_matches :handle_success
-
-          private
-
-          def create_step_match(raw_step_match)
-            step_definition = WireStepDefinition.new(@connection, raw_step_match)
-            step_args = raw_step_match['args'].map do |raw_arg|
-              Cucumber::Gherkin::Formatter::Argument.new(raw_arg['pos'], raw_arg['val'])
-            end
-            step_match(step_definition, step_args)
-          end
-
-          def step_match(step_definition, step_args)
-            StepMatch.new(step_definition, @name_to_match, @name_to_report, step_args)
-          end
-        end
-
-        class SnippetText < RequestHandler
-          def execute(step_keyword, step_name, multiline_arg_class_name)
-            request_params = {
-              :step_keyword => step_keyword,
-              :step_name => step_name,
-              :multiline_arg_class => multiline_arg_class_name
-            }
-            super(request_params)
-          end
-
-          def handle_success(snippet_text)
-            snippet_text
-          end
-
-          alias :handle_snippet_text :handle_success
-        end
-
-        class Invoke < RequestHandler
-          def execute(step_definition_id, args)
-            request_params = {
-              :id => step_definition_id,
-              :args => args
-            }
-            super(request_params)
-          end
-
-          def handle_pending(message)
-            raise Pending, message || "TODO"
-          end
-
-          def handle_diff!(tables)
-            # TODO: figure out if / how we could get a location for a table from the wire (or make a null location)
-            location = Core::Ast::Location.new(__FILE__, __LINE__)
-            table1 = table(tables[0], location)
-            table2 = table(tables[1], location)
-            table1.diff!(table2)
-          end
-
-          def handle_diff(tables)
-            begin
-              handle_diff!(tables)
-            rescue Cucumber::MultilineArgument::DataTable::Different
-              @connection.diff_failed
-            end
-            @connection.diff_ok
-          end
-
-          alias :handle_step_failed :handle_fail
-
-          private
-
-          def table(data, location)
-            Cucumber::MultilineArgument.from_core(Core::Ast::DataTable.new(data, location))
-          end
-        end
-
-        class DiffFailed < RequestHandler
-          alias :handle_step_failed :handle_fail
-        end
-
-        class DiffOk < RequestHandler
-          alias :handle_step_failed :handle_fail
-        end
-
-        module Tags
-          def clean_tag_names(scenario)
-            scenario.tags.map { |tag| tag.name.gsub(/^@/, '') }.sort
-          end
-
-          def request_params(scenario)
-            return nil unless scenario.tags.any?
-            { "tags" => clean_tag_names(scenario) }
-          end
-        end
-
-        class BeginScenario < RequestHandler
-          include Tags
-
-          def execute(scenario)
-            super(request_params(scenario))
-          end
-        end
-
-        class EndScenario < RequestHandler
-          include Tags
-
-          def execute(scenario)
-            super(request_params(scenario))
-          end
-        end
-      end
-    end
-  end
-end