tla-trace-filter 0.0.3

data/lib/filter/filter.rb

@@ -0,0 +1,134 @@
+module TlaTraceFilter
+
+  # Class service {#filter} acepptss lines from tla+tools trace
+  # output, and manages state {#state}, {#lines},
+  # {#stateLine}.Collaborates with {#parser} to parse state variable
+  # assignents in trace output {#lines}
+  #
+  class Filter
+
+    include TlaTraceFilter::Util::MyLogger
+    
+
+    # @# @!attribute [String] stateLine line opending state space dump
+    attr_accessor :stateLine
+    
+    # @# @!attribute [Array<String>] lines  collected
+    attr_accessor :lines
+
+    # @# @!attribute [enum] state where filtering is in
+    attr_accessor :state
+
+
+    # @# @!attribute [Parser] parser
+    attr_accessor :parser
+
+    # ------------------------------------------------------------------
+    # @!group Constructor
+
+    def initialize(options={})
+      
+      @logger = getLogger( nil, options )
+      @logger.info "#{__method__}: init filter"
+      
+
+      initState( options )
+    end
+
+    def initState( options = {} )
+      self.state  = :default
+      self.parser = TlaTraceFilter::Parser::Parser.new( options )
+    end
+
+    # @!endgroup
+
+
+    # ------------------------------------------------------------------
+    # @!group Class services
+
+    # Accept 'line' input and act according to {#state} :default=
+    # return 'line' possibly modified in place, :inStateSpace=collect
+    # {#lines}.
+    #
+    # @param line [String] line to filter
+    #
+    # @return [String, nil] result from filtering line, nil do not
+    # output
+    def filter(line)
+      case state
+      when :default
+        inDefault(line)
+      when :inStateSpace
+        inStateSpace(line)
+      else
+        raise "Unknown filter state #{state}" 
+      end
+    end
+
+
+    # @!endgroup
+
+    
+
+    # ------------------------------------------------------------------
+    # @!group Filter state machine. Valid states see {#filter}
+
+    def inDefault( line )
+      if line =~ /^State [0-9]+:/
+        enterStateSpace( line )
+      else
+        line
+      end
+    end
+
+    def inStateSpace( line )
+      if line =~ /^[\s]*\n$/
+        return exitStateSapce
+      else
+        self.lines << line
+        return nil
+      end
+    end
+    
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group State changes
+
+    # @return [nil] nil output postponed in exit state apce
+    def enterStateSpace(line)
+      @logger.info "#{__method__}: line=#{line}"
+      self.stateLine = line
+      self.lines = []
+      # self.lines = [ line ]
+      
+      self.state = :inStateSpace
+      return nil
+    end
+
+    # @return [Hash] hash with properties :line (String), :actionLine
+    # (Integer parsed), :state_space
+    def exitStateSapce
+      @logger.info "#{__method__} entering"
+      
+      ret =  {
+        :line => stateLine || "empty line",
+        :actionLine => stateLine[/Action line ([0-9]*)/,1].to_i,
+        :state_space => parser.parse( lines.join( "\n") ).value,
+      }
+      @logger.info "#{__method__} return=#{ret.to_yaml}"      
+      self.state = :default
+      ret 
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Helpers
+    
+
+    # @!endgroup
+
+
+  end
+end

data/lib/parser/grammar.treetop

