tla2dot 0.0.3

data/lib/tla2dot/parser.y

@@ -0,0 +1,415 @@
+# -*- mode: ruby -*-
+#
+# Parse state dump from TCL tlaplus
+
+class Tla2DotParser
+
+
+
+  options no_result_var
+
+rule
+
+  target    : entries                { @graph }
+
+  entries   : entry
+            | entries entry
+  
+  entry     : state                   { @graph.add_node( val[0] )  }
+            | trans                  
+
+            
+  trans     : TRANS  '-->' INTEGER    { @graph.add_edge( val[0], val[2] ) }
+
+
+  # state     : STATE variables         { Node.new( val[0], val[1] ) }
+  #           | STATE                   { Node.new( val[0], {} ) }
+
+  state     : state_def variables       { val[0].variables=val[1]; val[0] }
+            | state_def
+
+  state_def : state_id
+            | state_id actiondef
+             
+  state_id : STATE                   { Node.new( val[0], {} ) }
+
+
+  actiondef : '<' actionspecs '>'
+
+  actionspecs : actionspec
+              | actionspecs actionspec
+
+ actionspec : IDENT
+            | ','
+            | INTEGER
+  
+  variables : variable                
+            | variables variable      { k=val[1].keys.first; val[0][k] = val[1][k]; val[0] }
+
+  variable  : AND name '=' value      { {  val[1] => val[3] } }
+  
+  name      : IDENT
+
+  value     : INTEGER                 { val[0].to_i }         
+            | STRING
+            | IDENT
+            | record
+            | set
+            | seq
+
+  record    : '['  ']'                { {} }
+            | '[' rlist ']'           { val[1] }
+
+  rlist     : ritem                   { val[0] }
+            | rlist ',' ritem         { k=val[2].keys.first; val[0][k] = val[2][k]; val[0] }
+
+  ritem     : name '|->' value        { { val[0] => val[2] } }
+
+
+  seq       : '<' '<' '>' '>'         { [] }
+            | '<' '<' seqlist '>' '>' { val[2] }
+
+  seqlist   : seqitem                  
+            | seqlist ','   seqitem   { val[0].push( val[2][0] ); val[0] }
+
+  seqitem   : value                   { [ val[0] ] }
+  
+  
+  set       : '{' '}'                 { [] }
+            | '{' slist '}'           { val[1] }
+
+  slist     : sitem                  
+            | slist ','   sitem      { val[0].push( val[2][0] ); val[0] }
+
+  sitem     : value                  { [ val[0] ] }
+
+end
+
+---- inner
+
+class Node
+
+  include TLA2DOT::Utils::MyLogger    # mix logger
+  
+  @@logger = nil;                     # common logger for all nodes
+  @@options = {};                     # common logger for all nodes
+
+
+  # ------------------------------------------------------------------
+  # Attributes
+
+  # instance 
+  attr_accessor :name       #
+  attr_accessor :variables  # hash of name=>
+  attr_accessor :edges      # list of nodes reachable
+
+  # ------------------------------------------------------------------
+  # constructore
+  def initialize( name, variables )
+    @name = name
+    @variables = variables
+    @edges = []
+    @filter_render_variables = []
+  end
+
+  def myLogger
+    return @@logger if @@logger
+    @@logger = getLogger( "Node", getOptions )
+    @@logger.info( "#{__method__} created" )
+    @@logger
+  end
+  
+  def setOptions( options )
+    @@options = options
+  end
+
+  def getOptions
+    @@options 
+  end
+  
+  def name
+    @name
+  end
+
+  def variables=( variables )
+    @variables = variables
+  end
+
+  def variables
+    @variables
+  end
+
+  def ==( node )
+    node.respond_to?( :name) && self.name == node.name
+  end
+
+  def add_edge( node )
+    @edges << node unless @edges.include?( node ) 
+  end
+  
+  def successor_cnt
+    @edges.size
+  end
+
+  # array of successors for the node
+  def successors
+    @edges
+  end
+
+  # array tranitions (from_state->to_state) from this node to another
+  def transitions
+    myLogger.debug( "#{__method__} starting" )
+    successors.select{ |n| n.name != name }.map{ |n| { :to_state => n.name, :from_state => self.name } }
+  end
+
+  # array of variable names to render
+  def filter_render_variables
+    myLogger.debug( "#{__method__} filter_render_variables=#{@filter_render_variables} #{@filter_render_variables.class}" )
+    @filter_render_variables
+  end
+
+  # called when added to graph
+  def filter_render_variables=( variables )
+
+    @filter_render_variables = variables
+  end
+
+  # return true is state should show variable
+  def include_variable( variable )
+    
+    return filter_render_variables.include?( variable ) if
+      filter_render_variables.kind_of?( Array )
+
+    # assume boolean
+    return filter_render_variables
+
+  end
+  
+
+  # node variable to render as key/state hash (including 'id')
+  def content
+    myLogger.debug( "#{__method__} starting" )
+    vars = variables;
+    vars['ID'] = name
+    vars.select{ |k,v| include_variable( k ) }.
+      map { |k,v|
+         {:key =>k, :val => v, :state => render_value(v) }
+      }
+      
+  end
+
+  # escape for mustache rendering
+  def render_value( v )
+    return v.to_s.
+            gsub( /\{/, "\\{" ).
+            gsub( /\}/, "\\}" ).
+            gsub( /=>/, "=" ).
+            # gsub( /\{/, "" ).
+            # gsub( /\}/, "" ).
+            # gsub( /\[/, "" ).
+            # gsub( /\]/, "" ).
+            # gsub( /\[/, "\\[" ).
+            # gsub( /\]/, "\\]" ).
+            gsub( /"/, '\\"' )
+    # case
+    # when v.kind_of?( Hash )
+    #   return v.to_s.gsub( /\{/, "\\{" ).gsub( /\}/, "\\}" )
+    # else
+    #   return v
+    # end
+        
+  end
+  
+
+end
+
+
+class Graph
+
+  include TLA2DOT::Utils::MyLogger    # mix logger
+
+
+  attr_reader :nodes       #
+  
+  def initialize( filter_render_variables, options )
+    @nodes = {}
+    # filter_render_variables passed to node
+    @filter_render_variables = filter_render_variables
+    setOptions( options )
+  end
+
+  def myLogger
+    return @logger if @logger
+    @logger = getLogger( "Graph", getOptions )
+    @logger.info( "#{__method__} created" )
+    @logger
+  end
+
+
+  def setOptions( options )
+    @options = options
+  end
+
+  def getOptions
+    @options
+  end
+
+  def add_node(node)
+    node.filter_render_variables=( @filter_render_variables )
+    node.setOptions( getOptions )
+    myLogger.debug( "#{__method__} added node #{node}, @filter_render_variables=#{@filter_render_variables} #{@filter_render_variables.class}" )
+    @nodes[node.name] = node
+    self
+  end
+
+  
+  def nodes
+    @nodes
+  end
+
+  def states
+    @nodes.values
+  end
+  
+
+  def node_cnt
+    @nodes.size
+  end
+
+
+  def add_edge(predecessor_name, successor_name)
+
+    predecessor_node = @nodes[predecessor_name]
+    raise "Unknown precessor node #{predecessor_name}" unless predecessor_node
+    successor_node = @nodes[successor_name]
+    raise "Unknown precessor node #{successor_name}" unless successor_node
+    @nodes[predecessor_name].add_edge(@nodes[successor_name])
+  end
+
+  def [](name)
+    @nodes[name]
+  end  
+end
+
+# ------------------------------------------------------------------
+
+  include TLA2DOT::Utils::MyLogger    # mix logger
+  PROGNAME = "parser"               # progname for logger
+
+  def initialize( options = {} )
+    @logger = getLogger( PROGNAME, options )
+    @logger.debug( "#{__method__} initialized" )
+    setOptions( options )
+  end
+  
+  def setOptions( options )
+    @options = options
+  end
+
+  def getOptions
+    @options
+  end
+
+  
+
+# entry point
+def parse(str, filter_render_variables = [] )
+  @logger.info( "#{__method__} parsing started" )
+  @graph = Graph.new( filter_render_variables, getOptions )
+  @line = 0
+  return @graph  if str.nil? || str.empty? 
+  @str = str.kind_of?( Array ) ? str : [ str ]
+  begin
+    ret = yyparse self, :scan
+    @logger.info( "#{__method__} parsing done" )
+    return ret
+  rescue Exception => e
+    puts "Error on line #{@line} near #{@current}"
+    @logger.error( "#{__method__} error #{e}" )
+    # puts e
+    return nil
+  end
+end
+
+private
+
+# return next line for scanner
+def next_str
+  @current =  @str.any? ? @str.shift : nil
+  @line += 1
+  @current
+end
+
+
+# racc token scanner
+def scan
+  while true
+    str = next_str
+    break if str.nil?
+    until str.empty?
+      case str
+      when /\A\s+/
+        str = $'
+      when /\AState (\d+):/
+        yield [ :STATE, $1 ]
+        str = $'
+      when /\AState (\d+)\/(-?\d+):/
+        # using fingerprint name
+        yield [ :STATE, $2 ]
+        str = $'
+      when /\AState (\d+):/
+        yield [ :STATE, $1 ]
+        str = $'
+      when /\ATransition ([0-9\-\+]+)/
+        yield [ :TRANS, $1 ]
+        str = $'
+      when /\A"([^"]*)"*/
+        yield [ :STRING, $1 ]
+        str = $'
+      when /\A[a-zA-Z]\w*/
+        yield [ :IDENT, $& ]
+        str = $'
+      when /\A-?\d+/
+        yield [ :INTEGER, $& ]
+        str = $'
+      when /\A\/\\/
+        yield [ :AND, $& ]
+        str = $'
+      when /\A\|->/
+        yield [ $&, $& ]
+        str = $'
+      # when /\A\n/
+      #   puts "Nl"
+      #   yield [ :NL, $& ]
+      #   str = $'
+      when /\A\-->/
+        yield [ $&, $& ]
+        str = $'
+      when /\A=/
+        yield [ $&, $& ]
+        str = $'
+      else
+        c = str[0,1]
+        yield [ c, c ]
+        str = str[1..-1]
+      end
+    end # until
+  end # while
+  yield [ false, '$']   # is optional from Racc 1.3.7
+end
+
+---- footer
+
+if $0 == __FILE__
+  src = <<EOS
+{
+  name => MyName,
+  id => MyIdent
+}
+EOS
+  puts 'Parsing (String):'
+  print src
+  puts
+  puts 'Result (Ruby Object):'
+  p HashParser.new.parse(src)
+end

