require_relative "../spec_helper"

describe  TlaParserS::SymbolTable do

  let ( :parser ) { TlaParserS::Parser.new }
  let ( :symbol_table ) { described_class.new }

  # ------------------------------------------------------------------
  # resolve
  
  describe "interface" do

    
    it "#pushContext" do
      expect( symbol_table ).to respond_to( :pushContext )
    end
    
    it "#popContext" do
      expect( symbol_table ).to respond_to( :popContext )
    end
    
    it "#resolveContext" do
      expect( symbol_table ).to respond_to( :resolveContext )
    end
    
  end

  
  # ------------------------------------------------------------------
  # resolveContext
  
  describe "resolveContext" do

    [
      {
        :snippets => [ "A == 1  " ],
        :desc => "Constant operator defines no symboles",
        :debug => false,
        :resolve => "id",
        :expect => nil,
      },
      
      {
        :snippets => [ "A(id) == 1  " ],
        :desc => "Operator defines symbol",
        :debug => false,
        :resolve => "id",
        :expect => {
          :symbol_type => "Identifier",
          :context_type => "OperatorDef",          
          :context => "A",
          :symbol_name => "id",
        },
      },

      {
        :snippets => [
          "procedure A(id) { skip; }  ",
          "B(id1) == 1  ",          
        ],
        :desc => "Operator defines same  symbol",
        :debug => false,
        :resolve => "id",
        :expect => {
          :context_type => "Procedure",
          :symbol_type => "Identifier",          
          :context => "A",
          :symbol_name => "id",
        },
      },

      {
        :snippets => [
          "procedure A(id) { skip; }  ",
          "B(id1) == 1  ",          
        ],
        :desc => "Operator defines same  symbol",
        :debug => false,
        :resolve => "id1",
        :expect => {
          :symbol_type => "Identifier",
          :context_type => "OperatorDef",
          :context => "B",
          :symbol_name => "id1",
        },
      },
      
      {
        :snippets => [
          "procedure A(id) { skip; }  ",
          "B(id1) == 1  ",          
        ],
        :desc => "Operator defines same  symbol",
        :debug => false,
        :resolve => "id2",
        :expect => nil,
      },

      {
        :snippets => [
          "vari = 1",
          "B(id1) == 1  ",          
        ],
        :desc => "Variable definition resoloved",
        :debug => false,
        :resolve => "vari",
        :expect => {
          :symbol_type => "VariableDef",
          :context_type => "VariableDef",
          :context => "vari",
          :symbol_name => "vari",
        },
      },
      
    ].each_with_index do |testCase,i|

      
      it "#Case #{i}: #{testCase[:desc]} - parse '#{testCase[:str]}' starting '#{testCase[:start]}'" do
        
        testCase[:snippets].each do |snippet|

          tree = parser.parse( snippet )
          if ( testCase[:debug] )
            puts ""
            puts tree.inspect
          end
          tree.defines.each { |define| symbol_table.pushContext( define )} 
          
        end # iterate test case snippets

        result =  symbol_table.resolveContext( testCase[:resolve] )
        if  testCase[:expect].nil?
          expect( result  ).to eql( nil )
        else
          expect( result ).to include( testCase[:expect] )
        end
        
      end # it
      
    end # each 

  end

  
end