rack-amf 0.0.2 → 0.0.3

data/README.rdoc

@@ -1,6 +1,6 @@
 == DESCRIPTION:
 
-What will eventually become a full featured AMF gateway implemented as a Rack middleware and AMF0/3 serializers and deserializers. Currently includes a fully compliant AMF0/AMF3 deserializer, AMF3 serializer, and a Rack middleware that supports both standard AMF calls and <tt>RemoteObject</tt> calls.
+A full featured AMF gateway implemented as a Rack middleware. Includes fully compliant AMF0/AMF3 serializers and deserializers and a Rack middleware that includes a service handler and the ability to easily handle requests yourself if you don't want to use the service handler.
 
 == INSTALL:
 
@@ -19,7 +19,7 @@ config.ru:
     end
   end
   
-  Rack::AMF::Services.register('TestService', TestService.new)
+  Rack::AMF::Environment.register_service 'TestService', TestService.new
   
   run lambda {|env| [200, { 'Content-Type' => 'text/plain', 'Content-Length' => '16' }, ["Rack AMF gateway"] ] }
 

data/Rakefile

@@ -23,7 +23,7 @@ end
 
 spec = Gem::Specification.new do |s|
   s.name    = 'rack-amf'
-  s.version = '0.0.2'
+  s.version = '0.0.3'
   s.summary = 'AMF serializer/deserializer and AMF gateway packaged as a rack middleware'
 
   s.files        = FileList['README.rdoc', 'Rakefile', 'lib/**/*.rb', 'spec/**/*.rb']
@@ -51,4 +51,4 @@ task :gemspec do
   File.open("#{spec.name}.gemspec", 'w') do |f|
     f.write spec.to_ruby
   end
-end
+end

data/lib/amf/constants.rb

@@ -34,13 +34,14 @@ module AMF
   AMF3_XML_MARKER          =  0x0B #"\v"
   AMF3_BYTE_ARRAY_MARKER   =  0x0C #"\f"
 
-  # Other Markers
-  EMPTY_STRING             = 0x01
-  ANONYMOUS_OBJECT         = 0x01
-  DYNAMIC_OBJECT           = 0x0B
-  CLOSE_DYNAMIC_OBJECT     = 0x01
-  CLOSE_DYNAMIC_ARRAY      = 0x01
+  # Other AMF3 Markers
+  AMF3_EMPTY_STRING             = 0x01
+  AMF3_ANONYMOUS_OBJECT         = 0x01
+  AMF3_DYNAMIC_OBJECT           = 0x0B
+  AMF3_CLOSE_DYNAMIC_OBJECT     = 0x01
+  AMF3_CLOSE_DYNAMIC_ARRAY      = 0x01
 
-  MAX_INTEGER              = 268435455
-  MIN_INTEGER              = -268435456
+  # Other Constants
+  MAX_INTEGER               = 268435455
+  MIN_INTEGER               = -268435456
 end

data/lib/amf/pure/deserializer.rb

@@ -64,15 +64,15 @@ module AMF
         source.read(len)
       end
 
-      def read_object source
+      def read_object source, add_to_ref_cache=true
         obj = {}
+        @ref_cache << obj if add_to_ref_cache
         while true
           key = read_string source
           type = read_int8 source
           break if type == AMF0_OBJECT_END_MARKER
           obj[key.to_sym] = deserialize(source, type)
         end
-        @ref_cache << obj
         obj
       end
 
@@ -93,6 +93,8 @@ module AMF
         if key.to_i.to_s == key
           # Array
           obj = []
+          @ref_cache << obj
+
           obj[key.to_i] = deserialize(source, type)
           while true
             key = read_string source
@@ -102,7 +104,10 @@ module AMF
           end
         else
           # Hash
-          obj = {key.to_sym => deserialize(source, type)}
+          obj = {}
+          @ref_cache << obj
+
+          obj[key.to_sym] = deserialize(source, type)
           while true
             key = read_string source
             type = read_int8 source
@@ -110,17 +115,17 @@ module AMF
             obj[key.to_sym] = deserialize(source, type)
           end
         end
-        @ref_cache << obj
         obj
       end
 
       def read_array source
         len = read_word32_network(source)
         array = []
+        @ref_cache << array
+
         0.upto(len - 1) do
           array << deserialize(source)
         end
-        @ref_cache << array
         array
       end
 
@@ -132,14 +137,17 @@ module AMF
       end
 
       def read_typed_object source
+        # Create object to add to ref cache
         class_name = read_string source
-        props = read_object source
-        @ref_cache.pop
-
         obj = ClassMapper.get_ruby_obj class_name
