asir 0.2.0

data/lib/asir/transport/webrick.rb

@@ -0,0 +1,50 @@
+require 'asir/transport/http'
+require 'webrick'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # WEBrick Transport server.
+    class Webrick < HTTP
+
+      # Server-side: WEBrick
+
+      # Receive the Message payload String from the HTTP Message object.
+      # Returns the original http_message as the message_state.
+      def _receive_message http_message, additional_data
+        [ http_message.body, http_message ]
+      end
+
+      # Send the Result payload String in the HTTP Response object as application/binary.
+      def _send_result message, result, result_payload, http_result, message_state
+        http_result[CONTENT_TYPE] = APPLICATION_BINARY
+        http_result.body = result_payload
+      end
+
+      def prepare_server! opts = { }
+        u = URI.parse(uri)
+        port = u.port
+        path = u.path
+        opts[:Port] ||= port
+        @server = ::WEBrick::HTTPServer.new(opts)
+        @server.mount_proc path, lambda { | rq, rs |
+          serve_message! rq, rs
+        }
+        self
+      rescue ::Exception => exc
+        raise Error, "Webrick Server #{uri.inspect}: #{exc.inspect}", exc.backtrace
+      end
+
+      def run_server!
+        @server.start
+        self
+      end
+
+      def stop_server!
+        @server.stop
+        self
+      end
+    end
+    # !SLIDE END
+  end
+end

data/lib/asir/transport/zmq.rb

@@ -0,0 +1,110 @@
+require 'asir/transport/connection_oriented'
+gem 'zmq'
+require 'zmq'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # ZeroMQ Transport
+    class Zmq < ConnectionOriented
+      attr_accessor :queue
+
+      # !SLIDE
+      # 0MQ client.
+      def _client_connect!
+        sock = zmq_context.socket(one_way ? ZMQ::PUB : ZMQ::REQ)
+        sock.connect(zmq_uri)
+        sock
+      rescue ::Exception => exc
+        raise exc.class, "#{self.class} #{zmq_uri}: #{exc.message}", exc.backtrace
+      end
+
+      # !SLIDE
+      # 0MQ server.
+      def _server!
+        sock = zmq_context.socket(one_way ? ZMQ::SUB : ZMQ::REP)
+        sock.setsockopt(ZMQ::SUBSCRIBE, queue) if one_way
+        sock.bind("tcp://*:#{port}") # WTF?: why doesn't tcp://localhost:PORT work?
+        @server = sock
+      rescue ::Exception => exc
+        raise exc.class, "#{self.class} #{zmq_uri}: #{exc.message}", exc.backtrace
+      end
+
+      def _receive_result message, opaque_result
+        return nil if one_way || message.one_way
+        super
+      end
+
+      def _send_result message, result, result_payload, stream, message_state
+        return nil if one_way || message.one_way
+        super
+      end
+
+      def _write payload, stream
+        payload.insert(0, queue_) if one_way
+        stream.send payload, 0
+        stream
+      end
+
+      def _read stream
+        stream.recv 0
+      end
+
+      # def scheme; SCHEME; end; SCHEME = 'tcp'.freeze
+      def queue
+        @queue ||=
+          (
+          case
+          when @uri
+            x = URI.parse(@uri).path
+          else
+            x = ""
+          end
+          # x << "\t" unless x.empty?
+          x.freeze
+          )
+      end
+      def queue_
+        @queue_ ||=
+          (queue.empty? ? queue : queue + " ").freeze
+      end
+
+
+      def run_server!
+        _log { "run_server! #{uri}" } if @verbose >= 1
+        with_server_signals! do
+          @running = true
+          while @running
+            begin
+              serve_stream_message!(@server, @one_way ? nil : @server)
+            rescue Error::Terminate => err
+              @running = false
+              _log [ :run_server_terminate, err ]
+            end
+          end
+        end
+        self
+      ensure
+        _server_close!
+      end
+
+      def zmq_uri
+        @zmq_uri ||=
+          (
+          u = URI.parse(uri)
+          u.path = ''
+          u.to_s.freeze
+          )
+      end
+
+      def zmq_context
+        @@zmq_context ||=
+          ZMQ::Context.new(1)
+      end
+      @@zmq_context ||= nil
+    end
+    # !SLIDE END
+  end # class
+end # module
+
+

data/lib/asir/uuid.rb

