dolos 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8a83a078e5fa82aa8f6d28f3315597937b84c604d59e18f177a950594860e93
-  data.tar.gz: bccf5fc9390189e43ef9c785baeaf93b85e00d1ce480c63057cf0cc26c468050
+  metadata.gz: cfeffbbe4108e43ba81ccd210f2689910d310fc3947fe05ed22a9972e581e96a
+  data.tar.gz: e181ccca4725008464fc92670b8120cf55262ba469d6ec494270081eb902c241
 SHA512:
-  metadata.gz: 75fcc5acf6a6dfbd4eeaf7493f9f82a3d31b5d6b61c64f2d9ee3f6f7fe8856fa1392866cbde95ba12bdb06155f07ed7c9cfe46c24f4353c111bf3782f6033289
-  data.tar.gz: '0608ddcb140a18c1d156ae8729f4c998b1abe4b257be8e02dddff796a3e7d861892ddfebcc6f54b744e9b03d381ed029ad81954b2ff484cc2621d5b7f804d3cb'
+  metadata.gz: 27fe73f34d41692d31c00d30bc03869cdefcef4ee785acbb72da12c9bceb85b78357da7c3d6d1435598b40fb635fb5e71d56254c18597c8d7d424748afc7c098
+  data.tar.gz: 9dd78f5e313830742505bbeb1488ed643a700facc2193ed3e996eef795913a50bb660a2af2dcd7c9a73e6e5f84befa7e461b2cf10d4bd11f22d68901ecc59e9b

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,47 @@ 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`
+```
+Dolos
+nested json benchmark      8.426  (± 0.0%) i/s -     43.000  in   5.103600s
+letter benchmark           3.145k (± 0.7%) i/s -     15.810k in   5.027961s
+
+# Note: 23 times slower than Pure Ruby specialized json parser (below) if used to parse json
+nested json 166KB bench    8.189  (± 0.0%) i/s -     41.000  in   5.007158s
+nested json 1MB bench      0.959  (± 0.0%) i/s -     5.000  in    5.230650s
+
+-----------------------------------------------------------
+Pure ruby (flori/json)
+nested json 1MB bench      24.213  (± 4.1%) i/s -    122.000  in   5.042309s
+nested json 166KB bench   188.070  (± 1.6%) i/s -    954.000  in   5.073788s
+Ruby native (C)
+nested json 1MB bench     309.519  (± 0.3%) i/s -    1.560k in    5.040164s
+```
 
 ### 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,83 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require 'bundler/setup'
+require 'dolos'
+require 'dolos_common_parsers/common_parsers'
+
+include Dolos
+include Dolos::CommonParsers
+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
+
+require 'json/pure'
+
+
+json_from_file = File.read('benchmarks/json/nested_json_166.json')
+
+result = json_parser.run(json_from_file)
+puts result.success?
+
+Benchmark.ips do |x|
+  x.report('nested json 166kb benchmark') do
+    json_parser.run(json_from_file)
+  end
+  x.report('Pure ruby json: nested json 166kb benchmark') do
+    JSON.parse(json_from_file)
+  end
+  x.compare!
+end
+
+json_from_file1m = File.read('benchmarks/json/nested_json_1m.json')
+result1m = json_parser.run(json_from_file1m)
+puts result1m.success?
+
+# require 'json'
+
+Benchmark.ips do |x|
+  # x.report('nested json 1mb benchmark') do
+  #   json_parser.run(json_from_file1m)
+  # end
+  # x.report('Ruby native: nested json 1mb benchmark') do
+  #   JSON.parse(json_from_file1m)
+  # end
+  # x.report('Pure ruby json: nested json 1mb benchmark') do
+  #   JSON.parse(json_from_file1m)
+  # end
+  x.compare!
+end