state-fu 0.11.1

data/spec/custom_formatter.rb

@@ -0,0 +1,49 @@
+require 'spec/runner/formatter/progress_bar_formatter'
+class CustomFormatter < Spec::Runner::Formatter::ProgressBarFormatter
+  def add_line(l)
+    (@lines||=[]) << l
+  end
+
+  def dump_pending
+    unless @pending_examples.empty?
+      lpad = @pending_examples.map{|e|e[2].length}.max
+      @output.puts
+      @output.puts "Pending: #{@pending_examples.length}"
+      @pending_examples.each do |pending_example|
+        @output.puts yellow("#{pending_example[2].strip.ljust(lpad)}  # - #{pending_example[1]}")
+      end
+    end
+    @output.flush
+  end
+
+#  def example_failed(example, counter, failure)
+#    failure.instance_eval do
+#      (class<<self;self;end).class_eval { attr_accessor :location }
+#    end
+#    failure.location = example.location
+#    super(example,counter,failure)
+#  end
+
+  def dump_summary(duration, example_count, failure_count, pending_count)
+    if @lines
+      @output.puts "="*72
+      @lines.each do |line|
+        @output.puts line
+      end
+      @output.puts "="*72
+    end
+    super(duration, example_count, failure_count, pending_count)
+  end
+
+  def dump_failure(counter, failure)
+    @output.puts
+    @output.puts "#{counter.to_s})"
+    # @output.puts failure.location
+    @output.puts colorize_failure("#{failure.header}\n#{failure.exception.message}", failure.inspect)
+    @output.puts format_backtrace(failure.exception.backtrace)
+    #failure.exception
+    line = failure.exception.backtrace.last rescue failure.exception.inspect
+    add_line line
+    @output.flush
+  end
+end

data/spec/features/binding_and_transition_helper_mixin_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+module MySpecHelper
+  module BindingExampleHelper
+
+    attr_accessor :ok
+
+    def helper_method
+    end
+
+    def requirement_satisfier?
+      true
+    end
+
+    def requirement_satisfier_with_arg?( t )
+    end
+  end
+
+  module OtherExampleHelper
+    def other_helper_method
+    end
+
+    def other_requirement_satisfier?
+      true
+    end
+  end
+end
+
+describe "extending bindings and transitions with Lathe#helper" do
+
+  include MySpecHelper
+
+  before(:each) do
+    reset!
+    make_pristine_class('Klass')
+    Klass.class_eval do
+      attr_accessor :ok
+    end
+
+    @machine = Klass.state_fu_machine do
+      helper MySpecHelper::BindingExampleHelper
+      helper 'my_spec_helper/other_example_helper'
+
+      chain "a -a2b-> b -b2c-> c"
+
+      events.each do |e|
+        e.requires :requirement_satisfier?
+        e.requires :requirement_satisfier_with_arg?
+        e.requires :other_requirement_satisfier?
+      end
+    end
+
+    @other_machine = Klass.state_fu_machine(:other) do
+      helper ::MySpecHelper::OtherExampleHelper
+    end
+    @obj = Klass.new
+    @binding       = @obj.state_fu
+    @other_binding = @obj.other
+    @transition    = @obj.state_fu.transition(:a2b)
+  end # before
+
+  #
+  #
+
+  describe "binding" do
+    describe "instance methods" do
+
+      it "should respond to helper_method" do
+        @binding.should respond_to( :helper_method)
+      end
+
+
+      it "should respond to other_helper_method" do
+        @binding.should respond_to( :other_helper_method)
+      end
+
+      it "should respond to requirement_satisfier?" do
+        @binding.should respond_to( :requirement_satisfier?)
+      end
+
+      it "should respond to other_requirement_satisfier?" do
+        @binding.should respond_to( :other_requirement_satisfier?)
+      end
+
+    end
+  end
+
+  describe "transition" do
+    describe "instance methods" do
+
+      it "should respond to helper_method" do
+        @transition.should respond_to( :helper_method)
+      end
+
+      it "should respond to other_helper_method" do
+        @transition.should respond_to( :other_helper_method)
+      end
+
+      it "should respond to requirement_satisfier?" do
+        @transition.should respond_to( :requirement_satisfier?)
+      end
+
+      it "should respond to other_requirement_satisfier?" do
+        @transition.should respond_to( :other_requirement_satisfier?)
+      end
+
+    end
+  end
+
+end
+

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

@@ -0,0 +1,118 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+module RequirementFeatureHelper
+  def account_expired?
+    !! account_expired
+  end
+
+  def valid_password?
+    !! valid_password
+  end
+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
+
+  end
+
+end
+
+describe "requirements" do
+  before(:all) do
+    reset!
+    make_pristine_class('Klass')
+    Klass.class_eval do
+      attr_accessor :valid_password
+      attr_accessor :account_expired
+    end
+    @machine = StateFu::Machine.new do
+      initial_state :guest
+
+      event :has_valid_password, :from => :anonymous, :to => :logged_in do
+        requires :valid_password?
+      end
+
+      event :has_not_valid_password, :from => :anonymous, :to => :suspect do
+        requires :not_valid_password?
+      end
+
+      event :has_no_valid_password, :from => :anonymous, :to => :suspect do
+        requires :no_valid_password?
+      end
+      
+    end
+  end
+
+  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 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.respond_to?(:not_account_expired?).should == false
+    end
+  end
+
+  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_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