davidlee-state-fu 0.3.1 → 0.10.0

data/spec/features/method_missing_only_once_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe "method_missing" do
+  include MySpecHelper
+  before do
+    make_pristine_class('Klass')
+    Klass.state_fu_machine() {}
+    @obj = Klass.new
+  end
+
+  it "should revert to the original method_missing after it is called once" do
+    mock.proxy( @obj ).state_fu!.times(1)
+    mm1 = @obj.method(:method_missing)
+    call_snafu = lambda do
+      begin
+        @obj.snafu!
+      rescue NoMethodError
+      end
+    end
+    call_snafu.call()
+    mm2 = @obj.method(:method_missing)
+    mm1.should_not == mm2
+    call_snafu.call()
+    mm3 = @obj.method(:method_missing)
+    mm3.should == mm2
+    # @obj.snafu
+  end
+end

data/spec/features/not_requirements_spec.rb

@@ -1,81 +1,118 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../helper")
 
 module RequirementFeatureHelper
-
-  def account_expired_test
-    false
+  def account_expired?
+    !! account_expired
   end
 
-  def valid_password_test
-    true
+  def valid_password?
+    !! valid_password
   end
+end
 
-  def account_expired?
-    !!account_expired_test
-  end
+# it_should_behave_like "!" do
+shared_examples_for "not requirements" do
+    describe "requirements with names beginning with no[t]_" do
+
+    it "should return the opposite of the requirement name without not_" do
+#      @obj.current_state.should == :guest
+      @obj.stfu.teleport! :anonymous
+      @obj.valid_password = false
+      @binding.can_has_valid_password?.should == false
+      @binding.can_has_not_valid_password?.should == true
+      @binding.can_has_no_valid_password?.should == true
+      @obj.valid_password = true
+      @binding.can_has_valid_password?.should == true
+      @binding.can_has_not_valid_password?.should == false
+      @binding.can_has_no_valid_password?.should == false
+    end
+
+    it "should call the method directly if one exists" do
+      @obj.valid_password = true
+      (class << @obj; self; end).class_eval do
+        define_method( :no_valid_password? ) { true }
+      end
+      @binding.can_has_valid_password?.should == true
+      @binding.can_has_not_valid_password?.should == false
+      @binding.can_has_no_valid_password?.should == true
+    end
 
-  def valid_password?
-    !!valid_password_test
   end
+
 end
 
-describe "requirement objects" do
-  include MySpecHelper
+describe "requirements" do
   before(:all) do
     reset!
     make_pristine_class('Klass')
-    Klass.machine do
-      helper RequirementFeatureHelper
-
+    Klass.class_eval do
+      attr_accessor :valid_password
+      attr_accessor :account_expired
+    end
+    @machine = StateFu::Machine.new do
       initial_state :guest
 
-      event :login_success, :from => :guest, :to => [:logged_in, :expired] do
+      event :has_valid_password, :from => :anonymous, :to => :logged_in do
         requires :valid_password?
       end
 
-      event :login_failure, :from => :guest, :to => :guest do
-        execute :show_error
-      end
-
-      state :logged_in do
-        requires :not_account_expired?
+      event :has_not_valid_password, :from => :anonymous, :to => :suspect do
+        requires :not_valid_password?
       end
 
-      state :expired do
-        requires :account_expired?
+      event :has_no_valid_password, :from => :anonymous, :to => :suspect do
+        requires :no_valid_password?
       end
+      
     end
-    @obj = Klass.new
-    @binding = @obj.state_fu
   end
 
-  describe "requirements with names beginning with not_" do
+  before :each do
+    @obj.valid_password = true
+    @obj.account_expired = false
+  end
+
+  describe "requirements defined with a machine helper" do
+    before :all do
+      @machine.lathe { helper RequirementFeatureHelper }
+      @machine.bind!(Klass, :default)
+      @obj     = Klass.new
+      @binding = @obj.state_fu
+    end
+
+    it_should_behave_like "not requirements"
 
-    it "should return the opposite of the requirement name without not_" do
+    it "should not have methods on the object" do
+      @obj.respond_to?(:valid_password?).should == false
+      @obj.respond_to?(:account_expired?).should == false
+    end
+
+    it "should have methods on the binding" do
+      # this is a little misleading because theyre not evaluated on the binding ..
       @binding.respond_to?(:valid_password?).should == true
+      @binding.respond_to?(:account_expired?).should == true
       @binding.respond_to?(:not_valid_password?).should == false
-      @binding.evaluate_named_proc_or_method( :valid_password? ).should == true
-      @binding.evaluate_named_proc_or_method( :not_valid_password? ).should == false
+      @binding.respond_to?(:not_account_expired?).should == false
     end
+  end
 
