mojombo-erlectricity 0.2.1

data/ext/extconf.rb

@@ -0,0 +1,11 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'decoder'
+
+# The destination
+dir_config(extension_name)
+
+# Do the work
+create_makefile(extension_name)

data/lib/erlectricity.rb

@@ -0,0 +1,36 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. ext])
+
+
+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
+  require 'decoder'
+rescue LoadError
+  #load the pure ruby instead
+  require 'erlectricity/decoder'
+end
+
+require 'erlectricity/encoder'
+
+require 'erlectricity/port'
+require 'erlectricity/matcher'
+
+require 'erlectricity/condition'
+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'
+
+Erl = Erlectricity

data/lib/erlectricity/condition.rb

@@ -0,0 +1,51 @@
+module Erlectricity
+  class Condition
+  
+    def initialize
+    end
+  
+    def binding_for(arg)
+      nil
+    end
+  
+    def satisfies?(arg)
+      false
+    end
+    
+    alias === satisfies?
+  end
+
+  module Conditions
+    def atom()
+      TypeCondition.new(Symbol)
+    end
+  
+    def any()
+      TypeCondition.new(Object)
+    end
+  
+    def number()
+      TypeCondition.new(Fixnum)
+    end
+  
+    def pid()
+      TypeCondition.new(Erlectricity::Pid)
+    end
+  
+    def string()
+      TypeCondition.new(String)   
+    end
+  
+    def list()
+      TypeCondition.new(Array) 
+    end
+  
+    def hash()
+      HashCondition.new()
+    end
+  end
+  
+  extend Conditions
+end
+
+Any = Object

data/lib/erlectricity/conditions/hash.rb

@@ -0,0 +1,14 @@
+module Erlectricity
+class HashCondition < Condition
+
+  def satisfies?(arg)
+    return false unless arg.class == Array
+    arg.all?{|x| x.class == Array && x.length == 2}
+  end
+  
+  def binding_for(arg)
+    flattened = arg.inject([]){|memo, kv| memo + kv}
+    Hash[*flattened]
+  end
+end
+end

data/lib/erlectricity/conditions/static.rb

@@ -0,0 +1,13 @@
+module Erlectricity
+class StaticCondition < Condition
+  attr_accessor :value
+  def initialize(value)
+    self.value = value
+  end
+  
+  def satisfies?(arg)
+    arg.eql? value
+  end
+
+end
+end

data/lib/erlectricity/conditions/type.rb

@@ -0,0 +1,17 @@
+module Erlectricity
+class TypeCondition < Condition
+  attr_accessor :type
+  
+  def initialize(type)
+    self.type = type
+  end
+  
+  def satisfies?(arg)
+    arg.is_a? self.type
+  end
+  
+  def binding_for(arg)
+    arg
+  end
+end
+end

data/lib/erlectricity/constants.rb

@@ -0,0 +1,37 @@
+module Erlectricity
+  module External
+    module  Types
+      SMALL_INT = 97
+      INT = 98
+
+      SMALL_BIGNUM = 110
+      LARGE_BIGNUM = 111
+
+      FLOAT = 99
+
+      ATOM = 100
+      REF = 101           #old style reference
+      NEW_REF = 114     
+      PORT = 102          #not supported accross node boundaries
+      PID = 103
+
+      SMALL_TUPLE = 104
+      LARGE_TUPLE = 105
+
+      NIL = 106
+      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

@@ -0,0 +1,204 @@
+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}")      
+    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
+    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

@@ -0,0 +1,127 @@
+module Erlectricity
+class Encoder
+    include Erlectricity::External::Types
+    attr_accessor :out
+    def initialize(out)
+      self.out = out
+    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)
+      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_symbol(sym)
+      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
+        write_1 num
+      elsif num <= Erlectricity::External::MAX_INT && num >= Erlectricity::External::MIN_INT
+        write_1 INT
+        write_4 num
+      else
+        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
+      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
+      write_symbol(pid.node)
+      write_4 pid.id
+      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
+      else
+        write_1 LARGE_TUPLE
+        write_4 data.length
+      end
+      
+      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}"              
+    end
+  end
+end