rparsec2 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4561cdd86a68228d3d19811f6d8cf77a2664c21c61fac3b368035d6be7d55df3
-  data.tar.gz: bc34dfa71df4b91c505b6a27d5d3b23c3f6acc6c2542d77cebad140d78b670a9
+  metadata.gz: ce59ff665a46de4f47bc1cc49a0b6eba80901a691ed5d24b66309857cf01dbac
+  data.tar.gz: 3d015234cac23f1f2320d9ffdd44ac5b0cdc8308b20b1690d613dd881b7791ae
 SHA512:
-  metadata.gz: a9731ba718453a5814d896bccc2221b7473c577a16a62b710fe4e723225ea616c3067022e7e7cd902d217d290c9f47553184de4197a0421dd2b3d96418f6ccad
-  data.tar.gz: 89b2f4f0678b636570d6eb9d3b7ac0ac83555c64036a3ae9031c74df068a7603d028770bda66960c0933fa517a4c2b63249b772b18e4abae9f7b0523b3d8e49b
+  metadata.gz: 9be2831196854dee89ffd21ffc6850520b0d9b204314475039acd274241e5ad4db7286c2bef4a7a576c1c9e003050b94c574607a9b0947a13018742de7afa296
+  data.tar.gz: 300af123c05ac025a9f3294a6c628e05cf60b1551b1f9036a14598426e9cb720ee41506658ceacc7edad28cabb3fa5b721a5b30cc9e2ed7589766329b3668fdd

data/lib/rparsec/alt_parser.rb

@@ -0,0 +1,38 @@
+require "rparsec/look_ahead_sensitive_parser"
+
+module RParsec
+  class AltParser < LookAheadSensitiveParser # :nodoc:
+    def initialize(alts, la = 1)
+      super(la)
+      @alts = alts
+      @lookahead = la
+    end
+    def _parse ctxt
+      ind = ctxt.index
+      result = ctxt.result
+      err = ctxt.error
+      err_ind = -1
+      err_pos = -1
+      for p in @alts
+        ctxt.reset_error
+        ctxt.index = ind
+        ctxt.result = result
+        return true if p._parse(ctxt)
+        if ctxt.error.index > err_pos
+          err = ctxt.error
+          err_ind = ctxt.index
+          err_pos = ctxt.error.index
+        end
+      end
+      ctxt.index = err_ind
+      ctxt.error = err
+      return false
+    end
+    def withLookahead(n)
+      AltParser.new(@alts, n)
+    end
+    def | other
+      AltParser.new(@alts.dup << autobox_parser(other)).tap { |p| p.name = name }
+    end
+  end
+end

data/lib/rparsec/any_parser.rb

@@ -0,0 +1,12 @@
+require "rparsec/parser"
+
+module RParsec
+  class AnyParser < Parser # :nodoc:
+    def _parse ctxt
+      return ctxt.expecting if ctxt.eof
+      result = ctxt.current
+      ctxt.next
+      ctxt.retn result
+    end
+  end
+end

data/lib/rparsec/are_parser.rb

@@ -0,0 +1,20 @@
+require "rparsec/parser"
+
+module RParsec
+  class AreParser < Parser # :nodoc:
+    init :vals, :msg
+    def _parse ctxt
+      if @vals.length > ctxt.available
+        return ctxt.expecting(@msg)
+      end
+      cur = 0
+      for cur in (0...@vals.length)
+        if @vals[cur] != ctxt.peek(cur)
+          return ctxt.expecting(@msg)
+        end
+      end
+      ctxt.advance(@vals.length)
+      ctxt.retn @vals
+    end
+  end
+end

data/lib/rparsec/atom_parser.rb

@@ -0,0 +1,16 @@
+require "rparsec/parser"
+
+module RParsec
+  class AtomParser < Parser # :nodoc:
+    init :parser
+    def _parse ctxt
+      ind = ctxt.index
+      return true if @parser._parse ctxt
+      ctxt.index = ind
+      return false
+    end
+    def atomize
+      self
+    end
+  end
+end

