dredd_hooks 0.0.1 → 0.1.0

data/lib/dredd_hooks/definitions.rb

@@ -0,0 +1,30 @@
+module DreddHooks
+
+    HOOKS_ON_SINGLE_TRANSACTIONS = [:before, :before_validation, :after]
+
+    HOOKS_ON_MULTIPLE_TRANSACTIONS = [:before_each, :before_each_validation,
+                                      :after_each, :before_all, :after_all]
+
+    Server::EVENTS = {
+      beforeEach: [
+        :before_each,
+        :before,
+      ],
+      beforeEachValidation: [
+        :before_each_validation,
+        :before_validation,
+      ],
+      afterEach: [
+        :after,
+        :after_each,
+      ],
+      afterAll: [
+        :after_all,
+      ],
+      beforeAll: [
+        :before_all,
+      ],
+    }
+
+end
+

data/lib/dredd_hooks/errors.rb

@@ -0,0 +1,15 @@
+module DreddHooks
+
+  class UnknownHookError < RuntimeError
+
+    def initialize(hook_name)
+      @hook_name = hook_name
+    end
+
+    def to_s
+      "Unknown hook: #{@hook_name}"
+    end
+  end
+
+end
+

data/lib/dredd_hooks/file_loader.rb

@@ -1,18 +1,20 @@
 module DreddHooks
   module FileLoader
-    def self.unique_paths globs
-      paths = []
-      globs.each do |glob|
-        paths += Dir.glob glob
-      end
-      paths.uniq
-    end
 
-    def self.load globs
-      self.unique_paths(globs).each do |path|
+    def self.load(patterns)
+      unique_paths(patterns).each do |path|
         puts path
         require path
       end
     end
+
+
+    def self.unique_paths(patterns)
+      patterns.inject([]) { |paths, pattern|
+        paths + Dir.glob(pattern)
+      }.uniq
+    end
+    private_class_method :unique_paths
   end
-end
+end
+

data/lib/dredd_hooks/methods.rb

@@ -1,53 +1,59 @@
-module DreddHooks
-  module Methods
-    @@before_hooks = {}
-    @@before_validation_hooks = {}
-    @@after_hooks = {}
+require 'dredd_hooks/definitions'
+require 'dredd_hooks/runner'
 
-    @@before_each_hooks = []
-    @@before_each_validation_hooks = []
-    @@after_each_hooks = []
+module DreddHooks
 
-    @@before_all_hooks = []
-    @@after_all_hooks = []
+  # The Ruby hooks API
+  module Methods
 
+    # Define hook methods in the form of:
     #
-    # Ruby hooks API
+    #     def before(transaction_name, &block)
+    #       runner.register_before_hook(transaction_name, &block)
+    #     end
     #
+    # Hooks names are defined by HOOKS_ON_SINGLE_TRANSACTIONS.
+    #
+    # Returns nothing.
+    def self.define_hooks_on_single_transactions
+      HOOKS_ON_SINGLE_TRANSACTIONS.each do |hook_name|
 
-    def before transaction_name, &block
-      @@before_hooks[transaction_name] = [] if @@before_hooks[transaction_name].nil?
-      @@before_hooks[transaction_name].push block
-    end
+        define_method hook_name do |transaction_name, &block|
+          runner.send("register_#{hook_name}_hook", transaction_name, &block)
+        end
 
-    def before_validation transaction_name, &block
-      @@before_validation_hooks[transaction_name] = [] if @@before_validation_hooks[transaction_name].nil?
-      @@before_validation_hooks[transaction_name].push block
+      end
     end
+    private_class_method :define_hooks_on_single_transactions
 
-    def after transaction_name, &block
-      @@after_hooks[transaction_name] = [] if @@after_hooks[transaction_name].nil?
-      @@after_hooks[transaction_name].push block
-    end
+    # Define hook methods in the form of:
+    #
+    #     def before_all(&block)
+    #       runner.register_before_all_hook(&block)
+    #     end
+    #
+    # Hooks names are defined by HOOKS_ON_MULTIPLE_TRANSACTIONS.
+    #
+    # Returns nothing.
+    def self.define_hooks_on_multiple_transactions
+      HOOKS_ON_MULTIPLE_TRANSACTIONS.each do |hook_name|
 
