dolos 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68d26c878ffd86122b9c12273645cf351f5b20d6e1306e140c53727c29e49b2b
-  data.tar.gz: 6bda399416128f5692e2966a46194591209f61602408e6873cb4e41f37a22ec4
+  metadata.gz: bdfe6ab9b41e2783d7a0f6fa530bccf44cecc1aaaf2dff900bc346ef980d8fef
+  data.tar.gz: 29ee6fd6ff4bdc45a8d165a54e5a0a6bc57d3ae7068a60049d00385b37011fa7
 SHA512:
-  metadata.gz: 7ae6b3a4750cc5bfb5f54a84d518f8d4176eaf10dfef4482f45aaadc3db422a14f04cabb65ee0e1fe85b7dfb95fa1b54c8daf4f91083f4f39beac32c70c25616
-  data.tar.gz: e4ab436619a690d257fdaba829fcbc00ec74c56cd8fda0c754fd5f1985fe2d3b21adcda1db69f7ca116437ccf8cf9c6455f03cb05ab44b8107033db590266398
+  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,31 +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
+- 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