tla-trace-filter 0.0.3

data/lib/parser/parser.rb

@@ -0,0 +1,85 @@
+# coding: utf-8
+require "treetop"
+
+require File.join( File.dirname( __FILE__), 'node_extensions.rb')
+
+module TlaTraceFilter
+  module Parser
+
+    class ParseException < Exception; end
+    
+    class Parser
+
+      # @# @!attribute [TlaTracefilter::Parser::Parser] parser  
+      # Load the Treetop grammar from the 'sexp_parser' file, and 
+      # create a new instance of that parser as a class variable 
+      # so we don't have to re-create it every time we need to 
+      # parse a string
+      @@parser = nil
+
+      def initialize( options={} )
+      end
+
+      def self.parser_instance
+        return @@parser if @@parser
+        grammarPath = File.join( File.dirname( __FILE__),  "grammar.treetop")
+        Treetop.load( grammarPath )
+        @@parser = TlaTraceFilter::Parser::GrammarParser.new        
+      end
+
+      # ------------------------------------------------------------------
+      # @!group Services
+
+      # Parse 'data' starting with symbol start.
+      #
+      # @param start [Symbol] treetop grammar rule where to start
+      #
+      # @return [SyntaxNode] Parser tree 
+      def parse( data, start = nil )
+        parser = self.class.parser_instance
+        tree = parser.parse(data, :root=>start )
+
+        # If the AST is nil then there was an error during parsing
+        # we need to report a simple error message to help the user
+        if(tree.nil?)
+          # adopted from http://whitequark.org/blog/2011/09/08/treetop-typical-errors/
+          parser.failure_reason =~ /(Expected .*) after/m
+          expected = $1.nil? ? parser.failure_reason : $1
+          msg= <<~EOS
+          Parse error:
+          Line     : #{parser.failure_line}, offset   : #{parser.index}
+          #{expected.gsub( "\n", '$NEWLINE')}
+          #{data.lines.to_a[ parser.failure_line()-1 ]}
+          #{'~' * (parser.failure_column-1)}^
+          EOS
+          # puts msg
+          raise ParseException.new msg
+        end
+
+        # self.class.clean_tree( tree )
+        
+        tree
+      end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group prvate helpser
+
+      # we have created a tree from our input, but it has a lot of
+      # extraneous nodes that we don’t need or care about. Let’s put in
+      # a system for cleaning up the tree:
+      def self.clean_tree(root_node)
+        return if(root_node.elements.nil?)
+        # comment the following line if parse loosees nodes
+        root_node.elements.delete_if{|node| node.class.name == "Treetop::Runtime::SyntaxNode" }
+        root_node.elements.each {|node| self.clean_tree(node) }
+      end    
+
+      # @!endgroup
+
+      
+    end # class parser
+    
+  end
+end

data/lib/render/render.rb

