mojombo-erlectricity 0.2.1 → 1.0.0

data/lib/erlectricity/constants.rb

@@ -11,7 +11,7 @@ module Erlectricity
 
       ATOM = 100
       REF = 101           #old style reference
-      NEW_REF = 114     
+      NEW_REF = 114
       PORT = 102          #not supported accross node boundaries
       PID = 103
 
@@ -22,16 +22,15 @@ module Erlectricity
       STRING = 107
       LIST = 108
       BIN = 109
-      
+
       FUN = 117
       NEW_FUN = 112
     end
 
     VERSION = 131
-    
+
     MAX_INT = (1 << 27) -1
     MIN_INT = -(1 << 27)
     MAX_ATOM = 255
   end
-
 end

data/lib/erlectricity/decoder.rb

@@ -1,204 +1,210 @@
 module Erlectricity
-class Decoder
-  attr_accessor :in
-  include Erlectricity::External::Types
-  
-  def self.read_any_from(string)
-    new(StringIO.new(string)).read_any
-  end
-  
-  def initialize(ins)
-    @in = ins
-    @peeked = ""
-  end
-  
-  def read_any
-    fail("Bad Magic") unless read_1 == Erlectricity::External::VERSION
-    read_any_raw
-  end
-  
-  def read_any_raw
-    case peek_1
-    when ATOM then read_atom
-    when SMALL_INT then read_small_int
-    when INT then read_int
-    when SMALL_BIGNUM then read_small_bignum
-    when LARGE_BIGNUM then read_large_bignum
-    when FLOAT then read_float
-    when NEW_REF then read_new_reference
-    when PID then read_pid
-    when SMALL_TUPLE then read_small_tuple
-    when LARGE_TUPLE then read_large_tuple
-    when NIL then read_nil
-    when STRING then read_erl_string
-    when LIST then read_list
-    when BIN then read_bin
-    else
-      fail("Unknown term tag: #{peek_1}")      
+  class Decoder
+    attr_accessor :in
+    include Erlectricity::External::Types
+
+    def self.decode(string)
+      new(StringIO.new(string)).read_any
     end
