volute 0.1.0 → 0.1.1

data/lib/volute.rb

@@ -22,9 +22,12 @@
 # Made in Japan.
 #++
 
+
+# TODO : insert lengthy explanation here
+#
 module Volute
 
-  VOLUTE_VERSION = '0.1.0'
+  VOLUTE_VERSION = '0.1.1'
 
   #
   # adding class methods to target classes
@@ -65,7 +68,7 @@ module Volute
 
     previous_value = volute_get(key)
     vset(key, value)
-    Volute.root_eval(self, key, previous_value, value)
+    Volute.apply(self, key, previous_value, value)
 
     value
   end
@@ -73,28 +76,94 @@ module Volute
   #
   # Volute class methods
 
-  def self.<<(block)
+  def self.register(args, block)
 
-    (@top ||= []) << block
+    top << [ args, block ]
   end
 
   # Nukes all the top level volutes.
   #
   def self.clear!
 
-    (@top = [])
+    @top = nil
   end
 
-  def self.root_eval(object, attribute, previous_value, value)
+  # Volute.apply is generally called from the setter of a class which include
+  # Volute, but it's OK to call it directly, to force volute application.
+  #
+  #   class Engine
+  #     attr_accessor :state
+  #     def turn_key!
+  #       @key_turned = true
+  #       Volute.apply(self, :key_turned)
+  #     end
+  #     def press_red_button!
+  #       Volute.apply(self)
+  #     end
+  #   end
+  #
+  #   volute Engine do
+  #     if attribute == :key_turned
+  #       object.state = :running
+  #     else
+  #       object.state = :off
+  #     end
+  #   end
+  #
+  def self.apply(object, attribute=nil, previous_value=nil, value=nil)
 
     target = Target.new(object, attribute, previous_value, value)
 
-    (@top || []).each { |args, block| target.volute(*args, &block) }
+    top.each { |args, block| target.volute(*args, &block) }
+  end
+
+  def self.top
+
+    (@top ||= VoluteArray.new)
   end
 
   #
   # some classes
 
+  # Subclassing Array to add a #filter and a #remove method, so that
+  # things like
+  #
+  #   all_the_volutes = volutes
+  #   volutes_about_class_x = volutes(x)
+  #
+  #   volutes.remove(x)
+  #     # just removed all the volutes referring class or attribute x
+  #
+  class VoluteArray < Array
+
+    def filter(arg)
+
+      select { |args, block|
+
+        classes = args.select { |a| a.is_a?(Class) }
+
+        if args.include?(arg)
+          true
+        elsif arg.is_a?(Class)
+          (arg.ancestors & classes).size > 0
+        elsif arg.is_a?(Module)
+          (arg.constants.collect { |c| arg.const_get(c) } & classes).size > 0
+        #elsif arg.is_a?(Symbol)
+          # already handled by the initial if
+        else
+          false
+        end
+      }
+    end
+
+    def remove(arg)
+
+      filtered = filter(arg)
+
+      reject! { |volute| filtered.include?(volute) }
+    end
+  end
+
   class Target
 
     attr_reader :object, :attribute, :previous_value, :value
@@ -112,7 +181,9 @@ module Volute
     def volute(*args, &block)
 
       return if @over
-      return unless match?(args)
+
+      match = (args.first == :not) ? ( ! match?(args[1..-1])) : match?(args)
+      return unless match
 
       self.instance_eval(&block)
     end
@@ -122,50 +193,106 @@ module Volute
       @over = true
     end
 
-    #def is(val)
-    #  val == value
-    #end
-    #def was(val)
-    #  val == previous_value
-    #end
-
     protected
 
-    def match? (args)
+    def match?(args)
+
+      return true if args.empty?
+
+      return state_match?(args) if is_a_state_match?(args)
 
       classes = args.select { |a| a.is_a?(Class) }
       args.select { |a| a.is_a?(Module) }.each { |m|
         classes.concat(m.constants.collect { |c| m.const_get(c) })
       }
