yaparc 0.2.3 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: db3016ed938d0853130447ce2155b9e9978faf79798f137c99624d1539a9fc2b
+  data.tar.gz: 505b913fc07f99bf8cc7fb1be125aefedb767bb589d92f40c3bdc35ff6cccfb1
+SHA512:
+  metadata.gz: d53c0470dac4fa661db80607a2e752ab830a751fdd14f3453f838a80ffcd13993b013d32a2aa4c171dc3e8d4cf85154651ed656179669796c8cdac5120503c66
+  data.tar.gz: 75a76818b13a77821106dd09c65c5ae2c3a005ca8361797b75167b708f57846c4664a267f1eb40bba2d7ec9e75ec995291a77e51353423bd232f921475374d59

data/.document

@@ -0,0 +1,3 @@
+README
+LICENSE
+lib

data/.envrc

@@ -0,0 +1 @@
+use guix ruby ruby-rubocop

data/.rdoc_options

@@ -0,0 +1 @@
+main_page: README

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# yaparc change log
+
+## Unreleased
+
+## 0.4.0 - 2026-06-23
+
+* Remove `message` attribute from `Yaparc::Base`.
+* Rename `Yaparc::Fail` to `Yaparc::FailParser`.
+* Move `OK`, `Fail`, `Error` outside of `Result` and removed `Result` module.
+* Remove `tree` attribute of `Parsable` module.
+* Use newer keyword arguments.  This might cause troubles with Ruby version 2
+  or lower.
+* Limit `Tokenize`'s `prefix` and `postfix` write only.
+
+## 0.3.0 - 2024-12-31
+
+* Added `Yaparc::VERSION` constant.
+* Removed `Yaparc` module's `@@identifier_regex` class variable.
+* Added `Yaparc::IDENTIFIER_REGEX` constant.

data/Gemfile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2007-2009 Akimichi Tatsukawa <akimichi.tatsukawa@gmail.com>
+Copyright 2024      gemmaro            <gemmaro.dev@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README

@@ -1,57 +1,68 @@
-= Synopsis
+= yaparc
 
-There are several implementations of parser combinator in ruby. This is a yet another simple combinator parser libraryin ruby.
+== Synopsis
 
-= Requirements
+There are several implementations of parser combinator in Ruby.  This is an
+yet another simple combinator parser library in Ruby.
 
