erlectricity 0.2.1 → 1.0.0

data/lib/erlectricity/encoder.rb

@@ -1,56 +1,69 @@
 module Erlectricity
-class Encoder
+  class Encoder
     include Erlectricity::External::Types
+
     attr_accessor :out
+
     def initialize(out)
       self.out = out
     end
-    
+
+    def self.encode(data)
+      io = StringIO.new
+      self.new(io).write_any(data)
+      io.string
+    end
+
     def write_any obj
       write_1 Erlectricity::External::VERSION
       write_any_raw obj
-
     end
-    
+
     def write_any_raw obj
       case obj
-      when Symbol then write_symbol(obj)
-      when Fixnum, Bignum then write_fixnum(obj)
-      when Float then write_float(obj)
-      when Erlectricity::NewReference then write_new_reference(obj)
-      when Erlectricity::Pid then write_pid(obj)
-      when Erlectricity::List then write_list(obj)
-      when Array then write_tuple(obj)
-      when String then write_binary(obj)
-      else
-        fail(obj)
+        when Symbol then write_symbol(obj)
+        when Fixnum, Bignum then write_fixnum(obj)
+        when Float then write_float(obj)
+        when Erlectricity::NewReference then write_new_reference(obj)
+        when Erlectricity::Pid then write_pid(obj)
+        when Erlectricity::List then write_list(obj)
+        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
     end
-    
+
     def write_1(byte)
       out.write([byte].pack("C"))
     end
-    
+
     def write_2(short)
       out.write([short].pack("n"))
     end
-    
+
     def write_4(long)
       out.write([long].pack("N"))
     end
-    
+
     def write_string(string)
       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
+      fail(sym) unless sym.is_a?(Symbol)
       data = sym.to_s
       write_1 ATOM
       write_2 data.length
       write_string data
     end
-    
+
     def write_fixnum(num)
       if num >= 0 && num < 256
         write_1 SMALL_INT
@@ -62,25 +75,25 @@ class Encoder
         write_bignum num
       end
     end
-    
+
     def write_float(float)
       write_1 FLOAT
       write_string format("%15.15e", float).ljust(31, "\000")
     end
-    
+
     def write_bignum(num)
       fail(num)
     end
-    
+
     def write_new_reference(ref)
-      fail(ref) unless ref.is_a? Erlectricity::NewReference
+      fail(ref) unless ref.is_a?(Erlectricity::NewReference)
       write_1 NEW_REF
       write_2 ref.id.length
       write_symbol(ref.node)
       write_1 ref.creation
       write_string ref.id.pack('N' * ref.id.length)
     end
-    
+
     def write_pid(pid)
       fail(pid) unless pid.is_a? Erlectricity::Pid
       write_1 PID
@@ -89,9 +102,10 @@ class Encoder
       write_4 pid.serial
       write_1 pid.creation
     end
-    
+
     def write_tuple(data)
       fail(data) unless data.is_a? Array
+
       if data.length < 256
         write_1 SMALL_TUPLE
         write_1 data.length
@@ -99,29 +113,29 @@ class Encoder
         write_1 LARGE_TUPLE
         write_4 data.length
       end
-      
-      data.each{|e| write_any_raw e }
+
+      data.each { |e| write_any_raw e }
     end
-    
+
     def write_list(data)
       fail(data) unless data.is_a? Array
       write_1 NIL and return if data.empty?
-      
       write_1 LIST
       write_4 data.length
       data.each{|e| write_any_raw e }
       write_1 NIL
     end
-    
+
     def write_binary(data)
       write_1 BIN
       write_4 data.length
       write_string data
     end
-    
+
     private
+
     def fail(obj)
-      raise EncodeError, "Cannot encode to erlang external format: #{obj.inspect}"              
+      raise EncodeError, "Cannot encode to erlang external format: #{obj.inspect}"
     end
   end
-end
+end

data/lib/erlectricity/errors/decode_error.rb

@@ -1,3 +1,3 @@
 class DecodeError < ErlectricityError
-  
+
 end

data/lib/erlectricity/errors/encode_error.rb

@@ -1,3 +1,3 @@
 class EncodeError < ErlectricityError
-  
+
 end

data/lib/erlectricity/errors/erlectricity_error.rb

@@ -1,3 +1,3 @@
 class ErlectricityError < StandardError
-  
+
 end

data/lib/erlectricity/matcher.rb

@@ -1,38 +1,21 @@
 module Erlectricity
-class Matcher
-  attr_accessor :condition, :block
-  attr_accessor :receiver
-  
-  def initialize(parent, condition, block)
-    self.receiver = parent
-    @block = block
-    @condition = condition
-  end
-  
-  def run(arg)
-    args = get_bound arg
-    block.call *args
-  end
-  
-  def matches?(arg)
-    if @condition.is_a?(Array)
-      return false unless arg.is_a?(Array)
-      return false if @condition.length != arg.length
-      @condition.zip(arg).all?{|l,r| l.satisfies?(r)}
-    else
-      @condition.satisfies?(arg)
+  class Matcher
+    attr_accessor :condition, :block
+    attr_accessor :receiver
+
+    def initialize(parent, condition, block)
+      self.receiver = parent
+      @block = block
+      @condition = Condition.for(condition)
+    end
+
+    def run(arg)
+      args = @condition.binding_for(arg)
+      block.call(*args)
     end
-  end
-  
 
-  private
-  
-  def get_bound(arg)
-    if @condition.is_a?(Array) && arg.is_a?(Array)
-      @condition.zip(arg).map{|l,r| l.binding_for r}.compact
-    else
-      @condition.binding_for(arg)
+    def matches?(arg)
+      @condition.satisfies?(arg)
     end
   end
 end
-end

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/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] }