state_machines-graphviz 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b375be8fce2b404843e60ffc947edb7d7b37a5e4
+  data.tar.gz: e46a7734205fd1ff0946dacb72195e82e1863d5a
+SHA512:
+  metadata.gz: db7731a6a0236d51ca0a888870ab4f0bf1670ade1832051b2e84bd7220290b8ac5b86d473c089608aeb667388c70665fb9f2acf10cc89d59ee57d7f76fe59965
+  data.tar.gz: 854bb07b3eff8a50165b6bbc7012e2304259711d768238d5a0fbf88f02898f6e5a9730f36971a5c5d6f810cc87d30a649e9bfbf33a62230e1ff1ef99c7eda6c8

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/.travis.yaml

@@ -0,0 +1,10 @@
+language: ruby
+install: sudo apt-get install graphviz -y
+before_install: gem install bundler
+script: bundle exec rake
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+  - jruby-19mode
+  - rbx-2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in state_machine2-graphviz.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2006-2012 Aaron Pfeifer
+Copyright (c) 2014 Abdelkader Boudih
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# StateMachines::Graphviz
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'state_machine2-graphviz' , group: :development
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install state_machine2-graphviz
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/seuros/state_machine2-graphviz/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+desc 'Default: run all tests.'
+task :default => :spec

data/lib/state_machines/graphviz.rb

@@ -0,0 +1,5 @@
+require 'state_machines'
+require 'graphviz'
+require 'state_machines/graphviz/monkeypatch'
+require 'state_machines/graphviz/graph'
+require 'state_machines/graphviz/version'

data/lib/state_machines/graphviz/graph.rb

@@ -0,0 +1,72 @@
+module StateMachines
+  # Provides a set of higher-order features on top of the raw GraphViz graphs
+  class Graph < GraphViz
+    # The name of the font to draw state names in
+    attr_reader :font
+
+    # The graph's full filename
+    attr_reader :file_path
+
+    # The image format to generate the graph in
+    attr_reader :file_format
+
+    # Creates a new graph with the given name.
+    #
+    # Configuration options:
+    # * <tt>:path</tt> - The path to write the graph file to.  Default is the
+    #   current directory (".").
+    # * <tt>:format</tt> - The image format to generate the graph in.
+    #   Default is "png'.
+    # * <tt>:font</tt> - The name of the font to draw state names in.
+    #   Default is "Arial".
+    # * <tt>:orientation</tt> - The direction of the graph ("portrait" or
+    #   "landscape").  Default is "portrait".
+    def initialize(name, options = {})
+      options = { path: 'doc/state_machines', format: 'png', font: 'Arial', orientation: 'portrait' }.merge(options)
+      options.assert_valid_keys(:path, :format, :font, :orientation)
+
+      # TODO fail if path cannot be created or readonly
+      unless Dir.exist? options[:path]
+        FileUtils.mkpath(options[:path])
+      end
+      @font = options[:font]
+      @file_path = File.join(options[:path], "#{name}.#{options[:format]}")
+      @file_format = options[:format]
+
+      super('G', rankdir: options[:orientation] == 'landscape' ? 'LR' : 'TB')
+    end
+
+    # Generates the actual image file based on the nodes / edges added to the
+    # graph.  The path to the file is based on the configuration options for
+    # this graph.
+    def output
+      super(@file_format => @file_path)
+    end
+
+    # Adds a new node to the graph.  The font for the node will be automatically
+    # set based on the graph configuration.  The generated node will be returned.
+    #
+    # For example,
+    #
+    #   graph = StateMachines::Graph.new('test')
+    #   graph.add_nodes('parked', :label => 'Parked', :width => '1', :height => '1', :shape => 'ellipse')
+    def add_nodes(*args)
+      node = super
+      node.fontname = @font
+      node
+    end
+
+    # Adds a new edge to the graph.  The font for the edge will be automatically
+    # set based on the graph configuration.  The generated edge will be returned.
+    #
+    # For example,
+    #
+    #   graph = StateMachines::Graph.new('test')
+    #   graph.add_edges('parked', 'idling', :label => 'ignite')
+    def add_edges(*args)
+      edge = super
+      edge.fontname = @font
+      edge
+    end
+  end
+end

data/lib/state_machines/graphviz/monkeypatch.rb

