mojombo-erlectricity 0.2.1 → 1.0.0

data/lib/erlectricity/port.rb

@@ -3,44 +3,44 @@ module Erlectricity
     attr_reader :input, :output
     attr_reader :skipped
     attr_reader :queue
-  
+
     def initialize(input=STDIN, output=STDOUT)
       @input = input
       @output = output
-    
+
       input.sync = true
       output.sync = true
-    
+
       @encoder = Erlectricity::Encoder.new(nil)
       @skipped = []
       @queue = []
     end
-  
+
     def receive
       queue.empty? ? read_from_input : queue.shift
     end
-  
+
     def send(term)
       @encoder.out = StringIO.new('', 'w')
       @encoder.write_any(term)
       data = @encoder.out.string
       output.write([data.length].pack("N"))
-      output.write data
+      output.write(data)
     end
-  
+
     def restore_skipped
       @queue = self.skipped + self.queue
     end
-  
+
     private
+
     def read_from_input
       raw = input.read(4)
       return nil unless raw
-    
+
       packet_length = raw.unpack('N').first
       data = input.read(packet_length)
-      result = Erlectricity::Decoder.read_any_from(data)
-      result
+      Erlectricity::Decoder.decode(data)
     end
   end
 end

data/lib/erlectricity/receiver.rb

@@ -1,79 +1,69 @@
 module Erlectricity
-class Receiver
-  
-  attr_accessor :port
-  attr_accessor :parent
-  attr_accessor :matchers
-  
-  RECEIVE_LOOP = Object.new
-  NO_MATCH = Object.new
-  
-  def initialize(port, parent=nil, &block)
-    @port = port
-    @parent = parent
-    @matchers = []
-    block.call self if block
-  end
-  
-  def process(arg)
-    matcher = @matchers.find{|r| r.matches? arg}
+  class Receiver
+    attr_accessor :port
+    attr_accessor :parent
+    attr_accessor :matchers
+
+    RECEIVE_LOOP = Object.new
+    NO_MATCH = Object.new
 
-    if(matcher)      
-      port.restore_skipped
-      matcher.run arg
-    else
-      NO_MATCH
+    def initialize(port, parent = nil, &block)
+      @port = port
+      @parent = parent
+      @matchers = []
+      block.call(self) if block
     end
-  end
-  
-  def when(*args, &block)
-    args = args.map do |a| 
-      case a
-      when Condition then a 
-      when Class then TypeCondition.new(a)
-      else StaticCondition.new(a)
+
+    def process(arg)
+      matcher = @matchers.find { |r| r.matches?(arg) }
+
+      if matcher
+        port.restore_skipped
+        matcher.run(arg)
+      else
+        NO_MATCH
       end
     end
-    
-    args = args.first if args.length == 1
-    @matchers << Matcher.new(self, args, block)
-  end
-  
-  def run
-    
-    loop do
-      msg = port.receive
-      return if msg.nil?
-      
-      case result = process(msg)
-      when RECEIVE_LOOP then next
-      when NO_MATCH
-        port.skipped << msg
-        next
-      else
-        break result
+
+    def when(arg, &block)
+      condition = Condition.for(arg)
+      @matchers << Matcher.new(self, condition, block)
+    end
+
+    def run
+      loop do
+        msg = port.receive
+        return if msg.nil?
+
+        case result = process(msg)
+          when RECEIVE_LOOP then next
+          when NO_MATCH
+            port.skipped << msg
+            next
+          else
+            break result
+        end
       end
     end
-  end
-  
-  def receive(&block)
-    Receiver.new(port, self, &block).run
-  end
 
-  def receive_loop
-    RECEIVE_LOOP
-  end
-  
-  def send!(*term)
-    term = term.first if term.length == 1
-    port.send(term)
+    def receive(&block)
+      Receiver.new(port, self, &block).run
+    end
+
+    def receive_loop
+      RECEIVE_LOOP
+    end
+
+    def send!(term)
+      port.send(term)
+    end
   end
 end
-end
-
 
 module Kernel
-  def receive(input=STDIN, output=STDOUT, &block)
+  def receive(input = nil, output = nil, &block)
+    input ||= IO.new(3)
+    output ||= IO.new(4)
     Erlectricity::Receiver.new(Erlectricity::Port.new(input, output), nil, &block).run
   end
 end

data/lib/erlectricity/types/list.rb

@@ -1 +1,3 @@
-class Erlectricity::List < Array ; end
+class Erlectricity::List < Array
+
+end

data/lib/erlectricity.rb

@@ -1,19 +1,18 @@
 $:.unshift File.join(File.dirname(__FILE__), *%w[.. ext])
 
+require 'stringio'
 
 require 'erlectricity/constants'
-
 require 'erlectricity/types/new_reference'
 require 'erlectricity/types/pid'
 require 'erlectricity/types/function'
 require 'erlectricity/types/list'
 
-
 begin
-  #try to load the decoder C extension
+  # try to load the decoder C extension
   require 'decoder'
 rescue LoadError
-  #load the pure ruby instead
+  # fall back on the pure ruby version
   require 'erlectricity/decoder'
 end
 
@@ -21,14 +20,12 @@ 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'
-
 require 'erlectricity/receiver'
-
 require 'erlectricity/errors/erlectricity_error'
 require 'erlectricity/errors/decode_error'
 require 'erlectricity/errors/encode_error'

data/test/condition_spec.rb

@@ -6,14 +6,14 @@ context "Erlectricity::StaticConditions" do
     Erlectricity::StaticCondition.new([:foo]).satisfies?([:foo]).should == true
     Erlectricity::StaticCondition.new(3).satisfies?(3).should == true
   end
-  
+
   specify "should not satisfy on different 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" do
     s = Erlectricity::StaticCondition.new(:foo)
     s.binding_for(:foo).should == nil
@@ -29,25 +29,24 @@ context "Erlectricity::TypeConditions" do
     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 with no transormations" do
     s = Erlectricity::TypeCondition.new(Symbol)
     s.binding_for(:foo).should == :foo
     s.binding_for(:bar).should == :bar
   end
-
 end
 
 context "Erlectricity::HashConditions" do
@@ -55,17 +54,17 @@ context "Erlectricity::HashConditions" 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 bind to a Hash" do
     s = Erlectricity::HashCondition.new()
     s.binding_for([[:foo, 3], [:bar, [3,4,5]]]).should == {:foo => 3, :bar => [3,4,5] }

data/test/decode_spec.rb

@@ -3,127 +3,126 @@ 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
+    get("falsereio").should == :falsereio
+  end
+
   specify "a good thing should be awesome" 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)
+    Erlectricity::Decoder.decode(bin)
   end
 end

data/test/encode_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)
-    
+    ruby_ref = Erlectricity::Decoder.decode(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)
-    
+    ruby_pid = Erlectricity::Decoder.decode(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