-  end
-  
-  def read(length)
-    if length < @peeked.length
-      result = @peeked[0...length]
-      @peeked = @peeked[length..-1]
-      length = 0
-    else
-      result = @peeked
-      @peeked = ''
-      length -= result.length
-    end
-    
-    if length > 0
-      result << @in.read(length)
-    end
-    result
-  end
-  
-  def peek(length)
-    if length <= @peeked.length
-      @peeked[0...length]
-    else
-      read_bytes = @in.read(length - @peeked.length)    
-      @peeked << read_bytes if read_bytes
-      @peeked
+
+    def initialize(ins)
+      @in = ins
+      @peeked = ""
+    end
+
+    def read_any
+      fail("Bad Magic") unless read_1 == Erlectricity::External::VERSION
+      read_any_raw
+    end
+
+    def read_any_raw
+      case peek_1
+        when ATOM then read_atom
+        when SMALL_INT then read_small_int
+        when INT then read_int
+        when SMALL_BIGNUM then read_small_bignum
+        when LARGE_BIGNUM then read_large_bignum
+        when FLOAT then read_float
+        when NEW_REF then read_new_reference
+        when PID then read_pid
+        when SMALL_TUPLE then read_small_tuple
+        when LARGE_TUPLE then read_large_tuple
+        when NIL then read_nil
+        when STRING then read_erl_string
+        when LIST then read_list
+        when BIN then read_bin
+        else
+          fail("Unknown term tag: #{peek_1}")
+      end
+    end
+
+    def read(length)
+      if length < @peeked.length
+        result = @peeked[0...length]
+        @peeked = @peeked[length..-1]
+        length = 0
+      else
+        result = @peeked
+        @peeked = ''
+        length -= result.length
+      end
+
+      if length > 0
+        result << @in.read(length)
+      end
+      result
+    end
+
+    def peek(length)
+      if length <= @peeked.length
+        @peeked[0...length]
+      else
+        read_bytes = @in.read(length - @peeked.length)
+        @peeked << read_bytes if read_bytes
+        @peeked
+      end
+    end
+
+    def peek_1
+      peek(1).unpack("C").first
+    end
+
+    def peek_2
+      peek(2).unpack("n").first
+    end
+
+    def read_1
+      read(1).unpack("C").first
+    end
+
+    def read_2
+      read(2).unpack("n").first
+    end
+
+    def read_4
+      read(4).unpack("N").first
+    end
+
+    def read_string(length)
+      read(length)
+    end
+
+    def read_atom
+      fail("Invalid Type, not an atom") unless read_1 == ATOM
+      length = read_2
+      a = read_string(length)
+      case a
+        when "true"
+          true
+        when "false"
+          false
+        else
+          a.to_sym
+      end
+    end
+
+    def read_small_int
+      fail("Invalid Type, not a small int") unless read_1 == SMALL_INT
+      read_1
+    end
+
+    def read_int
+      fail("Invalid Type, not an int") unless read_1 == INT
+      value = read_4
+      negative = (value >> 31)[0] == 1
+      value = (value - (1 << 32)) if negative
+      value = Fixnum.induced_from(value)
+    end
+
+    def read_small_bignum
+      fail("Invalid Type, not a small bignum") unless read_1 == SMALL_BIGNUM
+      size = read_1
+      sign = read_1
+      bytes = read_string(size).unpack("C" * size)
+      added = bytes.zip((0..bytes.length).to_a).inject(0) do |result, byte_index|
+        byte, index = *byte_index
+        value = (byte * (256 ** index))
+        sign != 0 ? (result - value) : (result + value)
+      end
+      Bignum.induced_from(added)
+    end
+
+    def read_large_bignum
+      fail("Invalid Type, not a large bignum") unless read_1 == LARGE_BIGNUM
+      size = read_4
+      sign = read_1
+      bytes = read_string(size).unpack("C" * size)
+      added = bytes.zip((0..bytes.length).to_a).inject(0) do |result, byte_index|
+        byte, index = *byte_index
+        value = (byte * (256 ** index))
+        sign != 0 ? (result - value) : (result + value)
+      end
+      Bignum.induced_from(added)
+    end
+
+    def read_float
+      fail("Invalid Type, not a float") unless read_1 == FLOAT
+      string_value = read_string(31)
+      result = string_value.to_f
+    end
+
+    def read_new_reference
+      fail("Invalid Type, not a new-style reference") unless read_1 == NEW_REF
+      size = read_2
+      node = read_atom
+      creation = read_1
+      id = (0...size).map { |i| read_4 }
+      NewReference.new(node, creation, id)
+    end
+
+    def read_pid
+      fail("Invalid Type, not a pid") unless read_1 == PID
+      node = read_atom
+      id = read_4
+      serial = read_4
+      creation = read_1
+      Pid.new(node, id, serial, creation)
+    end
+
+    def read_small_tuple
+      fail("Invalid Type, not a small tuple") unless read_1 == SMALL_TUPLE
+      arity = read_1
+      (0...arity).map { |i| read_any_raw }
+    end
+
+    def read_large_tuple
+      fail("Invalid Type, not a small tuple") unless read_1 == LARGE_TUPLE
+      arity = read_4
+      (0...arity).map { |i| read_any_raw }
+    end
+
+    def read_nil
+      fail("Invalid Type, not a nil list") unless read_1 == NIL
+      []
+    end
+
+    def read_erl_string
+      fail("Invalid Type, not an erlang string") unless read_1 == STRING
+      length = read_2
+      read_string(length).unpack('C' * length)
+    end
+
+    def read_list
+      fail("Invalid Type, not an erlang list") unless read_1 == LIST
+      length = read_4
+      list = (0...length).map { |i| read_any_raw }
+      read_1
+      list
+    end
+
+    def read_bin
+      fail("Invalid Type, not an erlang binary") unless read_1 == BIN
+      length = read_4
+      read_string(length)
+    end
+
+    def fail(str)
+      raise DecodeError, str
     end
   end
