edn-abnf 0.5.9 → 0.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 806ffbc9b5f1324cd2ae94381fc1260144ed5a8dc62c29a45d42335fb5424a19
-  data.tar.gz: bcfcf9de27c7fe957601ee45ba33dec200314ddab4015543cf2f76aec39a3c6a
+  metadata.gz: b5a1d958a80d806f5fdf17fe1ac020448da6ecad0046e8bb2dc2019ce901851c
+  data.tar.gz: 1748c58f4baee7386ad82bfa78709e3779cd53660692da35b59c066c7c9c55ae
 SHA512:
-  metadata.gz: d3897fe3c7e47eadb5d3d29b90ed663d397254b802ce5fe54b493dbf75a1d3a808b04426e80c5b5e15410ab75d60056b4ca0f7a8b165140a4ba72ff49950cace
-  data.tar.gz: 6aab126c0f00fc8b2b6b43bffb9bd8902c79f6ae3df2fa1f6b7a866d277ed27825aa8f48d20294b24e44f62f4d5b7b9a6452a6e33bcb234476449a9901c0b827
+  metadata.gz: d8244cfa524d2e5552048e05f14e810f36a13b0d384c47e11c80e80bad5a0d4c63a13d99296b3dbb524ebf4f30ff879192e93164c9040989144be71834476aca
+  data.tar.gz: 842b886e2e0ae034564052fca7954c4c35f10ff9eb72547586d5421250bd26c8c504efba6ad1d8ff1c952e62247dabfd686db5394596d515cf3b6bfc7b588960

data/edn-abnf.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "edn-abnf"
-  s.version = "0.5.9"
+  s.version = "0.5.10"
   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-diagnostic-app/b64grammar.rb

@@ -669,9 +669,11 @@ module B64GRAMMAR
     r0
   end
 
-end
 
-class B64GRAMMARParser < Treetop::Runtime::CompiledParser
-  include B64GRAMMAR
+  class Parser < Treetop::Runtime::CompiledParser
+    include B64GRAMMAR
+  end
 end
 
+B64GRAMMARParser = B64GRAMMAR::Parser
+

data/lib/cbor-diagnostic-app/dtgrammar.rb

@@ -707,9 +707,11 @@ module DTGRAMMAR
     r0
   end
 
-end
 
-class DTGRAMMARParser < Treetop::Runtime::CompiledParser
-  include DTGRAMMAR
+  class Parser < Treetop::Runtime::CompiledParser
+    include DTGRAMMAR
+  end
 end
 
+DTGRAMMARParser = DTGRAMMAR::Parser
+

data/lib/cbor-diagnostic-app/hgrammar.rb

@@ -763,9 +763,11 @@ module HGRAMMAR
     r0
   end
 
-end
 
-class HGRAMMARParser < Treetop::Runtime::CompiledParser
-  include HGRAMMAR
+  class Parser < Treetop::Runtime::CompiledParser
+    include HGRAMMAR
+  end
 end
 
+HGRAMMARParser = HGRAMMAR::Parser
+

data/lib/cbor-diagnostic-app/ipgrammar.rb

@@ -1690,9 +1690,11 @@ module IPGRAMMAR
     r0
   end
 
-end
 
-class IPGRAMMARParser < Treetop::Runtime::CompiledParser
-  include IPGRAMMAR
+  class Parser < Treetop::Runtime::CompiledParser
+    include IPGRAMMAR
+  end
 end
 
+IPGRAMMARParser = IPGRAMMAR::Parser
+

data/lib/parser/edn-util.rb

@@ -42,8 +42,8 @@ class Treetop::Runtime::SyntaxNode
   def app_parser_level1_diagnostics(e, node)
     outbytes = 0
     if $options.level                                # do manual level-shifting
-      input = node.input
-      ol1pos = l1pos = node.interval.begin
+      input = node.input                             # l1 string
+      ol1pos = l1pos = node.interval.begin           # start position
       while outbytes <= e.position
         outbytes += 1
         ol1pos = l1pos
@@ -85,6 +85,30 @@ class Treetop::Runtime::SyntaxNode
     end
     warn reason
   end
+  def app_parser_level1_raw_diagnostics(e, node)
+    outbytes = 0
+    # do manual level-shifting
+      input = node.input                             # l1 string
+      ol1pos = l1pos = node.interval.begin           # start position
+      while outbytes <= e.position
+        ol1pos = l1pos
+        c1 = input[l1pos]
+        if c1 != "\r"           # Ignored CR doesn't generate output
+          outbytes += 1
+        end
+        l1pos += 1
+      end
+      intv = ol1pos...l1pos
+    failure_index = intv.begin
+    failure_line = node.input.line_of(failure_index)
+    failure_column = node.input.column_of(failure_index)
+    reason = "** Line #{failure_line}, column #{failure_column}:\n"
+    if line = node.input.lines.to_a[failure_line - 1]
+      reason << line
+      reason << "\n#{'~' * (failure_column - 1)}#{'^' * intv.size}"
+    end
+    warn reason
+  end
 end
 
 

