beambridge 0.9.0

data/examples/gruff/gruff_run.sh

@@ -0,0 +1,19 @@
+#!/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.sh

@@ -0,0 +1,20 @@
+#!/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/simple/README.md

@@ -0,0 +1,5 @@
+This example demonstrates how Erlang and Ruby data types get converted when
+crossing from one to the other.
+
+    $ cd examples/simple
+    $ ./rerl.sh

data/examples/simple/rerl.rb

@@ -0,0 +1,110 @@
+#
+#  rerl.rb, for use with erlang's open_port
+#  spawn using rerl.sh escript:
+#
+#    $ ./rerl.sh
+#    ./rerl.sh:35: Warning: variable 'Port' is unused
+#    [erlang] ruby is alive
+#    [erlang]  sending: test
+#    [erlang]  sending: {atom,symbol}
+#    [erlang]  sending: {number,1}
+#    [erlang]  sending: {string,<<"reverse">>}
+#    [erlang]  sending: {array,[1,2,3]}
+#    [erlang]  sending: {array,[<<"abc">>,<<"cde">>]}
+#    [erlang]  sending: {hash,[{key,val}]}
+#    [erlang]  sending: {object,{1,{2},3,<<"four">>}}
+#    [ ruby ] received: test, nil
+#    [ ruby ]  sending: test, nil
+#    [erlang] received: test
+#    [ ruby ] received: atom, :symbol
+#    [ ruby ]  sending: atom, :lobmys
+#    [erlang] received: {atom,lobmys}
+#    [ ruby ] received: number, 1
+#    [ ruby ]  sending: number, 2
+#    [ ruby ] received: string, "reverse"
+#    [erlang] received: {number,2}
+#    [ ruby ]  sending: string, "esrever"
+#    [ ruby ] received: array, [1, 2, 3]
+#    [erlang] received: {string,<<"esrever">>}
+#    [ ruby ]  sending: array, [3, 2, 1]
+#    [ ruby ] received: array, ["abc", "cde"]
+#    [erlang] received: {array,{3,2,1}}
+#    [ ruby ]  sending: array, ["cde", "abc"]
+#    [ ruby ] received: hash, {:key=>:val}
+#    [erlang] received: {array,{<<"cde">>,<<"abc">>}}
+#    [ ruby ]  sending: hash, {:key=>:val, :ruby=>:true}
+#    [ ruby ] received: object, [1, [2], 3, "four"]
+#    [erlang] received: {hash,{{key,val},{ruby,true}}}
+#    [ ruby ]  sending: object, [1, [2], 3, "four"]
+#    [erlang] received: {object,{1,{2},3,<<"four">>}}
+#
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[../../lib])
+
+require 'beambridge'
+
+def log arg
+  puts arg
+  # @f ||= File.open('/tmp/rerl.log', 'w')
+  # @f.puts arg
+  # @f.flush
+end
+
+def debug meth, got = nil, send = nil
+  log "[ ruby ] received: #{meth}, #{got.inspect}"
+  log "[ ruby ]  sending: #{meth}, #{send.inspect}"
+end
+
+receive do |f|
+  f.when(:test) do
+    debug(:test)
+    f.send!(:test)
+    f.receive_loop
+  end
+
+  f.when([:atom, Symbol]) do |sym|
+    debug(:atom, sym, sym.to_s.reverse.to_sym)
+    f.send!([:atom, sym.to_s.reverse.to_sym])
+    f.receive_loop
+  end
+
+  f.when([:bool, Erl.boolean]) do |bool|
+    debug(:bool, bool, !bool)
+    f.send!([:bool, !bool])
+    f.receive_loop
+  end
+
+  f.when([:number, Fixnum]) do |num|
+    debug(:number, num, num*2)
+    f.send!([:number, num*2])
+    f.receive_loop
+  end
+
+  f.when([:string, String]) do |str|
+    debug(:string, str, str.reverse)
+    f.send!([:string, str.reverse])
+    f.receive_loop
+  end
+
+  f.when([:array, Array]) do |arr|
+    debug(:array, arr, arr.reverse)
+    f.send!([:array, arr.reverse])
+    f.receive_loop
+  end
+
+  f.when([:hash, Erl.hash]) do |hash|
+    newhash = hash.dup
+    newhash[:ruby] = :true
+    debug(:hash, hash, newhash)
+    f.send!([:hash, newhash.to_a])
+    f.receive_loop
+  end
+
+  f.when([:object, Any]) do |obj|
+    debug(:object, obj, obj)
+    f.send!([:object, obj])
+    f.receive_loop
+  end
+  
+  f.send!(:i_am_alive)
+end