@@ -0,0 +1,161 @@
+#TODO register graphviz as render engine
+module StateMachines
+  class Machine
+    class << self
+      # Draws the state machines defined in the given classes using GraphViz.
+      # The given classes must be a comma-delimited string of class names.
+      #
+      # Configuration options:
+      # * <tt>:file</tt> - A comma-delimited string of files to load that
+      #   contain the state machine definitions to draw
+      # * <tt>:path</tt> - The path to write the graph file to
+      # * <tt>:format</tt> - The image format to generate the graph in
+      # * <tt>:font</tt> - The name of the font to draw state names in
+      def draw(class_names, options = {})
+        raise ArgumentError, 'At least one class must be specified' unless class_names && class_names.split(',').any?
+
+        # Load any files
+        if files = options.delete(:file)
+          files.split(',').each { |file| require file }
+        end
+
+        class_names.split(',').each do |class_name|
+          # Navigate through the namespace structure to get to the class
+          klass = Object
+          class_name.split('::').each do |name|
+            klass = klass.const_defined?(name) ? klass.const_get(name) : klass.const_missing(name)
+          end
+
+          # Draw each of the class's state machines
+          klass.state_machines.each_value do |machine|
+            machine.draw(options)
+          end
+        end
+      end
+    end
+
+    # Draws a directed graph of the machine for visualizing the various events,
+    # states, and their transitions.
+    #
+    # This requires both the Ruby graphviz gem and the graphviz library be
+    # installed on the system.
+    #
+    # Configuration options:
+    # * <tt>:name</tt> - The name of the file to write to (without the file extension).
+    #   Default is "#{owner_class.name}_#{name}"
+    # * <tt>:path</tt> - The path to write the graph file to.  Default is the
+    #   current directory (".").
+    # * <tt>:format</tt> - The image format to generate the graph in.
+    #   Default is "png'.
+    # * <tt>:font</tt> - The name of the font to draw state names in.
+    #   Default is "Arial".
+    # * <tt>:orientation</tt> - The direction of the graph ("portrait" or
+    #   "landscape").  Default is "portrait".
+    # * <tt>:human_names</tt> - Whether to use human state / event names for
+    #   node labels on the graph instead of the internal name.  Default is false.
+    def draw(graph_options = {})
+      name = graph_options.delete(:name) || "#{owner_class.name}_#{self.name}"
+      draw_options = {:human_name => false}
+      draw_options[:human_name] = graph_options.delete(:human_names) if graph_options.include?(:human_names)
+
+      graph = Graph.new(name, graph_options)
+
+      # Add nodes / edges
+      states.by_priority.each { |state| state.draw(graph, draw_options) }
+      events.each { |event| event.draw(graph, draw_options) }
+
+      # Output result
+      graph.output
+      graph
+    end
+  end
+
+  class State
+    # Draws a representation of this state on the given machine.  This will
+    # create a new node on the graph with the following properties:
+    # * +label+ - The human-friendly description of the state.
+    # * +width+ - The width of the node.  Always 1.
+    # * +height+ - The height of the node.  Always 1.
+    # * +shape+ - The actual shape of the node.  If the state is a final
+    #   state, then "doublecircle", otherwise "ellipse".
+    #
+    # Configuration options:
+    # * <tt>:human_name</tt> - Whether to use the state's human name for the
+    #   node's label that gets drawn on the graph
+    def draw(graph, options = {})
+      node = graph.add_nodes(name ? name.to_s : 'nil',
+                             :label => description(options),
+                             :width => '1',
+                             :height => '1',
+                             :shape => final? ? 'doublecircle' : 'ellipse'
+      )
+
+      # Add open arrow for initial state
+      graph.add_edges(graph.add_nodes('starting_state', :shape => 'point'), node) if initial?
+
+      true
+    end
+  end
+
+  class Event
+    # Draws a representation of this event on the given graph.  This will
+    # create 1 or more edges on the graph for each branch (i.e. transition)
+    # configured.
+    #
+    # Configuration options:
+    # * <tt>:human_name</tt> - Whether to use the event's human name for the
+    #   node's label that gets drawn on the graph
+    def draw(graph, options = {})
+      valid_states = machine.states.by_priority.map {|state| state.name}
+      branches.each do |branch|
+        branch.draw(graph, options[:human_name] ? human_name : name, valid_states)
+      end
+
+      true
+    end
+  end
+
+  class Branch
+    # Draws a representation of this branch on the given graph.  This will draw
+    # an edge between every state this branch matches *from* to either the
+    # configured to state or, if none specified, then a loopback to the from
+    # state.
+    #
+    # For example, if the following from states are configured:
+    # * +idling+
+    # * +first_gear+
+    # * +backing_up+
+    #
+    # ...and the to state is +parked+, then the following edges will be created:
+    # * +idling+      -> +parked+
+    # * +first_gear+  -> +parked+
+    # * +backing_up+  -> +parked+
+    #
+    # Each edge will be labeled with the name of the event that would cause the
+    # transition.
+    def draw(graph, event, valid_states)
+      state_requirements.each do |state_requirement|
+        # From states determined based on the known valid states
+        from_states = state_requirement[:from].filter(valid_states)
+
+        # If a to state is not specified, then it's a loopback and each from
+        # state maps back to itself
+        if state_requirement[:to].values.empty?
+          loopback = true
+        else
+          to_state = state_requirement[:to].values.first
+          to_state = to_state ? to_state.to_s : 'nil'
+          loopback = false
+        end
+
+        # Generate an edge between each from and to state
+        from_states.each do |from_state|
+          from_state = from_state ? from_state.to_s : 'nil'
+          graph.add_edges(from_state, loopback ? from_state : to_state, :label => event.to_s)
+        end
+      end
+
+      true
+    end
+  end
+end

