tmm1-erlectricity 0.2.1

data/CONTRIBUTORS

@@ -0,0 +1,2 @@
+Tom Preston-Werner
+  - provided the C extension that replaces the ruby decoder

data/History.txt

@@ -0,0 +1 @@
+

data/Manifest.txt

@@ -0,0 +1,45 @@
+CONTRIBUTORS
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+examples/gruff/gruff.erl
+examples/gruff/gruff_provider.rb
+examples/gruff/gruff_run.erl
+examples/gruff/stat_run.erl
+examples/gruff/stat_writer.erl
+examples/tinderl/tinderl.erl
+examples/tinderl/tinderl.rb
+ext/decoder.c
+ext/extconf.rb
+lib/erlectricity.rb
+lib/erlectricity/condition.rb
+lib/erlectricity/conditions/hash.rb
+lib/erlectricity/conditions/static.rb
+lib/erlectricity/conditions/type.rb
+lib/erlectricity/constants.rb
+lib/erlectricity/decoder.rb
+lib/erlectricity/encoder.rb
+lib/erlectricity/errors/decode_error.rb
+lib/erlectricity/errors/encode_error.rb
+lib/erlectricity/errors/erlectricity_error.rb
+lib/erlectricity/matcher.rb
+lib/erlectricity/port.rb
+lib/erlectricity/receiver.rb
+lib/erlectricity/types/function.rb
+lib/erlectricity/types/list.rb
+lib/erlectricity/types/new_function.rb
+lib/erlectricity/types/new_reference.rb
+lib/erlectricity/types/pid.rb
+lib/erlectricity/types/reference.rb
+lib/erlectricity/version.rb
+setup.rb
+test/condition_spec.rb
+test/decode_spec.rb
+test/encode_spec.rb
+test/matcher_spec.rb
+test/port_spec.rb
+test/receiver_spec.rb
+test/spec_suite.rb
+test/test_erlectricity.rb
+test/test_helper.rb

data/README.txt

@@ -0,0 +1,51 @@
+erlectricity
+  by Scott Fleckenstein
+     Tom Preston-Werner
+     
+     http://github.com/mojombo/erlectricity
+     
+== DESCRIPTION:
+
+Erlectricity allows a Ruby program to receive and respond to Erlang messages
+sent over the Erlang binary protocol.
+
+== INSTALL:
+
+$ gem install erlectricity
+
+-or-
+
+$ gem install mojombo-erlectricity -s http://gems.github.com
+
+== CONTRIBUTE:
+
+Contributions are welcome via GitHub! Fork the code from
+http://github.com/mojombo/erlectricity and send a pull request to mojombo.
+
+== USAGE (Ruby side):
+
+require 'rubygems'
+require 'erlectricity'
+
+receive do |f|
+  f.when(:echo, String) do |text|
+    f.send!(:result, "You said: #{text}")
+    f.receive_loop
+  end
+end
+
+== USAGE (Erlang side):
+
+-module(echo).
+-export([test/0]).
+
+test() ->
+  Cmd = "ruby echo.rb",
+  Port = open_port({spawn, Cmd}, [{packet, 4}, use_stdio, exit_status, binary]), 
+  Payload = term_to_binary({echo, <<"hello world!">>}),
+  port_command(Port, Payload),
+  receive
+    {Port, {data, Data}} ->
+      {result, Text} = binary_to_term(Data),
+      io:format("~p~n", [Text])
+  end.

data/Rakefile

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'erlectricity', 'version')
+
+AUTHOR = 'Scott Fleckenstein'  # can also be an array of Authors
+EMAIL = "nullstyle@gmail.com"
+DESCRIPTION = "A library to interface erlang and ruby through the erlang port system"
+GEM_NAME = 'erlectricity' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'erlectricity' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+NAME = "erlectricity"
+REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = Erlectricity::VERSION::STRING + (REV ? ".#{REV}" : "")
+CLEAN.include ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']
+RDOC_OPTS = ['--quiet', '--title', 'erlectricity documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject { |x| Array(x).first == 'hoe' } 
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  # p.extra_deps = [
+  #   ['concurrent', '0.2.2'],
+  # ]     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  p.spec_extras = {:extensions => ['ext/extconf.rb']}
+end
+
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :release]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end

