rohbau 0.1.0

data/lib/rohbau/event_tube.rb

@@ -0,0 +1,42 @@
+module Rohbau
+  class EventTube
+    def self.reset
+      @subscriptions = nil
+    end
+    def self.publish(name, event)
+      subscription_handler.handle(name, event)
+    end
+
+    def self.subscribe(name, &handler)
+      subscription_handler.add(name, &handler)
+    end
+
+    def self.subscription_handler
+      @subscriptions ||= SubscriptionHandler.new
+    end
+
+    class SubscriptionHandler
+      def initialize
+        @subscriptions = Hash.new do |h,k|
+          h[k] = []
+        end
+      end
+
+      def add(name, &handler)
+        subscriptions[name] << handler
+        true
+      end
+
+      def handle(name, event)
+        subscriptions[name].each do |handler|
+          handler.call(event)
+        end
+        true
+      end
+
+      private
+
+      attr_reader :subscriptions
+    end
+  end
+end

data/lib/rohbau/index.rb

@@ -0,0 +1,214 @@
+require 'thread_safe'
+
+module Rohbau
+  class Index
+    include Enumerable
+
+    def initialize
+      @last_uid = 0
+      @entities = ThreadSafe::Hash.new
+
+      @validator = Validator.new(self)
+
+      @options = {
+        :uid_generation => true,
+        :mapper         => DefaultMapper,
+        :unmapper       => DefaultMapper
+      }
+    end
+
+    def add(entity)
+
+      if option?(:uid_generation)
+        validate :add, entity
+
+        added_entity = copy(entity).tap do |new_entity|
+          new_entity.uid = next_uid
+          entities[new_entity.uid] = map(new_entity)
+        end
+      else
+        validate :add_with_uid, entity
+
+        added_entity = copy(entity).tap do |new_entity|
+          entities[new_entity.uid] = map(new_entity)
+        end
+      end
+
+      get added_entity.uid
+    end
+
+    def bulk_add(entities)
+      entities.map do |entity|
+        add entity
+      end
+    end
+
+    def get(uid)
+      validate :get, uid
+
+      unmap(entities[uid])
+    end
+
+    def update(entity)
+      validate :update, entity
+
+      entities[entity.uid] = map(entity)
+
+      get entity.uid
+    end
+
+    def delete(uid)
+      validate :delete, uid
+
+      unmap entities.delete(uid)
+    end
+
+    def bulk_delete(uids)
+      uids.map do |uid|
+        delete uid
+      end
+    end
+
+    def all
+      entities.values.map(&method(:unmap))
+    end
+
+    def each(&block)
+      all.each(&block)
+    end
+
+    def size
+      entities.size
+    end
+
+    def has_uid?(uid)
+      entities.key?(uid)
+    end
+
+    def option(key, value = nil)
+      if value != nil
+        @options[key] = value
+      else
+        @options[key]
+      end
+    end
+
+    def option?(key)
+      !!@options[key]
+    end
+
+    private
+
+    def map(entity)
+      option(:mapper).call(entity)
+    end
+
+    def unmap(mapped_entity)
+      option(:unmapper).call(mapped_entity)
+    end
+
+    def copy(entity)
+      Marshal.load(Marshal.dump entity)
+    end
+
+    def next_uid
+      "#{@last_uid += 1}"
+    end
+
+    def entities
+      @entities
+    end
+
+    def validate(method, *args)
+      @validator.public_send("validate_#{method}", *args)
+    end
+
+    class Validator
+      def initialize(memory)
+        @memory = memory
+      end
+
+      def validate_add(entity)
+        ensure_entity!(entity)
+        ensure_entity_has_no_uid!(entity)
+      end
+
+      def validate_add_with_uid(entity)
+        ensure_entity!(entity)
+        ensure_entity_has_uid!(entity)
+        ensure_uid_type!(entity.uid)
+      end
+
+      def validate_get(uid)
+        ensure_uid!(uid)
+        ensure_uid_type!(uid)
+      end
+
+      def validate_update(entity)
+        ensure_entity!(entity)
+        ensure_entity_has_uid!(entity)
+        ensure_entity_exists!(entity)
+      end
+
+      def validate_delete(uid)
+        ensure_uid_exists!(uid)
+      end
+
+
+      private
+      def ensure_uid!(uid)
+        if uid.nil?
+          raise argument_error('uid is missing')
+        end
+      end
+
+      def ensure_uid_type!(uid)
+        if !uid.kind_of?(String) || uid.size == 0
+          raise argument_error('uid is invalid', uid)
+        end
+      end
+
+      def ensure_entity!(entity)
+        if entity.nil?
+          raise argument_error('entity is invalid', entity)
+        end
+      end
+
+      def ensure_entity_has_uid!(entity)
+        if !entity.uid
+          raise argument_error('entity has no uid', entity)
+        end
+      end
+
+      def ensure_entity_has_no_uid!(entity)
+        if entity.uid
+          raise argument_error('entity has uid', entity)
+        end
+      end
+
+      def ensure_entity_exists!(entity)
+        if !@memory.has_uid?(entity.uid)
+          raise argument_error('entity is unknown', entity)
+        end
+      end
+
+      def ensure_uid_exists!(uid)
+        if !@memory.has_uid?(uid)
+          raise argument_error('uid is unknown', uid)
+        end
+      end
+
+      def argument_error(error, object = nil)
+        message = "#{self.class.inspect}: #{error}"
+        message += ": #{object.inspect}" if object
+        ArgumentError.new(message)
+      end
+    end
+
+    class DefaultMapper
+      def self.call(entity)
+        Marshal.load(Marshal.dump entity)
+      end
+    end
+  end
+end

