edn-abnf 0.5.32 → 0.5.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 526056ed796bf81ffc83f6042d90706a446955e4069c10382f253e68b29fe587
-  data.tar.gz: 9f0221ad1617fcdf26411960ded59fb620a7a3a66175d15547a3b24f4e24885a
+  metadata.gz: 066fe883e4f63f1d4f093c32c280a69ad282f587bd289224b5f9c3c869be7e73
+  data.tar.gz: 34bccaaa9015884fbb9bc9dcc9f8c1eba352dc0178a5ba33c6a71305c2d2b51c
 SHA512:
-  metadata.gz: fdf3bda3807bbf83935287d370927b2c10d02b667a72468b620ad7745e7ecdbca275a519b574133f5107cfd4fbe17d4b9bdcb81acc59df61e082d40c0e6c91e9
-  data.tar.gz: f7a0085dc92fe04f4b11e6872b518ff6bc7382813195cbf7d929fcf7281152c388c3790f09d57c71a2971e6fae5b0b4b28448474fbabea55e656c715cbcde045
+  metadata.gz: 5ca8b9c5816196a430547ebe8ed8b6b90599161b41f51443bb319cec2b86220ffe158df62f5520afbd67cb3450ecebc3ce0e970c90e8f3040f7dd1eb355f7543
+  data.tar.gz: b1bfc0fc1f5b6f076837b47900ceb9962163e32a488ef3c89d63ac1135eec991c7c8d3fa69cbf5355d7af8757c232f7fd89cd8ffdecd38a5b1ea8ae6152007b6

