asir 0.2.0

data/lib/asir/coder/xml.rb

@@ -0,0 +1,213 @@
+require 'asir'
+require 'asir/object_resolving'
+gem 'libxml-ruby'
+require 'xml'
+
+module ASIR
+  class Coder
+    # !SLIDE
+    # XML
+    #
+    # Encode/Decode objects as XML.
+    class XML < self
+      class Error < ::ASIR::Error
+        class BadIdref < self; end
+      end
+      def _encode obj
+        @stream = ''
+        @dom_id_map = { }
+        @dom_id = 0
+        @cls_tag_map = { }
+        encode_dom obj
+        @stream
+      end
+
+      def _decode obj
+        @stream = obj
+        @decoder ||= DECODER; @decoder_object = nil
+        @dom_id_map = { }
+        @dom_id = 0
+        @cls_tag_map = { }
+        @parser = ::XML::Parser.string(@stream)
+        @dom = @parser.parse
+        decode_dom @dom.root
+      end
+
+      def encode_dom obj
+        if dom_id = @dom_id_map[obj.object_id]
+          tag_obj(obj, nil, :idref => dom_id.first)
+        else
+          _encode_dom obj
+        end
+      end
+
+      def _encode_dom obj
+        case obj
+        when NilClass, TrueClass, FalseClass
+          tag_obj(obj)
+        when Numeric
+          tag_obj(obj, nil, :v => obj.to_s)
+        when Symbol
+          tag_obj(obj) do
+            @stream << obj.to_s
+          end
+        when String
+          tag_obj(obj, :id) do 
+            @stream << obj.to_s
+          end
+        when Array
+          tag_obj(obj, :id) do 
+            obj.each do | elem |
+              encode_dom elem
+            end
+          end
+        when Hash
+          tag_obj(obj, :id) do 
+            obj.each do | key, val |
+              encode_dom key
+              encode_dom val
+            end
+          end
+        else
+          tag_obj(obj, :id) do 
+            obj.instance_variables.each do | attr |
+              val = obj.instance_variable_get(attr)
+              key = attr.to_s.sub(/^@/, '')
+              tag(key) do 
+                encode_dom val
+              end
+            end
+          end
+        end
+      end
+
+      def tag_obj obj, with_id = false, attrs = nil
+        if block_given?
+          tag(cls_tag(obj), with_id ? { with_id => map_obj_to_dom_id!(obj) } : nil) do
+            yield
+          end
+        else
+          tag(cls_tag(obj), attrs)
+        end
+      end
+
+      CC = '::'.freeze; D = '.'.freeze
+      def cls_tag obj
+        obj = obj.class
+        @cls_tag_map[obj] ||= obj.name.gsub(CC, D).freeze
+      end
+
+      def map_obj_to_dom_id! obj
+        if dom_id = @dom_id_map[obj.object_id]
+          dom_id.first
+        else
+          @dom_id_map[obj.object_id] = [ @dom_id += 1, obj ]
+          @dom_id
+        end
+      end
+
+      B  = '<'.freeze;  S = ' '.freeze; E = '>'.freeze; SE = '/>'.freeze
+      BS = '</'.freeze; A = '='.freeze
+      def tag tag, attrs = nil
+        tag = tag.to_s
+        @stream << B << tag << S
+        if attrs
+          attrs.each do | key, val |
+            @stream << key.to_s << A << val.to_s.inspect << S
+          end
+        end
+        if block_given?
+          @stream << E; yield; @stream << BS << tag << E
+        else
+          @stream << SE
+        end
+      end
+
+      ################################################################
+
+      def decode_dom dom
+        if dom_id = dom.attributes[:idref]
+          unless obj = @dom_id_map[dom_id]
+            raise Error::BadIdref, "in element #{dom}"
+          end
+          obj
+        else
+          obj = _decode_dom(dom)
+          map_dom_id_to_obj! dom, obj if dom.attributes[:id]
+          obj
+        end
+      end
+
+      def _decode_dom dom
+        cls_name = dom.name
+        decoder = @decoder[cls_name] || 
+          (@decoder_object ||= @decoder['Object'])
+        raise Error, "BUG: " unless decoder
+        decoder.call(self, dom)
+      end
+
+      DECODER = {
+        'NilClass'   => lambda { | _, dom | nil },
+        'TrueClass'  => lambda { | _, dom | true },
+        'FalseClass' => lambda { | _, dom | false },
+        'String'     => lambda { | _, dom | (dom.attributes[:v] || dom.content) },
+        'Symbol'     => lambda { | _, dom | (dom.attributes[:v] || dom.content).to_sym },
+        'Integer'    => lambda { | _, dom | (dom.attributes[:v] || dom.content).to_i },
+        'Float'      => lambda { | _, dom | (dom.attributes[:v] || dom.content).to_f },
+        "Array" => lambda { | _, dom | 
+          obj = [ ]
+          _.map_dom_id_to_obj! dom, obj
+          dom.each_element do | elem |
+            obj << _.decode_dom(elem)
+          end
+          obj
+        },
+        'Hash' => lambda { | _, dom |
+          obj = { }
+          _.map_dom_id_to_obj! dom, obj
+          key = nil
+          dom.each_element do | val |
+            if key
+              obj[_.decode_dom(key)] = _.decode_dom(val)
+              key = nil
+            else
+              key = val
+            end
+          end
+          obj
+        },
+        'Object' => lambda { | _, dom |
+          cls_name = dom.name
+          # $stderr.puts "cls_name = #{cls_name.inspect}"
+          cls = _.tag_cls(cls_name)
+          obj = cls.allocate
+          _.map_dom_id_to_obj! dom, obj
+          dom.each_element do | child |
+            key = child.name
+            val = _.decode_dom child.first
+            obj.instance_variable_set("@#{key}", val)
+          end
+          obj
+        },
+      }
+      DECODER['Fixnum'] = DECODER['Bignum'] = DECODER['Integer']
+
+      def map_dom_id_to_obj! dom, obj
+        dom_id = dom.attributes[:id]
+        debugger unless dom_id
+        raise Error, "no :id attribute in #{dom}" unless dom_id
+        if (other_obj = @dom_id_map[dom_id]) and other_obj.object_id != obj.object_id
+          raise Error, "BUG: :id #{dom_id} already used for #{other_obj.class.name} #{other_obj.inspect}"
+        end
+        @dom_id_map[dom_id] = obj
+      end
+
+      include ObjectResolving
+      def tag_cls cls_name
+        @cls_tag_map[cls_name.freeze] ||= resolve_object(cls_name.gsub('.', '::'))
+      end
+
+    end
+    # !SLIDE END
+  end
+end