-* Ruby (http://www.ruby-lang.org/)
-* RubyGem (http://rubyforge.org/projects/rubygems/)
+== Install
 
-= Install
+  gem install yaparc
 
- $ gem install yaparc
+== Usage
 
-= Usage
+In combinator parser, each parser is construct as a function taking input
+string as arguments.  Larger parsers are built from smaller parsers.  Although
+combinators are higher-order functions in ordinary functional languages, they
+are constructed as classes in yaparc, because Ruby has more object-oriented
+than functional property.
 
-In combinator parser, each parser is construct as a function taking input string as arguments. Larger parsers are built from smaller parsers. Although combinators are higher-order functions in ordinary functional languages, they are constructed as classes in yaparc, because Ruby has more object-oriented than functional property.
+All parsers has +parse+ method, each of which takes input string as its
+arguments except Yaparc::Satisfy parser.  Every parser returns either
+Yaparc::Result::OK or Yaparc::Result::Fail as their result of parsing.  An
+instance of Yaparc::Result::Fail denotes faiilure, and instance of
+Yaparc::Result::OK indicates success.
 
-All parsers has 'parse' method, each of which takes input string as its arguments except SatisfyParser. Every parser returns either Result::OK or Result::Fail as their result of parsing. An instance of Result::Fail denotes faiilure, and instance of Result::OK indicates success.
+=== Primitive Parsers
 
-== Primitive Parsers
+* Yaparc::Succeed
+* Yaparc::FailParser
+* Yaparc::Item
+* Yaparc::Satisfy
 
-* Succeed
-* Fail
-* Item
-* Satisfy
+==== Succeed class
 
-=== Succeed class
-
-The parser Succeed always succeeds with the result value, without consuming any of the input string.
-In the following example, Succeed#parse takes an input string "blah, blah, blah" and returns the singleton array [[1, "blah, blah, blah"]].
+The parser Yaparc::Succeed always succeeds with the result value, without
+consuming any of the input string.  In the following example,
+Yaparc::Succeed#parse takes an input string <tt>blah, blah, blah</tt> and
+returns the singleton array <tt>[[1, "blah, blah, blah"]]</tt>.
 
     parser = Yaparc::Succeed.new(1)
     parser.parse("blah, blah, blah")
-    => #<Yaparc::Result::OK:0xb7aaaf5c @input="blah, blah, blah", @value=1>
+    #=> #<Yaparc::Result::OK:0xb7aaaf5c @input="blah, blah, blah", @value=1>
 
-=== Fail class
+==== FailParser class
 
-The parser Fail always fails, regardless of the contents of the input string.
+The parser Yaparc::FailParser always fails, regardless of the contents of the
+input string.
 
-    parser = Yaparc::Fail.new
+    parser = Yaparc::FailParser.new
     parser.parse("abc")
-    => #<Yaparc::Result::Fail:0xb7aa56b0 @value=nil>
+    #=> #<Yaparc::Result::FailParser:0xb7aa56b0 @value=nil>
 
-=== Item class
+==== Item class
 
-The parser Item fails if the input string is empty, and succeeds with the first character as the result value otherwise.
+The parser Yaparc::Item fails if the input string is empty, and succeeds with
+the first character as the result value otherwise.
 
     parser = Yaparc::Item.new
     parser.parse("abc")
-    => #<Yaparc::Result::OK:0xb7a9fdb4 @input="bc", @value="a">
+    #=> #<Yaparc::Result::OK:0xb7a9fdb4 @input="bc", @value="a">
 
-=== Satisfy class
+==== Satisfy class
 
-The parser Satisfy recognizes a single input via predicate which determines if an arbitrary input is suitable for the predicate.
+The parser Yaparc::Satisfy recognizes a single input via predicate which
+determines if an arbitrary input is suitable for the predicate.
 
     is_integer = lambda do |i|
       begin
@@ -63,80 +74,71 @@ The parser Satisfy recognizes a single input via predicate which determines if a
     end
     parser = Yaparc::Satisfy.new(is_integer)
     parser.parse("123")
-    => #<Yaparc::Result::OK:0xb7a8f284 @input="23", @value="1">
-
-
-== Combining Parsers
-
-* Alt
-* Seq
-* Many
-* ManyOne
+    #=> #<Yaparc::Result::OK:0xb7a8f284 @input="23", @value="1">
 
+=== Combining Parsers
 
+* Yaparc::Alt
+* Yaparc::Seq
+* Yaparc::Many
+* Yaparc::ManyOne
   
-=== Sequencing parser
+==== Sequencing parser
 
-The Seq corresponds to sequencing in BNF. The following parser recognizes anything that Symbol.new('+') or Natural.new would if placed in succession.
+The Yaparc::Seq corresponds to sequencing in BNF.  The following parser
+recognizes anything that <tt>Symbol.new('+')</tt> or <tt>Natural.new</tt>
+would if placed in succession.
 
   parser = Seq.new(Symbol.new('+'), Natural.new)
   parser.parse("+321")
-  => #<Yaparc::Result::OK:0xb7a81ae4 @input="", @value=321>
+  #=> #<Yaparc::Result::OK:0xb7a81ae4 @input="", @value=321>
 
-if a block given to Seq, it analyses input string to construct its logical structure.
+If a block given to Yaparc::Seq, it analyses input string to construct its
+logical structure.
 
-  parser = Yaparc::Seq.new(Yaparc::Symbol.new('+'), Yaparc::Natural.new) do | plus, nat|
+  parser = Yaparc::Seq.new(Yaparc::Symbol.new('+'), Yaparc::Natural.new) do |plus, nat|
     nat
   end
   parser.parse("+1234")
-  => #<Yaparc::Result::OK:0xb7a70a00 @input="", @value=1234>
+  #=> #<Yaparc::Result::OK:0xb7a70a00 @input="", @value=1234>
 
 It produces a parse tree which expounds the semantic structure of the program.
 
-=== Alternation parser
-
-The parser Alt class is an alternation parser, which returns the result of the first parser to succeed, and failure if neither does.
+==== Alternation parser
 
+The parser Yaparc::Alt class is an alternation parser, which returns the
+result of the first parser to succeed, and failure if neither does.
 
   parser = Yaparc::Alt.new(
-                          Yaparc::Seq.new(Yaparc::Symbol.new('+'), Yaparc::Natural.new) do | _, nat|
+                          Yaparc::Seq.new(Yaparc::Symbol.new('+'), Yaparc::Natural.new) do |_, nat|
                             nat
                           end,
                           Yaparc::Natural.new
                          )
   parser.parse("1234")
-  => #<Yaparc::Result::OK:0xb7a5a610 @input="", @value=1234>
+  #=> #<Yaparc::Result::OK:0xb7a5a610 @input="", @value=1234>
   parser.parse("-1234")
-  => #<Yaparc::Result::Fail:0xb7a57ba4 @value=nil>
+  #=> #<Yaparc::Result::Fail:0xb7a57ba4 @value=nil>
 
+==== Many
 
-=== Many
-
-In Many, zero or more applications of parser are admissible.
+In Yaparc::Many, zero or more applications of parser are admissible.
 
     parser = Yaparc::Many.new(Yaparc::Satisfy.new(lambda {|i| i > '0' and i < '9'}))
     parser.parse("123abc")
-    => #<Yaparc::Result::OK:0xb7a49dc4 @input="abc", @value="123">
-
-=== ManyOne
-
-The ManyOne requires at least one successfull application of parser.
-
+    #=> #<Yaparc::Result::OK:0xb7a49dc4 @input="abc", @value="123">
 
-== Tokenized parser
+==== ManyOne
 
-* Identifier
+The Yaparc::ManyOne requires at least one successfull application of parser.
 
-  Parser for identifier
+=== Tokenized parser
 
-* Natural
+Yaparc::Identifier :: Parser for identifier
+Yaparc::Natural    :: Parser for natural number
+Yaparc::Symbol     :: Parser for symbol
 
-  Parser for natural number
-
-* Symbol
-
-
-== Regex parser
+=== Regex parser
 
     parser = Regex.new(/\A[0-9]+/)
     result = parser.parse("1234ab")
@@ -148,10 +150,10 @@ The ManyOne requires at least one successfull application of parser.
     result = parser.parse("1234:ab")
     assert_equal ["ab", "1234"],  result.value
 
+=== Define your own parser
 
-== Define your own parser
-
-In order to construct parsers, you make parser class to be inherited from Yaparc::AbstractParser class.
+In order to construct parsers, you make parser class to be inherited from
+Yaparc::AbstractParser class.
 
   class Identifier < Yaparc::AbstractParser
     def initialize
@@ -161,36 +163,54 @@ In order to construct parsers, you make parser class to be inherited from Yaparc
     end
   end
 
-If you want to nest the same parser class in the parser definition, you have to choose this way.
-In the following example, note that Expr class is instantiated inside Expr#initialize method.
+If you want to nest the same parser class in the parser definition, you have
+to choose this way.  In the following example, note that +Expr+ class is
+instantiated inside <tt>Expr#initialize</tt> method.
 
   class Expr < Yaparc::AbstractParser
     def initialize
       @parser = lambda do
         Yaparc::Alt.new(
-                              Yaparc::Seq.new(Term.new,
-                                                    Yaparc::Symbol.new('+'),
-                                                    Expr.new) do |term, _, expr|
-                                ['+', term,expr]
-                              end,
-                              Term.new
-                              )
+                         Yaparc::Seq.new(Term.new,
+                                         Yaparc::Symbol.new('+'),
+                                         Expr.new) do |term, _, expr|
+                           ['+', term, expr]
+                         end,
+                         Term.new
+                       )
       end
     end
+  end
 
-Constructing your parsers, it should be noted that left-recursion leads to non-termination of the parser.
+Constructing your parsers, it should be noted that left-recursion leads to
+non-termination of the parser.
 
-== Avoiding left-recursion
+=== Avoiding left-recursion
 
  A ::= A B | C
 
-  is equivalent to
+is equivalent to
 
  A ::= C B*
 
+=== Tokenization
+
+When you want to tokenize input stream, use Yaparc::Tokenize class.
+
+== About this project
+
+RubyGems.org         :: https://rubygems.org/gems/yaparc
+RubyForge (archived) :: https://web.archive.org/web/20140515235842/http://rubyforge.org/projects/yaparc/
+
+== Development
 
-== Tokenization
+After checking out the repo, run <tt>bin/setup</tt> to install dependencies.
+Then, run <tt>rake test</tt> to run the tests.
+You can also run <tt>bin/console</tt> for an interactive prompt that will allow you to experiment.
 
-When you want to tokenize input stream, use Token class.
+To install this gem onto your local machine, run <tt>bundle exec rake install</tt>.
+To release a new version, update the version number in the library file, and then run <tt>bundle exec rake release</tt>, which will create a git tag for the version, push git commits and the created tag, and push the <tt>.gem</tt> file to [rubygems.org](https://rubygems.org).
 
+== Contributing
 
+Bug reports and pull requests are welcome.

data/Rakefile

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require "net/http"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]
+
+desc 'Generate signatures'
+task :gensig do
+  sh 'typeprof', '-o', 'sig/yaparc.gen.rbs', 'sig/yaparc.rbs', *Dir['lib/**/*.rb']
+end
+
+file "test/abc.html" do |t|
+  doc = Net::HTTP.get("web.archive.org", "/web/20120814155205/http://www.norbeck.nu:80/abc/bnf/abc20bnf.htm")
+  File.write(t.name, doc)
+end

data/TODO

@@ -0,0 +1,11 @@
+- [X] Result::Fail to Fail
+- [X] Fail to FailParser
+- [X] Remove raise
+- [X] Use newer keyword arguments
+- [X] Avoid accessors
+- [X] Split modules into files
+- [X] Split BNF files
+
+# Local Variables:
+# mode: org
+# End:

data/lib/yaparc/abstract_parser.rb

@@ -0,0 +1,16 @@
+require_relative 'parsable'
+
+module Yaparc
+  class AbstractParser
+    include Parsable
+
+    def parse(input)
+      tree = @parser.call.parse(input)
+      @tree = if block_given?
+                yield tree
+              else
+                tree
+              end
+    end
+  end
+end

data/lib/yaparc/alt.rb

@@ -0,0 +1,22 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Alt
+    include Parsable
+
+    def initialize(*parsers)
+      @parser = lambda do |input|
+        final_result = Fail.new(input:)
+        parsers.each do |parser|
+          case result = parser.parse(input)
+          in Fail
+            next
+          in OK
+            break final_result = result
+          end
+        end
+        final_result
+      end
+    end
+  end
+end

data/lib/yaparc/apply.rb

@@ -0,0 +1,18 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Apply
+    include Parsable
+
+    def initialize(parser)
+      @parser = lambda do |input|
+        result = parser.parse(input)
+        if result.instance_of?(OK)
+          Succeed.new(yield(result.value)).parse(result.input)
+        else
+          FailParser.new.parse(input)
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/char.rb

@@ -0,0 +1,16 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Char
+    include Parsable
+
+    def initialize(char, case_sensitive = true)
+      equal_char = if case_sensitive
+                     ->(i) { i == char }
+                   else # in case of case-insentive
+                     ->(i) { i.casecmp(char) == 0 }
+                   end
+      @parser = proc { Satisfy.new(equal_char) }
+    end
+  end
+end

data/lib/yaparc/cr.rb

@@ -0,0 +1,11 @@
+require_relative 'parsable'
+
+module Yaparc
+  class CR
+    include Parsable
+
+    def initialize
+      @parser = proc { Regex.new(/\A[ \t]+\n[ \t\n]+/) }
+    end
+  end
+end

data/lib/yaparc/digit.rb

@@ -0,0 +1,11 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Digit
+    include Parsable
+
+    def initialize
+      @parser = proc { Satisfy.new(IS_DIGIT) }
+    end
+  end
+end

data/lib/yaparc/fail_parser.rb

@@ -0,0 +1,11 @@
+require_relative 'parsable'
+
+module Yaparc
+  class FailParser
+    include Parsable
+
+    def initialize
+      @parser = ->(input) { Fail.new(input:) }
+    end
+  end
+end

data/lib/yaparc/ident.rb

@@ -0,0 +1,18 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Ident
+    include Parsable
+
+    def initialize
+      @parser = proc do
+        Seq.new(
+          Satisfy.new(IS_LOWER),
+          Many.new(Satisfy.new(IS_ALPHANUM), '')
+        ) do |head, tail|
+          head + tail
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/identifier.rb

@@ -0,0 +1,32 @@
+require_relative 'parsable'
+
+module Yaparc
+  # Refer to http://www.cs.nott.ac.uk/~gmh/monparsing.pdf, p.23
+  class Identifier
+    include Yaparc::Parsable
+
+    IDENTIFIER_REGEX = /\A[a-zA-Z_]+[a-zA-Z0-9_]*/
+
+    def initialize(regex: nil, exclude: nil)
+      identifier_regex = ::Yaparc::Regex.new(regex || IDENTIFIER_REGEX)
+
+      tokenizer = Tokenize.new(identifier_regex)
+
+      unless exclude
+        @parser = proc { tokenizer }
+        return
+      end
+
+      @parser = lambda do |input|
+        keyword_parsers = exclude.map { |keyword| Yaparc::String.new(keyword) }
+
+        case result = Yaparc::Alt.new(*keyword_parsers).parse(input)
+        when Yaparc::OK
+          Yaparc::FailParser.new
+        else # Fail or Error
+          tokenizer
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/item.rb

@@ -0,0 +1,17 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Item
+    include Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        if input.nil? || input.empty?
+          Fail.new(input:)
+        else
+          OK.new(value: input[0], input: input[1..])
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/literal.rb

@@ -0,0 +1,13 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Literal
+    include Parsable
+
+    def initialize(literal, case_sensitive = true)
+      @parser = proc {
+        Tokenize.new(Yaparc::String.new(literal, case_sensitive))
+      }
+    end
+  end
+end

data/lib/yaparc/many.rb

@@ -0,0 +1,14 @@
+require_relative 'parsable'
+
+module Yaparc
+  # permits zero or more applications of parser.
+  class Many
+    include Parsable
+
+    def initialize(parser, identity = [])
+      @parser = proc {
+        Alt.new(ManyOne.new(parser, identity), Succeed.new(identity))
+      }
+    end
+  end
+end

data/lib/yaparc/many_one.rb

@@ -0,0 +1,27 @@
+require_relative 'parsable'
+
+module Yaparc
+  # requires at least one successfull application of parser.
+  class ManyOne
+    include Parsable
+
+    def initialize(parser, identity = [])
+      @parser = lambda do |_input|
+        Seq.new(parser, Many.new(parser, identity)) do |head, tail|
+          case head
+          when ::String, ::Array, ::Integer
+            head + tail
+          when ::Hash
+            head.merge(tail)
+          else
+            if tail.nil?
+              head
+            else
+              [head] + tail
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/nat.rb

@@ -0,0 +1,11 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Nat
+    include Parsable
+
+    def initialize
+      @parser = proc { Seq.new(ManyOne.new(Digit.new, '')) { |vs| vs.to_i } }
+    end
+  end
+end

data/lib/yaparc/natural.rb

@@ -0,0 +1,12 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Natural
+    include Parsable
+
+    # Accepts Yaparc::Tokenize::new's keyword arguments.
+    def initialize(**args)
+      @parser = proc { Tokenize.new(Nat.new, **args) }
+    end
+  end
+end