data/lib/state_machines/graphviz/version.rb

@@ -0,0 +1,6 @@
+module StateMachines
+  # Gem version
+  module Graphviz
+    VERSION = '0.0.1'
+  end
+end

data/spec/files/switch.rb

@@ -0,0 +1,15 @@
+class Switch
+  def self.name
+    @name ||= "Switch_#{rand(1_000_000)}"
+  end
+
+  state_machine do
+    event :turn_on do
+      transition all => :on
+    end
+
+    event :turn_off do
+      transition all => :off
+    end
+  end
+end

data/spec/graph_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+describe StateMachines::Graph do
+  context 'GraphDefault' do
+    before(:each) do
+      @graph = StateMachines::Graph.new('test')
+    end
+
+    it 'should_have_a_default_font' do
+      expect('Arial').to eq(@graph.font)
+    end
+
+    it 'should_use_current_directory_for_filepath' do
+      expect('doc/state_machines/test.png').to eq(@graph.file_path)
+    end
+
+    it 'should_have_a_default_file_format' do
+      expect('png').to eq(@graph.file_format)
+    end
+
+    it 'should_have_a_default_orientation' do
+      expect('TB').to eq(@graph[:rankdir].source)
+    end
+  end
+
+  context 'GraphNodes' do
+    before(:each) do
+      @graph = StateMachines::Graph.new('test')
+      @node = @graph.add_nodes('parked', :shape => 'ellipse')
+    end
+
+    it 'should_return_generated_node' do
+      expect(@node).to_not be_nil
+    end
+
+    it 'should_use_specified_name' do
+      expect(@node).to eq(@graph.get_node('parked'))
+    end
+
+    it 'should_use_specified_options' do
+      expect('ellipse').to eq(@node['shape'].to_s.gsub('"', ''))
+    end
+
+    it 'should_set_default_font' do
+      expect('Arial').to eq(@node['fontname'].to_s.gsub('"', ''))
+    end
+  end
+
+  context 'GraphEdges' do
+    before(:each) do
+      @graph = StateMachines::Graph.new('test')
+      @graph.add_nodes('parked', :shape => 'ellipse')
+      @graph.add_nodes('idling', :shape => 'ellipse')
+      @edge = @graph.add_edges('parked', 'idling', :label => 'ignite')
+    end
+
+    it 'should_return_generated_edge' do
+      expect(@edge).to_not be_nil
+    end
+
+    it 'should_use_specified_nodes' do
+      expect('parked').to eq(@edge.node_one(false))
+      expect('idling').to eq(@edge.node_two(false))
+    end
+
+    it 'should_use_specified_options' do
+      expect('ignite').to eq(@edge['label'].to_s.gsub('"', ''))
+    end
+
+    it 'should_set_default_font' do
+      expect('Arial').to eq(@edge['fontname'].to_s.gsub('"', ''))
+    end
+  end
+
+  context 'GraphOutput' do
+    before(:each) do
+      @graph_name = "test_#{rand(1000000)}"
+      @graph = StateMachines::Graph.new(@graph_name)
+      @graph.add_nodes('parked', :shape => 'ellipse')
+      @graph.add_nodes('idling', :shape => 'ellipse')
+      @graph.add_edges('parked', 'idling', :label => 'ignite')
+      @graph.output
+    end
+
+    it 'should_save_file' do
+      expect(File.exist?("doc/state_machines/#{@graph_name}.png")).to be_truthy
+    end
+
+    after(:each) do
+      FileUtils.rm Dir["doc/state_machines/#{@graph_name}.png"]
+    end
+  end
+end