-    it "should call the method directly if one exists" do
-      mock( @binding ).not_valid_password?() { true }
-      @binding.evaluate_named_proc_or_method( :valid_password? ).should == true
-      @binding.evaluate_named_proc_or_method( :not_valid_password? ).should == true
+  describe "requirements defined on the object" do
+    before :all do
+      @machine.bind!(Klass, :default)
+      @obj = Klass.new
+      @binding = @obj.state_fu
+      Klass.class_eval do
+        include RequirementFeatureHelper
+      end
     end
 
-    it "should act as the opposite of requirement in guarding a transition" do
-      @binding.account_expired?.should == false
-      @binding.valid_password?.should == true
-      mock( @binding ).valid_password_test { false }
-      t = @binding.login_success(:logged_in)
-      t.requirements.should == [:not_account_expired?, :valid_password?]
-      t.unmet_requirements.should == [:valid_password?]
-      mock( @binding ).valid_password_test.times(2) { true }
-      t.unmet_requirements.should == []
-      @obj.login_success!(:logged_in).should == true
-      @binding.should == :logged_in
+    it_should_behave_like "not requirements"
+
+    it "should have methods on the object" do
+      @obj.respond_to?(:valid_password?).should == true
+      @obj.respond_to?(:not_valid_password?).should == false
+      @obj.respond_to?(:account_expired?).should == true
+      @obj.respond_to?(:not_account_expired?).should == false
     end
   end
-
 end

data/spec/features/plotter_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+##
+##
+##
+
+describe StateFu::Plotter do
+  include MySpecHelper
+  before do
+    reset!
+    make_pristine_class('Klass')
+    @machine = Klass.state_fu_machine(:drawme) do
+      chain 'clean -tarnish-> dirty -fester-> putrid'
+    end
+    @machine = Klass.state_fu_machine(:drawme)
+  end
+
+
+  describe "class methods" do
+    describe ".new" do
+      it "should expect a StateFu::Machine and return a Plotter" do
+        @plotter = StateFu::Plotter.new( @machine )
+        @plotter.should be_kind_of(StateFu::Plotter)
+        @plotter.machine.should == @machine
+        lambda { StateFu::Plotter.new( "abracadabra" ) }.should raise_error(RuntimeError)
+      end
+    end
+
+    describe "a new plotter" do
+      before do
+        @plotter = StateFu::Plotter.new( @machine )
+      end
+
+      it "should have an empty hash of states" do
+        @plotter = StateFu::Plotter.new( @machine )
+        @plotter.states.should == {}
+      end
+
+    end
+  end # class methods
+
+  describe "instance methods" do
+    before do
+      @plotter = StateFu::Plotter.new( @machine )
+    end
+
+    describe ".generate" do
+
+      it "should call generate_dot!" do
+        mock( @plotter ).generate_dot!() { "dot" }
+        @plotter.generate
+      end
+
+      it "should store the result in the dot attribute" do
+        mock( @plotter).generate_dot!() { "dot" }
+        @plotter.generate
+        @plotter.dot.should == "dot"
+      end
+
+      describe ".save_as(filename)" do
+        it "should save the string to a file" do
+          mock( File).open( 'filename', 'w' ).yields( @fh = Object.new() )
+          mock( @fh ).write( @plotter.output )
+          @plotter.output.save_as( 'filename' )
+        end
+      end
+
+      describe ".save!" do
+        it "should save the string in a tempfile and return the path" do
+          mock(@tempfile = Object.new).path {"path"}.subject
+          mock(Tempfile).new(['state_fu_graph','.dot']).yields( @fh = Object.new() ) { @tempfile }
+          mock( @fh ).write( @plotter.output )
+          @plotter.output.save!.should == 'path'
+        end
+      end
+    end # instance methods
+
+    describe "output" do
+      it "should return the result of .generate" do
+        @plotter.output.should == @plotter.generate
+      end
+    end
+
+    describe "generate_dot!" do
+      it "should return a string" do
+        @plotter.generate_dot!.should be_kind_of(String)
+      end
+
+      it "should extend the string to respond_to save_as" do
+        @plotter.output.should respond_to(:save_as)
+      end
+    end # output
+
+  end
+end
+
+

data/spec/features/shared_log_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe "using StateFu w/ shared logs" do
+  it "should be sane" do
+    StateFu::Logger.shared?.should == false
+  end
+end

