erlectricity 0.1.0 → 0.2.0

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

@@ -1,3 +1,5 @@
+CONTRIBUTORS
+History.txt
 Manifest.txt
 README.txt
 Rakefile
@@ -8,6 +10,8 @@ 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
@@ -19,11 +23,11 @@ lib/erlectricity/encoder.rb
 lib/erlectricity/errors/decode_error.rb
 lib/erlectricity/errors/encode_error.rb
 lib/erlectricity/errors/erlectricity_error.rb
-lib/erlectricity/match_context.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

data/Rakefile

@@ -49,7 +49,7 @@ hoe = Hoe.new(GEM_NAME, VERS) do |p|
   
   # == Optional
   p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
-  #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  p.extra_deps = [ ]     # 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.
 end
 

data/examples/gruff/gruff_provider.rb

@@ -1,36 +1,36 @@
 $:.unshift(File.dirname(__FILE__) + "/../../lib/")
-require 'rubygems'
 require 'erlectricity'
+require 'rubygems'
 require 'gruff'
 
-receive do
+receive do |f|
   
   
     
-  match(:plot, string(:name), atom(:style), string(:font)) do
+  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
     
     
-    receive do
-      match(:data, atom(:name), list(:points)) do
+    f.receive do |g|
+      g.when(:data, Symbol, Array) do |name, points|
         graph.data name, points
-        receive_loop
+        g.receive_loop
       end
   
-      match(:labels, hash(:label_data)) do
+      g.when(:labels, Erl.hash) do |label_data|
         graph.labels = label_data
-        receive_loop
+        g.receive_loop
       end
   
-      match(:end){ :ok }
+      g.when(:end){ :ok }
     end
     
     
-    send! :result, graph.to_blob
-    receive_loop
+    f.send! :result, graph.to_blob
+    f.receive_loop
   end
     
 end

data/examples/tinderl/tinderl.erl

@@ -12,7 +12,11 @@ start(Domain, Email, Password, Room) ->
 
 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) ->

data/examples/tinderl/tinderl.rb

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

data/ext/decoder.c

@@ -0,0 +1,389 @@
+#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));
+  }
+  
+  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);
+}

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

@@ -3,13 +3,20 @@ 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/decoder'
 require 'erlectricity/encoder'
 
 require 'erlectricity/port'
 require 'erlectricity/matcher'
-require 'erlectricity/match_context'
 
 require 'erlectricity/condition'
 require 'erlectricity/conditions/hash'
@@ -21,3 +28,5 @@ 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

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

data/lib/erlectricity/conditions/hash.rb

@@ -6,10 +6,9 @@ class HashCondition < Condition
     arg.all?{|x| x.class == Array && x.length == 2}
   end
   
-  def bindings_for(arg)
-    return {} unless self.binding_name
+  def binding_for(arg)
     flattened = arg.inject([]){|memo, kv| memo + kv}
-    {self.binding_name => Hash[*flattened]}
+    Hash[*flattened]
   end
 end
 end

data/lib/erlectricity/conditions/static.rb

@@ -1,17 +1,13 @@
 module Erlectricity
 class StaticCondition < Condition
   attr_accessor :value
-  def initialize(value, name=nil)
+  def initialize(value)
     self.value = value
-    super(name)
   end
   
   def satisfies?(arg)
     arg.eql? value
   end
-  
-  def bindings_for(arg)
-    {}
-  end
+
 end
 end

data/lib/erlectricity/conditions/type.rb

@@ -2,18 +2,16 @@ module Erlectricity
 class TypeCondition < Condition
   attr_accessor :type
   
-  def initialize(type, name=nil)
+  def initialize(type)
     self.type = type
-    super(name)
   end
   
   def satisfies?(arg)
     arg.is_a? self.type
   end
   
-  def bindings_for(arg)
-    return {} unless self.binding_name
-    {self.binding_name => arg}
+  def binding_for(arg)
+    arg
   end
 end
 end

data/lib/erlectricity/encoder.rb

@@ -19,6 +19,7 @@ class Encoder
       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
