rack-amf 0.0.4 → 1.0.0

data/lib/amf/version.rb

@@ -1,9 +0,0 @@
-module AMF
-  # 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/lib/amf.rb

@@ -1,17 +0,0 @@
-$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-$:.unshift "#{File.expand_path(File.dirname(__FILE__))}/amf/"
-
-require 'rubygems'
-require 'amf/version'
-require 'amf/common'
-
-module AMF
-  begin
-    raise LoadError, 'C extensions not implemented'
-  rescue LoadError
-    require 'amf/pure'
-  end
-  require 'amf/class_mapping'
-
-  ClassMapper = AMF::ClassMapping.new
-end

data/spec/amf/class_mapping_set_spec.rb

@@ -1,34 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-describe AMF::ClassMapping::MappingSet do
-  before :each do
-    @config = AMF::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

@@ -1,120 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-describe AMF::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 = AMF::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(AMF::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 AMF::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

data/spec/amf/deserializer_spec.rb

@@ -1,311 +0,0 @@
-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')
-      output = AMF.deserialize(input, 0)
-      output.should == 3.5
-    end
-
-    it "should deserialize booleans" do
-      input = object_fixture('amf0-boolean.bin')
-      output = AMF.deserialize(input, 0)
-      output.should === true
-    end
-
-    it "should deserialize strings" do
-      input = object_fixture('amf0-string.bin')
-      output = AMF.deserialize(input, 0)
-      output.should == "this is a テスト"
-    end
-
-    it "should deserialize anonymous objects" do
-      input = object_fixture('amf0-object.bin')
-      output = AMF.deserialize(input, 0)
-      output.should == {:foo => 'baz', :bar => 3.14}
-    end
-
-    it "should deserialize nulls" do
-      input = object_fixture('amf0-null.bin')
-      output = AMF.deserialize(input, 0)
-      output.should == nil
-    end
-
-    it "should deserialize undefineds" do
-      input = object_fixture('amf0-undefined.bin')
-      output = AMF.deserialize(input, 0)
-      output.should == nil
-    end
-
-    it "should deserialize references properly" do
-      input = object_fixture('amf0-ref-test.bin')
-      output = AMF.deserialize(input, 0)
-      output.length.should == 2
-      output[0].should === output[1]
-    end
-
-    it "should deserialize hashes" do
-      input = object_fixture('amf0-hash.bin')
-      output = AMF.deserialize(input, 0)
-      output.should == {:a => 'b', :c => 'd'}
-    end
-
-    it "should deserialize arrays from flash player" do
-      # Even Array is serialized as a "hash", so check that deserializer converts to array
-      input = object_fixture('amf0-ecma-ordinal-array.bin')
-      output = AMF.deserialize(input, 0)
-      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)
-
-      output.type.should == 'org.rackAMF.ASClass'
-      output.should == {:foo => 'bar', :baz => nil}
-    end
-
-    it "should deserialize a mapped object as a mapped ruby class instance" do
-      class RubyClass
-        attr_accessor :foo, :baz
-      end
-      AMF::ClassMapper.define {|m| m.map :as => 'org.rackAMF.ASClass', :ruby => 'RubyClass'}
-
-      input = object_fixture("amf0-typed-object.bin")
-      output = AMF.deserialize(input, 0)
-
-      output.should be_a(RubyClass)
-      output.foo.should == 'bar'
-      output.baz.should == nil
-    end
-  end
-
-  describe "AMF3" do
-    describe "simple messages" do
-      it "should deserialize a null" do
-        input = object_fixture("amf3-null.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == nil
-      end
-
-      it "should deserialize a false" do
-        input = object_fixture("amf3-false.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == false
-      end
-
-      it "should deserialize a true" do
-        input = object_fixture("amf3-true.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == true
-      end
-
-      it "should deserialize integers" do
-        input = object_fixture("amf3-max.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == AMF::MAX_INTEGER
-
-        input = object_fixture("amf3-0.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == 0
-
-        input = object_fixture("amf3-min.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == AMF::MIN_INTEGER
-      end
-
-      it "should deserialize large integers" do
-        input = object_fixture("amf3-largeMax.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == AMF::MAX_INTEGER + 1
-
-        input = object_fixture("amf3-largeMin.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == AMF::MIN_INTEGER - 1
-      end
-
-      it "should deserialize BigNums" do
-        input = object_fixture("amf3-bigNum.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == 2**1000
-      end
-
-      it "should deserialize a simple string" do
-        input = object_fixture("amf3-string.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == "String . String"
-      end
-
-      it "should deserialize a symbol as a string" do
-        input = object_fixture("amf3-symbol.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == "foo"
-      end
-
-      it "should deserialize dates" do
-        input = object_fixture("amf3-date.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == Time.at(0)
-      end
-
-      #BAH! Who sends XML over AMF?
-      it "should deserialize a REXML document"
-    end
-
-    describe "objects" do
-      it "should deserialize an unmapped object as a dynamic anonymous object" do
-        input = object_fixture("amf3-dynObject.bin")
-        output = AMF.deserialize(input, 3)
-
-        expected = {
-          :property_one => 'foo',
-          :property_two => 1,
-          :nil_property => nil,
-          :another_public_property => 'a_public_value'
-        }
-        output.should == expected
-      end
-
-      it "should deserialize a mapped object as a mapped ruby class instance" do
-        class RubyClass
-          attr_accessor :foo, :baz
-        end
-        AMF::ClassMapper.define {|m| m.map :as => 'org.rackAMF.ASClass', :ruby => 'RubyClass'}
-
-        input = object_fixture("amf3-typedObject.bin")
-        output = AMF.deserialize(input, 3)
-
-        output.should be_a(RubyClass)
-        output.foo.should == 'bar'
-        output.baz.should == nil
-      end
-
-      it "should deserialize a hash as a dynamic anonymous object" do
-        input = object_fixture("amf3-hash.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == {:foo => "bar", :answer => 42}
-      end
-
-      it "should deserialize an empty array" do
-        input = object_fixture("amf3-emptyArray.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == []
-      end
-
-      it "should deserialize an array of primatives" do
-        input = object_fixture("amf3-primArray.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == [1,2,3,4,5]
-      end
-
-      it "should deserialize an array of mixed objects" do
-        input = object_fixture("amf3-mixedArray.bin")
-        output = AMF.deserialize(input, 3)
-
-        h1 = {:foo_one => "bar_one"}
-        h2 = {:foo_two => ""}
-        so1 = {:foo_three => 42}
-        output.should == [h1, h2, so1, {:foo_three => nil}, {}, [h1, h2, so1], [], 42, "", [], "", {}, "bar_one", so1]
-      end
-
-      it "should deserialize a byte array"
-    end
-
-    describe "and implementing the AMF Spec" do
-      it "should keep references of duplicate strings" do
-        input = object_fixture("amf3-stringRef.bin")
-        output = AMF.deserialize(input, 3)
-
-        class StringCarrier; attr_accessor :str; end
-        foo = "foo"
-        bar = "str"
-        sc = StringCarrier.new
-        sc = {:str => foo}
-        output.should == [foo, bar, foo, bar, foo, sc]
-      end
-
-      it "should not reference the empty string" do
-        input = object_fixture("amf3-emptyStringRef.bin")
-        output = AMF.deserialize(input, 3)
-        output.should == ["",""]
-      end
-
-      it "should keep references of duplicate dates" do
-        input = object_fixture("amf3-datesRef.bin")
-        output = AMF.deserialize(input, 3)
-
-        output[0].should equal(output[1])
-        # Expected object:
-        # [DateTime.parse "1/1/1970", DateTime.parse "1/1/1970"]
-      end
-
-      it "should keep reference of duplicate objects" do
-        input = object_fixture("amf3-objRef.bin")
-        output = AMF.deserialize(input, 3)
-
-        obj1 = {:foo => "bar"}
-        obj2 = {:foo => obj1[:foo]}
-        output.should == [[obj1, obj2], "bar", [obj1, obj2]]
-      end
-
-      it "should keep references of duplicate arrays" do
-        input = object_fixture("amf3-arrayRef.bin")
-        output = AMF.deserialize(input, 3)
-
-        a = [1,2,3]
-        b = %w{ a b c }
-        output.should == [a, b, a, b]
-      end
-
-      it "should not keep references of duplicate empty arrays unless the object_id matches" do
-        input = object_fixture("amf3-emptyArrayRef.bin")
-        output = AMF.deserialize(input, 3)
-
-        a = []
-        b = []
-        output.should == [a,b,a,b]
-      end
-
-      it "should keep references of duplicate XML and XMLDocuments"
-      it "should keep references of duplicate byte arrays"
-
-      it "should deserialize a deep object graph with circular references" do
-        input = object_fixture("amf3-graphMember.bin")
-        output = AMF.deserialize(input, 3)
-
-        output[:children][0][:parent].should === output
-        output[:parent].should === nil
-        output[:children].length.should == 2
-        # Expected object:
-        # parent = Hash.new
-        # child1 = Hash.new
-        # child1[:parent] = parent
-        # child1[:children] = []
-        # child2 = Hash.new
-        # child2[:parent] = parent
-        # child2[:children] = []
-        # parent[:parent] = nil
-        # parent[:children] = [child1, child2]
-      end
-    end
-  end
-end

data/spec/amf/remoting_spec.rb

@@ -1,51 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-describe "when handling requests" do
-  it "should handle remoting message from remote object" do
-    input = request_fixture("remotingMessage.bin")
-    req = AMF::Request.new.populate_from_stream(input)
-
-    req.headers.length.should == 0
-    req.messages.length.should == 1
-    message = req.messages[0].data
-    message.should be_a(AMF::Values::RemotingMessage)
-    message.messageId.should == "FE4AF2BC-DD3C-5470-05D8-9971D51FF89D"
-    message.body.should == [true]
-  end
-
-  it "should handle command message from remote object" do
-    input = request_fixture("commandMessage.bin")
-    req = AMF::Request.new.populate_from_stream(input)
-
-    req.headers.length.should == 0
-    req.messages.length.should == 1
-    message = req.messages[0].data
-    message.should be_a(AMF::Values::CommandMessage)
-    message.messageId.should == "7B0ACE15-8D57-6AE5-B9D4-99C2D32C8246"
-    message.body.should == {}
-  end
-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')
-    resp.serialize.should == expected
-  end
-
-  it "should serialize a AcknowledgeMessage response" do
-    ak = AMF::Values::AcknowledgeMessage.new
-    ak.clientId = "7B0ACE15-8D57-6AE5-B9D4-99C2D32C8246"
-    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')
-    resp.serialize.should == expected
-  end
-end