antlr4 0.9.2

data/test/test_tree.rb

@@ -0,0 +1,140 @@
+
+require 'test/unit'
+
+$: << 'lib'
+require 'antlr4'
+require 'tree/Tree'
+require 'Token'
+
+require 'ostruct'
+
+class SampleNodeImpl
+  include NodeImpl
+end
+
+class TreeTest < Test::Unit::TestCase
+
+  def setup()
+  end
+  def teardown 
+  end
+
+  def test_create
+    [Tree, SyntaxTree, ParseTree, RuleNode,
+        TerminalNode, ErrorNode,
+        ParseTreeListener,  ParseTreeVisitor].each { |cls|
+      assert_not_nil cls.new 
+      assert  cls.new.kind_of? cls
+    }
+  end
+
+  def test_terminal_node
+    assert_not_nil TerminalNode.new
+  end
+  def test_error_node
+    assert_not_nil ErrorNode.new 
+  end
+
+  def test_listener 
+    t = ParseTreeListener.new
+    m = t.methods - Object.new.methods
+    assert m.length == 4
+    assert_nil t.visitTerminal(nil)
+    assert_nil t.visitErrorNode(nil)
+    assert_nil t.enterEveryRule(nil)
+    assert_nil t.exitEveryRule(nil)
+  end
+
+
+  def test_node_impl
+      n = SampleNodeImpl.new(:symbol)
+      n = node_impl_verify(SampleNodeImpl)
+      assert n.kind_of?(NodeImpl), "not kind_of NodeImpl"
+  end
+      
+  def node_impl_verify(klass)
+      n = klass.new(:symbol)
+      assert_not_nil n           ,"initialize fails"
+      assert_nil     n.parentCtx , "init value1 fails"
+      assert_not_nil     n.symbol , "init value2 fails"
+      assert         :symbol == n.symbol , "Symbol is not set"
+
+
+      assert :symbol == n.getSymbol(),  "getSymbol does not work" 
+      assert :symbol == n.getPayload(), "getSymbol does not work" 
+      assert n.symbol = :new_symbol,    "symbol= does not exist"
+      assert :new_symbol == n.symbol,   "symbol= does not work"
+
+      assert n.parentCtx = :new_symbol,   "parentCtx= does not exist"
+      assert :new_symbol == n.parentCtx,  "parentCtx= does not work"
+      assert n.parentCtx == n.getParent,  "getParent does not work"
+
+      assert_nil n.getChild(nil),         "getChild() does not work"
+      assert     n.getChildCount() == 0 , "getChildCount does not work"
+      n 
+  end
+  def test_node_impl_with_token
+      token = CommonToken.new([nil,TokenStream.new])
+      token.text = "text" 
+      assert_not_nil token , "CommonToken failed to init"
+      n = SampleNodeImpl.new(token)
+      assert_not_nil n, "failed to create samplenodeimpl with token"
+      assert_not_nil n.getSourceInterval() , "getSourceInterval failed"
+      assert_not_nil n.getText() , "getText failed"
+      assert_not_nil n.to_s , "to_s failed"
+      assert n.to_s == "text" , "to_s value failed"
+  end
+  def test_node_impl_symbol
+      tok = OpenStruct.new(:type=> 100, :text => "text")
+      n = SampleNodeImpl.new(tok)
+      assert n
+      assert n.to_s == "text"
+      assert n.getText == "text"
+      tok = OpenStruct.new(:type=> Token::EOF, :text => "text")
+      n = SampleNodeImpl.new(tok)
+      assert n
+      assert n.to_s == "<EOF>"
+      assert n.getText == "text"
+  end
+  def test_node_impl_nil_symbol 
+      n = SampleNodeImpl.new(nil)
+      assert n
+      assert_nil n.symbol , "symbol is not nil"
+      assert n.getSourceInterval() , "getSourceInterval failed"
+      assert n.getSourceInterval() == Antlr4::INVALID_INTERVAL , "getSourceInterval failed"
+  end
+#    def getText()
+#        return self.symbol.text
+#    end
+#
+#    def to_s
+##        if self.symbol.type == Token.EOF then
+#            "<EOF>"
+#        else
+#            self.symbol.text
+#        end
+#    end
+#  end
+  class SampleParseTreeVisitor <  ParseTreeVisitor
+      def visitTerminal(a)
+            true
+      end
+  end
+  def test_node_impl_accept
+      n = SampleNodeImpl.new(:symbol)
+      assert_not_nil n , "init failed to create NodeImpl"
+      assert n.accept(SampleParseTreeVisitor.new) , "NodeImpl::accept() fail"
+  end
+  def test_terminal_node_impl
+    t = node_impl_verify(TerminalNodeImpl)
+    assert t.kind_of?(TerminalNode), "Not a kind_of? TerminalNode"
+  end
+  def test_error_node_impl
+      n = node_impl_verify(ErrorNodeImpl)
+      assert n.kind_of?(TerminalNode), "Not a kind_of? TerminalNode"
+      assert n.kind_of?(ErrorNode), "Not a kind_of? ErrorNode"
+      assert_nil n.accept(ParseTreeVisitor.new), "accept(ParseTreeVisitor)"
+  end
+#
+
+end