-  
-  def peek_1
-    peek(1).unpack("C").first
-  end
-  
-  def peek_2
-    peek(2).unpack("n").first
-  end
-  
-  def read_1
-    read(1).unpack("C").first
-  end
-  
-  def read_2
-    read(2).unpack("n").first
-  end
- 
-  def read_4
-    read(4).unpack("N").first
-  end
-  
-  def read_string(length)
-    read(length)
-  end
-  
-  def read_atom
-    fail("Invalid Type, not an atom") unless read_1 == ATOM
-    length = read_2
-    read_string(length).to_sym
-  end
-  
-  def read_small_int
-    fail("Invalid Type, not a small int") unless read_1 == SMALL_INT
-    read_1
-  end
-  
-  def read_int
-    fail("Invalid Type, not an int") unless read_1 == INT
-    value = read_4
-    negative = (value >> 31)[0] == 1
-    value = (value - (1 << 32)) if negative
-    value = Fixnum.induced_from(value)
-  end
-  
-  def read_small_bignum
-    fail("Invalid Type, not a small bignum") unless read_1 == SMALL_BIGNUM
-    size = read_1
-    sign = read_1
-    bytes = read_string(size).unpack("C" * size)
-    added = bytes.zip((0..bytes.length).to_a).inject(0) do |result, byte_index| 
-      byte, index = *byte_index
-      value = (byte * (256 ** index))
-      sign != 0 ? (result - value) : (result + value) 
-    end
-    Bignum.induced_from(added)
-  end
-  
-  def read_large_bignum
-    fail("Invalid Type, not a large bignum") unless read_1 == LARGE_BIGNUM
-    size = read_4
-    sign = read_1
-    bytes = read_string(size).unpack("C" * size)
-    added = bytes.zip((0..bytes.length).to_a).inject(0) do |result, byte_index| 
-      byte, index = *byte_index
-      value = (byte * (256 ** index))
-      sign != 0 ? (result - value) : (result + value) 
-    end
-    Bignum.induced_from(added)
-  end
-  
-  def read_float
-    fail("Invalid Type, not a float") unless read_1 == FLOAT
-    string_value = read_string(31)
-    result = string_value.to_f
-  end
-  
-  def read_new_reference
-    fail("Invalid Type, not a new-style reference") unless read_1 == NEW_REF
-    size = read_2
-    node = read_atom
-    creation = read_1
-    id = (0...size).map{|i| read_4 }
-    NewReference.new(node, creation, id)
-  end
-  
-  def read_pid
-    fail("Invalid Type, not a pid") unless read_1 == PID
-    node = read_atom
-    id = read_4
-    serial = read_4
-    creation = read_1
-    Pid.new(node, id, serial, creation)
-  end
-  
-  def read_small_tuple
-    fail("Invalid Type, not a small tuple") unless read_1 == SMALL_TUPLE
-    arity = read_1
-    
-    (0...arity).map{|i| read_any_raw }
-  end
-  
-  def read_large_tuple
-    fail("Invalid Type, not a small tuple") unless read_1 == LARGE_TUPLE
-    arity = read_4
-    (0...arity).map{|i| read_any_raw}
-  end
-  
-  def read_nil
-    fail("Invalid Type, not a nil list") unless read_1 == NIL
-    []
-  end
-  
-  def read_erl_string
-    fail("Invalid Type, not an erlang string") unless read_1 == STRING
-    length = read_2
-    read_string(length).unpack('C' * length)
-  end
-  
-  def read_list
-    fail("Invalid Type, not an erlang list") unless read_1 == LIST
-    length = read_4
-    list = (0...length).map{|i| read_any_raw}
-    read_1
-    list
-  end
-  
-  def read_bin
-    fail("Invalid Type, not an erlang binary") unless read_1 == BIN
-    length = read_4
-    read_string(length)
-  end
-  
-  def fail(str)
-    raise DecodeError, str
-  end
-  
 end
-end

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