RocketAMF 0.0.5

data/lib/rocketamf/remoting.rb

@@ -0,0 +1,133 @@
+module RocketAMF
+  # Container for the AMF request.
+  class Request
+    attr_reader :amf_version, :headers, :messages
+
+    def initialize
+      @amf_version = 0
+      @headers = []
+      @messages = []
+    end
+
+    # Populates the request from the given stream or string. Returns self for easy
+    # chaining
+    #
+    # Example:
+    #
+    #    req = RocketAMF::Request.new.populate_from_stream(env['rack.input'].read)
+    #--
+    # Implemented in pure/remoting.rb RocketAMF::Pure::Request
+    def populate_from_stream stream
+      raise AMFError, 'Must load "rocketamf/pure"'
+    end
+  end
+
+  # Container for the response of the AMF call. Includes serialization and request
+  # handling code.
+  class Response
+    attr_accessor :amf_version, :headers, :messages
+
+    def initialize
+      @amf_version = 0
+      @headers = []
+      @messages = []
+    end
+
+    # Serializes the response to a string and returns it.
+    #--
+    # Implemented in pure/remoting.rb RocketAMF::Pure::Response
+    def serialize
+      raise AMFError, 'Must load "rocketamf/pure"'
+    end
+
+    # Builds response from the request, 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 request, &block
+      raise 'Response already constructed' if @constructed
+
+      # Set version from response
+      # Can't just copy version because FMS sends version as 1
+      @amf_version = request.amf_version == 3 ? 3 : 0 
+
+      request.messages.each do |m|
+        # What's the request body?
+        case m.data
+        when Values::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 == Values::CommandMessage::CLIENT_PING_OPERATION
+            response_value = Values::AcknowledgeMessage.new(command_msg)
+          else
+            response_value = Values::ErrorMessage.new(Exception.new("CommandMessage #{command_msg.operation} not implemented"), command_msg)
+          end
+        when Values::RemotingMessage
+          # Using RemoteObject style message calls
+          remoting_msg = m.data
+          acknowledge_msg = Values::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?(Values::ErrorMessage)
+            response_value = body
+          else
+            acknowledge_msg.body = body
+            response_value = acknowledge_msg
+          end
+        else
+          # Standard response message
+          response_value = dispatch_call :method => m.target_uri, :args => m.data, :source => m, :block => block
+        end
+
+        target_uri = m.response_uri
+        target_uri += response_value.is_a?(Values::ErrorMessage) ? '/onStatus' : '/onResult'
+        @messages << ::RocketAMF::Message.new(target_uri, '', response_value)
+      end
+
+      @constructed = true
+    end
+
+    # Return the serialized response as a string
+    def to_s
+      serialize
+    end
+
+    private
+    def dispatch_call p
+      begin
+        p[:block].call(p[:method], p[:args])
+      rescue Exception => e
+        # Create ErrorMessage object using the source message as the base
+        Values::ErrorMessage.new(p[:source], e)
+      end
+    end
+  end
+
+  # RocketAMF::Request or RocketAMF::Response header
+  class Header
+    attr_accessor :name, :must_understand, :data
+
+    def initialize name, must_understand, data
+      @name = name
+      @must_understand = must_understand
+      @data = data
+    end
+  end
+
+  # RocketAMF::Request or RocketAMF::Response message
+  class Message
+    attr_accessor :target_uri, :response_uri, :data
+
+    def initialize target_uri, response_uri, data
+      @target_uri = target_uri
+      @response_uri = response_uri
+      @data = data
+    end
+  end
+end

data/lib/rocketamf/values/array_collection.rb

@@ -0,0 +1,9 @@
+module RocketAMF
+  module Values #:nodoc:
+    class ArrayCollection < Array
+      def externalized_data=(data)
+        push(*data)
+      end
+    end
+  end
+end

data/lib/rocketamf/values/messages.rb

