beambridge 0.9.0

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/beambridge.rb

@@ -0,0 +1,34 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. ext])
+
+require 'stringio'
+
+require 'beambridge/version'
+require 'beambridge/constants'
+require 'beambridge/types/new_reference'
+require 'beambridge/types/pid'
+require 'beambridge/types/function'
+require 'beambridge/types/list'
+
+begin
+  # try to load the decoder C extension
+  require 'decoder'
+rescue LoadError
+  # fall back on the pure ruby version
+  require 'beambridge/decoder'
+end
+
+require 'beambridge/encoder'
+
+require 'beambridge/port'
+require 'beambridge/matcher'
+require 'beambridge/condition'
+require 'beambridge/conditions/boolean'
+require 'beambridge/conditions/hash'
+require 'beambridge/conditions/static'
+require 'beambridge/conditions/type'
+require 'beambridge/receiver'
+require 'beambridge/errors/beambridge_error'
+require 'beambridge/errors/decode_error'
+require 'beambridge/errors/encode_error'
+
+Erl = Beambridge

data/lib/beambridge/condition.rb

@@ -0,0 +1,66 @@
+module Beambridge
+  class Condition
+    def self.for(a)
+      case a
+        when Condition then a
+        when Class then TypeCondition.new(a)
+        else StaticCondition.new(a)
+      end
+    end
+
+    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(Beambridge::Pid)
+    end
+
+    def ref
+      TypeCondition.new(Beambridge::NewReference)
+    end
+
+    def string
+      TypeCondition.new(String)
+    end
+
+    def list
+      TypeCondition.new(Array)
+    end
+
+    def hash
+      HashCondition.new()
+    end
+
+    def boolean
+      BooleanCondition.new()
+    end
+  end
+
+  extend Conditions
+end
+
+Any = Object

data/lib/beambridge/conditions/boolean.rb

@@ -0,0 +1,11 @@
+module Beambridge
+  class BooleanCondition < Condition
+    def satisfies?(arg)
+      [TrueClass, FalseClass].include?(arg.class)
+    end
+
+    def binding_for(arg)
+      arg
+    end
+  end
+end

data/lib/beambridge/conditions/hash.rb

@@ -0,0 +1,13 @@
+module Beambridge
+  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/beambridge/conditions/static.rb

@@ -0,0 +1,34 @@
+module Beambridge
+  class StaticCondition < Condition
+    attr_accessor :value
+    def initialize(value)
+      if value.is_a?(Array)
+        self.value = value.map do |v|
+          Condition.for(v)
+        end
+      else
+        self.value = value
+      end
+    end
+
+    def satisfies?(arg)
+      if value.is_a?(Array)
+        return false unless arg.is_a?(Array)
+        return false if value.length != arg.length
+        value.zip(arg).all? do |l, r|
+          l.respond_to?(:satisfies?) ? l.satisfies?(r) : l.eql?(r)
+        end
+      else
+        arg.eql?(value)
+      end
+    end
+
+    def binding_for(arg)
+      if value.is_a?(Array)
+        value.zip(arg).map { |l, r| l.binding_for(r) }.compact
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/beambridge/conditions/type.rb

@@ -0,0 +1,17 @@
+module Beambridge
+  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/beambridge/constants.rb

@@ -0,0 +1,36 @@
+module Beambridge
+  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/beambridge/decoder.rb

@@ -0,0 +1,212 @@
+module Beambridge
+  class Decoder
+    attr_accessor :in
+    include Beambridge::External::Types
+
+    def self.decode(string)
+      new(StringIO.new(string)).read_any
+    end
+
+    def initialize(ins)
+      @in = ins
+      @peeked = ""
+    end
+
+    def read_any
+      fail("Bad Magic") unless read_1 == Beambridge::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
+        when ""
+          Marshal.load("\004\b:\005") # Workaround for inability to do ''.to_sym
+        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
+      Beambridge::List.new([])
+    end
+
+    def read_erl_string
+      fail("Invalid Type, not an erlang string") unless read_1 == STRING
+      length = read_2
+      Beambridge::List.new(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
+      Beambridge::List.new(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/beambridge/encoder.rb

@@ -0,0 +1,164 @@
+module Beambridge
+  class Encoder
+    include Beambridge::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 Beambridge::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 Beambridge::NewReference then write_new_reference(obj)
+        when Beambridge::Pid then write_pid(obj)
+        when Beambridge::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)
+      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 <= Beambridge::External::MAX_INT && num >= Beambridge::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)
+      if num.is_a?(Bignum)
+        n = num.size
+      else
+        n = (num.to_s(2).size / 8.0).ceil
+      end
+      if n <= 256
+        write_1 SMALL_BIGNUM
+        write_1 n
+        write_bignum_guts(num)
+      else
+        write_1 LARGE_BIGNUM
+        write_4 n
+        write_bignum_guts(num)
+      end
+    end
+
+    def write_bignum_guts(num)
+      write_1 (num >= 0 ? 0 : 1)
+      num = num.abs
+      while num != 0
+        rem = num % 256
+        write_1 rem
+        num = num >> 8
+      end
+    end
+
+    def write_new_reference(ref)
+      fail(ref) unless ref.is_a?(Beambridge::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? Beambridge::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.bytesize
+      write_string data
+    end
+
+    private
+
+    def fail(obj)
+      raise EncodeError, "Cannot encode to erlang external format: #{obj.inspect}"
+    end
+  end
+end