data/spec/machine_drawing_spec.rb

@@ -0,0 +1,215 @@
+describe StateMachines::Graphviz do
+  context 'Drawing' do
+    let(:klass) do
+      Class.new do
+        def self.name
+          @name ||= "Vehicle_#{rand(1_000_000)}"
+        end
+      end
+    end
+    let(:machine) { StateMachines::Machine.new(klass, initial: :parked) }
+
+    before(:each) do
+      machine.event :ignite do
+        transition parked: :idling
+      end
+    end
+
+    it 'should_raise_exception_if_invalid_option_specified' do
+      expect { machine.draw(invalid: true) }.to raise_error(ArgumentError)
+    end
+
+    it 'should_save_file_with_class_name_by_default' do
+      machine.draw
+      expect(File.exist?("doc/state_machines/#{klass.name}_state.png")).to be_truthy
+    end
+
+    it 'should_allow_base_name_to_be_customized' do
+      name = "machine_#{rand(1_000_000)}"
+      machine.draw(name: name)
+      @path = "doc/state_machines/#{name}.png"
+      expect(File.exist?(@path)).to be_truthy
+    end
+
+    it 'should_allow_format_to_be_customized' do
+      machine.draw(format: 'jpg')
+      @path = "doc/state_machines/#{klass.name}_state.jpg"
+      expect(File.exist?(@path)).to be_truthy
+    end
+
+    it 'should_allow_path_to_be_customized' do
+      machine.draw(path: "#{File.dirname(__FILE__)}/")
+      @path = "#{File.dirname(__FILE__)}/#{klass.name}_state.png"
+      expect(File.exist?(@path)).to be_truthy
+    end
+
+    it 'should_allow_orientation_to_be_landscape' do
+      graph = machine.draw(orientation: 'landscape')
+      expect(graph['rankdir'].to_s.gsub('"', '')).to eq('LR')
+    end
+
+    it 'should_allow_orientation_to_be_portrait' do
+      graph = machine.draw(orientation: 'portrait')
+      expect(graph['rankdir'].to_s.gsub('"', '')).to eq('TB')
+    end
+
+    it 'should_allow_human_names_to_be_displayed' do
+      machine.event :ignite, human_name: 'Ignite'
+      machine.state :parked, human_name: 'Parked'
+      machine.state :idling, human_name: 'Idling'
+      graph = machine.draw(human_names: true)
+
+      parked_node = graph.get_node('parked')
+      expect(parked_node['label'].to_s.gsub('"', '')).to eq('Parked')
+
+      idling_node = graph.get_node('idling')
+      expect(idling_node['label'].to_s.gsub('"', '')).to eq('Idling')
+    end
+
+    after(:each) do
+      FileUtils.rm Dir[@path || "doc/state_machines/#{klass.name}_state.png"]
+    end
+  end
+
+  context 'DrawingWithIntegerStates' do
+    let(:klass) do
+      Class.new do
+        def self.name
+          @name ||= "Vehicle_#{rand(1_000_000)}"
+        end
+      end
+    end
+
+    let(:machine) { StateMachines::Machine.new(klass, :state_id, initial: :parked) }
+    before(:each) do
+      machine.event :ignite do
+        transition parked: :idling
+      end
+      machine.state :parked, value: 1
+      machine.state :idling, value: 2
+    end
+
+    let!(:graph) { machine.draw }
+
+    it 'should_draw_all_states' do
+      expect(graph.node_count).to eq(3)
+    end
+
+    it 'should_draw_all_events' do
+      expect(graph.edge_count).to eq(2)
+    end
+
+    it 'should_draw_machine' do
+      expect(File.exist?("doc/state_machines/#{klass.name}_state_id.png")).to be_truthy
+    end
+
+    after(:each) do
+      FileUtils.rm Dir["doc/state_machines/#{klass.name}_state_id.png"]
+    end
+  end
+
+  context 'DrawingWithNilStates' do
+    let(:klass) do
+      Class.new do
+        def self.name
+          @name ||= "Vehicle_#{rand(1_000_000)}"
+        end
+      end
+    end
+    let(:machine) { StateMachines::Machine.new(klass, initial: :parked) }
+
+    before(:each) do
+      machine.event :ignite do
+        transition parked: :idling
+      end
+      machine.state :parked, value: nil
+    end
+
+    let!(:graph) { machine.draw }
+
+    it 'should_draw_all_states' do
+      expect(graph.node_count).to eq(3)
+    end
+
+    it 'should_draw_all_events' do
+      expect(graph.edge_count).to eq(2)
+    end
+
+    it 'should_draw_machine' do
+      expect(File.exist?("doc/state_machines/#{klass.name}_state.png")).to be_truthy
+    end
+
+    after(:each) do
+      FileUtils.rm Dir["doc/state_machines/#{klass.name}_state.png"]
+    end
+  end
+
+  context 'DrawingWithDynamicStates' do
+    let(:klass) do
+      Class.new do
+        def self.name
+          @name ||= "Vehicle_#{rand(1_000_000)}"
+        end
+      end
+    end
+
+    let(:machine) { StateMachines::Machine.new(klass, initial: :parked) }
+
+    before(:each) do
+      machine.event :activate do
+        transition parked: :idling
+      end
+      machine.state :idling, value: lambda { Time.now }
+    end
+
+    let!(:graph) { machine.draw }
+
+    it 'should_draw_all_states' do
+      expect(graph.node_count).to eq(3)
+    end
+
+    it 'should_draw_all_events' do
+      expect(graph.edge_count).to eq(2)
+    end
+
+    it 'should_draw_machine' do
+      expect(File.exist?("doc/state_machines/#{klass.name}_state.png")).to be_truthy
+    end
+
+    after(:each) do
+      FileUtils.rm Dir["doc/state_machines/#{klass.name}_state.png"]
+    end
+
+  end
+
+  context 'ClassDrawing' do
+    before(:each) do
+      klass = Class.new do
+        def self.name
+          @name ||= "Vehicle_#{rand(1_000_000)}"
+        end
+      end
+      machine = StateMachines::Machine.new(klass)
+      machine.event :ignite do
+        transition parked: :idling
+      end
+    end
+
+    it 'should_raise_exception_if_no_class_names_specified' do
+      expect { StateMachines::Machine.draw(nil) }.to raise_error(ArgumentError)
+      # FixMe
+      # assert_equal 'At least one class must be specified', exception.message
+    end
+
+    it 'should_load_files' do
+      StateMachines::Machine.draw('Switch', file: File.expand_path("#{File.dirname(__FILE__)}/files/switch.rb"))
+      expect(defined?(::Switch)).to be_truthy
+    end
+
+    it 'should_allow_path_and_format_to_be_customized' do
+      StateMachines::Machine.draw('Switch', file: File.expand_path("#{File.dirname(__FILE__)}/files/switch.rb"), path: "#{File.dirname(__FILE__)}/", format: 'jpg')
+      expect(File.exist?("#{File.dirname(__FILE__)}/#{Switch.name}_state.jpg")).to be_truthy
+      FileUtils.rm Dir["{.,#{File.dirname(__FILE__)}}/#{Switch.name}_state.{jpg,png}"]
+    end
+  end
+end

