rparsec2 1.1.0 → 1.2.1

data/lib/rparsec/functors.rb

@@ -1,282 +1,178 @@
-module RParsec
-
-#
-# This module provides frequently used functors.
-#
-module Functors
-  Id = proc { |x| x }
-  Idn = proc { |*x| x }
-  Neg = proc { |x| -x }
-  Inc = proc { |x| x + 1 }
-  Succ = proc { |x| x.succ }
-  Dec = proc { |x| x - 1 }
-  Plus = proc { |x, y| x + y }
-  Minus = proc { |x, y| x - y }
-  Mul = proc { |x, y| x * y }
-  Div = proc { |x, y| x / y }
-  Mod = proc { |x, y| x % y }
-  Power = proc { |x, y| x**y }
-  Not = proc { |x, _y| !x }
-  And = proc { |x, y| x && y }
-  Or = proc { |x, y| x || y }
-  Xor = proc { |x, y| x ^ y }
-  BitAnd = proc { |x, y| x & y }
-  Union = proc { |x, y| x | y }
-  Match = proc { |x, y| x =~ y }
-  Eq = proc { |x, y| x == y }
-  Ne = proc { |x, y| x != y }
-  Lt = proc { |x, y| x < y }
-  Gt = proc { |x, y| x > y }
-  Le = proc { |x, y| x <= y }
-  Ge = proc { |x, y| x >= y }
-  Compare = proc { |x, y| x <=> y }
-  Call = proc { |x, y| x.call(y) }
-  Feed = proc { |x, y| y.call(x) }
-  Fst = proc { |x, _| x }
-  Snd = proc { |_, x| x }
-  At = proc { |x, y| x[y] }
-  To_a = proc { |x| x.to_a }
-  To_s = proc { |x| x.to_s }
-  To_i = proc { |x| x.to_i }
-  To_sym = proc { |x| x.to_sym }
-  To_f = proc { |x| x.to_f }
-
-  #
-  # Get a Proc, when called, always return the given value.
-  #
-  def const(v)
-    proc { |_| v }
-  end
+# frozen_string_literal: true
 
-  #
-  # Get a Proc, when called, return the nth parameter.
-  #
-  def nth(n)
-    proc { |*args| args[n] }
-  end
-
-  #
-  # Create a Proc, which expects the two parameters
-  # in the reverse order of _block_.
-  #
-  def flip(&block)
-    proc { |x, y| block.call(y, x) }
-  end
-
-  #
-  # Create a Proc, when called, the parameter is
-  # first passed into _f2_, _f1_ is called in turn
-  # with the return value from _other_.
-  #
-  def compose(f1, f2)
-    proc { |*x| f1.call(f2.call(*x)) }
-  end
-
-  #
-  # Create a Proc that's curriable.
-  # When curried, parameters are passed in from left to right.
-  # i.e. curry(closure).call(a).call(b) is quivalent to closure.call(a,b) .
-  # _block_ is encapsulated under the hood to perform the actual
-  # job when currying is done.
-  # arity explicitly specifies the number of parameters to curry.
-  #
-  def curry(arity, &block)
-    fail "cannot curry for unknown arity" if arity < 0
-    Functors.make_curry(arity, &block)
-  end
+module RParsec
 
   #
-  # Create a Proc that's curriable.
-  # When curried, parameters are passed in from right to left.
-  # i.e. reverse_curry(closure).call(a).call(b) is quivalent to closure.call(b,a) .
-  # _block_ is encapsulated under the hood to perform the actual
-  # job when currying is done.
-  # arity explicitly specifies the number of parameters to curry.
-  #
-  def reverse_curry(arity, &block)
-    fail "cannot curry for unknown arity" if arity < 0
-    Functors.make_reverse_curry(arity, &block)
-  end
+  # This module provides frequently used functors.
+  #
+  module Functors
+    Id = proc { |x| x }
+    Idn = proc { |*x| x }
+    Neg = proc { |x| -x }
+    Inc = proc { |x| x + 1 }
+    Succ = proc { |x| x.succ }
+    Dec = proc { |x| x - 1 }
+    Plus = proc { |x, y| x + y }
+    Minus = proc { |x, y| x - y }
+    Mul = proc { |x, y| x * y }
+    Div = proc { |x, y| x / y }
+    Mod = proc { |x, y| x % y }
+    Power = proc { |x, y| x**y }
+    Not = proc { |x, _y| !x }
+    And = proc { |x, y| x && y }
+    Or = proc { |x, y| x || y }
+    Xor = proc { |x, y| x ^ y }
+    BitAnd = proc { |x, y| x & y }
+    Union = proc { |x, y| x | y }
+    Match = proc { |x, y| x =~ y }
+    Eq = proc { |x, y| x == y }
+    Ne = proc { |x, y| x != y }
+    Lt = proc { |x, y| x < y }
+    Gt = proc { |x, y| x > y }
+    Le = proc { |x, y| x <= y }
+    Ge = proc { |x, y| x >= y }
+    Compare = proc { |x, y| x <=> y }
+    Call = proc { |x, y| x.call(y) }
+    Feed = proc { |x, y| y.call(x) }
+    Fst = proc { |x, _| x }
+    Snd = proc { |_, x| x }
+    At = proc { |x, y| x[y] }
+    To_a = proc { |x| x.to_a }
+    To_s = proc { |x| x.to_s }
+    To_i = proc { |x| x.to_i }
+    To_sym = proc { |x| x.to_sym }
+    To_f = proc { |x| x.to_f }
+
+    #
+    # Get a +Proc+, when called, always return the given value.
+    #
+    def const(v)
+      proc { |_| v }
+    end
 