@@ -0,0 +1,133 @@
+module RocketAMF
+  module Values #:nodoc:
+    # Base class for all special AS3 response messages. Maps to
+    # <tt>flex.messaging.messages.AbstractMessage</tt>
+    class AbstractMessage
+      attr_accessor :clientId
+      attr_accessor :destination
+      attr_accessor :messageId
+      attr_accessor :timestamp
+      attr_accessor :timeToLive
+      attr_accessor :headers
+      attr_accessor :body
+
+      protected
+      def rand_uuid
+        [8,4,4,4,12].map {|n| rand_hex_3(n)}.join('-').to_s
+      end
+
+      def rand_hex_3(l)
+        "%0#{l}x" % rand(1 << l*4)
+      end
+    end
+
+    # Maps to <tt>flex.messaging.messages.RemotingMessage</tt>
+    class RemotingMessage < AbstractMessage
+      # The name of the service to be called including package name
+      attr_accessor :source
+
+      # The name of the method to be called
+      attr_accessor :operation
+
+      # The arguments to call the method with
+      attr_accessor :parameters
+
+      def initialize
+        @clientId = rand_uuid
+        @destination = nil
+        @messageId = rand_uuid
+        @timestamp = Time.new.to_i*100
+        @timeToLive = 0
+        @headers = {}
+        @body = nil
+      end
+    end
+
+    # Maps to <tt>flex.messaging.messages.AsyncMessage</tt>
+    class AsyncMessage < AbstractMessage
+      attr_accessor :correlationId
+    end
+
+    # Maps to <tt>flex.messaging.messages.CommandMessage</tt>
+    class CommandMessage < AsyncMessage
+      SUBSCRIBE_OPERATION = 0
+      UNSUSBSCRIBE_OPERATION = 1
+      POLL_OPERATION = 2
+      CLIENT_SYNC_OPERATION = 4
+      CLIENT_PING_OPERATION = 5
+      CLUSTER_REQUEST_OPERATION = 7
+      LOGIN_OPERATION = 8
+      LOGOUT_OPERATION = 9
+      SESSION_INVALIDATE_OPERATION = 10
+      MULTI_SUBSCRIBE_OPERATION = 11
+      DISCONNECT_OPERATION = 12
+      UNKNOWN_OPERATION = 10000
+
+      attr_accessor :operation
+
+      def initialize
+        @operation = UNKNOWN_OPERATION
+      end
+    end
+
+    # Maps to <tt>flex.messaging.messages.AcknowledgeMessage</tt>
+    class AcknowledgeMessage < AsyncMessage
+      def initialize message=nil
+        @clientId = rand_uuid
+        @destination = nil
+        @messageId = rand_uuid
+        @timestamp = Time.new.to_i*100
+        @timeToLive = 0
+        @headers = {}
+        @body = nil
+
+        if message.is_a?(AbstractMessage)
+          @correlationId = message.messageId
+        end
+      end
+    end
+
+    # Maps to <tt>flex.messaging.messages.ErrorMessage</tt> in AMF3 mode
+    class ErrorMessage < AcknowledgeMessage
+      # Extended data that will facilitate custom error processing on the client
+      attr_accessor :extendedData
+
+      # The fault code for the error, which defaults to the class name of the
+      # causing exception
+      attr_accessor :faultCode
+
+      # Detailed description of what caused the error
+      attr_accessor :faultDetail
+
+      # A simple description of the error
+      attr_accessor :faultString
+
+      # Optional "root cause" of the error
+      attr_accessor :rootCause
+
+      def initialize message, exception
+        super message
+
+        @e = exception
+        @faultCode = @e.class.name
+        @faultDetail = @e.backtrace.join("\n")
+        @faultString = @e.message
+      end
+
+      def to_amf serializer
+        stream = ""
+        if serializer.version == 0
+          data = {
+            :faultCode => @faultCode,
+            :faultDetail => @faultDetail,
+            :faultString => @faultString
+          }
+          serializer.write_hash(data, stream)
+        else
+          serializer.write_object(self, stream)
+        end
+        stream
+      end
+    end
+  end
+end

data/lib/rocketamf/values/typed_hash.rb

@@ -0,0 +1,13 @@
+module RocketAMF
+  module Values #:nodoc:
+    # Hash-like object that can store a type string. Used to preserve type information
+    # for unmapped objects after deserialization.
+    class TypedHash < Hash
+      attr_reader :type
+
+      def initialize type
+        @type = type
+      end
+    end
+  end
+end

data/lib/rocketamf/version.rb

@@ -0,0 +1,9 @@
+module RocketAMF
+  # AMF version
+  VERSION         = '0.0.4'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+  VARIANT_BINARY  = false
+end

