fupeg 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fb3eb5f497d0c4294b507b5c8681b39635b4a7d1df96644f2afd73170e552b2
-  data.tar.gz: 682bfdc3c694abeddd1dc31591ef5bd39429ec4c9b2511e71269939eedd26549
+  metadata.gz: c08b3d48fd87bd8fc04611663270f967afdf9bab0e0e5ce9c63b38c9f00332b6
+  data.tar.gz: 93308247a0fb582957862a4c0e274a3c646c1a7cba7ffc9acade0af1f5d6d250
 SHA512:
-  metadata.gz: 00d7f7fc3d440d968df79df59dab77c87918437dfee730682f31728fe0e1f43c650d88a1ef8d44d92c18f107d83a14fb47db0758516cf97e520e47690e118af7
-  data.tar.gz: 1653a4e8f7a3302b42682b29fac7b18e28e61dc99f1e63b392058282d73f3f2e54963e081431507b5e9fbb52bf5da7341de72d34e2fdaf7497db25215621f8b2
+  metadata.gz: 42973a5d22dd77f267a94d6ec65823ab891a2d63983dc548a4818b8b77ca24f5138754e08ae1a9b9b3e42a8791215f0c9b0f546e2397729a80dcb5fbb8929447
+  data.tar.gz: 5b99feff0f26acdac764194409f2b2d137a5dc6e16a6122e78cefda3647c680944b847112e135df32b9a27cd0c50652e3c6f32387713906c0fcb4938a8712c85

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.3.0] - 2023-08-28
+
+- Grammar.use_gram - to simplier grammar inclusion
+- Grammar.proxy - to proxy rules to included grammar
+- `_(pat)` doesn't return matched text, use `txt(pat)` instead
+- "\`" is specialized for tokens
+-- token is either ident (which is specified with `ident_only` method), or symbols,
+-- `token_sp?` is skipped after token
+- fixes for position calculation
+
 ## [0.2.0] - 2023-08-15
 
 - Split Parser and Grammar

data/lib/fupeg/grammar.rb

@@ -15,20 +15,43 @@ module FuPeg
       gr.__send__(root)
     end
 
+    def self.use_gram(gram, *, as: nil)
+      if as.nil?
+        name = gram.name[/\w+$/]
+        name = name.gsub(/(?<!^)(?=[A-Z](?![A-Z\d_]))/, "_").downcase
+        as = :"@#{name}"
+      elsif !as.start_with?("@")
+        as = :"@#{as}"
+      end
+      @used_grams ||= {}
+      @used_grams[as] = gram
+    end
+
+    def self.proxy(*meths, to:)
+      meths.each do |meth|
+        define_method(meth) { |*args, &block|
+          instance_variable_get(to).__send__(meth, *args, &block)
+        }
+      end
+    end
+
+    def self.used_grams
+      @used_grams&.dup || {}
+    end
+
     def initialize(parser)
       @p = parser
+      self.class.used_grams.each do |iv, v|
+        instance_variable_set(iv, v.new(parser))
+      end
     end
 
-    def fail!
-      @p.fail!(skip: 3)
+    def fail!(pat: nil)
+      @p.fail!(pat: pat, skip: 3)
     end
 
     def dot