data/spec/features/singleton_machine_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe "singleton machines" do
+  before do
+    make_pristine_class('Klass')
+    @m = StateFu::Machine.new do
+      state :a do
+        event :beatify, :transitions_to => :b
+      end
+    end
+    @m.events.length.should == 1
+    @obj = Klass.new
+    @m.bind!( @obj, :my_binding)
+  end
+
+  it "should return a binding to the machine when calling the binding's name" do
+    @obj.should respond_to(:my_binding)
+    @obj.my_binding.should be_kind_of(StateFu::Binding)
+    @obj.my_binding.machine.should == @m
+    @obj.my_binding.object.should == @obj
+  end
+
+  it "should have event methods defined" do
+    %w/beatify can_beatify? beatify!/.each do |method_name|
+      @obj.my_binding.should respond_to(method_name)
+      @obj.should respond_to(method_name)
+    end
+  end
+
+  it "should transition" do
+    @b = @obj.my_binding
+    @b.current_state.should == :a
+    t = @obj.beatify!
+    t.should be_kind_of(StateFu::Transition)
+    t.should be_accepted
+    @b.current_state.should == :b
+  end
+
+end

data/spec/features/state_and_array_options_accessor_spec.rb

@@ -8,7 +8,7 @@ describe "extending bindings and transitions with Lathe#helper" do
     reset!
     make_pristine_class('Klass')
 
-    @machine = Klass.machine do
+    @machine = Klass.state_fu_machine do
       state :normal, :colour => 'green'
       state :bad,    :colour => 'red'
       event( :worsen, :colour => 'orange' ) { from :normal => :bad }