-        ClassMapper.populate_ruby_obj obj, props, {}
         @ref_cache << obj
-        obj
+
+        # Read object props
+        props = read_object source, false
+
+        # Populate object
+        ClassMapper.populate_ruby_obj obj, props, {}
+        return obj
       end
     end
 

data/lib/amf/pure/remoting.rb

@@ -53,7 +53,7 @@ module AMF
       attr_accessor :amf_version, :headers, :messages
 
       def initialize
-        @amf_version = 3
+        @amf_version = 0
         @headers = []
         @messages = []
       end
@@ -95,7 +95,7 @@ module AMF
       include AMF::Pure::WriteIOHelpers
     end
 
-    # AMF::Request or AMF::Response header
+    # AMF::Pure::Request or AMF::Pure::Response header
     class Header
       attr_accessor :name, :must_understand, :data
 
@@ -106,7 +106,7 @@ module AMF
       end
     end
 
-    # AMF::Request or AMF::Response message
+    # AMF::Pure::Request or AMF::Pure::Response message
     class Message
       attr_accessor :target_uri, :response_uri, :data
 

data/lib/amf/pure/serializer.rb

@@ -5,7 +5,7 @@ module AMF
     # AMF0 implementation of serializer
     class Serializer
       def initialize
-        @ref_cache = SerializerCache.new
+        @ref_cache = SerializerCache.new :object
       end
 
       def version
@@ -13,9 +13,117 @@ module AMF
       end
 
       def serialize obj, stream = ""
-        if @ref_cache[obj] != nil
-          # Write reference header
+        if obj.respond_to?(:to_amf)
+          stream << obj.to_amf(self)
+        elsif @ref_cache[obj] != nil
+          write_reference @ref_cache[obj], stream
+        elsif obj.is_a?(NilClass)
+          write_null stream
+        elsif obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
+          write_boolean obj, stream
+        elsif obj.is_a?(Float) || obj.is_a?(Integer)
+          write_number obj, stream
+        elsif obj.is_a?(Symbol) || obj.is_a?(String)
+          write_string obj.to_s, stream
+        elsif obj.is_a?(Time)
+          write_date obj, stream
+        elsif obj.is_a?(Array)
+          write_array obj, stream
+        elsif obj.is_a?(Hash)
+          write_hash obj, stream
+        elsif obj.is_a?(Object)
+          write_object obj, stream
+        end
+        stream
+      end
+
+      def write_null stream
+        stream << AMF0_NULL_MARKER
+      end
+
+      def write_boolean bool, stream
+        stream << AMF0_BOOLEAN_MARKER
+        stream << pack_int8(bool ? 1 : 0)
+      end
+
+      def write_number num, stream
+        stream << AMF0_NUMBER_MARKER
+        stream << pack_double(num)
+      end
+
+      def write_string str, stream
+        len = str.length
+        if len > 2**16-1
+          stream << AMF0_LONG_STRING_MARKER
+          stream << pack_word32_network(len)
+        else
+          stream << AMF0_STRING_MARKER
+          stream << pack_int16_network(len)
+        end
+        stream << str
+      end
+
+      def write_date date, stream
+        stream << AMF0_DATE_MARKER
+
+        date.utc unless date.utc?
+        seconds = (date.to_f * 1000).to_i
+        stream << pack_double(seconds)
+
+        stream << pack_int16_network(0)
+      end
+
+      def write_reference index, stream
+        stream << AMF0_REFERENCE_MARKER
+        stream << pack_int16_network(index)
+      end
+
+      def write_array array, stream
+        @ref_cache.add_obj array
+        stream << AMF0_STRICT_ARRAY_MARKER
+        stream << pack_word32_network(array.length)
+        array.each do |elem|
+          serialize elem, stream
+        end
+      end
+
+      def write_hash hash, stream
+        @ref_cache.add_obj hash
+        stream << AMF0_HASH_MARKER
+        stream << pack_word32_network(hash.length)
+        write_prop_list hash, stream
+      end
+
+      def write_object obj, stream
+        @ref_cache.add_obj obj
+
+        # Is it a typed object?
+        class_name = ClassMapper.get_as_class_name obj
+        if class_name
+          stream << AMF0_TYPED_OBJECT_MARKER
+          stream << pack_int16_network(class_name.length)
+          stream << class_name
+        else
+          stream << AMF0_OBJECT_MARKER
+        end
+
+        write_prop_list obj, stream
+      end
+
+      private
+      include AMF::Pure::WriteIOHelpers
+      def write_prop_list obj, stream
+        # Write prop list
+        props = ClassMapper.props_for_serialization obj
+        props.sort.each do |key, value| # Sort keys before writing
+          stream << pack_int16_network(key.length)
+          stream << key
+          serialize value, stream
         end
