Implement ratio parsing returning a ruby Rational.

ext/edn_turbo/edn_parser.rl

@@ -107,8 +107,13 @@
         // try to parse a decimal first
         const char *np = parse_decimal(fpc, pe, v);
         if (np == nullptr) {
-            // if we can't, try to parse it as an int
-            np = parse_integer(fpc, pe, v);
+            // if we can't, try to parse it as a ratio
+            np = parse_ratio(fpc, pe, v);
+
+            // otherwise, an int
+            if (np == nullptr) {
+               np = parse_integer(fpc, pe, v);
+            }
         }
 
         if (np) {
@@ -319,7 +324,6 @@ const char* edn::Parser::parse_keyword(const char *p, const char *pe, VALUE& v)
 }
 
 
-
 // ============================================================
 // decimal parsing machine
 //
@@ -386,6 +390,37 @@ const char* edn::Parser::parse_integer(const char *p, const char *pe, VALUE& v)
 }
 
 
+// ============================================================
+// ratio parsing machine
+//
+%%{
+    machine EDN_ratio;
+    include EDN_common;
+
+    write data noerror;
+
+
+    main := (
+             ('-'|'+')? (integer '/' integer)
+            ) (^[0-9+\-\/]? @exit);
+}%%
+
+
+const char* edn::Parser::parse_ratio(const char *p, const char *pe, VALUE& v)
+{
+    int cs;
+
+    %% write init;
+    const char* p_save = p;
+    %% write exec;
+
+    if (cs >= EDN_ratio_first_final) {
+        v = edn::util::ratio_to_ruby(p_save, p - p_save);
+        return p + 1;
+    }
+    else if (cs == EDN_ratio_en_main) {} // silence ragel warning
+    return nullptr;
+}
 
 // ============================================================
 // operator parsing - handles tokens w/ a leading operator:
@@ -419,8 +454,13 @@ const char* edn::Parser::parse_integer(const char *p, const char *pe, VALUE& v)
         // try to parse a decimal first
         const char *np = parse_decimal(p_save, pe, v);
         if (np == nullptr) {
-            // if we can't, try to parse it as an int
-            np = parse_integer(p_save, pe, v);
+            // if we can't, try to parse it as a ratio
+            np = parse_ratio(p_save, pe, v);
+
+            if (np == nullptr) {
+               // again, if we can't, try to parse it as an int
+               np = parse_integer(p_save, pe, v);
+            }
         }
 
         if (np) {

ext/edn_turbo/main.cc

@@ -40,6 +40,7 @@ namespace edn {
    VALUE EDN_MAKE_LIST_METHOD         = Qnil;
    VALUE EDN_MAKE_SET_METHOD          = Qnil;
    VALUE EDN_MAKE_BIG_DECIMAL_METHOD  = Qnil;
+   VALUE EDN_MAKE_RATIONAL_METHOD     = Qnil;
    VALUE EDN_TAGGED_ELEM_METHOD       = Qnil;
    VALUE EDNT_EXTENDED_VALUE_METHOD   = Qnil;
 
@@ -209,7 +210,7 @@ void Init_edn_turbo(void)
    rb_define_method(rb_cParser, "read",
                     reinterpret_cast<VALUE(*)(ANYARGS)>(&edn::next), 0 );
 
-   // bind ruby methods we'll call - these should be defined in edn_turbo.rb
+   // bind edn-ruby methods we'll call
    edn::EDN_MAKE_SYMBOL_METHOD        = rb_intern("symbol");
    edn::EDN_MAKE_LIST_METHOD          = rb_intern("list");
    edn::EDN_MAKE_SET_METHOD           = rb_intern("set");
@@ -218,6 +219,7 @@ void Init_edn_turbo(void)
 
    // defined in EDNT - see edn_parser.rb
    edn::EDNT_EXTENDED_VALUE_METHOD    = rb_intern("extend_for_meta");
+   edn::EDN_MAKE_RATIONAL_METHOD      = rb_intern("rational"); // should be in edn-ruby
 
    // ruby methods
    edn::RUBY_STRING_TO_I_METHOD       = rb_intern("to_i");

ext/edn_turbo/parser.h

@@ -82,6 +82,7 @@ namespace edn
       const char* parse_keyword (const char *p, const char *pe, VALUE& v);
       const char* parse_decimal (const char *p, const char *pe, VALUE& v);
       const char* parse_integer (const char *p, const char *pe, VALUE& v);
+      const char* parse_ratio   (const char *p, const char *pe, VALUE& v);
       const char* parse_operator(const char *p, const char *pe, VALUE& v);
       const char* parse_esc_char(const char *p, const char *pe, VALUE& v);
       const char* parse_symbol  (const char *p, const char *pe, VALUE& v);

ext/edn_turbo/util.cc

@@ -155,12 +155,11 @@ namespace edn
       // as above.. TODO: check exponential..
       VALUE float_to_ruby(const char* str, std::size_t len)
       {
-         // if big decimal is needed, call into ruby side to get
-         // the correct value
+         // if big decimal is needed, call into ruby side to get the
+         // correct value
          if (str[len-1] == 'M' || len >= LD_max_chars)
          {
-            std::string buf(str, len);
-            VALUE vs = edn_prot_rb_new_str(buf.c_str());
+            VALUE vs = edn_prot_rb_new_str(str);
 
             if (str[len-1] == 'M') {
                return call_module_fn(rb_mEDN, EDN_MAKE_BIG_DECIMAL_METHOD, vs);
@@ -173,6 +172,12 @@ namespace edn
          return rb_float_new(buftotype<double>(str, len));
       }
 
+      //
+      // returns a ruby Rational
+      VALUE ratio_to_ruby(const char* str, std::size_t len)
+      {
+         return call_module_fn(rb_mEDN, EDN_MAKE_RATIONAL_METHOD, edn_prot_rb_new_str(str));
+      }
 
       //
       // read from a StringIO - handled from ruby side

ext/edn_turbo/util.h

@@ -31,6 +31,7 @@ namespace edn
    extern VALUE EDN_MAKE_LIST_METHOD;
    extern VALUE EDN_MAKE_SET_METHOD;
    extern VALUE EDN_MAKE_BIG_DECIMAL_METHOD;
+   extern VALUE EDN_MAKE_RATIONAL_METHOD;
    extern VALUE EDN_TAGGED_ELEM_METHOD;
    extern VALUE EDN_EOF_CONST;
 
@@ -45,6 +46,7 @@ namespace edn
       // defined in edn_parser_util.cc
       VALUE integer_to_ruby(const char* str, std::size_t len);
       VALUE float_to_ruby  (const char* str, std::size_t len);
+      VALUE ratio_to_ruby  (const char* str, std::size_t len);
 
       VALUE ruby_io_read(VALUE io);
 

lib/edn_turbo.rb

@@ -30,4 +30,10 @@
 # Replace the parser in the EDN module with the C based one.
 module EDN
   self.parser = EDNT::Parser
+
+  # makes a rational type for converting a clojure ratio
+  # - this should be in edn-ruby
+  def self.rational(value)
+    Rational(value)
+  end
 end

spec/edn_turbo/edn_parser_spec.rb

@@ -126,7 +126,7 @@ def fixture(*fixture_filename)
       end
     end
 
-    context 'numbers' do
+    context 'numeric' do
       it 'zero' do
         expect(subject.parse(' 0 ')).to eq(0)
       end
@@ -187,6 +187,18 @@ def fixture(*fixture_filename)
       #   expect(val).to eq(4.54e+44)
       #   expect(val.class).to eq(Float)
       # end
+      it 'ratio' do
+        val = subject.parse(' 2/3 ')
+        expect(val).to eq(Rational(2, 3))
+      end
+      it 'positive ratio' do
+        val = subject.parse(' +2/3 ')
+        expect(val).to eq(Rational(2, 3))
+      end
+      it 'negative ratio' do
+        val = subject.parse(' -2/3 ')
+        expect(val).to eq(Rational(-2, 3))
+      end
     end
 
     context 'operators' do