data/test/test_uuid.rb

@@ -0,0 +1,122 @@
+
+require 'test/unit'
+
+$: << 'lib'
+require 'uuid'
+
+class UuidTest < Test::Unit::TestCase
+
+  def setup()
+    @start = "AADB8D7E-AEEF-4415-AD2B-8204D6CF042E"
+  end
+  def teardown 
+  end
+
+  def test_create
+# BASE_SERIALIZED_UUID = UUID("AADB8D7E-AEEF-4415-AD2B-8204D6CF042E")
+# Three inputs
+# a UUID 'string' of hexdigits and - {}
+# a URN prefixed UUID string
+# a IO input of bytes as a string
+# an array of bytes/numbers
+# a single int
+#    assert titles.length > 0, 'Titles exist'
+#    assert titles.class == Array , 'Titles Array'
+    assert true
+  #start = "AADB8D7E-AEEF-4415-AD2B-8204D6CF042E"
+#u = UUID.new(start) 
+
+  end
+  def test_basic_create 
+    u = UUID.new( @start )
+    assert u
+    assert u.class == UUID
+    uuid = UUID.new( "{#{@start}}" )
+    assert uuid
+    assert uuid.class == UUID
+    urn_uuid = UUID.new("urn:" + @start )
+    assert urn_uuid
+    assert u.class == UUID
+    assert u == urn_uuid
+    assert urn_uuid == uuid
+    assert u == uuid
+  end
+  def test_string
+    u = UUID.new( @start )
+    assert u
+    assert @start.downcase == u.to_s.downcase
+    assert @start.upcase == u.to_s.upcase
+  end
+  def test_int_value
+    start_value = 5233100606242806050955395731361295
+    start_uuid  = "00010203-0405-0607-0809-0a0b0c0d0e0f"
+    u1 = UUID.new(start_value)
+    assert u1
+    assert u1.to_i == start_value
+    assert u1.to_s == start_uuid
+  end
+  
+  def test_create_from_byte_array
+      ba = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
+      #).pack("C*").chars.reduce(0) {|a,b| ((a << 8)| b.ord) }
+      ba_int =  5233100606242806050955395731361295
+      bs = "\x00\x00\x01\x02\x03\x04\x05\x06\a\b\t\n\v\f\r\x0E\x0F" 
+      u1 = UUID.create_from_bytes(ba)
+      assert u1
+      u2 = UUID.new(ba_int)
+      assert u2
+      assert u1 == u2 , "Equality test" 
+      assert u1.bytes_array == u2.bytes_array, "Compare created bytes_array"
+  end
+
+  def test_bytes_array
+      ba_uuid = '00010203-0405-0607-0809-0a0b0c0d0e0f'
+      ba = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
+      ba_int =  5233100606242806050955395731361295
+      u = UUID.new(ba_int)
+      assert u
+      assert u.bytes_array == ba
+      assert u.to_s == ba_uuid
+  end
+  def test_bytes
+      ba_int =  5233100606242806050955395731361295
+      bs = "\x00\x01\x02\x03\x04\x05\x06\a\b\t\n\v\f\r\x0E\x0F" 
+      u = UUID.create_from_bytes(ba_int)
+      assert u
+      assert u.bytes.unpack("H*") == bs.unpack("H*"), "Compare bytes to std byte string "
+      u2 = UUID.create_from_bytes(bs)
+      assert u2
+      assert u2.bytes == u.bytes
+      
+  end
+  def test_eql
+    u1 = UUID.new(@start)
+    u2 = UUID.new("{#{@start}}")
+    assert u1.eql? u2
+  end
+  def test_io
+    require 'tempfile'
+    x = UUID.new('{00010203-0405-0607-0809-0a0b0c0d0e0f}')
+    assert x
+    tmpfile = Tempfile.new('test-uuid')
+    tmpfile.write(x.bytes)
+    tmpfile.rewind
+    bytes = tmpfile.read
+    v = UUID.create_from_bytes(bytes)
+    assert v
+    assert x == v
+    tmpfile.close!
+  end
+end
+
+__END__
+#          byte_string = ().pack("C*").split('').reduce(0) {|a,b| a << 4| b.ord }
+#([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]).pack("C*").split('').reduce(0) {|a,b| a << 4| b.ord }
+
+"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2\37\u023a" \
+"\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4" \
+ "\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4" \
+
+ "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2\37\u023a\b\1\4\2"
+ "\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4"
+ "\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22"

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: antlr4
+version: !ruby/object:Gem::Version
+  version: 0.9.2
+platform: ruby
+authors:
+- Chad Slaughter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-31 00:00:00.000000000 Z
+dependencies: []
+description: "Ruby implementation of the Antlr4 runtime.\nThis is needed by any parser/lexer
+  written in Antlr4 using the target \nlangague=Ruby.  "
+email:
+- chad.slaughter+antlr4@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/antlr4.rb
+- lib/antlr4/BufferedTokenStream.rb
+- lib/antlr4/CommonTokenFactory.rb
+- lib/antlr4/CommonTokenStream.rb
+- lib/antlr4/FileStream.rb
+- lib/antlr4/InputStream.rb
+- lib/antlr4/IntervalSet.rb
+- lib/antlr4/LL1Analyzer.rb
+- lib/antlr4/Lexer.rb
+- lib/antlr4/ListTokenSource.rb
+- lib/antlr4/Parser.rb
+- lib/antlr4/ParserInterpreter.rb
+- lib/antlr4/ParserRuleContext.rb
+- lib/antlr4/PredictionContext.rb
+- lib/antlr4/Recognizer.rb
+- lib/antlr4/RuleContext.rb
+- lib/antlr4/Token.rb
+- lib/antlr4/TokenFactory.rb
+- lib/antlr4/TokenSource.rb
+- lib/antlr4/TokenStream.rb
+- lib/antlr4/TraceListener.rb
+- lib/antlr4/atn/ATN.rb
+- lib/antlr4/atn/ATNConfig.rb
+- lib/antlr4/atn/ATNConfigSet.rb
+- lib/antlr4/atn/ATNDeserializationOptions.rb
+- lib/antlr4/atn/ATNDeserializer.rb
+- lib/antlr4/atn/ATNSimulator.rb
+- lib/antlr4/atn/ATNState.rb
+- lib/antlr4/atn/ATNType.rb
+- lib/antlr4/atn/LexerATNSimulator.rb
+- lib/antlr4/atn/LexerAction.rb
+- lib/antlr4/atn/LexerActionExecutor.rb
+- lib/antlr4/atn/ParserATNSimulator.rb
+- lib/antlr4/atn/PredictionMode.rb
+- lib/antlr4/atn/SemanticContext.rb
+- lib/antlr4/atn/Transition.rb
+- lib/antlr4/base.rb
+- lib/antlr4/dfa/DFA.rb
+- lib/antlr4/dfa/DFASerializer.rb
+- lib/antlr4/dfa/DFAState.rb
+- lib/antlr4/error.rb
+- lib/antlr4/error/DiagnosticErrorListener.rb
+- lib/antlr4/error/ErrorListener.rb
+- lib/antlr4/error/ErrorStrategy.rb
+- lib/antlr4/tree/Chunk.rb
+- lib/antlr4/tree/ParseTreeMatch.rb
+- lib/antlr4/tree/ParseTreePattern.rb
+- lib/antlr4/tree/ParseTreePatternMatcher.rb
+- lib/antlr4/tree/RuleTagToken.rb
+- lib/antlr4/tree/TokenTagToken.rb
+- lib/antlr4/tree/Tree.rb
+- lib/antlr4/tree/Trees.rb
+- lib/antlr4/version.rb
+- lib/antlr4/xpath/XPath.rb
+- lib/double_key_map.rb
+- lib/java_symbols.rb
+- lib/uuid.rb
+- test/test_intervalset.rb
+- test/test_tree.rb
+- test/test_uuid.rb
+homepage: https://github.com/slaught/antlr4-ruby
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of the Antlr4 runtime
+test_files:
+- test/test_intervalset.rb
+- test/test_tree.rb
+- test/test_uuid.rb