Sutto-perennial 0.2.3.7 → 0.2.4.0

data/lib/perennial/dispatchable.rb

@@ -40,15 +40,21 @@ module Perennial
         @dispatch_queue ||= []
       end
       
+      def dispatching?
+        @dispatching ||= false
+      end
+      
       # Dispatch an 'event' with a given name to the handlers
       # registered on the current class. Used as a nicer way of defining
       # behaviours that should occur under a given set of circumstances.
       # == Params
       # +name+: The name of the current event
       # +opts+: an optional hash of options to pass
-      def dispatch(name, opts = {}, from_queue = false)
-        if dispatch_queue.empty? || from_queue
+      def dispatch(name, opts = {})
+        if !dispatching?
           Logger.debug "Dispatching #{name} event (#{dispatch_queue.size} queued - on #{self.class.name})"
+          # Add ourselves to the queue
+          @dispatching = true
           begin
             # The full handler name is the method we call given it exists.
             full_handler_name = :"handle_#{name.to_s.underscore}"
@@ -77,11 +83,11 @@ module Perennial
           rescue Exception => e
             Logger.log_exception(e)
           end
-          dispatch_queue.shift if from_queue
-          dispatch(*dispatch_queue.first) unless dispatch_queue.empty?
+          @dispatching = false
+          dispatch(*@dispatch_queue.shift) unless dispatch_queue.empty?
         else
           Logger.debug "Adding #{name} event to the end of the queue (on #{self.class.name})"
-          dispatch_queue << [name, opts, true]
+          dispatch_queue << [name, opts]
         end
       end
       
@@ -114,6 +120,7 @@ module Perennial
       # Handlers are called in the order they are registered.
       def register_handler(handler)
         unless handler.blank? || !handler.respond_to?(:handle)
+          handler.registered = true if handler.respond_to?(:registered=)
           Dispatchable.handler_mapping[self] << handler 
         end
       end

data/lib/perennial/nash.rb

@@ -0,0 +1,161 @@
+module Perennial
+  # A ninja hash. Like OpenStruct, but better
+  class Nash
+    
+    attr_reader :table
+    
+    def initialize(initial = {})
+      @table = {}
+      initial.to_hash.each_pair { |k,v| self[k] = v }
+    end
+    
+    def [](key)
+      @table[real_key(key)]
+    end
+    
+    def []=(key, *values)
+      @table.send(:[]=, real_key(key), *values)
+    end
+    
+    def respond_to?(name, rec = nil)
+      true
+    end
+    
+    def id
+      self.has_key?(:id) ? self.id : super
+    end
+    
+    def dup
+      Nash.new(self.table)
+    end
+    
+    def to_hash
+      @table.dup
+    end
+    
+    def keys
+      @table.keys
+    end
+    
+    def values
+      @table.values
+    end
+    
+    def has_key?(key)
+      @table.has_key? real_key(key)
+    end
+    
+    def has_value?(value)
+      @table.has_value? value
+    end
+    
+    def each_pair
+      @table.each_pair { |k, v| yield k, v }
+    end
+    
+    def each_key
+      @table.each_key { |k| yield k }
+    end
+    
+    def each_value
+      @table.each_value { |v| yield v }
+    end
+    
+    def delete(key)
+      @table.delete(real_key(key))
+    end
+    
+    def merge!(hash_or_nash)
+      hash_or_nash.to_hash.each_pair do |k, v|
+        self[k] = v
+      end
+      return self
+    end
+    
+    def merge(hash_or_nash)
+      dup.merge! hash_or_nash
+    end
+    
+    def reverse_merge!(hash_or_nash)
+      replace Nash.new(hash_or_nash).merge!(self)
+    end
+    
+    def reverse_merge(hash_or_nash)
+      dup.reverse_merge(hash_or_nash)
+    end
+    
+    def replace(nash)
+      if nash.is_a?(self.class)
+        @table = nash.table
+      else
+        @table = {}
+        nash.to_hash.each_pair { |k, v| self[k] = v }
+      end
+      return self
+    end
+    
+    def blank?
+      @table.blank?
+    end
+    
+    def present?
+      @table.present?
+    end
+     
+    def inspect
+      str = ""
+      if first = Thread.current[:inspect_stack].nil?
+        Thread.current[:inspect_stack] = [self]
+        str = _inspect
+        Thread.current[:inspect_stack] = nil
+      else
+        if Thread.current[:inspect_stack].include?(self)
+          return "..."
+        else
+          Thread.current[:inspect_stack] << self
+          str = _inspect
+          Thread.current[:inspect_stack].pop
+        end
+      end
+      return str
+    end
+    
+    def _inspect
+      str = "#<Perennial::Nash:#{(object_id * 2).to_s(16)}"
+      if !blank?
+        str << " "
+        str << table.map { |k, v| "#{k}=#{v.inspect}" }.join(", ")
+      end
+      str << ">"
+      return str
+    end
+     
+    protected
+    
+    def method_missing(name, *args, &blk)
+      name = name.to_s
+      case name.to_s[-1]
+      when ??
+        self[name[0..-2]].present?
+      when ?=
+        send(:[]=, real_key(name[0..-2]), *args)
+      when ?!
+        self[name[0..-2]] = self.class.new
+      else
+        self[name]
+      end
+    end
+    
+    def real_key(name)
+      name.to_sym
+    end
+    
+    
+  end
+end
+
+class Hash
+  def to_nash
+    Perennial::Nash.new(self)
+  end
+end

data/lib/perennial/settings.rb

@@ -4,7 +4,8 @@ module Perennial
   class Settings
     
     cattr_accessor :configuration, :log_level, :verbose, :daemon