-      if classes.size > 0 && (classes & object.class.ancestors).empty?
-        return false
-      end
+      return true if (classes & @object.class.ancestors).size > 0
 
       atts = args.select { |a| a.is_a?(Symbol) }
-      if atts.size > 0 && ( ! atts.include?(attribute.to_sym))
-        return false
+      return true if atts.include?(attribute.to_sym)
+
+      atts = args.select { |a| a.is_a?(Regexp) }
+      return true if atts.find { |r| r.match(attribute.to_s) }
+
+      return transition_match?(args.last) if args.last.is_a?(Hash)
+
+      false
+    end
+
+    def has_attribute?(att)
+
+      return false if att == :any
+
+      #m = @object.method(att) rescue nil
+      #return false unless m
+      #return false if m.arity != -1
+        # arity would be -1 on ruby 1.8.7 and 0 on ruby 1.9.1, ...
+
+      begin
+        @object.send(att)
+        true
+      rescue NoMethodError => nme
+        false
       end
+    end
 
-      opts = args.last.is_a?(Hash) ? args.pop : {}
+    def is_a_state_match?(args)
 
-      return true if opts.empty?
+      state = args.first
+
+      return false if args.length != 1
+      return false unless state.is_a?(Hash)
+      return false if state.keys.find { |arg| ! arg.is_a?(Symbol) }
+      return false if state.keys.find { |att| ! has_attribute?(att) }
+      true
+    end
 
-      opts.inject(false) do |b, (k, v)|
-        b || (
-          (k == :any || k == previous_value) &&
-          (v == :any || v == value)
-        )
+    def val_match?(target, current, in_array=false)
+
+      return true if target == current
+      return true if target == :any
+      return current != nil if target == :not_nil
+
+      if target.is_a?(Regexp) && current.is_a?(String)
+        return target.match(current)
+      end
+      if in_array == false && target.is_a?(Array)
+        return target.find { |t| val_match?(t, current, true) }
       end
 
-    #rescue Exception => e
-    #  p e
-    #  e.backtrace.each { |l| p l }
+      false
+    end
+
+    def state_match?(args)
+
+      args.first.each do |att, target_val|
+        return false unless val_match?(target_val, @object.send(att))
+      end
+      true
+    end
+
+    def transition_match?(hash)
+
+      hash.each do |startv, endv|
+        if val_match?(startv, previous_value) && val_match?(endv, value)
+          return true
+        end
+      end
+      false
     end
   end
 end
 
+# Registers a 'volute' at the top level (ie a volute not nested into another)
+#
 def volute(*args, &block)
 
-  Volute << [ args, block ]
+  Volute.register(args, block)
+end
+
+# With no arguments, it will list all the top-level volutes.
+#
+def volutes(arg=nil)
+
+  arg ? Volute.top.filter(arg) : Volute.top
 end
 

data/spec/apply_spec.rb

@@ -0,0 +1,52 @@
+
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+
+class Engine
+  attr_accessor :state
+
+  def turn_key!
+    @key_turned = true
+    Volute.apply(self, :key_turned)
+  end
+
+  def press_red_button!
+    Volute.apply(self)
+  end
+end
+
+
+describe 'Volute.apply' do
+
+  before(:each) do
+
+    Volute.clear!
+
+    volute Engine do
+      if attribute == :key_turned
+        object.state = :running
+      else
+        object.state = :off
+      end
+    end
+
+    @engine = Engine.new
+
+    volute Package do
+      volute do
+        over if object.delivered
+      end
+      volute :location do
+        (object.comment ||= []) << value
+      end
+    end
+  end
+
+  it 'should apply volutes' do
+
+    @engine.turn_key!
+
+    @engine.state.should == :running
+  end
+end
+

data/spec/filter_not_spec.rb