@@ -106,7 +107,6 @@ class Encoder
       fail(data) unless data.is_a? Array
       write_1 NIL and return if data.empty?
       
-      #NOTE: we do not ever encode as the string format.      
       write_1 LIST
       write_4 data.length
       data.each{|e| write_any_raw e }

data/lib/erlectricity/matcher.rb

@@ -10,10 +10,8 @@ class Matcher
   end
   
   def run(arg)
-    context = MatchContext.new(self.receiver) 
-
-    populate_context context, arg
-    context.instance_eval &block
+    args = get_bound arg
+    block.call *args
   end
   
   def matches?(arg)
@@ -28,33 +26,13 @@ class Matcher
   
 
   private
-  def populate_context(context, arg)
+  
+  def get_bound(arg)
     if @condition.is_a?(Array) && arg.is_a?(Array)
-      @condition.zip(arg).all?{|l,r| set_binding(context, l, r)}
+      @condition.zip(arg).map{|l,r| l.binding_for r}.compact
     else
-      set_binding(context, condition, arg)
+      @condition.binding_for(arg)
     end
   end
-  
-  def set_binding(context, condition, arg)
-    condition.bindings_for(arg).each do |k, v|
-      add_to_context(context, k, v)
-    end
-  end
-  
-  def add_to_context(context, name, value)
-    return if name.nil?
-    
-    context.instance_eval <<-EOS
-      def #{name}
-        @#{name}
-      end
-      def #{name}= (value)
-        @#{name} = value
-      end
-    EOS
-    
-    context.send(:"#{name}=", value)
-  end
 end
 end

data/lib/erlectricity/receiver.rb

@@ -1,6 +1,5 @@
 module Erlectricity
 class Receiver
-  include Conditions
   
   attr_accessor :port
   attr_accessor :parent
@@ -13,7 +12,7 @@ class Receiver
     @port = port
     @parent = parent
     @matchers = []
-    instance_eval &block if block
+    block.call self if block
   end
   
   def process(arg)
@@ -27,8 +26,14 @@ class Receiver
     end
   end
   
-  def match(*args, &block)
-    args = args.map{|a| a.is_a?(Condition) ? a : StaticCondition.new(a)}
+  def when(*args, &block)
+    args = args.map do |a| 
+      case a
+      when Condition then a 
+      when Class then TypeCondition.new(a)
+      else StaticCondition.new(a)
+      end
+    end
     
     args = args.first if args.length == 1
     @matchers << Matcher.new(self, args, block)

data/lib/erlectricity/types/list.rb

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

data/lib/erlectricity/version.rb

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

data/test/condition_spec.rb

@@ -7,16 +7,16 @@ context "Erlectricity::StaticConditions" do
     Erlectricity::StaticCondition.new(3).satisfies?(3).should == true
   end
   
-  specify "should not satisfy on diffeent values" do
+  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, even if a name is supplied" do
-    s = Erlectricity::StaticCondition.new(:foo, :bound_name)
-    s.bindings_for(:foo).should == {}
+  specify "should not produce any bindings" do
+    s = Erlectricity::StaticCondition.new(:foo)
+    s.binding_for(:foo).should == nil
   end
 end
 
@@ -42,17 +42,12 @@ context "Erlectricity::TypeConditions" do
     Erlectricity::TypeCondition.new(Fixnum).satisfies?(3.0).should == false
   end
   
-  specify "should bind the arg to the name specified with no transormations" do
-    s = Erlectricity::TypeCondition.new(Symbol, :bound_name)
-    s.bindings_for(:foo).should == {:bound_name => :foo}
-    s.bindings_for(:bar).should == {:bound_name => :bar}
-  end
-  
-  specify "should not bind anything if no binding name is specified" do
-    
+  specify "should bind the arg with no transormations" do
     s = Erlectricity::TypeCondition.new(Symbol)
-    s.bindings_for(:foo).should == {}
+    s.binding_for(:foo).should == :foo
+    s.binding_for(:bar).should == :bar
   end
+
 end
 
 context "Erlectricity::HashConditions" do
