erlectricity 0.1.0

data/test/condition_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "Erlectricity::StaticConditions" do
+  specify "should satisfy on the same value" do
+    Erlectricity::StaticCondition.new(:foo).satisfies?(:foo).should == true
+    Erlectricity::StaticCondition.new([:foo]).satisfies?([:foo]).should == true
+    Erlectricity::StaticCondition.new(3).satisfies?(3).should == true
+  end
+  
+  specify "should not satisfy on diffeent values" do
+    Erlectricity::StaticCondition.new(:foo).satisfies?("foo").should == false
+    Erlectricity::StaticCondition.new([:foo]).satisfies?(:foo).should == false
+    Erlectricity::StaticCondition.new(Object.new).satisfies?(Object.new).should == false
+    Erlectricity::StaticCondition.new(3).satisfies?(3.0).should == false
+  end
+  
+  specify "should not produce any bindings, even if a name is supplied" do
+    s = Erlectricity::StaticCondition.new(:foo, :bound_name)
+    s.bindings_for(:foo).should == {}
+  end
+end
+
+context "Erlectricity::TypeConditions" do
+  specify "should be satisfied when the arg has the same class" do
+    Erlectricity::TypeCondition.new(Symbol).satisfies?(:foo).should == true
+    Erlectricity::TypeCondition.new(Symbol).satisfies?(:bar).should == true
+    Erlectricity::TypeCondition.new(String).satisfies?("foo").should == true
+    Erlectricity::TypeCondition.new(String).satisfies?("bar").should == true
+    Erlectricity::TypeCondition.new(Array).satisfies?([]).should == true
+    Erlectricity::TypeCondition.new(Fixnum).satisfies?(3).should == true
+  end
+  
+  specify "should be satisfied when the arg is of a descendent class" do
+    Erlectricity::TypeCondition.new(Object).satisfies?(:foo).should == true
+    Erlectricity::TypeCondition.new(Object).satisfies?("foo").should == true
+    Erlectricity::TypeCondition.new(Object).satisfies?(3).should == true
+  end
+  
+  specify "should not be satisfied when the arg is of a different class" do
+    Erlectricity::TypeCondition.new(String).satisfies?(:foo).should == false
+    Erlectricity::TypeCondition.new(Symbol).satisfies?("foo").should == false
+    Erlectricity::TypeCondition.new(Fixnum).satisfies?(3.0).should == false
+  end
+  
+  specify "should bind the arg to the name specified with no transormations" do
+    s = Erlectricity::TypeCondition.new(Symbol, :bound_name)
+    s.bindings_for(:foo).should == {:bound_name => :foo}
+    s.bindings_for(:bar).should == {:bound_name => :bar}
+  end
+  
+  specify "should not bind anything if no binding name is specified" do
+    
+    s = Erlectricity::TypeCondition.new(Symbol)
+    s.bindings_for(:foo).should == {}
+  end
+end
+
+context "Erlectricity::HashConditions" do
+  specify "should satisfy an args of the form [[key, value], [key, value]]" do
+    Erlectricity::HashCondition.new.satisfies?([[:foo, 3], [:bar, Object.new]]).should == true
+    Erlectricity::HashCondition.new.satisfies?([[:foo, 3]]).should == true
+  end
+  
+  specify "should satisfy on empty arrays" do
+    Erlectricity::HashCondition.new.satisfies?([]).should == true
+  end
+  
+  specify "should nat satisfy other args" do
+     Erlectricity::HashCondition.new.satisfies?(:foo).should == false
+     Erlectricity::HashCondition.new.satisfies?("foo").should == false
+     Erlectricity::HashCondition.new.satisfies?(3.0).should == false
+  end
+  
+  specify "should product a binder" do
+    s = Erlectricity::HashCondition.new(:bound_name)
+    s.bindings_for([[:foo, 3], [:bar, [3,4,5]]]).should == {:bound_name => {:foo => 3, :bar => [3,4,5] }}
+  end
+end

data/test/decode_spec.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "The byte reader attached to decoder" do
+  specify "should not advance the stream when peeking unless there arent enough bytes available" do
+    @decoder = Erlectricity::Decoder.new(StringIO.new('abcdefghijklmnopqrstuvwxyz'))
+    100.times{ @decoder.peek_1.should == 'a'[0] }
+    100.times{ @decoder.peek_2.should == 'ab'.unpack("n").first }
+  end
+end
+
+context "When unpacking from a binary stream" do
+  setup do
+    @decoder = Erlectricity::Decoder.new(nil)
+  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
+  
+  def get(str)
+    bin = run_erl("term_to_binary(#{str})")
+    @decoder.in = StringIO.new(bin)
+    @decoder.read_any
+  end
+end