data/lib/tla2dot/template.rb

@@ -0,0 +1,184 @@
+require 'mustache'                   # extendending implementation of
+
+module TLA2DOT
+
+  class Template < Mustache
+
+    include TLA2DOT::Utils::MyLogger    # mix logger
+    PROGNAME = "template"               # progname for logger
+
+    # ------------------------------------------------------------------
+    # Attributes
+
+    # instance 
+    attr_writer :partials            # f: partial-name --> template string
+    attr_writer :templates           # f: template-name --> template string
+
+    # ------------------------------------------------------------------
+    # Constructor
+    
+    def initialize( options={} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} created" )
+      @logger.debug( "#{__method__}, options='#{options}" )
+
+      @template_extension = "mustache"# type part in filename
+
+      # for mustache templates
+      if options[:templates] then
+        @template_paths = options[:templates]
+      else
+        @template_paths = TLA2DOT::Cli::TEMPLATES
+      end
+      # init partial cache
+      @partials = {}
+
+    end
+
+    # ------------------------------------------------------------------
+    # Services
+    
+    def to_str( template_name, data )
+      @logger.info( "#{__method__}: template_name=#{template_name}, data=#{data}, nodes.size=#{data.nodes.size}" )
+      # @logger.debug( "#{__method__}: nodes=#{data.nodes}" )
+      @data = data
+      template = get_template( template_name )
+      render( template, { :tsti=>"moikka", :data=>data, "tst" => "hello" } )
+
+    end
+
+
+    # def data
+    #   @data
+    # end
+    
+    
+
+    # ------------------------------------------------------------------
+    # Integrate with mustache
+
+    # method used by mustache framework - delegate to 'get_partial'
+    def partial(name)
+      @logger.debug( "#{__method__} name=#{name}" )
+      get_partial( name )
+    end
+
+    # cache @partials - for easier extension
+    def get_partial( name ) 
+      @logger.debug( "#{__method__} name=#{name}" )
+      return @partials[name] if @partials[name]
+
+      partial_file = get_template_filepath( name )
+      @logger.info( "#{__method__} read partial_file=#{partial_file}" )
+      @partials[name] = File.read( partial_file )
+      @partials[name]
+    end
+
+    # hide @templates - for easier extension
+    def get_template( name ) 
+
+      template_file = get_template_filepath( name )
+      @logger.info( "#{__method__} read template_file=#{template_file}" )
+      File.read( template_file )
+
+    end # def get_template( name ) 
+
+
+    # return path to an existing template file name 
+    private
+
+    def get_template_filepath( name ) 
+
+      @template_paths.each do |directory_or_gemname| 
+
+        template_path = get_template_filepath_resolve( directory_or_gemname, name ) 
+        
+        return template_path if File.exists?( template_path ) 
+
+      end # each 
+
+
+      # could not find 
+      
+      raise <<-eos
+
+          No such template '#{name}' found in directories: #{@template_paths.join(", ")}
+ 
+          Use opition -t list directories or Gems, where file '#{name}.#{@template_extension}' can be located.
+        
+        eos
+
+
+    end
+
+    # return path to plain 'directory' or to gem directory
+    def get_template_filepath_resolve( directory_or_gemname, template_file )
+      @logger.info( "#{__method__} directory_or_gemname=#{directory_or_gemname}" )
+      if directory_or_gemname[-1] == '/' then
+        return get_template_filepath_in_directory( directory_or_gemname[0..-2], template_file )
+      else
+        directory = gemname_to_directory( directory_or_gemname )
+        return get_template_filepath_in_directory( directory, template_file )
+      end
+    end
+
+    # return directory to 'gemspec'
+    def gemname_to_directory( gemname_and_spec ) 
+
+      # The version requirements are optional.
+      # You can also specify multiple version requirements, just append more at the end
+      gem_spec = gemname_and_spec.split(',')
+      gem_name, *gem_ver_reqs = gem_spec[0], gem_spec[1]
+      @logger.debug( "#{__method__}, gem_name=#{gem_name}, *gem_ver_reqs=#{gem_ver_reqs}" )
+      gdep = Gem::Dependency.new(gem_name, *gem_ver_reqs)
+      # find latest that satisifies
+      found_gspec = gdep.matching_specs.sort_by(&:version).last
+      @logger.debug( "#{__method__}, found_gspec=#{found_gspec}" )
+      # instead of using Gem::Dependency, you can also do:
+      # Gem::Specification.find_all_by_name(gem_name, *gem_ver_reqs)
+
+      if found_gspec
+        @logger.debug( "#{__method__}, Requirement '#{gdep}' already satisfied by #{found_gspec.name}-#{found_gspec.version}" )
+        template_path = "#{found_gspec.gem_dir}/mustache"
+        @logger.debug( "#{__method__}, template_path=#{template_path}" )
+      else
+        #puts "Requirement '#{gdep}' not satisfied; installing..."
+        # ver_args = gdep.requirements_list.map{|s| ['-v', s] }.flatten
+        # # multi-arg is safer, to avoid injection attacks
+        # system('gem', 'install', gem_name, *ver_args)
+        raise "Could not find gem '#{gdep}' - try 'gem install #{gdep}'"
+      end
+      
+      return template_path
+
+    end
+    
+
+    # return path to 'template_file' in an existing 'directory'
+    def get_template_filepath_in_directory( directory, template_file ) 
+      @logger.debug( "#{__method__} directory=#{directory}, template_file=#{template_file}" )
+
+      if ! File.exists?( directory ) then
+        raise <<-eos
+
+          No such directory '#{directory}'.
+ 
+          Option -t should list
+          - existing paths OR
+          - Gems which includes 'mustache' directory
+        
+        eos
+
+      end
+
+      template_path = "#{directory}/#{template_file}.#{@template_extension}"
+      @logger.info( "#{__method__} read template_path=#{template_path}" )
+      
+      return template_path
+
+    end
+
+
+  end # class
+
+end # module