data/lib/rparsec/best_parser.rb

@@ -0,0 +1,44 @@
+require "rparsec/parser"
+require "rparsec/failures"
+
+module RParsec
+  class BestParser < Parser # :nodoc:
+    init :alts, :longer
+    def _parse ctxt
+      best_result = nil
+      best_ind = -1
+      err_ind = -1
+      err_pos = -1
+      ind = ctxt.index
+      result = ctxt.result
+      err = ctxt.error
+      for p in @alts
+        ctxt.reset_error
+        ctxt.index = ind
+        ctxt.result = result
+        if p._parse(ctxt)
+          err = nil
+          now_ind = ctxt.index
+          if best_ind == -1 || (now_ind != best_ind && @longer == (now_ind > best_ind))
+            best_result = ctxt.result
+            best_ind = now_ind
+          end
+        elsif best_ind < 0 # no good match found yet.
+          if ctxt.error.index > err_pos
+            err_ind = ctxt.index
+            err_pos = ctxt.error.index
+          end
+          err = Failures.add_error(err, ctxt.error)
+        end
+      end
+      if best_ind >= 0
+        ctxt.index = best_ind
+        return ctxt.retn(best_result)
+      else
+        ctxt.error = err
+        ctxt.index = err_ind
+        return false
+      end
+    end
+  end
+end

data/lib/rparsec/bound_parser.rb

@@ -0,0 +1,11 @@
+require "rparsec/parser"
+
+module RParsec
+  class BoundParser < Parser # :nodoc:
+    init :parser, :proc
+    def _parse ctxt
+      return false unless @parser._parse(ctxt)
+      @proc.call(ctxt.result)._parse ctxt
+    end
+  end
+end

data/lib/rparsec/boundn_parser.rb

@@ -0,0 +1,11 @@
+require "rparsec/parser"
+
+module RParsec
+  class BoundnParser < Parser # :nodoc:
+    init :parser, :proc
+    def _parse ctxt
+      return false unless @parser._parse(ctxt)
+      @proc.call(*ctxt.result)._parse ctxt
+    end
+  end
+end

data/lib/rparsec/catch_parser.rb

@@ -0,0 +1,17 @@
+require "rparsec/parser"
+
+module RParsec
+  class CatchParser < Parser # :nodoc:
+    init :symbol, :parser
+    def _parse ctxt
+      interrupted = true
+      ok = false
+      catch @symbol do
+        ok = @parser._parse(ctxt)
+        interrupted = false
+      end
+      return ctxt.retn(@symbol) if interrupted
+      ok
+    end
+  end
+end

data/lib/rparsec/context.rb

@@ -5,11 +5,13 @@ require 'strscan'
 module RParsec
 
   class ParseContext # :nodoc:
-    attr_reader :error, :src, :index, :result
-    attr_writer :error, :index, :result
+    attr_reader :src
+    attr_accessor :error, :index, :result
 
     def initialize(src, index=0, error=nil)
-      @src, @index, @error = src, index, error
+      @src = src
+      @index = index
+      @error = error
       @scanner = nil
     end
 

data/lib/rparsec/{misc.rb → def_helper.rb}

@@ -6,18 +6,15 @@ module RParsec
   # Helpers for defining ctor.
   #
   module DefHelper # :nodoc:
-    def def_ctor(*vars)
+    def def_readable(*vars)
+      attr_reader(*vars)
+
       define_method(:initialize) do |*params|
-        vars.each_with_index do |var, i|
-          instance_variable_set("@" + var.to_s, params[i])
+        vars.zip(params) do |var, param|
+          instance_variable_set("@#{var}", param)
         end
       end
     end
-
-    def def_readable(*vars)
-      attr_reader(*vars)
-      def_ctor(*vars)
-    end
   end
 
 end # module

data/lib/rparsec/eof_parser.rb

@@ -0,0 +1,11 @@
+require "rparsec/parser"
+
+module RParsec
+  class EofParser < Parser # :nodoc:
+    init :msg
+    def _parse ctxt
+      return true if ctxt.eof
+      return ctxt.expecting(@msg)
+    end
+  end
+end

data/lib/rparsec/error.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rparsec/misc'
+require 'rparsec/def_helper'
 
 module RParsec
 
@@ -11,21 +11,17 @@ module RParsec
 
   class Failure # :nodoc:
     def initialize(ind, input, message = nil)
-      @index, @input, @msg = ind, input, message
+      @index = ind
+      @input = input
+      @msg = message
     end
 
-    attr_reader :index, :input
-    attr_writer :index
+    attr_reader :input
+    attr_accessor :index
 
-    def msg
-      return @msg.to_s
-    end
-
-    Precedence = 100
+    def msg = @msg.to_s
   end
 
-  class Expected < Failure # :nodoc:
-    Precedence = 100
-  end
+  Expected = Class.new(Failure) # :nodoc:
 
 end # module

data/lib/rparsec/expect_parser.rb

@@ -0,0 +1,18 @@
+require "rparsec/parser"
+
+module RParsec
+  class ExpectParser < Parser # :nodoc:
+    def initialize(parser, msg)
+      super()
+      @parser = parser
+      @msg = msg
+      @name = msg
+    end
+    def _parse ctxt
+      ind = ctxt.index
+      return true if @parser._parse ctxt
+      return false unless ind == ctxt.index
+      ctxt.expecting(@msg)
+    end
+  end
+end

data/lib/rparsec/expressions.rb

@@ -50,25 +50,11 @@ module RParsec
       end
 
       def apply_operator(term, op, kind, delim)
-        term, op = ignore_rest(term, delim), ignore_rest(op, delim)
-        # we could use send here,
-        # but explicit case stmt is more straight forward and less coupled with names.
-        # performance might be another benefit,
-        # though it is not clear whether meta-code is indeed slower than regular ones at all.
-        case kind
-        when :prefix
-          term.prefix(op)
-        when :postfix
-          term.postfix(op)
-        when :infixl
-          term.infixl(op)
-        when :infixr
-          term.infixr(op)
-        when :infixn
-          term.infixn(op)
-        else
-          raise ArgumentError, "unknown associativity: #{kind}"
-        end
+        Associativities.include?(kind) or raise ArgumentError, "unknown associativity: #{kind}"
+
+        term = ignore_rest(term, delim)
+        op = ignore_rest(op, delim)
+        term.send(kind, op)
       end
 
       def ignore_rest(parser, delim)

data/lib/rparsec/failure_parser.rb

@@ -0,0 +1,10 @@
+require "rparsec/parser"
+
+module RParsec
+  class FailureParser < Parser # :nodoc:
+    init :msg
+    def _parse ctxt
+      return ctxt.failure(@msg)
+    end
+  end
+end

data/lib/rparsec/failures.rb

@@ -0,0 +1,31 @@
+module RParsec
+  class Failures # :nodoc:
+    def self.add_error(err, e)
+      return e if err.nil?
+      return err if e.nil?
+      cmp = compare_error(err, e)
+      return err if cmp > 0
+      return e if cmp < 0
+      err
+    end
+
+    class << self
+      private
+
+      def get_first_element(err)
+        while err.kind_of?(Array)
+          err = err[0]
+        end
+        err
+      end
+
+      def compare_error(e1, e2)
+        e1 = get_first_element(e1)
+        e2 = get_first_element(e2)
+        return -1 if e1.index < e2.index
+        return 1 if e1.index > e2.index
+        0
+      end
+    end
+  end
+end

data/lib/rparsec/followed_parser.rb

@@ -0,0 +1,13 @@
+require "rparsec/parser"
+
+module RParsec
+  class FollowedParser < Parser # :nodoc:
+    init :p1, :p2
+    def _parse ctxt
+      return false unless @p1._parse ctxt
+      result = ctxt.result
+      return false unless @p2._parse ctxt
+      ctxt.retn(result)
+    end
+  end
+end

data/lib/rparsec/fragment_parser.rb

@@ -0,0 +1,12 @@
+require "rparsec/parser"
+
+module RParsec
+  class FragmentParser < Parser # :nodoc:
+    init :parser
+    def _parse ctxt
+      ind = ctxt.index
+      return false unless @parser._parse ctxt
+      ctxt.retn(ctxt.src[ind, ctxt.index - ind])
+    end
+  end
+end

data/lib/rparsec/functor_mixin.rb

@@ -9,27 +9,20 @@ module RParsec
     # Create a +Proc+, which expects the two parameters in the reverse
     # order of +self+.
     #
-    def flip
-      Functors.flip(&self)
-    end
+    def flip = Functors.flip(&self)
 
     #
     # Create a +Proc+, when called, the parameter is first passed into
     # +other+, +self+ is called in turn with the return value from
     # +other+.
     #
-    def compose(other)
-      Functors.compose(self, other)
-    end
-
+    def compose(other) = Functors.compose(self, other)
     alias << compose
 
     #
     # <tt>a >> b</tt> is equivalent to <tt>b << a</tt>.  See also #<<.
     #
-    def >>(other)
-      other << self
-    end
+    def >>(other) = other << self
 
     #
     # Create a Proc that's curriable.
@@ -47,9 +40,7 @@ module RParsec
     # See the "functor_test.rb"
     [Proc, Method].each do |klass|
       refine klass do
-        def curry(ary = arity)
-          Functors.curry(ary, &self)
-        end
+        def curry(ary = arity) = Functors.curry(ary, &self)
       end
     end
 
@@ -61,42 +52,30 @@ module RParsec
     # the hood to perform the actual job when currying is done.  +ary+
     # explicitly specifies the number of parameters to curry.
     #
-    def reverse_curry(ary = arity)
-      Functors.reverse_curry(ary, &self)
-    end
+    def reverse_curry(ary = arity) = Functors.reverse_curry(ary, &self)
 
     #
     # Uncurry a curried closure.
     #
-    def uncurry
-      Functors.uncurry(&self)
-    end
+    def uncurry = Functors.uncurry(&self)
 
     #
     # Uncurry a reverse curried closure.
     #
-    def reverse_uncurry
-      Functors.reverse_uncurry(&self)
-    end
+    def reverse_uncurry = Functors.reverse_uncurry(&self)
 
     #
     # Create a +Proc+, when called, repeatedly call +self+ for +n+
     # times.  The same arguments are passed to each invocation.
     #
-    def repeat(n)
-      Functors.repeat(n, &self)
-    end
-    #
+    def repeat(n) = Functors.repeat(n, &self)
+    alias * repeat
 
     # Create a +Proc+, when called, repeatedly call +self+ for +n+
     # times.  At each iteration, return value from the previous
     # iteration is used as parameter.
     #
-    def power(n)
-      Functors.power(n, &self)
-    end
-
+    def power(n) = Functors.power(n, &self)
     alias ** power
-    alias * repeat
   end
 end

data/lib/rparsec/get_index_parser.rb

@@ -0,0 +1,9 @@
+require 'rparsec/parser'
+
+module RParsec
+  class GetIndexParser < Parser # :nodoc:
+    def _parse ctxt
+      ctxt.retn(ctxt.index)
+    end
+  end
+end

data/lib/rparsec/keywords.rb

@@ -25,9 +25,7 @@ module RParsec
     #
     # Do we lex case sensitively?
     #
-    def case_sensitive?
-      @case_sensitive
-    end
+    def case_sensitive? = @case_sensitive
 
     #
     # To create an instance that lexes the given keywords case
@@ -57,7 +55,9 @@ module RParsec
 
     # scanner has to return a string
     def initialize(words, case_sensitive, default_lexer, keyword_symbol, &block)
-      @default_lexer, @case_sensitive, @keyword_symbol = default_lexer, case_sensitive, keyword_symbol
+      @default_lexer = default_lexer
+      @case_sensitive = case_sensitive
+      @keyword_symbol = keyword_symbol
       # this guarantees that we have copy of the words array and all the word strings.
       words = copy_words(words, case_sensitive)
       @name_map = {}
@@ -94,21 +94,21 @@ module RParsec
 
     def make_lexer(default_lexer, word_map)
       default_lexer.map do |tok|
-        text, ind = tok.text, tok.index
+        text = tok.text
+        ind = tok.index
         key = canonical_name(text)
         my_symbol = word_map[key]
-        case when my_symbol.nil? then tok
-          else Token.new(my_symbol, text, ind) end
+        my_symbol.nil? ? tok : Token.new(my_symbol, text, ind)
       end
     end
 
     def canonical_name(name)
-      case when @case_sensitive then name else name.downcase end
+      @case_sensitive ? name : name.downcase
     end
 
     def copy_words(words, case_sensitive)
       words.map do |w|
-        case when case_sensitive then w.dup else w.downcase end
+        case_sensitive ? w.dup : w.downcase
       end
     end
   end

data/lib/rparsec/lazy_parser.rb

@@ -0,0 +1,10 @@
+require "rparsec/parser"
+
+module RParsec
+  class LazyParser < Parser # :nodoc:
+    init :block
+    def _parse ctxt
+      @block.call._parse ctxt
+    end
+  end
+end

data/lib/rparsec/locator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rparsec/misc'
+require 'rparsec/def_helper'
 
 module RParsec
 
@@ -13,12 +13,14 @@ module RParsec
 
     def locate(ind)
       return _locateEof if ind >= code.length
-      line, col = 1, 1
+      line = 1
+      col = 1
       return line, col if ind <= 0
       for i in (0...ind)
         c = code[i]
         if c == LF
-          line, col = line + 1, 1
+          line = line + 1
+          col = 1
         else
           col = col + 1
         end
@@ -27,10 +29,12 @@ module RParsec
     end
 
     def _locateEof
-      line, col = 1, 1
+      line = 1
+      col = 1
       code.each_byte do |c|
         if c == LF.ord
-          line, col = line + 1, 1
+          line = line + 1
+          col = 1
         else
           col = col + 1
         end

data/lib/rparsec/look_ahead_sensitive_parser.rb

@@ -0,0 +1,46 @@
+require "rparsec/parser"
+
+module RParsec
+  class LookAheadSensitiveParser < Parser # :nodoc:
+    def initialize(la = 1)
+      super()
+      @lookahead = la
+    end
+    def visible(ctxt, n)
+      ctxt.index - n < @lookahead
+    end
+    def lookahead(n)
+      raise ArgumentError, "lookahead number #{n} should be positive" unless n > 0
+      return self if n == @lookahead
+      withLookahead(n)
+    end
+    def not(msg = "#{self} unexpected")
+      NotParser.new(self, msg, @lookahead)
+    end
+  end
+
+  # Define here to avoid circular loadings.
+  class NotParser < LookAheadSensitiveParser # :nodoc:
+    def initialize(parser, msg, la = 1)
+      super(la)
+      @parser = parser
+      @msg = msg
+      @name = "~#{parser.name}"
+    end
+    def _parse ctxt
+      ind = ctxt.index
+      if @parser._parse ctxt
+        ctxt.index = ind
+        return ctxt.expecting(@msg)
+      end
+      return ctxt.retn(nil) if visible(ctxt, ind)
+      return false
+    end
+    def withLookahead(n)
+      NotParser.new(@parser, @msg, n)
+    end
+    def not()
+      @parser
+    end
+  end
+end

data/lib/rparsec/many__parser.rb

@@ -0,0 +1,20 @@
+require "rparsec/parser"
+
+module RParsec
+  class Many_Parser < Parser # :nodoc:
+    init :parser, :least
+    def _parse ctxt
+      @least.times do
+        return false unless @parser._parse ctxt
+      end
+      while true
+        ind = ctxt.index
+        if @parser._parse ctxt
+          return true if ind == ctxt.index # infinite loop
+          next
+        end
+        return ind == ctxt.index
+      end
+    end
+  end
+end