alter-ego 1.0.0 → 1.0.1

data/History.txt

@@ -1,3 +1,9 @@
+== 1.0.1 2009-07-19
+
+* 2 minor enhancements:
+  * Removed dependency on ActiveSupport
+  * Removed old internal version of HookR
+
 == 1.0.0 2008-11-28
 
 * 1 major enhancement:

data/Manifest.txt

@@ -5,8 +5,6 @@ README.rdoc
 State_Design_Pattern_UML_Class_Diagram.png
 Rakefile
 TODO
-lib/assertions.rb
-spec/assertions_spec.rb
 lib/alter_ego.rb
 script/console
 script/destroy
@@ -14,6 +12,4 @@ script/generate
 spec/spec.opts
 spec/spec_helper.rb
 spec/alter_ego_spec.rb
-lib/alter_ego.rb
-spec/alter_ego_spec.rb
 tasks/rspec.rake

data/Rakefile

@@ -8,7 +8,8 @@ $hoe = Hoe.new('alter-ego', AlterEgo::VERSION) do |p|
   p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
   p.rubyforge_name       = p.name # TODO this is default value
   p.extra_deps         = [
-    ['activesupport','>= 2.0.2'],
+    ['fail-fast',    '~> 1.1.0'],
+    ['hookr',        '~> 1.0.0']
   ]
   p.extra_dev_deps = [
     ['newgem', ">= #{::Newgem::VERSION}"]
@@ -29,3 +30,5 @@ Dir['tasks/**/*.rake'].each { |t| load t }
 task :docs do |task|
   cp "State_Design_Pattern_UML_Class_Diagram.png", "doc"
 end
+
+task :default => :spec

data/TODO

@@ -1,4 +1,6 @@
-* TODO Factor assertions out into separate library
+# -*- mode: org -*-
+* DONE Factor assertions out into separate library
+  CLOSED: [2008-11-29 Sat 01:29]
 * TODO Remove ActiveSupport dependency
 * TODO Nested state support with history
 * TODO Verify full methods/respond_to? integration

data/lib/alter_ego.rb

@@ -1,16 +1,19 @@
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-require File.join(File.dirname(__FILE__), 'assertions')
+gem 'hookr',     "~> 1.0.0"
+gem 'fail-fast', "~> 1.1.0"
+
 require 'forwardable'
 require 'singleton'
 require 'rubygems'
-require 'activesupport'
+require 'fail_fast'
+require 'hookr'
 
 module AlterEgo
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 
-  include Assertions
+  include FailFast::Assertions
 
   class StateError < RuntimeError
   end
@@ -69,12 +72,31 @@ module AlterEgo
     end
   end
 
+  # A customization of HookR::Hook to deal with the fact that State internal
+  # callbacks need to be executed in the context of the state's context, not the
+  # state object itself.
+  class StateHook < HookR::Hook
+    class StateContextCallback < HookR::InternalCallback
+      def call(event)
+        context = event.arguments.first
+        context.instance_eval(&block)
+      end
+    end
+
+    # Add an internal callback that executes in the context of the state
+    # context, instead of the state itself
+    def add_internal_callback(handle=nil, &block)
+      add_block_callback(StateContextCallback, handle, &block)
+    end
+  end
+
   class State
-    include Assertions
-    extend Assertions
+    include FailFast::Assertions
+    extend FailFast::Assertions
+    include HookR::Hooks
 
     def self.transition(options, &trans_action)
-      options.assert_valid_keys(:to, :on, :if)
+      assert_only_keys(options, :to, :on, :if)
       assert_keys(options, :to)
       guard    = options[:if]
       to_state = options[:to]
@@ -120,14 +142,8 @@ module AlterEgo
       define_contextual_method_from_symbol_or_block(request, method, &block)
     end
 
-    def self.on_enter(method = nil, &block)
-      assert(method.nil? ^ block.nil?)
-      define_contextual_method_from_symbol_or_block(:on_enter, method, &block)
-    end
-
-    def self.on_exit(method = nil, &block)
-      assert(method.nil? ^ block.nil?)
-      define_contextual_method_from_symbol_or_block(:on_exit, method, &block)
+    def self.make_hook(name, parent, params)
+      ::AlterEgo::StateHook.new(name, parent, params)
     end
 
     def valid_transitions
@@ -164,39 +180,31 @@ module AlterEgo
                                                  new_state)
       return false unless continue
 
