dolos 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8a83a078e5fa82aa8f6d28f3315597937b84c604d59e18f177a950594860e93
-  data.tar.gz: bccf5fc9390189e43ef9c785baeaf93b85e00d1ce480c63057cf0cc26c468050
+  metadata.gz: bdfe6ab9b41e2783d7a0f6fa530bccf44cecc1aaaf2dff900bc346ef980d8fef
+  data.tar.gz: 29ee6fd6ff4bdc45a8d165a54e5a0a6bc57d3ae7068a60049d00385b37011fa7
 SHA512:
-  metadata.gz: 75fcc5acf6a6dfbd4eeaf7493f9f82a3d31b5d6b61c64f2d9ee3f6f7fe8856fa1392866cbde95ba12bdb06155f07ed7c9cfe46c24f4353c111bf3782f6033289
-  data.tar.gz: '0608ddcb140a18c1d156ae8729f4c998b1abe4b257be8e02dddff796a3e7d861892ddfebcc6f54b744e9b03d381ed029ad81954b2ff484cc2621d5b7f804d3cb'
+  metadata.gz: 239dcd2a22ae2bcbd85e2915e28fe67eec4f0e75e9d7c7e4668ec930b30781cac256628833c8f5ca19cdafec1d31642098b27e5ba5a83c43e0abe08ae1277766
+  data.tar.gz: 0c5698dd2cd7b91b9861125e6306ba99a7406bcaf4b1314eac5218fdc789235cc91d3794c67f0f82ff9cf32956b52f788e1c20607215f04586919a3988e75dad

data/README.md

@@ -23,30 +23,34 @@ require 'dolos'
 include Dolos
 
 ws = c(" ")
-parser = c("Parsers") >> ws >> c("are") >> ws >> c("great!")
+parser = c("Parsers") & ws & c("are") & ws & c("great!")
 parser.run("Parsers are great!") # <Result::Success>
 
 greeter = c("Hello")
-greet_and_speak = greeter >> c(", ") >> parser
+greet_and_speak = greeter & c(", ") & parser
 greet_and_speak.run("Hello, Parsers are great!") # <Result::Success>
 ```
 
 ### Letter address parser example
+
 ```ruby
 require 'dolos'
 require 'dolos_common_parsers/common_parsers'
 
+include Dolos
+# frozen_string_literal: true
+require_relative 'dolos'
+require_relative 'dolos_common_parsers/common_parsers'
+
 include Dolos
 
 # Include common parsers
-# In future this can be more structured, 
-# moved them to separate module to prevent breaking changes
+# In future this can be more structured, moved them to separate module to prevent breaking changes
 include Dolos::CommonParsers
 
 # Library usage example
 # Parse out a name and address from a letter
-# For higher difficulty, we will not split this into multiple lines, 
-# but instead parse it all at once
+# For higher difficulty, we will not split this into multiple lines, but instead parse it all at once
 letter = <<-LETTER
         Mr. Vardeniui Pavardeniui
         AB „Lietuvos Paštas“
@@ -63,12 +67,12 @@ alpha_with_lt = char_in("ąčęėįšųūžĄČĘĖĮŠŲŪŽ") | alpha
 
 # Capture all letters in a row and join them,
 # because they are captured as elements of array by each alpha_with_lt parser.
-first_name = alpha_with_lt.rep.capture!.map(&:join)
-last_name = alpha_with_lt.rep.capture!.map(&:join)
+first_name = alpha_with_lt.rep.map(&:join).capture!
+last_name = alpha_with_lt.rep.map(&:join).capture!
 
 # Combine first line parsers
 # Consume zero or more whitespace, after that honorific must follow and so on
-name_line = ws.rep0 >> honorific >> first_name >> ws >> last_name >> eol
+name_line = ws.rep0 & honorific & first_name & ws & last_name & eol
 
 # Next line is company info
 # We could choose to accept UAB and AB or just AB and etc.
@@ -78,9 +82,9 @@ quote_open = c("„")
 quote_close = c("“")
 
 # Consume LT alphabet with whitespace
-company_name = (alpha_with_lt | ws).rep.capture!.map(&:join)
-company_info = company_type >> ws.rep0 >> quote_open >> company_name >> quote_close
-second_line = ws.rep0 >> company_info >> eol
+company_name = (alpha_with_lt | ws).rep.map(&:join).capture!
+company_info = company_type & ws.rep0 & quote_open & company_name & quote_close
+second_line = ws.rep0 & company_info & eol
 
 # Address line
 # 'char_while' will consume characters while passed predicate is true