@@ -0,0 +1,132 @@
+module TlaTraceFilter
+  module Parser
+  grammar Grammar
+
+    # ------------------------------------------------------------------
+    # state_space
+
+    rule state_space
+    ( '/\\' space  variables:state_variable space* <NonTerminal> )* <StateSpace> / newline
+    end
+
+    rule state_variable
+    	 state_variable:name space+ "=" space+ variable_value:composite_value <StateVariable>
+    end
+
+    # ------------------------------------------------------------------
+    # Composite values
+
+    rule composite_value
+        set_value    /
+        function_value / sequence_value / record_value / reserved_word / integer / string
+    end
+
+    rule set_value
+	 '{' space* (value_list)? '}' <SetValue>
+    end
+
+    rule function_value
+	 '(' space* (function_value_list)? ')' <FunctionValue>
+    end
+
+    rule sequence_value
+	 '<<' space* (value_list)? '>>'  <SequenceValue>
+    end
+    
+    rule record_value
+	 '[' space* (record_element_list)? ']' <RecordValue>
+    end
+
+
+    # ------------------------------------------------------------------
+    # Composite buiding blocks
+
+    rule record_element_list
+    	 record_element space* (record_element_list_tail)*
+    end
+
+    rule  record_element_list_tail
+          ',' space* record_element
+    end
+
+    rule record_element
+    	element_name:name space* '|->' space* element_value:value space* <RecordElement>
+    end
+
+    rule function_value_list
+    	 function_value_element space* (function_value_list_tail)*
+    end
+
+    rule  function_value_list_tail
+          '@@' space* function_value_element
+    end
+
+    rule function_value_element
+    	 domain:function_domain space* ':>' space* range:value space* <FunctionElement>
+    end
+
+    rule function_domain
+    	 string / integer / reserved_word
+    end
+
+    rule value_list
+    	 value space* (value_list_tail)*
+    end
+
+    rule value_list_tail
+      ',' space* value_list
+    end
+
+    rule value
+        reserved_word  / integer / string / composite_value
+    end
+    
+
+    # ------------------------------------------------------------------
+    # atomic values
+
+    rule string
+	 '"'  string_value:[^"]*  '"'  <StringValue> 
+    end
+
+    rule name 
+	[_A-Za-z] [_A-Za-z0-9]* <Name>
+    end
+
+    rule integer
+	('+'/'-')? [0-9]+  <IntegerValue>
+    end
+
+    rule reserved_word
+           (tla_reserved_word/ sbuilder_reserved_word )  
+    end
+
+    rule tla_reserved_word
+            "FALSE" <FalseValue> / "TRUE" <TrueValue>
+    end
+
+    rule sbuilder_reserved_word
+	    "Nil"  <NilValue> / "WildCard"  <WildCardValue>
+    end
+
+
+
+    # ------------------------------------------------------------------
+    # white spaces etc
+
+    rule space
+       whitespace / newline
+    end
+
+    rule whitespace
+    [\s]+
+    end
+
+    rule newline
+    [\n]
+    end
+
+
+  end
+  end
+end

data/lib/parser/node_extensions.rb

@@ -0,0 +1,267 @@
+require 'set'
+# Open up Treetop::Runtime::SyntaxNode to add tree traversal methods
+module Treetop 
+  module Runtime
+    class SyntaxNode
+
+      # ------------------------------------------------------------------
+      # @!group Tree traversing methods added to an opend class
+
+
+      # @return [s(AstSexp) nodes matching 'sym' or 'blk' returning
+      # true anywhere in sexp-tree
+      def nodes_with_match( cl=nil, &blk )
+        blk = ->(chldSexp)  { chldSexp.class == cl } unless cl.nil?
+        nodes = [] # []
+        deep_each do |n|
+          found = blk[n]
+          nodes << n  if found
+          found
+        end
+        nodes
+      end
+
+      def deep_each(prune=true, &block)
+        return enum_for(:deep_each) unless block_given?
+
+        each_sexp do |sexp|
+          found = block[sexp]
+          if  !( prune && found  )
+            sexp.deep_each(&block)
+          end
+        end
+      end
+
+      def each_sexp
+        return enum_for(:each_sexp) unless block_given?
+        elements && elements.each do |sexp|
+          # next unless Sexp === sexp
+          yield sexp
+        end
+      end
+
+      # @!endgroup
+      
+      
+    end  # class SyntaxNode
+  end
+  
+end
+
+module TlaTraceFilter
+  module Parser
+    module Grammar
+
+      class Root <Treetop::Runtime::SyntaxNode
+      end # root
+        
+
+      class NonTerminal <Root
+      end
+      class Terminal <Root
+      end
+      
+      class StateSpace < NonTerminal
+
+        def value
+          h = state_space
+          h.keys.each do |variable|
+            h[variable] = h[variable].variable_value.value
+          end
+          h
+        end
+        
+        def state_space
+          # nodes_with_match(StateVariable).each_with_index do |e, indx|
+          #   puts ( "#{indx} e.class=#{e.class} #{e.respond_to?(:name) ? e.name : 'xx'}")
+          # end
+          nodes_with_match(StateVariable).inject( {} ) do |memo,stateVariable|
+            memo[stateVariable.name.to_sym] = stateVariable
+            memo
+          end
+        end
+      end
+
+      
+      class StateVariable < NonTerminal
+        def name
+          state_variable.text_value
+        end
+      end
+
+      # ------------------------------------------------------------------
+      # @!group Composites
+
+      class CompositeValue < NonTerminal
+
+        def value_childs
+          nodes_with_match do |n|
+            n.is_a?( Terminal ) ||
+              n.is_a?( CompositeValue) ||
+              n.is_a?(RecordElement) ||
+              n.is_a?(FunctionElement)
+          end
+        end
+        
+      end
+
+      class FunctionValue < CompositeValue
+
+        def value
+          function_value
+        end
+
+        def function_value
+          value_childs.inject({}) do |memo, functionElement|
+            memo = memo.merge( functionElement.value )
+          end
+        end
+        
+      end
+
+      class RecordValue < CompositeValue
+        def value
+          record_value
+        end
+
+        def record_value
+          value_childs.inject({}) do |memo, recordElement|
+            memo = memo.merge( recordElement.value )
+          end
+          # {}
+        end
+
+        def record_elements
+          value_childs
+        end
+        
+      end
+
+      class SetValue < CompositeValue
+        def value
+          set_value
+        end
+
+        def set_value
+          Set.new(set_array)
+        end
+        
+        def set_array
+          value_childs.inject( [] ) do |memo, setElement|
+            memo << setElement.value
+            memo
+          end
+        end
+        
+        
+      end
+      
+
+      class FunctionElement < NonTerminal
+        def value
+          function_element_value
+        end
+
+        def function_element_value
+          { domain.value => range.value }
+        end
+      end
+      
+      class RecordElement < NonTerminal
+
+        def value
+          record_element_value
+        end
+
+        def record_element_value
+          { element_name.value => element_value.value }
+        end
+        
+      end
+      
+      class SequenceValue < CompositeValue
+        def value
+          sequence_value
+        end
+
+        def sequence_value 
+          value_childs.map { |n| n.value }
+        end
+
+      end
+      
+
+      # @!endgroup
+
+
+      # ------------------------------------------------------------------
+      # @!group Atomic values
+
+      class Name < Terminal
+        def value
+          name_value
+        end
+        def name_value
+          text_value
+        end
+      end
+
+      class LiteralValue < Terminal
+        def value
+          literal_value
+        end
+        def literal_value
+          text_value
+        end
+      end
+
+      class TrueValue < LiteralValue
+        def value
+          true
+        end
+      end
+
+      class FalseValue < LiteralValue
+        def value
+          false
+        end
+      end
+      
+      class NilValue < LiteralValue
+        def value
+          nil
+        end
+      end
+      
+      class WildCardValue < LiteralValue
+        def value
+          "*"
+        end
+      end
+
+      class StringValue < Terminal
+        def value
+          str_value
+        end
+        def str_value
+          string_value.text_value
+        end
+      end
+
+      class IntegerValue < Terminal
+        def value
+          int_value
+        end
+        def int_value
+          text_value.to_i
+        end
+        
+      end
+      
+
+      # @!endgroup
+
+      
+    end
+  end
+end