+
+        # Write end
+        stream << pack_int16_network(0)
+        stream << AMF0_OBJECT_END_MARKER
       end
     end
 
@@ -24,8 +132,8 @@ module AMF
       attr_reader :string_cache
 
       def initialize
-        @string_cache = SerializerCache.new
-        @object_cache = SerializerCache.new
+        @string_cache = SerializerCache.new :string
+        @object_cache = SerializerCache.new :object
       end
 
       def version
@@ -121,7 +229,7 @@ module AMF
           header = array.length << 1 # make room for a low bit of 1
           header = header | 1 # set the low bit to 1
           stream << pack_integer(header)
-          stream << CLOSE_DYNAMIC_ARRAY
+          stream << AMF3_CLOSE_DYNAMIC_ARRAY
           array.each do |elem|
             serialize elem, stream
           end
@@ -137,14 +245,14 @@ module AMF
           @object_cache.add_obj obj
 
           # Always serialize things as dynamic objects
-          stream << DYNAMIC_OBJECT
+          stream << AMF3_DYNAMIC_OBJECT
 
           # Write class name/anonymous
           class_name = ClassMapper.get_as_class_name obj
           if class_name
             write_utf8_vr class_name, stream
           else
-            stream << ANONYMOUS_OBJECT
+            stream << AMF3_ANONYMOUS_OBJECT
           end
 
           # Write out properties
@@ -155,7 +263,7 @@ module AMF
           end
 
           # Write close
-          stream << CLOSE_DYNAMIC_OBJECT
+          stream << AMF3_CLOSE_DYNAMIC_OBJECT
         end
       end
 
@@ -164,7 +272,7 @@ module AMF
 
       def write_utf8_vr str, stream
         if str == ''
-          stream << EMPTY_STRING
+          stream << AMF3_EMPTY_STRING
         elsif @string_cache[str] != nil
           write_reference @string_cache[str], stream
         else
@@ -181,33 +289,37 @@ module AMF
     end
 
     class SerializerCache #:nodoc:
-      def initialize
-        @cache_index = 0
-        @store = {}
-      end
-
-      def [] obj
-        @store[object_key(obj)]
+      def self.new type
+        if type == :string
+          StringCache.new
+        elsif type == :object
+          ObjectCache.new
+        end
       end
 
-      def []= obj, value
-        @store[object_key(obj)] = value
-      end
+      class StringCache < Hash #:nodoc:
+        def initialize
+          @cache_index = 0
+        end
 
-      def add_obj obj
-        key = object_key obj
-        if @store[key].nil?
-          @store[key] = @cache_index
+        def add_obj str
+          self[str] = @cache_index
           @cache_index += 1
         end
       end
 
-      private
-      def object_key obj
-        if obj.is_a?(String)
-          obj
-        else
-          obj.object_id
+      class ObjectCache < Hash #:nodoc:
+        def initialize
+          @cache_index = 0
+        end
+
+        def [] obj
+          super(obj.object_id)
+        end
+
+        def add_obj obj
+          self[obj.object_id] = @cache_index
+          @cache_index += 1
         end
       end
     end

data/lib/amf/version.rb

@@ -1,6 +1,6 @@
 module AMF
   # AMF version
-  VERSION         = '0.0.1'
+  VERSION         = '0.0.3'
   VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/lib/rack/amf.rb

@@ -1,17 +1,68 @@
 require 'rack'
 require 'amf'
-
-require 'rack/amf/application'
-require 'rack/amf/service_manager'
-require 'rack/amf/request'
-require 'rack/amf/response'
+require 'rack/amf/environment'
 
 module Rack::AMF
-  APPLICATION_AMF = 'application/x-amf'.freeze
+  def self.new app, options={} #:nodoc:
+    # Set default mode
+    options[:mode] = :service_manager if !options[:mode]
+
+    # Which version of the middleware?
+    if options[:mode] == :pass_through
+      require 'rack/amf/middleware/pass_through'
+      Middleware::PassThrough.new(app, options)
+    elsif options[:mode] == :service_manager
+      require 'rack/amf/middleware/service_manager'
+      Middleware::ServiceManager.new(app, options)
+    else
+      raise "Invalide mode: #{options[:mode]}"
+    end
+  end
+end
+=begin
+require 'rack'
+require 'amf'
+require 'rack/amf/environment'
+
+# Rack::AMF middleware
+module Rack::AMF; end;
+
+# Bootstrap based on environment
+if defined?(Rails)
+  # Load in needed files
+  require 'rack/amf/middleware/rails'
+
+  #--
+  # Then we'll modify new to return the middleware to use in rails
+  module Rack::AMF
+    def self.new app, options={} #:nodoc:
+      Middleware::Rails.new(app, options)
+    end
+  end
+
+  # Set default configs
+  Rack::AMF::Environment.url = '/amf'
+  Rack::AMF::Environment.mode = :rails
 
