dolos 0.2.0 → 0.3.0

data/sig/dolos/common_parsers.rbs

@@ -1,5 +1,16 @@
 module Dolos
   module CommonParsers
+    def digit: -> Parser[String]
+    def digits: -> Parser[String]
+
+    def int: -> Parser[Integer]
+
+    def eol: -> Parser[String]
+
     def ws: -> Parser[String]
+    def ws_rep0: -> Parser[String]
+
+    def alpha: -> Parser[String]
+    def alphanum: -> Parser[String]
   end
 end

data/sig/dolos/parser.rbs

@@ -4,16 +4,20 @@ module Dolos
     def initialize: (^(ParserState) -> Result[A]) -> Parser[A]
     def capture!: -> Parser[A]
     def choice: [B](Parser[B])-> Parser[A | B]
+    def combine: [B](^(A, B) -> Parser[B]) -> Parser[B]
     def flat_map: [B](Parser[A], ^(A) -> Parser[B]) -> Parser[B]
     def flatten: -> Parser[A]
     def map: [B](^(A) -> B) -> Parser[B]
-    def map_value: [B](^(A) -> B) -> Parser[B]
+    def map_captures: [B](^(A) -> B) -> Parser[B]
     def optional: -> Parser[A?]
     def product: [B](Parser[A]) -> Parser[B]
+    def product_l: [B](Parser[B]) -> Parser[B]
+    def product_r: [B](Parser[B]) -> Parser[A]
     def run: (String) -> Result[A]
     def run_with_state: (ParserState) -> Result[A]
-    def repeat: (Integer, Integer)-> Parser[Array[A]]
+    def repeat: [B](Integer, Integer, Parser[B]?)-> Parser[Array[A]]
     def zero_or_more: -> Parser[Array[A]]
     def one_or_more: (Integer?) -> Parser[Array[A]]
+    def lazy: -> Parser[A]
   end
 end

data/sig/dolos/parser_state.rbs

@@ -1,6 +1,6 @@
 module Dolos
   class ParserState
-    attr_reader input: Dolos::StringIOWrapper
+    attr_reader input: StringIOWrapper
     attr_accessor last_success_position: Integer
 
     def initialize: (String) -> void

data/sig/dolos/parsers.rbs

@@ -1,6 +1,10 @@
 module Dolos
   module Parsers
     def any_char: -> Parser[String]
+    def char_in: -> Parser[String]
+    def char_while : -> Parser[String]
+    def recursive: [A,B,C]() { (Parser[A]) -> Parser[B] } -> Parser[C]
+
     def regex: (Regexp) -> Parser[String]
     def string: (String)-> Parser[String]
   end

data/sig/dolos/result.rbs

@@ -15,6 +15,11 @@ module Dolos
   end
 
   class Failure < Result[bot]
+    @message_proc: ^-> String
+    @message_evaluated: bool
+    @message_value: String
+    @state: ParserState
+
     attr_reader committed: bool
     attr_reader error_position: Integer
     attr_reader message: String
@@ -25,6 +30,8 @@ module Dolos
 
     def map: [B](^(bot) -> B) -> Result[B]
 
+    def pretty_print: -> String
+
     def success?: -> bool
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dolos
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - benetis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-19 00:00:00.000000000 Z
+date: 2023-08-23 00:00:00.000000000 Z
 dependencies: []
 description: Parser combinators library for Ruby. In active development, not stable
   yet.
@@ -19,21 +19,29 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- ".rubocop.yml"
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - benchmarks/json/json.rb
-- benchmarks/json/nested_json.json
-- docs/dolos_stable_diff.png
+- benchmarks/json/nested_json_166.json
+- benchmarks/json/nested_json_1m.json
+- benchmarks/letter.rb
+- docs/.nojekyll
+- docs/README.md
+- docs/_sidebar.md
+- docs/getting_started.md
+- docs/images/dolos_stable_diff.png
+- docs/index.html
 - examples/letter.rb
 - lib/dolos.rb
+- lib/dolos/common.rb
 - lib/dolos/parser_state.rb
 - lib/dolos/parsers.rb
 - lib/dolos/result.rb
 - lib/dolos/string_io_wrapper.rb
 - lib/dolos/version.rb
-- lib/dolos_common_parsers/common_parsers.rb
 - sig/dolos.rbs
 - sig/dolos/common_parsers.rbs
 - sig/dolos/parser.rbs

data/lib/dolos_common_parsers/common_parsers.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Dolos
-  module CommonParsers
-    def ws
-      regex(/\s/)
-    end
-
-    def eol
-      regex(/\n|\r\n|\r/)
-    end
-
-    def digit
-      regex(/\d/)
-    end
-
-    def int
-      digit.map(&:to_i)
-    end
-
-    # Capture as string
-    def digits
-      regex(/\d+/)
-    end
-
-    def alpha_num
-      regex(/[a-zA-Z0-9]/)
-    end
-
-    def alpha
-      regex(/[a-zA-Z]/)
-    end
-  end
-end