-      if (not valid_transitions.empty?) and (not valid_transitions.include?(new_state))
+      unless valid_transitions.empty? || valid_transitions.include?(new_state)
         raise(InvalidTransitionError,
               "Not allowed to transition from #{self.identifier} to #{new_state}")
       end
 
-      on_exit(context)
-      new_state_obj.on_enter(context)
-      context.state=(new_state)
+      execute_hook(:on_exit, context)
+      new_state_obj.execute_hook(:on_enter, context)
+      context.state = new_state
       assert(new_state == context.state)
       true
     end
 
     protected
 
-    def on_exit(context)
-    end
-
-    def on_enter(context)
-    end
+    define_hook :on_enter, :context
+    define_hook :on_exit,  :context
 
     private
 
     def self.add_request_filter(request_pattern, new_state_pattern, action)
-      new_filter = RequestFilter.new(identifier,
-                                     request_pattern,
-                                     new_state_pattern,
-                                     action)
+      new_filter = RequestFilter.new(identifier, request_pattern, new_state_pattern, action)
       self.request_filters << new_filter
     end
 
-    def self.define_contextual_method_from_symbol_or_block(name,
-                                                           symbol,
-                                                           &block)
+    def self.define_contextual_method_from_symbol_or_block(name, symbol, &block)
       if symbol
         define_method(name) do |context, *args|
            context.send(symbol, *args)
@@ -207,9 +215,11 @@ module AlterEgo
         end
       end
     end
-end
+  end
 
   module ClassMethods
+    include FailFast::Assertions
+
     def state(identifier, options={}, &block)
       if states.has_key?(identifier)
         raise InvalidDefinitionError, "State #{identifier.inspect} already defined"
@@ -223,7 +233,7 @@ end
     end
 
     def request_filter(options, &block)