data/lib/parser/edngrammar.rb

@@ -1809,6 +1809,492 @@ module EDNGRAMMAR
     r0
   end
 
+  module AppRstring0
+    def app_prefix
+      elements[0]
+    end
+
+    def rawstring
+      elements[1]
+    end
+  end
+
+  module AppRstring1
+    def ast                       # XXX ignoring h and b64
+      data = rawstring.ast.force_encoding(Encoding::UTF_8) # XXX undo .b
+      app = app_prefix.text_value
+      begin
+        ::EDNGRAMMAR::APPS[app].decode(app, data)
+      rescue CBOR_DIAG::AppParseError => e
+        app_parser_level1_raw_diagnostics(e, rawstring.rawcontent)
+        raise e
+      end
+    end
+  end
+
+  def _nt_app_rstring
+    start_index = index
+    if node_cache[:app_rstring].has_key?(index)
+      cached = node_cache[:app_rstring][index]
+      if cached
+        node_cache[:app_rstring][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_prefix
+    s0 << r1
+    if r1
+      r2 = _nt_rawstring
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(AppRstring0)
+      r0.extend(AppRstring1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:app_rstring][start_index] = r0
+
+    r0
+  end
+
+  module Rawstring0
+  end
+
+  module Rawstring1
+    def startrawdelim
+      elements[0]
+    end
+
+    def rawcontent
+      elements[2]
+    end
+
+    def matchrawdelim
+      elements[3]
+    end
+  end
+
+  module Rawstring2
+    def ast; rawcontent.text_value.gsub("\r", "") + (
+                          tv = matchrawdelim.text_value
+                          dv = startrawdelim.text_value.length
+                          tv[dv..]                      
+                          ) end
+  end
+
+  def _nt_rawstring
+    start_index = index
+    if node_cache[:rawstring].has_key?(index)
+      cached = node_cache[:rawstring][index]
+      if cached
+        node_cache[:rawstring][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_startrawdelim
+    s0 << r1
+    if r1
+      i3, s3 = index, []
+      if (match_len = has_terminal?("\r", false, index))
+        r5 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"\\r"')
+        r5 = nil
+      end
+      if r5
+        r4 = r5
+      else
+        r4 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s3 << r4
+      if r4
+        if (match_len = has_terminal?("\n", false, index))
+          r6 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"\\n"')
+          r6 = nil
+        end
+        s3 << r6
+      end
+      if s3.last
+        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        r3.extend(Rawstring0)
+      else
+        @index = i3
+        r3 = nil
+      end
+      if r3
+        r2 = r3
+      else
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r2
+      if r2
+        r7 = _nt_rawcontent
+        s0 << r7
+        if r7
+          r8 = _nt_matchrawdelim
+          s0 << r8
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Rawstring1)
+      r0.extend(Rawstring2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:rawstring][start_index] = r0
+
+    r0
+  end
+
+  def _nt_rawdelim
+    start_index = index
+    if node_cache[:rawdelim].has_key?(index)
+      cached = node_cache[:rawdelim][index]
+      if cached
+        node_cache[:rawdelim][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      if (match_len = has_terminal?("`", false, index))
+        r1 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"`"')
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    if s0.empty?
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:rawdelim][start_index] = r0
+
+    r0
+  end
+
+  module Startrawdelim0
+    def rawdelim
+      elements[0]
+    end
+
+  end
+
+  def _nt_startrawdelim
+    start_index = index
+    if node_cache[:startrawdelim].has_key?(index)
+      cached = node_cache[:startrawdelim][index]
+      if cached
+        node_cache[:startrawdelim][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_rawdelim
+    s0 << r1
+    if r1
+      i2 = index
+      r3 = lambda {|(rd)|@rawdelim = rd.text_value}.call(s0)
+      if !r3
+        terminal_parse_failure("<semantic predicate>")
+      end
+      if r3
+        @index = i2
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      else
+        @index = i2
+        r2 = nil
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Startrawdelim0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:startrawdelim][start_index] = r0
+
+    r0
+  end
+
+  module Matchrawdelim0
+    def rawdelim
+      elements[0]
+    end
+
+  end
+
+  def _nt_matchrawdelim
+    start_index = index
+    if node_cache[:matchrawdelim].has_key?(index)
+      cached = node_cache[:matchrawdelim][index]
+      if cached
+        node_cache[:matchrawdelim][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_rawdelim
+    s0 << r1
+    if r1
+      i2 = index
+      r3 = lambda {|(rd)|rd.text_value.length >= @rawdelim.length}.call(s0)
+      if !r3
+        terminal_parse_failure("<semantic predicate>")
+      end
+      if r3
+        @index = i2
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      else
+        @index = i2
+        r2 = nil
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Matchrawdelim0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:matchrawdelim][start_index] = r0
+
+    r0
+  end
+
+  module Shortrawdelim0
+    def rawdelim
+      elements[0]
+    end
+
+  end
+
+  def _nt_shortrawdelim
+    start_index = index
+    if node_cache[:shortrawdelim].has_key?(index)
+      cached = node_cache[:shortrawdelim][index]
+      if cached
+        node_cache[:shortrawdelim][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_rawdelim
+    s0 << r1
+    if r1
+      i2 = index
+      r3 = lambda {|(rd)|rd.text_value.length < @rawdelim.length}.call(s0)
+      if !r3
+        terminal_parse_failure("<semantic predicate>")
+      end
+      if r3
+        @index = i2
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      else
+        @index = i2
+        r2 = nil
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Shortrawdelim0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:shortrawdelim][start_index] = r0
+
+    r0
+  end
+
+  def _nt_rawchars
+    start_index = index
+    if node_cache[:rawchars].has_key?(index)
+      cached = node_cache[:rawchars][index]
+      if cached
+        node_cache[:rawchars][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      i1 = index
+      if (match_len = has_terminal?("\t", false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"\\t"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r1 = r2
+      else
+        if (match_len = has_terminal?("\n", false, index))
+          r3 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"\\n"')
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r1 = r3
+        else
+          if (match_len = has_terminal?("\r", false, index))
+            r4 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"\\r"')
+            r4 = nil
+          end
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r1 = r4
+          else
+            if has_terminal?(@regexps[gr = '\A[\\ -_]'] ||= Regexp.new(gr), :regexp, index)
+              r5 = true
+              @index += 1
+            else
+              terminal_parse_failure('[\\ -_]')
+              r5 = nil
+            end
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r1 = r5
+            else
+              if has_terminal?(@regexps[gr = '\A[a-~]'] ||= Regexp.new(gr), :regexp, index)
+                r6 = true
+                @index += 1
+              else
+                terminal_parse_failure('[a-~]')
+                r6 = nil
+              end
+              if r6
+                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+                r1 = r6
+              else
+                r7 = _nt_NONASCII
+                if r7
+                  r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+                  r1 = r7
+                else
+                  @index = i1
+                  r1 = nil
+                end
+              end
+            end
+          end
+        end
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    if s0.empty?
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:rawchars][start_index] = r0
+
+    r0
+  end
+
+  def _nt_rawcontent
+    start_index = index
+    if node_cache[:rawcontent].has_key?(index)
+      cached = node_cache[:rawcontent][index]
+      if cached
+        node_cache[:rawcontent][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      i1 = index
+      r2 = _nt_rawchars
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r1 = r2
+      else
+        r3 = _nt_shortrawdelim
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r1 = r3
+        else
+          @index = i1
+          r1 = nil
+        end
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    if s0.empty?
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:rawcontent][start_index] = r0
+
+    r0
+  end
+
   module Sqstr0
     def SQUOTE1
       elements[0]
@@ -1974,18 +2460,30 @@ module EDNGRAMMAR
             r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
             r0 = r10
           else
-            r11 = _nt_app_sequence
+            r11 = _nt_app_rstring
             if r11
               r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
               r0 = r11
             else
-              r12 = _nt_embedded
+              r12 = _nt_rawstring
               if r12
                 r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
                 r0 = r12
               else
-                @index = i0
-                r0 = nil
+                r13 = _nt_app_sequence
+                if r13
+                  r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
+                  r0 = r13
+                else
+                  r14 = _nt_embedded
+                  if r14
+                    r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
+                    r0 = r14
+                  else
+                    @index = i0
+                    r0 = nil
+                  end
+                end
               end
             end
           end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: edn-abnf
 version: !ruby/object:Gem::Version
-  version: 0.5.9
+  version: 0.5.10
 platform: ruby
 authors:
 - Carsten Bormann
 bindir: bin
 cert_chain: []
-date: 2025-07-08 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -133,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: CBOR Extended Diagnostic Notation (EDN) implemented in ABNF
 test_files: []