-    def before_each &block
-      @@before_each_hooks.push block
-    end
+        define_method hook_name do |&block|
+          runner.send("register_#{hook_name}_hook", &block)
+        end
 
-    def before_each_validation &block
-      @@before_each_validation_hooks.push block
+      end
     end
+    private_class_method :define_hooks_on_multiple_transactions
 
-    def after_each &block
-      @@after_each_hooks.push block
-    end
+    define_hooks_on_single_transactions
+    define_hooks_on_multiple_transactions
 
-    def before_all &block
-      @@before_all_hooks.push block
-    end
+    private
 
-    def after_all &block
-      @@after_all_hooks.push block
-    end
+      def runner
+        Runner.instance
+      end
   end
-end
+end
+

data/lib/dredd_hooks/runner.rb

@@ -1,84 +1,141 @@
+require 'singleton'
+
+require 'dredd_hooks/definitions'
+
 module DreddHooks
-  module Runner
 
+  # The Ruby hooks runner stores and runs the Ruby hooks
+  #
+  # It provides registration methods to be used from the DSL,
+  # as well as methods to run hooks by name from the server.
+  #
+  # All these methods are generated automatically according
+  # to the hooks definitions.
+  #
+  # Note that this class is a Singleton. Use Runner.instance to
+  # get references to its unique instance.
+  class Runner
+
+    include Singleton
+
+    # Define registration methods in the form of:
     #
-    # Runers for Transaction specific hooks
+    #     def register_before_hook(transction_name, &block)
+    #       hooks = @before_hooks || {}
+    #       transaction_hooks = hooks.fetch(transaction_name, [])
+    #       transaction_hooks.push(block)
+    #       hooks[transaction_name] = transaction_hooks
+    #       @before_hooks = hooks
+    #     end
     #
+    # Hooks names are defined by HOOKS_ON_SINGLE_TRANSACTIONS.
+    #
+    # Returns nothing.
+    def self.define_registration_methods_for_hooks_on_single_transactions
+      HOOKS_ON_SINGLE_TRANSACTIONS.each do |hook_name|
 
-    def self.run_before_hooks_for_transaction transaction
-      transaction_name = transaction["name"]
-      hooks = Methods.class_variable_get("@@before_hooks")[transaction_name]
-      if hooks.kind_of? Array
-        hooks.each do |hook_proc|
-          hook_proc.call transaction
+        define_method "register_#{hook_name}_hook" do |transaction_name, &block|
+          hooks = instance_variable_get("@#{hook_name}_hooks") || {}
+          transaction_hooks = hooks.fetch(transaction_name, [])
+          transaction_hooks.push(block)
+          hooks[transaction_name] = transaction_hooks
+          instance_variable_set("@#{hook_name}_hooks", hooks)
         end
-      end
-      return transaction
-    end
 
-    def self.run_before_validation_hooks_for_transaction transaction
-      transaction_name = transaction["name"]
-      hooks = Methods.class_variable_get("@@before_validation_hooks")[transaction_name]
-      if hooks.kind_of? Array
-        hooks.each do |hook_proc|
-          hook_proc.call transaction
-        end
       end
-      return transaction
     end
+    private_class_method :define_registration_methods_for_hooks_on_single_transactions
 
-    def self.run_after_hooks_for_transaction transaction
-      transaction_name = transaction["name"]
-      hooks = Methods.class_variable_get("@@after_hooks")[transaction_name]
-      if hooks.kind_of? Array
-        hooks.each do |hook_proc|
-          hook_proc.call transaction
+    # Define registration methods in the form of:
+    #
+    #     def register_before_all_hook(&block)
+    #       hooks = @before_hooks || []
+    #       hooks.push(block)
+    #       @before_all_hooks = hooks
+    #     end
+    #
+    # Hooks names are defined by HOOKS_ON_MULTIPLE_TRANSACTIONS.
+    #
+    # Returns nothing.
+    def self.define_registration_methods_for_hooks_on_multiple_transactions
+      HOOKS_ON_MULTIPLE_TRANSACTIONS.each do |hook_name|
+
+        define_method "register_#{hook_name}_hook" do |&block|
+          hooks = instance_variable_get("@#{hook_name}_hooks") || []
+          hooks.push(block)
+          instance_variable_set("@#{hook_name}_hooks", hooks)
         end