-  Services = Rack::AMF::ServiceManager.new
+  # Install rails mods
+  Rack::AMF::Middleware::Rails.install_environment
+else
+  module Rack::AMF
+    def self.new app, options={} #:nodoc:
+      # Set default mode
+      options[:mode] = :service_manager if !options[:mode]
 
-  def self.new app, mode=:internal
-    Rack::AMF::Application.new(app, mode)
+      # Which version of the middleware?
+      if options[:mode] == :pass_through
+        require 'rack/amf/middleware/pass_through'
+        Middleware::PassThrough.new(app, options)
+      elsif options[:mode] == :service_manager
+        require 'rack/amf/middleware/service_manager'
+        Middleware::ServiceManager.new(app, options)
+      else
+        raise "Invalide mode: #{options[:mode]}"
+      end
+    end
   end
-end
+end
+=end

data/lib/rack/amf/environment.rb

@@ -0,0 +1,34 @@
+module Rack::AMF
+  module Environment
+    class << self
+      attr_accessor :url, :mode, :debug, :services
+      debug = false # Set to off by default
+
+      # Used to register a service for use with the ServiceManager middleware.
+      # To register a service, simply pass in the root path for the service and
+      # an object that can receive service calls.
+      #
+      # Example:
+      #
+      #   Rack::AMF::Environment.register_service 'SpecialService', SpecialService.new
+      #   Rack::AMF::Environment.register_service 'org.rack-amf.AMFService', AMFService.new
+      def register_service path, service
+        @services ||= {}
+        @services[path] = service
+      end
+
+      # Populates the environment from the given options hash, which was passed
+      # in through rack
+      def populate options={} #:nodoc:
+        url = options[:url] if options.key?(:url)
+        debug = options[:debug] if options.key?(:debug)
+        mode = options[:mode] if options.key?(:mode)
+      end
+
+      def log data #:nodoc:
+        return if !debug
+        puts data
+      end
+    end
+  end
+end

data/lib/rack/amf/middleware.rb

@@ -0,0 +1,35 @@
+require 'rack/amf/request'
+require 'rack/amf/response'
+
+module Rack::AMF
+  # Provide some helper items that can be included in the various middleware
+  # being offered.
+  module Middleware #:nodoc:
+    APPLICATION_AMF = 'application/x-amf'.freeze
+
+    # Standard middleware call method. Calls "handle" with the environment after
+    # creating the request and response objects, and handles serializing the
+    # response after the middleware is done.
+    def call env #:nodoc:
+      return @app.call(env) unless should_handle?(env)
+
+      # Wrap request and response
+      env['rack-amf.request'] = Request.new(env)
+      env['rack-amf.response'] = Response.new(env['rack-amf.request'])
+
+      # Call handle on "inheriting" class
+      handle env
+
+      # Calculate length and return response
+      response = env['rack-amf.response'].to_s
+      [200, {"Content-Type" => APPLICATION_AMF, 'Content-Length' => response.length.to_s}, [response]]
+    end
+
+    # Check if we should handle it based on the environment
+    def should_handle? env #:nodoc:
+      return false unless env['CONTENT_TYPE'] == APPLICATION_AMF
+      return false if Rack::AMF::Environment.url && env['PATH_INFO'] != Rack::AMF::Environment.url
+      true
+    end
+  end
+end

data/lib/rack/amf/middleware/pass_through.rb

@@ -0,0 +1,20 @@
+require 'rack/amf/middleware'
+
+module Rack::AMF::Middleware #:nodoc:
+  # Middleware which simply passes AMF requests through. Sets env['rack-amf.request']
+  # to the Rack::AMF::Request object and env['rack-amf.response'] to the
+  # Rack::AMF::Response object. Simply modify the response as necessary and it
+  # will be automatically serialized and sent.
+  class PassThrough
+    include Rack::AMF::Middleware
+
+    def initialize app, options={}
+      @app = app
+      Rack::AMF::Environment.populate options
+    end
+
+    def handle
+      @app.call env
+    end
+  end
+end

data/lib/rack/amf/middleware/rails.rb