-      options.assert_valid_keys(:state, :request, :new_state, :action)
+      assert_only_keys(options, :state, :request, :new_state, :action)
       options = {
         :state     => not_nil,
         :request   => not_nil,
@@ -250,7 +260,7 @@ end
     end
 
     def add_state(new_state, identifier=new_state.identifier, options = {})
-      options.assert_valid_keys(:default)
+      assert_only_keys(options, :default)
 
       self.states[identifier] = new_state.new
 
@@ -314,7 +324,7 @@ end
       AlterEgo::NotNilMatcher.instance
     end
 
-  end
+  end                           # End ClassMethods
 
   def self.append_features(klass)
     # Give the other module my instance methods at the class level

data/spec/alter_ego_spec.rb

@@ -472,7 +472,7 @@ describe TrafficLightWithRedCountdown, "that is yellow" do
     @it.cycle
   end
 
-  it "should raise an error if #seconds_till_red is called" do
+  it "should not raise an error when #seconds_till_red is called" do
     lambda do
       @it.seconds_till_red
     end.should_not raise_error

metadata

@@ -1,46 +1,36 @@
 --- !ruby/object:Gem::Specification 
 name: alter-ego
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors: 
 - Avdi Grimm
 autorequire: 
 bindir: bin
-cert_chain: 
-- |
-  -----BEGIN CERTIFICATE-----
-  MIIDKDCCAhCgAwIBAgIBADANBgkqhkiG9w0BAQUFADA6MQ0wCwYDVQQDDARhdmRp
-  MRQwEgYKCZImiZPyLGQBGRYEYXZkaTETMBEGCgmSJomT8ixkARkWA29yZzAeFw0w
-  ODExMjYwMzQwMTBaFw0wOTExMjYwMzQwMTBaMDoxDTALBgNVBAMMBGF2ZGkxFDAS
-  BgoJkiaJk/IsZAEZFgRhdmRpMRMwEQYKCZImiZPyLGQBGRYDb3JnMIIBIjANBgkq
-  hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxp+TCbzj+cyaiE1xAqxO+irHbdNF+9y4
-  rZF3gCs0wfIcqeKDIvlks7FvH0Qj6yiAj8YHUgmuLORat2IBLBmX/G+G0Z2L6MLs
-  bNwx4YpbTW1cwOFVENSWwNjsvY68/I/EpAeRdtiskG/J33TDxi427dyBDSHsrQ8J
-  4oC24EnKwsTOdHwkEaDEmZJQeo5ienR7dalAwIPCIm4tA41kbilLVpMVp0f1hn5o
-  cVFYZgJFOdNnggVO9B/0/doQhxvC4Jdj2XeoOdIkjul1VjCeF+s+i/PhnKk/Y0++
-  /9fBCqzfFHYay5TOtTLDlzc7WoN5NBtKChn1gG0AnD+mJ4EnjvgTIQIDAQABozkw
-  NzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUen5OQUuU+3P6OyVZ
-  NsrtAIO7DQcwDQYJKoZIhvcNAQEFBQADggEBAGwXuO2cpDc9m8iJmmbSjnDhhQYL
-  OssAG5bMy88JnrD+KufXA4BKvLTLkNtTSaNFvL74+FSIK8VwCUpEyn8rsYi3s6N8
-  /f5+5LDg19Jm6dmkRgFGQjF8cW0PheDtlY0Ywo+wdUhD+LFH+2VanZNx2dz6IjSh
-  A0uvcb+roaNG70ESPvoJO4PZFCkrgS2QE9TwnhRLi1DONaGmbMYWSZku4tHFEu+R
-  B/QQd37jgRGtEcplcoMaoCOqAvlIu6QkQt4X3jVhNGqeF2Wgmb1QXEF8cH/hqX4T
-  NNbtubu/GbyYwC2cb3Clh5gMrAYS765Q8U2aySfRySAFaQyPub+h0uVWkIc=
-  -----END CERTIFICATE-----
+cert_chain: []
 
-date: 2008-11-28 00:00:00 -05:00
+date: 2009-07-19 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: fail-fast
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hookr
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: 2.0.2
+        version: 1.0.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: newgem
@@ -50,7 +40,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.0
+        version: 1.3.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
@@ -82,8 +72,6 @@ files:
 - State_Design_Pattern_UML_Class_Diagram.png
 - Rakefile
 - TODO
-- lib/assertions.rb
-- spec/assertions_spec.rb
 - lib/alter_ego.rb
 - script/console
 - script/destroy
@@ -115,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: alter-ego
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: AlterEgo is a Ruby implementation of the State pattern as described by the Gang of Four

data/lib/assertions.rb

@@ -1,63 +0,0 @@
-class AssertionFailureError < Exception
-end
-
-module Assertions
-
-  # Assert that no +values+ are nil or false.  Returns the last value.
-  def assert(*values, &block)
-    iterate_and_return_last(values, block) do |v|
-      raise_assertion_error unless v
-    end
-  end
-
-  # The opposite of #assert.
-  def deny(*values)
-    assert(*values.map{ |v| !v})
-    assert(yield(*values)) if block_given?
-    values.last
-  end
-
-  # Assert that no +values+ are nil.  Returns the last value.
-  def assert_exists(*values, &block)
-    iterate_and_return_last(values, block) {  |value| deny(value.nil?) }
-  end
-
-  # Assert that +values+ are collections that contain at least one element.
-  # Returns the last value.
-  def assert_one_or_more(*values, &block)
-    iterate_and_return_last(values, block) do |value|
-      assert_exists(value)
-      deny(value.kind_of?(String))
-      deny(value.empty?)
-    end
-  end
-
-  def assert_keys(hash, *keys)
-    assert_exists(hash)
-    assert(hash.respond_to?(:[]))
-    values = keys.inject([]) { |vals, k| vals << assert_exists(hash[k]) }
-    assert(yield(*values)) if block_given?
-    hash
-  end
-
-  private
-
-  def iterate_and_return_last(values, block = nil)
-    values.each { |v| yield(v) }
-    if block
-      raise_assertion_error unless block.call(*values)
-    end
-    values.last
-  end
-
-  def raise_assertion_error
-    error = AssertionFailureError.new
-    backtrace = caller
-    trimmed_backtrace = []
-    trimmed_backtrace.unshift(backtrace.pop) until
-      backtrace.last.include?(__FILE__)
-    error.set_backtrace(trimmed_backtrace)
-    raise error
-  end
-
-end

data/spec/assertions_spec.rb

@@ -1,284 +0,0 @@
-require File.expand_path('spec_helper', File.dirname(__FILE__))
-
-module AssertionsSpecHelper
-  def do_success(&block)
-    do_assertion(@success_values.first, &block)
-  end
-  def do_failure(&block)
-    do_assertion(@failure_values.first, &block)
-  end
-end
-
-describe "any assertion", :shared => true do
-  it "on failure, should raise an exception with trimmed backtrace" do
-    begin
-      do_failure
-    rescue AssertionFailureError => e
-      e.backtrace.first.should include(__FILE__)
-    end
-  end
-end
-
-describe "a basic assertion", :shared => true do
-  it "should raise AssertionFailureError when it fails" do
-    @failure_values.each do |value|
-      lambda do
-        do_assertion(value)
-      end.should raise_error(AssertionFailureError)
-    end
-  end
-
-  it "should not raise an exception when it succeeds" do
-    @success_values.each do |value|
-      lambda do
-        do_assertion(value)
-      end.should_not raise_error
-    end
-  end
-
-  it "should return its argument on success" do
-    @success_values.each do |value|
-      do_assertion(value).should equal(value)
-    end
-  end
-
-end
-
-describe "an assertion taking a block", :shared => true do
-  it "should fail if the block result is not true" do
-    lambda do
-      do_success { false }
-    end.should raise_error(AssertionFailureError)
-  end
-end
-
-describe "an assertion yielding passed values", :shared => true do
-
-  it_should_behave_like "an assertion taking a block"
-
-  it "should yield values that pass the test" do
-    @success_values.each do |value|
-      did_yield = false
-      do_assertion(value) do |yielded_value|
-        did_yield = true
-        yielded_value.should equal(value)
-        true
-      end
-      did_yield.should be_true
-    end
-  end
-
-  it "should not yield values that fail the test" do
-    @failure_values.each do |value|
-      did_yield = false
-      lambda do
-        do_assertion(value) do |yielded_value|
-          did_yield = true
-        end
-      end.should raise_error(AssertionFailureError)
-      did_yield.should be_false
-    end
-  end
-
-end
-
-describe "an assertion taking multiple values", :shared => true do
-  def gather_arguments(values)
-    args = []
-    # gather 3 arguments
-    3.times do |i|
-      args[i] = values[i % values.size]
-    end
-    args
-  end
-
-  it "should not raise error if all values succeed test" do
-    values = gather_arguments(@success_values)
-    lambda { do_assertion(*values) }.should_not raise_error
-  end
-
-  it "should raise error if all values fail test" do
-    values = gather_arguments(@failure_values)
-    lambda { do_assertion(*values) }.should raise_error(AssertionFailureError)
-  end
-
-  it "should raise error if one values fails test" do
-    values = gather_arguments(@success_values)
-    values[1] = @failure_values.first
-    lambda { do_assertion(*values) }.should raise_error(AssertionFailureError)
-  end
-
-  it "should return the last argument on success" do
-    values = gather_arguments(@success_values)
-    do_assertion(*values).should equal(values.last)
-  end
-
-end
-
-describe Assertions, "#assert" do
-
-  include Assertions
-  include AssertionsSpecHelper
-
-  def do_assertion(*args, &block)
-    assert(*args, &block)
-  end
-
-  before :each do
-    @success_values      = [true, "", 0]
-    @failure_values      = [false, nil]
-  end
-
-  it_should_behave_like "any assertion"
-  it_should_behave_like "a basic assertion"
-  it_should_behave_like "an assertion taking multiple values"
-  it_should_behave_like "an assertion yielding passed values"
-end
-
-describe Assertions, "#assert_exists" do
-
-  include Assertions
-  include AssertionsSpecHelper
-
-  def do_assertion(*args, &block)
-    assert_exists(*args, &block)
-  end
-
-  before :each do
-    @success_values = ["foo", 123, false]
-    @failure_values = [nil]
-  end
-
-  it_should_behave_like "any assertion"
-  it_should_behave_like "a basic assertion"
-  it_should_behave_like "an assertion taking multiple values"
-  it_should_behave_like "an assertion yielding passed values"
-
-end
-
-describe Assertions, "#assert_one_or_more" do
-
-  include Assertions
-  include AssertionsSpecHelper
-
-  def do_assertion(*args, &block)
-    assert_one_or_more(*args, &block)
-  end
-
-  before :each do
-    @success_values = [[1], {:foo => :bar }]
-    @failure_values = [nil, [], "foo"]
-  end
-
-  it_should_behave_like "any assertion"
-  it_should_behave_like "a basic assertion"
-  it_should_behave_like "an assertion taking multiple values"
-  it_should_behave_like "an assertion yielding passed values"
-end
-
-describe Assertions, "#deny" do
-
-  include Assertions
-  include AssertionsSpecHelper
-
-  def do_assertion(*args, &block)
-    deny(*args, &block)
-  end
-
-  before :each do
-    @success_values = [false, nil]
-    @failure_values = [true, "", 0]
-  end
-
-  it_should_behave_like "any assertion"
-  it_should_behave_like "a basic assertion"
-  it_should_behave_like "an assertion taking multiple values"
-  it_should_behave_like "an assertion yielding passed values"
-end
-
-describe Assertions, "#assert_keys" do
-
-  include Assertions
-
-  def do_assertion(*args, &block)
-    assert_keys(*args, &block)
-  end
-
-  def do_success(&block)
-    assert_keys({}, &block)
-  end
-
-  def do_failure(&block)
-    assert_keys({}, :foo, &block)
-  end
-
-  it_should_behave_like "any assertion"
-  it_should_behave_like "an assertion taking a block"
-
-  it "should fail if a specified key does not exist" do
-    lambda { assert_keys({}, :foo) }.should raise_error(AssertionFailureError)
-  end
-
-  it "should fail if a specified key is nil" do
-    lambda do
-      assert_keys({:foo => nil}, :foo)
-    end.should raise_error(AssertionFailureError)
-  end
-
-  it "should fail if any of the specified keys are nil" do
-    lambda do
-      assert_keys({:foo => true, :bar => nil}, :foo, :bar)
-    end.should raise_error(AssertionFailureError)
-  end
-
-  it "should fail if the given hash is nil" do
-    lambda do
-      assert_keys(nil)
-    end.should raise_error(AssertionFailureError)
-  end
-
-  it "should fail if given something unlike a hash" do
-    lambda do
-      assert_keys(true)
-    end.should raise_error(AssertionFailureError)
-  end
-
-  it "should succeed if no keys are given" do
-    lambda do
-      assert_keys({:foo => true, :bar => nil})
-    end.should_not raise_error
-  end
-
-  it "should yield key values if they all exist" do
-    did_yield = false
-    assert_keys({:foo => 23, :bar => 32}, :foo, :bar) do |x, y|
-      did_yield = true
-      x.should == 23
-      y.should == 32
-      true
-    end
-    did_yield.should be_true
-  end
-
-  it "should yield nothing if a key is missing" do
-    begin
-      did_yield = false
-      assert_keys({:foo => 23, :bar => 32}, :foo, :bar) do |x, y|
-        did_yield = true
-      end
-    rescue AssertionFailureError
-      did_yield.should be_false
-    end
-  end
-
-  it "should return the hash" do
-    @hash = { :buz => 42 }
-    assert_keys(@hash, :buz).should equal(@hash)
-  end
-end
-
-describe AssertionFailureError do
-  it "should derive from Exception" do
-    AssertionFailureError.superclass.should equal(Exception)
-  end
-end

metadata.gz.sig

@@ -1,2 +0,0 @@
-�?(��(��y�c.�#�~�Z��+�p��8���!W�J!S���N"�t>4]��-

��g��xG�=�F\
-Y�ɏ�m�(�;���.��>e"���>O