@@ -88,35 +92,38 @@ second_line = ws.rep0 >> company_info >> eol
 # After that result is captured and mapped to hash
 # Mapping to hash so at the end its easy to tell tuples apart
 # Also while mapping, doing some cleaning with '.strip'
-street_name = char_while(->(char) { !char.match(/\d/) })
-  .capture!
-  .map(&:first)
-  .map { |s| { street: s.strip } }
-building = digits.capture!.map(&:first).map { |s| { building: s.strip } }
-address_line = ws.rep0 >> street_name >> building >> eol
+street_name = char_while(->(char) { !char.match(/\d/) }).map { |s| { street: s.strip } }.capture!
+building = digits.map { |s| { building: s.strip } }.capture!
+address_line = ws.rep0 & street_name & building & eol
 
 # City line
-# All digits can be matched here or 'digits.rep(5)' could be used. 
-# Also joining with map results.
-postcode = digits.capture!.map(&:join).map { |s| { postcode: s.strip } }
-city = alpha_with_lt.rep.capture!.map(&:join).map { |s| { city: s.strip } }
-city_line = ws.rep0 >> postcode >> ws >> city >> eol
-
-# Full letter parser which is combined from all previous parsers.
-# Also, all previous parsers can be ran separately.
-letter_parser = name_line >> second_line >> address_line >> city_line
+# All digits can be matched here or 'digits.rep(5)' could be used. Also joining with map.
+postcode = digits.map { |s| { postcode: s.strip } }.capture!
+city = alpha_with_lt.rep.map(&:join).map { |s| { city: s.strip } }.capture!
+city_line = ws.rep0 & postcode & ws & city & eol
+
+# Full letter parser which is combined from all previous parsers. All previous parsers can be ran separately.
+letter_parser = name_line & second_line & address_line & city_line
 result = letter_parser.run(letter)
 
-# List of tuples
 pp result.captures
-# ["Vardeniui", "Pavardeniui", "Lietuvos Paštas", {:street=>"Totorių g."},
-# {:building=>"8"}, {:postcode=>"01121"}, {:city=>"Vilnius"}]
 
 ```
 ### Roadmap
 - Better error handling
-- Recursive parser
 - Benchmarks & parser tests
+- Documentation
+- Performance
+
+### Benchmarks
+`bundle exec ruby benchmarks/json/json.rb`
+```
+Calculating -------------------------------------
+nested json benchmark
+                          0.090  (± 0.0%) i/s -      6.000  in  66.952366s
+```
+Its very slow, not ready for use yet. API is unstable is as well.
+
 
 ### Contributing
 Contributors are welcome. Note: since library is not yet stable, I recommend getting in touch with me before starting to work on something.

data/benchmarks/json/json.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require 'dolos'
+require 'dolos_common_parsers/common_parsers'
+
+include Dolos
+include Dolos::CommonParsers
+
+def ws_rep0 = ws.rep0
+
+def comma = c(",")
+
+def string_literal = (c("\"") >> char_while(->(ch) { ch != "\"" }).opt << c("\""))
+
+def boolean = (c("true").map { true } | c("false").map { false })
+
+def null = c("null").map { nil }
+
+def array = recursive do |arr|
+  c("[") >> ws_rep0 >> value.repeat(n_min: 0, separator: (comma << ws_rep0)) << ws_rep0 << c("]")
+end
+
+def negative_sign = c("-").opt
+
+def decimal_point = c('.').opt
+
+def number = (negative_sign & digits & decimal_point & digits.opt).map do |tuple|
+  tuple.join.to_f
+end
+
+def value = number | object | string_literal | boolean | null | array
+
+def key_line = ((string_literal << ws_rep0) << c(":") & ws_rep0 >> value).map do |tuple|
+  { tuple[0] => tuple[1] }
+end
+
+def key_lines = (key_line << ws_rep0).repeat(n_min: 1, separator: (comma << ws_rep0 << eol.opt)).map do |arr|
+  arr.reduce({}) do |acc, hash|
+    acc.merge(hash)
+  end
+end
+
+def object = recursive do |obj|
+  c("{") >> ws_rep0 >> key_lines.opt << ws_rep0 << c("}")
+end
+
+def json_parser = ws_rep0 >> value
+
+json_from_file = File.read('benchmarks/json/random.json')
+
+Benchmark.ips do |x|
+  x.time = 60
+  x.warmup = 15
+
+  x.report('nested json benchmark') do
+    json_parser.run(json_from_file)
+  end
+  x.compare!
+end