iregexp 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6fe6ee35f1dd62cd10b9aa7105cf58c46f76c16f20a23a752c70ffd3e043fb6
-  data.tar.gz: 93a7a857b277c22f055b922761cdd152524fd48c8755ca503501f5082bf78263
+  metadata.gz: b48ffdc37779e3d0a862960ac7fcfd685de4cf59ef24dbc7556557372c5058c5
+  data.tar.gz: 074b33ad95b11cef1dc154f90eeee325432172d1721da222b08ab178791ae504
 SHA512:
-  metadata.gz: c8dc4f7369ab2e828fb3be27f848369a7763a4345f0aec9026a11b4397a3ef2b3bfc34648bcf18013435be8fac05582203b965f5bbd9ead54cbcc10d48774354
-  data.tar.gz: 1d43505cf373b29f6cf8e670b644e879e10b0dba00a4efc06c56610026be8fb3c796fd96f1ca9247ef170682b92f0b8d223f96367bc78c86453eef153c621a11
+  metadata.gz: 423cf8699b215e8aa87d6480a15be10d4964e1b51ebe736e721369c0d5a7d499786af1ab600b42d478f1ece5363557cd94c9d7bdc631a28ae7d7d935631eb102
+  data.tar.gz: aa366d615c0e246d50653a41efa1f852caf596db29952c0864c5fa63a3a9f69e545fc3242ff712726555fff97c5cfaa7e46a52de0420dfb302365563e15066a2

data/bin/iregexp

@@ -15,7 +15,7 @@ FUNCSIG_CHARS = {"l" => :logical, "n" => :nodes, "v" => :value}
 $options = OpenStruct.new
 begin
   op = OptionParser.new do |opts|
-    opts.banner = "Usage: jpt.rb [options] file.jp"
+    opts.banner = "Usage: iregexp [options] file | -e expr"
 
     opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
       $options.verbose = v

data/iregexp.gemspec

@@ -1,13 +1,13 @@
 Gem::Specification.new do |s|
   s.name = "iregexp"
-  s.version = "0.0.1"
+  s.version = "0.0.3"
   s.summary = "I-Regexp Tools"
   s.description = %q{iregexp implements converters and miscellaneous tools for I-Regexp}
   s.author = "Carsten Bormann"
   s.email = "cabo@tzi.org"
   s.license = "MIT"
   s.homepage = "http://github.com/cabo/iregexp"
-  s.files = Dir['lib/**/*.rb'] + %w(iregexp.gemspec) + Dir['data/*'] + Dir['bin/**/*.rb']
+  s.files = Dir['lib/**/*.rb'] + %w(iregexp.gemspec) + Dir['data/*'] + Dir['test-data/*'] + Dir['bin/**/*.rb']
   s.executables = Dir['bin/*'].map {|x| File.basename(x)}
   s.required_ruby_version = '>= 3.0'
 

data/lib/iregexp.rb

@@ -16,7 +16,7 @@ class IREGEXP
       reason << line
       reason << "#{'~' * (parser.failure_column - 1)}^"
     end
-    reason.join("\n").gsub(/[\u0000-\u0009\u000b\u001f\u007f]/) {|c| "\\u%04x" % c.ord}
+    reason.join("\n").gsub(/[\u0000-\u0009\u000b-\u001f\u007f]/) {|c| "\\u%04x" % c.ord}
   end
 
   SAFE_FN = /\A[-._a-zA-Z0-9]+\z/
@@ -24,7 +24,7 @@ class IREGEXP
   def self.from_iregexp(s)
     ast = @@parser.parse s
     if !ast
-      fail ParseError.new(self.reason(@@parser, s))
+      fail ParseError.new("\n" << self.reason(@@parser, s))
     end
     ret = IREGEXP.new(ast)
 

data/lib/parser/iregexpgrammar.rb

@@ -196,19 +196,6 @@ module IREGEXPGRAMMAR
     end
   end
 
-  module Quantifier1
-    def quantity
-      elements[1]
-    end
-
-  end
-
-  module Quantifier2
-    def ast
-      quantity.ast
-    end
-  end
-
   def _nt_quantifier
     start_index = index
     if node_cache[:quantifier].has_key?(index)