data/test/encode_spec.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "When packing to a binary stream" do
+  setup 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 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}")
+    get{@encoder.write_fixnum(-1)}.should == get_erl("-1")
+    get{@encoder.write_fixnum(-(1 << 27))}.should == get_erl("#{-(1 << 27)}")
+    write_any(256).should == get_erl_with_magic("256")
+    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 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})")
+  end
+end

data/test/matcher_spec.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+def false_match(matcher, arg)
+   matcher.matches?(arg).should == false
+end
+
+context "A matcher whose condition is Symbol (the class object)" do
+  setup do
+    @matcher = Erlectricity::Matcher.new(nil, Erlectricity::TypeCondition.new(Symbol), nil)
+  end
+  
+  specify "should match any symbol" do
+    @matcher.matches?(:foo).should == true
+    @matcher.matches?(:bar).should == true
+    @matcher.matches?(:baz).should == true
+  end
+  
+  specify "should not match strings" do
+    @matcher.matches?("foo").should == false
+    @matcher.matches?("bar").should == false
+    @matcher.matches?("baz").should == false
+  end
+  
+  specify "should not match a arrays" do
+    @matcher.matches?([:foo]).should == false
+    @matcher.matches?([:foo, :bar]).should == false
+    @matcher.matches?([:foo, :bar, :baz]).should == false
+  end
+end
+
+context "a matcher whose condition is a symbol" do
+  setup do
+    @matcher = Erlectricity::Matcher.new(nil, Erlectricity::StaticCondition.new(:foo), nil)
+  end
+  
+  specify "should match that symbol" do
+    @matcher.matches?(:foo).should == true
+  end
+  
+  specify "should not match any other symbol" do
+    @matcher.matches?(:bar).should == false
+    @matcher.matches?(:baz).should == false
+  end
+end
+
+context "a matcher whose matcher is an array" do
+  setup do
+  end
+  
+  specify "should match if all of its children match" do
+    Erlectricity::Matcher.new(nil, [Erlectricity::StaticCondition.new(:speak), Erlectricity::TypeCondition.new(Object)], nil).matches?([:paste, "haha"]).should == false
+    
+    matcher = Erlectricity::Matcher.new(nil, [Erlectricity::StaticCondition.new(:foo), Erlectricity::StaticCondition.new(:bar)], nil)
+    matcher.matches?([:foo, :bar]).should == true
+  end
+  
+  specify "should not match any of its children dont match" do
+    matcher = Erlectricity::Matcher.new(nil, [Erlectricity::StaticCondition.new(:foo), Erlectricity::StaticCondition.new(:bar)], nil)
+    matcher.matches?([:foo]).should == false
+    matcher.matches?([:foo, :bar, :baz]).should == false
+    matcher.matches?([:fooo, :barr]).should == false
+    matcher.matches?([3, :bar]).should == false
+  end
+  
+  specify "should not match if arg isn't an array" do
+    matcher = Erlectricity::Matcher.new(nil, [Erlectricity::StaticCondition.new(:foo), Erlectricity::StaticCondition.new(:bar)], nil)
+    matcher.matches?(:foo).should == false
+  end
+end
+
+context "a matcher" do
+  
+end

data/test/port_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "A port" do
+  specify "should return terms from the queue if it is not empty" do
+    port = FakePort.new()
+    port.queue.clear
+    port.queue << :foo << :bar
+    port.receive.should == :foo
+    port.receive.should == :bar
+    port.receive.should == nil
+  end
+  
+  specify "should read_from_input if the queue gets empty" do
+    port = FakePort.new(:bar)
+    port.queue.clear
+    port.queue << :foo
+    port.receive.should == :foo
+    port.receive.should == :bar
+    port.receive.should == nil
+  end
+  
+  specify "should put the terms in skipped at the front of queue when restore_skipped is called" do
+    port = FakePort.new(:baz)
+    port.queue.clear
+    port.queue << :bar
+    port.skipped << :foo
+    port.restore_skipped
+    
+    port.receive.should == :foo
+    port.receive.should == :bar
+    port.receive.should == :baz
+    port.receive.should == nil
+    
+  end
+end