@@ -71,8 +66,8 @@ context "Erlectricity::HashConditions" do
      Erlectricity::HashCondition.new.satisfies?(3.0).should == false
   end
   
-  specify "should product a binder" do
-    s = Erlectricity::HashCondition.new(:bound_name)
-    s.bindings_for([[:foo, 3], [:bar, [3,4,5]]]).should == {:bound_name => {:foo => 3, :bar => [3,4,5] }}
+  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

@@ -1,16 +1,7 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
 
-context "The byte reader attached to decoder" do
-  specify "should not advance the stream when peeking unless there arent enough bytes available" do
-    @decoder = Erlectricity::Decoder.new(StringIO.new('abcdefghijklmnopqrstuvwxyz'))
-    100.times{ @decoder.peek_1.should == 'a'[0] }
-    100.times{ @decoder.peek_2.should == 'ab'.unpack("n").first }
-  end
-end
-
 context "When unpacking from a binary stream" do
   setup do
-    @decoder = Erlectricity::Decoder.new(nil)
   end
   
   specify "an erlang atom should decode to a ruby symbol" do
@@ -127,7 +118,6 @@ context "When unpacking from a binary stream" do
   
   def get(str)
     bin = run_erl("term_to_binary(#{str})")
-    @decoder.in = StringIO.new(bin)
-    @decoder.read_any
+    Erlectricity::Decoder.read_any_from(bin)
   end
 end

data/test/encode_spec.rb

@@ -88,6 +88,13 @@ context "When packing to a binary stream" do
     write_any([3] * 512).should == get_erl_with_magic("{#{([3] * 512).join(',')}}")
   end
   
+  specify "An Erlectricity::List should by default be written as a list" do
+    write_any(Erl::List.new([1,2,300])).should == get_erl_with_magic("[1,2,300]")
+    write_any(Erl::List.new([300] * 255)).should == get_erl_with_magic("[#{([300] * 255).join(',')}]")
+    write_any(Erl::List.new([300] * 256)).should == get_erl_with_magic("[#{([300] * 256).join(',')}]")
+    write_any(Erl::List.new([300] * 512)).should == get_erl_with_magic("[#{([300] * 512).join(',')}]")
+  end
+  
   specify "An array written with write_list should encode as erlang would a list" do
     get{@encoder.write_list [1,2,300]}.should == get_erl("[1,2,300]")
     get{@encoder.write_list [300] * 255}.should == get_erl("[#{([300] * 255).join(',')}]")

data/test/matcher_spec.rb

@@ -67,7 +67,3 @@ context "a matcher whose matcher is an array" do
     matcher.matches?(:foo).should == false
   end
 end
-
-context "a matcher" do
-  
-end

data/test/receiver_spec.rb

@@ -5,8 +5,8 @@ def simple_receiver_and_port(*terms, &block)
   receiver = if block
       Erlectricity::Receiver.new(port, &block)
     else
-      Erlectricity::Receiver.new(port) do
-        match(any) do
+      Erlectricity::Receiver.new(port) do |f|
+        f.when Erl.any do
           :matched
         end
       end
@@ -17,12 +17,12 @@ end
 context "When a receiver is passed a message that matches two match blocks it" do
   setup do
     @port = FakePort.new([:foo, :foo])
-    @receiver = Erlectricity::Receiver.new(@port) do
-      match(:foo, :foo) do
+    @receiver = Erlectricity::Receiver.new(@port) do |f|
+      f.when(:foo, :foo) do
         :first
       end
       
-      match(:foo, any) do
+      f.when(:foo, Erl.any) do
         :second
       end
     end
@@ -41,9 +41,9 @@ context "A receiver" do
   end
   
   specify "should process another message if the matched block returns the results of receive_loop" do
-    recv = simple_receiver_and_port(:foo, :bar, :baz) do
-      match(:bar) {  }
-      match(any) { receive_loop }
+    recv = simple_receiver_and_port(:foo, :bar, :baz) do |f|
+      f.when(:bar) {  }
+      f.when(Erl.any) { f.receive_loop }
     end
     
     recv.run
@@ -52,15 +52,15 @@ context "A receiver" do
   
   specify "should properly nest" do
     @port = FakePort.new(:foo, :bar, :baz)