@@ -0,0 +1,39 @@
+require 'rack/amf/middleware'
+
+module Rack::AMF::Middleware #:nodoc:
+  class Rails
+    include Rack::AMF::Middleware
+
+    def initialize app, options={}
+      @app = app
+
+      options.delete(:url) # Too late to modify the URL
+      Rack::AMF::Environment.populate options
+    end
+
+    def handle env
+      @app.call env
+    end
+
+    def self.install_environment
+      return if @installed
+      @installed = true
+
+      # Load in files
+      extras_dir = File.dirname(__FILE__)+'/../rails'
+      Dir["#{extras_dir}/*.rb"].each {|f| require f}
+
+      # Install route
+      ActionController::Routing::RouteSet.class_eval do
+        next if self.instance_methods.include? 'draw_with_rackamf'
+        def draw_with_rackamf
+          draw_without_rackamf do |map|
+            map.rack_amf Rack::AMF::Environment.url, :controller => 'rack_amf', :action => 'handle'
+            yield map
+          end
+        end
+        alias_method_chain :draw, :rackamf
+      end
+    end
+  end
+end

data/lib/rack/amf/middleware/service_manager.rb

@@ -0,0 +1,38 @@
+require 'rack/amf/middleware'
+
+module Rack::AMF::Middleware #:nodoc:
+  # Internal AMF handler, it uses the ServiceManager to handle request service
+  # mapping.
+  class ServiceManager
+    include Rack::AMF::Middleware
+
+    def initialize app, options={}
+      @app = app
+      Rack::AMF::Environment.populate options
+    end
+
+    def handle env
+      env['rack-amf.response'].each_method_call do |method, args|
+        handle_method method, args
+      end
+    end
+
+    private
+    def handle_method method, args
+      path = method.split('.')
+      method_name = path.pop
+      path = path.join('.')
+
+      s = Rack::AMF::Environment.services
+      if s[path]
+        if s[path].respond_to?(method_name)
+          s[path].send(method_name, *args)
+        else
+          raise "Service #{path} does not respond to #{method_name}"
+        end
+      else
+        raise "Service #{path} does not exist"
+      end
+    end
+  end
+end

data/lib/rack/amf/rails/rack_amf_controller.rb

@@ -0,0 +1,23 @@
+class RackAmfController < ApplicationController
+  def handle
+    if request.env['rack-amf.request']
+      RAILS_DEFAULT_LOGGER.info "[rack-amf] Handle request"
+      request.env['rack-amf.response'].each_method_call do |method, args|
+        handle_call method, args
+      end
+    else
+      render :text => '<html><body>Rack::AMF Gateway</body></html>'
+    end
+  end
+
+  private
+  def handle_call method, args
+    path = method.split('.')
+    raise "Invalid method '#{method}': Methods must look like this 'ServiceController.method'" if path.length != 2
+
+    action = path.pop
+    controller = path.pop
+
+    
+  end
+end

data/lib/rack/amf/request.rb

@@ -1,4 +1,5 @@
 module Rack::AMF
+  # Rack specific wrapper around AMF::Request
   class Request
     attr_reader :raw_request
 
@@ -7,6 +8,11 @@ module Rack::AMF
       @raw_request = ::AMF::Request.new.populate_from_stream(env['rack.input'].read)
     end
 
+    # Returns the request AMF version
+    def version
+      raw_request.amf_version
+    end
+
     # Returns all messages in the request
     def messages
       @raw_request.messages

data/lib/rack/amf/response.rb

@@ -1,53 +1,77 @@
 module Rack::AMF
+  # Rack specific wrapper around AMF::Response
   class Response
     attr_reader :raw_response
 
+    V = ::AMF::Values
+
     def initialize request
       @request = request
       @raw_response = ::AMF::Response.new
+      @raw_response.amf_version = @request.version == 3 ? 3 : 0 # Can't just copy version because FMS sends version as 1
     end
 
     # Builds response, iterating over each method call and using the return value
     # as the method call's return value
+    #--
+    # Iterate over all the sent messages. If they're somthing we can handle, like
+    # a command message, then simply add the response message ourselves. If it's
+    # a method call, then call the block with the method and args, catching errors
+    # for handling. Then create the appropriate response message using the return
+    # value of the block as the return value for the method call.
     def each_method_call &block
-      @request.messages.each do |m|
-        target_uri = m.response_uri
+      raise 'Response already constructed' if @constructed
 