data/lib/tla2dot.rb

@@ -0,0 +1,10 @@
+# tla2dot.rb
+
+require_relative "utils/logger.rb"
+
+require_relative "tla2dot/parser.tab.rb"
+require_relative "tla2dot/template.rb"
+require_relative "cli/cli.rb"
+
+
+

data/lib/utils/logger.rb

@@ -0,0 +1,70 @@
+require 'logger'
+
+# see http://hawkins.io/2013/08/using-the-ruby-logger/
+
+module TLA2DOT
+  
+  module Utils
+    
+    module MyLogger
+
+      # no logging done
+
+      class NullLoger < Logger
+        def initialize(*args)
+        end
+
+        def add(*args, &block)
+        end
+      end
+
+      LOGFILE="tla2dot.log"
+
+      def getLogger( progname, options={} ) 
+
+        level = get_level( options )
+
+        if level.nil? 
+
+          return NullLoger.new 
+
+        else
+          
+          logger = Logger.new( LOGFILE )
+          logger.level=level
+          logger.progname = progname
+          return logger
+
+        end 
+
+      end # getLogger
+
+      # ------------------------------------------------------------------
+      private
+
+      def get_level( options ) 
+
+        # puts  "#{__method__}: options=#{options}" 
+
+        level_name = options && options[:log] ? options[:log] : ENV['LOG_LEVEL']
+
+        level = case  level_name
+                when 'warn', 'WARN'
+                  Logger::WARN
+                when 'info', 'INFO'
+                  Logger::INFO
+                when 'debug', 'DEBUG'
+                  Logger::DEBUG
+                when 'error', 'ERROR'
+                  Logger::ERROR
+                else
+                  nil
+                end
+
+        return level
+      end
+
+    end
+
+  end 
+end

data/mustache/defaults.mustache

@@ -0,0 +1,19 @@
+   fontname = "Bitstream Vera Sans";
+   fontsize = 8;
+   shape = "record";
+   labeljust="l";
+   rankdir=LR;
+
+
+   node      [     fontname = "Courier"
+                   fontsize = 8
+                   shape = "record"
+
+             ];
+
+   edge      [
+                  fontname = "Bitstream Vera Sans"
+                  fontsize = 8
+                  arrowhead = "none"
+            ];
+

data/mustache/root.mustache

@@ -0,0 +1,20 @@
+digraph G {
+
+    /* font size layout etc. */
+    {{> defaults }}
+
+    /* nodes */
+    {{# data }}
+    	 {{# states}}
+	     {{name}} [{{> stateOutput }}];
+         {{/ states}}
+    {{/ data }}
+
+    /* arcs */
+    {{# data }}
+    	 {{# states}}{{# transitions }} {{ from_state }} -> {{to_state}};
+	    {{/ transitions }}{{/ states}}
+    {{/ data }}
+
+
+}