@@ -0,0 +1,32 @@
+module ASIR
+# Provides an RFC4122-compliant random (version 4) UUID service.
+module UUID
+  # Return an RFC4122-compliant random (version 4) UUID,
+  # represented as a string of 36 characters.
+  #
+  # Possible (but unlikely!) return value:
+  #   "e29fc859-8d6d-4c5d-aa5a-1ab726f4a192".
+  #
+  # Possible exceptions:
+  #   Errno::ENOENT
+  #
+  PROC_SYS_FILE = "/proc/sys/kernel/random/uuid".freeze
+  case
+  when File.exist?(PROC_SYS_FILE)
+    def self.generate
+      File.read(PROC_SYS_FILE).chomp!
+    end
+  when (gem 'uuid' rescue nil)
+    require 'uuid'
+    def self.generate
+      ::UUID.generate
+    end
+  else
+    def self.generate
+      raise "Unimplemented"
+    end
+  end
+end
+end
+
+

data/lib/asir/version.rb

@@ -0,0 +1,3 @@
+module ASIR
+  VERSION = "0.2.0"
+end

data/spec/const_get_speed_spec.rb

@@ -0,0 +1,33 @@
+module ASIR
+  module Test
+    module NamespaceCost
+      module Relative
+        def self.m
+          Exception
+        end
+      end
+      module Absolute
+        def self.m
+          ::Exception
+        end
+      end
+    end
+  end
+end
+
+describe 'Namespace Costs' do
+  it "uses dynamic namespacing" do
+    do_it ::ASIR::Test::NamespaceCost::Relative
+  end
+  it "uses static namespacing" do
+    do_it ::ASIR::Test::NamespaceCost::Absolute
+  end
+  def do_it obj
+    t0 = Time.now
+    10_000_000.times do
+      obj.m
+    end
+    t1 = Time.now
+    puts "#{obj} #{t1.to_f - t0.to_f}"
+  end
+end

data/spec/debug_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+case (RUBY_PLATFORM rescue 'UNKNOWN')
+when /java/
+  gem 'json_pure'
+else
+  gem 'json'
+  case RUBY_VERSION
+  when /^2\./
+    gem 'simplecov'
+  when /^1\.9/
+    gem 'ruby-debug19'
+    gem 'simplecov'
+    # require 'ruby-debug' # BROKEN in 1.9.3-head
+  when /^1\.8/
+    gem 'ruby-debug'
+    gem 'rcov'
+    require 'ruby-debug'
+  end
+end
+

