edn-abnf 0.5.28 → 0.5.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 254c7ec5b1f24c1b4437b853694c729d58dbc5f4a1b91ecb715f613e45dbbbfe
-  data.tar.gz: e1da36e9da61a6d507b61dee58c3e91501196b32c871c445283db7ba24865fe5
+  metadata.gz: 2ebeb1470b1565a31939bfbca8e695d4376220f29ad26b3e299b870358f4e063
+  data.tar.gz: 6c9947fa5ca0f670c952ef8a180f4712220bf8a142488f5f040a412b8209f53f
 SHA512:
-  metadata.gz: 10fccb5a3e4524830ec86d7c671ca298d2bb25800438b4334e9209120a1340d3c0946ec65093c81973edb4dadc8d7014776c2e6f93f7f63085528ad75a18a20c
-  data.tar.gz: c6b14fdbbfe4d951aa2a8e74d86c4764675a1ceecdfed62a262251da0a8be803ee26a98143387d42a0f30b24968177e1fd8f1de7617aae0dd463bb5cb18e27aa
+  metadata.gz: 3d16fd0184ae65329b09eac63f2a27d24ccf7609bc6f2da5993272e844f58667d87dcd31163481323858fe92049dbc41beed7a7ad8ba33595ab65acf6cc2e492
+  data.tar.gz: dc225c8629265f47e3921ae6db088534e337f215d7de5f5f7152e493090fb15b740884fd4b3d0fdca35912e833355943aa259e67ba3f972fb3f3f3bedf53a653

data/bin/edn-abnf

@@ -180,10 +180,10 @@ begin
     result = edn.tree               # XXX .tree?
   end
 rescue CBOR_DIAG::AppParseError, ArgumentError => e
-  puts "** #{e}"
+  warn "** #{e}"
   exit 1
 rescue CBOR::OutOfBytesError, RuntimeError, JSON::GeneratorError => e
-  puts "** (encoded CBOR input:) #{e}"
+  warn "** (encoded CBOR input:) #{e}"
   exit 1
 end
 

data/edn-abnf.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "edn-abnf"
-  s.version = "0.5.28"
+  s.version = "0.5.30"
   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/parser/edngrammar.rb

@@ -1299,7 +1299,7 @@ module EDNGRAMMAR
       elements[1]
     end
 
-    def item
+    def simple_number
       elements[2]
     end
 
@@ -1310,7 +1310,7 @@ module EDNGRAMMAR
   end
 
   module Simple5
-    def ast; CBOR::Simple.new(item.ast) end
+    def ast; CBOR::Simple(simple_number.text_value.to_i) end
   end
 
   def _nt_simple
@@ -1386,7 +1386,7 @@ module EDNGRAMMAR
               r7 = _nt_S
               s5 << r7
               if r7
-                r8 = _nt_item
+                r8 = _nt_simple_number
                 s5 << r8
                 if r8
                   r9 = _nt_S
@@ -1429,6 +1429,285 @@ module EDNGRAMMAR
     r0
   end
 
