state_machine 1.0.1 → 1.0.2

data/lib/state_machine/condition_proxy.rb

@@ -1,94 +0,0 @@
-require 'state_machine/eval_helpers'
-
-module StateMachine
-  # Represents a type of module in which class-level methods are proxied to
-  # another class, injecting a custom <tt>:if</tt> condition along with method.
-  # 
-  # This is used for being able to automatically include conditionals which
-  # check the current state in class-level methods that have configuration
-  # options.
-  # 
-  # == Examples
-  # 
-  #   class Vehicle
-  #     class << self
-  #       attr_accessor :validations
-  #       
-  #       def validate(options, &block)
-  #         validations << options
-  #       end
-  #     end
-  #     
-  #     self.validations = []
-  #     attr_accessor :state, :simulate
-  #     
-  #     def moving?
-  #       self.class.validations.all? {|validation| validation[:if].call(self)}
-  #     end
-  #   end
-  # 
-  # In the above class, a simple set of validation behaviors have been defined.
-  # Each validation consists of a configuration like so:
-  # 
-  #   Vehicle.validate :unless => :simulate
-  #   Vehicle.validate :if => lambda {|vehicle| ...}
-  # 
-  # In order to scope conditions, a condition proxy can be created to the
-  # Vehicle class.  For example,
-  # 
-  #   proxy = StateMachine::ConditionProxy.new(Vehicle, lambda {|vehicle| vehicle.state == 'first_gear'})
-  #   proxy.validate(:unless => :simulate)
-  #   
-  #   vehicle = Vehicle.new     # => #<Vehicle:0xb7ce491c @simulate=nil, @state=nil>
-  #   vehicle.moving?           # => false
-  #   
-  #   vehicle.state = 'first_gear'
-  #   vehicle.moving?           # => true
-  #   
-  #   vehicle.simulate = true
-  #   vehicle.moving?           # => false
-  class ConditionProxy < Module
-    include EvalHelpers
-    
-    # Creates a new proxy to the given class, merging in the given condition
-    def initialize(klass, condition)
-      @klass = klass
-      @condition = condition
-    end
-    
-    # Hooks in condition-merging to methods that don't exist in this module
-    def method_missing(*args, &block)
-      # Get the configuration
-      if args.last.is_a?(Hash)
-        options = args.last
-      else
-        args << options = {}
-      end
-      
-      # Get any existing condition that may need to be merged
-      if_condition = options.delete(:if)
-      unless_condition = options.delete(:unless)
-      
-      # Provide scope access to configuration in case the block is evaluated
-      # within the object instance
-      proxy = self
-      proxy_condition = @condition
-      
-      # Replace the configuration condition with the one configured for this
-      # proxy, merging together any existing conditions
-      options[:if] = lambda do |*args|
-        # Block may be executed within the context of the actual object, so
-        # it'll either be the first argument or the executing context
-        object = args.first || self
-        
-        proxy.evaluate_method(object, proxy_condition) &&
-        Array(if_condition).all? {|condition| proxy.evaluate_method(object, condition)} &&
-        !Array(unless_condition).any? {|condition| proxy.evaluate_method(object, condition)}
-      end
-      
-      # Evaluate the method on the original class with the condition proxied
-      # through
-      @klass.send(*args, &block)
-    end
-  end
-end

data/test/unit/condition_proxy_test.rb

