seh 0.0.1 → 0.0.2

data/lib/seh/event.rb

@@ -2,17 +2,32 @@ require 'ostruct'
 
 module Seh
   module Private
+    START = 0
+    BEFORE = 100
+
+    BEFORE_SUCCESS = 250
+    BEFORE_FAILURE = 250
+
+    SUCCESS = 500
+    FAILURE = 500
+
+    AFTER_SUCCESS = 750
+    AFTER_FAILURE = 750
+
+    AFTER = 900
+    FINISH = 1000
+
     class EventData
-      attr_accessor :types, :target, :time, :start, :finish
+      attr_accessor :types, :target, :time, :staged_handlers, :success
 
       def initialize
         @types = []
         @target = nil
         @time = Time.now
+        @success = true
 
         # staged handlers
-        @start = []
-        @finish = []
+        @staged_handlers = {}
       end
     end
 
@@ -42,12 +57,19 @@ module Seh
       instance_eval(&block) if block
     end
 
+    def fail
+      @data.success = false
+    end
+
+    def success?
+      @data.success
+    end
+
     def dispatch
       raise "Event may only be dispatched once" unless @state == Private::EventStateReady
       @state = Private::EventStateInflight
-      @data.target.each_bind { |bind| bind.block.call self if bind.event_type.match @data.types }
-      @data.start.each { |block| block.call self }
-      @data.finish.each { |block| block.call self }
+      collect_targets.each { |t| t.each_bind { |bind| bind.block.call self if bind.event_type.match @data.types } }
+      @data.staged_handlers.each_key.sort.each { |stage| @data.staged_handlers[stage].each { |block| block.call self } }
       @state = Private::EventStateDone
     end
 
@@ -69,11 +91,60 @@ module Seh
     end
 
     def start(&block)
-      @data.start << block if block_given?
+      staged_handler Private::START, block if block_given?
+    end
+
+    def before(&block)
+      staged_handler Private::BEFORE, block if block_given?
+    end
+
+    def before_success(&block)
+      staged_handler Private::BEFORE_SUCCESS, ->e{ block.call e if e.success? } if block_given?
+    end
+
+    def before_failure(&block)
+      staged_handler Private::BEFORE_FAILURE, ->e{ block.call e unless e.success? } if block_given?
+    end
+
+    def success(&block)
+      staged_handler Private::SUCCESS, ->e{ block.call e if e.success? } if block_given?
+    end
+
+    def failure(&block)
+      staged_handler Private::FAILURE, ->e{ block.call e unless e.success? } if block_given?
+    end
+
+    def after_success(&block)
+      staged_handler Private::AFTER_SUCCESS, ->e{ block.call e if e.success? } if block_given?
+    end
+
+    def after_failure(&block)
+      staged_handler Private::AFTER_FAILURE, ->e{ block.call e unless e.success? } if block_given?
+    end
+
+    def after(&block)
+      staged_handler Private::AFTER, block if block_given?
     end
 
     def finish(&block)
-      @data.finish << block if block_given?
+      staged_handler Private::FINISH, block if block_given?
+    end
+
+    private
+    def staged_handler( stage, block )
+      @data.staged_handlers[stage] ||= []
+      @data.staged_handlers[stage] << block
+      nil
+    end
+
+    def collect_targets
+      targets_working = [@data.target]
+      targets_final = []
+      while t = targets_working.shift do
+        targets_final << t
+        targets_working.concat t.parents if t.respond_to? :parents
+      end
+      targets_final.uniq
     end
   end
 end

data/lib/seh/version.rb

@@ -1,3 +1,3 @@
 module Seh
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/seh.gemspec

@@ -8,8 +8,16 @@ Gem::Specification.new do |s|
   s.authors     = ["Ryan Berckmans"]
   s.email       = ["ryan.berckmans@gmail.com"]
   s.homepage    = "https://github.com/ryanberckmans/seh"
-  s.summary     = "event handling similar to w3c dom events; pre-alpha wip"
-  s.description = ""
+  s.summary     = "pure ruby event handling similar to w3c dom events; pre-alpha wip"
+  s.description = "Pure ruby event handling similar to w3c dom events. Lots of bells and whistles to support complex event handling as required by stuff like video games.
++ event handling in a synchronous specific order
++ event targets can have multiple parents and common ancestors; event propagation does a breadth first search traversal over a directed acyclic event target graph
++ staged callbacks: event.before { .. }; event.after { .. }
++ staged callbacks allow for an ancestor to influence affect of event on a descendant: ancestor.before { |event| event.x = 5 }; descendant.after { |event| puts event.x }
++ events can have multiple types, and types can inherit from other types
++ bind callbacks using event type filtering: node.bind(overcast AND (rain OR snow)) { |event| callback! }
++ optional event failure: event.success { yay! }; event.failure { oops! }
++ events on stack don't care about other events above/below - event A, currently executing, can create/dispatch/finish another event B"
 
   s.rubyforge_project = "seh"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: seh
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,31 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-06-15 00:00:00.000000000Z
+date: 2011-06-16 00:00:00.000000000Z
 dependencies: []
-description: ''
+description: ! 'Pure ruby event handling similar to w3c dom events. Lots of bells
+  and whistles to support complex event handling as required by stuff like video games.
+
+  + event handling in a synchronous specific order
+
+  + event targets can have multiple parents and common ancestors; event propagation
+  does a breadth first search traversal over a directed acyclic event target graph
+
+  + staged callbacks: event.before { .. }; event.after { .. }
+
+  + staged callbacks allow for an ancestor to influence affect of event on a descendant:
+  ancestor.before { |event| event.x = 5 }; descendant.after { |event| puts event.x
+  }
+
+  + events can have multiple types, and types can inherit from other types
+
+  + bind callbacks using event type filtering: node.bind(overcast AND (rain OR snow))
+  { |event| callback! }
+
+  + optional event failure: event.success { yay! }; event.failure { oops! }
+
+  + events on stack don''t care about other events above/below - event A, currently
+  executing, can create/dispatch/finish another event B'
 email:
 - ryan.berckmans@gmail.com
 executables: []
@@ -53,5 +75,5 @@ rubyforge_project: seh
 rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
-summary: event handling similar to w3c dom events; pre-alpha wip
+summary: pure ruby event handling similar to w3c dom events; pre-alpha wip
 test_files: []