yaparc 0.2.3 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0166a0d68a1864c4c92132c88f6b74809e317d5c031c5e57bf9951b6aaedc7b8
+  data.tar.gz: 86ae7441a45dbf7c8f168abf2bc4633dc317e8dc11ac29e9e572df3d3f91206b
+SHA512:
+  metadata.gz: cb4bc055e722070a425921ee0b23e05ae51764d6d76c6f3a955d2c96c3e32eb3eaff0c159710e7b7d067c360efa3308fc55b7868bbc5af94a8df9db1a8903c9b
+  data.tar.gz: a8583f87131780d75a5ed7c46bb49265411fca899921486cf6f854d77c96c98ee41813015b6e5435a0d531bb06e3cf3c12cb2d08bd0effff553ae1e75b839f89

data/.document

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

data/.rdoc_options

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

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# yaparc change log
+
+## Unreleased
+
+## 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::Fail
+* 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
+==== Fail class
 
-The parser Fail always fails, regardless of the contents of the input string.
+The parser Yaparc::Fail always fails, regardless of the contents of the input
+string.
 
     parser = Yaparc::Fail.new
     parser.parse("abc")
-    => #<Yaparc::Result::Fail:0xb7aa56b0 @value=nil>
+    #=> #<Yaparc::Result::Fail: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,21 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+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

data/lib/yaparc.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module Yaparc
+  VERSION = "0.3.0"
+
   module Result
     class Base
       attr_accessor :message, :input, :value
@@ -454,13 +458,14 @@ 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_]*/
+
+    IDENTIFIER_REGEX = /\A[a-zA-Z_]+[a-zA-Z0-9_]*/
 
     def initialize(options = {})
       identifier_regex = if regex = options[:regex]
                            ::Yaparc::Regex.new(regex)
                          else
-                           ::Yaparc::Regex.new(@@identifier_regex)
+                           ::Yaparc::Regex.new(IDENTIFIER_REGEX)
                          end
 
       tokenizer = Tokenize.new(identifier_regex)

data/manifest.scm

@@ -0,0 +1 @@
+(specifications->manifest (list "ruby@3.1" "ruby-rubocop"))

data/sig/yaparc.gen.rbs