data/lib/rohbau/it_behaves_like.rb

@@ -0,0 +1,26 @@
+require 'minitest/spec'
+
+module Rohbau
+  module ItBehavesLike
+
+    def get_shared_example(spec_name)
+      Rohbau::SharedSpec::SpecIndex.get spec_name
+    end
+
+    def it_behaves_like(spec)
+      if spec.kind_of? Proc
+        shared_example = spec
+      else
+        shared_example = get_shared_example(spec)
+      end
+      raise "No shared spec for #{spec.inspect} found" unless shared_example
+
+      instance_eval(&shared_example)
+    end
+
+  end
+end
+
+class MiniTest::Spec
+  extend Rohbau::ItBehavesLike
+end

data/lib/rohbau/minitest/exclude.rb

@@ -0,0 +1,58 @@
+module Rohbau
+  module Minitest
+    module Exclude
+
+      class SpecNuker
+        def initialize(description_name, description_caller)
+          spec_class = find_spec_class(description_caller)
+          @description_caller   = description_caller
+          @description_name     = description_name
+          @description_classes  = spec_class.children
+        end
+
+        def nuke!(it_desc)
+          it_method_name = find_it_method(it_desc)
+
+          if it_method_name.nil?
+            inspected_method = "\"#{@description_caller}\"##{it_desc.inspect}"
+            msg = "Method #{inspected_method} is not defined"
+            return warn(msg)
+          end
+
+          description_class.send :undef_method, it_method_name
+        end
+
+        private
+
+        def find_spec_class(description_class)
+          description_class.superclass
+        end
+
+        def find_it_method(it_desc)
+          description_class.instance_methods.detect do |instance_method|
+            instance_method =~ %r{test_[0-9]+_#{it_desc}}
+          end
+        end
+
+        def description_class
+          @description_classes.detect do |description_class|
+            description_class.name == @description_name
+          end
+        end
+
+      end
+
+    end
+  end
+end
+
+module MiniTest::Spec::DSL
+
+
+  # only single nesting in one describe block is supported
+  # for now
+  def exclude(it_desc, reason = "")
+    Rohbau::Minitest::Exclude::SpecNuker.new(self.name, self).nuke!(it_desc)
+  end
+
+end

data/lib/rohbau/registry.rb

@@ -0,0 +1,45 @@
+module Rohbau
+  module Registry
+    def self.included(cls)
+      cls.send :extend, ExternalInterface
+      cls.send :include, Implementation
+    end
+
+    module Implementation
+      def cache(name, &block)
+        @cache ||= {}
+        @cache[name] ||= block.call
+      end
+    end
+
+    module ExternalInterface
+      def register(service_name, &constructor)
+        registrations << service_name
+        implementations[service_name] << constructor
+        this = self
+
+        this.send :define_method, service_name do
+          cache service_name do
+            instance_eval(&this.implementations[service_name].last)
+          end
+        end
+      end
+
+      def unregister(service_name)
+        implementations[service_name].pop
+
+        if implementations[service_name].empty?
+          self.send :remove_method, service_name
+        end
+      end
+
+      def registrations
+        @registrations ||= []
+      end
+
+      def implementations
+        @implementations ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+    end
+  end
+end

data/lib/rohbau/request.rb

@@ -0,0 +1,24 @@
+module Rohbau
+  class Request
+
+    def initialize(runtime)
+      raise "No Runtime instanciated (#{self.inspect})" unless runtime
+      @runtime = runtime
+    end
+
+    def services
+      @service_factory ||= build_service_factory
+    end
+
+    protected
+
+    def build_service_factory
+      raise NotImplementedError, "Please provide #{self.class}#build_service_factory"
+    end
+
+    def runtime
+      @runtime
+    end
+
+  end
+end

data/lib/rohbau/require.rb

@@ -0,0 +1,20 @@
+module Rohbau
+  module Require
+    module_function
+
+    def require_all(*sub_dirs)
+      called_by = caller_locations(1, 1).first
+      file = called_by.absolute_path
+
+      dir = File.basename(file, '.rb')
+
+      sub_dirs.each do |sub_dir|
+        dir = File.join(dir, sub_dir)
+      end
+
+      files = File.expand_path("../#{dir}/*.rb", file)
+      Dir[files].each { |f| require f }
+    end
+
+  end
+end

data/lib/rohbau/runtime.rb

@@ -0,0 +1,94 @@
+require 'pathname'
+require 'thread_safe'
+
+module Rohbau
+  class Runtime
+    def self.register(name, plugin_class)
+      attr_reader name
+      plugins[name] = plugin_class
+      plugin_class.registered(self) if plugin_class.respond_to?(:registered)
+    end
+
+    def self.unregister(name)
+      remove_method name
+      plugins.delete name
+    end
+
+    def self.plugins
+      @plugins ||= {}
+    end
+
+    def initialize
+      on_boot
+      initialize_plugins
+      after_boot
+    end
+
+    def terminate
+      terminate_plugins
+      after_termination
+    end
+
+    def root
+      Pathname.new(Dir.pwd)
+    end
+
+    protected
+
+    def on_boot
+      # noop
+    end
+
+    def after_boot
+      # noop
+    end
+
+    def after_termination
+    end
+
+
+    def initialize_plugins
+      self.class.plugins.each do |name, plugin_class|
+        instance_variable_set :"@#{name}", plugin_class.new
+      end
+    end
+
+    def notify_plugins(message, *args)
+      self.class.plugins.each do |name, _|
+        plugin = public_send(name)
+        if plugin.instance.respond_to? message
+          plugin.instance.public_send(message, *args)
+        end
+      end
+    end
+
+    def terminate_plugins
+      self.class.plugins.each do |name, _|
+        plugin = public_send(name)
+        plugin.terminate if plugin.respond_to? :terminate
+      end
+    end
+
+    def handle_transaction(&block)
+      if transaction_handling_plugin
+        transaction_handling_plugin.transaction_handler(&block)
+      else
+        block.call
+      end
+    end
+
+    def transaction_handling_plugin
+      return @handling_plugin if defined? @handling_plugin
+
+      plugin = self.class.plugins.detect do |_, runtime_loader|
+        runtime_loader.instance.respond_to? :transaction_handler
+      end
+      if plugin
+        @handling_plugin = plugin[1].instance
+      else
+        @handling_plugin = nil
+      end
+    end
+
+  end
+end

data/lib/rohbau/runtime_loader.rb

@@ -0,0 +1,67 @@
+module Rohbau
+  class RuntimeLoader
+    class << self
+      def instance
+        @instance
+      end
+
+      def running?
+        !!instance
+      end
+
+      def terminate
+        instance.terminate if instance.respond_to? :terminate
+        remove_instance_variable :@instance if defined? @instance
+      end
+
+      attr_accessor :registrar
+
+      def registered(registrar)
+        self.registrar = registrar
+      end
+
+      def new(*args)
+        super(*args)
+        self
+      end
+    end
+
+    def initialize(runtime)
+      return if singleton_assigned?
+      build_singleton(runtime)
+    end
+
+    private
+
+    def singleton_assigned?
+      self.class.instance_variable_defined? singleton_variable
+    end
+
+    def singleton
+      self.class.instance_variable_get singleton_variable
+    end
+
+    def initialize_with_immediate_callback(cls, &callback)
+      cls.send :define_method, :initialize do |*args|
+        callback.call(self)
+        super(*args)
+      end
+
+      cls.new
+    end
+
+    def assign_to_singleton(instance)
+      self.class.instance_variable_set singleton_variable, instance
+    end
+
+    def build_singleton(runtime)
+      initialize_with_immediate_callback runtime do |instance|
+        assign_to_singleton(instance)
+      end
+    end
+
+    def singleton_variable
+      :@instance
+    end
+  end
+end

data/lib/rohbau/service_factory.rb

@@ -0,0 +1,37 @@
+require 'rohbau/registry'
+
+module Rohbau
+  class ServiceFactory
+    include Rohbau::Registry
+
+    def initialize(runtime)
+      raise "No Runtime instanciated" unless runtime
+      @runtime = runtime
+    end
+
+    def self.external_dependencies_complied?
+      missing_dependencies.empty?
+    end
+
+    def self.missing_dependencies
+      external_dependencies.reject do |dependency|
+        registrations.include? dependency
+      end
+    end
+
+    def self.external_dependencies(*dependencies)
+      if dependencies.any?
+        @external_dependencies = dependencies
+      else
+        @external_dependencies ||= []
+      end
+    end
+
+    protected
+
+    def runtime
+      @runtime
+    end
+
+  end
+end

data/lib/rohbau/shared_spec.rb

@@ -0,0 +1,47 @@
+require 'rohbau/it_behaves_like'
+require 'rohbau/minitest/exclude'
+
+module Rohbau
+  class SharedSpec < Proc
+
+    def self.for(name, &block)
+      shared_specs[name] = Proc.new(&block)
+    end
+
+    def self.get(name)
+      shared_specs[name]
+    end
+
+    def self.inherited(child_class)
+      SpecIndex.register child_class
+    end
+
+    def self.shared_specs
+      @shared_specs ||= {}
+    end
+
+    class SpecIndex
+      def self.reset
+        @specs = []
+      end
+
+      def self.register(shared_spec_class)
+        reset unless @specs
+        @specs << shared_spec_class
+      end
+
+      def self.all
+        @specs.dup
+      end
+
+      def self.get(name)
+        @specs.each do |spec|
+          found = spec.get(name)
+          return found if found
+        end
+        nil
+      end
+    end
+  end
+end
+