yaparc 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0166a0d68a1864c4c92132c88f6b74809e317d5c031c5e57bf9951b6aaedc7b8
-  data.tar.gz: 86ae7441a45dbf7c8f168abf2bc4633dc317e8dc11ac29e9e572df3d3f91206b
+  metadata.gz: db3016ed938d0853130447ce2155b9e9978faf79798f137c99624d1539a9fc2b
+  data.tar.gz: 505b913fc07f99bf8cc7fb1be125aefedb767bb589d92f40c3bdc35ff6cccfb1
 SHA512:
-  metadata.gz: cb4bc055e722070a425921ee0b23e05ae51764d6d76c6f3a955d2c96c3e32eb3eaff0c159710e7b7d067c360efa3308fc55b7868bbc5af94a8df9db1a8903c9b
-  data.tar.gz: a8583f87131780d75a5ed7c46bb49265411fca899921486cf6f854d77c96c98ee41813015b6e5435a0d531bb06e3cf3c12cb2d08bd0effff553ae1e75b839f89
+  metadata.gz: d53c0470dac4fa661db80607a2e752ab830a751fdd14f3453f838a80ffcd13993b013d32a2aa4c171dc3e8d4cf85154651ed656179669796c8cdac5120503c66
+  data.tar.gz: 75a76818b13a77821106dd09c65c5ae2c3a005ca8361797b75167b708f57846c4664a267f1eb40bba2d7ec9e75ec995291a77e51353423bd232f921475374d59

data/.envrc

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

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## 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.

data/Gemfile

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

data/README

@@ -26,7 +26,7 @@ Yaparc::Result::OK indicates success.
 === Primitive Parsers
 
 * Yaparc::Succeed
-* Yaparc::Fail
+* Yaparc::FailParser
 * Yaparc::Item
 * Yaparc::Satisfy
 
@@ -41,14 +41,14 @@ returns the singleton array <tt>[[1, "blah, blah, blah"]]</tt>.
     parser.parse("blah, blah, blah")
     #=> #<Yaparc::Result::OK:0xb7aaaf5c @input="blah, blah, blah", @value=1>
 
-==== Fail class
+==== FailParser class
 
-The parser Yaparc::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
 

data/Rakefile

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rake/testtask"
+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"]
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
 end
 
-require "rubocop/rake_task"
+require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 
@@ -19,3 +20,8 @@ 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

data/lib/yaparc/no_fail.rb

@@ -0,0 +1,20 @@
+require_relative 'parsable'
+
+module Yaparc
+  # hutton92:_higher_order_funct_parsin,p.19
+  # https://www.cambridge.org/core/journals/journal-of-functional-programming/article/higherorder-functions-for-parsing/0490F2C8511F7625F9FC15BFFEDBB0AA
+  class NoFail
+    include Parsable
+
+    def initialize(parser)
+      @parser = lambda do |input|
+        result = parser.parse(input)
+        if result.instance_of?(Fail)
+          Error.new(value: result.value, input: result.input)
+        else
+          Succeed.new(result.value)
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/parsable.rb

@@ -0,0 +1,20 @@
+module Yaparc
+  module Parsable
+    IS_LOWER      = ->(c) { c >= 'a' and c <= 'z' }
+    IS_ALPHANUM   = ->(c) { (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9') }
+    IS_DIGIT      = ->(i) { i >= '0' and i <= '9' }
+    IS_SPACE      = ->(i) { i == ' ' }
+    IS_WHITESPACE = ->(i) { [' ', "\n", "\t"].include?(i) }
+    IS_CR         = ->(i) { i == "\n" }
+
+    def parse(input)
+      result = @parser.call(input)
+
+      if result.respond_to?(:parse)
+        result.parse(input)
+      else
+        result
+      end
+    end
+  end
+end

data/lib/yaparc/regex.rb

@@ -0,0 +1,22 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Regex
+    include Parsable
+
+    def initialize(regex)
+      @regex = regex
+      @parser = lambda do |input|
+        if match = Regexp.new(regex).match(input)
+          if block_given?
+            Succeed.new(yield(*match.to_a[1..])).parse(match.post_match)
+          else
+            OK.new(value: match[0], input: match.post_match)
+          end
+        else
+          Fail.new(input:)
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/satisfy.rb

@@ -0,0 +1,28 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Satisfy
+    include Parsable
+
+    def initialize(predicate)
+      @parser = lambda do |input|
+        result = Item.new.parse(input)
+
+        if result.instance_of?(OK) && predicate.call(result.value)
+          Succeed.new(result.value, result.input)
+        else
+          FailParser.new
+        end
+      end
+    end
+
+    def parse(input)
+      case parser = @parser.call(input)
+      in Succeed
+        parser.parse(parser.remaining)
+      in FailParser
+        parser.parse(input)
+      end
+    end
+  end
+end

data/lib/yaparc/seq.rb

@@ -0,0 +1,33 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Seq
+    include Parsable
+
+    def initialize(*parsers)
+      @parser = lambda do |input|
+        args = []
+        initial_result = OK.new(input:)
+        final_result = parsers.inject(initial_result) do |subsequent, parser|
+          result = parser.parse(subsequent.input)
+          break Fail.new(input: subsequent.input) if result.instance_of?(Fail)
+
+          args << result.value
+          result
+        end
+
+        case final_result
+        in Fail
+          Fail.new(input: final_result.input)
+        in OK
+          final_value = if block_given?
+                          yield(*args)
+                        else
+                          args.last
+                        end
+          OK.new(value: final_value, input: final_result.input)
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/space.rb

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

data/lib/yaparc/string.rb

@@ -0,0 +1,24 @@
+require_relative 'parsable'
+
+module Yaparc
+  class String
+    include Parsable
+
+    def initialize(string, case_sensitive = true)
+      @parser = lambda do |_input|
+        result = Item.new.parse(string)
+        if result.instance_of?(OK)
+          Seq.new(
+            Char.new(result.value, case_sensitive),
+            Yaparc::String.new(result.input, case_sensitive),
+            Succeed.new(result.value + result.input)
+          ) do |_, _, succeed_result|
+            succeed_result
+          end
+        else
+          Succeed.new(result)
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/succeed.rb

@@ -0,0 +1,14 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Succeed
+    include Parsable
+
+    attr_reader :remaining
+
+    def initialize(value, remaining = nil)
+      @parser = ->(input) { OK.new(value:, input:) }
+      @remaining = remaining
+    end
+  end
+end

data/lib/yaparc/symbol.rb

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

data/lib/yaparc/tokenize.rb

@@ -0,0 +1,18 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Tokenize
+    include Parsable
+
+    attr_writer :prefix, :postfix
+
+    def initialize(parser, prefix: nil, postfix: nil)
+      @parser = lambda do |_input|
+        @prefix = prefix || WhiteSpace.new
+        @postfix = postfix || WhiteSpace.new
+        block_given? and yield self
+        Seq.new(@prefix, parser, @postfix) { |_, vs, _| vs }
+      end
+    end
+  end
+end

data/lib/yaparc/white_space.rb

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

data/lib/yaparc/zero_one.rb

@@ -0,0 +1,20 @@
+require_relative 'parsable'
+
+module Yaparc
+  class ZeroOne
+    include Parsable
+
+    def initialize(parser, identity = [])
+      @parser = lambda do |input|
+        case (result = parser.parse(input))
+        in Fail
+          OK.new(value: identity, input:)
+        in Error
+          Error.new(value: result.value, input: result.input)
+        in OK
+          result
+        end
+      end
+    end
+  end
+end