@@ -0,0 +1,220 @@
+# TypeProf 0.21.3
+
+# Classes
+module Yaparc
+  VERSION: String
+
+  module Result
+    class Base
+      attr_accessor message: nil
+      attr_accessor input: nil
+      attr_accessor value: nil
+      def initialize: (?Hash[untyped, untyped] options) -> void
+    end
+
+    class OK < Base
+    end
+
+    class Fail < Base
+    end
+
+    class Error < Base
+    end
+  end
+
+  module Parsable
+    IS_LOWER: Proc
+    IS_ALPHANUM: Proc
+    IS_DIGIT: Proc
+    IS_SPACE: Proc
+    IS_WHITESPACE: Proc
+    IS_CR: Proc
+    @parser: bot
+
+    attr_accessor tree: untyped
+    def parse: (nil input) -> untyped
+  end
+
+  class Succeed
+    include Parsable
+    @parser: Proc
+
+    attr_reader remaining: nil
+    def initialize: (untyped value, ?nil remaining) -> void
+  end
+
+  class Fail
+    include Parsable
+    @parser: Proc
+
+    def initialize: -> void
+  end
+
+  class Item
+    include Parsable
+    @parser: Proc
+
+    def initialize: -> void
+  end
+
+  class ZeroOne
+    include Parsable
+    @parser: Proc
+
+    def initialize: (untyped parser, ?Array[untyped] identity) -> void
+  end
+
+  class Satisfy
+    include Parsable
+    @parser: Proc
+
+    def initialize: (Proc predicate) -> void
+    def parse: (untyped input) -> untyped
+  end
+
+  class NoFail
+    include Parsable
+    @parser: Proc
+
+    def initialize: (untyped parser) -> void
+  end
+
+  class Seq
+    include Parsable
+    @parser: Proc
+
+    def initialize: (*Char | String | Succeed | WhiteSpace parsers) ?{ (*untyped) -> untyped } -> void
+  end
+
+  class Alt
+    include Parsable
+    @parser: Proc
+
+    def initialize: (*untyped parsers) -> void
+  end
+
+  class Apply
+    include Parsable
+    @parser: Proc
+
+    def initialize: (untyped parser) -> void
+  end
+
+  class String
+    include Parsable
+    @parser: Proc
+
+    def initialize: (untyped string, ?true case_sensitive) -> void
+  end
+
+  class Regex
+    include Parsable
+    @regex: Regexp
+    @parser: Proc
+
+    def initialize: (Regexp regex) -> void
+  end
+
+  class Many
+    include Parsable
+
+    def initialize: (Satisfy parser, ?Array[untyped] | String identity) -> void
+  end
+
+  class ManyOne
+    include Parsable
+
+    def initialize: (Digit parser, ?Array[untyped] | String identity) -> void
+  end
+
+  class Space
+    include Parsable
+    @parser: Proc
+
+    def initialize: -> void
+  end
+
+  class CR
+    include Parsable
+    @parser: Proc
+
+    def initialize: -> void
+  end
+
+  class WhiteSpace
+    include Parsable
+    @parser: Proc
+
+    def initialize: -> void
+  end
+
+  class Tokenize
+    include Parsable
+    @parser: Proc
+
+    attr_accessor prefix: WhiteSpace
+    attr_accessor postfix: WhiteSpace
+    def initialize: (Regex | String parser, ?Hash[untyped, untyped] args) -> void
+  end
+
+  class Literal
+    include Parsable
+    @parser: Proc
+
+    def initialize: (untyped literal, ?true case_sensitive) -> void
+  end
+
+  class Identifier
+    IDENTIFIER_REGEX: Regexp
+    include Parsable
+    @parser: Proc
+
+    def initialize: (?Hash[untyped, untyped] options) -> void
+  end
+
+  class Char
+    include Parsable
+    @parser: Proc
+
+    def initialize: (untyped char, ?true case_sensitive) -> void
+  end
+
+  class Ident
+    include Parsable
+
+    def initialize: -> void
+  end
+
+  class Digit
+    include Parsable
+    @parser: Proc
+
+    def initialize: -> void
+  end
+
+  class Nat
+    include Parsable
+
+    def initialize: -> void
+  end
+
+  class Natural
+    include Parsable
+
+    def initialize: (?Hash[untyped, untyped] args) -> void
+  end
+
+  class Symbol
+    include Parsable
+    @parser: Proc
+
+    def initialize: (untyped literal, ?Hash[untyped, untyped] _args) -> void
+  end
+
+  class AbstractParser
+    include Parsable
+    @parser: bot
+
+    def parse: (untyped input) -> untyped
+  end
+end

data/sig/yaparc.rbs

@@ -0,0 +1,4 @@
+module Yaparc
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/yaparc.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/yaparc"
+
+Gem::Specification.new do |spec|
+  spec.name = "yaparc"
+  spec.version = Yaparc::VERSION
+  spec.authors = ["Akimichi Tatsukawa", "gemmaro"]
+  spec.email = ["akimichi.tatsukawa@gmail.com", "gemmaro.dev@gmail.com"]
+
+  spec.summary = "Yet another simple parser combinator library"
+  spec.homepage = homepage = "https://git.disroot.org/gemmaro/yaparc"
+  spec.required_ruby_version = ">= 3.1.6"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "test-unit"
+
+  spec.metadata = {
+    'rubygems_mfa_required' => 'true',
+    'bug_tracker_uri'       => "#{homepage}/issues",
+    'changelog_uri'         => "#{homepage}/src/branch/main/CHANGELOG.md",
+    'documentation_uri'     => "https://rubydoc.info/gems/yaparc",
+    'homepage_uri'          => homepage,
+    'source_code_uri'       => homepage,
+    'wiki_uri'              => "#{homepage}/wiki",
+  }
+end