-                   
+  
+    @@configuration         = Perennial::Nash.new
     @@verbose               = false
     @@log_level             = :info
     @@daemon                = false
@@ -63,18 +64,13 @@ module Perennial
       end
       
       def setup!(options = {})
-        @@configuration = {}
+        @@configuration ||= Perennial::Nash.new
         settings_file = self.default_settings_path
         if File.exist?(settings_file)
           loaded_yaml = YAML.load(File.read(settings_file))
           @@configuration.merge!(lookup_settings_from(loaded_yaml))
         end
         @@configuration.merge! options
-        @@configuration.symbolize_keys!
-        # Generate a module 
-        mod = generate_settings_accessor_mixin
-        extend  mod
-        include mod
         @@setup = true
       end
       
@@ -89,36 +85,21 @@ module Perennial
         return true
       end
       
-      def [](key)
-        self.setup
-        return self.configuration[key.to_sym]
+      def to_hash
+        @@configuration.to_hash
       end
       
-      def []=(key, value)
-        self.setup
-        self.configuration[key.to_sym] = value
-        return value
+      def method_missing(name, *args, &blk)
+        self.setup! unless self.setup?
+        @@configuration.send(name, *args, &blk)
       end
       
-      def to_hash
-        self.configuration.dup
+      def respond_to?(name, rec = nil)
+        true
       end
       
       protected
       
-      def generate_settings_accessor_mixin
-        Module.new do
-          Settings.configuration.keys.each do |k|
-            define_method(k) do
-              return Settings.configuration[k]
-            end
-            define_method("#{k}=") do |val|
-              Settings.configuration[k] = val
-            end
-          end
-        end
-      end
-      
       def lookup_settings_from(settings_hash)
         lookup_key_path.inject(settings_hash) do |h, k|
           h[k.to_s] ||= {} 
@@ -126,6 +107,15 @@ module Perennial
       end
       
     end
+    
+    def method_missing(name, *args, &blk)
+      self.class.setup
+      @@configuration.send(name, *args, &blk)
+    end
+    
+    def respond_to?(name, rec = nil)
+      true
+    end
 
   end
 end

data/lib/perennial.rb

@@ -9,9 +9,9 @@ require 'perennial/exceptions'
 
 module Perennial
   
-  VERSION = "0.2.3.7"
+  VERSION = "0.2.4.0"
   
-  has_library :dispatchable, :hookable, :loader, :logger,
+  has_library :dispatchable, :hookable, :loader, :logger, :nash,
               :loggable, :manifest, :settings, :argument_parser,
               :option_parser, :application, :generator, :daemon,
               :delegateable

data/test/dispatchable_test.rb

@@ -22,6 +22,43 @@ class DispatchableTest < Test::Unit::TestCase
 
   class ExampleHandlerB < ExampleHandlerA; end
   
+  class ExampleHandlerC
+    attr_reader :max_count, :messages, :call_stack
+    def initialize(d)
+      @messages = []
+      @max_count = 0
+      @current_count = 0
+      @dispatcher = d
+      @call_stack = []
+    end
+    
+    def handle(name, opts)
+      @call_stack << "start-#{name}"
+      @current_count += 1
+      @messages << name
+      @dispatcher.dispatch(:b) if name == :a
+      @max_count = @current_count if @current_count > @max_count
+      @current_count -= 1
+      @call_stack << "end-#{name}"
+    end
+    
+  end
+  
+  class RegisterableHandler
+    
+    def registered=(value)
+      @registered = value
+    end
+    
+    def registered?
+      @registered ||= false
+    end
+    
+    def handle(name, opts = {})
+    end
+    
+  end
+  
   context 'marking a class as dispatchable' do
     
     setup do
@@ -126,4 +163,50 @@ class DispatchableTest < Test::Unit::TestCase
     
   end
   
+  context 'dispatching nested events' do
+    
+    setup do
+      @dispatcher = class_via(ExampleDispatcher).new
+      @handler    = ExampleHandlerC.new(@dispatcher)
+      @dispatcher.class.register_handler @handler
+      @dispatcher.dispatch :a
+    end
+    
+    should 'call them in the correct order' do
+      assert_equal [:a, :b], @handler.messages
+    end
+    
+    should 'only call 1 dispatch at a time' do
+      assert_equal 1, @handler.max_count
+    end
+    
+    should 'finish a before dispatching b' do
+      assert_equal ["start-a", "end-a", "start-b", "end-b"], @handler.call_stack
+    end
+    
+  end
+  
+  context 'registering handlers' do
+    
+    setup do
+      @dispatcher = class_via(ExampleDispatcher).new
+      @handler    = class_via(RegisterableHandler).new
+    end
+    
+    should 'default to not being registered' do
+      assert !@handler.registered?
+    end
+    
+    should 'set registered on register_handler' do
+      @dispatcher.class.register_handler @handler
+      assert @handler.registered?
+    end
+    
+    should 'call registered= on the handler' do
+      mock(@handler).registered = true
+      @dispatcher.class.register_handler @handler
+    end
+    
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: Sutto-perennial
 version: !ruby/object:Gem::Version 
-  version: 0.2.3.7
+  version: 0.2.4.0
 platform: ruby
 authors: 
 - Darcy Laycock
@@ -53,6 +53,7 @@ files:
 - lib/perennial/loggable.rb
 - lib/perennial/logger.rb
 - lib/perennial/manifest.rb
+- lib/perennial/nash.rb
 - lib/perennial/option_parser.rb
 - lib/perennial/settings.rb
 - lib/perennial.rb