erlectricity-funbox 1.1.2

data/lib/erlectricity/encoder.rb

@@ -0,0 +1,164 @@
+module Erlectricity
+  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)
+        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 <= 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)
+      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?(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.respond_to?(:bytesize) ? data.bytesize : data.length
+      write_string data
+    end
+
+    private
+
+    def fail(obj)
+      raise EncodeError, "Cannot encode to erlang external format: #{obj.inspect}"
+    end
+  end
+end

data/lib/erlectricity/errors/decode_error.rb

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

data/lib/erlectricity/errors/encode_error.rb

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

data/lib/erlectricity/errors/erlectricity_error.rb

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

data/lib/erlectricity/matcher.rb

@@ -0,0 +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.for(condition)
+    end
+
+    def run(arg)
+      args = @condition.binding_for(arg)
+      block.call(*args)
+    end
+
+    def matches?(arg)
+      @condition.satisfies?(arg)
+    end
+  end
+end

data/lib/erlectricity/port.rb

@@ -0,0 +1,46 @@
+module Erlectricity
+  class Port
+    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)
+    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)
+      Erlectricity::Decoder.decode(data)
+    end
+  end
+end

data/lib/erlectricity/receiver.rb

@@ -0,0 +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) }
+
+      if matcher
+        port.restore_skipped
+        matcher.run(arg)
+      else
+        NO_MATCH
+      end
+    end
+
+    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
+
+    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
+
+module Kernel
+  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/function.rb

@@ -0,0 +1,3 @@
+module Erlectricity
+  Function = Struct.new :pid, :module, :index, :uniq, :free_vars
+end

data/lib/erlectricity/types/list.rb

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

data/lib/erlectricity/types/new_function.rb

@@ -0,0 +1,3 @@
+module Erlectricity
+  NewFunction = Struct.new :arity, :uniq, :index,:num_free, :module, :old_index, :old_uniq, :pid, :free_vars
+end

data/lib/erlectricity/types/new_reference.rb

@@ -0,0 +1,3 @@
+module Erlectricity
+  NewReference = Struct.new :node, :creation, :id
+end

data/lib/erlectricity/types/pid.rb

@@ -0,0 +1,3 @@
+module Erlectricity
+  Pid = Struct.new :node, :id, :serial, :creation
+end

data/lib/erlectricity/types/reference.rb

@@ -0,0 +1,3 @@
+module Erlectricity
+  Reference = Struct.new :node, :id, :creator
+end

data/lib/erlectricity/version.rb

@@ -0,0 +1,9 @@
+module Erlectricity #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/test/condition_spec.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "Erlectricity::StaticConditions" do
+  specify "should satisfy on the same value" do
+    Erlectricity::StaticCondition.new(:foo).satisfies?(:foo).should == true
+    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
+  end
+end
+
+context "Erlectricity::TypeConditions" do
+  specify "should be satisfied when the arg has the same class" do
+    Erlectricity::TypeCondition.new(Symbol).satisfies?(:foo).should == true
+    Erlectricity::TypeCondition.new(Symbol).satisfies?(:bar).should == true
+    Erlectricity::TypeCondition.new(String).satisfies?("foo").should == true
+    Erlectricity::TypeCondition.new(String).satisfies?("bar").should == true
+    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
+  specify "should satisfy an args of the form [[key, value], [key, value]]" 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] }
+  end
+end

data/test/decode_spec.rb

@@ -0,0 +1,145 @@
+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("[]").class.should == Erl::List
+    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\"").class.should == Erl::List
+    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 an erl::list" do
+    get("[3,4,256]").class.should == Erl::List
+    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"
+    get("<< 99,0,99 >>").should == "c\000c"
+  end
+
+  specify "the empty atom should decode to the empty symbol" do
+    empty_symbol = get("''")
+    empty_symbol.should.be.instance_of Symbol
+    empty_symbol.to_s.should == ""
+  end
+
+  specify "erlang atomic booleans should decode to ruby booleans" do
+    get("true").should == true
+    get("false").should == false
+    get("falsereio").should == :falsereio
+    get("t").should == :t
+    get("f").should == :f
+  end
+
+  specify "massive binaries should not overflow the stack" do
+    bin = [131,109,0,128,0,0].pack('c*') + ('a' * (8 * 1024 * 1024))
+    assert_equal (8 * 1024 * 1024), Erlectricity::Decoder.decode(bin).size
+  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.decode(bin)
+  end
+end