data/spec/machine_spec.rb

@@ -0,0 +1,19 @@
+describe StateMachines::Machine do
+  before(:each) do
+     klass =  Class.new do
+       def self.name
+         @name ||= "Vehicle_#{rand(1_000_000)}"
+       end
+     end
+
+    @machine = StateMachines::Machine.new(klass, initial: :parked)
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+  end
+
+  it 'should not raise exception' do
+    expect { @machine.draw }.not_to raise_error
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'state_machines'
+require 'state_machines/graphviz'

data/spec/state_spec.rb

@@ -0,0 +1,142 @@
+context 'Drawing' do
+  before(:each) do
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, :value => 1)
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+
+    graph = StateMachines::Graph.new('test')
+    @state.draw(graph)
+    @node = graph.get_node('parked')
+  end
+
+  it 'should_use_ellipse_shape' do
+    expect(@node['shape'].to_s.gsub('"', '')).to eq('ellipse')
+  end
+
+  it 'should_set_width_to_one' do
+    expect('1').to eq(@node['width'].to_s.gsub('"', ''))
+  end
+
+  it 'should_set_height_to_one' do
+    expect('1').to eq(@node['height'].to_s.gsub('"', ''))
+  end
+
+  it 'should_use_description_as_label' do
+    expect('parked (1)').to eq(@node['label'].to_s.gsub('"', ''))
+  end
+end
+
+context 'DrawingInitial' do
+  before(:each) do
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, :initial => true)
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+
+    @graph = StateMachines::Graph.new('test')
+    @state.draw(@graph)
+    @node = @graph.get_node('parked')
+  end
+
+  it 'should_use_ellipse_as_shape' do
+    expect('ellipse').to eq(@node['shape'].to_s.gsub('"', ''))
+  end
+
+  it 'should_draw_edge_between_point_and_state' do
+    expect(2).to eq(@graph.node_count)
+    expect(1).to eq(@graph.edge_count)
+  end
+end
+
+context 'DrawingNilName' do
+  before(:each) do
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, nil)
+
+    graph = StateMachines::Graph.new('test')
+    @state.draw(graph)
+    @node = graph.get_node('nil')
+  end
+
+  it 'should_have_a_node' do
+    expect(@node).to be_truthy
+  end
+
+  it 'should_use_description_as_label' do
+    expect('nil').to eq(@node['label'].to_s.gsub('"', ''))
+  end
+end
+
+context 'DrawingLambdaValue' do
+  before(:each) do
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, :value => lambda {})
+
+    graph = StateMachines::Graph.new('test')
+    @state.draw(graph)
+    @node = graph.get_node('parked')
+  end
+
+  it 'should_have_a_node' do
+    expect(@node).to be_truthy
+  end
+
+  it 'should_use_description_as_label' do
+    expect('parked (*)').to eq(@node['label'].to_s.gsub('"', ''))
+  end
+end
+
+context 'DrawingNonFinal' do
+  before(:each) do
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked)
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+
+    graph = StateMachines::Graph.new('test')
+    @state.draw(graph)
+    @node = graph.get_node('parked')
+  end
+
+  it 'should_use_ellipse_as_shape' do
+    expect('ellipse').to eq(@node['shape'].to_s.gsub('"', ''))
+  end
+end
+
+context 'DrawingFinal' do
+  before(:each) do
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked)
+
+    graph = StateMachines::Graph.new('test')
+    @state.draw(graph)
+    @node = graph.get_node('parked')
+  end
+
+  it 'should_use_doublecircle_as_shape' do
+    expect('doublecircle').to eq(@node['shape'].to_s.gsub('"', ''))
+  end
+end
+
+context 'DrawingWithHumanName' do
+  before(:each) do
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, :human_name => 'Parked')
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+
+    graph = StateMachines::Graph.new('test')
+    @state.draw(graph, :human_name => true)
+    @node = graph.get_node('parked')
+  end
+
+  it 'should_use_description_with_human_name_as_label' do
+    expect('Parked').to eq(@node['label'].to_s.gsub('"', ''))
+  end
+end
+