-    @receiver = Erlectricity::Receiver.new(@port) do
-      match(:foo) do
-        receive do
-          match(:bar){ :ok }
+    @receiver = Erlectricity::Receiver.new(@port) do |f|
+      f.when(:foo) do
+        f.receive do |g|
+          g.when(:bar){ :ok }
         end
-        receive_loop  
+        f.receive_loop  
       end
       
-      match(:baz) do
+      f.when(:baz) do
         :done
       end
     end
@@ -71,15 +71,15 @@ context "A receiver" do
   
   specify "should queue up skipped results and restore them when a match happens" do
     @port = FakePort.new(:foo, :baz, :bar)
-    @receiver = Erlectricity::Receiver.new(@port) do
-      match(:foo) do
-        receive do
-          match(:bar){ :ok }
+    @receiver = Erlectricity::Receiver.new(@port) do |f|
+      f.when(:foo) do
+        f.receive do |g|
+          g.when(:bar){ :ok }
         end
-        receive_loop  
+        f.receive_loop  
       end
       
-      match(:baz) do
+      f.when(:baz) do
         :done
       end
     end
@@ -91,10 +91,10 @@ context "A receiver" do
   specify "should expose bindings to the matched block" do
     @port = FakePort.new(:foo, :bar, :baz)
     results = []
-    @receiver = Erlectricity::Receiver.new(@port) do
-      match(atom(:bindinated)) do
+    @receiver = Erlectricity::Receiver.new(@port) do |f|
+      f.when(Erl.atom) do |bindinated|
         results << bindinated
-        receive_loop  
+        f.receive_loop  
       end
     end
     

data/test/test_helper.rb

@@ -1,8 +1,8 @@
 $:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'erlectricity'
 require 'rubygems'
 require 'test/unit'
 require 'test/spec'
-require 'erlectricity'
 
 class Test::Unit::TestCase
   
@@ -10,6 +10,11 @@ class Test::Unit::TestCase
     `erl -noshell -eval 'A = #{code.split.join(' ')}, io:put_chars(A).' -s erlang halt`
   end
   
+  def encode_packet(code)
+    bin = run_erl("term_to_binary(#{code})")
+    [bin.length, bin].pack("Na#{bin.length}")
+  end
+  
   def word_length
     (1.size * 8) - 2
   end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
+rubygems_version: 0.9.4
 specification_version: 1
 name: erlectricity
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2007-05-08 00:00:00 -07:00
+  version: 0.2.0
+date: 2007-10-29 00:00:00 -07:00
 summary: A library to interface erlang and ruby through the erlang port system
 require_paths: 
 - lib
+- ext
 email: nullstyle@gmail.com
 homepage: http://erlectricity.rubyforge.org
 rubyforge_project: erlectricity
@@ -29,6 +30,8 @@ post_install_message:
 authors: 
 - Scott Fleckenstein
 files: 
+- CONTRIBUTORS
+- History.txt
 - Manifest.txt
 - README.txt
 - Rakefile
@@ -39,6 +42,8 @@ files:
 - 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
@@ -50,11 +55,11 @@ files:
 - lib/erlectricity/errors/decode_error.rb
 - lib/erlectricity/errors/encode_error.rb
 - lib/erlectricity/errors/erlectricity_error.rb
-- lib/erlectricity/match_context.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
@@ -73,10 +78,13 @@ files:
 test_files: 
 - test/test_erlectricity.rb
 - test/test_helper.rb
-rdoc_options: []
-
-extra_rdoc_files: []
-
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
 executables: []
 
 extensions: []

data/lib/erlectricity/match_context.rb

@@ -1,20 +0,0 @@
-module Erlectricity
-class MatchContext
-  attr_accessor :receiver
-  def initialize(receiver)
-    self.receiver = receiver
-  end
-  
-  def receive(&block)
-    receiver.receive(&block)
-  end
-
-  def receive_loop
-    receiver.receive_loop
-  end
-  
-  def send!(*term)
-    receiver.send!(*term)
-  end
-end
-end