-        rd = m.data
-        if rd.is_a?(::AMF::Values::CommandMessage)
-          if rd.operation == ::AMF::Values::CommandMessage::CLIENT_PING_OPERATION
-            data = ::AMF::Values::AcknowledgeMessage.new(rd)
+      @request.messages.each do |m|
+        # What's the request body?
+        case m.data
+        when V::CommandMessage
+          # Pings should be responded to with an AcknowledgeMessage built using the ping
+          # Everything else is unsupported
+          command_msg = m.data
+          if command_msg.operation == V::CommandMessage::CLIENT_PING_OPERATION
+            response_value = V::AcknowledgeMessage.new(command_msg)
           else
-            data == ::AMF::Values::ErrorMessage.new(Exception.new("CommandMessage #{rd.operation} not implemented"), rd)
+            response_value = V::ErrorMessage.new(Exception.new("CommandMessage #{command_msg.operation} not implemented"), command_msg)
           end
-        elsif rd.is_a?(::AMF::Values::RemotingMessage)
-          am = ::AMF::Values::AcknowledgeMessage.new(rd)
-          body = dispatch_call(rd.source+'.'+rd.operation, rd.body, rd, block)
-          if body.is_a?(::AMF::Values::ErrorMessage)
-            data = body
+        when V::RemotingMessage
+          # Using RemoteObject style message calls
+          remoting_msg = m.data
+          acknowledge_msg = V::AcknowledgeMessage.new(remoting_msg)
+          body = dispatch_call :method => remoting_msg.source+'.'+remoting_msg.operation, :args => remoting_msg.body, :source => remoting_msg, :block => block
+
+          # Response should be the bare ErrorMessage if there was an error
+          if body.is_a?(V::ErrorMessage)
+            response_value = body
           else
-            am.body = body
-            data = am
+            acknowledge_msg.body = body
+            response_value = acknowledge_msg
           end
         else
-          data = dispatch_call(m.target_uri, rd, m, block)
+          # Standard response message
+          response_value = dispatch_call :method => m.target_uri, :args => m.data, :source => m, :block => block
         end
 
-        target_uri += data.is_a?(::AMF::Values::ErrorMessage) ? '/onStatus' : '/onResult'
-        @raw_response.messages << ::AMF::Message.new(target_uri, '', data)
+        target_uri = m.response_uri
+        target_uri += response_value.is_a?(V::ErrorMessage) ? '/onStatus' : '/onResult'
+        @raw_response.messages << ::AMF::Message.new(target_uri, '', response_value)
       end
+
+      @constructed = true
     end
 
+    # Return the serialized response as a string
     def to_s
       raw_response.serialize
     end
 
     private
-    def dispatch_call method, args, source_message, handler
+    def dispatch_call p
       begin
-        handler.call(method, args)
+        p[:block].call(p[:method], p[:args])
       rescue Exception => e
-        ::AMF::Values::ErrorMessage.new(source_message, e)
+        # Create ErrorMessage object using the source message as the base
+        V::ErrorMessage.new(p[:source], e)
       end
     end
   end

data/spec/amf/class_mapping_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/../spec_helper.rb'
 
 describe AMF::ClassMapping do
   before(:all) do
-    class RubyClass
+    class ClassMappingTest
       attr_accessor :prop_a
       attr_accessor :prop_b
       attr_accessor :prop_c
@@ -12,25 +12,25 @@ describe AMF::ClassMapping do
   before :each do
     @mapper = AMF::ClassMapping.new
     @mapper.define do |m|
-      m.map :as => 'ASClass', :ruby => 'RubyClass'
+      m.map :as => 'ASClass', :ruby => 'ClassMappingTest'
     end
   end
 
   it "should return AS class name for ruby objects" do
-    @mapper.get_as_class_name(RubyClass.new).should == 'ASClass'
-    @mapper.get_as_class_name('RubyClass').should == 'ASClass'
+    @mapper.get_as_class_name(ClassMappingTest.new).should == 'ASClass'
+    @mapper.get_as_class_name('ClassMappingTest').should == 'ASClass'
   end
 
   it "should allow config modification" do
     @mapper.define do |m|
-      m.map :as => 'SecondClass', :ruby => 'RubyClass'
+      m.map :as => 'SecondClass', :ruby => 'ClassMappingTest'
     end
-    @mapper.get_as_class_name(RubyClass.new).should == 'SecondClass'
+    @mapper.get_as_class_name(ClassMappingTest.new).should == 'SecondClass'
   end
 
   describe "ruby object generator" do
     it "should instantiate a ruby class" do
-      @mapper.get_ruby_obj('ASClass').should be_a(RubyClass)
+      @mapper.get_ruby_obj('ASClass').should be_a(ClassMappingTest)
     end
 
     it "should properly instantiate namespaced classes" do
@@ -48,7 +48,7 @@ describe AMF::ClassMapping do
 
   describe "ruby object populator" do
     it "should populate a ruby class" do
