wires 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 369f57cc3ba7cc10459a5c96c64de94ea0620993
-  data.tar.gz: d204b15eee9ef1c0ca74fa2edbeeb53fa17c6281
+  metadata.gz: 84333d4617ce57228fdd29e5255aa9e30f1ce474
+  data.tar.gz: 445840683d9422bae1292a8655253d32510cca87
 SHA512:
-  metadata.gz: c8e1098cdc6fc1f761cba1ad67818b63e688d15033df550a4dca9184a512cd21fd805a05ce7a7be45f67a57b02e12e48f73198ada199de4f46fd9ab3b189c88b
-  data.tar.gz: 7c4e58d4a7acc0422dbe72d44b176be64fb12d1a641d94943c3ef46373471dfb36194bfcb21cb65a11b455503a883009888d5f660a0624652d8fd0522bec42f9
+  metadata.gz: 68bc50ed50729dcae3f913cf9db1dcc36bdf112710a7c03d9dfcc76ab7da05fccfc83f6e65846e29169ba325d3dba30e100d3570efe589cbcac00c46aedbecd8
+  data.tar.gz: eaa90eea5b0051e1f1f9b773b51aa14290b440d29ea54b3d08ae2883a92fc1f5aed96dc812bd8c6ad94316c9d887c2c12387a7186fbfcf19fbfc332c5947eb2d

data/LICENSE

@@ -0,0 +1,2 @@
+Copyright (c) 2013 : Joe McIlvain
+All rights reserved.

data/README.md

