state-fu 0.11.1

data/lib/support/plotter.rb

@@ -0,0 +1,62 @@
+require 'tempfile'
+
+module StateFu
+  class Plotter
+    attr_reader :machine, :dot, :graph, :states, :events
+
+    OUTPUT_HELPER = Module.new do
+
+      def save!
+        Tempfile.new(['state_fu_graph','.dot']) do |fh|
+          fh.write( self )
+        end.path
+      end
+
+      def save_as( filename )
+        File.open(filename, 'w') { |fh| fh.write( self ) }
+      end
+
+      def save_png(filename)
+        raise NotImplementedError
+        # dot graph.dot -Tpng -O
+      end
+
+    end
+
+    def output
+      generate
+    end
+
+    def initialize( machine, options={} )
+      raise RuntimeError, machine.class.to_s unless machine.is_a?(StateFu::Machine)
+      @machine = machine
+      @options = options.symbolize_keys!
+      @states  = {}
+      @events  = {}
+      # generate
+    end
+
+    def generate
+      @dot ||= generate_dot!.extend( OUTPUT_HELPER )
+    end
+
+    def generate_dot!
+      @graph = Vizier::Graph.new(:state_machine) do |g|
+        g.node :shape => 'doublecircle'
+        machine.state_names.map.each do |s|
+          @states[s] = g.add_node(s.to_s)
+        end
+        machine.events.map.each do |e|
+          e.origins.map(&:name).each do |from|
+            e.targets.map(&:name).each do |to|
+              g.connect( @states[from], @states[to], :label => e.name.to_s )
+            end
+          end
+          # @events[s] = g.add_node(s.to_s)
+        end
+      end
+      @graph.generate!
+    end
+
+  end
+end

data/lib/support/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
+
+# 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
+          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/lib/tasks/spec_last.rake

@@ -0,0 +1,55 @@
+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
+
+begin
+  require 'rake'
+  require 'spec'
+  require 'spec/rake/spectask'
+
+  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
+
+rescue LoadError
+  # fail quietly if rspec is not installed
+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