-      @p.match(/./m)
-    end
-
-    def `(str)
-      @p.match(str)
+      @p.dot
     end
 
     def _(lit = nil, &block)
@@ -40,21 +63,17 @@ module FuPeg
     end
 
     def will?(lit = nil, &block)
-      @p.preserve(pos: true) { @p.match(lit, &block) }
+      @p.look_ahead(true, lit, &block)
     end
 
     def wont!(lit = nil, &block)
-      @p.preserve(pos: true, failed: true) { !@p.match(lit, &block) } || @p.fail!
+      @p.look_ahead(false, lit, &block)
     end
 
-    def text(lit = nil, &block)
+    def txt(lit = nil, &block)
       @p.text(lit, &block)
     end
 
-    def bounds(lit = nil, &block)
-      @p.bounds(lit, &block)
-    end
-
     def cut(&block)
       @p.with_cut_point(&block)
     end
@@ -68,21 +87,70 @@ module FuPeg
     end
 
     def rep(range = 0.., lit = nil, &block)
-      range = range..range if Integer === range
-      range = 0..range.max if range.begin.nil?
-      unless Integer === range.min && (range.end.nil? || Integer === range.max)
-        raise "Range malformed #{range}"
-      end
-      @p.backtrack do
-        max = range.end && range.max
-        ar = []
-        (1..max).each do |i|
-          res = @p.backtrack { yield i == 1 }
-          break unless res
-          ar << res
-        end
-        (ar.size >= range.min) ? ar : @p.fail!
-      end
+      @p.repetition(range, lit, &block)
+    end
+
+    # specialized matchers
+
+    def eof
+      @p.eof? && :eof
+    end
+
+    def nl
+      _(/\r\n|\r|\n/)
+    end
+
+    def eol
+      _ { lnsp? && nl && :eol }
+    end
+
+    def lnsp?
+      _(/[ \t]*/)
+    end
+
+    def lnsp!
+      _(/[ \t]+/)
+    end
+
+    def sp!
+      _(/\s+/)
+    end
+
+    def sp?
+      _(/\s*/)
+    end
+
+    def ident
+      (w = ident_only) && token_sp? && w
+    end
+
+    # raw token match
+    # if token is ident, then exact match performed with whole next ident
+    # else only string match
+    # and then whitespace is consumed
+    def `(token)
+      @p.match {
+        if _is_ident?(token)
+          _{ ident_only == token } || fail!(pat: token)
+        else
+          @p.match(token)
+        end && token_sp? && token
+      }
+    end
+
+    def _is_ident?(tok)
+      @_is_ident ||= Hash.new { |h, k|
+        h[k] = self.class.parse(:ident_only, k) == k
+      }
+      @_is_ident[tok]
+    end
+
+    def ident_only
+      txt(/[a-zA-Z_]\w*/)
+    end
+
+    def token_sp?
+      _(/\s*/)
     end
   end
 end

data/lib/fupeg/parser.rb

@@ -4,6 +4,11 @@ require "strscan"
 
 module FuPeg
   class Parser
+    attr_accessor :debug
+    attr_accessor :file
+    attr_reader :failed
+    attr_reader :str
+
     def initialize(str, pos = 0)
       reset!(str, pos)
     end
@@ -19,11 +24,10 @@ module FuPeg
         @scan.pos = pos
       end
       @failed = nil
+      @debug = false
       @cut = CutPoint.new
     end
 
-    attr_reader :failed
-
     def bytepos
       @scan.pos
     end
@@ -32,30 +36,44 @@ module FuPeg
       @str_size - @str.byteslice(pos..).size
     end
 
-    Fail = Struct.new(:stack, :bytepos)
+    Fail = Struct.new(:stack, :bytepos, :pattern)
 
-    def fail!(*, skip: 2)
-      if !@failed || bytepos > @failed.bytepos
+    def fail!(*, pat: nil, skip: 2)
+      if debug || !@failed || bytepos > @failed.bytepos
         stack = caller_locations(skip)
         stack.delete_if do |loc|
-          if loc.path.start_with?(__dir__)
+          path = loc.path
+          if path == __FILE__
+            true
+          elsif path.start_with?(__dir__)
             loc.label =~ /\b(backtrack|each|block)\b/
           end
         end
-        @failed = Fail.new(stack, bytepos)
+        @failed = Fail.new(stack, bytepos, pat)
+        report_failed($stderr) if debug
       end
       nil
     end
 
     def failed_position
-      position_for_bytepos(@failed.bytepos)
+      position(bytepos: @failed.bytepos)
     end
 
     def report_failed(out)
-      pos = position_for_bytepos(@failed.bytepos)
-      out << "Failed at #{pos.lineno}:#{pos.colno} :\n"
-      out << pos.line + "\n"
-      out << (" " * (pos.colno - 1) + "^\n")
+      pos = position(bytepos: @failed.bytepos)
+      out << if @failed.pattern
+        "Failed #{failed.pattern.inspect} at #{pos.lineno}:#{pos.colno}"
+      else
+        "Failed at #{pos.lineno}:#{pos.colno}"
+      end
+      if @file
+        out << " of #{@file}"
+      end
+      out << ":\n"
+      out << pos.line.chomp + "\n"
+      curpos = pos.line[...pos.colno].gsub("\t", " " * 8).size
+      curpos = 1 if curpos == 0 && @failed.bytepos == @str.bytesize
+      out << (" " * (curpos - 1) + "^\n")
       out << "Call stack:\n"
       @failed.stack.each do |loc|
         out << "#{loc.path}:#{loc.lineno} in #{loc.label}\n"
@@ -63,31 +81,6 @@ module FuPeg
       out
     end
 