@@ -222,11 +209,11 @@ module IREGEXPGRAMMAR
 
     i0 = index
     i1 = index
-    if has_terminal?(@regexps[gr = '\A[\\*-\\+]'] ||= Regexp.new(gr), :regexp, index)
+    if (match_len = has_terminal?("*", false, index))
       r2 = true
-      @index += 1
+      @index += match_len
     else
-      terminal_parse_failure('[\\*-\\+]')
+      terminal_parse_failure('"*"')
       r2 = nil
     end
     if r2
@@ -235,11 +222,11 @@ module IREGEXPGRAMMAR
       r1.extend(Quantifier0)
       r1.extend(Quantifier0)
     else
-      if (match_len = has_terminal?("?", false, index))
+      if (match_len = has_terminal?("+", false, index))
         r3 = true
         @index += match_len
       else
-        terminal_parse_failure('"?"')
+        terminal_parse_failure('"+"')
         r3 = nil
       end
       if r3
@@ -248,48 +235,32 @@ module IREGEXPGRAMMAR
         r1.extend(Quantifier0)
         r1.extend(Quantifier0)
       else
-        @index = i1
-        r1 = nil
+        if (match_len = has_terminal?("?", false, index))
+          r4 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"?"')
+          r4 = nil
+        end
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r1 = r4
+          r1.extend(Quantifier0)
+          r1.extend(Quantifier0)
+        else
+          @index = i1
+          r1 = nil
+        end
       end
     end
     if r1
       r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
       r0 = r1
     else
-      i4, s4 = index, []
-      if (match_len = has_terminal?("{", false, index))
-        r5 = true
-        @index += match_len
-      else
-        terminal_parse_failure('"{"')
-        r5 = nil
-      end
-      s4 << r5
+      r5 = _nt_range_quantifier
       if r5
-        r6 = _nt_quantity
-        s4 << r6
-        if r6
-          if (match_len = has_terminal?("}", false, index))
-            r7 = true
-            @index += match_len
-          else
-            terminal_parse_failure('"}"')
-            r7 = nil
-          end
-          s4 << r7
-        end
-      end
-      if s4.last
-        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-        r4.extend(Quantifier1)
-        r4.extend(Quantifier2)
-      else
-        @index = i4
-        r4 = nil
-      end
-      if r4
-        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
-        r0 = r4
+        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+        r0 = r5
       else
         @index = i0
         r0 = nil
@@ -301,20 +272,20 @@ module IREGEXPGRAMMAR
     r0
   end
 
-  module Quantity0
+  module RangeQuantifier0
   end
 
-  module Quantity1
+  module RangeQuantifier1
     def QuantExact
-      elements[0]
+      elements[1]
     end
 
   end
 
-  module Quantity2
+  module RangeQuantifier2
     def ast
-      l = elements[0].ast
-      r = if rp = elements[1].elements
+      l = elements[1].ast
+      r = if rp = elements[2].elements
             if rp[1].text_value != ''
               rp[1].ast
             else
@@ -327,63 +298,83 @@ module IREGEXPGRAMMAR
     end
   end
 
-  def _nt_quantity
+  def _nt_range_quantifier
     start_index = index
-    if node_cache[:quantity].has_key?(index)
-      cached = node_cache[:quantity][index]
+    if node_cache[:range_quantifier].has_key?(index)
+      cached = node_cache[:range_quantifier][index]
       if cached