data/edn-abnf.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "edn-abnf"
-  s.version = "0.5.32"
+  s.version = "0.5.35"
   s.summary = "CBOR Extended Diagnostic Notation (EDN) implemented in ABNF"
   s.description = %q{edn-abnf implements converters and miscellaneous tools for CBOR EDN's ABNF}
   s.author = "Carsten Bormann"

data/lib/cbor-diag-support.rb

@@ -12,7 +12,7 @@ module CBOR
     def inspect
       "#<CBOR::Box #{self.class} value=#{value.inspect}, options=#{options.inspect}>"
     end
-    def self.from_number(n, options={})
+    def self.from_instance(n, options={})
       case n
       when Box
         n.class.new(n.value, n.options.merge(options))
@@ -20,23 +20,13 @@ module CBOR
         Ibox.new(n, options.dup)
       when ::Float
         Fbox.new(n, options.dup)
+      when ::String, ::Array, ::Hash, ::CBOR::Tagged
+        Xbox.new(n, options.dup)
       else
         raise ArgumentError, "cbor-diagnostic: can't box number from #{n.inspect}':\n"
       end
     end
-    def to_cbor
-      CBOR.encode(value)
-    end
-    def cbor_diagnostic(opts = {})
-      ret = value.cbor_diagnostic(opts)
-      if ei = options[:ei]
-        ret << "_#{ei}"
-      end
-      ret
-    end
-  end
 
-  class Ibox < Box
     INTEGER_EI = {
       "i" => [23, 0],
       "0" => [0xFF, 1],
@@ -44,7 +34,7 @@ module CBOR
       "2" => [0xFFFFFFFF, 4],
       "3" => [0xFFFFFFFFFFFFFFFF, 8]
     }
-    def make_head(ib, plusbytes, d)
+    def self.make_head(ib, plusbytes, d)
       case plusbytes
       when 0
         [ib + d].pack("C")
@@ -61,6 +51,52 @@ module CBOR
       end
     end
 
+    def to_cbor
+      CBOR.encode(value)
+    end
+    def cbor_diagnostic(opts = {})
+      ret = value.cbor_diagnostic(opts)
+      if ei = options[:ei]
+        ret << "_#{ei}"
+      end
+      ret
+    end
+  end
+
+  class Xbox < Box
+    def to_cbor
+      enc = CBOR.encode(value)
+      if ei = options[:ei]
+        maxval, plusbytes = INTEGER_EI[ei]
+        if maxval
+          ib = enc.getbyte(0) & 0xE0
+          ai = enc.getbyte(0) & 0x1F
+          d, replacement = case ai
+                           when 0...24; [ai, 0]
+                           when 24; [enc[1..1].ord, 1]
+                           when 25; [enc[1..2].unpack1("n"), 2]
+                           when 26; [enc[1..4].unpack1("N"), 4]
+                           when 27; [enc[1..8].unpack1("Q>"), 8]
+                           # when 31; XXX conflicting EI information
+                           else raise "unknown additional information #{ai} in ib #{ib}"
+                           end
+          raise ArgumentError, "cbor-diagnostic: #{value} doesn't fit into encoding indicator _#{ei}':\n" unless d <= maxval
+          ib = enc.getbyte(0) & 0xE0
+          new_head = CBOR::Ibox.make_head(ib, plusbytes, d)
+          enc[0..replacement] = new_head
+        else
+          if ei == "" && value == ""
+            enc = CBOR.encode(value.cbor_stream!([]))
+          else
+            warn "*** cbor-diagnostic: ignoring unsupported encoding indicator _#{ei} for #{value.inspect}"
+          end
+        end
+      end
+      enc
+    end
+  end
+
+  class Ibox < Box
     def to_cbor
       if ei = options[:ei]
         maxval, plusbytes = INTEGER_EI[ei]
@@ -74,7 +110,7 @@ module CBOR
              end
         raise ArgumentError, "cbor-diagnostic: #{value} doesn't fit into encoding indicator _#{ei}':\n" unless d <= maxval
 
-        make_head(ib, plusbytes, d)
+        CBOR::Ibox.make_head(ib, plusbytes, d)
 
         # s = bignum_to_bytes(d)
         # head(0xc0, TAG_BIGNUM_BASE + (ib >> 5))

data/lib/parser/edngrammar.rb

@@ -197,10 +197,12 @@ module EDNGRAMMAR
 
   module String11
     def ast
+      val = elements[0].ast
       if ei = spec.text_value[1..-1]
-         warn "*** ignoring unimplemented encoding indicator #{ei.inspect} for #{elements[0].text_value}"
+         # warn "*** implementing encoding indicator #{ei.inspect} for #{elements[0].text_value}"
+         val = CBOR::Box.from_instance(val, {ei: ei})
       end
-      elements[0].ast
+      val
     end
   end
 
@@ -452,7 +454,7 @@ module EDNGRAMMAR
   
       if ei = spec.text_value[1..-1]
          # warn "*** implementing encoding indicator #{ei.inspect} for #{elements[0].text_value}"
-         val = CBOR::Box.from_number(val, {ei: ei})
+         val = CBOR::Box.from_instance(val, {ei: ei})
       end
       val
     end
@@ -1800,10 +1802,12 @@ module EDNGRAMMAR
 
   module Tagged1
     def ast
+      val = CBOR::Tagged.new(uint.text_value.to_i, item.ast)
       if ei = spec.text_value[1..-1]
-         warn "*** ignoring unimplemented encoding indicator #{ei.inspect} after tag number #{uint.text_value}"
+        val = CBOR::Box.from_instance(val, {ei: ei})
+        # warn "*** implementing encoding indicator #{ei.inspect} after tag number #{uint.text_value}"
       end
-      CBOR::Tagged.new(uint.text_value.to_i, item.ast)
+      val
     end
   end
 
@@ -2634,6 +2638,28 @@ module EDNGRAMMAR
     def ast; elements[0].ast end
   end
 
+  module Bstr8
+    def sq_app_string_dt
+      elements[0]
+    end
+
+  end
+
+  module Bstr9
+    def ast; elements[0].ast end
+  end
+
+  module Bstr10
+    def raw_app_string_dt
+      elements[0]
+    end
+
+  end
+
+  module Bstr11
+    def ast; elements[0].ast end
+  end
+
   def _nt_bstr
     start_index = index
     if node_cache[:bstr].has_key?(index)
@@ -2766,38 +2792,100 @@ module EDNGRAMMAR
             r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
             r0 = r13
           else
-            r17 = _nt_app_string
+            i17, s17 = index, []
+            r18 = _nt_sq_app_string_dt
+            s17 << r18
+            if r18
+              i19 = index
+              r20 = lambda {|x|$options.integrated}.call(s17)
+              if !r20
+                terminal_parse_failure("<semantic predicate>")
+              end
+              if r20
+                @index = i19
+                r19 = instantiate_node(SyntaxNode,input, index...index)
+              else
+                @index = i19
+                r19 = nil
+              end
+              s17 << r19
+            end
+            if s17.last
+              r17 = instantiate_node(SyntaxNode,input, i17...index, s17)
+              r17.extend(Bstr8)
+              r17.extend(Bstr9)
+            else
+              @index = i17
+              r17 = nil
+            end
             if r17
               r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
               r0 = r17
             else
-              r18 = _nt_sqstr
-              if r18
-                r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
-                r0 = r18
+              i21, s21 = index, []
+              r22 = _nt_raw_app_string_dt
+              s21 << r22
+              if r22
+                i23 = index
+                r24 = lambda {|x|$options.integrated}.call(s21)
+                if !r24
+                  terminal_parse_failure("<semantic predicate>")
+                end
+                if r24
+                  @index = i23
+                  r23 = instantiate_node(SyntaxNode,input, index...index)
+                else
+                  @index = i23
+                  r23 = nil
+                end
+                s21 << r23
+              end
+              if s21.last
+                r21 = instantiate_node(SyntaxNode,input, i21...index, s21)
+                r21.extend(Bstr10)
+                r21.extend(Bstr11)
+              else
+                @index = i21
+                r21 = nil
+              end
+              if r21
+                r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
+                r0 = r21
               else
-                r19 = _nt_app_rstring
-                if r19
-                  r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
-                  r0 = r19
+                r25 = _nt_app_string
+                if r25
+                  r25 = SyntaxNode.new(input, (index-1)...index) if r25 == true
+                  r0 = r25
                 else
-                  r20 = _nt_rawstring
-                  if r20
-                    r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
-                    r0 = r20
+                  r26 = _nt_sqstr
+                  if r26
+                    r26 = SyntaxNode.new(input, (index-1)...index) if r26 == true
+                    r0 = r26
                   else
-                    r21 = _nt_app_sequence
-                    if r21
-                      r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
-                      r0 = r21
+                    r27 = _nt_app_rstring
+                    if r27
+                      r27 = SyntaxNode.new(input, (index-1)...index) if r27 == true
+                      r0 = r27
                     else
-                      r22 = _nt_embedded
-                      if r22
-                        r22 = SyntaxNode.new(input, (index-1)...index) if r22 == true
-                        r0 = r22
+                      r28 = _nt_rawstring
+                      if r28
+                        r28 = SyntaxNode.new(input, (index-1)...index) if r28 == true
+                        r0 = r28
                       else
-                        @index = i0
-                        r0 = nil
+                        r29 = _nt_app_sequence
+                        if r29
+                          r29 = SyntaxNode.new(input, (index-1)...index) if r29 == true
+                          r0 = r29
+                        else
+                          r30 = _nt_embedded
+                          if r30
+                            r30 = SyntaxNode.new(input, (index-1)...index) if r30 == true
+                            r0 = r30
+                          else
+                            @index = i0
+                            r0 = nil
+                          end
+                        end
                       end
                     end
                   end
@@ -3000,7 +3088,8 @@ module EDNGRAMMAR
       if ei == ""
         r.cbor_stream!
       elsif ei
-        warn "*** ignoring unimplemented encoding indicator #{ei.inspect} after ["
+        r = CBOR::Box.from_instance(r, {ei: ei})
+        # warn "*** implementing XXX encoding indicator #{ei.inspect} after ["
       end
       r
     end
@@ -3187,7 +3276,8 @@ module EDNGRAMMAR
       if ei == ""
         r.cbor_stream!
       elsif ei
-        warn "*** ignoring unimplemented encoding indicator #{ei.inspect} after {" # }
+        r = CBOR::Box.from_instance(r, {ei: ei})
+        # warn "*** implementing encoding indicator #{ei.inspect} after {" # }
       end
       r
     end
@@ -11603,6 +11693,943 @@ module EDNGRAMMAR
     r0
   end
 
+  def _nt_app_string_dt_prefix
+    start_index = index
+    if node_cache[:app_string_dt_prefix].has_key?(index)
+      cached = node_cache[:app_string_dt_prefix][index]
+      if cached
+        node_cache[:app_string_dt_prefix][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    if (match_len = has_terminal?("dt", false, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"dt"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("DT", false, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"DT"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:app_string_dt_prefix][start_index] = r0
+
+    r0
+  end
+
+  module SqAppStringDt0
+    def app_string_dt_prefix
+      elements[0]
+    end
+
+    def SQUOTE1
+      elements[1]
+    end
+
+    def app_string_dt
+      elements[2]
+    end
+
+    def SQUOTE2
+      elements[3]
+    end
+  end
+
+  module SqAppStringDt1
+    def ast
+        CBOR_DIAG::App_dt.decode(app_string_dt_prefix.text_value, app_string_dt.ast)
+      end
+  end
+
+  def _nt_sq_app_string_dt
+    start_index = index
+    if node_cache[:sq_app_string_dt].has_key?(index)
+      cached = node_cache[:sq_app_string_dt][index]
+      if cached
+        node_cache[:sq_app_string_dt][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_app_string_dt_prefix
+    s0 << r1
+    if r1
+      r2 = _nt_SQUOTE
+      s0 << r2
+      if r2
+        r3 = _nt_app_string_dt
+        s0 << r3
+        if r3
+          r4 = _nt_SQUOTE
+          s0 << r4
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(SqAppStringDt0)
+      r0.extend(SqAppStringDt1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:sq_app_string_dt][start_index] = r0
+
+    r0
+  end
+
+  module RawAppStringDt0
+    def app_string_dt_prefix
+      elements[0]
+    end
+
+    def app_string_dt_raw1
+      elements[1]
+    end
+  end
+
+  module RawAppStringDt1
+    def ast
+        CBOR_DIAG::App_dt.decode(app_string_dt_prefix.text_value, app_string_dt_raw1.ast)
+      end
+  end
+
+  def _nt_raw_app_string_dt
+    start_index = index
+    if node_cache[:raw_app_string_dt].has_key?(index)
+      cached = node_cache[:raw_app_string_dt][index]
+      if cached
+        node_cache[:raw_app_string_dt][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_app_string_dt_prefix
+    s0 << r1
+    if r1
+      r2 = _nt_app_string_dt_raw1
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(RawAppStringDt0)
+      r0.extend(RawAppStringDt1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:raw_app_string_dt][start_index] = r0
+
+    r0
+  end
+
+  module AppStringDtRaw10
+  end
+
+  module AppStringDtRaw11
+    def ast; elements[1].ast; end
+  end
+
+  def _nt_app_string_dt_raw1
+    start_index = index
+    if node_cache[:app_string_dt_raw1].has_key?(index)
+      cached = node_cache[:app_string_dt_raw1][index]
+      if cached
+        node_cache[:app_string_dt_raw1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("`", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"`"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      i2 = index
+      r3 = _nt_app_string_dt_raw2
+      if r3
+        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+        r2 = r3
+      else
+        r4 = _nt_app_string_dt_raw1
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r2 = r4
+        else
+          @index = i2
+          r2 = nil
+        end
+      end
+      s0 << r2
+      if r2
+        if (match_len = has_terminal?("`", false, index))
+          r5 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"`"')
+          r5 = nil
+        end
+        s0 << r5
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(AppStringDtRaw10)
+      r0.extend(AppStringDtRaw11)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:app_string_dt_raw1][start_index] = r0
+
+    r0
+  end
+
+  module AppStringDtRaw20
+    def app_string_dt
+      elements[1]
+    end
+  end
+
+  module AppStringDtRaw21
+    def ast; elements[1].ast; end
+  end
+
+  def _nt_app_string_dt_raw2
+    start_index = index
+    if node_cache[:app_string_dt_raw2].has_key?(index)
+      cached = node_cache[:app_string_dt_raw2][index]
+      if cached
+        node_cache[:app_string_dt_raw2][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r2 = _nt_newline
+    if r2
+      r1 = r2
+    else
+      r1 = instantiate_node(SyntaxNode,input, index...index)
+    end
+    s0 << r1
+    if r1
+      r3 = _nt_app_string_dt
+      s0 << r3
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(AppStringDtRaw20)
+      r0.extend(AppStringDtRaw21)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:app_string_dt_raw2][start_index] = r0
+
+    r0
+  end
+
+  module AppStringDt0
+    def ast; text_value; end
+  end
+
+  def _nt_app_string_dt
+    start_index = index
+    if node_cache[:app_string_dt].has_key?(index)
+      cached = node_cache[:app_string_dt][index]
+      if cached
+        node_cache[:app_string_dt][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_date_time
+    r0.extend(AppStringDt0)
+    r0.extend(AppStringDt0)
+
+    node_cache[:app_string_dt][start_index] = r0
+
+    r0
+  end
+
+  def _nt_date_fullyear
+    start_index = index
+    if node_cache[:date_fullyear].has_key?(index)
+      cached = node_cache[:date_fullyear][index]
+      if cached
+        node_cache[:date_fullyear][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 4
+        break
+      end
+    end
+    if s0.size < 4
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 4
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:date_fullyear][start_index] = r0
+
+    r0
+  end
+
+  def _nt_date_month
+    start_index = index
+    if node_cache[:date_month].has_key?(index)
+      cached = node_cache[:date_month][index]
+      if cached
+        node_cache[:date_month][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 2
+        break
+      end
+    end
+    if s0.size < 2
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 2
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:date_month][start_index] = r0
+
+    r0
+  end
+
+  def _nt_date_mday
+    start_index = index
+    if node_cache[:date_mday].has_key?(index)
+      cached = node_cache[:date_mday][index]
+      if cached
+        node_cache[:date_mday][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 2
+        break
+      end
+    end
+    if s0.size < 2
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 2
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:date_mday][start_index] = r0
+
+    r0
+  end
+
+  def _nt_time_hour
+    start_index = index
+    if node_cache[:time_hour].has_key?(index)
+      cached = node_cache[:time_hour][index]
+      if cached
+        node_cache[:time_hour][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 2
+        break
+      end
+    end
+    if s0.size < 2
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 2
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:time_hour][start_index] = r0
+
+    r0
+  end
+
+  def _nt_time_minute
+    start_index = index
+    if node_cache[:time_minute].has_key?(index)
+      cached = node_cache[:time_minute][index]
+      if cached
+        node_cache[:time_minute][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 2
+        break
+      end
+    end
+    if s0.size < 2
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 2
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:time_minute][start_index] = r0
+
+    r0
+  end
+
+  def _nt_time_second
+    start_index = index
+    if node_cache[:time_second].has_key?(index)
+      cached = node_cache[:time_second][index]
+      if cached
+        node_cache[:time_second][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 2
+        break
+      end
+    end
+    if s0.size < 2
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 2
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:time_second][start_index] = r0
+
+    r0
+  end
+
+  module TimeSecfrac0
+  end
+
+  def _nt_time_secfrac
+    start_index = index
+    if node_cache[:time_secfrac].has_key?(index)
+      cached = node_cache[:time_secfrac][index]
+      if cached
+        node_cache[:time_secfrac][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?(".", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"."')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_DIGIT
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      if s2.empty?
+        @index = i2
+        r2 = nil
+      else
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(TimeSecfrac0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:time_secfrac][start_index] = r0
+
+    r0
+  end
+
+  module TimeNumoffset0
+    def time_hour
+      elements[1]
+    end
+
+    def time_minute
+      elements[3]
+    end
+  end
+
+  def _nt_time_numoffset
+    start_index = index
+    if node_cache[:time_numoffset].has_key?(index)
+      cached = node_cache[:time_numoffset][index]
+      if cached
+        node_cache[:time_numoffset][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    i1 = index
+    if (match_len = has_terminal?("+", false, index))
+      r2 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"+"')
+      r2 = nil
+    end
+    if r2
+      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+      r1 = r2
+    else
+      if (match_len = has_terminal?("-", false, index))
+        r3 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"-"')
+        r3 = nil
+      end
+      if r3
+        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+        r1 = r3
+      else
+        @index = i1
+        r1 = nil
+      end
+    end
+    s0 << r1
+    if r1
+      r4 = _nt_time_hour
+      s0 << r4
+      if r4
+        if (match_len = has_terminal?(":", false, index))
+          r5 = true
+          @index += match_len
+        else
+          terminal_parse_failure('":"')
+          r5 = nil
+        end
+        s0 << r5
+        if r5
+          r6 = _nt_time_minute
+          s0 << r6
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(TimeNumoffset0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:time_numoffset][start_index] = r0
+
+    r0
+  end
+
+  def _nt_time_offset
+    start_index = index
+    if node_cache[:time_offset].has_key?(index)
+      cached = node_cache[:time_offset][index]
+      if cached
+        node_cache[:time_offset][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    if (match_len = has_terminal?("z", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"Z"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_time_numoffset
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:time_offset][start_index] = r0
+
+    r0
+  end
+
+  module PartialTime0
+    def time_hour
+      elements[0]
+    end
+
+    def time_minute
+      elements[2]
+    end
+
+    def time_second
+      elements[4]
+    end
+
+  end
+
+  def _nt_partial_time
+    start_index = index
+    if node_cache[:partial_time].has_key?(index)
+      cached = node_cache[:partial_time][index]
+      if cached
+        node_cache[:partial_time][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_time_hour
+    s0 << r1
+    if r1
+      if (match_len = has_terminal?(":", false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('":"')
+        r2 = nil
+      end
+      s0 << r2
+      if r2
+        r3 = _nt_time_minute
+        s0 << r3
+        if r3
+          if (match_len = has_terminal?(":", false, index))
+            r4 = true
+            @index += match_len
+          else
+            terminal_parse_failure('":"')
+            r4 = nil
+          end
+          s0 << r4
+          if r4
+            r5 = _nt_time_second
+            s0 << r5
+            if r5
+              r7 = _nt_time_secfrac
+              if r7
+                r6 = r7
+              else
+                r6 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s0 << r6
+            end
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(PartialTime0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:partial_time][start_index] = r0
+
+    r0
+  end
+
+  module FullDate0
+    def date_fullyear
+      elements[0]
+    end
+
+    def date_month
+      elements[2]
+    end
+
+    def date_mday
+      elements[4]
+    end
+  end
+
+  def _nt_full_date
+    start_index = index
+    if node_cache[:full_date].has_key?(index)
+      cached = node_cache[:full_date][index]
+      if cached
+        node_cache[:full_date][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_date_fullyear
+    s0 << r1
+    if r1
+      if (match_len = has_terminal?("-", false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"-"')
+        r2 = nil
+      end
+      s0 << r2
+      if r2
+        r3 = _nt_date_month
+        s0 << r3
+        if r3
+          if (match_len = has_terminal?("-", false, index))
+            r4 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"-"')
+            r4 = nil
+          end
+          s0 << r4
+          if r4
+            r5 = _nt_date_mday
+            s0 << r5
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(FullDate0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:full_date][start_index] = r0
+
+    r0
+  end
+
+  module FullTime0
+    def partial_time
+      elements[0]
+    end
+
+    def time_offset
+      elements[1]
+    end
+  end
+
+  def _nt_full_time
+    start_index = index
+    if node_cache[:full_time].has_key?(index)
+      cached = node_cache[:full_time][index]
+      if cached
+        node_cache[:full_time][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_partial_time
+    s0 << r1
+    if r1
+      r2 = _nt_time_offset
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(FullTime0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:full_time][start_index] = r0
+
+    r0
+  end
+
+  module DateTime0
+    def full_date
+      elements[0]
+    end
+
+    def full_time
+      elements[2]
+    end
+  end
+
+  def _nt_date_time
+    start_index = index
+    if node_cache[:date_time].has_key?(index)
+      cached = node_cache[:date_time][index]
+      if cached
+        node_cache[:date_time][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_full_date
+    s0 << r1
+    if r1
+      if (match_len = has_terminal?("t", :insens, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"T"')
+        r2 = nil
+      end
+      s0 << r2
+      if r2
+        r3 = _nt_full_time
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(DateTime0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:date_time][start_index] = r0
+
+    r0
+  end
+
 
   class Parser < Treetop::Runtime::CompiledParser
     include EDNGRAMMAR

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: edn-abnf
 version: !ruby/object:Gem::Version
-  version: 0.5.32
+  version: 0.5.35
 platform: ruby
 authors:
 - Carsten Bormann