@@ -0,0 +1,13 @@
+Wires
+=====
+
+An asynchronous (threaded) event routing framework in Ruby.  
+
+Patch your objects together with wires.
+
+Inspired by [the python 'circuits' framework](http://circuitsframework.com/).
+
+Wires is a work in progress.
+
+Copyright (c) 2013 : Joe McIlvain
+All rights reserved.

data/lib/wires/channels.rb

@@ -0,0 +1,100 @@
+
+def on(events, channels='*', &codeblock)
+    channels = [channels] unless channels.is_a? Array
+    for channel in channels
+        Channel(channel).register(events, codeblock)
+    end
+end
+
+
+def fire(event, channel='*') 
+    Channel(channel).fire(event)
+end
+
+
+def Channel(*args) Channel.new(*args) end
+
+class Channel
+    
+    attr_reader :name
+    attr_reader :target_list
+    
+    def initialize(name)
+        @name = name
+        @target_list = Set.new
+        @@channel_list << self
+    end
+    
+    # Ensure that there is only one instance of Channel per name
+    @@channel_list = Set.new
+    def self.new(*args, &block)
+        (@@channel_list.select {|x| x.name == args[0]} [0]) \
+        or super(*args, &block)
+    end
+    
+    # Class-wide reference to the global channel and event hub
+    @@channel_star = Channel('*')
+    @@hub = Hub.new
+    
+    # Register a proc to be triggered by an event on this channel
+    def register(events, proc)
+        
+        if not proc then raise SyntaxError, \
+            "No Proc given to execute on event: #{events}" end
+        
+        # Convert all events to strings
+        events = [events] unless events.is_a? Array
+        events.flatten!
+        events.map! { |e| (e.is_a?(Class) ? e.codestring : e.to_s) }
+        events.uniq!
+        
+        @target_list << [events, proc]
+        @target_list << [events, proc]
+    end
+    
+    # Fire an event on this channel
+    def fire(_event)
+        
+        # Pull out args from optional array notation
+        _event = [_event] unless _event.is_a? Array
+        _event, *args = _event
+        
+        # Create event object from event as an object, class, or symbol/string
+        event = 
+        case _event
+            when Event
+                _event
+            when Class
+                _event.new(*args) if _event < Event
+            else
+                cls = Event.from_codestring(_event.to_s).new(*args)
+        end
+        
+        # Fire to each relevant target on each channel
+        for chan in relevant_channels()
+            for target in chan.target_list
+                for string in target[0] & event.class.codestrings
+                    @@hub.enqueue([string, event, *target[1..-1]])
+        end end end
+        
+    end
+    
+    def relevant_channels
+        return @@channel_list if self==@@channel_star
+        
+        if self.name.is_a?(Regexp) then raise TypeError,
+            "Cannot fire on Regexp channel: #{self.name}."\
+            "  Regexp channels can only used in event handlers." end
+            
+        relevant = [@@channel_star, self]
+        for c in @@channel_list
+            relevant << c if case c.name
+            when Regexp
+                self.name =~ c.name
+            else String
+                self.name == c.name.to_s
+            end
+        end
+        return relevant.uniq
+    end
+end

data/lib/wires/events.rb

@@ -0,0 +1,131 @@
+# Store a list of all Event classes that get loaded.
+class EventRegistry
+    @@registry = []
+    
+    def self.<<(cls)
+        @@registry << cls
+        @@registry.uniq!
+    end
+    
+    def self.list
+        @@registry
+    end
+end
+
+# All Event classes should inherit from this one
+class Event
+    
+    # Register with the EventRegistry and make subclasses do the same
+    EventRegistry << self
+    def self.inherited(subcls)
+        
+        # Be sure codestring doesn't conflict
+        existing = self._from_codestring(subcls.codestring)
+        if existing then raise NameError, \
+                "New Event subclass '#{subcls}' conflicts with"\
+                " existing Event subclass '#{existing}'."\
+                " The generated codestring '#{subcls.codestring}'"\
+                " must be unique for each Event subclass." end
+        
+        # Register, then call super
+        EventRegistry << subcls
+        super
+    end
+    
+    # List of class inheritance lineage back to but excluding Object
+    def self.ancestry(cls=self)
+        _next = cls.superclass
+        [cls==Object ? [] : [cls, self.ancestry(_next)]].flatten
+    end
+    
+    # Convert class <ClassNameEvent> to string "class_name"
+    def self.codestring(cls=self)
+        cls.to_s
+           .gsub(/(?<!(?:_|^))([A-Z])/, "_\\1")
+           .downcase
+           .gsub(/_event/, "")
+    end
+    
+    # List of codestrings associated with this event and ancestors
+    def self.codestrings
+        x = self.ancestry
+                .map {|cls| cls.codestring}
+    end
+    
+    # Pull class from registry by codestring 
+    # (more reliable than crafting a reverse regexp)
+    def self._from_codestring(str)
+        return EventRegistry.list
+                            .select{|e| e.codestring==str}[0]
+    end
+    def self.from_codestring(str)
+        cls = self._from_codestring(str)
+        if not cls then raise NameError,
+            "No known Event subclass with codestring: '#{str}'" end
+        cls
+    end
+    
+    # Create attributes and accessors for all arguments to the constructor.
+    # This is done here rather than in initialize so that the functionality
+    # will remain if the user developer overrides initialize in the subclass.
+    def self.new(*args, &block)
+        obj = super
+        
+        kwargs = args[-1].is_a?(Hash) ? args.pop : Hash.new
+        kwargs[:args] = args
+        kwargs[:proc] = block if block
+        for key in kwargs.keys
+            att = key.to_s
+            obj.instance_variable_set("@#{att}", kwargs[key])
+            self.class_eval("def #{att}; @#{att}; end")
+            self.class_eval("def #{att}=(val); @#{att}=val; end")
+        end
+        
+        obj
+    end
+    
+    # Calling super in self.new with *args will complain if this isn't here
+    def initialize(*args, &block) end
+end
+
+
+#
+# Comparison support for Events and Symbols/Strings
+#
+
+# Reopen Event and add comparison functions
+class Event
+    def self.==(other)
+        other.is_a?(Class) ? 
+            super : self.codestring==other.to_s
+    end
+    def self.<=(other)
+        other.is_a?(Class) ? 
+            super : self.codestrings.include?(other.to_s)
+    end
+    def self.<(other)
+        other.is_a?(Class) ? 
+            super : (self<=other and not self==other)
+    end
+    def self.>=(other)
+        other.is_a?(Class) ? 
+            super : Event.from_codestring(other.to_s)<=self
+    end
+    def self.>(other)
+        other.is_a?(Class) ? 
+            super : Event.from_codestring(other.to_s)<self
+    end
+end
+
+# Autogenerate the inverse comparison functions for Symbol/String
+for cls in [Symbol, String]
+    %w(== < > <= >=).zip(%w(== > < >= <=))
+                       .each do |ops|
+        op, opinv = ops # unzip operator and inverse operator
+        cls.class_eval(
+            "def #{op}(other)\n"\
+            "    (other.is_a?(Class) and other<=Event) ? \n"\
+            "        (other#{opinv}self) : super\n"\
+            "end\n")
+    end
+end

data/lib/wires/hub.rb

@@ -0,0 +1,66 @@
+
+# Make sure puts goes to $stdout for all threads!
+def puts(x) $stdout.puts(x) end
+
+
+class Hub
+    def initialize
+        @queue = Queue.new
+    end
+    
+    def self.new
+        @instance ||= super
+    end
+    
+    def kill!() @keepgoing=false end
+    
+    def run
+        @keepgoing = true
+            
+        while @keepgoing
+            if @queue.empty? then sleep(0)
+            else _process_item(@queue.shift) end
+        end
+        
+    end
+    
+    def _process_item(x)
+        x, waiting_thread = x
+        string, event, proc = x
+        Thread.new do
+            
+            begin
+                waiting_thread.wakeup
+                proc.call($event = event)
+                
+            rescue Interrupt, SystemExit => e
+                @keepgoing = false
+                _unhandled_exception(e)
+                
+            rescue Exception => e
+                _unhandled_exception(e)
+            end
+        end
+    end
+    
+    def _unhandled_exception(x)
+        $stderr.puts $!
+        $stderr.puts $@
+    end
+    
+    def fire(x)
+        @queue << [x, Thread.current]
+        sleep
+    end
+    
+    def enqueue(x)
+        fire x
+    end
+end
+
+
+# Run the hub in a new thread and join it at main thread exit
+#   However, do not join if an exception caused the exit - 
+#     Such an exception indicates usually an error in user code
+__hub_thread = Thread.new() {Hub.new.run}
+at_exit { __hub_thread.join if not $! }

data/lib/wires.rb

@@ -1,6 +1,6 @@
 require 'set'
 require 'thread'
 
-require_relative 'events'
-require_relative 'hub'
-require_relative 'channels'
+require 'wires/events'
+require 'wires/hub'
+require 'wires/channels'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - Joe McIlvain
@@ -18,9 +18,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/wires.rb
+- lib/wires/hub.rb
+- lib/wires/events.rb
+- lib/wires/channels.rb
+- LICENSE
+- README.md
 homepage: https://github.com/jemc/wires/
 licenses:
-- 'All rights temporarily reserved '
+- 'Copyright (c) Joe McIlvain. All rights reserved '
 metadata: {}
 post_install_message: 
 rdoc_options: []