tla-parser-s 0.1.0

data/spec/semantics/context_spec.rb

@@ -0,0 +1,392 @@
+require_relative "../spec_helper"
+
+describe  TlaParserS::Context do
+
+  let ( :parser ) { TlaParserS::Parser.new }
+  let ( :context ) {  described_class.new     }
+
+
+  root_definitions = <<-EOS
+      A == 1
+      procedure proc() {}
+      macro mac(){}
+  EOS
+
+  let ( :snippets ) { parser.parse( root_definitions  )}
+  let ( :initialContext ) { context.pushContext( snippets ) }
+  
+
+  # ------------------------------------------------------------------
+  # resolve
+  
+  describe "interface" do
+
+    it "#initContext" do
+      expect( context ).to respond_to( :initContext )
+    end
+
+    
+    it "#addContext" do
+      expect( context ).to respond_to( :addContext )
+    end
+    
+    it "#pushContext" do
+      expect( context ).to respond_to( :pushContext )
+    end
+
+    it "#resolveExpression" do
+      expect( context ).to respond_to( :resolveExpression )
+    end
+
+    it "#resolveDefines" do
+      expect( context ).to respond_to( :resolveDefine )
+    end
+    
+    it "#currentContext" do
+      expect( context ).to respond_to( :currentContext )
+    end
+    
+    
+  end
+
+  # ------------------------------------------------------------------
+  # resolve
+  describe "initSymbolTable" do
+    
+    it "#they are valid" do
+      expect( snippets ).not_to eql( nil )
+    end
+
+    it "#they are valid" do
+      expect( initialContext.currentContext.keys() ).to eql( ["A", "proc", "mac" ] )
+    end
+    
+  end
+
+
+  # ------------------------------------------------------------------
+  # resolve
+  
+  describe "resolveExpression" do
+
+
+    it "#fulle resolve output" do
+
+      expression = parser.parse( "A", :expression )
+      resolved = initialContext.resolveExpression( expression )
+      expect( resolved.first ).
+        to match(
+              {:symbol=>"A",
+               :resolved=> a_hash_including(
+                 {:symbol_type=>"OperatorDef",
+                  :context_type=>"Snippets",
+                  :context=>"Snippets",
+                  :symbol_name=>"A"}
+               )
+              })
+
+    end
+
+
+    [
+      {
+        :initialContextSnippets => [ "A == 1" ], 
+        :expression => "A",
+        :desc => "Define constant operator",
+        :debug => false,
+        :expect_synopsis =>"Expression resoves to constant expression",
+        :expect => [ {"A" => "OperatorDef" }],
+      },
+      
+      {
+        :initialContextSnippets => [ "macro A() {}" ],
+        :expression => "A + B",
+        :desc => "Define constant operator, one not resolved",
+        :debug => false,
+        :expect_synopsis =>"A-resolved, B-not resolved",
+        :expect => [ {"A" => "Macro" }, { "B" => nil } ],
+      },
+      
+      {
+        :initialContextSnippets => [
+          "procedure A() {}",
+          "B==TRUE",
+        ],
+        :expression => "A + B",
+        :desc => "Two level context",
+        :debug => false,
+        :expect_synopsis =>"A-resolved, B-resolved",
+        :expect => [ {"A" => "Procedure" }, { "B" => "OperatorDef" } ],
+      },
+
+      {
+        :initialContextSnippets => [
+        ],
+        :expression => "TRUE",
+        :desc => "Expression 'TRUE'",
+        :debug => false,
+        :expect_synopsis =>"in global definitions",
+        :expect => [ {"TRUE" => nil } ],
+      },
+      
+      
+    ].each_with_index do |testCase,i|
+
+      describe "#Case #{i}: #{testCase[:desc]}'" do
+
+        it "##{testCase[:expect_synopsis]}" do
+
+          initialContext = described_class.new 
+
+          # reset symbol table in context
+          initialContext.initContext
+          
+          # build context
+          testCase[:initialContextSnippets].each do |initialContextSnippet|
+            
+            parsedSnippets = parser.parse( initialContextSnippet )
+            expect( parsedSnippets ).not_to eql( nil )            
+            
+            if ( testCase[:debug] )
+              puts "Snippets"
+              puts parsedSnippets.inspect
+            end
+            
+            initialContext.pushContext( parsedSnippets )            
+          end
+
+          # parse expression
+          expression = parser.parse( testCase[:expression], :expression )
+          if ( testCase[:debug] )
+            puts "Expression:"
+            puts expression.inspect
+          end
+          expect( expression ).not_to eql( nil )          
+          
+          # resolve in context
+          resolved = initialContext.resolveExpression( expression )
+          expect( resolved.map{ |r| { r[:symbol] => r[:resolved] ? r[:resolved][:symbol_type] : nil } } ).to eql( testCase[:expect] )
+          
+        end # it
+
+      end # describe
+      
+    end # each 
+    
+
+  end
+
+
+  # ------------------------------------------------------------------
+  # resolveDefine
+  
+  describe "resolveDefine" do
+
+    context "return value" do
+
+      it "#full resolve output" do
+
+        baseContext = <<-EOS
+      procedure Be() {}
+      EOS
+
+        
+        myContext = described_class.new 
+        myContext.initContext
+        baseSnippets = parser.parse( baseContext )
+        myContext.pushContext( baseSnippets, "module2" )
+        
+        statement = parser.parse( "procedure procci(){ call Be(); }", :procedure )
+        resolved = myContext.resolveDefine( statement )
+        expect( resolved ).
+          to match(
+               [
+                 {:symbol=>"Be",
+                  :resolved=>a_hash_including(
+                    {:symbol_type=>"Procedure",
+                     :context_type=>"Snippets",
+                     :context=>"Snippets",
+                     :module=>"module2",
+                     :symbol_name=>"Be"})
+                  }]
+             )
+      end
+    end # return value
+
+    describe "test cases" do
+
+      [
+        {
+          :initialContext => [
+            <<-EOS,
+          procedure proc1() {}
+          macro macro1() {}
+          op1 == TRUE
+          EOS
+          ],
+          
+          :callable => "procedure procci(){ call proc1(); macro1(); }",
+          :start => :procedure,
+          :desc => "Call proc, call macro",
+          :debug => false,
+          :expect_synopsis =>"Resolved in base context definitions ",
+          :expect => [{"proc1" => "Procedure:Snippets" }, { "macro1" => "Macro:Snippets" } ],
+        },
+
+        
+        {
+          :initialContext => [
+            <<-EOS,
+          procedure proc1() {}
+          macro macro1() {}
+          op1 == TRUE
+          a = {}
+          EOS
+          ],
+          
+          :callable => "procedure procci(){ call proc1( a ); macro1(op1); }",
+          :start => :procedure,        
+          :desc => "Actual paramters resolved",
+          :debug => false,
+          :expect_synopsis =>"in base context",
+          :expect => [{"proc1" => "Procedure:Snippets" },
+                      { "a" => "VariableDef:Snippets"},
+                      { "macro1" => "Macro:Snippets" },
+                      { "op1" => "OperatorDef:Snippets" }],
+        },
+
+        {
+          :initialContext => [
+            <<-EOS,
+          procedure proc1( a ) {}
+          macro macro1() {}
+          op1 == TRUE
+          EOS
+          ],
+          
+          :callable => "procedure procci( a ){ call proc1( a ); macro1(a); }",
+          :start => :procedure,        
+          :desc => "Actual paramters resolved",
+          :debug => false,
+          :expect_synopsis =>"in formal parameter",
+          :expect => [{"proc1" => "Procedure:Snippets" }, { "a" => "Identifier:procci" },
+                      { "macro1" => "Macro:Snippets" }, { "a" => "Identifier:procci" }],
+        },
+        
+        {
+          :initialContext => [
+            <<-EOS,
+          procedure proc1( a ) { }
+          macro macro1() {}
+          vari = 1
+          EOS
+          ],
+          :callable => "procedure procci( a ){ macro1(a, vari, { a \\in Setti: a = vari } ); }",
+          :start => :procedure,        
+          :desc => "Resolved",
+          :debug => false,
+          :expect_synopsis =>"2nd a in set generator",
+          :expect => [
+            {"macro1" => "Macro:Snippets" }, { "a" => "Identifier:procci" },
+            { "vari" => "VariableDef:Snippets" }, { "a" => "SetExpression:Set-Setti"}, { "vari" => "VariableDef:Snippets" } ],
+        },
+
+        
+
+        {
+          :initialContext => [
+            <<-EOS,
+          procedure proc1( a ) { }
+          macro macro1() {}
+          vari = 1
+          operattori == FALSE
+          EOS
+          ],
+          :callable => "procedure procci( a ){ macro1(a, vari,  \\A a \\in Joukko: a + FALSE ); }",
+          :start => :procedure,        
+          :desc => "Resolve in procedure context",
+          :debug => false,
+          :expect_synopsis =>"2nd 'a' resolved as quantification parameter",
+          :expect => [
+            {"macro1"=>"Macro:Snippets"}, {"a"=>"Identifier:procci"}, {"vari"=>"VariableDef:Snippets"},
+            { "Joukko" => nil}, 
+            {"a"=>"QuantifyExpression:Quantification-??"}, {"FALSE" => nil },     ]
+        },
+
+        {
+          :initialContext => [
+            <<-EOS,
+          macro macro1( a ) {}
+          macro macro2( a ) {}
+          v1 = 1
+          v2 = 2
+          EOS
+          ],
+          :callable => "procedure proxy( a ){ macro1( a, v1 ); macro2( a, v2, v3 ); }",
+          :start => :procedure,        
+          :desc => "Two macro calls in compound statement, v3 not resolved",
+          :debug => false,
+          :expect_synopsis =>"macro1 & macro2 calls resolved",
+          :expect => [
+            {"macro1" => "Macro:Snippets" }, { "a" => "Identifier:proxy" }, { "v1" => "VariableDef:Snippets" },
+            {"macro2" => "Macro:Snippets" }, { "a" => "Identifier:proxy" }, { "v2" => "VariableDef:Snippets" }, { "v3" => nil },
+          ]
+        },
+
+        
+      ].each_with_index do |testCase,i|
+
+        describe "#Case #{i+1}: #{testCase[:desc]}'" do
+
+          it "##{testCase[:expect_synopsis]}" do
+
+            myContext = described_class.new 
+
+            # reset symbol table in context
+            myContext.initContext
+            myContext.pushContext
+            
+            # build context
+            testCase[:initialContext].each_with_index do |myContextSnippet,i|
+              
+              parsedSnippets = parser.parse( myContextSnippet )
+              expect( parsedSnippets ).not_to eql( nil )            
+              
+              if ( testCase[:debug] )
+                puts "Snippets"
+                puts parsedSnippets.inspect
+              end
+
+              moduleName = "module-#{i+1}"
+              myContext.addContext( parsedSnippets, moduleName )            
+            end
+
+            if ( testCase[:debug] )
+              puts "Context"
+              myContext.dumpContext
+            end
+            
+            # parse callable
+            callable = parser.parse( testCase[:callable], testCase[:start] )
+            if ( testCase[:debug] )
+              puts "Callable:"
+              puts callable.inspect
+            end
+            expect( callable ).not_to eql( nil )          
+            
+            # resolve in context
+            resolved = myContext.resolveDefine( callable )
+            expect( resolved.map{ |r| { r[:symbol] => r[:resolved] ? r[:resolved][:symbol_type] + ':' + r[:resolved][:context]  : nil } } ).to eql( testCase[:expect] )
+            
+          end # it
+
+        end # describe
+        
+      end #eac
+      
+    end # testCases
+    
+  end # resolveDefine
+  
+end
+  

