rparsec2 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5de30f07e3855c6c2168832879138e3341ce79a20272ddf2c92857f47414e1ea
-  data.tar.gz: 74c1ad503c94fe4a75a788d1384161b6f1b34a7e017a0740a0025d24f8a8518f
+  metadata.gz: 4561cdd86a68228d3d19811f6d8cf77a2664c21c61fac3b368035d6be7d55df3
+  data.tar.gz: bc34dfa71df4b91c505b6a27d5d3b23c3f6acc6c2542d77cebad140d78b670a9
 SHA512:
-  metadata.gz: 26932d06bc2b3ec459ea0b3e22d091ebd1470d277bdac373b075821c97b82b4ab5936bdf4944150f21016cd9632f0a84d0428417f68446c31e33447734035e74
-  data.tar.gz: e776214089f74d14ce7f61d4fde624ca245127d7edf89ca87033fe96b2132ab25b74f4d36a8927a6c0c24145c0722b911334f7e1eb32f08064ed7e6b448fd33f
+  metadata.gz: a9731ba718453a5814d896bccc2221b7473c577a16a62b710fe4e723225ea616c3067022e7e7cd902d217d290c9f47553184de4197a0421dd2b3d96418f6ccad
+  data.tar.gz: 89b2f4f0678b636570d6eb9d3b7ac0ac83555c64036a3ae9031c74df068a7603d028770bda66960c0933fa517a4c2b63249b772b18e4abae9f7b0523b3d8e49b

data/lib/rparsec/context.rb

@@ -1,86 +1,88 @@
+# frozen_string_literal: true
+
 require 'strscan'
 
 module RParsec
 
-class ParseContext
-  attr_reader :error, :src, :index, :result
-  attr_writer :error, :index, :result
-  
-  def initialize(src, index=0, error=nil)
-    @src, @index, @error = src, index, error
-    @scanner = nil
-  end
+  class ParseContext # :nodoc:
+    attr_reader :error, :src, :index, :result
+    attr_writer :error, :index, :result
 
-  def scanner
-    @scanner = StringScanner.new(src) if @scanner.nil?
-    @scanner.pos= @index
-    @scanner
-  end
-  
-  def prepare_error
-    @error.flatten! if @error.kind_of?(Array)
-  end
-  
-  def to_msg
-    return '' if @error.nil?
-    return @error.msg unless @error.kind_of?(Array) 
-    @error.map{|e|e.msg}.join(' or ')
-  end
-  
-  def error_input
-    return nil if @error.nil?
-    err = @error
-    err = err.last if err.kind_of? Array
-    err.input
-  end
-  
-  def reset_error
-    @error = nil
-  end
-  
-  def current
-    @src[@index]
-  end
-  
-  def eof
-    @index >= @src.length
-  end
-  
-  def available
-    @src.length - @index
-  end
-  
-  def peek i
-    @src[@index+i]
-  end
-  
-  def next
-    @index += 1
-  end
-  
-  def advance n
-    @index += n
-  end
-  
-  def retn(val)
-    @result = val
-    true
-  end
-  
-  def failure(msg=nil)
-    @error = Failure.new(@index, get_current_input, msg)
-    return false
-  end
-  
-  def expecting(expected=nil)
-    @error = Expected.new(@index, get_current_input, expected)
-    return false
-  end
-  
-  def get_current_input
-    return nil if eof
-    current
+    def initialize(src, index=0, error=nil)
+      @src, @index, @error = src, index, error
+      @scanner = nil
+    end
+
+    def scanner
+      @scanner = StringScanner.new(src) if @scanner.nil?
+      @scanner.pos = @index
+      @scanner
+    end
+
+    def prepare_error
+      @error.flatten! if @error.kind_of?(Array)
+    end
+
+    def to_msg
+      return '' if @error.nil?
+      return @error.msg unless @error.kind_of?(Array)
+      @error.map { |e| e.msg }.join(' or ')
+    end
+
+    def error_input
+      return nil if @error.nil?
+      err = @error
+      err = err.last if err.kind_of? Array
+      err.input
+    end
+
+    def reset_error
+      @error = nil
+    end
+
+    def current
+      @src[@index]
+    end
+
+    def eof
+      @index >= @src.length
+    end
+
+    def available
+      @src.length - @index
+    end
+
+    def peek i
+      @src[@index + i]
+    end
+
+    def next
+      @index += 1
+    end
+
+    def advance n
+      @index += n
+    end
+
+    def retn(val)
+      @result = val
+      true
+    end
+
+    def failure(msg=nil)
+      @error = Failure.new(@index, get_current_input, msg)
+      return false
+    end
+
+    def expecting(expected=nil)
+      @error = Expected.new(@index, get_current_input, expected)
+      return false
+    end
+
+    def get_current_input
+      return nil if eof
+      current
+    end
   end
-end
 
 end # module

data/lib/rparsec/error.rb

@@ -1,28 +1,31 @@
+# frozen_string_literal: true
+
 require 'rparsec/misc'
 
 module RParsec
 
-class ParserException < StandardError
-  extend DefHelper
-  def_readable :index
-end
-class Failure
-  def initialize(ind, input, message = nil)
-    @index, @input, @msg = ind, input, message
+  class ParserException < StandardError # :nodoc:
+    extend DefHelper
+    def_readable :index
   end
 
-  attr_reader :index, :input
-  attr_writer :index
+  class Failure # :nodoc:
+    def initialize(ind, input, message = nil)
+      @index, @input, @msg = ind, input, message
+    end
 
-  def msg
-    return @msg.to_s
-  end
+    attr_reader :index, :input
+    attr_writer :index
 
-  Precedence = 100
-end
+    def msg
+      return @msg.to_s
+    end
 
-class Expected < Failure
-  Precedence = 100
-end
+    Precedence = 100
+  end
+
+  class Expected < Failure # :nodoc:
+    Precedence = 100
+  end
 
-end # module
+end # module

data/lib/rparsec/expressions.rb

@@ -1,186 +1,98 @@
+# frozen_string_literal: true
+
 require 'rparsec/parser'
 
 module RParsec
 
-Associativities = [:prefix, :postfix, :infixn, :infixr, :infixl]
-#
-# This class holds information about operator precedences
-# and associativities.
-# prefix, postfix, infixl, infixr, infixn can be called
-# to register operators.
-#
-class OperatorTable
-  #
-  # operators attribute is used internally. Do not access it.
-  #
-  attr_reader :operators
-
-  #
-  # Re-initialize the operator table. Internal use only.
-  #
-  def reinit
-    @operators = []
-  end
-
-  #
-  # To create an OperatorTable instance.
-  # If a block is given, it is invoked to do post-instantiation.
-  # For example:
-  #
-  # OperatorTable.new do |tbl|
-  #   tbl.infixl(char(?+) >> Plus, 10)
-  #   tbl.infixl(char(?-) >> Minus, 10)
-  #   tbl.infixl(char(?*) >> Mul, 20)
-  #   tbl.infixl(char(?/) >> Div, 20)
-  #   tbl.prefix(char(?-) >> Neg, 50)
-  # end
-  #
-  def self.new
-    this = allocate
-    this.reinit
-    if block_given?
-      yield this
-    end
-    this
-  end
-
-  #
-  # Defines a prefix operator that returns a unary Proc object with a precedence associated.
-  # Returns self.
-  #
-  def prefix(op, precedence)
-    add(:prefix, op, precedence)
-  end
-
-  #
-  # Defines a postfix operator that returns a unary Proc object with a precedence associated.
-  # Returns self.
-  #
-  def postfix(op, precedence)
-    add(:postfix, op, precedence)
-  end
-
-  #
-  # Defines a left associative infix operator that returns a binary Proc object with a precedence
-  # associated. Returns self.
-  #
-  def infixl(op, precedence)
-    add(:infixl, op, precedence)
-  end
-
-  #
-  # Defines a right associative infix operator that returns a binary Proc object with a precedence
-  # associated. Returns self.
+  Associativities = [:prefix, :postfix, :infixn, :infixr, :infixl]
   #
-  def infixr(op, precedence)
-    add(:infixr, op, precedence)
-  end
-
+  # This module helps build an expression parser
+  # using an OperatorTable instance and a parser
+  # that parses the term expression.
   #
-  # Defines a non-associative infix operator that returns a binary Proc object with a precedence
-  # associated. Returns self.
-  #
-  def infixn(op, precedence)
-    add(:infixn, op, precedence)
-  end
-
-  private
+  module Expressions
+    class << self
+      private
 
-  def add(*entry)
-    @operators << entry
-    self
-  end
-end
-
-#
-# This module helps build an expression parser
-# using an OperatorTable instance and a parser
-# that parses the term expression.
-#
-module Expressions
-  class << self
-    private
-
-    def array_to_dict arr
-      result = {}
-      arr.each_with_index do |key, i|
-        result[key] = i unless result.include? key
+      def array_to_dict arr
+        result = {}
+        arr.each_with_index do |key, i|
+          result[key] = i unless result.include? key
+        end
+        result
       end
-      result
     end
-  end
 
-  KindPrecedence = array_to_dict Associativities
+    KindPrecedence = array_to_dict Associativities
 
-  #
-  # build an expression parser using the given term parser
-  # and operator table.
-  # When _delim_ is specified, patterns recognized by _delim_
-  # is automatically ignored.
-  #
-  def self.build(term, table, delim = nil)
-    # sort so that higher precedence first.
-    apply_operators(term, prepare_suites(table).sort, delim)
-  end
-
-  class << self
-    private
+    #
+    # build an expression parser using the given +term+ parser and
+    # operator +table+.  When +delim+ is specified, patterns
+    # recognized by +delim+ is automatically ignored.
+    #
+    def self.build(term, table, delim = nil)
+      # sort so that higher precedence first.
+      apply_operators(term, prepare_suites(table).sort, delim)
+    end
 
-    def apply_operators(term, entries, delim)
-      # apply operators stored in [[precedence,associativity],[op...]] starting from beginning.
-      entries.inject(term) do |result, entry|
-        key, ops = *entry
-        _, kind_index = *key
-        op = ops[0]
-        op = Parsers.sum(*ops) if ops.length > 1
-        apply_operator(result, op, Associativities[kind_index], delim)
+    class << self
+      private
+
+      def apply_operators(term, entries, delim)
+        # apply operators stored in [[precedence,associativity],[op...]] starting from beginning.
+        entries.inject(term) do |result, entry|
+          key, ops = *entry
+          _, kind_index = *key
+          op = ops[0]
+          op = Parsers.sum(*ops) if ops.length > 1
+          apply_operator(result, op, Associativities[kind_index], delim)
+        end
       end
-    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}"
+      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
       end
-    end
 
-    def ignore_rest(parser, delim)
-      return parser if delim.nil?
-      parser << delim
-    end
+      def ignore_rest(parser, delim)
+        return parser if delim.nil?
+        parser << delim
+      end
 
-    def prepare_suites(table)
-      # create a hash with [precedence, associativity] as key, and op as value.
-      suites = {}
-      table.operators.each do |entry|
-        kind, op, precedence = *entry
-        key = [-precedence, KindPrecedence[kind]]
-        suite = suites[key]
-        if suite.nil?
-          suite = [op]
-          suites[key] = suite
-        else
-          suite << op
+      def prepare_suites(table)
+        # create a hash with [precedence, associativity] as key, and op as value.
+        suites = {}
+        table.operators.each do |entry|
+          kind, op, precedence = *entry
+          key = [-precedence, KindPrecedence[kind]]
+          suite = suites[key]
+          if suite.nil?
+            suite = [op]
+            suites[key] = suite
+          else
+            suite << op
+          end
         end
+        suites
       end
-      suites
     end
   end
-end
 
 end # module

data/lib/rparsec/functor_mixin.rb

@@ -0,0 +1,102 @@
+module RParsec
+  #
+  # This module provides instance methods that
+  # manipulate closures in a functional style.
+  # It is typically included in Proc and Method.
+  #
+  module FunctorMixin
+    #
+    # Create a +Proc+, which expects the two parameters in the reverse
+    # order of +self+.
+    #
+    def flip
+      Functors.flip(&self)
+    end
+
+    #
+    # 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
+
+    alias << compose
+
+    #
+    # <tt>a >> b</tt> is equivalent to <tt>b << a</tt>.  See also #<<.
+    #
+    def >>(other)
+      other << self
+    end
+
+    #
+    # Create a Proc that's curriable.
+    # When curried, parameters are passed in from left to right.
+    # i.e. closure.curry.call(a).call(b) is quivalent to closure.call(a,b) .
+    # _self_ is encapsulated under the hood to perform the actual
+    # job when currying is done.
+    # _ary_ explicitly specifies the number of parameters to curry.
+    #
+    # *IMPORTANT*
+    # Proc and Method have built-in curry.
+    # but the arity always return -1.
+    # So, curry.reverse_curry does not work as expected.
+    # You need to use the "using FunctorMixin"
+    # See the "functor_test.rb"
+    [Proc, Method].each do |klass|
+      refine klass do
+        def curry(ary = arity)
+          Functors.curry(ary, &self)
+        end
+      end
+    end
+
+    #
+    # Create a +Proc+ that's curriable.  When curried, parameters are
+    # passed in from right to left.
+    # i.e. <tt>closure.reverse_curry.call(a).call(b)</tt> is quivalent
+    # to <tt>closure.call(b, a)</tt>.  +self+ is encapsulated under
+    # 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
+
+    #
+    # Uncurry a curried closure.
+    #
+    def uncurry
+      Functors.uncurry(&self)
+    end
+
+    #
+    # Uncurry a reverse curried closure.
+    #
+    def reverse_uncurry
+      Functors.reverse_uncurry(&self)
+    end
+
+    #
+    # 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
+    #
+
+    # 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
+
+    alias ** power
+    alias * repeat
+  end
+end