erlectricity 0.1.0

data/lib/erlectricity/encoder.rb

@@ -0,0 +1,127 @@
+module Erlectricity
+class Encoder
+    include Erlectricity::External::Types
+    attr_accessor :out
+    def initialize(out)
+      self.out = out
+    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 Array then write_tuple(obj)
+      when String then write_binary(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_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)
+      fail(num)
+    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?
+      
+      #NOTE: we do not ever encode as the string format.      
+      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.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/match_context.rb

@@ -0,0 +1,20 @@
+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

data/lib/erlectricity/matcher.rb

@@ -0,0 +1,60 @@
+module Erlectricity
+class Matcher
+  attr_accessor :condition, :block
+  attr_accessor :receiver
+  
+  def initialize(parent, condition, block)
+    self.receiver = parent
+    @block = block
+    @condition = condition
+  end
+  
+  def run(arg)
+    context = MatchContext.new(self.receiver) 
+
+    populate_context context, arg
+    context.instance_eval &block
+  end
+  
+  def matches?(arg)
+    if @condition.is_a?(Array)
+      return false unless arg.is_a?(Array)
+      return false if @condition.length != arg.length
+      @condition.zip(arg).all?{|l,r| l.satisfies?(r)}
+    else
+      @condition.satisfies?(arg)
+    end
+  end
+  
+
+  private
+  def populate_context(context, arg)
+    if @condition.is_a?(Array) && arg.is_a?(Array)
+      @condition.zip(arg).all?{|l,r| set_binding(context, l, r)}
+    else
+      set_binding(context, condition, 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/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)
+      result = Erlectricity::Decoder.read_any_from(data)
+      result
+    end
+  end
+end

data/lib/erlectricity/receiver.rb

@@ -0,0 +1,74 @@
+module Erlectricity
+class Receiver
+  include Conditions
+  
+  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 = []
+    instance_eval &block 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 match(*args, &block)
+    args = args.map{|a| a.is_a?(Condition) ? a : StaticCondition.new(a)}
+    
+    args = args.first if args.length == 1
+    @matchers << Matcher.new(self, args, 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)
+    term = term.first if term.length == 1
+    port.send(term)
+  end
+end
+end
+
+
+module Kernel
+  def receive(input=STDIN, output=STDOUT, &block)
+    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/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 = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/erlectricity.rb

@@ -0,0 +1,23 @@
+require 'erlectricity/constants'
+
+require 'erlectricity/types/new_reference'
+require 'erlectricity/types/pid'
+require 'erlectricity/types/function'
+
+require 'erlectricity/decoder'
+require 'erlectricity/encoder'
+
+require 'erlectricity/port'
+require 'erlectricity/matcher'
+require 'erlectricity/match_context'
+
+require 'erlectricity/condition'
+require 'erlectricity/conditions/hash'
+require 'erlectricity/conditions/static'
+require 'erlectricity/conditions/type'
+
+require 'erlectricity/receiver'
+
+require 'erlectricity/errors/erlectricity_error'
+require 'erlectricity/errors/decode_error'
+require 'erlectricity/errors/encode_error'