data/examples/gruff/gruff.erl

@@ -0,0 +1,62 @@
+-module(gruff).
+-export([start/0, stop/0, plot/4]).
+
+start() -> 
+  spawn(fun() -> 
+    register(gruff, self()), 
+    process_flag(trap_exit, true), 
+    Cmd = "ruby ./gruff_provider.rb",
+    Port = open_port({spawn, Cmd}, [{packet, 4}, use_stdio, exit_status, binary]), 
+    port_loop(Port) 
+  end). 
+
+stop() -> gruff ! stop. 
+
+plot(Name, Font, Data, Labels) -> 
+  gruff ! {plot, self(), Name, Font, Data, Labels},
+  receive
+    {result, Bin} -> Bin
+  end.
+
+send_data(_Port, []) -> ok;
+send_data(Port, [{Name, Points}|Rest]) ->
+  Data = {data, Name, Points},
+  Port ! {self(), {command, term_to_binary(Data)}},
+  send_data(Port, Rest).
+
+send_labels(Port, Labels) ->
+  Data = {labels, Labels},
+  Port ! {self(), {command, term_to_binary(Data)}}.
+
+
+port_loop(Port) ->
+  receive
+    {plot, Caller, Name, Font, Data, Labels} ->
+      PlotData = term_to_binary({plot, Name, 'Line', Font}),
+      Port ! {self(), {command, PlotData}},
+
+      send_data(Port, Data),
+      send_labels(Port, Labels),
+      
+      EndData = term_to_binary('end'),
+      Port ! {self(), {command, EndData}},
+      Result = get_result(Port),
+      Caller ! {result, Result },
+      
+      port_loop(Port);
+        
+    stop -> 
+      Port ! {self(), close}, 
+      receive 
+        {Port, closed} -> exit(normal) 
+      end
+  end.
+
+get_result(Port) ->
+  receive
+    {Port, {data, Data}} ->
+      {result, Bin} = binary_to_term(Data),
+      Bin;
+    {'EXIT', Port, Reason} ->  
+      exit({port_terminated,Reason})
+    end.

data/examples/gruff/gruff_provider.rb

@@ -0,0 +1,36 @@
+$:.unshift(File.dirname(__FILE__) + "/../../lib/")
+require 'erlectricity'
+require 'rubygems'
+require 'gruff'
+
+receive do |f|
+
+  f.when(:plot, String, Symbol, String) do |name, style, font|
+    graph = Gruff.const_get(style).new
+    graph.title = name
+    graph.font = font
+    graph.legend_font_size = 10
+    
+    
+    f.receive do |g|
+      g.when(:data, Symbol, Array) do |name, points|
+        graph.data name, points
+        g.receive_loop
+      end
+  
+      g.when(:labels, Erl.hash) do |label_data|
+        graph.labels = label_data
+        g.receive_loop
+      end
+  
+      g.when(:end){ :ok }
+    end
+    
+
+    f.send! :result, graph.to_blob
+    f.receive_loop
+  end
+    
+end
+
+

data/examples/gruff/gruff_run.erl

@@ -0,0 +1,17 @@
+#!/usr/bin/env escript
+-export([main/1]).
+main(_Any) ->
+  Data = [
+    {apples, [10, 2, 3, 4, 4, 3]},
+    {oranges, [4, 8, 7, 9, 8, 9]},
+    {watermelons, [2, 3, 1, 5, 6, 8]},
+    {peaches, [9, 9, 10, 8, 7, 9]}
+  ],
+  gruff:start(),
+  Result = gruff:plot(
+    <<"My Charts">>, 
+    <<"/Users/scott/Library/Fonts/Arial">>, 
+    Data, 
+    [{0, <<"2003">>}, {2, <<"2004">>}, {4, <<"2005">>}]
+  ),
+  file:write_file("out.png", Result).

data/examples/gruff/stat_run.erl