data/lib/asir/coder/yaml.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+
+module ASIR
+  class Coder
+    # !SLIDE
+    # YAML Coder
+    # Use YAML for encode/decode.
+    class Yaml < self
+      def _encode obj
+        case obj
+        when Message, Result
+          obj = obj.encode_more!
+        end
+        ::YAML::dump(obj)
+      rescue ::Exception
+        require 'pp'
+        msg = "#{self}: failed to encode: #{$!.inspect}:\n  #{PP.pp(obj, '')}"
+        $stderr.puts msg
+        raise Error, msg
+      end
+
+      def _decode obj
+        case obj = ::YAML::load(obj)
+        when Message, Result
+          obj.decode_more!
+        else
+          obj
+        end
+      end
+    end # class
+  end # class
+end # module
+

data/lib/asir/coder/zlib.rb

@@ -0,0 +1,21 @@
+require 'asir'
+
+require 'zlib'
+
+module ASIR
+  class Coder
+    class Zlib < self
+      attr_accessor :compression_level
+
+      def _encode obj
+        raise TypeError unless String === obj
+        ::Zlib::Deflate.deflate(obj, @compression_level || ::Zlib::DEFAULT_COMPRESSION)
+      end
+      def _decode obj
+        raise TypeError unless String === obj
+        ::Zlib::Inflate.inflate(obj)
+      end
+    end
+  end
+end
+

data/lib/asir/configuration.rb

@@ -0,0 +1,32 @@
+module ASIR
+  IDENTITY_PROC = lambda { | x | x }
+  module Configuration
+    def self.included target
+      super
+      target.extend ClassMethods
+    end
+
+    # Global default config_proc
+    def self.config_proc_hash
+      @@config_proc_hash ||= { }
+    end
+
+    module ClassMethods
+      def config_proc
+        ASIR::Configuration.config_proc_hash[self]
+      end
+      def config_proc= x
+        ASIR::Configuration.config_proc_hash[self] = x
+      end
+    end
+
+    def initialize *args
+      super
+      ch = ASIR::Configuration.config_proc_hash
+      (self.class.ancestors.map{|m| ch[m]}.compact.first ||
+       ch[nil] || 
+       IDENTITY_PROC
+       ).call(self)
+    end
+  end
+end

data/lib/asir/error.rb