-        node_cache[:quantity][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:range_quantifier][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
     i0, s0 = index, []
-    r1 = _nt_QuantExact
+    if (match_len = has_terminal?("{", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"{"')
+      r1 = nil
+    end
     s0 << r1
     if r1
-      i3, s3 = index, []
-      if (match_len = has_terminal?(",", false, index))
-        r4 = true
-        @index += match_len
-      else
-        terminal_parse_failure('","')
-        r4 = nil
-      end
-      s3 << r4
-      if r4
-        r6 = _nt_QuantExact
-        if r6
-          r5 = r6
+      r2 = _nt_QuantExact
+      s0 << r2
+      if r2
+        i4, s4 = index, []
+        if (match_len = has_terminal?(",", false, index))
+          r5 = true
+          @index += match_len
         else
-          r5 = instantiate_node(SyntaxNode,input, index...index)
+          terminal_parse_failure('","')
+          r5 = nil
+        end
+        s4 << r5
+        if r5
+          r7 = _nt_QuantExact
+          if r7
+            r6 = r7
+          else
+            r6 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s4 << r6
+        end
+        if s4.last
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+          r4.extend(RangeQuantifier0)
+        else
+          @index = i4
+          r4 = nil
+        end
+        if r4
+          r3 = r4
+        else
+          r3 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r3
+        if r3
+          if (match_len = has_terminal?("}", false, index))
+            r8 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"}"')
+            r8 = nil
+          end
+          s0 << r8
         end
-        s3 << r5
-      end
-      if s3.last
-        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-        r3.extend(Quantity0)
-      else
-        @index = i3
-        r3 = nil
-      end
-      if r3
-        r2 = r3
-      else
-        r2 = instantiate_node(SyntaxNode,input, index...index)
       end
-      s0 << r2
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Quantity1)
-      r0.extend(Quantity2)
+      r0.extend(RangeQuantifier1)
+      r0.extend(RangeQuantifier2)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:quantity][start_index] = r0
+    node_cache[:range_quantifier][start_index] = r0
 
     r0
   end
@@ -547,11 +538,11 @@ module IREGEXPGRAMMAR
       r0.extend(NormalChar0)
       r0.extend(NormalChar0)
     else
-      if has_terminal?(@regexps[gr = '\A[,-\\-]'] ||= Regexp.new(gr), :regexp, index)
+      if (match_len = has_terminal?(",", false, index))
         r2 = true
-        @index += 1
+        @index += match_len
       else
-        terminal_parse_failure('[,-\\-]')
+        terminal_parse_failure('","')
         r2 = nil
       end
       if r2
@@ -560,11 +551,11 @@ module IREGEXPGRAMMAR
         r0.extend(NormalChar0)
         r0.extend(NormalChar0)
       else
-        if has_terminal?(@regexps[gr = '\A[/->]'] ||= Regexp.new(gr), :regexp, index)
+        if (match_len = has_terminal?("-", false, index))
           r3 = true
-          @index += 1
+          @index += match_len
         else
-          terminal_parse_failure('[/->]')
+          terminal_parse_failure('"-"')
           r3 = nil
         end
         if r3
@@ -573,11 +564,11 @@ module IREGEXPGRAMMAR
           r0.extend(NormalChar0)
           r0.extend(NormalChar0)
         else
-          if has_terminal?(@regexps[gr = '\A[@-Z]'] ||= Regexp.new(gr), :regexp, index)
+          if has_terminal?(@regexps[gr = '\A[/->]'] ||= Regexp.new(gr), :regexp, index)
             r4 = true
             @index += 1
           else
-            terminal_parse_failure('[@-Z]')
+            terminal_parse_failure('[/->]')
             r4 = nil
           end
           if r4
@@ -586,11 +577,11 @@ module IREGEXPGRAMMAR
             r0.extend(NormalChar0)
             r0.extend(NormalChar0)
           else
-            if has_terminal?(@regexps[gr = '\A[\\^-z]'] ||= Regexp.new(gr), :regexp, index)
+            if has_terminal?(@regexps[gr = '\A[@-Z]'] ||= Regexp.new(gr), :regexp, index)
               r5 = true
               @index += 1
             else
-              terminal_parse_failure('[\\^-z]')
+              terminal_parse_failure('[@-Z]')
               r5 = nil
             end
             if r5
@@ -599,11 +590,11 @@ module IREGEXPGRAMMAR
               r0.extend(NormalChar0)
               r0.extend(NormalChar0)
             else
-              if has_terminal?(@regexps[gr = '\A[~-􏿿]'] ||= Regexp.new(gr), :regexp, index)
+              if has_terminal?(@regexps[gr = '\A[\\^-z]'] ||= Regexp.new(gr), :regexp, index)
                 r6 = true
                 @index += 1
               else
-                terminal_parse_failure('[~-􏿿]')
+                terminal_parse_failure('[\\^-z]')
                 r6 = nil
               end
               if r6
@@ -612,8 +603,22 @@ module IREGEXPGRAMMAR
                 r0.extend(NormalChar0)
                 r0.extend(NormalChar0)
               else
-                @index = i0
-                r0 = nil
+                if has_terminal?(@regexps[gr = '\A[~-􏿿]'] ||= Regexp.new(gr), :regexp, index)
+                  r7 = true
+                  @index += 1
+                else
+                  terminal_parse_failure('[~-􏿿]')
+                  r7 = nil
+                end
+                if r7
+                  r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+                  r0 = r7
+                  r0.extend(NormalChar0)
+                  r0.extend(NormalChar0)
+                else
+                  @index = i0
+                  r0 = nil
+                end
               end
             end
           end
@@ -726,85 +731,97 @@ module IREGEXPGRAMMAR
         r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
         r2 = r3
       else
-        if has_terminal?(@regexps[gr = '\A[\\--\\.]'] ||= Regexp.new(gr), :regexp, index)
+        if (match_len = has_terminal?("-", false, index))
           r4 = true
-          @index += 1
+          @index += match_len
         else
-          terminal_parse_failure('[\\--\\.]')
+          terminal_parse_failure('"-"')
           r4 = nil
         end
         if r4
           r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
           r2 = r4
         else
-          if (match_len = has_terminal?("?", false, index))
+          if (match_len = has_terminal?(".", false, index))
             r5 = true
             @index += match_len
           else
-            terminal_parse_failure('"?"')
+            terminal_parse_failure('"."')
             r5 = nil
           end
           if r5
             r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
             r2 = r5
           else
-            if has_terminal?(@regexps[gr = '\A[\\[-\\^]'] ||= Regexp.new(gr), :regexp, index)
+            if (match_len = has_terminal?("?", false, index))
               r6 = true
-              @index += 1
+              @index += match_len
             else
-              terminal_parse_failure('[\\[-\\^]')
+              terminal_parse_failure('"?"')
               r6 = nil
             end
             if r6
               r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
               r2 = r6
             else
-              if (match_len = has_terminal?("n", false, index))
+              if has_terminal?(@regexps[gr = '\A[\\[-\\^]'] ||= Regexp.new(gr), :regexp, index)
                 r7 = true
-                @index += match_len
+                @index += 1
               else
-                terminal_parse_failure('"n"')
+                terminal_parse_failure('[\\[-\\^]')
                 r7 = nil
               end
               if r7
                 r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
                 r2 = r7
               else
-                if (match_len = has_terminal?("r", false, index))
+                if (match_len = has_terminal?("n", false, index))
                   r8 = true
                   @index += match_len
                 else
-                  terminal_parse_failure('"r"')
+                  terminal_parse_failure('"n"')
                   r8 = nil
                 end
                 if r8
                   r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
                   r2 = r8
                 else
-                  if (match_len = has_terminal?("t", false, index))
+                  if (match_len = has_terminal?("r", false, index))
                     r9 = true
                     @index += match_len
                   else
-                    terminal_parse_failure('"t"')
+                    terminal_parse_failure('"r"')
                     r9 = nil
                   end
                   if r9
                     r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
                     r2 = r9
                   else
-                    if has_terminal?(@regexps[gr = '\A[\\{-\\}]'] ||= Regexp.new(gr), :regexp, index)
+                    if (match_len = has_terminal?("t", false, index))
                       r10 = true
-                      @index += 1
+                      @index += match_len
                     else
-                      terminal_parse_failure('[\\{-\\}]')
+                      terminal_parse_failure('"t"')
                       r10 = nil
                     end
                     if r10
                       r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
                       r2 = r10
                     else
-                      @index = i2
-                      r2 = nil
+                      if has_terminal?(@regexps[gr = '\A[\\{-\\}]'] ||= Regexp.new(gr), :regexp, index)
+                        r11 = true
+                        @index += 1
+                      else
+                        terminal_parse_failure('[\\{-\\}]')
+                        r11 = nil
+                      end
+                      if r11
+                        r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
+                        r2 = r11
+                      else
+                        @index = i2
+                        r2 = nil
+                      end
                     end
                   end
                 end
@@ -1390,41 +1407,65 @@ module IREGEXPGRAMMAR
     s0 << r1
     if r1
       i3 = index
-      if has_terminal?(@regexps[gr = '\A[l-m]'] ||= Regexp.new(gr), :regexp, index)
+      if (match_len = has_terminal?("l", false, index))
         r4 = true
-        @index += 1
+        @index += match_len
       else
-        terminal_parse_failure('[l-m]')
+        terminal_parse_failure('"l"')
         r4 = nil
       end
       if r4
         r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
         r3 = r4
       else
-        if (match_len = has_terminal?("o", false, index))
+        if (match_len = has_terminal?("m", false, index))
           r5 = true
           @index += match_len
         else
-          terminal_parse_failure('"o"')
+          terminal_parse_failure('"m"')
           r5 = nil
         end
         if r5
           r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
           r3 = r5
         else
-          if has_terminal?(@regexps[gr = '\A[t-u]'] ||= Regexp.new(gr), :regexp, index)
+          if (match_len = has_terminal?("o", false, index))
             r6 = true
-            @index += 1
+            @index += match_len
           else
-            terminal_parse_failure('[t-u]')
+            terminal_parse_failure('"o"')
             r6 = nil
           end
           if r6
             r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
             r3 = r6
           else
-            @index = i3
-            r3 = nil
+            if (match_len = has_terminal?("t", false, index))
+              r7 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"t"')
+              r7 = nil
+            end
+            if r7
+              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+              r3 = r7
+            else
+              if (match_len = has_terminal?("u", false, index))
+                r8 = true
+                @index += match_len
+              else
+                terminal_parse_failure('"u"')
+                r8 = nil
+              end
+              if r8
+                r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+                r3 = r8
+              else
+                @index = i3
+                r3 = nil
+              end
+            end
           end
         end
       end
@@ -1934,19 +1975,31 @@ module IREGEXPGRAMMAR
           r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
           r3 = r5
         else
-          if has_terminal?(@regexps[gr = '\A[n-o]'] ||= Regexp.new(gr), :regexp, index)
+          if (match_len = has_terminal?("n", false, index))
             r6 = true
-            @index += 1
+            @index += match_len
           else
-            terminal_parse_failure('[n-o]')
+            terminal_parse_failure('"n"')
             r6 = nil
           end
           if r6
             r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
             r3 = r6
           else
-            @index = i3
-            r3 = nil
+            if (match_len = has_terminal?("o", false, index))
+              r7 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"o"')
+              r7 = nil
+            end
+            if r7
+              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+              r3 = r7
+            else
+              @index = i3
+              r3 = nil
+            end
           end
         end
       end

data/test-data/simple.irl

@@ -0,0 +1,49 @@
+=
+=.
+=a
+=🤔
+-\
+-\v
+-\\\
+-\\\v
+-\\\z
+-\ca
+=\(\)\*\+\.\?\[\\
+=\]\{\|\}\t\r\n
+=a*
+=🤔*
+-a**
+=a|b
+=aa|bb
+=aa|
+=|bb
+=aa|bb*
+=aa|bb+
+=aa|bb?
+=aa|bb{6}
+=aa|bb{6,}
+=aa|bb{6,8}
+=(aa)
+-aa)
+-(aa
+=aa(bb|cc)dd
+-aabb|cc)dd
+-aa(bb|ccdd
+=[abc]
+-[a
+-a]
+=[a🤔b]
+=[^abc]
+=[ab-f]
+=[^ab-f]
+=[^-ab-f]
+=[-ab-f]
+=[ab-f-]
+=[a\n-\r-]
+=\p{Nd}
+=\P{Ll}
+=\P{L}
+=\p{Co}
+*[\p{Nd}]
+*[\P{Nd}]
+*[^\p{Nd}\p{Ll}]

data/test-data/simple.out

@@ -0,0 +1,114 @@
+=                 ["seq"]
+                  ""
+=.                ["dot"]
+                  "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t"
+=a                "a"
+                  "a"
+=🤔                "🤔"
+                  "🤔"
+-\                Expected one of [\(-\+], "-", ".", "?", [\[-\^], "n", "r", "t", [\{-\}] at line 1, column 2 (byte 2):
+                  \
+                  ~^
+-\v               Expected one of [\(-\+], "-", ".", "?", [\[-\^], "n", "r", "t", [\{-\}] at line 1, column 2 (byte 2):
+                  \v
+                  ~^
+-\\\              Expected one of [\(-\+], "-", ".", "?", [\[-\^], "n", "r", "t", [\{-\}] at line 1, column 4 (byte 4):
+                  \\\
+                  ~~~^
+-\\\v             Expected one of [\(-\+], "-", ".", "?", [\[-\^], "n", "r", "t", [\{-\}] at line 1, column 4 (byte 4):
+                  \\\v
+                  ~~~^
+-\\\z             Expected one of [\(-\+], "-", ".", "?", [\[-\^], "n", "r", "t", [\{-\}] at line 1, column 4 (byte 4):
+                  \\\z
+                  ~~~^
+-\ca              Expected one of [\(-\+], "-", ".", "?", [\[-\^], "n", "r", "t", [\{-\}] at line 1, column 2 (byte 2):
+                  \ca
+                  ~^
+=\(\)\*\+\.\?\[\\ ["seq", "(", ")", "*", "+", ".", "?", "[", "\\"]
+                  "()*+.?[\\"
+=\]\{\|\}\t\r\n   ["seq", "]", "{", "|", "}", "\t", "\r", "\n"]
+                  "]{|}\t\r\n"
+=a*               ["rep", 0, false, "a"]
+                  "", "a", "aa", "aaa", "aaaa"
+=🤔*               ["rep", 0, false, "🤔"]
+                  "", "🤔", "🤔🤔", "🤔🤔🤔", "🤔🤔🤔🤔"
+-a**              Expected one of [\u0000-'], ",", "-", [/->], [@-Z], [\^-z], [~-􏿿], ".", "\\", "\\p{", "\\P{", "[", "(", "|" at line 1, column 3 (byte 3):
+                  a**
+                  ~~^
+=a|b              ["alt", "a", "b"]
+                  "a", "b"
+=aa|bb            ["alt", ["seq", "a", "a"], ["seq", "b", "b"]]
+                  "aa", "bb"
+=aa|              ["alt", ["seq", "a", "a"], ["seq"]]
+                  "aa", ""
+=|bb              ["alt", ["seq"], ["seq", "b", "b"]]
+                  "", "bb"
+=aa|bb*           ["alt", ["seq", "a", "a"], ["seq", "b", ["rep", 0, false, "b"]]]
+                  "aa", "b", "bb", "bbb", "bbbb", "bbbbb"
+=aa|bb+           ["alt", ["seq", "a", "a"], ["seq", "b", ["rep", 1, false, "b"]]]
+                  "aa", "bb", "bbb", "bbbb", "bbbbb", "bbbbbb"
+=aa|bb?           ["alt", ["seq", "a", "a"], ["seq", "b", ["rep", 0, 1, "b"]]]
+                  "aa", "b", "bb"
+=aa|bb{6}         ["alt", ["seq", "a", "a"], ["seq", "b", ["rep", 6, 6, "b"]]]
+                  "aa", "bbbbbbb"
+=aa|bb{6,}        ["alt", ["seq", "a", "a"], ["seq", "b", ["rep", 6, false, "b"]]]
+                  "aa", "bbbbbbb", "bbbbbbbb", "bbbbbbbbb", "bbbbbbbbbb", "bbbbbbbbbbb"
+=aa|bb{6,8}       ["alt", ["seq", "a", "a"], ["seq", "b", ["rep", 6, 8, "b"]]]
+                  "aa", "bbbbbbb", "bbbbbbbb", "bbbbbbbbb"
+=(aa)             ["seq", "a", "a"]
+                  "aa"
+-aa)              Expected one of "*", "+", "?", "{", [\u0000-'], ",", "-", [/->], [@-Z], [\^-z], [~-􏿿], ".", "\\", "\\p{", "\\P{", "[", "(", "|" at line 1, column 3 (byte 3):
+                  aa)
+                  ~~^
+-(aa              Expected one of "*", "+", "?", "{", [\u0000-'], ",", "-", [/->], [@-Z], [\^-z], [~-􏿿], ".", "\\", "\\p{", "\\P{", "[", "(", "|", ")" at line 1, column 4 (byte 4):
+                  (aa
+                  ~~~^
+=aa(bb|cc)dd      ["seq", "a", "a", ["alt", ["seq", "b", "b"], ["seq", "c", "c"]], "d", "d"]
+                  "aabbdd", "aaccdd"
+-aabb|cc)dd       Expected one of "*", "+", "?", "{", [\u0000-'], ",", "-", [/->], [@-Z], [\^-z], [~-􏿿], ".", "\\", "\\p{", "\\P{", "[", "(", "|" at line 1, column 8 (byte 8):
+                  aabb|cc)dd
+                  ~~~~~~~^
+-aa(bb|ccdd       Expected one of "*", "+", "?", "{", [\u0000-'], ",", "-", [/->], [@-Z], [\^-z], [~-􏿿], ".", "\\", "\\p{", "\\P{", "[", "(", "|", ")" at line 1, column 11 (byte 11):
+                  aa(bb|ccdd
+                  ~~~~~~~~~~^
+=[abc]            ["pos", "a", "b", "c"]
+                  "a", "b", "c"
+-[a               Expected one of "-", [\u0000-,], [\.-Z], [\^-􏿿], "\\", "\\p{", "\\P{", "]" at line 1, column 3 (byte 3):
+                  [a
+                  ~~^
+-a]               Expected one of "*", "+", "?", "{", [\u0000-'], ",", "-", [/->], [@-Z], [\^-z], [~-􏿿], ".", "\\", "\\p{", "\\P{", "[", "(", "|" at line 1, column 2 (byte 2):
+                  a]
+                  ~^
+=[a🤔b]            ["pos", "a", "🤔", "b"]
+                  "a", "🤔", "b"
+=[^abc]           ["neg", "a", "b", "c"]
+                  "\n", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v"
+=[ab-f]           ["pos", "a", ["-", "b", "f"]]
+                  "a", "b", "c", "d", "e", "f"
+=[^ab-f]          ["neg", "a", ["-", "b", "f"]]
+                  "\n", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y"
+=[^-ab-f]         ["neg", "-", "a", ["-", "b", "f"]]
+                  "\n", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y"
+=[-ab-f]          ["pos", "-", "a", ["-", "b", "f"]]
+                  "-", "a", "b", "c", "d", "e", "f"
+=[ab-f-]          ["pos", "a", ["-", "b", "f"], "-"]
+                  "a", "b", "c", "d", "e", "f", "-"
+=[a\n-\r-]        ["pos", "a", ["-", "\n", "\r"], "-"]
+                  "a", "\n", "\u000b", "\f", "\r", "-"
+=\p{Nd}           ["p", "Nd"]
+                  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "٠", "١", "٢", "٣", "٤", "٥", "٦", "٧", "٨", "٩"
+=\P{Ll}           ["P", "Ll"]
+                  "\n", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S"
+=\P{L}            ["P", "L"]
+                  "\n", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "!", "\"", "#", "%", "&", "'", "(", ")", "*"
+=\p{Co}           ["p", "Co"]
+                  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""
+*[\p{Nd}]         ["pos", ["p", "Nd"]]
+                  bug in regexp example generator:
+                  "p", "{", "N", "d", "}"
+*[\P{Nd}]         ["pos", ["P", "Nd"]]
+                  bug in regexp example generator:
+                  "P", "{", "N", "d", "}"
+*[^\p{Nd}\p{Ll}]  ["neg", ["p", "Nd"], ["p", "Ll"]]
+                  bug in regexp example generator:
+                  "\n", "a", "b", "c", "e", "f", "g", "h", "i", "j", "k", "m", "n", "o", "q", "r", "s", "t", "u", "v"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iregexp
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-29 00:00:00.000000000 Z
+date: 2023-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,17 +70,17 @@ description: iregexp implements converters and miscellaneous tools for I-Regexp
 email: cabo@tzi.org
 executables:
 - iregexp
-- iregexp~
 extensions: []
 extra_rdoc_files: []
 files:
 - bin/iregexp
-- bin/iregexp~
 - iregexp.gemspec
 - lib/iregexp.rb
 - lib/parser/iregexp-util.rb
 - lib/parser/iregexpgrammar.rb
 - lib/writer/iregexp-writer.rb
+- test-data/simple.irl
+- test-data/simple.out
 homepage: http://github.com/cabo/iregexp
 licenses:
 - MIT

data/bin/iregexp~

@@ -1,102 +0,0 @@
-#!/usr/bin/env ruby
-require 'pp'
-require 'yaml'
-require 'treetop'
-require 'json'
-
-require_relative '../lib/jpt'
- 
-Encoding.default_external = Encoding::UTF_8
-require 'optparse'
-require 'ostruct'
-
-FUNCSIG_CHARS = {"l" => :logical, "n" => :nodes, "v" => :value}
-
-$options = OpenStruct.new
-begin
-  op = OptionParser.new do |opts|
-    opts.banner = "Usage: jpt.rb [options] file.jp"
-
-    opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
-      $options.verbose = v
-    end
-    opts.on("-l", "--[no-]lines", "multi-line mode") do |v|
-      $options.lines = v
-    end
-    opts.on("-q", "--[no-]test", "test-file mode") do |v|
-      $options.test = v
-    end
-    opts.on("-fFUNCSIG", "--[no-]f=FUNCSIG", "add function signature name=rppp") do |v|
-      fail "funcsig format must be name=rppp" unless v =~ /\A([a-z][_a-z0-9]*)-([lnv]+)\z/
-      
-      JPTType.add_funcsig($1, $2)
-    end
-    opts.on("-tFMT", "--to=FMT", [:basic, :neat, :json, :yaml, :enum, :jp], "Target format") do |v|
-      $options.target = v
-    end
-  end
-  op.parse!
-rescue Exception => e
-  warn e
-  exit 1
-end
-
-if ARGV == []
-  puts op
-  exit 1
-end
-jp_file = ARGF.read
-
-if $options.test
-  argument = query = output = nil
-  jp_file.scan(/((?:^(?:$|[^$=].*)\n)+)|([$].*)|=(.*)|#.*/) do |arg,qy,out|
-    begin
-      if arg
-        argument = JSON.parse(arg)
-        puts
-        puts JSON.dump(argument)
-      elsif qy
-        jpt = JPT.from_jp(qy)
-        output = jpt.apply(argument)
-        print jpt.tree.inspect << " "
-        puts "➔ #{JSON.dump(output)}"
-      elsif out
-        suggested = JSON.parse(out)
-        if output != suggested
-          p [:SUGGESTED, suggested]
-        end
-      end
-    rescue => e
-      warn "*** #{e.detailed_message} #{e.backtrace}"
-    end
-  end
-elsif $options.lines
-  lines = jp_file.lines(chomp: true)
-  col = lines.map(&:length).max
-  form = "%-#{col}s %s"
-  lines.each do |line|
-    jpt = JPT.from_jp(line)
-    result = jpt.tree.inspect
-    puts form % [line, result]
-  end
-else
-
-jpt = JPT.from_jp(jp_file)
-result = jpt.tree
-
-case $options.target
-when :basic, nil
-  pp result
-when :neat, :json
-  require 'neatjson'
-  puts JSON.neat_generate(result, after_comma: 1, after_colon: 1)
-when :yaml
-  puts result.to_yaml
-when :jp
-  require_relative '../lib/writer/jp-writer.rb'
-  puts jpt.to_s
-else
-  warn ["Unknown target format: ", $options.target].inspect
-end
-
-end