@@ -0,0 +1,18 @@
+#!/usr/bin/env escript
+-export([main/1]).
+main(_Any) ->
+  gruff:start(),
+  MemoryWriter = stat_writer:start(<<"Memory Info">>, fun() -> erlang:memory() end),
+  ProcessWriter = stat_writer:start(<<"Process Info">>, 
+    fun() -> 
+      {_, QueueLength} = erlang:process_info(erlang:whereis(gruff), message_queue_len),
+      [{processes, erlang:system_info(process_count)},
+       {gruff_queue_length, QueueLength}] 
+    end
+  ),
+  receive
+  after 20000 ->
+    MemoryWriter ! stop,
+    ProcessWriter ! stop,
+    elang:halt()
+  end.

data/examples/gruff/stat_writer.erl

@@ -0,0 +1,40 @@
+-module(stat_writer).
+-export([start/2, loop/3]).
+
+start(Title, Fun) ->
+  spawn(?MODULE, loop, [Title, Fun, []]).
+  
+loop(Title, Fun, []) -> 
+  Data = accumulate([], Fun()),
+  loop(Title, Fun, Data, 0).
+
+loop(Title, Fun, Data, Generation) ->
+  receive
+    {stop} -> ok
+  after 3000 ->
+    NewGeneration = Generation + 1,    
+    NewData = accumulate(Data, Fun()),
+    NewChart = gruff:plot(
+       list_to_binary([Title, << "- Generation" >>, integer_to_list(NewGeneration)]), 
+      <<"/Users/scott/Library/Fonts/Arial">>,   
+      NewData, 
+      []
+    ),
+    file:write_file(io_lib:format("~s - ~s.png", [Title, integer_to_list(NewGeneration)]),NewChart),
+    loop(Title, Fun, NewData, NewGeneration)
+  end.
+
+process_axis({Name, PreviousReadings}, {Name, Reading}) ->
+  {Name, [Reading|PreviousReadings]}.
+
+accumulate(Data, []) -> Data;
+accumulate([], [{Name, Reading}|Rest]) ->
+  Data = [{Name, [Reading]}],
+  accumulate(Data, Rest);
+accumulate(Data, [{Name, Reading}|Rest]) ->
+  MergedData =  case lists:keysearch(Name, 1, Data) of
+                  {value, Axis} -> lists:keyreplace(Name, 1, Data, process_axis(Axis, {Name, Reading}));
+                  false ->
+                    [{Name, [Reading]}|Data]
+                end,
+  accumulate(MergedData, Rest).

data/examples/tinderl/tinderl.erl

@@ -0,0 +1,45 @@
+-module(tinderl).
+-export([start/4, stop/0, speak/1, paste/1]).
+
+start(Domain, Email, Password, Room) -> 
+  spawn(fun() -> 
+    register(tinderl, self()), 
+    process_flag(trap_exit, true), 
+    Cmd = lists:flatten(io_lib:format("ruby ./tinderl.rb ~s ~s ~s ~s", [Domain, Email, Password, Room])),
+    Port = open_port({spawn, Cmd}, [{packet, 4}, use_stdio, exit_status, binary]), 
+    port_loop(Port) 
+  end). 
+
+stop() -> tinderl ! stop. 
+
+
+speak(String) when is_list(String) -> speak(list_to_binary(String));
+speak(String) when is_binary(String) -> tinderl ! {speak, self(), String}.
+
+paste(String) when is_list(String) -> speak(list_to_binary(String));
+paste(String) when is_binary(String) -> tinderl ! {paste, self(), String}.
+
+port_loop(Port) ->
+  receive
+    {speak, _Caller, String} ->
+      Data = term_to_binary({speak, String}),
+      Port ! {self(), {command, Data}}, 
+
+      port_loop(Port);
+    
+    {paste, _Caller, String} ->
+        Data = term_to_binary({paste, String}),
+        Port ! {self(), {command, Data}}, 
+
+        port_loop(Port);
+        
+    stop -> 
+      Port ! {self(), close}, 
+      receive 
+        {Port, closed} -> exit(normal) 
+      end; 
+    
+    {'EXIT', Port, Reason} ->
+      exit({port_terminated,Reason})
+  end.
+

data/examples/tinderl/tinderl.rb

