davidlee-state-fu 0.3.1 → 0.10.0

data/lib/state_fu/transition_query.rb

@@ -0,0 +1,214 @@
+module StateFu
+  class TransitionQuery #< Array
+    attr_accessor :binding, :options, :result, :args, :block
+
+    def initialize(binding, options={})
+      defaults = { :valid => true, :cyclic => nil }
+      @options = defaults.merge(options).symbolize_keys
+      @binding = binding
+    end
+
+    include Enumerable
+    
+    def each *a, &b
+      result.each *a, &b
+    end
+
+    def method_missing(method_name, *args, &block)
+      if result.respond_to?(method_name, true)
+        result.__send__(method_name, *args, &block)
+      else
+        super(method_name, *args, &block)
+      end
+    end
+            
+    #
+    #
+    #
+    
+    def find( event_or_array )
+      event, target = parse_destination(event_or_array)
+      _args, _block = @args, @block
+      returning binding.new_transition(event, target) do |t|
+        t.apply!(&_block) if _block
+        if _args
+          t.args = _args 
+        end
+      end        
+    end
+    
+    def cyclic
+      @options.merge! :cyclic => true
+      self
+    end
+
+    def not_cyclic
+      @options.merge! :cyclic => false
+      self
+    end
+
+    def valid
+      @options.merge! :valid => true
+      self
+    end
+
+    def not_valid
+      @options.merge! :valid => false
+      self
+    end
+    alias_method :invalid, :not_valid
+
+    def to state
+      @options.merge! :target => state
+      self
+    end
+
+    def for event
+      @options.merge! :event => event
+      self
+    end
+
+    def simple
+      @options.merge! :simple => true
+      self
+    end
+    
+    #
+    #
+    #
+    
+    def singular
+      result.first if result.length == 1
+    end
+
+    def next
+      @options[:cyclic] ||= false
+      singular
+    end
+    
+    def next_state
+      @options[:cyclic] ||= false
+      if result.map(&:target).uniq.length == 1
+        result.first.target
+      end
+    end
+
+    def next_event
+      @options[:cyclic] ||= false
+      if result.map(&:event).uniq.length == 1
+        result.first.event
+      end
+    end
+    
+    #
+    #
+    #
+
+    def events
+      map {|t| t.event }
+    end
+
+    def targets
+      map {|t| t.target }
+    end
+
+    def apply! # (&block
+      result.each { |t| t.apply &block if block }
+    end
+
+    def with(*args, &block)
+      @args  = args
+      @block = block
+      self
+    end
+    
+    def all_destinations
+      binding.events.inject([]){ |arr, evt| arr += evt.targets.map{|tgt| [evt,tgt] }; arr}.uniq
+    end
+    
+    def all_destination_names
+      all_destinations.map {|tuple| tuple.map(&:to_sym) }
+    end
+
+    private
+
+    #
+    # Result 
+    #
+    
+    module Result
+      def states
+        map(&:target).uniq.extend StateArray
+      end
+      alias_method :targets, :states
+      alias_method :next_states, :states
+
+      def events
+        map(&:event).uniq.extend EventArray
+      end
+    end # Result
+
+    def result
+      @result = binding.events.select do |e| 
+        case options[:cyclic]
+        when true
+          e.cycle?
+        when false
+          !e.cycle?
+        else
+          true
+        end
+      end.map do |event|
+        next if options[:event] and event != options[:event]
+        returning [] do |ts|
+
+          # TODO hmm ... "sequences" ... delete this?
+          if options[:sequences]
+            if target = event.target_for_origin(current_state)
+              ts << binding.transition([event,target], *args) unless options[:cyclic]
+            end
+          end
+
+          if event.targets
+            next unless event.target if options[:simple]
+            event.targets.flatten.each do |target|
+              next if options[:target] and target != options[:target]
+              t = binding.new_transition( event, target, *args)
+              ts << t if (t.valid? or !options[:valid])
+            end
+          end
+
+        end
+      end.flatten.extend(Result)
+      
+      if @args || @block
+        @result.each do |t|
+          t.apply!( &@block) if @block 
+          t.args = @args     if @args
+        end
+      end
+      
+      @result
+    end # result 
+
+    # sanitizes / extracts destination for find.
+    #
+    # takes a single, simple (one target only) event,
+    # or an array of [event, target],
+    # or one of the above with symbols in place of the objects themselves.    
+    def parse_destination(event_or_array)
+      case event_or_array
+      when Event, Symbol
+        event  = event_or_array
+        target = nil
+      when Array
+        event, target = *event_or_array
+      end
+      raise ArgumentError.new( [event,target].inspect ) unless
+        [Event, Symbol].include?(event.class) &&
+        [State, Symbol, NilClass].include?(target.class)
+      [event, target]
+    end # parse_destination
+
+  end
+end

data/lib/state_fu.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.basename(__FILE__, 'state-fu')))

data/lib/tasks/spec_last.rake