-      obj = @mapper.populate_ruby_obj RubyClass.new, {:prop_a => 'Data'}
+      obj = @mapper.populate_ruby_obj ClassMappingTest.new, {:prop_a => 'Data'}
       obj.prop_a.should == 'Data'
     end
 
@@ -84,7 +84,7 @@ describe AMF::ClassMapping do
     end
 
     it "should extract object properties" do
-      obj = RubyClass.new
+      obj = ClassMappingTest.new
       obj.prop_a = 'Test A'
       obj.prop_b = 'Test B'
 
@@ -93,9 +93,9 @@ describe AMF::ClassMapping do
     end
 
     it "should extract inherited object properties" do
-      class RubyClass2 < RubyClass
+      class ClassMappingTest2 < ClassMappingTest
       end
-      obj = RubyClass2.new
+      obj = ClassMappingTest2.new
       obj.prop_a = 'Test A'
       obj.prop_b = 'Test B'
 

data/spec/amf/deserializer_spec.rb

@@ -1,6 +1,10 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 
 describe "when deserializing" do
+  before :each do
+    AMF::ClassMapper.reset
+  end
+
   describe "AMF0" do
     it "should deserialize numbers" do
       input = object_fixture('amf0-number.bin')
@@ -58,12 +62,20 @@ describe "when deserializing" do
       output.should == ['a', 'b', 'c', 'd']
     end
 
+    it "should serialize strict arrays" do
+      input = object_fixture('amf0-strict-array.bin')
+      output = AMF.deserialize(input, 0)
+      output.should == ['a', 'b', 'c', 'd']
+    end
+
     it "should deserialize dates" do
       input = object_fixture('amf0-date.bin')
       output = AMF.deserialize(input, 0)
       output.should == Time.utc(2003, 2, 13, 5)
     end
 
+    it "should deserialize XML"
+
     it "should deserialize an unmapped object as a dynamic anonymous object" do
       input = object_fixture("amf0-typed-object.bin")
       output = AMF.deserialize(input, 0)

data/spec/amf/remoting_spec.rb

@@ -29,6 +29,7 @@ end
 describe "when handling responses" do
   it "should serialize a simple call" do
     resp = AMF::Response.new
+    resp.amf_version = 3
     resp.messages << AMF::Message.new('/1/onResult', '', 'hello')
 
     expected = request_fixture('simple-response.bin')
@@ -41,6 +42,7 @@ describe "when handling responses" do
     ak.messageId = "7B0ACE15-8D57-6AE5-B9D4-99C2D32C8246"
     ak.timestamp = 0
     resp = AMF::Response.new
+    resp.amf_version = 3
     resp.messages << AMF::Message.new('/1/onResult', '', ak)
 
     expected = request_fixture('acknowledge-response.bin')

data/spec/amf/serializer_spec.rb

@@ -3,6 +3,82 @@ require File.dirname(__FILE__) + '/../spec_helper.rb'
 require 'rexml/document'
 
 describe "when serializing" do
+  before :each do
+    AMF::ClassMapper.reset
+  end
+
+  describe "AMF0" do
+    it "should serialize nils" do
+      output = AMF.serialize(nil, 0)
+      output.should == object_fixture('amf0-null.bin')
+    end
+
+    it "should serialize booleans" do
+      output = AMF.serialize(true, 0)
+      output.should === object_fixture('amf0-boolean.bin')
+    end
+
+    it "should serialize numbers" do
+      output = AMF.serialize(3.5, 0)
+      output.should == object_fixture('amf0-number.bin')
+    end
+
+    it "should serialize strings" do
+      output = AMF.serialize("this is a テスト", 0)
+      output.should == object_fixture('amf0-string.bin')
+    end
+
+    it "should serialize arrays" do
+      output = AMF.serialize(['a', 'b', 'c', 'd'], 0)
+      output.should == object_fixture('amf0-strict-array.bin')
+    end
+
+    it "should serialize references" do
+      class OtherClass
+        attr_accessor :foo, :bar
+      end
+      obj = OtherClass.new
+      obj.foo = "baz"
+      obj.bar = 3.14
+
+      output = AMF.serialize({'0' => obj, '1' => obj}, 0)
+      output.should == object_fixture('amf0-ref-test.bin')
+    end
+
+    it "should serialize dates" do
+      output = AMF.serialize(Time.utc(2003, 2, 13, 5), 0)
+      output.should == object_fixture('amf0-date.bin')
+    end
+  
+    it "should serialize hashes" do
+      output = AMF.serialize({:a => 'b', :c => 'd'}, 0)
+      output.should == object_fixture('amf0-hash.bin')
+    end
+
+    it "should serialize unmapped objects" do
+      class RubyClass
+        attr_accessor :foo, :baz
+      end
+      obj = RubyClass.new
+      obj.foo = "bar"
+
+      output = AMF.serialize(obj, 0)
+      output.should == object_fixture('amf0-untyped-object.bin')
+    end
+
+    it "should serialize mapped objects" do
+      class RubyClass
+        attr_accessor :foo, :baz
+      end
+      obj = RubyClass.new
+      obj.foo = "bar"
+      AMF::ClassMapper.define {|m| m.map :as => 'org.rackAMF.ASClass', :ruby => 'RubyClass'}
+
+      output = AMF.serialize(obj, 0)
+      output.should == object_fixture('amf0-typed-object.bin')
+    end
+  end
+
   describe "AMF3" do
     describe "simple messages" do
       it "should serialize a null" do