@@ -0,0 +1,34 @@
+module ASIR
+  # Generic API error.
+  class Error < ::Exception
+    # Subclass should override method.
+    class SubclassResponsibility < self; end
+
+    # Unsupported Feature.
+    class Unsupported < self; end
+
+    # Requested Stop.
+    class Terminate < self; end
+
+    # Unforwardable Exception.
+    #
+    # This encapsulates an Exception that should never be
+    # forwarded and re-thrown directly in the client.
+    # E.g.: SystemExit, Interrupt.
+    class Unforwardable < self
+      attr_accessor :original
+      def initialize msg, original = nil, *args
+        if ::Exception === msg
+          original ||= msg
+          msg = "#{original.class.name} #{msg.message}"
+        end
+        @original = original
+        super(msg)
+        self.set_backtrace original && original.backtrace
+      end
+      def self.unforwardable;    @@unforwardable; end
+      def self.unforwardable= x; @@unforwardable = x; end
+      @@unforwardable ||= [ ::SystemExit, ::Interrupt ]
+    end
+  end
+end

data/lib/asir/identity.rb

@@ -0,0 +1,36 @@
+require 'asir/uuid'
+require 'thread' # Mutex
+
+module ASIR
+  # !SLIDE
+  # Message Identity
+  #
+  module Identity
+    attr_accessor :identifier, :timestamp
+
+    # Optional: Opaque data about the Client that created the Message.
+    attr_accessor :client
+
+    # Optional: Opaque data about the Service that handled the Result.
+    attr_accessor :server
+
+    # Creates a thread-safe unique identifier.
+    def create_identifier!
+      @identifier ||= 
+        @@identifier_mutex.synchronize do
+          if @@uuid_pid != $$
+            @@uuid_pid = $$
+            @@uuid = nil
+          end
+          "#{@@counter += 1}-#{@@uuid ||= ::ASIR::UUID.generate}".freeze
+        end
+    end
+    @@counter ||= 0; @@uuid ||= nil; @@uuid_pid = nil; @@identifier_mutex ||= Mutex.new
+
+    # Creates a timestamp.
+    def create_timestamp!
+      @timestamp ||= 
+        ::Time.now.gmtime
+    end
+  end
+end

data/lib/asir/initialization.rb

@@ -0,0 +1,23 @@
+
+module ASIR
+  # !SLIDE
+  # Object Initialization
+  #
+  # Support initialization by Hash.
+  #
+  # E.g.:
+  #   Foo.new(:bar => 1, :baz => 2)
+  # ->
+  #   obj = Foo.new; obj.bar = 1; obj.baz = 2; obj
+  module Initialization
+    def initialize opts = nil
+      opts ||= EMPTY_HASH
+      initialize_before_opts if respond_to? :initialize_before_opts
+      opts.each do | k, v |
+        send(:"#{k}=", v)
+      end
+      initialize_after_opts if respond_to? :initialize_after_opts
+    end
+  end
+end
+

data/lib/asir/log.rb

@@ -0,0 +1,82 @@
+module ASIR
+  # !SLIDE
+  # Diagnostic Logging
+  #
+  # Logging mixin.
+  module Log
+    attr_accessor :_logger
+
+    def self.included target
+      super
+      target.send(:extend, ClassMethods)
+    end
+
+    @@enabled = false
+    def self.enabled
+      @@enabled
+    end
+    def self.enabled= x
+      @@enabled = x
+    end
+
+    module ClassMethods
+      def _log_enabled= x
+        (Thread.current[:'ASIR::Log.enabled'] ||= { })[self] = x
+      end
+      def _log_enabled?
+        (Thread.current[:'ASIR::Log.enabled'] ||= { })[self]
+      end
+    end
+
+    def _log_enabled= x
+      @_log_enabled = x
+    end
+
+    def _log_enabled?
+      ASIR::Log.enabled || 
+        @_log_enabled || 
+        self.class._log_enabled?
+    end
+
+    def _log msg = nil
+      return unless _log_enabled?
+      msg ||= yield if block_given?
+      msg = String === msg ? msg : _log_format(msg)
+      msg = "  #{$$} #{Module === self ? self : self.class} #{msg}"
+      case @_logger
+      when Proc
+        @_logger.call msg
+      when IO
+        @_logger.puts msg
+      else
+        $stderr.puts msg
+      end
+      nil
+    end
+
+    def _log_result msg
+      _log { 
+        msg = String === msg ? msg : _log_format(msg);
+        "#{msg} => ..." }
+      result = yield
+      _log { "#{msg} => \n    #{result.inspect}" }
+      result
+    end
+
+    def _log_format obj
+      case obj
+      when Exception
+        msg = "#{obj.inspect}"
+        msg << "\n    #{obj.backtrace * "\n    "}" if false
+        msg
+      when Array
+        obj.map { | x | _log_format x } * ", "
+      else
+        obj.inspect
+      end
+    end
+  end # module
+end # module
+
+
+