davidlee-state-fu 0.2.0 → 0.3.1

data/lib/state_fu/transition.rb

@@ -211,5 +211,18 @@ module StateFu
     alias_method :pretend?,       :testing?
     alias_method :dry_run?,       :testing?
 
+    # an accepted transition == true
+    # an unaccepted transition == false
+    # same for === (for case equality)
+    def == other
+      case other
+      when true
+        accepted?
+      when false
+        !accepted?
+      else
+        super( other )
+      end
+    end
   end
 end

data/lib/vizier.rb

@@ -0,0 +1,300 @@
+#!/usr/bin/env ruby
+
+begin
+  require File.join(File.dirname(__FILE__), '/state_fu/core_ext' )
+rescue LoadError
+  require 'activesupport'
+end 
+ 
+# sorry, there's only Heisendocumentation (if I realize anyone's looking for
+# them, I might write some)
+ 
+# temporary dirty hack
+ 
+module Vizier
+ 
+  module Support
+    LEGAL_CHARS = 'a-zA-Z0-9_'
+ 
+    def attributes=( attrs )
+      @attributes = attrs.symbolize_keys!.extend( Attributes )
+    end
+ 
+    def attributes
+      (@attributes ||= {}).extend( Attributes )
+    end
+ 
+    def legal?( str )
+      str =~ /^[#{LEGAL_CHARS}]+$/ && str == str.split
+    end
+ 
+    def sanitize(str)
+      sanitize( str )
+    end
+ 
+    def quote( str )
+      return str if legal?( str )
+      '"' + str.to_s.gsub(/"/,'\"') + '"'
+    end
+ 
+    def self.included( klass )
+      klass.extend( ClassMethods )
+    end
+ 
+    module Finder
+      def []( idx )
+        begin
+          super( idx )
+        rescue TypeError => e
+          if idx.is_a?( String ) || idx.is_a?( Symbol )
+            self.detect { |i| i.name.to_s == idx.to_s }
+          elsif idx.class.respond_to?(:table_name)
+            self.detect { |i| i.name.to_s == Vizier::Node.make_name( idx ) }
+          else
+            raise e
+          end
+        end
+      end
+    end
+ 
+    module ClassMethods
+      def sanitize( str )
+        str.to_s.gsub(/[^#{LEGAL_CHARS}]/,'_').gsub(/__+/,'_')
+      end
+ 
+      def finder( name )
+        class_eval do
+          define_method name do
+            instance_variable_get( "@#{name}" ).extend( Finder )
+          end
+        end
+      end
+    end
+  end
+ 
+  module Attributes
+    include Support
+ 
+    def to_s
+      return '[]' if empty?
+      '[ ' + self.map do |k,v|
+        "#{quote k} = #{quote v}"
+      end.join(" ") + ' ]'
+    end
+ 
+  end
+ 
+  class Base
+    def [](k)
+      attributes[k.to_sym]
+    end
+ 
+    def []=(k,v)
+      attributes[k.to_sym] = v
+    end
+  end
+ 
+  class Link < Base
+    include Support
+    attr_accessor :from
+    attr_accessor :to
+ 
+    def initialize( from, to, attrs={} )
+      self.attributes = attrs
+      @from = extract_name( from )
+      @to = extract_name( to )
+    end
+ 
+    def extract_name( o )
+      o.is_a?(String) ? o : o.name
+    end
+ 
+    def to_str
+      "#{quote from} -> #{quote to} #{attributes};"
+    end
+  end
+ 
+  # TODO ..
+  module Label
+    def []( i )
+ 
+    end
+  end
+ 
+  class Node < Base
+    include Support
+ 
+    attr_accessor :object
+    attr_accessor :fields
+    attr_accessor :name
+ 
+    def initialize( name = nil, attrs={} )
+      self.attributes = attrs
+      if name.is_a?( String )
+        self.name = name
+        @label = attrs.delete(:label) || name
+      else
+        @object = name
+        self.name = Node.make_name( @object )
+        @label = attrs.delete(:label) || Node.first_response( @object, :name, :identifier, :label ) || name
+      end
+    end
+ 
+    def self.make_name( obj )
+      sanitize [ obj.class, first_response( obj, :name, :identifier, :id, :hash)].join('_')
+    end
+ 
+    def self.first_response obj, *method_names
+      responder = method_names.flatten.detect { |m| obj.respond_to?(m) }
+      obj.send( responder ) unless responder.nil?
+    end
+ 
+    def name=( str )
+      @name = str.to_s.gsub(/[^a-zA-Z0-9_]/,'_').gsub(/__+/,'_')
+    end
+ 
+    def to_str
+      "#{quote name} #{attributes.to_s};"
+    end
+ 
+    def to_s
+      quote( name )
+    end
+  end
+ 
+  class SubGraph < Base
+    include Support
+ 
+    finder :nodes
+ 
+    attr_accessor :links
+    attr_accessor :name
+ 
+    def initialize( name, attrs={} )
+      self.attributes = attrs
+      @node = {}
+      @edge = {}
+ 
+      @name = name
+      @nodes = []
+      @links = []
+    end
+ 
+    def node(attrs={})
+      (@node ||= {}).merge!(attrs).extend(Attributes)
+    end
+ 
+    def graph(attrs={})
+      self.attributes.merge!(attrs).extend(Attributes)
+    end
+ 
+    def edge(attrs={})
+      (@edge ||= {}).merge!(attrs).extend(Attributes)
+    end
+ 
+    def add_node( n, a={} )
+      returning Node.new(n,a) do |n|
+        @nodes << n
+      end
+    end
+ 
+    def add_link(from, to, a={})
+      returning Link.new( from, to, a) do |l|
+        @links << l
+      end
+    end
+    alias_method :connect, :add_link
+    alias_method :add_edge, :add_link
+ 
+    def build(lines = [], indent = 0)
+      lines.map do |line|
+        if line.is_a?( Array )
+          build( line, indent + 1)
+        else
+          (" " * (indent * 4) ) + line.to_s
+        end
+      end.join("\n")
+    end
+ 
+    def write_comment( str, j = 0 )
+      l = 40 - (j * 4)
+      i = ' ' * (j * 4)
+      "\n#{i}/*#{'*'*(l-2)}\n#{i}** #{ str.ljust((l - (6) - (j*4)),' ') }#{i} **\n#{i}#{'*'*(l-1)}/"
+    end
+ 
+    def comment(str)
+      write_comment(str, 2)
+    end
+ 
+    def to_str
+      build( ["subgraph #{quote name} {",
+              [ # attributes.map {|k,v| "#{quote k} = #{quote v};" },
+               ["graph #{attributes};",
+                 "node #{node};",
+                 "edge #{edge};"
+                ],
+                nodes.map(&:to_str),
+                links.map(&:to_str),
+                "}"
+               ],
+            ])
+    end
+    alias_method :generate!, :to_str
+ 
+  end
+ 
+  class Graph < SubGraph
+    finder :subgraphs
+ 
+    def comment( str )
+      write_comment( str, 1 )
+    end
+ 
+    def to_str
+      build(["digraph #{quote name} {",
+             [
+              comment("global options"),
+              "graph #{graph};",
+              "node #{node};",
+              "edge #{edge};"
+             ],
+             comment("nodes"),
+             nodes.map(&:to_str),
+             comment("links"),
+             links.map(&:to_str),
+             comment("subgraphs"),
+             subgraphs.map(&:to_str),
+             "}"])
+    end
+    alias_method :generate!, :to_str
+ 
+    def publish!( a = {} )
+      generate! # -> png
+    end
+ 
+    def subgraph(name, a = {})
+      returning( SubGraph.new(name, a)) do |g|
+        @subgraphs << g
+        yield g if block_given?
+      end
+    end
+ 
+    def cluster(name = nil, a = {}, &block)
+      if name && name = "cluster_#{name}"
+        subgraph( name, a, &block )
+      else
+        clusters
+      end
+    end
+ 
+    def clusters
+      @subgraphs.select {|s| s.name =~ /^cluster_/ }.extend( Finder )
+    end
+ 
+    def initialize(name = 'my_graph', attrs = {})
+      @subgraphs = []
+      super( name, attrs )
+      yield self if block_given?
+    end
+  end
+end

data/spec/BDD/plotter_spec.rb

@@ -0,0 +1,115 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+##
+##
+##
+
+describe StateFu::Plotter do
+  include MySpecHelper
+  before do
+    reset!
+    make_pristine_class('Klass')
+    @machine = Klass.machine(:drawme) do
+      chain 'clean -tarnish-> dirty -fester-> putrid'
+    end
+    @machine = Klass.machine(:drawme)
+  end
+
+  it "deleteme" do
+    @machine.graphviz.save_as('/tmp/1.dot')
+  end
+
+  describe "example machine" do
+    it "should have 3 states" do
+      @machine.states.length.should == 3
+    end
+
+    it "should have 2 simple events" do
+      @machine.events.length.should == 2
+      @machine.events.each{ |e| e.should be_simple }
+    end
+
+  end
+
+  describe StateFu::Plotter do
+    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
+
+        it "should return a Vizier::Graph" # .graph
+
+        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
+
+      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
+
+    end
+  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.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.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/not_requirements_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+module RequirementFeatureHelper
+
+  def account_expired_test
+    false
+  end
+
+  def valid_password_test
+    true
+  end
+
+  def account_expired?
+    !!account_expired_test
+  end
+
+  def valid_password?
+    !!valid_password_test
+  end
+end
+
+describe "requirement objects" do
+  include MySpecHelper
+  before(:all) do
+    reset!
+    make_pristine_class('Klass')
+    Klass.machine do
+      helper RequirementFeatureHelper
+
+      initial_state :guest
+
+      event :login_success, :from => :guest, :to => [:logged_in, :expired] 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?
+      end
+
+      state :expired do
+        requires :account_expired?
+      end
+    end
+    @obj = Klass.new
+    @binding = @obj.state_fu
+  end
+
+  describe "requirements with names beginning with not_" do
+
+    it "should return the opposite of the requirement name without not_" do
+      @binding.respond_to?(:valid_password?).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
+    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
+    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
+    end
+  end
+
+end

data/spec/features/state_and_array_options_accessor_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe "extending bindings and transitions with Lathe#helper" do
+
+  include MySpecHelper
+
+  before(:each) do
+    reset!
+    make_pristine_class('Klass')
+
+    @machine = Klass.machine do
+      state :normal, :colour => 'green'
+      state :bad,    :colour => 'red'
+      event( :worsen, :colour => 'orange' ) { from :normal => :bad }
+    end
+    @obj = Klass.new
+    @binding       = @obj.state_fu
+
+  end # before
+
+  describe "accessing sprocket options" do
+    describe "state#[]" do
+      it "should return state.options[key]" do
+        @machine.states[:normal][:colour].should == 'green'
+      end
+    end
+    describe "event#[]" do
+      it "should return event.options[key]" do
+        @machine.events[:worsen][:colour].should == 'orange'
+      end
+    end
+
+    describe "state#[]=" do
+      it "should update state.options" do
+        @machine.states[:normal][:flavour] = 'lime'
+        @machine.states[:normal][:flavour].should == 'lime'
+      end
+    end
+    describe "event#[]=" do
+      it "should update event.options" do
+        @machine.events[:worsen][:flavour] = 'orange'
+        @machine.events[:worsen][:flavour].should == 'orange'
+      end
+    end
+
+  end
+end