data/spec/example_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+$:.unshift File.expand_path('../../example', __FILE__)
+
+describe "ASIR Example" do
+  attr_accessor :file, :expects
+
+  before(:each) do
+    @expects = [ ]
+  end
+
+  after(:each) do
+    @file.should_not == nil
+    File.open(@file) do | fh |
+      until fh.eof?
+        line = fh.readline
+        line.chomp!
+        case
+        when line.sub!(/^\s*#\s*EXPECT\/:\s*/, '')
+          expect Regexp.new(line)
+        when line.sub!(/^\s*#\s*EXPECT!\/:\s*/, '')
+          expect Regexp.new(line), :'!~'
+        when line.sub!(/^\s*#\s*EXPECT:\s*/, '')
+          expect Regexp.new(Regexp.escape(line))
+        when line.sub!(/^\s*#\s*EXPECT!:\s*/, '')
+          expect Regexp.new(Regexp.escape(line)), :'!~'
+        end
+      end
+    end
+    @output, @exit_code = run_file!(@file)
+    @exit_code.should == 0
+    @expects.empty?.should_not == true
+    @expects.each do | rx, mode |
+      $stderr.puts "    Checking #{mode} #{rx.inspect}" if ENV['SPEC_VERBOSE']
+      case mode
+      when :'=~'
+        @output.should =~ rx
+      when :'!~'
+        @output.should_not =~ rx
+      else
+        raise ArgumentError
+      end
+    end
+  end
+
+  def run_file! file, output = StringIO.new('')
+    progname_save, stdout_save, stderr_save = $0, $stdout, $stderr
+    exc = system_exit = nil; exit_code = 0
+    begin
+      if true
+        cmd = "ASIR_EXAMPLE_SILENT=1 ruby -I example -I lib #{file}"
+        $stderr.puts "\n   Running #{cmd}:" if ENV['SPEC_VERBOSE']
+        output = `#{cmd} 2>&1 | tee #{file}.out`
+      else
+        $stderr.puts "\n   Loading #{file}:" if ENV['SPEC_VERBOSE']
+        $stdout.puts "*** #{$$}: client process"; $stdout.flush
+        $stdout = $stderr = output
+        $0 = file
+        Kernel.load(file, true)
+        output = output.string if StringIO === output
+      end
+    rescue ::SystemExit => system_exit
+      exit_code = 1 # ???
+    rescue ::Exception => exc
+      exit_code = -1
+    end
+    [ output, exit_code ]
+  ensure
+    $0, $stdout, $stderr = progname_save, stdout_save, stderr_save
+    $stderr.write output  if ENV['SPEC_VERBOSE']
+    if exc
+      stderr_save.puts "ERROR: #{file}: #{exc.inspect}\n#{exc.backtrace * "\n"}"
+      raise exc
+    end
+  end
+
+  def expect rx, mode = :'=~'
+    @expects << [ rx, mode ]
+  end
+
+  Dir['example/**/ex[0-9]*.rb'].sort.each do | file |
+    title = File.open(file) { | fh | fh.read(4096) }
+    title = title =~ /#\s+!SLIDE[^\n]*\n\s*#\s*([^\n]+)/ && $1
+    it "#{file} - #{title}" do
+      @file = file
+    end
+  end
+end

data/spec/json_spec.rb

@@ -0,0 +1,128 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'asir/coder/json'
+
+describe "ASIR::Coder::JSON" do
+# unless RUBY_PLATFORM =~ /java/
+  before(:each) do 
+    @enc = ASIR::Coder::JSON.new
+    @dec = @enc.dup
+  end
+
+  basic_objs = [ ]
+
+  [
+   [ nil, 'null' ],
+   true,
+   false,
+  ].each do | x |
+    x, str = *x
+    str ||= x.inspect
+    str = "[#{str}]"
+    basic_objs << [ x, str ]
+    it "should handle #{x.inspect}" do
+      out = @enc.encode(x)
+      out.should == str
+      @dec.decode(out).should == x
+    end
+  end
+
+  [
+   1234,
+   1.234,
+   [ :symbol, '"symbol"' ],
+  ].each do | x |
+    x, str = *x
+    str ||= x.inspect
+    str = "[#{str}]"
+    basic_objs << [ x, str ]
+    it "should handle #{x.inspect}" do
+      out = @enc.encode(x)
+      out.should == str
+      y = @dec.decode(out)
+      y = y.to_sym if Symbol === x
+      y.should == x
+    end
+  end
+
+  [
+   'String',
+  ].each do | x |
+    x, str = *x
+    str ||= x.inspect
+    str = "[#{str}]"
+    basic_objs << [ x, str ]
+    it "should handle #{x.inspect}" do
+      out = @enc.encode(x)
+      out.should == str
+      y = @dec.decode(out)
+      y.should == x
+    end
+  end
+
+  it "should handle empty Array" do
+    x = [ ]
+    out = @enc.encode(x)
+    out.should == "[[]]"
+    @dec.decode(out).should == x
+  end
+
+  it "should handle Array" do
+    x = basic_objs.map{|e| e[0]}
+    out = @enc.encode(x)
+    out.should == "[[null,true,false,1234,1.234,\"symbol\",\"String\"]]"
+    y = @dec.decode(out)
+    y.should == x.map{|e| Symbol === e ? e.to_s : e }
+  end
+
+  it "should handle empty Hash" do
+    x = { }
+    out = @enc.encode(x)
+    out.should == "[{}]"
+    @dec.decode(out).should == x
+  end
+
+  it "should handle Hash" do
+    x = Hash[ *basic_objs.flatten.reverse ]
+    out = @enc.encode(x)
+    out.should =~ %r{\A\[\{}
+    out.should =~ %r{\}\]\Z}
+    basic_objs.each do | v, str |
+      # out.should =~ %r{#{k.inspect}:}
+      out.should =~ %r{#{str}}
+    end
+    y = @dec.decode(out)
+    y.should == x.inject({}){|h, (k, v)| h[k] = Symbol === v ? v.to_s : v; h }
+  end
+
+  module ASIR::Coder::Test
+    class Object
+      attr_accessor :a, :h, :o
+    end
+  end
+
+  it "should handle deep objects" do
+    x = ASIR::Coder::Test::Object.new
+    x.a = [ *basic_objs.map{|a| a[0]} ]
+    x.h = Hash[ *basic_objs.flatten.reverse ]
+    x.o = ASIR::Coder::Test::Object.new
+    x.o.a = 123
+    out = @enc.encode(x)
+    # FIXME:
+    out.should =~ %r{\A\[\"#<ASIR::Coder::Test::Object:[^>]+>\"\]\Z}
+    #out.should =~ %r{<#{x.class.name.gsub('::', '.')} id=\"#{x.object_id}\" >}
+    #out.should =~ %r{</#{x.class.name.gsub('::', '.')}>}
+    y = @dec.decode(out)
+    (String === y).should == true
+=begin
+FIXME:
+    y.a.should == x.a
+    y.h.should == x.h
+    y.o.class.should == ASIR::Coder::Test::Object
+    y.o.a.should == x.o.a
+    x.instance_variables.sort { | a, b | a.to_s <=> b.to_s }.should == 
+      y.instance_variables.sort { | a, b | a.to_s <=> b.to_s }
+=end
+  end
+#end
+end
+