+  module SimpleNumber0
+  end
+
+  module SimpleNumber1
+    def DIGIT
+      elements[2]
+    end
+  end
+
+  module SimpleNumber2
+  end
+
+  module SimpleNumber3
+    def DIGIT
+      elements[1]
+    end
+  end
+
+  module SimpleNumber4
+  end
+
+  module SimpleNumber5
+  end
+
+  module SimpleNumber6
+    def DIGIT
+      elements[1]
+    end
+  end
+
+  def _nt_simple_number
+    start_index = index
+    if node_cache[:simple_number].has_key?(index)
+      cached = node_cache[:simple_number][index]
+      if cached
+        node_cache[:simple_number][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    if (match_len = has_terminal?("25", false, index))
+      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"25"')
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      if has_terminal?(@regexps[gr = '\A[0-5]'] ||= Regexp.new(gr), :regexp, index)
+        r3 = true
+        @index += 1
+      else
+        terminal_parse_failure('[0-5]')
+        r3 = nil
+      end
+      s1 << r3
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(SimpleNumber0)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i4, s4 = index, []
+      if (match_len = has_terminal?("2", false, index))
+        r5 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"2"')
+        r5 = nil
+      end
+      s4 << r5
+      if r5
+        if has_terminal?(@regexps[gr = '\A[0-4]'] ||= Regexp.new(gr), :regexp, index)
+          r6 = true
+          @index += 1
+        else
+          terminal_parse_failure('[0-4]')
+          r6 = nil
+        end
+        s4 << r6
+        if r6
+          r7 = _nt_DIGIT
+          s4 << r7
+        end
+      end
+      if s4.last
+        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+        r4.extend(SimpleNumber1)
+      else
+        @index = i4
+        r4 = nil
+      end
+      if r4
+        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+        r0 = r4
+      else
+        i8, s8 = index, []
+        if (match_len = has_terminal?("1", false, index))
+          r9 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"1"')
+          r9 = nil
+        end
+        s8 << r9
+        if r9
+          s10, i10 = [], index
+          loop do
+            r11 = _nt_DIGIT
+            if r11
+              s10 << r11
+            else
+              break
+            end
+            if s10.size == 2
+              break
+            end
+          end
+          if s10.size < 2
+            @index = i10
+            r10 = nil
+          else
+            if s10.size < 2
+              @terminal_failures.pop
+            end
+            r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
+          end
+          s8 << r10
+        end
+        if s8.last
+          r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+          r8.extend(SimpleNumber2)
+        else
+          @index = i8
+          r8 = nil
+        end
+        if r8
+          r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+          r0 = r8
+        else
+          i12, s12 = index, []
+          if has_terminal?(@regexps[gr = '\A[4-9]'] ||= Regexp.new(gr), :regexp, index)
+            r13 = true
+            @index += 1
+          else
+            terminal_parse_failure('[4-9]')
+            r13 = nil
+          end
+          s12 << r13
+          if r13
+            r14 = _nt_DIGIT
+            s12 << r14
+          end
+          if s12.last
+            r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
+            r12.extend(SimpleNumber3)
+          else
+            @index = i12
+            r12 = nil
+          end
+          if r12
+            r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
+            r0 = r12
+          else
+            i15, s15 = index, []
+            if (match_len = has_terminal?("3", false, index))
+              r16 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"3"')
+              r16 = nil
+            end
+            s15 << r16
+            if r16
+              if has_terminal?(@regexps[gr = '\A[2-9]'] ||= Regexp.new(gr), :regexp, index)
+                r17 = true
+                @index += 1
+              else
+                terminal_parse_failure('[2-9]')
+                r17 = nil
+              end
+              s15 << r17
+            end
+            if s15.last
+              r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+              r15.extend(SimpleNumber4)
+            else
+              @index = i15
+              r15 = nil
+            end
+            if r15
+              r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
+              r0 = r15
+            else
+              i18, s18 = index, []
+              if (match_len = has_terminal?("2", false, index))
+                r19 = true
+                @index += match_len
+              else
+                terminal_parse_failure('"2"')
+                r19 = nil
+              end
+              s18 << r19
+              if r19
+                if has_terminal?(@regexps[gr = '\A[0-3]'] ||= Regexp.new(gr), :regexp, index)
+                  r20 = true
+                  @index += 1
+                else
+                  terminal_parse_failure('[0-3]')
+                  r20 = nil
+                end
+                s18 << r20
+              end
+              if s18.last
+                r18 = instantiate_node(SyntaxNode,input, i18...index, s18)
+                r18.extend(SimpleNumber5)
+              else
+                @index = i18
+                r18 = nil
+              end
+              if r18
+                r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
+                r0 = r18
+              else
+                i21, s21 = index, []
+                if (match_len = has_terminal?("1", false, index))
+                  r22 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('"1"')
+                  r22 = nil
+                end
+                s21 << r22
+                if r22
+                  r23 = _nt_DIGIT
+                  s21 << r23
+                end
+                if s21.last
+                  r21 = instantiate_node(SyntaxNode,input, i21...index, s21)
+                  r21.extend(SimpleNumber6)
+                else
+                  @index = i21
+                  r21 = nil
+                end
+                if r21
+                  r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
+                  r0 = r21
+                else
+                  r24 = _nt_DIGIT
+                  if r24
+                    r24 = SyntaxNode.new(input, (index-1)...index) if r24 == true
+                    r0 = r24
+                  else
+                    @index = i0
+                    r0 = nil
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:simple_number][start_index] = r0
+
+    r0
+  end
+
   module Uint0
     def DIGIT1
       elements[0]
@@ -1879,7 +2158,8 @@ module EDNGRAMMAR
   end
 
   module Rawstring1