data/examples/simple/rerl.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env escript
+main(_) ->
+  Cmd = "ruby rerl.rb",
+  Port = open_port({spawn, Cmd}, [{packet, 4}, nouse_stdio, exit_status, binary]),
+  loop(Port).
+
+send(Port, Message) ->
+  io:format("[erlang]  sending: ~p~n", [Message]),
+  % can also use ! instead of port_command
+  % Port ! { self(), { command, term_to_binary(Message) } }.
+  port_command(Port, term_to_binary(Message)).
+
+loop(Port) ->
+  receive
+    {Port, {data, In}} ->
+      Data = binary_to_term(In),
+      process(Port, Data);
+    Any ->
+      io:format("[erlang]    other: ~p~n", [Any])
+  end,
+  loop(Port).
+
+process(Port, i_am_alive) ->
+  io:format("[erlang] ruby is alive~n"),
+
+  send(Port, test),
+  send(Port, {atom, symbol}),
+  send(Port, {bool, true}),
+  send(Port, {number, 1}),
+  send(Port, {string, <<"reverse">>}),
+  send(Port, {array, [1,2,3]}),
+  send(Port, {array, [<<"abc">>, <<"cde">>]}),
+  send(Port, {hash, [{key,val}]}),
+  send(Port, {object, {1,{2},3,<<"four">>}});
+
+process(Port, Data) ->
+  io:format("[erlang] received: ~p~n", [Data]).

data/examples/tinderl/README.md

@@ -0,0 +1,14 @@
+This is a more advanced example of Erlectricity that shows how you can
+integrate with Campfire via the Ruby "tinder" gem.
+
+    $ cd examples/tinderl
+    $ erl
+    Erlang (BEAM) emulator version 5.6.4 [source] [smp:2] [async-threads:0] [kernel-poll:false]
+
+    Eshell V5.6.4  (abort with ^G)
+    1> c(tinderl).
+    {ok,tinderl}
+    2> tinderl:start("example.campfireapp.com", "tom@example.com", "secret", "My Room").
+    <0.38.0>
+    5> tinderl:speak("Hello, World!").
+    {speak,<0.31.0>,<<"Hello, World!">>}

data/examples/tinderl/tinderl.erl

@@ -0,0 +1,43 @@
+-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}, nouse_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.join(File.dirname(__FILE__), *%w[../../lib])
+
+require 'beambridge'
+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|
+    p obj
+  end
+end
+
+room.leave if room

data/ext/decoder.c

@@ -0,0 +1,398 @@
+#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_decode(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");
+  }
+
+  unsigned 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");
+  }
+
+  unsigned int size = read_4(pData);
+
+  VALUE newref_class = rb_const_get(mErlectricity, rb_intern("List"));
+  VALUE array = rb_funcall(newref_class, rb_intern("new"), 1, INT2NUM(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, unsigned 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");
+  }
+
+  unsigned int length = read_4(pData);
+
+  VALUE rStr = rb_str_new((char *) *pData, length);
+  *pData += length;
+
+  return rStr;
+}
+
+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);
+  VALUE newref_class = rb_const_get(mErlectricity, rb_intern("List"));
+  VALUE array = rb_funcall(newref_class, rb_intern("new"), 1, INT2NUM(length));
+
+  int i = 0;
+  for(i; i < length; ++i) {
+    rb_ary_store(array, i, INT2NUM(**pData));
+    *pData += 1;
+  }
+
+  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);
+
+  // Erlang true and false are actually atoms
+  if(length == 4 && strncmp((char *) buf, "true", length) == 0) {
+    return Qtrue;
+  } else if(length == 5 && strncmp((char *) buf, "false", length) == 0) {
+    return Qfalse;
+  } else {
+    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);
+
+  unsigned 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);
+
+  unsigned 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");
+  }
+
+  VALUE newref_class = rb_const_get(mErlectricity, rb_intern("List"));
+  return rb_funcall(newref_class, rb_intern("new"), 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_decode(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("Beambridge"));
+  cDecoder = rb_define_class_under(mErlectricity, "Decoder", rb_cObject);
+  rb_define_singleton_method(cDecoder, "decode", method_decode, 1);
+}