data/spec/amf/values/messages_spec.rb

@@ -17,7 +17,11 @@ describe AMF::Values::ErrorMessage do
     @message = AMF::Values::ErrorMessage.new(nil, @e)
   end
 
-  it "should serialize as a hash in AMF0"
+  it "should serialize as a hash in AMF0" do
+    response = AMF::Response.new
+    response.messages << AMF::Message.new('1/onStatus', '', @message)
+    response.serialize.should == request_fixture('amf0-error-response.bin')
+  end
 
   it "should extract exception properties correctly" do
     @message.faultCode.should == 'Exception'

data/spec/spec_helper.rb

@@ -21,4 +21,13 @@ end
 def create_rack_request(binary_path)
   env = {'rack.input' => StringIO.new(request_fixture(binary_path))}
   Rack::AMF::Request.new(env)
+end
+
+# Add reset support to ClassMapping
+module AMF
+  class ClassMapping
+    def reset
+      @mappings = nil
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rack-amf
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Tony Hillerson
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-04 00:00:00 -04:00
+date: 2009-10-19 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -38,10 +38,14 @@ files:
 - lib/amf/values/typed_hash.rb
 - lib/amf/version.rb
 - lib/amf.rb
-- lib/rack/amf/application.rb
+- lib/rack/amf/environment.rb
+- lib/rack/amf/middleware/pass_through.rb
+- lib/rack/amf/middleware/rails.rb
+- lib/rack/amf/middleware/service_manager.rb
+- lib/rack/amf/middleware.rb
+- lib/rack/amf/rails/rack_amf_controller.rb
 - lib/rack/amf/request.rb
 - lib/rack/amf/response.rb
-- lib/rack/amf/service_manager.rb
 - lib/rack/amf.rb
 - spec/amf/class_mapping_set_spec.rb
 - spec/amf/class_mapping_spec.rb

data/lib/rack/amf/application.rb

@@ -1,32 +0,0 @@
-require 'rack/amf/request'
-require 'rack/amf/response'
-
-module Rack::AMF
-  class Application
-    def initialize app, mode
-      @app = app
-      @mode = mode
-    end
-
-    def call env
-      if env['CONTENT_TYPE'] != APPLICATION_AMF
-        return [200, {"Content-Type" => "text/plain"}, ["Hello From Rack::AMF"]]
-      end
-
-      # Wrap request and response
-      env['amf.request'] = Request.new(env)
-      env['amf.response'] = Response.new(env['amf.request'])
-
-      # Handle request
-      if @mode == :pass_through
-        @app.call env
-      elsif @mode == :internal
-        # Have the service manager handle it
-        Services.handle(env)
-      end
-
-      response = env['amf.response'].to_s
-      [200, {"Content-Type" => APPLICATION_AMF, 'Content-Length' => response.length.to_s}, [response]]
-    end
-  end
-end

data/lib/rack/amf/service_manager.rb

@@ -1,35 +0,0 @@
-module Rack::AMF
-  class ServiceManager
-    def initialize
-      @services = {}
-    end
-
-    def register path, service
-      @services ||= {}
-      @services[path] = service
-    end
-
-    def handle env
-      env['amf.response'].each_method_call do |method, args|
-        handle_method method, args
-      end
-    end
-
-    private
-    def handle_method method, args
-      path = method.split('.')
-      method_name = path.pop
-      path = path.join('.')
-
-      if @services[path]
-        if @services[path].respond_to?(method_name)
-          @services[path].send(method_name, *args)
-        else
-          raise "Service #{path} does not respond to #{method_name}"
-        end
-      else
-        raise "Service #{path} does not exist"
-      end
-    end
-  end
-end