+
       end
-      return transaction
     end
+    private_class_method :define_registration_methods_for_hooks_on_multiple_transactions
 
+    # Define runner methods in the form of:
     #
-    # Runners for *_each hooks API
+    #     def run_before_hooks_for_transaction(transaction)
+    #       hooks = @before_hooks || {}
+    #       transaction_name = transaction['name']
+    #       transaction_hooks = hooks.fetch(transaction_name, [])
+    #       transaction_hooks.each do |hook|
+    #         hook.call(transaction)
+    #       end
+    #       return transaction
+    #     end
     #
+    # Hooks names are defined by HOOKS_ON_SINGLE_TRANSACTIONS.
+    #
+    # Returns nothing.
+    def self.define_runners_for_hooks_on_single_transactions
+      HOOKS_ON_SINGLE_TRANSACTIONS.each do |hook_name|
 
-    def self.run_before_each_hooks_for_transaction transaction
-      Methods.class_variable_get("@@before_each_hooks").each do |hook_proc|
-        hook_proc.call transaction
-      end
-      return transaction
-    end
-
-    def self.run_before_each_validation_hooks_for_transaction transaction
-      Methods.class_variable_get("@@before_each_validation_hooks").each do |hook_proc|
-        hook_proc.call transaction
-      end
-      return transaction
-    end
+        define_method "run_#{hook_name}_hooks_for_transaction" do |transaction|
+          hooks = instance_variable_get("@#{hook_name}_hooks") || {}
+          transaction_name = transaction['name']
+          transaction_hooks = hooks.fetch(transaction_name, [])
+          transaction_hooks.each do |hook|
+            hook.call(transaction)
+          end
+          return transaction
+        end
 
-    def self.run_after_each_hooks_for_transaction transaction
-      Methods.class_variable_get("@@after_each_hooks").each do |hook_proc|
-        hook_proc.call transaction
       end
-      return transaction
     end
+    private_class_method :define_runners_for_hooks_on_single_transactions
 
+    # Define runner methods in the form of:
+    #
+    #     def run_before_all_hooks_for_transaction(transaction)
+    #       hooks = @before_all_hooks || []
+    #       hooks.each do |hook|
+    #         hook.call(transaction)
+    #       end
+    #       return transaction
+    #     end
     #
-    # Runners for *_all hooks API
+    # Hooks names are defined by HOOKS_ON_MULTIPLE_TRANSACTIONS.
     #
+    # Returns nothing.
+    def self.define_runners_for_hooks_on_multiple_transactions
+      HOOKS_ON_MULTIPLE_TRANSACTIONS.each do |hook_name|
 
-    def self.run_before_all_hooks_for_transactions transactions
-      Methods.class_variable_get("@@before_all_hooks").each do |hook_proc|
-        hook_proc.call transactions
-      end
-      return transactions
-    end
+        define_method "run_#{hook_name}_hooks_for_transaction" do |transaction|
+          hooks = instance_variable_get("@#{hook_name}_hooks") || []
+          hooks.each do |hook|
+            hook.call(transaction)
+          end
+          return transaction
+        end
 
-    def self.run_after_all_hooks_for_transactions transactions
-      Methods.class_variable_get("@@after_all_hooks").each do |hook_proc|
-        hook_proc.call transactions
       end
-      return transactions
     end
+    private_class_method :define_runners_for_hooks_on_multiple_transactions
+
+    define_registration_methods_for_hooks_on_single_transactions
+    define_registration_methods_for_hooks_on_multiple_transactions
+
+    define_runners_for_hooks_on_single_transactions
+    define_runners_for_hooks_on_multiple_transactions
+
   end