data/spec/features/{transition_boolean_comparison.rb → transition_boolean_comparison_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 
 describe "extending bindings and transitions with Lathe#helper" do
 
@@ -27,40 +27,56 @@ describe "extending bindings and transitions with Lathe#helper" do
   #
 
   describe StateFu::Transition  do
-    describe "#==" do
+    describe "equality" do
+
+      it "should == the current_state" do
+        @transition.should == @transition.current_state
+      end
+
+      it "should != any other state" do
+        @transition.should_not == @transition.target
+      end
+
+      it "should == the current_state_name" do
+        @transition.should == @transition.current_state
+      end
+
+      it "should != any other State's name" do
+        @transition.should_not == @transition.target.name
+      end
 
       describe "with an unaccepted transition" do
         before do
-          stub(@transition).accepted? { false }
+          # stub(@transition).accepted? { false }
         end
 
-        it "should == true" do
+        it "should != true" do
           @transition.should_not == true
         end
 
-        it "should not == false" do
+        it "should == false" do
           @transition.should == false
         end
 
-        it "should === true" do
+        it "should not === true" do
           @transition.should_not === true
         end
 
-        it "should not === false" do
+        it "should === false" do
           @transition.should === false
         end
-
-        it "should not evaluate as truthy" do
-          pending
-          x = @transition || 1
-          x.should == 1
+        
+        it "should not be nil?" do
+          @transition.nil?.should be_false
         end
       end
 
 
       describe "with an accepted transition" do
         before do
-          stub(@transition).accepted? { true }
+          @obj.ok = true
+          @transition.fire!
+          @transition.should be_accepted
         end
         it "should == true" do
           @transition.should == true
@@ -78,11 +94,6 @@ describe "extending bindings and transitions with Lathe#helper" do
           @transition.should_not === false
         end
 
-        it "should evaluate as truthy" do
-          x = @transition || 1
-          x.should == @transition
-        end
-
       end
     end
 

data/spec/helper.rb

@@ -1,124 +1,13 @@
 #!/usr/bin/env ruby
-thisdir = File.expand_path(File.dirname(__FILE__))
+require File.join(File.dirname(__FILE__),'spec_helper')
 
-# ensure we require state-fu from lib, not gems
-$LOAD_PATH.unshift( "#{thisdir}/../lib" )
-require 'state-fu'
-require 'no_stdout'
-
-StateFu::Logger.suppress!
-
-require 'rubygems'
-
-{"rr" => "rr", "spec" => "rspec" }.each do |lib, gem_name|
-  begin
-    require lib
-  rescue LoadError => e
-    STDERR.puts "The '#{gem_name}' gem is required to run StateFu's specs. Please install it by running (as root):\ngem install #{gem_name}\n\n"
-    exit 1;
-  end
+begin
+  require 'rr'
+rescue LoadError => e
+  STDERR.puts "The '#{gem_name}' gem is required to run StateFu's specs. Please install it by running (as root):\ngem install #{gem_name}\n\n"
+  exit 1;
 end
 
-# require 'state-fu'
-
 Spec::Runner.configure do |config|
   config.mock_with :rr
 end
-
-module MySpecHelper
-  include NoStdout
-
-  def prepare_active_record( options={}, &migration )
-    begin
-      require 'activesupport'
-      require 'active_record'
-      require 'sqlite3'
-    rescue LoadError => e
-      pending "skipping specifications due to load error: #{e}"
-      return false
-    end
-
-    options.symbolize_keys!
-    options.assert_valid_keys( :db_config, :migration_name, :hidden )
-
-    # connect ActiveRecord
-    db_config = options.delete(:db_config) || {
-      :adapter  => 'sqlite3',
-      :database => ':memory:'
-    }
-    ActiveRecord::Base.establish_connection( db_config )
-
-    return unless block_given?
-
-    # prepare the migration
-    migration_class_name =
-      options.delete(:migration_name) || 'BeforeSpecMigration'
-    make_pristine_class( migration_class_name, ActiveRecord::Migration )
-    migration_class = migration_class_name.constantize
-    migration_class.class_eval( &migration )
-
-    # run the migration without spewing crap everywhere
-    if options.delete(:hidden) != false
-      no_stdout { migration_class.migrate( :up ) }
-    else
-      migration_class.migrate( :up )
-    end
-  end
-
-  def skip_unless_relaxdb
-    unless Object.const_defined?( 'RelaxDB' )
-      pending('Skipping specs because you do not have the relaxdb gem (paulcarey-relaxdb) installed ...')
-    end
-  end
-
-  def prepare_relaxdb( options={} )
-    begin
-      require 'relaxdb'
-      if Object.const_defined?( "RelaxDB" )
-        RelaxDB.configure :host => "localhost", :port => 5984, :design_doc => "spec_doc"
-        RelaxDB.delete_db "relaxdb_spec" rescue "ok"
-        RelaxDB.use_db    "relaxdb_spec"
-        RelaxDB.enable_view_creation
-      end
-    rescue LoadError => e
-      # pending "skipping specifications due to load error: #{e}"
-      return false
-    end
-    begin
-      RelaxDB.replicate_db "relaxdb_spec_base", "relaxdb_spec"
-      RelaxDB.enable_view_creation
-    rescue => e
-      puts "\n===== Run rake create_base_db before the first spec run ====="
-      puts
-      exit!
-    end
-    #
-  end
-
-  def make_pristine_class(class_name, superklass=Object, reset_first = false)
-    reset! if reset_first
-    @class_names ||= []
-    @class_names << class_name
-    klass = Class.new( superklass )
-    klass.send( :include, StateFu )
-    Object.send(:remove_const, class_name ) if Object.const_defined?( class_name )
-    Object.const_set(class_name, klass)
-  end
-
-  def reset!
-    @class_names ||= []
-    @class_names.each do |class_name|
-      Object.send(:remove_const, class_name ) if Object.const_defined?( class_name )
-    end
-    @class_names = []
-    StateFu::FuSpace.reset!
-  end
-
-  def set_method_arity( object, method_name, needed_arity = 1 )
-    a = Proc.new {}
-    stub( a ).arity() { needed_arity }
-    stub( object ).method( anything ) { |x| object.send(x) }
-    stub( object ).method( method_name ) { a }
-  end
-
-end

data/spec/integration/active_record_persistence_spec.rb

@@ -30,11 +30,25 @@ describe "an ActiveRecord model with StateFu included:" do
     ExampleRecord.superclass.should == ActiveRecord::Base
   end
 
+  describe "when the ActiveRecord model has no table yet (eg before migrations)" do
+    before do
+      make_pristine_class('TableMissingClass', ActiveRecord::Base )
+      TableMissingClass.class_eval do
+        state_fu_machine() { }
+      end
+    end
+
+    it "should not raise an error when the persister is instantiated" do
+      lambda { TableMissingClass.columns }.should raise_error
+      lambda { TableMissingClass.state_fu_machine }.should_not raise_error
+    end
+
+  end
   describe "when the default machine is defined with no field_name specified" do
     before do
       ExampleRecord.class_eval do
-        machine do
-          state :initial do
+        state_fu_machine do
+                              state :initial do
             event( :change, :to => :final ) { after :save! }
           end
         end
@@ -148,13 +162,13 @@ describe "an ActiveRecord model with StateFu included:" do
           r = ExampleRecord.find( @r.id )
           r.state_fu.should be_kind_of( StateFu::Binding )
           r.state_fu.current_state.should be_kind_of( StateFu::State )
-          r.state_fu.current_state.should == ExampleRecord.machine.states[:final]
+          r.state_fu.current_state.should == ExampleRecord.state_fu_machine.states[:final]
         end
       end # saved record after transition
 
       describe "when a second machine named :status is defined with :field_name => 'status' " do
         before do
-          ExampleRecord.machine(:status, :field_name => 'status') do
+          ExampleRecord.state_fu_machine(:status, :field_name => 'status') do
             event( :go, :from => :initial, :to => :final )
           end
           @ex = ExampleRecord.new()

data/spec/integration/binding_extension_spec.rb

@@ -12,7 +12,7 @@ describe "extending StateFu::Lathe" do
     before do
       reset!
       make_pristine_class('Klass')
-      @machine = Klass.machine() do
+      @machine = Klass.state_fu_machine() do
         state :init
       end
     end # before