lucid 0.0.4 → 0.0.5

data/lib/lucid/unit.rb

@@ -0,0 +1,11 @@
+module Lucid
+  class Unit
+    def initialize(step_collection)
+      @step_collection = step_collection
+    end
+
+    def step_count
+      @step_collection.length
+    end
+  end
+end

data/lib/lucid/wire_support/configuration.rb

@@ -0,0 +1,38 @@
+require 'yaml'
+require 'erb'
+
+module Lucid
+  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/lucid/wire_support/connection.rb

@@ -0,0 +1,61 @@
+require 'timeout'
+require 'lucid/wire_support/wire_protocol'
+
+module Lucid
+  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/lucid/wire_support/request_handler.rb

@@ -0,0 +1,32 @@
+module Lucid
+  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/lucid/wire_support/wire_exception.rb

@@ -0,0 +1,32 @@
+module Lucid
+  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/lucid/wire_support/wire_language.rb

@@ -0,0 +1,54 @@
+require 'multi_json'
+require 'socket'
+require 'lucid/wire_support/connection'
+require 'lucid/wire_support/configuration'
+require 'lucid/wire_support/wire_packet'
+require 'lucid/wire_support/wire_exception'
+require 'lucid/wire_support/wire_step_definition'
+
+module Lucid
+  module WireSupport
+
+    # The wire-protocol (lanugage independent) implementation of the programming
+    # language API.
+    class WireLanguage
+      include Interface::InterfaceMethods
+
+      def initialize(runtime)
+        @connections = []
+      end
+
+      def alias_adverbs(adverbs)
+      end
+
+      def load_code_file(wire_file)
+        config = Configuration.from_file(wire_file)
+        @connections << Connection.new(config)
+      end
+
+      def matcher_text(code_keyword, step_name, multiline_arg_class, matcher_type)
+        matchers = @connections.map do |remote|
+          remote.matcher_text(code_keyword, step_name, multiline_arg_class.to_s)
+        end
+        matchers.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/lucid/wire_support/wire_packet.rb

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

data/lib/lucid/wire_support/wire_protocol.rb

@@ -0,0 +1,43 @@
+require 'lucid/wire_support/wire_protocol/requests'
+
+module Lucid
+  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 matcher_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/lucid/wire_support/wire_protocol/requests.rb

@@ -0,0 +1,125 @@
+require 'lucid/wire_support/request_handler'
+require 'gherkin/formatter/argument'
+
+module Lucid
+  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|
+              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(matcher_text)
+            matcher_text
+          end
+
+          alias :handle_matcher_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)
+            table1 = AST::Table.new(tables[0])
+            table2 = AST::Table.new(tables[1])
+            table1.diff!(table2)
+          end
+
+          def handle_diff(tables)
+            begin
+              handle_diff!(tables)
+            rescue Lucid::AST::Table::Different
+              @connection.diff_failed
+            end
+            @connection.diff_ok
+          end
+
+          alias :handle_step_failed :handle_fail
+        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.source_tags.map { |tag| tag.name.gsub(/^@/, '') }.sort
+          end
+
+          def request_params(scenario)
+            return nil unless scenario.source_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

data/lib/lucid/wire_support/wire_step_definition.rb

@@ -0,0 +1,26 @@
+module Lucid
+  module WireSupport
+    class WireStepDefinition
+      attr_reader :regexp_source, :file_colon_line
+
+      def initialize(connection, data)
+        @connection = connection
+        @id              = data['id']
+        @regexp_source   = data['regexp'] || "Unknown"
+        @file_colon_line = data['source'] || "Unknown"
+      end
+
+      def invoke(args)
+        prepared_args = args.map{ |arg| prepare(arg) }
+        @connection.invoke(@id, prepared_args)
+      end
+
+      private
+
+      def prepare(arg)
+        return arg unless arg.is_a?(Lucid::AST::Table)
+        arg.raw
+      end
+    end
+  end
+end