-end
+end
+

data/lib/dredd_hooks/server.rb

@@ -1,86 +1,76 @@
 require 'socket'
-require 'json'
+
+require 'dredd_hooks/server/buffer'
+require 'dredd_hooks/server/events_handler'
 
 module DreddHooks
+
+  # The hooks worker server
   class Server
-    #
-    # The hooks worker server
-    #
+
+    attr_reader :buffer, :error, :events_handler, :out, :server
+    private :buffer, :error, :events_handler, :out, :server
 
     HOST = '127.0.0.1'
     PORT = 61321
     MESSAGE_DELIMITER = "\n"
 
-    @server = nil
-
-    def process_message message, client
-      event = message['event']
-      data = message['data']
-
-      if event == "beforeEach"
-        data = DreddHooks::Runner.run_before_each_hooks_for_transaction data
-        data = DreddHooks::Runner.run_before_hooks_for_transaction data
-      end
-
-      if event == "beforeEachValidation"
-        data = DreddHooks::Runner.run_before_each_validation_hooks_for_transaction data
-        data = DreddHooks::Runner.run_before_validation_hooks_for_transaction data
-      end
-
-      if event == "afterEach"
-        data = DreddHooks::Runner.run_after_hooks_for_transaction data
-        data = DreddHooks::Runner.run_after_each_hooks_for_transaction data
-      end
-
-      if event == "beforeAll"
-        data = DreddHooks::Runner.run_before_all_hooks_for_transactions data
-      end
-
-      if event == "afterAll"
-        data = DreddHooks::Runner.run_after_all_hooks_for_transactions data
-      end
-
-      to_send = {
-        "uuid" => message['uuid'],
-        "event" => event,
-        "data" => data
-      }.to_json
-      client.puts to_send + "\n"
+    def initialize(error=STDERR, out=STDOUT)
+      @error = error
+      @out = out
+      @server = TCPServer.new(HOST, PORT)
+      @buffer = Buffer.new(MESSAGE_DELIMITER)
+      @events_handler = EventsHandler.new
     end
 
     def run
-      @server = TCPServer.new HOST, PORT
+      disable_buffering(out)
       loop do
-        #Thread.abort_on_exception=true
-        client = @server.accept
-        STDERR.puts 'Dredd connected to Ruby Dredd hooks worker'
-        buffer = ""
+        client = server.accept
+        out.puts 'Dredd connected to Ruby Dredd hooks worker'
+        buffer.flush!
         while (data = client.recv(10))
-          buffer += data
-          if buffer.include? MESSAGE_DELIMITER
-            splitted_buffer = buffer.split(MESSAGE_DELIMITER)
-            buffer = ""
-
-            messages = []
-
-            splitted_buffer.each do |message|
-              begin
-                messages.push JSON.parse(message)
-
-              rescue JSON::ParserError
-                # if message aftger delimiter is not parseable json, it's
-                # a chunk of next message, put it back to the buffer
-                buffer += message
-              end
-            end
+          buffer << data
+          if buffer.any_message?
+            messages = buffer.unshift_messages
 
             messages.each do |message|
-              process_message message, client
+              response = process_message(message)
+              client.puts response + MESSAGE_DELIMITER
             end
           end
         end
         client.close
       end
     end
+
+    private
+
+      # Write to a file (e.g. STDOUT) without delay
+      #
+      # See https://stackoverflow.com/q/23001033
+      # and http://ruby-doc.org/core-2.3.1/IO.html#method-i-sync-3D
+      def disable_buffering(file)
+        file.sync = true
+      end
+
+      def process_message(message)
+        event = message['event']
+        transaction = message['data']
+
+        transaction = events_handler.handle(event, transaction)
+
+        response(message['uuid'], event, transaction)
+      end
+
+      def response(message_uuid, event, transaction)
+        {
+          uuid: message_uuid,
+          event: event,
+          data: transaction,
+        }.to_json
+      end
+
   end
-end
+end
+