-    begin
-      StringScanner.new("x").skip("x")
-      def match(lit = //, &block)
-        block ? backtrack(&block) : (@scan.scan(lit) || fail!)
-      end
-    rescue
-      def match(lit = //, &block)
-        if String === lit
-          @_lit_cache ||= {}
-          lit = @_lit_cache[lit] ||= Regexp.new(Regexp.escape(lit))
-        end
-        block ? backtrack(&block) : (@scan.scan(lit) || fail!)
-      end
-    end
-
-    def text(lit = nil, &block)
-      pos = @scan.pos
-      match(lit, &block) && @str.byteslice(pos, @scan.pos - pos)
-    end
-
-    def bounds(lit = nil, &block)
-      pos = @scan.pos
-      match(lit, &block) && pos...@scan.pos
-    end
-
     class CutPoint
       attr_accessor :next
 
@@ -134,22 +127,80 @@ module FuPeg
       @line_ends << @str.bytesize
     end
 
-    def position_for_bytepos(pos)
-      lineno = @line_ends.bsearch_index { |x| x >= pos }
+    def position(bytepos: @scan.pos)
+      lineno = @line_ends.bsearch_index { |x| x >= bytepos }
       case lineno
       when nil
-        raise "Position #{pos} is larger than string byte size #{@str.bytesize}"
+        raise "Position #{bytepos} is larger than string byte size #{@str.bytesize}"
       else
         prev_end = @line_ends[lineno - 1]
         line_start = prev_end + 1
-        column = @str.byteslice(line_start, pos - prev_end).size
+        column = @str.byteslice(line_start, bytepos - prev_end).size
+      end
+      if bytepos == @str.bytesize
+        if @str[-1] == "\n"
+          lineno, column = lineno + 1, 1
+        else
+          column += 1
+        end
       end
       line = @str.byteslice(line_start..@line_ends[lineno])
-      Position.new(lineno, column, line, charpos(pos))
+      Position.new(lineno, column, line, charpos(bytepos))
     end
 
     # helper methods
 
+    begin
+      StringScanner.new("x").skip("x")
+      def match(lit = nil, &block)
+        block ? backtrack(&block) : (!lit || @scan.skip(lit) && true || fail!(pat: lit))
+      end
+    rescue
+      def match(lit = nil, &block)
+        if String === lit
+          @_lit_cache ||= {}
+          lit = @_lit_cache[lit] ||= Regexp.new(Regexp.escape(lit))
+        end
+        block ? backtrack(&block) : (!lit || @scan.skip(lit) && true || fail!(pat: lit))
+      end
+    end
+
+    def text(lit = nil, &block)
+      pos = @scan.pos
+      match(lit, &block) && @str.byteslice(pos, @scan.pos - pos)
+    end
+
+    def bounds(lit = nil, &block)
+      pos = @scan.pos
+      match(lit, &block) && pos...@scan.pos
+    end
+
+    def repetition(range = 0.., lit = nil, &block)
+      range = range..range if Integer === range
+      range = 0..range.max if range.begin.nil?
+      unless Integer === range.min && (range.end.nil? || Integer === range.max)
+        raise "Range malformed #{range}"
+      end
+      backtrack do
+        max = range.end && range.max
+        ar = []
+        (1..max).each do |i|
+          res = backtrack { yield i == 1 }
+          break unless res
+          ar << res
+        end
+        (ar.size >= range.min) ? ar : fail!
+      end
+    end
+
+    def dot
+      match(/./m)
+    end
+
+    def eof?
+      @scan.eos?
+    end
+
     def backtrack
       pos = @scan.pos
       res = yield
@@ -165,12 +216,25 @@ module FuPeg
       raise
     end
 
-    def preserve(pos = false, failed = false, &block)
-      p, f = @scan.pos, @failed
-      r = yield
-      @scan.pos = p if pos
-      @failed = f if failed
-      r
+    def look_ahead(positive, lit = nil, &block)
+      if block
+        p, f = @scan.pos, @failed
+        r = yield
+        @scan.pos = p
+        if positive ? r : !r
+          @failed = f
+          true
+        else
+          fail!
+        end
+      else
+        m = @scan.match?(lit)
+        if positive ? m : !m
+          true
+        else
+          fail!(pat: lit)
+        end
+      end
     end
   end
 end

data/lib/fupeg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FuPeg
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fupeg
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Yura Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-15 00:00:00.000000000 Z
+date: 2023-08-28 00:00:00.000000000 Z
 dependencies: []
 description: "\n    Simple backtracing parser, using ruby logical operators for primitive
   sequence/choice\n    and slim wrappers for other PEG style operators and backtrace.\n