@@ -0,0 +1,27 @@
+$:.unshift(File.dirname(__FILE__) + "/../../lib/")
+require 'erlectricity'
+require 'rubygems'
+require 'tinder'
+
+domain, email, password, room_name = *ARGV
+campfire = Tinder::Campfire.new domain
+campfire.login email, password
+room = campfire.find_room_by_name room_name
+
+receive do |f|
+  f.when(:speak, Any) do |comment|
+    room.speak comment
+    f.receive_loop
+  end 
+  
+  f.when(:paste, Any) do |comment|
+    room.paste comment
+    f.receive_loop
+  end
+  
+  f.when(Any) do |obj|
+    STDERR.write obj.inspect
+  end
+end
+
+room.leave if room

data/ext/decoder.c

@@ -0,0 +1,391 @@
+#include "ruby.h"
+#include <string.h>
+
+#define ERL_VERSION       131
+#define ERL_SMALL_INT     97
+#define ERL_INT           98
+#define ERL_SMALL_BIGNUM  110
+#define ERL_LARGE_BIGNUM  111
+#define ERL_FLOAT         99
+#define ERL_ATOM          100
+#define ERL_REF           101
+#define ERL_NEW_REF       114
+#define ERL_PORT          102
+#define ERL_PID           103
+#define ERL_SMALL_TUPLE   104
+#define ERL_LARGE_TUPLE   105
+#define ERL_NIL           106
+#define ERL_STRING        107
+#define ERL_LIST          108
+#define ERL_BIN           109
+#define ERL_FUN           117
+#define ERL_NEW_FUN       112
+
+static VALUE mErlectricity;
+static VALUE cDecoder;
+void Init_decoder();
+
+VALUE method_read_any_from(VALUE klass, VALUE rString);
+
+VALUE read_any_raw(unsigned char **pData);
+
+// checkers
+
+void check_int(int num) {
+  char buf[17];
+  sprintf(buf, "%u", num);
+  rb_raise(rb_eStandardError, buf);
+}
+
+void check_str(char *str) {
+  rb_raise(rb_eStandardError, str);
+}
+
+// string peekers/readers
+
+unsigned int peek_1(unsigned char **pData) {
+  return (unsigned int) **pData;
+}
+
+unsigned int peek_2(unsigned char **pData) {
+  return (unsigned int) ((**pData << 8) + *(*pData + 1));
+}
+
+unsigned int peek_4(unsigned char **pData) {
+  return (unsigned int) ((**pData << 24) + (*(*pData + 1) << 16) + (*(*pData + 2) << 8) + *(*pData + 3));
+}
+
+unsigned int read_1(unsigned char **pData) {
+  unsigned int val = peek_1(pData);
+  *pData += 1;
+  return val;
+}
+
+unsigned int read_2(unsigned char **pData) {
+  unsigned int val = peek_2(pData);
+  *pData += 2;
+  return val;
+}
+
+unsigned int read_4(unsigned char **pData) {
+  unsigned int val = peek_4(pData);
+  *pData += 4;
+  return val;
+}
+
+// tuples, lists
+
+VALUE read_small_tuple(unsigned char **pData) {
+  if(read_1(pData) != ERL_SMALL_TUPLE) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a small tuple");
+  }
+  
+  int arity = read_1(pData);
+  
+  VALUE array = rb_ary_new2(arity);
+  
+  int i;
+  for(i = 0; i < arity; ++i) {
+    rb_ary_store(array, i, read_any_raw(pData));
+  }
+  
+  return array;
+}
+
+VALUE read_large_tuple(unsigned char **pData) {
+  if(read_1(pData) != ERL_LARGE_TUPLE) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a large tuple");
+  }
+  
+  int arity = read_4(pData);
+  
+  VALUE array = rb_ary_new2(arity);
+  
+  int i;
+  for(i = 0; i < arity; ++i) {
+    rb_ary_store(array, i, read_any_raw(pData));
+  }
+  
+  return array;
+}
+
+VALUE read_list(unsigned char **pData) {
+  if(read_1(pData) != ERL_LIST) {
+    rb_raise(rb_eStandardError, "Invalid Type, not an erlang list");
+  }
+  
+  int size = read_4(pData);
+  
+  VALUE array = rb_ary_new2(size);
+  
+  int i;
+  for(i = 0; i < size; ++i) {
+    rb_ary_store(array, i, read_any_raw(pData));
+  }
+  
+  read_1(pData);
+  
+  return array;
+}
+
+// primitives
+
+void read_string_raw(unsigned char *dest, unsigned char **pData, int length) {
+  memcpy((char *) dest, (char *) *pData, length);
+  *(dest + length) = (unsigned char) 0;
+  *pData += length;
+}
+
+VALUE read_bin(unsigned char **pData) {
+  if(read_1(pData) != ERL_BIN) {
+    rb_raise(rb_eStandardError, "Invalid Type, not an erlang binary");
+  }
+  
+  int length = read_4(pData);
+  
+  unsigned char buf[length + 1];
+  read_string_raw(buf, pData, length);
+  
+  return rb_str_new2((char *) buf);
+}
+
+VALUE read_string(unsigned char **pData) {
+  if(read_1(pData) != ERL_STRING) {
+    rb_raise(rb_eStandardError, "Invalid Type, not an erlang string");
+  }
+  
+  int length = read_2(pData);
+  
+  unsigned char buf[length + 1];
+  read_string_raw(buf, pData, length);
+  
+  VALUE array = rb_ary_new2(length);
+  
+  int i = 0;
+  for(i; i < length; ++i) {
+    rb_ary_store(array, i, INT2NUM(*(buf + i)));
+  }
+  
+  return array;
+}
+
+VALUE read_atom(unsigned char **pData) {
+  if(read_1(pData) != ERL_ATOM) {
+    rb_raise(rb_eStandardError, "Invalid Type, not an atom");
+  }
+  
+  int length = read_2(pData);
+  
+  unsigned char buf[length + 1];
+  read_string_raw(buf, pData, length);
+  
+  return ID2SYM(rb_intern((char *) buf));
+}
+
+VALUE read_small_int(unsigned char **pData) {
+  if(read_1(pData) != ERL_SMALL_INT) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a small int");
+  }
+  
+  int value = read_1(pData);
+  
+  return INT2FIX(value);
+}
+
+VALUE read_int(unsigned char **pData) {
+  if(read_1(pData) != ERL_INT) {
+    rb_raise(rb_eStandardError, "Invalid Type, not an int");
+  }
+  
+  long long value = read_4(pData);
+  
+  long long negative = ((value >> 31) & 0x1 == 1);
+  
+  if(negative) {
+    value = (value - ((long long) 1 << 32));
+  }
+  
+  return INT2FIX(value);
+}
+
+VALUE read_small_bignum(unsigned char **pData) {
+  if(read_1(pData) != ERL_SMALL_BIGNUM) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a small bignum");
+  }
+  
+  unsigned int size = read_1(pData);
+  unsigned int sign = read_1(pData);
+  
+  VALUE num = INT2NUM(0);
+  VALUE tmp;
+  
+  unsigned char buf[size + 1];
+  read_string_raw(buf, pData, size);
+  
+  int i;
+  for(i = 0; i < size; ++i) {
+    tmp = INT2FIX(*(buf + i));
+    tmp = rb_funcall(tmp, rb_intern("<<"), 1, INT2NUM(i * 8));
+    num = rb_funcall(num, rb_intern("+"), 1, tmp);
+  }
+  
+  if(sign) {
+    num = rb_funcall(num, rb_intern("*"), 1, INT2NUM(-1));
+  }
+  
+  return num;
+}
+
+VALUE read_large_bignum(unsigned char **pData) {
+  if(read_1(pData) != ERL_LARGE_BIGNUM) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a small bignum");
+  }
+  
+  unsigned int size = read_4(pData);
+  unsigned int sign = read_1(pData);
+  
+  VALUE num = INT2NUM(0);
+  VALUE tmp;
+  
+  unsigned char buf[size + 1];
+  read_string_raw(buf, pData, size);
+  
+  int i;
+  for(i = 0; i < size; ++i) {
+    tmp = INT2FIX(*(buf + i));
+    tmp = rb_funcall(tmp, rb_intern("<<"), 1, INT2NUM(i * 8));
+    
+    num = rb_funcall(num, rb_intern("+"), 1, tmp);
+  }
+  
+  if(sign) {
+    num = rb_funcall(num, rb_intern("*"), 1, INT2NUM(-1));
+  }
+  
+  return num;
+}
+
+VALUE read_float(unsigned char **pData) {
+  if(read_1(pData) != ERL_FLOAT) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a float");
+  }
+  
+  unsigned char buf[32];
+  read_string_raw(buf, pData, 31);
+  
+  VALUE rString = rb_str_new2((char *) buf);
+  
+  return rb_funcall(rString, rb_intern("to_f"), 0);
+}
+
+VALUE read_nil(unsigned char **pData) {
+  if(read_1(pData) != ERL_NIL) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a nil list");
+  }
+  
+  return rb_ary_new2(0);
+}
+
+// specials
+
+VALUE read_pid(unsigned char **pData) {
+  if(read_1(pData) != ERL_PID) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a pid");
+  }
+  
+  VALUE node = read_atom(pData);
+  VALUE id = INT2NUM(read_4(pData));
+  VALUE serial = INT2NUM(read_4(pData));
+  VALUE creation = INT2FIX(read_1(pData));
+  
+  VALUE pid_class = rb_const_get(mErlectricity, rb_intern("Pid"));
+  return rb_funcall(pid_class, rb_intern("new"), 4, node, id, serial, creation);
+}
+
+VALUE read_new_reference(unsigned char **pData) {
+  if(read_1(pData) != ERL_NEW_REF) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a new-style reference");
+  }
+  
+  int size = read_2(pData);
+  VALUE node = read_atom(pData);
+  VALUE creation = INT2FIX(read_1(pData));
+  
+  VALUE id = rb_ary_new2(size);
+  int i;
+  for(i = 0; i < size; ++i) {
+    rb_ary_store(id, i, INT2NUM(read_4(pData)));
+  }
+  
+  VALUE newref_class = rb_const_get(mErlectricity, rb_intern("NewReference"));
+  return rb_funcall(newref_class, rb_intern("new"), 3, node, creation, id);
+}
+
+// read_any_raw
+
+VALUE read_any_raw(unsigned char **pData) {
+  switch(peek_1(pData)) {
+    case ERL_SMALL_INT:
+      return read_small_int(pData);
+      break;
+    case ERL_INT:
+      return read_int(pData);
+      break;
+    case ERL_FLOAT:
+      return read_float(pData);
+      break;
+    case ERL_ATOM:
+      return read_atom(pData);
+      break;
+    case ERL_PID:
+      return read_pid(pData);
+      break;
+    case ERL_SMALL_TUPLE:
+      return read_small_tuple(pData);
+      break;
+    case ERL_LARGE_TUPLE:
+      return read_large_tuple(pData);
+      break;
+    case ERL_NIL:
+      return read_nil(pData);
+      break;
+    case ERL_STRING:
+      return read_string(pData);
+      break;
+    case ERL_LIST:
+      return read_list(pData);
+      break;
+    case ERL_BIN:
+      return read_bin(pData);
+      break;
+    case ERL_SMALL_BIGNUM:
+      return read_small_bignum(pData);
+      break;
+    case ERL_LARGE_BIGNUM:
+      return read_large_bignum(pData);
+      break;
+    case ERL_NEW_REF:
+      return read_new_reference(pData);
+      break;
+  }
+  return Qnil;
+}
+
+VALUE method_read_any_from(VALUE klass, VALUE rString) {
+  unsigned char *data = (unsigned char *) StringValuePtr(rString);
+  
+  unsigned char **pData = &data;
+  
+  // check protocol version
+  if(read_1(pData) != ERL_VERSION) {
+    rb_raise(rb_eStandardError, "Bad Magic");
+  }
+  
+  return read_any_raw(pData);
+}
+
+void Init_decoder() {
+  mErlectricity = rb_const_get(rb_cObject, rb_intern("Erlectricity"));
+  cDecoder = rb_define_class_under(mErlectricity, "Decoder", rb_cObject);
+  rb_define_singleton_method(cDecoder, "read_any_from", method_read_any_from, 1);
+}