-    def ast; rawcontent.text_value.gsub("\r", "") + (
+    def ast
+                          rawcontent.text_value.gsub("\r", "") + (
                           tv = matchrawdelim.text_value
                           dv = startrawdelim.text_value.length
                           tv[dv..]) end
@@ -3401,15 +3681,15 @@ module EDNGRAMMAR
     r0
   end
 
-  module EndStar0
+  module EndsInStar0
   end
 
-  def _nt_end_star
+  def _nt_ends_in_star
     start_index = index
-    if node_cache[:end_star].has_key?(index)
-      cached = node_cache[:end_star][index]
+    if node_cache[:ends_in_star].has_key?(index)
+      cached = node_cache[:ends_in_star][index]
       if cached
-        node_cache[:end_star][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:ends_in_star][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -3453,13 +3733,13 @@ module EDNGRAMMAR
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(EndStar0)
+      r0.extend(EndsInStar0)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:end_star][start_index] = r0
+    node_cache[:ends_in_star][start_index] = r0
 
     r0
   end
@@ -3582,13 +3862,13 @@ module EDNGRAMMAR
       elements[0]
     end
 
-    def end_star
+    def ends_in_star
       elements[1]
     end
   end
 
   module Comment2
-    def end_star
+    def ends_in_star
       elements[1]
     end
 
@@ -3670,7 +3950,7 @@ module EDNGRAMMAR
       end
       s7 << r8
       if r8
-        r9 = _nt_end_star
+        r9 = _nt_ends_in_star
         s7 << r9
         if r9
           s10, i10 = [], index
@@ -3679,7 +3959,7 @@ module EDNGRAMMAR
             r12 = _nt_non_slash_star
             s11 << r12
             if r12
-              r13 = _nt_end_star
+              r13 = _nt_ends_in_star
               s11 << r13
             end
             if s11.last
@@ -9081,15 +9361,15 @@ module EDNGRAMMAR
     r0
   end
 
-  module HEndStar0
+  module HEndsInStar0
   end
 
-  def _nt_h_end_star
+  def _nt_h_ends_in_star
     start_index = index
-    if node_cache[:h_end_star].has_key?(index)
-      cached = node_cache[:h_end_star][index]
+    if node_cache[:h_ends_in_star].has_key?(index)
+      cached = node_cache[:h_ends_in_star][index]
       if cached
-        node_cache[:h_end_star][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:h_ends_in_star][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -9133,13 +9413,13 @@ module EDNGRAMMAR
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(HEndStar0)
+      r0.extend(HEndsInStar0)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:h_end_star][start_index] = r0
+    node_cache[:h_ends_in_star][start_index] = r0
 
     r0
   end
@@ -9156,13 +9436,13 @@ module EDNGRAMMAR
       elements[0]
     end
 
-    def h_end_star
+    def h_ends_in_star
       elements[1]
     end
   end
 
   module HComment2
-    def h_end_star
+    def h_ends_in_star
       elements[1]
     end
 
@@ -9247,7 +9527,7 @@ module EDNGRAMMAR
       end
       s7 << r8
       if r8
-        r9 = _nt_h_end_star
+        r9 = _nt_h_ends_in_star
         s7 << r9
         if r9
           s10, i10 = [], index
@@ -9256,7 +9536,7 @@ module EDNGRAMMAR
             r12 = _nt_h_non_slash_star
             s11 << r12
             if r12
-              r13 = _nt_h_end_star
+              r13 = _nt_h_ends_in_star
               s11 << r13
             end
             if s11.last
@@ -9693,15 +9973,15 @@ module EDNGRAMMAR
     r0
   end
 
-  module RhEndStar0
+  module RhEndsInStar0
   end
 
-  def _nt_rh_end_star
+  def _nt_rh_ends_in_star
     start_index = index
-    if node_cache[:rh_end_star].has_key?(index)
-      cached = node_cache[:rh_end_star][index]
+    if node_cache[:rh_ends_in_star].has_key?(index)
+      cached = node_cache[:rh_ends_in_star][index]
       if cached
-        node_cache[:rh_end_star][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:rh_ends_in_star][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -9745,13 +10025,13 @@ module EDNGRAMMAR
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(RhEndStar0)
+      r0.extend(RhEndsInStar0)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:rh_end_star][start_index] = r0
+    node_cache[:rh_ends_in_star][start_index] = r0
 
     r0
   end
@@ -9768,13 +10048,13 @@ module EDNGRAMMAR
       elements[0]
     end
 
-    def rh_end_star
+    def rh_ends_in_star
       elements[1]
     end
   end
 
   module RhComment2
-    def rh_end_star
+    def rh_ends_in_star
       elements[1]
     end
 
@@ -9856,7 +10136,7 @@ module EDNGRAMMAR
       end
       s7 << r8
       if r8
-        r9 = _nt_rh_end_star
+        r9 = _nt_rh_ends_in_star
         s7 << r9
         if r9
           s10, i10 = [], index
@@ -9865,7 +10145,7 @@ module EDNGRAMMAR
             r12 = _nt_rh_non_slash_star
             s11 << r12
             if r12
-              r13 = _nt_rh_end_star
+              r13 = _nt_rh_ends_in_star
               s11 << r13
             end
             if s11.last

metadata

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