@@ -0,0 +1,46 @@
+require 'fileutils'
+
+unless Object.const_defined?('STATE_FU_APP_PATH')
+  STATE_FU_APP_PATH = Object.const_defined?('RAILS_ROOT') ? RAILS_ROOT : File.join( File.dirname(__FILE__), '/../..')
+end
+
+unless Object.const_defined?('STATE_FU_PLUGIN_PATH')
+  STATE_FU_PLUGIN_PATH = Object.const_defined?('RAILS_ROOT') ? File.join( RAILS_ROOT, '/vendor/plugins/state-fu' ) : STATE_FU_APP_PATH
+end
+
+namespace :spec do
+  def find_last_modified_spec
+    require 'find'
+    specs = []
+    Find.find( File.expand_path(File.join(STATE_FU_APP_PATH,'spec'))) do |f|
+      next unless f !~ /\.#/ && f =~ /_spec.rb$/
+      specs << f
+    end
+    spec = specs.sort_by { |spec| File.stat( spec ).mtime }.last
+  end
+
+  desc "runs the last modified spec; L=n runs only that line"
+  Spec::Rake::SpecTask.new(:last) do |t|
+    specfile = find_last_modified_spec || return
+    t.verbose = true
+    t.spec_opts = ["-c","-b","-u"]
+    if ENV['L']
+      t.spec_opts += ["-l", ENV["L"],"-f", "specdoc"]
+    else
+      t.spec_opts += ["-f", "profile"]
+    end
+    t.spec_files = FileList[specfile]
+  end
+
+  desc "runs all specs, or those which last failed"
+  Spec::Rake::SpecTask.new(:faily) do |t|
+    specfile    = find_last_modified_spec || return
+    faily       = 'spec.fail'
+    t.verbose   = true
+    t.spec_opts = ["-f","failing_examples:#{faily}", "-f","n","-c","-b","-u"]
+    if File.exists?(faily) && File.read(faily).split("\n")[0] != ""
+      t.spec_opts << ["-e",faily]
+    end
+  end
+
+end

data/lib/tasks/state_fu.rake

@@ -0,0 +1,57 @@
+require 'fileutils'
+
+unless Object.const_defined?('STATE_FU_APP_PATH')
+  STATE_FU_APP_PATH = Object.const_defined?('RAILS_ROOT') ? RAILS_ROOT : File.join( File.dirname(__FILE__), '/../..')
+end
+
+unless Object.const_defined?('STATE_FU_PLUGIN_PATH')
+  STATE_FU_PLUGIN_PATH = Object.const_defined?('RAILS_ROOT') ? File.join( RAILS_ROOT, '/vendor/plugins/state-fu' ) : STATE_FU_APP_PATH
+end
+
+namespace :state_fu do
+
+  task :update do
+    path = STATE_FU_PLUGIN_PATH
+    pwd = FileUtils.pwd
+    FileUtils.cd( path )
+    system('git pull')
+    FileUtils.cd pwd
+  end
+
+  def graph_name( klass, machine, doc_path = false )
+    parts = ["#{klass}_#{machine}"]
+    if doc_path
+      folder = parts.unshift( File.join( STATE_FU_APP_PATH, "doc/") )
+      FileUtils.mkdir_p( folder )
+      parts.push( '.png' )
+    end
+    parts.join
+  end
+
+  def graph( klass, machine )
+    name = graph_name( klass, machine )
+    graphviz = `which dot`.strip || raise("Graphviz not installed? Can't find dot executable!")
+    puts graphviz
+    tmp_dot  = "/tmp/#{name}.dot"
+    klass.machine( machine.to_sym ).graphviz.save_as( tmp_dot )
+    tmp_png = tmp_dot + '.png'
+    doc_png = graph_name( klass, machine, true )
+    puts( "#{graphviz} -Tpng -O #{tmp_dot}" )
+    system( "#{graphviz} -Tpng -O #{tmp_dot}" )
+    FileUtils.cp tmp_png, doc_png
+    doc_png
+  end
+
+  desc "Graph workflows with dot"
+  task :graph => :environment do |t|    
+    state_fu_classes = ObjectSpace.each_object { |o| x << o  if o.respond_to? :machines }
+    state_fu_classes.each do |klass| 
+      klass.state_fu_machines.each do |machine_name, machine|
+        STDERR.puts "#{klass} -> #{machine_name.inspect}"
+        doc_png = graph( klass, machine_name )
+        # yield doc_png if block_given?
+      end
+    end
+    # `open #{doc_png}`
+  end
+end

data/lib/vizier.rb

@@ -4,43 +4,43 @@ 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
- 
+end
+
+# Vizier is a simple library to help generate dot output for graphviz. It is used by StateFu's rake 
+# tasks to generate graphs of state machines.
+#
+# Sorry, there's only Heisendocumentation (if I realize anyone's looking for docs, I might write some)
+#
+module Vizier  #:nodoc:all
+
   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
@@ -56,12 +56,12 @@ module Vizier
         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
@@ -71,63 +71,63 @@ module Vizier
       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 )
@@ -139,65 +139,65 @@ module Vizier
         @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
@@ -205,7 +205,7 @@ module Vizier
     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 )
@@ -215,17 +215,17 @@ module Vizier
         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};" },
@@ -240,16 +240,16 @@ module Vizier
             ])
     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} {",
              [
@@ -267,18 +267,18 @@ module Vizier
              "}"])
     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 )
@@ -286,15 +286,15 @@ module Vizier
         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
+end

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

@@ -37,7 +37,7 @@ describe "extending bindings and transitions with Lathe#helper" do
       attr_accessor :ok
     end
 
-    @machine = Klass.machine do
+    @machine = Klass.state_fu_machine do
       helper MySpecHelper::BindingExampleHelper
       helper 'my_spec_helper/other_example_helper'
 
@@ -50,7 +50,7 @@ describe "extending bindings and transitions with Lathe#helper" do
       end
     end
 
-    @other_machine = Klass.machine(:other) do
+    @other_machine = Klass.state_fu_machine(:other) do
       helper ::MySpecHelper::OtherExampleHelper
     end
     @obj = Klass.new