-  #
-  # Uncurry a curried closure.
-  #
-  def uncurry(&block)
-    return block unless block.arity == 1
-    proc do |*args|
-      result = block
-      args.each do |a|
-        result = result.call(a)
-      end
-      result
+    #
+    # Get a +Proc+, when called, return the <tt>n</tt>th parameter.
+    #
+    def nth(n)
+      proc { |*args| args[n] }
     end
-  end
 
-  #
-  # Uncurry a reverse curried closure.
-  #
-  def reverse_uncurry(&block)
-    return block unless block.arity == 1
-    proc do |*args|
-      result = block
-      args.reverse_each do |a|
-        result = result.call(a)
-      end
-      result
+    #
+    # Create a +Proc+, which expects the two parameters in the reverse
+    # order of +block+.
+    #
+    def flip(&block)
+      proc { |x, y| block.call(y, x) }
     end
-  end
 
-  #
-  # Create a Proc, when called,
-  # repeatedly call _block_ for _n_ times.
-  # The same arguments are passed to each invocation.
-  #
-  def repeat(n, &block)
-    proc do |*args|
-      result = nil
-      n.times { result = block.call(*args) }
-      result
+    #
+    # Create a +Proc+, when called, the parameter is first passed into
+    # +f2+, +f1+ is called in turn with the return value from +f2+.
+    #
+    def compose(f1, f2)
+      proc { |*x| f1.call(f2.call(*x)) }
     end
-  end
 
-  #
-  # Create a Proc, when called,
-  # repeatedly call _block_ for _n_ times.
-  # At each iteration, return value from the previous iteration
-  # is used as parameter.
-  #
-  def power(n, &block)
-    return const(nil) if n <= 0
-    return block if n == 1
-    proc do |*args|
-      result = block.call(*args)
-      (n - 1).times { result = block.call(result) }
-      result
+    #
+    # Create a +Proc+ that's curriable.  When curried, parameters are
+    # passed in from left to right.
+    # i.e. <tt>curry(closure).call(a).call(b)</tt> is quivalent to
+    # <tt>closure.call(a,b)</tt>.  +block+ is encapsulated under the
+    # hood to perform the actual job when currying is done.  +arity+
+    # explicitly specifies the number of parameters to curry.
+    #
+    def curry(arity, &block)
+      fail "cannot curry for unknown arity" if arity < 0
+      Functors.make_curry(arity, &block)
     end
-  end
 
-  extend self
+    #
+    # Create a +Proc+ that's curriable.  When curried, parameters are
+    # passed in from right to left.
+    # i.e. <tt>reverse_curry(closure).call(a).call(b)</tt> is
+    # quivalent to <tt>closure.call(b, a)</tt>.  +block+ is
+    # encapsulated under the hood to perform the actual job when
+    # currying is done.  +arity+ explicitly specifies the number of
+    # parameters to curry.
+    #
+    def reverse_curry(arity, &block)
+      fail "cannot curry for unknown arity" if arity < 0
+      Functors.make_reverse_curry(arity, &block)
+    end
 
-  def self.make_curry(arity, &block)
-    return block if arity <= 1
-    proc do |x|
-      make_curry(arity - 1) do |*rest|
-        block.call(*rest.insert(0, x))
+    #
+    # Uncurry a curried closure.
+    #
+    def uncurry(&block)
+      return block unless block.arity == 1
+      proc do |*args|
+        result = block
+        args.each do |a|
+          result = result.call(a)
+        end
+        result
       end
     end