@@ -0,0 +1,510 @@
+# coding: utf-8
+require "mustache"
+require "json"
+require "yaml"
+module TlaTraceFilter
+
+
+  class RenderException < Exception; end
+  
+  
+  class Render < Mustache
+
+    include TlaTraceFilter::Util::MyLogger
+
+    # ------------------------------------------------------------------
+    # @!group Constants
+
+    # Default templates for inputState, call, and outputState
+    API_INPUT_STATE_DEFAULT_PARTIAL  = "api-call-input"    
+    API_CALL_DEFAULT_PARTIAL         = "api-call-default"
+    API_RETURN_DEFAULT_PARTIAL       = "api-call-return"    
+    API_OUTPUT_STATE_DEFAULT_PARTIAL = "api-call-output"
+
+    # Keys mapping to the output templates
+    API_DEFAULT_KEY = "default"
+    API_EMPTY_KEY = "empty"    
+    
+    # @!endgroup
+
+    
+    # ------------------------------------------------------------------
+    # @!group Attributes
+
+    # @# @!attribute [Hash] hash mapping partial names to mustache templates  
+    attr_accessor :partials
+
+    # @# @!attribute [Array] templatePath array of path to search for
+    # templates
+    attr_accessor :templatePaths
+
+    # @# @!attribute [Hash] callPartials hash mapping interface-names
+    #                (with default) to partial name
+    attr_accessor :callPartials
+    
+    # @# @!attribute [Hash] returnPartials hash mapping interface-names
+    #                (with default) to partial name
+    attr_accessor :returnPartials
+    
+    # @# @!attribute [Hash] inputStatePartials hash mapping interface-names
+    #                (with default) to partial name
+    attr_accessor :inputStatePartials
+    
+    # @# @!attribute [Hash] outputStatePartials hash mapping interface-names
+    #                (with default) to partial name
+    attr_accessor :outputStatePartials
+    
+    # @!endgroup
+
+
+    # ------------------------------------------------------------------
+    # @!group Constructor
+
+    def initialize( options = {} )
+      # super
+      @logger = getLogger( nil, options )
+      @logger.info "#{__method__}: initalized"
+
+      configMustache( options )
+      
+      initPartials
+      
+    end
+
+    def configMustache( options )
+
+      # exception for non existing reference
+      self.raise_on_context_miss=options[:debug_mustache] 
+      
+      # default search only GEM templates
+      self.templatePaths =  [ File.join( File.dirname(__FILE__), "../../mustache/") ]
+      # user defined template search path prepended
+      self.templatePaths =  [ options[:mustache] ] + templatePaths if options[:mustache]
+    end
+
+    def initPartials
+      self.partials = {}
+      API_CALL_INIT( "" )
+      API_RETURN_INIT( "" )
+      API_INPUT_STATE_INIT( "" )
+      API_OUTPUT_STATE_INIT( "" )
+      # self.callPartials = {}
+      # self.inputStatePartials = {}
+      # self.outputStatePartials = {}      
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Initialize dynamic dispatchers
+
+    # Lambda to configure API_CALL dynamic dispatch. If no data given
+    # results calling to default templates
+    def API_CALL_INIT( data )
+      @logger.info "#{__method__}: data=#{data}"
+      begin 
+        self.callPartials = data.nil? || data == "" ? {} : YAML.load( data )
+      rescue Exception => e
+        msg = <<-EOS
+        #{e}
+
+        Error parsing YAML data in API_CALL_INIT:
+
+        #{data}
+        EOS
+        @logger.error( "#{__method__}: #{msg}" )                    
+        raise Exception.new, msg, e.backtrace
+      end
+
+      @logger.debug "#{__method__}: callPartials=#{callPartials}" if @logger.debug?
+      
+      # ensure that 'default' and 'empty' partials are defined
+      self.callPartials[API_DEFAULT_KEY] = API_CALL_DEFAULT_PARTIAL if callPartials[API_DEFAULT_KEY].nil?
+      self.callPartials[API_EMPTY_KEY] = API_CALL_DEFAULT_PARTIAL if callPartials[API_EMPTY_KEY].nil?      
+      
+    end
+
+    
+    # Initiliaze template api return templates. If no data given
+    # results calling to default templates
+    def API_RETURN_INIT( data )
+      
+      @logger.info "#{__method__}: data=#{data}"
+      begin 
+        self.returnPartials = data.nil? || data == "" ? {} : YAML.load( data )
+      rescue Exception => e
+        msg = <<-EOS
+        #{e}
+
+        Error parsing YAML data in API_RETURN_INIT:
+
+        #{data}
+        EOS
+        @logger.error( "#{__method__}: #{msg}" )                    
+        raise Exception.new, msg, e.backtrace
+      end
+
+      @logger.debug "#{__method__}: returnPartials=#{returnPartials}" if @logger.debug?
+      
+      # ensure that 'default' and 'empty' partials are defined
+      self.returnPartials[API_DEFAULT_KEY] = API_RETURN_DEFAULT_PARTIAL if returnPartials[API_DEFAULT_KEY].nil?
+      self.returnPartials[API_EMPTY_KEY] = API_RETURN_DEFAULT_PARTIAL if returnPartials[API_EMPTY_KEY].nil?      
+      
+    end
+    
+    # Initiliaze template calls. If no data given results calling to
+    # default templates
+    def API_INPUT_STATE_INIT( data)
+      @logger.info "#{__method__}: data=#{data}"
+      begin 
+        self.inputStatePartials = data.nil? || data == "" ? {} : YAML.load( data )
+      rescue Exception => e
+        msg = <<-EOS
+        #{e}
+
+        Error parsing YAML data in API_INPUT_STATE_INIT:
+
+        #{data}
+        EOS
+        @logger.error( "#{__method__}: #{msg}" )                    
+        raise Exception.new, msg, e.backtrace
+      end
+
+      @logger.debug "#{__method__}: inputStatePartials=#{inputStatePartials}" if @logger.debug?
+      
+      # ensure that 'default' and 'empty' partials are defined
+      self.inputStatePartials[API_DEFAULT_KEY] = API_INPUT_STATE_DEFAULT_PARTIAL if inputStatePartials[API_DEFAULT_KEY].nil?
+      self.inputStatePartials[API_EMPTY_KEY] = API_OUTPUT_STATE_DEFAULT_PARTIAL if inputStatePartials[API_EMPTY_KEY].nil?      
+      
+    end
+
+    # Lambda to initiliaze template calls. If no data given results
+    # calling to default templates
+    def API_OUTPUT_STATE_INIT( data)
+      @logger.info "#{__method__}: data=#{data}"
+      begin 
+        self.outputStatePartials = data.nil? || data == "" ? {} : YAML.load( data )
+      rescue Exception => e
+        msg = <<-EOS
+        #{e}
+
+        Error parsing YAML data in API_INIT:
+
+        #{data}
+        EOS
+        @logger.error( "#{__method__}: #{msg}" )                    
+        raise Exception.new, msg, e.backtrace
+      end
+
+      @logger.debug "#{__method__}: outputStatePartials=#{outputStatePartials}" if @logger.debug?
+      
+      # ensure that 'default' and 'empty' partials are defined
+      self.outputStatePartials[API_DEFAULT_KEY] = API_OUTPUT_STATE_DEFAULT_PARTIAL if outputStatePartials[API_DEFAULT_KEY].nil?
+      self.outputStatePartials[API_EMPTY_KEY] = API_OUTPUT_STATE_DEFAULT_PARTIAL if outputStatePartials[API_EMPTY_KEY].nil?      
+      
+    end
+    
+
+    # @return [String] name of partial template to render API-return for
+    #         interfaceOperation, use default if not found
+    #
+    # Implementation makes a lookup to returnPartials
+    def getReturnPartialName( interfaceOperation ) # 
+      returnPartialName = nil
+      returnPartialName = returnPartials[API_EMPTY_KEY] if interfaceOperation.nil?
+      returnPartialName = returnPartials[interfaceOperation] if returnPartialName.nil?
+      returnPartialName = returnPartials[API_DEFAULT_KEY] if returnPartialName.nil?
+      raise "Missing could not resolve '#{interfaceOperation}' in returnPartials #{returnPartials}" if returnPartialName.nil?
+      @logger.info "#{__method__}: API-return to interfaceOperation '#{interfaceOperation}' render with '#{returnPartialName}'"
+      returnPartialName
+    end
+
+    # @return [String] name of partial template to render API-call for
+    #         interfaceOperation, use default if not found
+    #
+    # Implementation makes a lookup to callPartials
+    def getCallPartialName( interfaceOperation ) # 
+      
+      callPartialName = nil
+      callPartialName = callPartials[API_EMPTY_KEY] if interfaceOperation.nil?
+      callPartialName = callPartials[interfaceOperation] if callPartialName.nil?
+      callPartialName = callPartials[API_DEFAULT_KEY] if callPartialName.nil?
+      raise "Missing could not resolve '#{interfaceOperation}' in callPartials #{callPartials}" if callPartialName.nil?
+
+      @logger.info "#{__method__}: API-call to interfaceOperation '#{interfaceOperation}' render with '#{callPartialName}'"
+      callPartialName
+    end
+
+    def getInputStatePartialName( interfaceOperation )
+      inputStatePartialName = nil
+      inputStatePartialName = inputStatePartials[API_EMPTY_KEY] if interfaceOperation.nil?
+      inputStatePartialName = inputStatePartials[interfaceOperation] if inputStatePartialName.nil?
+      inputStatePartialName = inputStatePartials[API_DEFAULT_KEY] if inputStatePartialName.nil?
+      raise "Missing could not resolve '#{interfaceOperation}' in inputStatePartials #{inputStatePartials}" if inputStatePartialName.nil?
+
+      @logger.info "#{__method__}: API-call to interfaceOperation '#{interfaceOperation}' render with '#{inputStatePartialName}'"
+      inputStatePartialName
+    end
+
+    def getOutputStatePartialName( interfaceOperation )
+      outputStatePartialName = nil
+      outputStatePartialName = outputStatePartials[API_EMPTY_KEY] if interfaceOperation.nil?
+      outputStatePartialName = outputStatePartials[interfaceOperation] if outputStatePartialName.nil?
+      outputStatePartialName = outputStatePartials[API_DEFAULT_KEY] if outputStatePartialName.nil?
+      raise "Missing could not resolve '#{interfaceOperation}' in outputStatePartials #{outputStatePartials}" if outputStatePartialName.nil?
+
+      @logger.info "#{__method__}: API-call to interfaceOperation '#{interfaceOperation}' render with '#{outputStatePartialName}'"
+      outputStatePartialName
+    end
+
+    # @!endgroup
+
+
+    # ------------------------------------------------------------------
+    # @!group Mustache actions
+
+
+    # @return [Integer] line number correspoding character
+    #     'interface.source.sourceLine' in file
+    #     'options.src_dir'/'interface.source.sourceModule', 0 if path
+    #     not found
+    def SOLC_LINE( data=nil )
+      
+      # Access mustache context
+      options = context[:options]
+      interface = context[:interface]
+
+      @logger.debug "#{__method__}: options=#{options}, interface #{interface}" if @logger.debug?
+
+      
+      # options defines valid data
+      return 0 unless options && options["src_dir"] && File.exists?( options["src_dir"] )
+
+      return  0 unless interface && interface[:source] && interface[:source][:sourceModule] && File.exists?( File.join( options["src_dir"], interface[:source][:sourceModule] ))
+
+      fileName = File.join( options["src_dir"], interface[:source][:sourceModule] )
+      # now possible access line
+      characters = 0
+      lineCount = 0
+      File.open( fileName ).each do |line|
+        # count characters && increment line number
+        characters += line.length
+        lineCount += 1
+        break if characters > interface[:source][:sourceLine]
+      end
+      @logger.info "#{__method__}: lineCount=#{lineCount} for "
+      # number of 'characters' mapped to lineCount
+      lineCount
+    end
+
+    # Lamba called for 'API_INPUT_STATE' to dispatch dynamically rendering of
+    # [:interface][:interface_operation] inputState.
+    def API_INPUT_STATE
+      @logger.info "#{__method__}: [:interface][:interface_operation]=#{context[:interface][:interface_operation]},  now=#{context[:now]}"
+      callPartialName = getInputStatePartialName( context[:interface][:interface_operation]  )
+      template = partial( callPartialName )
+      render( template, context )
+    end
+
+    # Lamba called for 'API_OUTPUT_STATE' to dispatch dynamically rendering of
+    # [:interface][:interface_operation] outputState.
+    def API_OUTPUT_STATE
+      @logger.info "#{__method__}: [:interface][:interface_operation]=#{context[:interface][:interface_operation]} now=#{context[:now]}"      
+      callPartialName = getOutputStatePartialName( context[:interface][:interface_operation]  )
+      template = partial( callPartialName )
+      render( template, context )
+    end
+
+    def API_RETURN
+
+      interfaceOperation = context[:interface][:interface_operation]
+      responseKey = context[:interface][:response_key]      
+
+      # partial access like Bank(saveAccout)
+      callPartialName = getReturnPartialName( interfaceOperation )
+      template = partial( callPartialName )
+
+      # context access likke i_Bank_saveAccount_
+      # raise "keys=#{context[:outputState][:responses].to_yaml}"
+      context[:api_return] = context[:outputState][:responses][responseKey]
+      
+      render( template, context )
+
+    end
+    
+    
+
+    # Mustache lamba to render API calls with input data.
+    #
+    # Lambda depends on context having corect information.
+    # 
+    # context[:state_space][:step] ->
+    #
+    def API_CALL( data=nil)
+      # partialName = data || context[:interface][:interface_operation] if context && context[:interface]
+      # state_space = context[:parsed][:state_space] if context && context[:parsed]
+      # raise "Missing callPartial - error in API_INIT?" if callPartial.nil?
+      # return "" if state_space.nil?
+
+      callPartialName = getCallPartialName( context[:interface][:interface_operation]  )
+      template = partial( callPartialName )
+      
+      # # string procedure input variables ends with
+      # api = "#{context[:interface][:interface_name]}_input"
+
+      # # find name of procedure input varibable
+      # api = context[:parsed][:state_space].keys.find { |k| k.to_s.end_with?( api ) } unless api.nil?
+      
+      # # access procedure input data
+      # api = context[:parsed][:state_space][api] unless api.nil?
+
+      # # access procedure input for currently running interface opertaion
+      # api = api[context[:interface][:interface_operation]] unless api.nil?
+
+      # # create context
+      # context[:api_input] = api
+
+      context[:api_input] =
+        
+        if context[:parsed] && context[:parsed][:state_space] && context[:parsed][:state_space][:step_input]
+          context[:parsed][:state_space][:step_input]
+        else
+          
+          api = "#{context[:interface][:interface_name]}_input"
+                
+          # find name of procedure input varibable
+          api = context[:parsed][:state_space].keys.find { |k| k.to_s.end_with?( api ) } unless api.nil?
+      
+          # access procedure input data
+          api = context[:parsed][:state_space][api] unless api.nil?
+
+          # access procedure input for currently running interface opertaion
+          api = api[context[:interface][:interface_operation]] unless api.nil?
+
+          api =  { :error => "No input found in context[:parsed][:state_space][:step_input] - maybe set 'SetStepInput = TRUE'"} if api.nil?
+
+          api
+        end
+      
+      # render output
+      render( template, context )
+    end
+    
+
+    # @!endgroup
+
+
+
+    # ------------------------------------------------------------------
+    # @!group Mustache extesion points
+    
+    # Override from mustache.rb to use my 'get_partial'.
+    def partial(name)
+      get_partial(name)
+    end
+    
+
+    # @!endgroup
+
+
+    # ------------------------------------------------------------------
+    # @!group Service intefaces
+
+    # @param partial [String] name of partial for rendering 
+    # @param data [Hash] hash to render 
+    def render_str( template, data )
+      render( template, data )
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Service implementation
+
+    # Return cached partial, use {#read_partial} to read if not
+    # defined
+    #
+    # @param name [String] partial name to read
+    def get_partial(name)
+      return partials[name] if partials[name]
+      @logger.info "#{__method__}: reading partial #{name}"
+      
+      self.partials[name] = read_partial(name)
+      @logger.debug "#{__method__}: partial #{name} --> #{partials[name]}" if @logger.debug?
+      
+      partials[name]
+    end
+
+    # Read partial with name 'name'
+    #
+    # @param name [String] name of partial to read 
+    def read_partial(name)
+
+      tName = templateName(name)
+      templatePaths.each do |path|
+
+        # read from file (ends with / ) or from gem-directory
+        content = if path[-1] == '/'
+                    read_partial_file( path, tName )
+                  else
+                    read_gem_partial_file( path, tName )
+                  end
+        return content unless content.nil?
+      end
+
+      # Error if not found, else read file content
+      raise <<-EOS
+      Could not find template '#{name}' in directories #{templatePaths.join(',')}
+      EOS
+      
+    end
+
+    # @return [String,nil] read content of file 'path/templateName',
+    #         nil if not found
+    def read_partial_file( path, templateName )
+      raise RenderException.new "Expected '#{path}' to end with / character" unless path[-1,1] == '/'
+      filePath = File.join( path, templateName )
+      return File.read( filePath  ) if File.exist? filePath
+    end
+
+    def templateName( name )
+      "#{name}.mustache"
+    end
+    
+
+    # # @return [Array<String>] array of template paths 
+    # def templatePaths
+    #   ["/tmp", File.join( File.dirname(__FILE__), "../../mustache") ]
+    # end
+    
+
+    # @!endgroup
+
+    # # ------------------------------------------------------------------
+    # @!group Access partial from GEM
+
+    # Read 'templateName' from '@gemName/mustache' -directory
+    def read_gem_partial_file( gemName , templateName)
+      gemPath = gem_location( gemName )
+      read_partial_file( File.join(gemPath, "mustache" ) + "/", templateName )
+    end
+
+    # Find installation directory of 'gemName' Should find gems
+    # defined in gemspec and Gemfile. Should not find gemName
+    # otherwiset (= also NOT even if installed locally in gems)
+    def gem_location( gemName )
+      gemSpec = Gem.loaded_specs[gemName]
+      raise "Unknown gemName #{gemName}" if gemSpec.nil?
+      gemSpec.gem_dir
+    end
+
+    
+
+    # @!endgroup
+
+
+
+
+    
+  end
+end