@@ -69,6 +69,12 @@ receive do |f| f.receive_loop end + f.when([:bool, Erl.boolean]) do |bool| + debug(:bool, bool, !bool) + f.send!([:bool, !bool]) + f.receive_loop + end + f.when([:number, Fixnum]) do |num| debug(:number, num, num*2) f.send!([:number, num*2]) examples/simple/rerl.rb @@ -25,6 +25,7 @@ process(Port, i_am_alive) -> send(Port, test), send(Port, {atom, symbol}), + send(Port, {bool, true}), send(Port, {number, 1}), send(Port, {string, <<"reverse">>}), send(Port, {array, [1,2,3]}), examples/simple/rerl.sh @@ -21,6 +21,7 @@ require 'erlectricity/encoder' require 'erlectricity/port' require 'erlectricity/matcher' require 'erlectricity/condition' +require 'erlectricity/conditions/boolean' require 'erlectricity/conditions/hash' require 'erlectricity/conditions/static' require 'erlectricity/conditions/type' lib/erlectricity.rb @@ -54,6 +54,10 @@ module Erlectricity def hash HashCondition.new() end + + def boolean + BooleanCondition.new() + end end extend Conditions lib/erlectricity/condition.rb @@ -24,6 +24,7 @@ module Erlectricity when Array then write_tuple(obj) when String then write_binary(obj) when Time then write_any_raw(obj.to_i.divmod(1000000) + [obj.usec]) + when TrueClass, FalseClass then write_boolean(obj) else fail(obj) end @@ -45,6 +46,10 @@ module Erlectricity out.write(string) end + def write_boolean(bool) + write_symbol(bool.to_s.to_sym) + end + def write_symbol(sym) fail(sym) unless sym.is_a?(Symbol) data = sym.to_s lib/erlectricity/encoder.rb @@ -3,119 +3,112 @@ require File.dirname(__FILE__) + '/test_helper.rb' context "When unpacking from a binary stream" do setup do end - + specify "an erlang atom should decode to a ruby symbol" do get("haha").should == :haha end - + specify "an erlang number encoded as a small_int (< 255) should decode to a fixnum" do get("0").should == 0 get("255").should == 255 end - + specify "an erlang number encoded as a int (signed 27-bit number) should decode to a fixnum" do get("256").should == 256 get("#{(1 << 27) -1}").should == (1 << 27) -1 get("-1").should == -1 get("#{-(1 << 27)}").should == -(1 << 27) end - - + specify "an erlang number encoded as a small bignum (1 byte length) should decode to fixnum if it can" do get("#{(1 << 27)}").should == (1 << 27) get("#{-(1 << 27) - 1}").should == -(1 << 27) - 1 get("#{(1 << word_length) - 1}").should == (1 << word_length) - 1 get("#{-(1 << word_length)}").should == -(1 << word_length) end - + specify "an erlang number encoded as a small bignum (1 byte length) should decode to bignum if it can't be a fixnum" do get("#{(1 << word_length)}").should == (1 << word_length) get("#{-(1 << word_length) - 1}").should == -(1 << word_length) - 1 get("#{(1 << (255 * 8)) - 1}").should == (1 << (255 * 8)) - 1 get("#{-((1 << (255 * 8)) - 1)}").should == -((1 << (255 * 8)) - 1) end - - + specify "an erlang number encoded as a big bignum (4 byte length) should decode to bignum" do get("#{(1 << (255 * 8)) }").should == (1 << (255 * 8)) get("#{-(1 << (255 * 8))}").should == -(1 << (255 * 8)) get("#{(1 << (512 * 8)) }").should == (1 << (512 * 8)) get("#{-(1 << (512 * 8))}").should == -(1 << (512 * 8)) end - + specify "an erlang float should decode to a Float" do get("#{1.0}").should == 1.0 get("#{-1.0}").should == -1.0 get("#{123.456}").should == 123.456 get("#{123.456789012345}").should == 123.456789012345 end - - + specify "an erlang reference should decode to a Reference object" do ref = get("make_ref()") ref.should.be.instance_of Erlectricity::NewReference ref.node.should.be.instance_of Symbol end - + specify "an erlang pid should decode to a Pid object" do pid = get("spawn(fun() -> 3 end)") pid.should.be.instance_of Erlectricity::Pid pid.node.should.be.instance_of Symbol end - - + specify "an erlang tuple encoded as a small tuple (1-byte length) should decode to an array" do ref = get("{3}") ref.length.should == 1 ref.first.should == 3 - + ref = get("{3, a, make_ref()}") ref.length.should == 3 ref[0].should == 3 ref[1].should == :a ref[2].class.should == Erlectricity::NewReference - + tuple_meat = (['3'] * 255).join(', ') ref = get("{#{tuple_meat}}") ref.length.should == 255 ref.each{|r| r.should == 3} end - - + specify "an erlang tuple encoded as a large tuple (4-byte length) should decode to an array" do tuple_meat = (['3'] * 256).join(', ') ref = get("{#{tuple_meat}}") ref.length.should == 256 ref.each{|r| r.should == 3} - + tuple_meat = (['3'] * 512).join(', ') ref = get("{#{tuple_meat}}") ref.length.should == 512 ref.each{|r| r.should == 3} end - - + specify "an empty erlang list encoded as a nil should decode to an array" do get("[]").should == [] end - + specify "an erlang list encoded as a string should decode to an array of bytes (less than ideal, but consistent)" do get("\"asdasd\"").should == "asdasd".split('').map{|c| c[0]} get("\"#{'a' * 65534}\"").should == ['a'[0]] * 65534 end - + specify "an erlang list encoded as a list should decode to a array" do get("[3,4,256]").should == [3,4,256] get("\"#{'a' * 65535 }\"").should == [97] * 65535 get("[3,4, foo, {3,4,5,bar}, 256]").should == [3,4, :foo, [3,4,5,:bar], 256] end - - + specify "an erlang binary should decode to a string" do get("<< 3,4,255 >>").should == "\003\004\377" get("<< \"whatup\" >>").should == "whatup" end - + specify "erlang atomic booleans should decode to ruby booleans" do get("true").should == true get("false").should == false @@ -126,10 +119,10 @@ context "When unpacking from a binary stream" do get(%Q-[{options,{struct,[{test,<<"I'm chargin' mah lazer">>}]}},{passage,<<"Why doesn't this work?">>}]-).should == [[:options, [:struct, [[:test, "I'm chargin' mah lazer"]]]], [:passage, "Why doesn't this work?"]] end - + def get(str) x = "term_to_binary(#{str.gsub(/"/, '\\\"')})" bin = run_erl(x) Erlectricity::Decoder.read_any_from(bin) end -end +end \ No newline at end of file test/decode_spec.rb @@ -5,19 +5,26 @@ context "When packing to a binary stream" do @out = StringIO.new('', 'w') @encoder = Erlectricity::Encoder.new(@out) end + specify "A symbol should be encoded to an erlang atom" do get{@encoder.write_symbol :haha}.should == get_erl("haha") write_any(:haha).should == get_erl_with_magic("haha") end - + + specify "A boolean should be encoded to an erlang atom" do + get{@encoder.write_boolean true}.should == get_erl("true") + get{@encoder.write_boolean false}.should == get_erl("false") + write_any(true).should == get_erl_with_magic("true") + write_any(false).should == get_erl_with_magic("false") + end + specify "A number should be encoded as an erlang number would be" do - #SMALL_INTS get{@encoder.write_fixnum 0}.should == get_erl("0") get{@encoder.write_fixnum 255}.should == get_erl("255") write_any(0).should == get_erl_with_magic("0") write_any(255).should == get_erl_with_magic("255") - + #INTS get{@encoder.write_fixnum 256}.should == get_erl("256") get{@encoder.write_fixnum((1 << 27) - 1)}.should == get_erl("#{(1 << 27) - 1}") @@ -27,105 +34,105 @@ context "When packing to a binary stream" do write_any((1 << 27) - 1).should == get_erl_with_magic("#{(1 << 27) - 1}") write_any(-1).should == get_erl_with_magic("-1") write_any(-(1 << 27)).should == get_erl_with_magic("#{-(1 << 27)}") - + # #SMALL_BIGNUMS # get{@encoder.write_fixnum((1 << word_length))}.should == get_erl("#{(1 << word_length)}") # get{@encoder.write_fixnum(-(1 << word_length) - 1)}.should == get_erl("#{-(1 << word_length) - 1}") # get{@encoder.write_fixnum((1 << (255 * 8)) - 1)}.should == get_erl("#{(1 << (255 * 8)) - 1}") # get{@encoder.write_fixnum(-((1 << (255 * 8)) - 1))}.should == get_erl("#{-((1 << (255 * 8)) - 1)}") - # + # # write_any((1 << word_length)).should == get_erl_with_magic("#{(1 << word_length)}") # write_any(-(1 << word_length) - 1).should == get_erl_with_magic("#{-(1 << word_length) - 1}") # write_any((1 << (255 * 8)) - 1).should == get_erl_with_magic("#{(1 << (255 * 8)) - 1}") # write_any(-((1 << (255 * 8)) - 1)).should == get_erl_with_magic("#{-((1 << (255 * 8)) - 1)}") - # + # # #LARG_BIGNUMS # get{@encoder.write_fixnum((1 << (255 * 8)))}.should == get_erl("#{(1 << (255 * 8))}") # get{@encoder.write_fixnum(-(1 << (255 * 8))}.should == get_erl("#{-(1 << (255 * 8)}") # get{@encoder.write_fixnum((1 << (512 * 8))}.should == get_erl("#{(1 << (512 * 8))}") # get{@encoder.write_fixnum(-((1 << (512 * 8)) - 1))}.should == get_erl("#{-((1 << (512 * 8)) - 1)}") - # + # # write_any((1 << (255 * 8))).should == get_erl_with_magic("#{(1 << (255 * 8))}") # write_any(-(1 << (255 * 8)).should == get_erl_with_magic("#{-(1 << (255 * 8)}") # write_any((1 << (512 * 8))).should == get_erl_with_magic("#{(1 << (512 * 8))}") # write_any(-((1 << (512 * 8)) - 1)).should == get_erl_with_magic("#{-((1 << (512 * 8)) - 1)}") end - + # specify "A float (that is within the truncated precision of ruby compared to erlang) should encode as erlang does" do # get{@encoder.write_float 1.0}.should == get_erl("1.0") # get{@encoder.write_float -1.0}.should == get_erl("-1.0") # get{@encoder.write_float 123.456}.should == get_erl("123.456") # get{@encoder.write_float 123.456789012345}.should == get_erl("123.456789012345") # end - + specify "An Erlectiricity::NewReference should encode back to its original form" do ref_bin = run_erl("term_to_binary(make_ref())") ruby_ref = Erlectricity::Decoder.read_any_from(ref_bin) - + get{@encoder.write_new_reference(ruby_ref)}.should == ref_bin[1..-1] write_any(ruby_ref).should == ref_bin end - + specify "An Erlectiricity::Pid should encode back to its original form" do pid_bin = run_erl("term_to_binary(spawn(fun() -> 3 end))") ruby_pid = Erlectricity::Decoder.read_any_from(pid_bin) - + get{@encoder.write_pid(ruby_pid)}.should == pid_bin[1..-1] write_any(ruby_pid).should == pid_bin end - + specify "An array written with write_tuple should encode as erlang would a tuple" do get{@encoder.write_tuple [1,2,3]}.should == get_erl("{1,2,3}") get{@encoder.write_tuple [3] * 255}.should == get_erl("{#{([3] * 255).join(',')}}") get{@encoder.write_tuple [3] * 256}.should == get_erl("{#{([3] * 256).join(',')}}") get{@encoder.write_tuple [3] * 512}.should == get_erl("{#{([3] * 512).join(',')}}") end - + specify "An array should by default be written as a tuple" do write_any([1,2,3]).should == get_erl_with_magic("{1,2,3}") write_any([3] * 255).should == get_erl_with_magic("{#{([3] * 255).join(',')}}") write_any([3] * 256).should == get_erl_with_magic("{#{([3] * 256).join(',')}}") write_any([3] * 512).should == get_erl_with_magic("{#{([3] * 512).join(',')}}") end - + specify "An Erlectricity::List should by default be written as a list" do write_any(Erl::List.new([1,2,300])).should == get_erl_with_magic("[1,2,300]") write_any(Erl::List.new([300] * 255)).should == get_erl_with_magic("[#{([300] * 255).join(',')}]") write_any(Erl::List.new([300] * 256)).should == get_erl_with_magic("[#{([300] * 256).join(',')}]") write_any(Erl::List.new([300] * 512)).should == get_erl_with_magic("[#{([300] * 512).join(',')}]") end - + specify "An array written with write_list should encode as erlang would a list" do get{@encoder.write_list [1,2,300]}.should == get_erl("[1,2,300]") get{@encoder.write_list [300] * 255}.should == get_erl("[#{([300] * 255).join(',')}]") get{@encoder.write_list [300] * 256}.should == get_erl("[#{([300] * 256).join(',')}]") get{@encoder.write_list [300] * 512}.should == get_erl("[#{([300] * 512).join(',')}]") end - + specify "a string should be encoded as a erlang binary would be" do get{@encoder.write_binary "hey who"}.should == get_erl("<< \"hey who\" >>") get{@encoder.write_binary ""}.should == get_erl("<< \"\" >>") - + write_any("hey who").should == get_erl_with_magic("<< \"hey who\" >>") write_any("").should == get_erl_with_magic("<< \"\" >>") end - + def get @encoder.out = StringIO.new('', 'w') yield @encoder.out.string end - + def write_any(term) @encoder.out = StringIO.new('', 'w') @encoder.write_any term @encoder.out.string end - + def get_erl(str) get_erl_with_magic(str)[1..-1] #[1..-1] to chop off the magic number end - + def get_erl_with_magic(str) run_erl("term_to_binary(#{str.gsub(/"/, '\\\"')})") end test/encode_spec.rb 8c85ba2728484706e82f35e33d47ac5db0f20063 Tom Preston-Werner tom@mojombo.com http://github.com/mojombo/erlectricity/commit/5e82730ec45dc5de9e153469cfaad50e06718e3c 5e82730ec45dc5de9e153469cfaad50e06718e3c 2009-04-27T22:41:33-07:00 2009-04-27T22:41:33-07:00 support boolean encoding and matching bf2af10a2ce5f444b78e851fdb219ccc14a9b5e3 Tom Preston-Werner tom@mojombo.com