@@ -0,0 +1,58 @@
+
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+
+describe 'a volute with a :not as first arg' do
+
+  before(:each) do
+
+    @item = Item.new
+    @invoice = Invoice.new
+  end
+
+  describe 'and classes as further args' do
+
+    before(:each) do
+
+      Volute.clear!
+
+      volute :not, Item do
+        object.comment = 'not an item'
+      end
+    end
+
+    it 'should not affect the negated class' do
+
+      @item.weight = '12 pounds'
+
+      @item.comment.should == nil
+    end
+
+    it 'should affect other classes' do
+
+      @invoice.paid = true
+
+      @invoice.comment.should == 'not an item'
+    end
+  end
+
+  describe 'and nothing else' do
+
+    before(:each) do
+
+      Volute.clear!
+
+      volute :not do
+        object.comment = 'NEVER !'
+      end
+    end
+
+    it 'should never trigger' do
+
+      @item.weight = '1kg'
+
+      @item.comment.should == nil
+    end
+  end
+end
+

data/spec/{volute_guard_spec.rb → filter_spec.rb}

@@ -126,64 +126,92 @@ describe 'a volute for an attribute' do
   end
 end
 
-describe 'transition volutes' do
+describe 'a volute for a class or an attribute' do
 
   before(:each) do
 
     Volute.clear!
 
+    @item = Item.new
     @package = Package.new
-    @package.vset(:location, 'NRT')
 
-    volute :location, :any => 'SFO' do
-      object.comment = 'reached SFO'
-    end
-    volute :location, 'NRT' => 'SFO' do
-      object.comment = 'reached SFO from NRT'
-    end
-    volute 'NRT' => 'FCO' do
-      object.comment = 'reached FCO from NRT'
-    end
-    volute 'GVA' => :any do
-      object.comment = 'left GVA'
+    volute Item, :delivered do
+      object.comment = 'Item, :delivered'
     end
   end
 
-  it 'should not trigger when not specified' do
+  it 'should not trigger inappropriately' do
 
-    @package.location = 'ZRH'
+    @package.location = 'Baden Baden'
 
     @package.comment.should == nil
   end
 
-  it 'should trigger for an end state' do
+  it 'should trigger for the class' do
+
+    @item.weight = :heavy
 
-    @package.vset(:location, 'ZRH')
-    @package.location = 'SFO'
+    @item.comment.should == 'Item, :delivered'
+  end
+
+  it 'should trigger for the attribute' do
+
+    @package.delivered = true
 
-    @package.comment.should == 'reached SFO'
+    @package.comment.should == 'Item, :delivered'
   end
+end
 
-  it 'should trigger for an attribute, a start state and an end state' do
+describe 'a volute for a class' do
 
-    @package.location = 'SFO'
+  before(:each) do
+
+    Volute.clear!
 
-    @package.comment.should == 'reached SFO from NRT'
+    @item = Item.new
+    @heavy_item = HeavyItem.new
+
+    volute Item do
+      (object.comment ||= []) << 'regular'
+    end
+    volute HeavyItem do
+      (object.comment ||= []) << 'heavy'
+    end
   end
 
-  it 'should trigger for a start state and an end state' do
+  it 'should trigger for a child class' do
 
-    @package.location = 'FCO'
+    @heavy_item.delivered = true
 
-    @package.comment.should == 'reached FCO from NRT'
+    @heavy_item.comment.should == [ 'regular', 'heavy' ]
+  end
+end
+
+describe 'a volute with a regex arg' do
+
+  before(:each) do
+
+    Volute.clear!
+
+    @invoice = Invoice.new
+
+    volute /^customer_/ do
+      object.comment = 'set on customer_ attribute called'
+    end
+  end
+
+  it 'should not trigger for attributes whose name doesn\'t match' do
+
+    @invoice.paid = true
+
+    @invoice.comment.should == nil
   end
 
-  it 'should trigger for a start state' do
+  it 'should trigger for attributes whose name matches' do
 
-    @package.vset(:location, 'GVA')
-    @package.location = 'CAL'
+    @invoice.customer_name = 'tojo'
 
-    @package.comment.should == 'left GVA'
+    @invoice.comment.should == 'set on customer_ attribute called'
   end
 end