json example refactoring

1 files changed, 48 insertions, 44 deletions

diff --git a/spec/practical/json_spec.cr b/spec/practical/json_spec.cr
index e4705e8..9d47b93 100644
--- a/spec/practical/json_spec.cr
+++ b/spec/practical/json_spec.cr
@@ -25,41 +25,39 @@ def assoc_to_hash(arr : Array({K, V})) : Hash(K, V) forall K, V
   h
 end
 
+def float_or_int(x : Float64) : Float64 | Int64
+  (x % 1).zero? ? x.to_i64 : x
+end
+
 describe "example: JSON parsing", tags: "example" do
-  json_null = Parser.token_sequence("null".chars).map_const(JSONValue.new(nil))
+  json_null = Parser.token_sequence("null".chars)
+    .map_const(JSONValue.new(nil))
+    .named("json_null")
 
   t = Parser.token_sequence("true".chars).map_const(true)
   f = Parser.token_sequence("false".chars).map_const(false)
-  json_bool = (t | f).map { |b| JSONValue.new(b) }
+  json_bool = (t | f).map { |b| JSONValue.new(b) }.named("json_bool")
 
-  digits = Parser(Char, Char).satisfy(&.ascii_number?).many
+  digits = Parser(Char, Char).satisfy(&.number?).many
   sign = Parser.token('-').map_const(-1).recover(1)
   point = Parser.token('.').optional
-  json_number = sign.and_then do |s|
-    digits.and_then do |front|
-      point.and_then do |p|
-        digits.and_then do |back|
-          if front.empty? && back.empty?
-            Parser(Char, JSONValue).flunk
-          else
-            x = 
-              case
-                when front.empty? && !p.nil? # {[], '.', _} # 0 <= x < 1
-                  "0.#{back.join}".to_f64
-                when back.empty? #{_, _, []} # whole number
-                  front.join.to_i64
-                else #when !front.empty? && !p.nil? && !back.empty? # some other float
-                  "#{front.join}.#{back.join}".to_f64
-                #else
-                #  raise "json_number, Should be unreachable: #{front} #{p} #{back}"
-              end
-            x = x.to_i64 if x.is_a?(Float64) && (x % 1).zero?
-            Parser(Char, JSONValue).pure(JSONValue.new(x * s))
-          end
-        end
-      end
-    end
-  end
+
+  json_number = parser_chain "json_number", Char, JSONValue,
+    {s,     sign},
+    {front, digits},
+    {p,     point},
+    {back,  digits},
+    finally:
+      case {front.empty?, p.nil?, back.empty?}
+        when {true, false, false}
+          Parser(Char, Float64).pure("0.#{back.join}".to_f64)
+        when {false, _, true}
+          Parser(Char, Float64).pure(front.join.to_f64)
+        when {false, false, false}
+          Parser(Char, Float64).pure("#{front.join}.#{back.join}".to_f64)
+        else
+          Parser(Char, Float64).flunk("Could not parse '#{front.join}#{p}#{back.join}' as a number")
+      end.map { |x| JSONValue.new(float_or_int(x) * s) }
 
   q = Parser.token('"')
   s_char = Parser(Char, Char).first_of([
@@ -67,7 +65,7 @@ describe "example: JSON parsing", tags: "example" do
     Parser(Char, Char).satisfy(&.!=('"')),
   ])
   string_literal = (q >> s_char.many.map(&.join) << q)
-  json_string = string_literal.map { |s| JSONValue.new(s) }
+  json_string = string_literal.map { |s| JSONValue.new(s) }.named("json_string")
 
   # Forward-declared here to allow for mutual recursion
   json_value   = uninitialized Parser(Char, JSONValue)
@@ -77,27 +75,33 @@ describe "example: JSON parsing", tags: "example" do
   a_sep = ws >> Parser.token(',') >> ws
   a_front = Parser.token('[') >> ws
   a_back = ws >> Parser.token(']')
-  json_array = Parser(Char, JSONValue).new("json_array") do |tokens|
-    # Has to be created and re-created here to allow mutual recursion
+
+  # Has to be created this way to allow for mutual recursion
+  non_empty_elements = Parser(Char, Array(JSONValue)).new("non_empty_elements") do |tokens|
     # `a_sep.optional` matches a trailing comma in this expression
-    non_empty_elements = p_json_value.value.sep_by(a_sep) << a_sep.optional
-    elements = non_empty_elements.recover([] of JSONValue)
-    p = (a_front >> elements << a_back).map { |es| JSONValue.new(es) }
-    p.parse(tokens)
+    (p_json_value.value.sep_by(a_sep) << a_sep.optional).parse(tokens)
   end
+  elements = non_empty_elements.recover([] of JSONValue)
+
+  json_array = (a_front >> elements << a_back).map { |es| JSONValue.new(es) }
+    .named("json_value")
 
   kv_sep = ws >> Parser.token(':') >> ws
-  o_sep = ws >> Parser.token(',') >> ws
+  # Has to be created this way to allow for mutual recursion
+  kv_pair = Parser(Char, {String, JSONValue}).new("kv_pair") do |tokens|
+    (string_literal + (kv_sep >> p_json_value.value)).parse(tokens)
+  end
+
+  o_sep   = ws >> Parser.token(',') >> ws
   o_front = Parser.token('{') >> ws
   o_back  = ws >> Parser.token('}')
-  json_object = Parser(Char, JSONValue).new("json_object") do |tokens|
-    # Has to be created and re-created here to allow mutual recursion
-    kv_pair = string_literal + (kv_sep >> p_json_value.value)
-    # `a_sep.optional` matches a trailing comma in this expression
-    attributes = kv_pair.sep_by(o_sep) << o_sep.optional
-    p = o_front >> attributes.recover([] of {String, JSONValue}) << o_back
-    p.map { |pairs| JSONValue.new(assoc_to_hash(pairs)) }.parse(tokens)
-  end
+
+  # `a_sep.optional` matches a trailing comma in this expression
+  non_empty_attributes = kv_pair.sep_by(o_sep) << o_sep.optional
+  o_attributes = non_empty_attributes.recover([] of {String, JSONValue})
+  json_object = (o_front >> o_attributes << o_back).map do |pairs|
+    JSONValue.new(assoc_to_hash(pairs))
+  end.named("json_object")
 
   json_value = Parser(Char, JSONValue).new("json_value") do |tokens|
     Parser(Char, JSONValue).first_of([