jiffy 1.0.4 → 1.1.0

data/lib/jiffy/parsers/json_value.rb

@@ -1,12 +1,12 @@
 
 # line 1 "json_value.rl"
 
-# line 56 "json_value.rl"
+# line 32 "json_value.rl"
 
 
 class Jiffy
   module Parsers
-    module JsonValue
+    class JsonValue < Parser
       def initialize(*args)
         
 # line 13 "json_value.rb"
@@ -116,22 +116,27 @@ end
 self.json_value_en_main = 1;
 
 
-# line 63 "json_value.rl"
+# line 39 "json_value.rl"
+
         super
       end
 
-      def parse_json_value(p, pe)
+      def parse
+        pe = :ignored
+        eof = :ignored
+        p = self.p
+
         
-# line 126 "json_value.rb"
+# line 131 "json_value.rb"
 begin
 	p ||= 0
 	pe ||= data.length
 	cs = json_value_start
 end
 
-# line 68 "json_value.rl"
+# line 49 "json_value.rl"
         
-# line 135 "json_value.rb"
+# line 140 "json_value.rb"
 begin
 	_klen, _trans, _keys, _acts, _nacts = nil
 	_goto_level = 0
@@ -161,7 +166,7 @@ begin
 		_acts += 1
 		case _json_value_actions[_acts - 1]
 			when 4 then
-# line 45 "json_value.rl"
+# line 21 "json_value.rl"
 		begin
  p = p - 1; 	begin
 		p += 1
@@ -170,7 +175,7 @@ begin
 		break
 	end
  		end
-# line 174 "json_value.rb"
+# line 179 "json_value.rb"
 		end # from state action switch
 	end
 	if _trigger_goto
@@ -238,75 +243,51 @@ when 0 then
 # line 5 "json_value.rl"
 		begin
 
-      np = parse_json_string(p, pe)
-
-      if np
-         begin p = (( np))-1; end
+       begin p = (( JsonString.new(p: p, data: data, yielder: yielder).parse))-1; end
 
-      else
-        raise_unparseable p
-      end
     		end
 when 1 then
-# line 15 "json_value.rl"
+# line 9 "json_value.rl"
 		begin
 
-      np = parse_json_float(p, pe)
-
-      if np
-         begin p = (( np))-1; end
+       begin p = (( JsonFloat.new(p: p, data: data, yielder: yielder).parse))-1; end
 
-      else
-        raise_unparseable p
-      end
     		end
 when 2 then
-# line 25 "json_value.rl"
+# line 13 "json_value.rl"
 		begin
 
-      np = parse_json_array(p, pe)
+       begin p = (( JsonArray.new(p: p, data: data, yielder: yielder).parse))-1; end
 
-      if np
-         begin p = (( np))-1; end
-
-      else
-        raise_unparseable p
-      end
     		end
 when 3 then
-# line 35 "json_value.rl"
+# line 17 "json_value.rl"
 		begin
 
-      np = parse_json_object(p, pe)
+       begin p = (( JsonObject.new(p: p, data: data, yielder: yielder).parse))-1; end
 
-      if np
-         begin p = (( np))-1; end
-
-      else
-        raise_unparseable p
-      end
     		end
 when 5 then
-# line 48 "json_value.rl"
+# line 24 "json_value.rl"
 		begin
- o.t :null 		end
+ y << :null 		end
 when 6 then
-# line 49 "json_value.rl"
+# line 25 "json_value.rl"
 		begin
- o.t :false 		end
+ y << :false 		end
 when 7 then
-# line 50 "json_value.rl"
+# line 26 "json_value.rl"
 		begin
- o.t :true 		end
+ y << :true 		end
 when 8 then
-# line 52 "json_value.rl"
+# line 28 "json_value.rl"
 		begin
- o.t :begin_string 		end
+ y << :begin_string 		end
 when 9 then
-# line 52 "json_value.rl"
+# line 28 "json_value.rl"
 		begin
- o.t :end_string 		end
-# line 310 "json_value.rb"
+ y << :end_string 		end
+# line 291 "json_value.rb"
 			end # action switch
 		end
 	end
@@ -333,7 +314,7 @@ when 9 then
 	end
 	end
 
-# line 69 "json_value.rl"
+# line 50 "json_value.rl"
 
         if cs >= json_value_first_final
           p

data/lib/jiffy/parsers/json_value.rl

