erlectricity 0.1.0

data/Manifest.txt

@@ -0,0 +1,41 @@
+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
+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/match_context.rb
+lib/erlectricity/matcher.rb
+lib/erlectricity/port.rb
+lib/erlectricity/receiver.rb
+lib/erlectricity/types/function.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,3 @@
+README for erlectricity
+=======================
+

data/Rakefile

@@ -0,0 +1,68 @@
+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 = []     # 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
+
+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,38 @@
+$:.unshift(File.dirname(__FILE__) + "/../../lib/")
+require 'rubygems'
+require 'erlectricity'
+require 'gruff'
+
+receive do
+  
+  
+    
+  match(:plot, string(:name), atom(:style), string(:font)) do
+    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
+        graph.data name, points
+        receive_loop
+      end
+  
+      match(:labels, hash(:label_data)) do
+        graph.labels = label_data
+        receive_loop
+      end
+  
+      match(:end){ :ok }
+    end
+    
+    
+    send! :result, graph.to_blob
+    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,41 @@
+-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_binary(String) -> tinderl ! {speak, self(), 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,23 @@
+$:.unshift(File.dirname(__FILE__) + "/../../lib/")
+require 'rubygems'
+require 'erlectricity'
+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
+  match(:speak, any(:comment)) do
+    room.speak comment
+    receive_loop
+  end 
+  
+  match(:paste, any(:comment)) do
+    room.paste comment
+    receive_loop
+  end
+end
+
+room.leave if room

data/lib/erlectricity/condition.rb

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

data/lib/erlectricity/conditions/hash.rb

@@ -0,0 +1,15 @@
+module Erlectricity
+class HashCondition < Condition
+
+  def satisfies?(arg)
+    return false unless arg.class == Array
+    arg.all?{|x| x.class == Array && x.length == 2}
+  end
+  
+  def bindings_for(arg)
+    return {} unless self.binding_name
+    flattened = arg.inject([]){|memo, kv| memo + kv}
+    {self.binding_name => Hash[*flattened]}
+  end
+end
+end

data/lib/erlectricity/conditions/static.rb

@@ -0,0 +1,17 @@
+module Erlectricity
+class StaticCondition < Condition
+  attr_accessor :value
+  def initialize(value, name=nil)
+    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

@@ -0,0 +1,19 @@
+module Erlectricity
+class TypeCondition < Condition
+  attr_accessor :type
+  
+  def initialize(type, name=nil)
+    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}
+  end
+end
+end

data/lib/erlectricity/constants.rb

@@ -0,0 +1,37 @@
+module Erlectricity
+  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/erlectricity/decoder.rb

@@ -0,0 +1,202 @@
+module Erlectricity
+class Decoder
+  attr_accessor :in
+  include Erlectricity::External::Types
+  
+  def self.read_any_from(string)
+    new(StringIO.new(string)).read_any
+  end
+  
+  def initialize(ins)
+    @in = ins
+    @peeked = ""
+  end
+  
+  def read_any
+    fail("Bad Magic") unless read_1 == Erlectricity::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
+    read_string(length).to_sym
+  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
+    []
+  end
+  
+  def read_erl_string
+    fail("Invalid Type, not an erlang string") unless read_1 == STRING
+    length = read_2
+    read_string(length).unpack('C' * length)
+  end
+  
+  def read_list
+    fail("Invalid Type, not an erlang list") unless read_1 == LIST
+    length = read_4
+    (0...length).map{|i| read_any_raw}
+  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