@@ -1,328 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-class Validateable
-  class << self
-    def validate(*args, &block)
-      args << block if block_given?
-      args
-    end
-  end
-end
-
-class ConditionProxyTest < Test::Unit::TestCase
-  def test_should_call_class_with_same_arguments
-    options = {}
-    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {})
-    validation = condition_proxy.validate(:name, options)
-    
-    assert_equal [:name, options], validation
-  end
-  
-  def test_should_pass_block_through_to_class
-    options = {}
-    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {})
-    
-    proxy_block = lambda {}
-    validation = condition_proxy.validate(:name, options, &proxy_block)
-    
-    assert_equal [:name, options, proxy_block], validation
-  end
-  
-  def test_should_pass_object_into_proxy_condition
-    condition_args = []
-    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {|*args| condition_args = args})
-    options = condition_proxy.validate[0]
-    
-    object = Validateable.new
-    options[:if].call(object)
-    
-    assert_equal [object], condition_args
-  end
-  
-  def test_should_evaluate_symbol_condition
-    klass = Class.new(Validateable) do
-      attr_accessor :callback_called
-      
-      def callback
-        @callback_called = true
-      end
-    end
-    
-    condition_proxy = StateMachine::ConditionProxy.new(klass, :callback)
-    options = condition_proxy.validate[0]
-    
-    object = klass.new
-    options[:if].call(object)
-    
-    assert object.callback_called
-  end
-  
-  def test_should_evaluate_string_condition
-    klass = Class.new(Validateable) do
-      attr_accessor :callback_called
-    end
-    
-    condition_proxy = StateMachine::ConditionProxy.new(klass, '@callback_called = true')
-    options = condition_proxy.validate[0]
-    
-    object = klass.new
-    options[:if].call(object)
-    
-    assert object.callback_called
-  end
-end
-
-class ConditionProxyWithoutConditionsTest < Test::Unit::TestCase
-  def setup
-    @proxy_result = nil
-    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
-    
-    @object = Validateable.new
-    @options = condition_proxy.validate[0]
-  end
-  
-  def test_should_have_options_configuration
-    assert_instance_of Hash, @options
-  end
-  
-  def test_should_have_if_option
-    assert_not_nil @options[:if]
-  end
-  
-  def test_should_be_false_if_proxy_condition_is_false
-    @proxy_result = false
-    assert !@options[:if].call(@object)
-  end
-  
-  def test_should_be_true_if_proxy_condition_is_true
-    @proxy_result = true
-    assert @options[:if].call(@object)
-  end
-  
-  def test_should_be_true_if_proxy_condition_is_not_true
-    @proxy_result = 1
-    assert @options[:if].call(@object)
-  end
-end
-
-class ConditionProxyWithIfConditionTest < Test::Unit::TestCase
-  def setup
-    @proxy_result = nil
-    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
-    
-    @object = Validateable.new
-    
-    @condition_result = nil
-    @options = condition_proxy.validate(:if => lambda {@condition_result})[0]
-  end
-  
-  def test_should_have_if_option
-    assert_not_nil @options[:if]
-  end
-  
-  def test_should_be_false_if_proxy_condition_is_false
-    @proxy_result = false
-    assert !@options[:if].call(@object)
-  end
-  
-  def test_should_be_false_if_original_condition_is_false
-    @condition_result = false
-    assert !@options[:if].call(@object)
-  end
-  
-  def test_should_be_true_if_proxy_and_original_condition_are_true
-    @proxy_result = true
-    @condition_result = true
-    assert @options[:if].call(@object)
-  end
-  
-  def test_should_evaluate_symbol_condition
-    klass = Class.new(Validateable) do
-      attr_accessor :callback
-    end
-    
-    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
-    options = condition_proxy.validate(:if => :callback)[0]
-    
-    object = klass.new
-    object.callback = false
-    assert !options[:if].call(object)
-    
-    object.callback = true
-    assert options[:if].call(object)
-  end
-  
-  def test_should_evaluate_string_condition
-    klass = Class.new(Validateable) do
-      attr_accessor :callback
-    end
-    
-    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
-    options = condition_proxy.validate(:if => '@callback')[0]
-    
-    object = klass.new
-    object.callback = false
-    assert !options[:if].call(object)
-    
-    object.callback = true
-    assert options[:if].call(object)
-  end
-end
-
-class ConditionProxyWithMultipleIfConditionsTest < Test::Unit::TestCase
-  def setup
-    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {true})
-    
-    @object = Validateable.new
-    
-    @first_condition_result = nil
-    @second_condition_result = nil
-    @options = condition_proxy.validate(:if => [lambda {@first_condition_result}, lambda {@second_condition_result}])[0]
-  end
-  
-  def test_should_be_true_if_all_conditions_are_true
-    @first_condition_result = true
-    @second_condition_result = true
-    assert @options[:if].call(@object)
-  end
-  
-  def test_should_be_false_if_any_condition_is_false
-    @first_condition_result = true
-    @second_condition_result = false
-    assert !@options[:if].call(@object)
-    
-    @first_condition_result = false
-    @second_condition_result = true
-    assert !@options[:if].call(@object)
-  end
-end
-
-class ConditionProxyWithUnlessConditionTest < Test::Unit::TestCase
-  def setup
-    @proxy_result = nil
-    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
-    
-    @object = Validateable.new
-    
-    @condition_result = nil
-    @options = condition_proxy.validate(:unless => lambda {@condition_result})[0]
-  end
-  
-  def test_should_have_if_option
-    assert_not_nil @options[:if]
-  end
-  
-  def test_should_be_false_if_proxy_condition_is_false
-    @proxy_result = false
-    assert !@options[:if].call(@object)
-  end
-  
-  def test_should_be_false_if_original_condition_is_true
-    @condition_result = true
-    assert !@options[:if].call(@object)
-  end
-  
-  def test_should_be_true_if_proxy_is_true_and_original_condition_is_false
-    @proxy_result = true
-    @condition_result = false
-    assert @options[:if].call(@object)
-  end
-  
-  def test_should_evaluate_symbol_condition
-    klass = Class.new(Validateable) do
-      attr_accessor :callback
-    end
-    
-    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
-    options = condition_proxy.validate(:unless => :callback)[0]
-    
-    object = klass.new
-    object.callback = true
-    assert !options[:if].call(object)
-    
-    object.callback = false
-    assert options[:if].call(object)
-  end
-  
-  def test_should_evaluate_string_condition
-    klass = Class.new(Validateable) do
-      attr_accessor :callback
-    end
-    
-    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
-    options = condition_proxy.validate(:unless => '@callback')[0]
-    
-    object = klass.new
-    object.callback = true
-    assert !options[:if].call(object)
-    
-    object.callback = false
-    assert options[:if].call(object)
-  end
-end
-
-class ConditionProxyWithMultipleUnlessConditionsTest < Test::Unit::TestCase
-  def setup
-    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {true})
-    
-    @object = Validateable.new
-    
-    @first_condition_result = nil
-    @second_condition_result = nil
-    @options = condition_proxy.validate(:unless => [lambda {@first_condition_result}, lambda {@second_condition_result}])[0]
-  end
-  
-  def test_should_be_true_if_all_conditions_are_false
-    @first_condition_result = false
-    @second_condition_result = false
-    assert @options[:if].call(@object)
-  end
-  
-  def test_should_be_false_if_any_condition_is_true
-    @first_condition_result = true
-    @second_condition_result = false
-    assert !@options[:if].call(@object)
-    
-    @first_condition_result = false
-    @second_condition_result = true
-    assert !@options[:if].call(@object)
-  end
-end
-
-class ConditionProxyWithIfAndUnlessConditionsTest < Test::Unit::TestCase
-  def setup
-    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {true})
-    
-    @object = Validateable.new
-    
-    @if_condition_result = nil
-    @unless_condition_result = nil
-    @options = condition_proxy.validate(:if => lambda {@if_condition_result}, :unless => lambda {@unless_condition_result})[0]
-  end
-  
-  def test_should_be_false_if_if_condition_is_false
-    @if_condition_result = false
-    @unless_condition_result = false
-    assert !@options[:if].call(@object)
-    
-    @if_condition_result = false
-    @unless_condition_result = true
-    assert !@options[:if].call(@object)
-  end
-  
-  def test_should_be_false_if_unless_condition_is_true
-    @if_condition_result = false
-    @unless_condition_result = true
-    assert !@options[:if].call(@object)
-    
-    @if_condition_result = true
-    @unless_condition_result = true
-    assert !@options[:if].call(@object)
-  end
-  
-  def test_should_be_true_if_if_condition_is_true_and_unless_condition_is_false
-    @if_condition_result = true
-    @unless_condition_result = false
-    assert @options[:if].call(@object)
-  end
-end