data/state_machines-graphviz.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'state_machines/graphviz/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'state_machines-graphviz'
+  spec.version       = StateMachines::Graphviz::VERSION
+  spec.authors       = ['Abdelkader Boudih', 'Aaron Pfeifer']
+  spec.email         = ['terminale@gmail.com']
+  spec.summary       = %q(Drawing module for state machine2)
+  spec.description   = %q(Graphviz module for state machine2)
+  spec.homepage      = 'https://github.com/seuros/state_machines-graphviz'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{/^spec\//})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'state_machines'
+  spec.add_dependency 'ruby-graphviz'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec' , '3.0.0.beta2'
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: state_machines-graphviz
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Abdelkader Boudih
+- Aaron Pfeifer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: state_machines
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-graphviz
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta2
+description: Graphviz module for state machine2
+email:
+- terminale@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yaml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/state_machines/graphviz.rb
+- lib/state_machines/graphviz/graph.rb
+- lib/state_machines/graphviz/monkeypatch.rb
+- lib/state_machines/graphviz/version.rb
+- spec/files/switch.rb
+- spec/graph_spec.rb
+- spec/machine_drawing_spec.rb
+- spec/machine_spec.rb
+- spec/spec_helper.rb
+- spec/state_spec.rb
+- state_machines-graphviz.gemspec
+homepage: https://github.com/seuros/state_machines-graphviz
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Drawing module for state machine2
+test_files: []
+has_rdoc: