tla-parser-s 0.1.2 → 0.2.2

data/lib/utils/logger.rb

@@ -30,8 +30,9 @@ module TlaParserS
         @@logfile = options[:logfile] || File.join( Dir.getwd, LOGFILE )
       end
 
-      def getLogger( progname, options={} ) 
+      def getLogger( progname=nil, options={} ) 
 
+        progname = self.class.name.split('::').last if progname.nil?
         level = get_level( options )
 
         if level.nil? 

data/spec/fixtures/resolver1/op4.tla

@@ -0,0 +1,2 @@
+RECURSIVE op4( _, _ )
+op4( A, B ) == A \/ B

data/spec/fixtures/resolver1/op_let.tla

@@ -0,0 +1 @@
+op_let == LET x == 3 IN x > var4

data/spec/fixtures/resolver1/op_tail_chg.tla

@@ -0,0 +1 @@
+Tail_changed(s) == [i \in 1..(Len(s)-1) |-> s[i+var4]]

data/spec/fixtures/resolver1/var_rec_expr_add.tla

@@ -0,0 +1,3 @@
+var_rec_expr_add = var4.a[1+op2]
+
+

data/spec/parser/parser_fixtures_spec.rb

@@ -25,7 +25,7 @@ describe  TlaParserS::Parser do
     end # it
 
     context "variables" do
-      let (:variable_nodes) { tree.recursive_select( Sexp::VariableDef ) }
+      let (:variable_nodes) { tree.recursive_select( SbuilderSexp::VariableDef ) }
 
       it "#number of variable definitions" do
         expect( variable_nodes.length ).to eql( 3 )
@@ -40,7 +40,7 @@ describe  TlaParserS::Parser do
 
     context "macros" do
 
-      let (:macro_nodes) { tree.recursive_select( Sexp::Macro ) }
+      let (:macro_nodes) { tree.recursive_select( SbuilderSexp::Macro ) }
       
       it "#number of macro definitions" do
         expect( macro_nodes.length ).to eql( 2 )
@@ -65,7 +65,7 @@ describe  TlaParserS::Parser do
 
     context "operators" do
 
-      let (:operator_nodes) { tree.recursive_select( Sexp::OperatorDef ) }
+      let (:operator_nodes) { tree.recursive_select( SbuilderSexp::OperatorDef ) }
 
       it "#number of operator definitions" do
         expect( operator_nodes.length ).to eql( 2 )
@@ -78,7 +78,7 @@ describe  TlaParserS::Parser do
 
     context "procedures" do
 
-      let (:procedure_nodes) { tree.recursive_select( Sexp::Procedure ) }
+      let (:procedure_nodes) { tree.recursive_select( SbuilderSexp::Procedure ) }
 
       it "#number of operator definitions" do
         expect( procedure_nodes.length ).to eql( 3 )

data/spec/parser/parser_spec.rb

@@ -30,6 +30,14 @@ describe  TlaParserS::Parser do
     when "Goto"
       "goto #{node.goto_label}"
 
+    when "WithStatement"
+      expression = node.with_expression.traverse { |m, node_type, enode, node_val  | m.concat( expression_value(node_type, enode, node_val)) }
+      statement = node.with_statement.traverse(""){ |memo,node_type, node|
+        memo.concat( statement_value( node_type, node ))
+      }
+
+      "with ( #{expression} ) #{statement}"
+
     when "Conditional"
       # eval confition
       condition = node.condition.traverse { |m, node_type, enode, node_val  | m.concat( expression_value(node_type, enode, node_val)) }
@@ -105,22 +113,31 @@ describe  TlaParserS::Parser do
          "Identifier", "RecordField", "StringValue", "OriginalValue"
       node_val
     when "PrimaryExpression"
+      # puts "PrimaryExpression: node: #{node}, elements #{node.elements.join(',')}"
       accessors=[]
-      node.attribute_accessors && node.attribute_accessors.each do |identfier|
-        attribute = identfier.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      node.attribute_accessors && node.attribute_accessors.each do |accessor|
+        # puts "PrimaryExpression: accessor=#{accessor}, #{accessor.expression_val}"
+        attribute = accessor.traverse { |m, node_type, enode, node_val|
+          # puts "PrimaryExpression: node_type=#{node_type}"
+          m.concat( expression_value(node_type, enode, node_val ))
+        }
+        # puts "PrimaryExpression: accessor=#{accessor} -> attribute=#{attribute}"
         accessors << attribute
       end
       ret = accessors.join('')
       ret
     when "FieldByName"
       ".#{node_val}"
-    when "FieldByValue"      
-      ret = "[#{node_val}]"
-      # puts "FieldByValue=>#{ret}"
-      ret
+    when "FieldByValue"
+      # puts "FieldByValue: here node: #{node}"
+      expr = node.field_value_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      ret = "[#{expr}]"
+      # puts "FieldByValue: node: #{node}, ret=#{ret}"
+      ret 
     when "RecordExcept"
       elements=[]
       node.record_field_definitions && node.record_field_definitions.each_with_index do |field_node,i|
+        # puts "RecordExcept: lvalue_expression= #{field_node.lvalue_expression}=#{field_node.lvalue_expression.text_value}"
         lvalue_expression = field_node.lvalue_expression.recurse_lvalue
         rvalue_expression = field_node.rvalue_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
         elements << "#{lvalue_expression}=#{rvalue_expression}"
@@ -158,6 +175,25 @@ describe  TlaParserS::Parser do
       end
       # puts "SetConstructor: set_elements=#{set_elements}"
       "{#{ set_elements.join(',')}}"
+
+    when "FunctionExpression"
+      bind_var = nil
+      bind_set = nil
+      expr = nil
+
+      # puts "node.binds_node='#{node.binds_node}'"
+      if node.binds_node then
+        bind_set = node.binds_node.bind_set.traverse { |m, node_type, enode, node_val | m.concat( expression_value(node_type, enode, node_val)) } 
+        # puts "SetExpression: bind_set=#{bind_set}"
+        bind_var = node.binds_node.bind_var.node_value
+        # puts "SetExpression: bind_var=#{bind_var}"
+      end
+
+      # puts "function: node.function_expression=#{node.function_expression}"        
+      expr = node.function_expression && node.function_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      # puts "function: expression=#{expr}"
+
+      "[#{bind_var} \\in #{bind_set}|->#{expr}]"
     when "SetExpression"
       set_expression = nil
       bind_var = nil
@@ -199,6 +235,17 @@ describe  TlaParserS::Parser do
       
       "#{node_val}(#{arguments.join(',')})#{ record_field ? "." + record_field : ''}"
 
+    when "LetExpression"
+      # operator in LET
+      operatorDef = node.operatorDef
+      operatorName = operatorDef.name
+      operatorExpr = []
+      operatorExpr << operatorDef.body_node.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      # expression in LET
+      letExpr = []
+      letExpr << node.letExpression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      # rersult
+      "LET #{operatorName} == #{operatorExpr.join(',') } IN #{letExpr.join(',')}"
     when "IfExpression"
       condition_expression = node.condition_node.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
       then_expression = node.then_expression_node.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
@@ -465,6 +512,14 @@ describe  TlaParserS::Parser do
         :expect => "call proc(1)", 
       },
 
+      {
+        :str => 'with ( id \in Set  ) skip',
+        :desc => "with Id",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => 'with ( id\inSet ) skip', 
+      },
       
       {
         :str => "call proc( 2 , 3 )",
@@ -602,6 +657,10 @@ describe  TlaParserS::Parser do
       },
 
 
+
+      
+
+
       {
         :str => "either     skip   or     goto l1",
         :desc => "Either or (simple)",
@@ -989,7 +1048,7 @@ describe  TlaParserS::Parser do
         :debug => false,
         :expect => "A",
       },
-
+      
       {
         :str => "1 + 3 ",
         :desc => "Addition",
@@ -997,6 +1056,29 @@ describe  TlaParserS::Parser do
         :debug => false,
         :expect => "1+3",
       },
+      {
+        :str => "1 ..3 ",
+        :desc => "Integer range",
+        :start => :expression,
+        :debug => false,
+        :expect => "1..3",
+      },
+
+      {
+        :str => "Len( s) ",
+        :desc => "Sequence length",
+        :start => :expression,
+        :debug => false,
+        :expect => "Len(s)",
+      },
+
+      {
+        :str => "1 .. Len( d) ",
+        :desc => "Integer range to Len",
+        :start => :expression,
+        :debug => false,
+        :expect => "1..Len(d)",
+      },
 
       {
         :str => "1 \\/ 3 ",
@@ -1119,7 +1201,14 @@ describe  TlaParserS::Parser do
         :expect => '<<1,2+A>>',
       },
 
-      
+      {
+        :str => '<< 1>> \o <<2>>',        
+        :desc => "Concatenate sequences",
+        :start => :expression,
+        :debug => false,
+        :expect => '<<1>>\o<<2>>',
+      },
+
       {
         :str => '{  }',        
         :desc => "Empty set expression",
@@ -1160,6 +1249,30 @@ describe  TlaParserS::Parser do
         :expect => '{ x \in Set : TRUE }',
       },
       
+      {
+        :str => '{ x  \in 1..Len(x ): TRUE }',        
+        :desc => "Set contruction using interger range",
+        :start => :expression,
+        :debug => false,
+        :expect => '{ x \in 1..Len(x) : TRUE }',
+      },
+
+      {
+        :str => 'Cardinality( { } )',        
+        :desc => "Cardinality of set",
+        :start => :expression,
+        :debug => false,
+        :expect => 'Cardinality({})',
+      },
+
+      {
+        :str => 'Cardinality({ p \in 1 ..Len(steps)     :  \A s \in steps[p]: s.ctx = Nil } )',        
+        :desc => "Comple cardinality expression",
+        :start => :expression,
+        :debug => false,
+        :expect => 'Cardinality({ p \\in 1..Len(steps) : \\A s \\in steps[p] : s.ctx=Nil })',
+      },
+      
       {
         :str => '{ x.id :    x  \in Set }',        
         :desc => "Set contruction using element mapper",
@@ -1307,16 +1420,23 @@ describe  TlaParserS::Parser do
         :debug => false,
         :expect => "A.id1.id2.id3",
       },
-
       
       {
-        :str => 'rec[key] ',        
+        :str => 'rec[key] ',
         :desc => "Record access by value",
         :start => :expression,
         :debug => false,
         :expect => 'rec[key]',
       },
       
+      {
+        :str => 'rec[key +1] ',        
+        :desc => "Record access by value",
+        :start => :expression,
+        :debug => false,
+        :expect => 'rec[key+1]',
+      },
+      
       {
         :str => '[ name |-> name, address |-> address ]',        
         :desc => "Record as an expression",
@@ -1328,13 +1448,21 @@ describe  TlaParserS::Parser do
       # v_ids := [  v_ids EXCEPT ![id_type] = @ \ { Next_id( id_type ) } ] ;      
 
       {
-        :str => '[  v_ids EXCEPT ![id] = a ] ',        
+        :str => '[  v_ids EXCEPT ![id] = a ] ',
         :desc => "Record except, one field using a (indetifier)",
         :start => :expression,
         :debug => false,
         :expect => '[v_ids EXCEPT ![id]=a]',
       },
 
+      {
+        :str => '[   i \in 1..(Len(s)-1) |-> s[i] ]',        
+        :desc => "Function defines sequence - Tail definition",
+        :start => :expression,
+        :debug => false,
+        :expect => '[i \in 1..(Len(s)-1)|->s[i]]',
+      },
+
       {
         :str => '[  op(TRUE) EXCEPT ![id] = a ] ',        
         :desc => "Record except using operator",
@@ -1393,6 +1521,15 @@ describe  TlaParserS::Parser do
         :expect => 'CHOOSE x \in t_Owner: 1+2',
       },
 
+      {
+        :str => 'LET x == 3 IN  1',        
+        :desc => "LET expression",
+        :start => :expression,
+        :debug => false,
+        :expect => 'LET x == 3 IN 1',
+      },
+
+
       {
         :str => 'IF 1=2 THEN   FALSE   ELSE   TRUE',        
         :desc => "IF expression",
@@ -1421,6 +1558,8 @@ describe  TlaParserS::Parser do
       
     ].each_with_index do |testCase,i|
 
+      # next unless testCase[:choose]
+
       it "#Case #{i}: #{testCase[:desc]} - parse '#{testCase[:str]}' starting '#{testCase[:start]}'" do
 
         tree = parser.parse( testCase[:str], testCase[:start] )
@@ -1480,7 +1619,33 @@ describe  TlaParserS::Parser do
         :debug => false,
         :expect => [ "i2", "i3" ],
       },
-      
+
+      {
+        :str => "RECURSIVE f1(_)",
+        :desc => "Recursive 1 ",
+        :start => :directive,
+        :exception => nil,
+        :debug => false,
+        :expect => [],
+      },
+
+      {
+        :str => "RECURSIVE f2(_ ,_ )",
+        :desc => "Recursive 2 ",
+        :start => :directive,
+        :exception => nil,
+        :debug => false,
+        :expect => [],        
+      },
+
+      {
+        :str => "RECURSIVE f3(_,_, _)",
+        :desc => "Recursive 3 ",
+        :start => :directive,
+        :exception => nil,
+        :debug => false,
+        :expect => [],        
+      },
 
     ].each_with_index do |testCase,i|
         

data/spec/semantics/context_spec.rb

@@ -233,6 +233,55 @@ describe  TlaParserS::Context do
           :expect => [{"proc1" => "Procedure:Snippets" }, { "macro1" => "Macro:Snippets" } ],
         },
 
+        {
+          :initialContext => [
+            <<-EOS,
+            RECURSIVE op(_)
+            op == TRUE
+          EOS
+          ],
+          
+          :callable => "op2 == op",
+          :start => :callable,
+          :desc => "Recursive directive with plac-holder",
+          :debug => false,
+          :expect_synopsis =>"No Resolved in base context definitions ",
+          :expect => [{"op" => "OperatorDef:Snippets" }],
+        },
+
+
+        {
+          :initialContext => [
+            <<-EOS,
+            var = 1
+          EOS
+          ],
+          :callable => 'Tail(s) == [i \in 1..(Len(s)-1) |-> s[i+var]]',
+          :start => :callable,
+          :desc => "Function definition",
+          :debug => false,
+          :expect_synopsis =>"No Resolved in base context definitions ",
+          :expect => [{"s"=>"Identifier:Tail"},
+                      {"i"=>"FunctionExpression:Func-1..(Len(s)-1) "},
+                      {"var"=>"VariableDef:Snippets"}],
+        },
+
+        {
+          :initialContext => [
+            <<-EOS,
+            op == TRUE
+            var = 1
+          EOS
+          ],
+          
+          :callable => "op2 == var[op]",
+          :start => :callable,
+          :desc => "Record access by name",
+          :debug => false,
+          :expect_synopsis =>"op and var resolved in initialContext ",
+          :expect => [ {"var"=>"VariableDef:Snippets"}, {"op"=>"OperatorDef:Snippets"}],
+        },
+
         {
           :initialContext => [
             <<-EOS,
@@ -401,6 +450,9 @@ describe  TlaParserS::Context do
         
       ].each_with_index do |testCase,i|
 
+        # next unless testCase[:choose]
+        
+
         describe "#Case #{i+1}: #{testCase[:desc]}'" do
 
           it "##{testCase[:expect_synopsis]}" do

data/spec/semantics/resolver_spec.rb

@@ -26,7 +26,7 @@ describe  TlaParserS::Resolver do
     end
 
     
-    describe "phases" do
+    describe "Initialize context & parse snippets" do
 
       it "#initContext" do
         expect( resolver ).to respond_to( :initContext )
@@ -37,9 +37,17 @@ describe  TlaParserS::Resolver do
         expect( resolver ).to respond_to( :initSnippets )
       end
 
+    end
+
+    describe "Services to use after init & parse" do
+
       it "#resolveModules" do
         expect( resolver ).to respond_to( :resolveModules )
       end
+      
+      it "#sortModules" do
+        expect( resolver ).to respond_to( :sortModules )
+      end
 
     end
     
@@ -53,7 +61,8 @@ describe  TlaParserS::Resolver do
 
 
     before :all do
-      @resolver =  described_class.new.initSnippets( entries )
+      @resolver = described_class.new
+      @resolver.initSnippets( entries )
     end
 
     it "#fixture include some files" do
@@ -63,9 +72,7 @@ describe  TlaParserS::Resolver do
     # ------------------------------------------------------------------
     # resolveModules (after initSnippets)
 
-    context "resolveModules successfull" do
-
-     
+    context "resolveModules successfully" do
       
       %w( proc1 proc2 proc3 proc4 proc5 var1 var2 var4 var5 op1 macro1 macro2 ).each do |entry|
         it "#defines #{entry} -entry" do
@@ -79,7 +86,6 @@ describe  TlaParserS::Resolver do
           :entrypoints => ["proc1"],
           :expect => [ "proc1.tla", "macro1.tla", "directives.tla",  "directives.cfg" ]
         },
-        
         {
           :desc => "Proc2 calls macro1, macro2",
           :entrypoints => ["proc2"],
@@ -164,6 +170,7 @@ describe  TlaParserS::Resolver do
           :expect => [ "stmt_assign.tla", "variables.tla", "var4.tla", "directives.tla" , "op1.tla", "directives.cfg"]
         },
 
+        
         {
           :desc => "Assignment statement to record",
           :entrypoints => ["assignit2"],
@@ -188,6 +195,12 @@ describe  TlaParserS::Resolver do
           :expect => [ "var_choose_except.tla", "op1.tla", "var4.tla", "directives.tla", "directives.cfg" ]
         },
         
+        {
+          :desc => "Tail seq-function, ref var4:",
+          :entrypoints => ["Tail_changed"],
+          :expect => [ "op_tail_chg.tla", "var4.tla", "directives.tla", "directives.cfg" ]
+        },
+        
         {
           :desc => "var = IF THEN ELSE :",
           :entrypoints => ["var_if"],
@@ -212,6 +225,12 @@ describe  TlaParserS::Resolver do
           :expect => [ "var_rec_expr.tla", "var4.tla", "op1.tla",  "directives.tla", "directives.cfg"  ]
         },
         
+        {
+          :desc => "Record addition exression ",
+          :entrypoints => ["var_rec_expr_add"],
+          :expect => [ "var_rec_expr_add.tla", "var4.tla", "op2.tla",  "directives.tla", "directives.cfg"  ]
+        },
+        
         {
           :desc => "Variable definition with set map expression",
           :entrypoints => ["var_set_expr_map"],
@@ -230,7 +249,6 @@ describe  TlaParserS::Resolver do
           :expect => [ "stmt_cond.tla", "var4.tla", "var_x.tla", "var5.tla", "directives.tla", "op1.tla", "directives.cfg" ]
         },
         
-        
         {
           :desc => "Assert statemtn ",
           :entrypoints => ["stmt_assert"],
@@ -249,6 +267,19 @@ describe  TlaParserS::Resolver do
           :entrypoints => ["var_quantify"],
           :expect => [ "var_quantify.tla", "op1.tla", "var4.tla", "directives.tla", "directives.cfg" ]
         },
+
+        {
+          :desc => "Let expression",
+          :entrypoints => ["op_let"],
+          :expect => [ "op_let.tla", "var4.tla", "directives.tla", "directives.cfg" ]
+        },
+
+        
+        {
+          :desc => "RECURSIVE directive",
+          :entrypoints => ["op4"],
+          :expect => [ "op4.tla", "directives.tla", "directives.cfg" ]
+        },
         
       ].each_with_index do |testCase,i|
         it "Case #{i+1}: #{testCase[:desc]}"  do
@@ -261,6 +292,50 @@ describe  TlaParserS::Resolver do
       end # each 
 
     end # resoveModule success
+
+    context "sortsModules successfully" do
+      [
+        {
+          :desc => "Empty array sorted",
+          :unsorted => [ ],
+          :expect => [ ]
+        },
+        {
+          :desc => "One module sorted",
+          :unsorted => [ "proc1.tla" ],
+          :expect => [ "proc1.tla" ]
+        },
+        {
+          :desc => "Two modules in correct order",
+          :unsorted => [ "macro1.tla", "proc1.tla" ],
+          :expect => [  "macro1.tla", "proc1.tla" ]
+        },
+        {
+          :desc => "Two modules in correct out of order",
+          :unsorted => [ "proc1.tla", "macro1.tla"  ],
+          :expect => [  "macro1.tla", "proc1.tla" ]
+        },
+        {
+          :desc => "Duplicate modules in correct out of order",
+          :unsorted => [ "proc1.tla", "macro1.tla", "proc1.tla"  ],
+          :expect => [  "macro1.tla", "proc1.tla" ]
+        },
+        {
+          :desc => "Unresolved module dropped",
+          :unsorted => [ "macro1.tla",  "xproc1.tla", "proc1.tla"  ],
+          :expect => [   "macro1.tla", "proc1.tla",  ]
+        },
+      ].each_with_index do |testCase,i|
+
+        it "Sort-case #{i+1}: #{testCase[:desc]}"  do
+          sortedModules = @resolver.sortModules( testCase[:unsorted] )
+          expect( sortedModules ).to eql( testCase[:expect] )
+        end
+        
+      end
+      
+    end
+      
     
   end # fixture - success
     
@@ -270,6 +345,8 @@ describe  TlaParserS::Resolver do
 
   describe "resoveModule errors" do
 
+    
+
     [
       {
         :desc => "Succesfull case",
@@ -292,7 +369,6 @@ describe  TlaParserS::Resolver do
         :exception => /Parse error/,
         :expect => nil,
       },
-
       {
         :desc => "Parse error includes module name",
         :snippets => [
@@ -334,6 +410,7 @@ describe  TlaParserS::Resolver do
     ].each_with_index do |testCase,i|
       
       it "Case #{i+1}: #{testCase[:desc]}"  do
+
         resolver = described_class.new
         
         if ( testCase[:exception] )
@@ -366,11 +443,11 @@ describe  TlaParserS::Resolver do
     describe "initSnippets" do
 
       it "#nil input" do
-        expect( resolver.initSnippets( nil ) ).to eql( resolver )
+        expect( resolver.initSnippets( nil ) ).to eql( [] )
       end
       
       it "[] input" do
-        expect( resolver.initSnippets( [] ) ).to eql( resolver )
+        expect( resolver.initSnippets( [] ) ).to eql( [] )
       end
 
       it "#unknown file exception" do
@@ -394,12 +471,30 @@ describe  TlaParserS::Resolver do
     let( :entryPoints ) { ["proc6"] }
 
     it "outputs to stderr unresolved" do
-      uresolver = described_class.new( {:report_unresolved => true  }).initSnippets( uentries )
+      uresolver = described_class.new( {:report_unresolved => true  })
+      uresolver.initSnippets( uentries )
       expect( uresolver.resolveModules( entryPoints )).to eql( [ "entries[0]"] )
       expect { uresolver.resolveModules( entryPoints ) }.to output( /Symbol 'unknown' in entry 'proc6'/ ).to_stderr
     end
 
   end # reports unresolver
+
+  # ------------------------------------------------------------------
+  #
+
+  # describe "Sort modules" do
+
+  #   unsortedModules = [ 1,2 ]
+
+  #   it "#returns array" do
+  #     expect( resolver.sortModules( unsortedModules ) ).to be_an( Array )
+  #   end
+
+  #   it "#does not change length of sorted modules" do
+  #     expect( resolver.sortModules( unsortedModules ).length ).to eql( unsortedModules.length )
+  #   end
+    
+  # end
   
   
 end