data/spec/amf/class_mapping_set_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe RocketAMF::ClassMapping::MappingSet do
+  before :each do
+    @config = RocketAMF::ClassMapping::MappingSet.new
+  end
+
+  it "should retrieve AS mapping for ruby class" do
+    @config.map :as => 'ASTest', :ruby => 'RubyTest'
+    @config.get_as_class_name('RubyTest').should == 'ASTest'
+    @config.get_as_class_name('BadClass').should be_nil
+  end
+
+  it "should retrive ruby class name mapping for AS class" do
+    @config.map :as => 'ASTest', :ruby => 'RubyTest'
+    @config.get_ruby_class_name('ASTest').should == 'RubyTest'
+    @config.get_ruby_class_name('BadClass').should be_nil
+  end
+
+  it "should map special classes by default" do
+    SPECIAL_CLASSES = [
+      'flex.messaging.messages.AcknowledgeMessage',
+      'flex.messaging.messages.ErrorMessage',
+      'flex.messaging.messages.CommandMessage',
+      'flex.messaging.messages.ErrorMessage',
+      'flex.messaging.messages.RemotingMessage',
+      'flex.messaging.io.ArrayCollection'
+    ]
+
+    SPECIAL_CLASSES.each do |as_class|
+      @config.get_ruby_class_name(as_class).should_not be_nil
+    end
+  end
+end

data/spec/amf/class_mapping_spec.rb

@@ -0,0 +1,120 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe RocketAMF::ClassMapping do
+  before(:all) do
+    class ClassMappingTest
+      attr_accessor :prop_a
+      attr_accessor :prop_b
+      attr_accessor :prop_c
+    end
+  end
+
+  before :each do
+    @mapper = RocketAMF::ClassMapping.new
+    @mapper.define do |m|
+      m.map :as => 'ASClass', :ruby => 'ClassMappingTest'
+    end
+  end
+
+  it "should return AS class name for ruby objects" do
+    @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 => 'ClassMappingTest'
+    end
+    @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(ClassMappingTest)
+    end
+
+    it "should properly instantiate namespaced classes" do
+      module ANamespace; class TestRubyClass; end; end
+      @mapper.define {|m| m.map :as => 'ASClass', :ruby => 'ANamespace::TestRubyClass'}
+      @mapper.get_ruby_obj('ASClass').should be_a(ANamespace::TestRubyClass)
+    end
+
+    it "should return a hash with original type if not mapped" do
+      obj = @mapper.get_ruby_obj('UnmappedClass')
+      obj.should be_a(RocketAMF::Values::TypedHash)
+      obj.type.should == 'UnmappedClass'
+    end
+  end
+
+  describe "ruby object populator" do
+    it "should populate a ruby class" do
+      obj = @mapper.populate_ruby_obj ClassMappingTest.new, {:prop_a => 'Data'}
+      obj.prop_a.should == 'Data'
+    end
+
+    it "should populate a typed hash" do
+      obj = @mapper.populate_ruby_obj RocketAMF::Values::TypedHash.new('UnmappedClass'), {:prop_a => 'Data'}
+      obj[:prop_a].should == 'Data'
+    end
+
+    it "should allow custom populators" do
+      class CustomPopulator
+        def can_handle? obj
+          true
+        end
+        def populate obj, props, dynamic_props
+          obj[:populated] = true
+          obj.merge! props
+          obj.merge! dynamic_props if dynamic_props
+        end
+      end
+
+      @mapper.object_populators << CustomPopulator.new
+      obj = @mapper.populate_ruby_obj({}, {:prop_a => 'Data'})
+      obj[:populated].should == true
+      obj[:prop_a].should == 'Data'
+    end
+  end
+
+  describe "property extractor" do
+    it "should extract hash properties" do
+      hash = {:a => 'test1', :b => 'test2'}
+      props = @mapper.props_for_serialization(hash)
+      props.should == {'a' => 'test1', 'b' => 'test2'}
+    end
+
+    it "should extract object properties" do
+      obj = ClassMappingTest.new
+      obj.prop_a = 'Test A'
+      obj.prop_b = 'Test B'
+
+      hash = @mapper.props_for_serialization obj
+      hash.should == {'prop_a' => 'Test A', 'prop_b' => 'Test B', 'prop_c' => nil}
+    end
+
+    it "should extract inherited object properties" do
+      class ClassMappingTest2 < ClassMappingTest
+      end
+      obj = ClassMappingTest2.new
+      obj.prop_a = 'Test A'
+      obj.prop_b = 'Test B'
+
+      hash = @mapper.props_for_serialization obj
+      hash.should == {'prop_a' => 'Test A', 'prop_b' => 'Test B', 'prop_c' => nil}
+    end
+
+    it "should allow custom serializers" do
+      class CustomSerializer
+        def can_handle? obj
+          true
+        end
+        def serialize obj
+          {:success => true}
+        end
+      end
+
+      @mapper.object_serializers << CustomSerializer.new
+      @mapper.props_for_serialization(nil).should == {:success => true}
+    end
+  end
+end