data/test/receiver_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+def simple_receiver_and_port(*terms, &block)
+  port = FakePort.new(*terms)
+  receiver = if block
+      Erlectricity::Receiver.new(port, &block)
+    else
+      Erlectricity::Receiver.new(port) do
+        match(any) do
+          :matched
+        end
+      end
+    end
+end
+
+
+context "When a receiver is passed a message that matches two match blocks it" do
+  setup do
+    @port = FakePort.new([:foo, :foo])
+    @receiver = Erlectricity::Receiver.new(@port) do
+      match(:foo, :foo) do
+        :first
+      end
+      
+      match(:foo, any) do
+        :second
+      end
+    end
+  end
+  
+  specify "should run the first matching receiver's block" do
+    @receiver.run.should == :first
+  end
+end
+
+context "A receiver" do
+  specify "should return the result of the match block when finished" do
+    simple_receiver_and_port(:foo).run.should == :matched
+    simple_receiver_and_port(:bar).run.should == :matched
+    simple_receiver_and_port(:bar, :baz).run.should == :matched
+  end
+  
+  specify "should process another message if the matched block returns the results of receive_loop" do
+    recv = simple_receiver_and_port(:foo, :bar, :baz) do
+      match(:bar) {  }
+      match(any) { receive_loop }
+    end
+    
+    recv.run
+    recv.port.terms.should == [:baz]
+  end
+  
+  specify "should properly nest" do
+    @port = FakePort.new(:foo, :bar, :baz)
+    @receiver = Erlectricity::Receiver.new(@port) do
+      match(:foo) do
+        receive do
+          match(:bar){ :ok }
+        end
+        receive_loop  
+      end
+      
+      match(:baz) do
+        :done
+      end
+    end
+    
+    @receiver.run.should == :done
+    @port.terms.should == []
+  end
+  
+  specify "should queue up skipped results and restore them when a match happens" do
+    @port = FakePort.new(:foo, :baz, :bar)
+    @receiver = Erlectricity::Receiver.new(@port) do
+      match(:foo) do
+        receive do
+          match(:bar){ :ok }
+        end
+        receive_loop  
+      end
+      
+      match(:baz) do
+        :done
+      end
+    end
+    
+    @receiver.run.should == :done
+    @port.terms.should == []  
+  end
+  
+  specify "should expose bindings to the matched block" do
+    @port = FakePort.new(:foo, :bar, :baz)
+    results = []
+    @receiver = Erlectricity::Receiver.new(@port) do
+      match(atom(:bindinated)) do
+        results << bindinated
+        receive_loop  
+      end
+    end
+    
+    @receiver.run.should == nil
+    results.should == [:foo, :bar, :baz]
+  end
+
+end

data/test/spec_suite.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+Dir[File.dirname(__FILE__) + '/*_spec.rb'].each{ |f| require f}

data/test/test_erlectricity.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+

data/test/test_helper.rb

@@ -0,0 +1,36 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'rubygems'
+require 'test/unit'
+require 'test/spec'
+require 'erlectricity'
+
+class Test::Unit::TestCase
+  
+  def run_erl(code)
+    `erl -noshell -eval 'A = #{code.split.join(' ')}, io:put_chars(A).' -s erlang halt`
+  end
+  
+  def word_length
+    (1.size * 8) - 2
+  end
+end
+
+class FakePort < Erlectricity::Port
+  attr_reader :sent
+  attr_reader :terms
+  
+  def initialize(*terms)
+    @terms = terms
+    @sent = []
+    super(StringIO.new(""), StringIO.new(""))
+  end
+
+  def send(term)
+    sent << term
+  end
+  
+  private
+  def read_from_input
+    @terms.shift
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: erlectricity
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-05-08 00:00:00 -07:00
+summary: A library to interface erlang and ruby through the erlang port system
+require_paths: 
+- lib
+email: nullstyle@gmail.com
+homepage: http://erlectricity.rubyforge.org
+rubyforge_project: erlectricity
+description: A library to interface erlang and ruby through the erlang port system
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Scott Fleckenstein
+files: 
+- Manifest.txt
+- README.txt
+- Rakefile
+- examples/gruff/gruff.erl
+- examples/gruff/gruff_provider.rb
+- examples/gruff/gruff_run.erl
+- examples/gruff/stat_run.erl
+- examples/gruff/stat_writer.erl
+- examples/tinderl/tinderl.erl
+- examples/tinderl/tinderl.rb
+- lib/erlectricity.rb
+- lib/erlectricity/condition.rb
+- lib/erlectricity/conditions/hash.rb
+- lib/erlectricity/conditions/static.rb
+- lib/erlectricity/conditions/type.rb
+- lib/erlectricity/constants.rb
+- lib/erlectricity/decoder.rb
+- lib/erlectricity/encoder.rb
+- lib/erlectricity/errors/decode_error.rb
+- lib/erlectricity/errors/encode_error.rb
+- lib/erlectricity/errors/erlectricity_error.rb
+- lib/erlectricity/match_context.rb
+- lib/erlectricity/matcher.rb
+- lib/erlectricity/port.rb
+- lib/erlectricity/receiver.rb
+- lib/erlectricity/types/function.rb
+- lib/erlectricity/types/new_function.rb
+- lib/erlectricity/types/new_reference.rb
+- lib/erlectricity/types/pid.rb
+- lib/erlectricity/types/reference.rb
+- lib/erlectricity/version.rb
+- setup.rb
+- test/condition_spec.rb
+- test/decode_spec.rb
+- test/encode_spec.rb
+- test/matcher_spec.rb
+- test/port_spec.rb
+- test/receiver_spec.rb
+- test/spec_suite.rb
+- test/test_erlectricity.rb
+- test/test_helper.rb
+test_files: 
+- test/test_erlectricity.rb
+- test/test_helper.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+