@@ -3,53 +3,29 @@
     include json_common "json_common.rl";
 
     action parse_string {
-      np = parse_json_string(fpc, pe)
-
-      if np
-        fexec np;
-      else
-        raise_unparseable p
-      end
+      fexec JsonString.new(p: p, data: data, yielder: yielder).parse;
     }
 
     action parse_number {
-      np = parse_json_float(fpc, pe)
-
-      if np
-        fexec np;
-      else
-        raise_unparseable p
-      end
+      fexec JsonFloat.new(p: p, data: data, yielder: yielder).parse;
     }
 
     action parse_array {
-      np = parse_json_array(fpc, pe)
-
-      if np
-        fexec np;
-      else
-        raise_unparseable p
-      end
+      fexec JsonArray.new(p: p, data: data, yielder: yielder).parse;
     }
 
     action parse_object {
-      np = parse_json_object(fpc, pe)
-
-      if np
-        fexec np;
-      else
-        raise_unparseable p
-      end
+      fexec JsonObject.new(p: p, data: data, yielder: yielder).parse;
     }
 
     action exit { fhold; fbreak; }
 
     main := (
-        Vnull >{ o.t :null } |
-        Vfalse >{ o.t :false } |
-        Vtrue >{ o.t :true } |
+        Vnull >{ y << :null } |
+        Vfalse >{ y << :false } |
+        Vtrue >{ y << :true } |
         begin_number >parse_number |
-        begin_string >{ o.t :begin_string } >parse_string @{ o.t :end_string } |
+        begin_string >{ y << :begin_string } >parse_string @{ y << :end_string } |
         begin_array >parse_array |
         begin_object >parse_object
     ) %*exit;
@@ -57,13 +33,18 @@
 
 class Jiffy
   module Parsers
-    module JsonValue
+    class JsonValue < Parser
       def initialize(*args)
         %% write data;
+
         super
       end
 
-      def parse_json_value(p, pe)
+      def parse
+        pe = :ignored
+        eof = :ignored
+        p = self.p
+
         %% write init;
         %% write exec;
 

data/lib/jiffy/version.rb

@@ -1,3 +1,3 @@
 class Jiffy
-  VERSION = '1.0.4'
+  VERSION = '1.1.0'
 end

data/test/jiffy_test.rb

@@ -1,5 +1,3 @@
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-
 require 'stringio'
 require 'minitest/autorun'
 require 'jiffy'
@@ -8,6 +6,10 @@ valid_json = '["Valid JSON"]'
 invalid_json = '["Invalid" "JSON"]'
 incomplete_json = '["Incomplete JSON'
 
+class DummyOutputter
+  def process_token(*); end
+end
+
 def it_should_properly_handle(exception, options)
   io = Object.new.tap do |io|
     io.define_singleton_method :readpartial do |*|
@@ -16,13 +18,13 @@ def it_should_properly_handle(exception, options)
   end
 
   it "should return false upon #{exception.inspect}" do
-    assert_equal false, Jiffy.new(in: io, out: StringIO.new).cl_format(err: StringIO.new)
+    assert_equal false, Jiffy.new(in: io).cl_format(err: StringIO.new, outputter: DummyOutputter.new)
   end
 
   it "should write #{options[:with]} to :stderr upon #{exception.inspect}" do
     err = StringIO.new
 
-    Jiffy.new(in: io, out: StringIO.new).cl_format(err: err)
+    Jiffy.new(in: io).cl_format(err: err, outputter: DummyOutputter.new)
 
     assert_includes err.string, options[:with]
   end
@@ -30,43 +32,256 @@ def it_should_properly_handle(exception, options)
   it ":stderr should end with a newline upon #{exception.inspect}" do
     err = StringIO.new
 
-    Jiffy.new(in: io, out: StringIO.new).cl_format(err: err)
+    Jiffy.new(in: io).cl_format(err: err, outputter: DummyOutputter.new)
 
     assert_equal "\n", err.string[-1]
   end
 end
 
-describe Jiffy do
-  positive_examples = Dir[File.join(File.dirname(__FILE__), 'positive-examples', '*')]
-
-  describe '#format' do
-    positive_examples.each do |example|
-      it "should format #{File.basename(example)} without raising an exception" do
-        out = StringIO.new
-
-        Jiffy.new(in: example, out: out).format
+def it_should_tokenize(json, *tokens)
+  it "should tokenize #{json.inspect} to #{tokens.map(&:inspect).join ', '}" do
+    assert_equal tokens, Jiffy.new(in: StringIO.new(json)).tokenize.to_a
+  end
+end
 
-        assert_equal(out.string, File.read(example).strip)
-      end
+def it_should_not_tokenize(json)
+  it "should not tokenize #{json.inspect}" do
+    assert_raises Jiffy::UnexpectedEndError, Jiffy::UnparseableError do
+      Jiffy.new(in: StringIO.new(json)).tokenize.to_a
     end
+  end
+end
 
-    negative_examples = Dir[File.join(File.dirname(__FILE__), 'negative-examples', '*')]
-
-    negative_examples.each do |example|
-      it "should raise an exception when formatting #{File.basename(example)}" do
-        out = StringIO.new
-
-        assert_raises Jiffy::UnexpectedEndError, Jiffy::UnparseableError do
-          Jiffy.new(in: example, out: out).format
-        end
-      end
-    end
+describe Jiffy do
+  describe '#tokenize' do
+    it_should_tokenize '{}',
+      :begin_object,
+      :end_object
+
+    it_should_tokenize '{"":{}}',
+      :begin_object,
+      :begin_name,
+      :end_name,
+      :name_separator,
+      :begin_object,
+      :end_object,
+      :end_object
+
+    it_should_tokenize '{"":"","":""}',
+      :begin_object,
+      :begin_name,
+      :end_name,
+      :name_separator,
+      :begin_string,
+      :end_string,
+      :value_separator,
+      :begin_name,
+      :end_name,
+      :name_separator,
+      :begin_string,
+      :end_string,
+      :end_object
+
+    it_should_tokenize '[]',
+      :begin_array,
+      :end_array
+
+    it_should_tokenize '[[]]',
+      :begin_array,
+      :begin_array,
+      :end_array,
+      :end_array
+
+    it_should_tokenize '[{}]',
+      :begin_array,
+      :begin_object,
+      :end_object,
+      :end_array
+
+    it_should_tokenize '{"":[]}',
+      :begin_object,
+      :begin_name,
+      :end_name,
+      :name_separator,
+      :begin_array,
+      :end_array,
+      :end_object
+
+    it_should_tokenize '["",""]',
+      :begin_array,
+      :begin_string,
+      :end_string,
+      :value_separator,
+      :begin_string,
+      :end_string,
+      :end_array
+
+    it_should_tokenize '[false]',
+      :begin_array,
+      :false,
+      :end_array
+
+    it_should_tokenize '[true]',
+      :begin_array,
+      :true,
+      :end_array
+
+    it_should_tokenize '[null]',
+      :begin_array,
+      :null,
+      :end_array
+
+    it_should_tokenize '["foo"]',
+      :begin_array,
+      :begin_string,
+      [:char, "f"],
+      [:char, "o"],
+      [:char, "o"],
+      :end_string,
+      :end_array
+
+    it_should_tokenize '["\b"]',
+      :begin_array,
+      :begin_string,
+      :escaped_backspace,
+      :end_string,
+      :end_array
+
+    it_should_tokenize '["\r"]',
+      :begin_array,
+      :begin_string,
+      :escaped_carriage_return,
+      :end_string,
+      :end_array
+
+    it_should_tokenize '["\f"]',
+      :begin_array,
+      :begin_string,
+      :escaped_formfeed,
+      :end_string,
+      :end_array
+
+    it_should_tokenize '["\t"]',
+      :begin_array,
+      :begin_string,
+      :escaped_horizontal_tab,
+      :end_string,
+      :end_array
+
+    it_should_tokenize '["\n"]',
+      :begin_array,
+      :begin_string,
+      :escaped_newline,
+      :end_string,
+      :end_array
+
+    it_should_tokenize '["\""]',
+      :begin_array,
+      :begin_string,
+      :escaped_quotation_mark,
+      :end_string,
+      :end_array
+
+    it_should_tokenize '["\\\\"]',
+      :begin_array,
+      :begin_string,
+      :escaped_reverse_solidus,
+      :end_string,
+      :end_array
+
+    it_should_tokenize '["\/"]',
+      :begin_array,
+      :begin_string,
+      :escaped_solidus,
+      :end_string,
+      :end_array
+
+    it_should_tokenize '["\u1111"]',
+      :begin_array,
+      :begin_string,
+      [:escaped_unicode, "1111"],
+      :end_string,
+      :end_array
+
+    it_should_tokenize '[-100]',
+      :begin_array,
+      :minus,
+      [:number, 1],
+      [:number, 0],
+      [:number, 0],
+      :end_array
+
+    it_should_tokenize '[1.123]',
+      :begin_array,
+      [:number, 1],
+      [:char, "."],
+      [:number, 1],
+      [:number, 2],
+      [:number, 3],
+      :end_array
+
+    it_should_tokenize '[1.123e10]',
+      :begin_array,
+      [:number, 1],
+      [:char, "."],
+      [:number, 1],
+      [:number, 2],
+      [:number, 3],
+      :exponent,
+      [:number, 1],
+      [:number, 0],
+      :end_array
+
+    it_should_tokenize '[-1.123e-10]',
+      :begin_array,
+      :minus,
+      [:number, 1],
+      [:char, "."],
+      [:number, 1],
+      [:number, 2],
+      [:number, 3],
+      :exponent,
+      :minus,
+      [:number, 1],
+      [:number, 0],
+      :end_array
+
+    it_should_tokenize '[1.123E+10]',
+      :begin_array,
+      [:number, 1],
+      [:char, "."],
+      [:number, 1],
+      [:number, 2],
+      [:number, 3],
+      :exponent,
+      :plus,
+      [:number, 1],
+      [:number, 0],
+      :end_array
+
+    it_should_not_tokenize '[0x00]'
+    it_should_not_tokenize '[Infinity]'
+    it_should_not_tokenize '[,""]'
+    it_should_not_tokenize '["",]'
+    it_should_not_tokenize '[01]'
+    it_should_not_tokenize "[\"line\nbreak\"]"
+    it_should_not_tokenize '{"" ""}'
+    it_should_not_tokenize '[NaN]'
+    it_should_not_tokenize '[+1.123]'
+    it_should_not_tokenize '[+100]'
+    it_should_not_tokenize "['single quoted string']"
+    it_should_not_tokenize "[\"tab\tcharacter\"]"
+    it_should_not_tokenize '{"":"",}'
+    it_should_not_tokenize 'true'
+    it_should_not_tokenize '""'
+    it_should_not_tokenize '[true'
+    it_should_not_tokenize '{"":""'
 
     it 'should raise UnexpectedEndError on valid, but incomplete JSON input' do
       example = StringIO.new incomplete_json
 
       assert_raises Jiffy::UnexpectedEndError do
-        Jiffy.new(in: example, out: StringIO.new).format
+        Jiffy.new(in: example).tokenize.to_a
       end
     end
 
@@ -74,7 +289,7 @@ describe Jiffy do
       example = StringIO.new ""
 
       assert_raises Jiffy::UnexpectedEndError do
-        Jiffy.new(in: example, out: StringIO.new).format
+        Jiffy.new(in: example).tokenize.to_a
       end
     end
 
@@ -82,13 +297,25 @@ describe Jiffy do
       example = StringIO.new invalid_json
 
       assert_raises Jiffy::UnparseableError do
-        Jiffy.new(in: example, out: StringIO.new).format
+        Jiffy.new(in: example).tokenize.to_a
       end
     end
   end
 
   describe '#initialize' do
-    it 'should raise an error when :in is neither an instance of Strirng nor IO' do
+    it 'should not raise an error when :in is an instance of String' do
+      Jiffy.new(in: __FILE__)
+    end
+
+    it 'should not raise en error when :in responds to :readpartial' do
+      class Bar
+        def readpartial(*); end
+      end
+
+      Jiffy.new(in: Bar.new)
+    end
+
+    it 'should raise an error when :in is neither an instance of Strirng nor responds to :readpartial' do
       class Foo; end
 
       assert_raises ArgumentError do
@@ -107,7 +334,7 @@ describe Jiffy do
     it 'should return true upon valid input' do
       example = StringIO.new valid_json
 
-      assert_equal true, Jiffy.new(in: example, out: StringIO.new).cl_format
+      assert_equal true, Jiffy.new(in: example).cl_format(outputter: DummyOutputter.new)
     end
 
     it 'should not write to :stderr upon valid input' do
@@ -115,7 +342,7 @@ describe Jiffy do
 
       err = StringIO.new
 
-      Jiffy.new(in: example, out: StringIO.new).cl_format(err: err)
+      Jiffy.new(in: example).cl_format(err: err, outputter: DummyOutputter.new)
 
       assert_equal "", err.string
     end
@@ -125,7 +352,7 @@ describe Jiffy do
 
       out = StringIO.new
 
-      Jiffy.new(in: example, out: out).cl_format
+      Jiffy.new(in: example).cl_format(outputter: Jiffy::Outputters::Json.new(out: out))
 
       assert_equal "\n", out.string[-1]
     end