data/spec/semantics/resolver_spec.rb

@@ -0,0 +1,364 @@
+require_relative "../spec_helper"
+
+describe  TlaParserS::Resolver do
+
+  fixture1DirPath =  "#{FIXTURE_ROOT}/resolver1/*"
+  entries = Dir.glob(fixture1DirPath).map { |fileName| File.new(fileName )}
+  
+  let ( :resolver ) {  described_class.new  }
+  
+
+  # ------------------------------------------------------------------
+  # resolve
+  
+  describe "interface" do
+
+    describe "getters" do
+      
+      it "#context" do
+        expect( resolver ).to respond_to( :context )
+      end
+      
+      it "#parser" do
+        expect( resolver ).to respond_to( :parser )
+      end
+      
+    end
+
+    
+    describe "phases" do
+
+      it "#initContext" do
+        expect( resolver ).to respond_to( :initContext )
+      end
+
+      
+      it "#initSnippets" do
+        expect( resolver ).to respond_to( :initSnippets )
+      end
+
+      it "#resolveModules" do
+        expect( resolver ).to respond_to( :resolveModules )
+      end
+
+    end
+    
+  end # interface
+    
+
+  # ------------------------------------------------------------------
+  # Fixture 1
+  
+  describe "Fixture 'resolver1'" do
+
+
+    before :all do
+      @resolver =  described_class.new.initSnippets( entries )
+    end
+
+    it "#fixture include some files" do
+      expect( entries.map{ |e| File.basename(e) } ).to include(  "proc1.tla", "proc2.tla"  )
+    end
+
+    # ------------------------------------------------------------------
+    # resolveModules (after initSnippets)
+
+    context "resolveModules successfull" do
+
+     
+      
+      %w( proc1 proc2 proc3 proc4 proc5 var1 var2 var4 var5 op1 macro1 macro2 ).each do |entry|
+        it "#defines #{entry} -entry" do
+          expect( @resolver.context.entries ).to include( entry )
+        end
+      end
+
+      [
+        {
+          :desc => "Proc1 calls macro1",
+          :entrypoints => ["proc1"],
+          :expect => [ "proc1.tla", "macro1.tla", "directives.tla",  "directives.cfg" ]
+        },
+        
+        {
+          :desc => "Proc2 calls macro1, macro2",
+          :entrypoints => ["proc2"],
+          :expect => [ "proc2.tla", "macro1.tla", "macro2.tla", "proc1.tla", "directives.tla", "directives.cfg" ]
+        },
+
+        {
+          :desc => "Proc3 calls macro1, v1, op1",
+          :entrypoints => ["proc3"],
+          :expect => [ "proc3.tla", "macro1.tla", "variables.tla", "op1.tla", "directives.tla", "directives.cfg" ]
+        },
+
+        {
+          :desc => "Proc4 uses var4",
+          :entrypoints => ["proc4"],
+          :expect => [ "proc4.tla", "var4.tla", "directives.tla", "directives.cfg" ]
+        },
+
+        {
+          :desc => "Proc4_hide uses var4 -as formal parametr",
+          :entrypoints => ["proc4_hide"],
+          :expect => [ "proc4_hide.tla", "directives.tla", "directives.cfg" ]
+        },
+
+        {
+          :desc => "Proc5 uses var5",
+          :entrypoints => ["proc5"],
+          :expect => [ "proc5.tla", "var5.tla",  "directives.tla", "op1.tla", "directives.cfg"]
+        },
+        
+        {
+          :desc => "Loop proc7->proc6",
+          :entrypoints => ["proc7"],
+          :expect => [ "proc7.tla", "proc6.tla", "directives.tla", "directives.cfg" ]
+        },
+        
+        {
+          :desc => "Loop proc6->proc7",
+          :entrypoints => ["proc6"],
+          :expect => [ "proc6.tla", "proc7.tla", "directives.tla", "directives.cfg" ]
+        },
+        
+        {
+          :desc => "Variable defintion w. set expression",
+          :entrypoints => ["var_set"],
+          :expect => [ "var_set.tla", "op1.tla", "directives.tla", "directives.cfg" ]
+        },
+
+        {
+          :desc => "Sequence defintion w. set expression",
+          :entrypoints => ["var_seq"],
+          :expect => [ "var_seq.tla", "op1.tla", "op2.tla", "directives.tla", "directives.cfg" ]
+        },
+
+        {
+          :desc => "Print statement",
+          :entrypoints => ["printit"],
+          :expect => [ "stmt_print.tla", "variables.tla", "op2.tla", "var4.tla", "directives.tla", "op1.tla", "directives.cfg" ]
+        },
+
+        {
+          :desc => "Assignment statement",
+          :entrypoints => ["assignit"],
+          :expect => [ "stmt_assign.tla", "variables.tla", "var4.tla", "directives.tla" , "op1.tla", "directives.cfg"]
+        },
+
+        {
+          :desc => "Assignment statement to record",
+          :entrypoints => ["assignit2"],
+          :expect => [ "stmt_assign2.tla", "var5.tla", "var_x.tla", "var4.tla", "directives.tla" , "op1.tla", "directives.cfg"]
+        },
+
+        {
+          :desc => "Record except",
+          :entrypoints => ["var_rec_except"],
+          :expect => [ "var_rec_except.tla", "var5.tla", "op1.tla", "directives.tla", "directives.cfg" ]
+        },
+        
+        {
+          :desc => "Choose x in Set:",
+          :entrypoints => ["var_choose_except"],
+          :expect => [ "var_choose_except.tla", "op1.tla", "var4.tla", "directives.tla", "directives.cfg" ]
+        },
+        
+        {
+          :desc => "Record exression",
+          :entrypoints => ["var_rec_expr"],
+          :expect => [ "var_rec_expr.tla", "var4.tla", "op1.tla",  "directives.tla", "directives.cfg"  ]
+        },
+        
+        {
+          :desc => "Variable definition with set map expression",
+          :entrypoints => ["var_set_expr_map"],
+          :expect => [ "var_set_expr_map.tla", "var4.tla", "directives.tla", "directives.cfg" ]
+        },
+        
+        {
+          :desc => "Variable definition set record expression",
+          :entrypoints => ["var_record"],
+          :expect => [ "var_record.tla", "var5.tla", "directives.tla", "op1.tla", "directives.cfg" ]
+        },
+        
+        {
+          :desc => "Conditional statement ",
+          :entrypoints => ["stmt_cond"],
+          :expect => [ "stmt_cond.tla", "var4.tla", "var_x.tla", "var5.tla", "directives.tla", "op1.tla", "directives.cfg" ]
+        },
+        
+        
+        {
+          :desc => "Assert statemtn ",
+          :entrypoints => ["stmt_assert"],
+          :expect => [ "stmt_assert.tla", "var_x.tla", "directives.tla", "directives.cfg" ]
+        },
+        
+        {
+          :desc => "Either statement ",
+          :entrypoints => ["stmt_either"],
+          :expect => [ "stmt_either.tla", "var4.tla", "var5.tla", "directives.tla",  "op1.tla", "directives.cfg" ]
+        },
+
+        
+        {
+          :desc => "Quantify expression",
+          :entrypoints => ["var_quantify"],
+          :expect => [ "var_quantify.tla", "op1.tla", "var4.tla", "directives.tla", "directives.cfg" ]
+        },
+        
+      ].each_with_index do |testCase,i|
+        it "Case #{i+1}: #{testCase[:desc]}"  do
+          resolvedModules = @resolver.resolveModules( testCase[:entrypoints] ).map { |path| File.basename( path )}
+          expect( resolvedModules ).to eql( testCase[:expect] )
+          # testCase[:expect].each do |moduleName|
+          #   expect( resolvedModules  ).to include( moduleName )
+          # end # each testCase
+        end # it
+      end # each 
+
+    end # resoveModule success
+    
+  end # fixture - success
+    
+
+  # ------------------------------------------------------------------
+  # Error cases
+
+  describe "resoveModule errors" do
+
+    [
+      {
+        :desc => "Succesfull case",
+        :snippets => [
+          "procedure proc1() {skip;}"
+        ],
+        :entries => ["proc1"],
+        :entrypoints => ["proc1"],
+        :exception => nil,
+        :expect => [ "entries[0]"]
+      },
+      
+      {
+        :desc => "Parse error",
+        :snippets => [
+          "procedure xxx proc1() {skip;}"
+        ],
+        :entries => ["proc1"],
+        :entrypoints => ["proc1"],
+        :exception => /Parse error/,
+        :expect => nil,
+      },
+
+      {
+        :desc => "Parse error includes module name",
+        :snippets => [
+          "procedure proc0() {skip;}",
+          "procedure xxx proc1() {skip;}",
+        ],
+        :entries => ["proc1"],
+        :entrypoints => ["proc1"],
+        :exception => /Parsing 'entries\[1\]'/,
+        :expect => nil,
+      },
+
+      {
+        :desc => "Unknown entrypoint",
+        :snippets => [
+          "procedure proccci3() {skip;}"
+        ],
+        :entries => ["proccci3"],
+        :entrypoints => ["proc1"],
+        :exception => /Unknown entrypoint 'proc1'/,
+        :expect => [],
+      },
+
+      {
+        :desc => "Unknown resource used, default no errors",
+        :snippets => [
+          "procedure p1() {skip;}",
+          "procedure p2() {skip;}",
+          "procedure p3() {skip;}",                                   
+          "procedure p4() { macro1(var1);}",
+        ],
+        :entries => ["p4"],
+        :entrypoints => ["p4"],
+        :exception => nil,
+        :expect => [ "entries[3]"],
+      },
+
+      
+    ].each_with_index do |testCase,i|
+      
+      it "Case #{i+1}: #{testCase[:desc]}"  do
+        resolver = described_class.new
+        
+        if ( testCase[:exception] )
+
+          expect{
+            resolver.initSnippets( testCase[:snippets] )
+            resolver.resolveModules( testCase[:entrypoints] )
+          }.to raise_exception( testCase[:exception] )
+        else
+          
+          resolver.initSnippets( testCase[:snippets] )
+
+          if testCase[:entries] 
+            expect( resolver.context.entries ).to include( *testCase[:entries]  )
+          end
+          
+          expect( resolver.resolveModules( testCase[:entrypoints] ).map { |path| File.basename( path )} ).to eql( testCase[:expect] )
+        end
+        
+      end
+      
+    end # each 
+  end # error case 1
+
+  # ------------------------------------------------------------------
+  # Error cases 2
+
+  describe "Error cases 2" do
+
+    describe "initSnippets" do
+
+      it "#nil input" do
+        expect( resolver.initSnippets( nil ) ).to eql( resolver )
+      end
+      
+      it "[] input" do
+        expect( resolver.initSnippets( [] ) ).to eql( resolver )
+      end
+
+      it "#unknown file exception" do
+        expect{ resolver.initSnippets( File.new( "no-sushc-file")) }.to raise_exception /No such file or directory/
+      end
+
+    end
+    
+  end
+
+  # ------------------------------------------------------------------
+  # Option to report unresolved identifiers
+  
+  describe "Reports un-resolved" do
+
+    let ( :uentries ) { 
+      [
+        "procedure proc6( a ) { call proc6(unknown); }"
+      ]
+    }
+    let( :entryPoints ) { ["proc6"] }
+
+    it "outputs to stderr unresolved" do
+      uresolver = described_class.new( {:report_unresolved => true  }).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
+  
+  
+end
+