-  end
 
-  def self.make_reverse_curry(arity, &block)
-    return block if arity <= 1
-    proc do |x|
-      make_reverse_curry(arity - 1) do |*rest|
-        block.call(*rest << x)
+    #
+    # Uncurry a reverse curried closure.
+    #
+    def reverse_uncurry(&block)
+      return block unless block.arity == 1
+      proc do |*args|
+        result = block
+        args.reverse_each do |a|
+          result = result.call(a)
+        end
+        result
       end
     end
-  end
-end
-
-#
-# 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
 
-  #
-  # a >> b is equivalent to b << a
-  #
-  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)
+    #
+    # Create a +Proc+, when called, repeatedly call +block+ for +n+
+    # times.  The same arguments are passed to each invocation.
+    #
+    def repeat(n, &block)
+      proc do |*args|
+        result = nil
+        n.times { result = block.call(*args) }
+        result
       end
     end
-  end
-
-  #
-  # Create a Proc that's curriable.
-  # When curried, parameters are passed in from right to left.
-  # i.e. closure.reverse_curry.call(a).call(b) is quivalent to closure.call(b,a) .
-  # _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
+    #
+    # Create a +Proc+, when called, repeatedly call +block+ for +n+
+    # times.  \At each iteration, return value from the previous
+    # iteration is used as parameter.
+    #
+    def power(n, &block)
+      return const(nil) if n <= 0
+      return block if n == 1
+      proc do |*args|
+        result = block.call(*args)
+        (n - 1).times { result = block.call(result) }
+        result
+      end
+    end
 
-  #
-  # Uncurry a reverse curried closure.
-  #
-  def reverse_uncurry
-    Functors.reverse_uncurry(&self)
-  end
+    extend 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 self.make_curry(arity, &block)
+      return block if arity <= 1
+      proc do |x|
+        make_curry(arity - 1) do |*rest|
+          block.call(*rest.insert(0, x))
+        end
+      end
+    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)
+    def self.make_reverse_curry(arity, &block)
+      return block if arity <= 1
+      proc do |x|
+        make_reverse_curry(arity - 1) do |*rest|
+          block.call(*rest << x)
+        end
+      end
+    end
   end
-
-  alias ** power
-  alias * repeat
-end
-
 end # module

data/lib/rparsec/id_monad.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 module RParsec
 
-class IdMonad
-  def value v
-    v
-  end
+  class IdMonad # :nodoc:
+    def value v
+      v
+    end
 
-  def bind prev
-    yield prev
-  end
+    def bind prev
+      yield prev
+    end
 
-  def mplus a, _b
-    a
+    def mplus a, _b
+      a
+    end
   end
-end
 
-end # module
+end # module

data/lib/rparsec/keywords.rb

@@ -1,114 +1,116 @@
+# frozen_string_literal: true
+
 require 'rparsec/parser'
 
 module RParsec
 
-#
-# This class helps building lexers and parsers for keywords.
-#
-class Keywords
-  extend Parsers
-
-  private_class_method :new
-
   #
-  # The symbol used to identify a keyword token
+  # This class helps building lexers and parsers for keywords.
   #
-  attr_reader :keyword_symbol
-
-  #
-  # The lexer that parses all the keywords represented
-  #
-  attr_reader :lexer
-
-  #
-  # Do we lex case sensitively?
-  #
-  def case_sensitive?
-    @case_sensitive
-  end
+  class Keywords
+    extend Parsers
+
+    private_class_method :new
+
+    #
+    # The symbol used to identify a keyword token
+    #
+    attr_reader :keyword_symbol
+
+    #
+    # The lexer that parses all the keywords represented
+    #
+    attr_reader :lexer
+
+    #
+    # Do we lex case sensitively?
+    #
+    def case_sensitive?
+      @case_sensitive
+    end
 
-  #
-  # To create an instance that lexes the given keywords
-  # case sensitively.
-  # _default_lexer_ is used to lex a token first, the token text is then compared with
-  # the given keywords. If it matches any of the keyword, a keyword token is generated instead
-  # using _keyword_symbol_.
-  # The _block_ parameter, if present, is used to convert the token text to another object
-  # when the token is recognized during grammar parsing phase.
-  #
-  def self.case_sensitive(words, default_lexer = word.token(:word), keyword_symbol = :keyword, &block)
-    new(words, true, default_lexer, keyword_symbol, &block)
-  end
+    #
+    # To create an instance that lexes the given keywords case
+    # sensitively.  +default_lexer+ is used to lex a token first, the
+    # token text is then compared with the given keywords. If it
+    # matches any of the keyword, a keyword token is generated instead
+    # using +keyword_symbol+.  The +block+ parameter, if present, is
+    # used to convert the token text to another object when the token
+    # is recognized during grammar parsing phase.
+    #
+    def self.case_sensitive(words, default_lexer = word.token(:word), keyword_symbol = :keyword, &block)
+      new(words, true, default_lexer, keyword_symbol, &block)
+    end
 
-  #
-  # To create an instance that lexes the given keywords
-  # case insensitively.
-  # _default_lexer_ is used to lex a token first, the token text is then compared with
-  # the given keywords. If it matches any of the keyword, a keyword token is generated instead
-  # using _keyword_symbol_.
-  # The _block_ parameter, if present, is used to convert the token text to another object
-  # when the token is recognized during parsing phase.
-  #
-  def self.case_insensitive(words, default_lexer = word.token(:word), keyword_symbol = :keyword, &block)
-    new(words, false, default_lexer, keyword_symbol, &block)
-  end
+    #
+    # To create an instance that lexes the given keywords case
+    # insensitively.  +default_lexer+ is used to lex a token first,
+    # the token text is then compared with the given keywords. If it
+    # matches any of the keyword, a keyword token is generated instead
+    # using +keyword_symbol+.  The +block+ parameter, if present, is
+    # used to convert the token text to another object when the token
+    # is recognized during parsing phase.
+    #
+    def self.case_insensitive(words, default_lexer = word.token(:word), keyword_symbol = :keyword, &block)
+      new(words, false, default_lexer, keyword_symbol, &block)
+    end
 
-  # 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
-    # this guarantees that we have copy of the words array and all the word strings.
-    words = copy_words(words, case_sensitive)
-    @name_map = {}
-    @symbol_map = {}
-    word_map = {}
-    words.each do |w|
-      symbol = "#{keyword_symbol}:#{w}".to_sym
-      word_map[w] = symbol
-      parser = Parsers.token(symbol, &block)
-      @symbol_map["#{w}".to_sym] = parser
-      @name_map[w] = parser
+    # 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
+      # this guarantees that we have copy of the words array and all the word strings.
+      words = copy_words(words, case_sensitive)
+      @name_map = {}
+      @symbol_map = {}
+      word_map = {}
+      words.each do |w|
+        symbol = "#{keyword_symbol}:#{w}".to_sym
+        word_map[w] = symbol
+        parser = Parsers.token(symbol, &block)
+        @symbol_map["#{w}".to_sym] = parser
+        @name_map[w] = parser
+      end
+      @lexer = make_lexer(default_lexer, word_map)
     end
-    @lexer = make_lexer(default_lexer, word_map)
-  end
 
-  #
-  # Get the parser that recognizes the token of the given keyword during the parsing phase.
-  #
-  def parser(key)
-    result = nil
-    if key.kind_of? String
-      name = canonical_name(key)
-      result = @name_map[name]
-    else
-      result = @symbol_map[key]
+    #
+    # Get the parser that recognizes the token of the given keyword during the parsing phase.
+    #
+    def parser(key)
+      result = nil
+      if key.kind_of? String
+        name = canonical_name(key)
+        result = @name_map[name]
+      else
+        result = @symbol_map[key]
+      end
+      raise ArgumentError, "parser not found for #{key}" if result.nil?
+      result
     end
-    raise ArgumentError, "parser not found for #{key}" if result.nil?
-    result
-  end
 
-  alias [] parser
+    alias [] parser
 
-  private
+    private
 
-  def make_lexer(default_lexer, word_map)
-    default_lexer.map do |tok|
-      text, ind = tok.text, 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
+    def make_lexer(default_lexer, word_map)
+      default_lexer.map do |tok|
+        text, ind = tok.text, 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
+      end
     end
-  end
 
-  def canonical_name(name)
-    case when @case_sensitive then name else name.downcase end
-  end
+    def canonical_name(name)
+      case when @case_sensitive then name else name.downcase end
+    end
 
-  def copy_words(words, case_sensitive)
-    words.map do |w|
-      case when case_sensitive then w.dup else w.downcase end
+    def copy_words(words, case_sensitive)
+      words.map do |w|
+        case when case_sensitive then w.dup else w.downcase end
+      end
     end
   end
-end
 
-end # module
+end # module