ruby_sol 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b2593b67e173346abecef94cbccce4e9df27a752
+  data.tar.gz: 326e3fdfedc35f62b87ef8f52d09dd948dde2513
+SHA512:
+  metadata.gz: a5622c3d5f7dd27f473886ff0a594a645e8617e85597a04e077df44ddfca31862c1f9efaceefdee6ef9079d962a1c06eebf7c139ad28d9e5b54add7158a662b9
+  data.tar.gz: 7f14fdcaaacb200e80507c9537aa771c32844e006c136c0926801ba300f839afbecb64aa4d5e6847fb4b759ee81b8f6d0dd1727d9ea7a1251967a76742804037

data/README.rdoc

@@ -0,0 +1,90 @@
+== DESCRIPTION:
+
+ruby_sol - based on RocketAMF reader/write of Flash Player's .sol files.
+
+== INSTALLATION
+    gem install ruby_sol
+
+== EXAMPLE
+
+    require 'pp'
+    require "stringio"
+    require 'ruby_sol'
+    
+    #
+    # reading sol file
+    #
+    # read_sol adds 2 field automatically
+    # __ruby_sol__amf_version - version of amf inside sol
+    # __ruby_sol__sol_name - name of the sol stored inside file
+    #
+    filename = 'test.sol';
+    content = RubySol::read_sol(File.new(filename).read)
+    pp content
+    
+    
+    #
+    # writing sol file
+    #
+    # data to store should be hash (as sol is key-value storage)
+    # hash keys - should be string, values - any object (that can be encoded via AMF)
+    # hash keys with __ruby_sol__ prefix don't stored, but used
+    # to send some sol-encoding parameters.
+    data = { "__ruby_sol__amf_version" => 3,        # tells RubySol which amf version should be used
+             "__ruby_sol__sol_name"    => "test",   # tells RubySol the name of sol should be written inside
+             "sample_data1"=>  {
+                'a'=>'b',
+                'c' => [1,2,3,4],
+                "float"=>135799632.71333,
+                "datetime"=>DateTime.new(2013,4,26,8,0,0,'+2'),
+                "int" => 1,
+            },
+            'sample_data2' => ['a', 'b', 'c']
+    }
+    f = File.new('test.sol' , 'w')
+    f.write(RubySol::create_sol(data))
+    f.close()
+
+== EXAMPLE2 - dump all FlashPlayer's files content
+
+    require 'pp'
+    require "stringio"
+    require 'ruby_sol'
+    
+    files = Dir.glob(ENV['HOME']+"/.macromedia/Flash_Player/**/*.sol")
+    files.each {|filename|
+         puts filename
+         pp RubySol::read_sol(File.new(filename).read)
+    }
+
+== SEE ALSO:
+
+* http://wiki.gnashdev.org/SOL
+* http://www.pyamf.org/tutorials/general/sharedobject.html
+
+== LICENSE:
+
+RocketAMF's licence
+
+(The MIT License)
+
+Copyright (c) 2011 Stephen Augenstein and Jacob Henry
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'rake'
+require 'rdoc/task'
+require 'rubygems/package_task'
+require 'rspec/core/rake_task'
+
+desc 'Default: run the specs.'
+task :default => :spec
+
+# I don't want to depend on bundler, so we do it the bundler way without it
+gemspec_path = 'RubySol.gemspec'
+spec = begin
+  eval(File.read(File.join(File.dirname(__FILE__), gemspec_path)), TOPLEVEL_BINDING, gemspec_path)
+rescue LoadError => e
+  original_line = e.backtrace.find { |line| line.include?(gemspec_path) }
+  msg  = "There was a LoadError while evaluating #{gemspec_path}:\n  #{e.message}"
+  msg << " from\n  #{original_line}" if original_line
+  msg << "\n"
+  puts msg
+  exit
+end
+
+RSpec::Core::RakeTask.new do |t|
+end
+
+desc 'Generate documentation'
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = spec.name
+  rdoc.options += spec.rdoc_options
+  rdoc.rdoc_files.include(*spec.extra_rdoc_files)
+  rdoc.rdoc_files.include("lib") # Don't include ext folder because no one cares
+end
+
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+
+desc "Build gem packages"
+task :gems do
+  sh "rake  gem RUBY_CC_VERSION=1.8.7:1.9.2"
+end

data/lib/ruby_sol.rb

@@ -0,0 +1,113 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$:.unshift "#{File.expand_path(File.dirname(__FILE__))}/ruby_sol/"
+
+require "date"
+require "stringio"
+require 'ruby_sol/extensions'
+require 'ruby_sol/class_mapping'
+require 'ruby_sol/constants'
+require 'ruby_sol/pure/deserializer'
+require 'ruby_sol/pure/serializer'
+
+SOL_HEADER = "\0\xBF"
+SOL_SIGNATURE = "TCSO\0\x04\0\0\0\0"
+SOL_PADDING = "\0"
+
+module RubySol
+
+  Deserializer = RubySol::Pure::Deserializer
+  Serializer = RubySol::Pure::Serializer
+
+  # usage RubySol::read_sol(File.new(filename, 'r:ASCII-8BIT').read)
+  def self.read_sol(source)
+
+    if StringIO === source
+      f = source
+    elsif source
+      f = StringIO.new(source)
+    elsif f.nil?
+      raise AMFError, "no source to deserialize"
+    end
+
+    header = f.read(2)
+    len=f.read(4).unpack('N').first
+    throw SOLError, 'bad size' unless (len + 6 == f.size)
+    signature = f.read(10)
+    throw SOLError, 'bad signature' unless (signature == SOL_SIGNATURE)
+
+    des = RubySol::Deserializer.new(RubySol::ClassMapper.new)
+    des.source = f
+    sol_name=des.amf0_read_string()
+
+    zeros=f.read(3)
+    throw SOLError, 'bad signature' unless (zeros == SOL_PADDING * 3)
+
+    amf_version = f.read(1).unpack('C').first
+    values = {'__ruby_sol__amf_version' => amf_version,
+              '__ruby_sol__sol_name' => sol_name }
+
+    des.source = f
+
+    while !f.eof?
+      str = amf_version == 3? des.amf3_read_string() : des.amf0_read_string();
+      obj = amf_version == 3? des.amf3_deserialize() : des.amf0_deserialize();
+      values[str] = obj
+      padding = f.read(1);
+    end
+    return values
+  end
+
+  def self.create_sol(content)
+    name = content['__ruby_sol__sol_name'] || 'unknown'
+    version = content['__ruby_sol__amf_version'] || 0
+
+    ser = RubySol::Serializer.new(RubySol::ClassMapper.new)
+
+    ser.stream << SOL_SIGNATURE
+    ser.amf0_write_string_wo_marker(name)
+    ser.stream << SOL_PADDING * 3
+    ser.stream << [version].pack('c')
+
+    content.each_key { |key|
+      if key !~ /^__ruby_sol__/
+        if version == 0
+          ser.amf0_write_string_wo_marker(key)
+          ser.amf0_serialize(content[key])
+          ser.stream << SOL_PADDING
+        elsif version == 3
+          ser.amf3_write_utf8_vr(key)
+          ser.amf3_serialize(content[key])
+          ser.stream << SOL_PADDING
+        end
+      end
+    }
+    res = ser.stream
+    return SOL_HEADER.force_encoding("ASCII-8BIT") + [res.bytesize].pack('N').force_encoding("ASCII-8BIT") + res.force_encoding("ASCII-8BIT")
+  end
+  # We use const_missing to define the active ClassMapper at runtime. This way,
+  # heavy modification of class mapping functionality is still possible without
+  # forcing extenders to redefine the constant.
+  def self.const_missing const #:nodoc:
+    if const == :ClassMapper
+      RubySol.const_set(:ClassMapper, RubySol::ClassMapping)
+    else
+      super(const)
+    end
+  end
+
+  # to have RocketAMF specs compatibility
+  def self.deserialize source, amf_version = 0
+    des = RubySol::Deserializer.new(RubySol::ClassMapper.new)
+    des.deserialize(amf_version, source)
+  end
+  def self.serialize obj, amf_version = 0
+    ser = RubySol::Serializer.new(RubySol::ClassMapper.new)
+    ser.serialize(amf_version, obj)
+  end
+
+  # The base exception for AMF errors.
+  class AMFError < StandardError; end
+
+  # The base exception for ruby SOL errors.
+  class SOLError < StandardError; end
+end

data/lib/ruby_sol/class_mapping.rb

@@ -0,0 +1,250 @@
+#require 'ruby_sol/values/typed_hash'
+#require 'ruby_sol/values/messages'
+module RubySol
+  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
+
+module RubySol
+  # Container for all mapped classes
+  class MappingSet
+    # Creates a mapping set object and populates the default mappings
+    def initialize
+      @as_mappings = {}
+      @ruby_mappings = {}
+      map_defaults
+    end
+
+    # Adds required mapping configs, calling map for the required base mappings.
+    # Designed to allow extenders to take advantage of required default mappings.
+    def map_defaults
+#      map :as => 'flex.messaging.messages.AbstractMessage', :ruby => 'RubySol::Values::AbstractMessage'
+#      map :as => 'flex.messaging.messages.RemotingMessage', :ruby => 'RubySol::Values::RemotingMessage'
+#      map :as => 'flex.messaging.messages.AsyncMessage', :ruby => 'RubySol::Values::AsyncMessage'
+#      map :as => 'DSA', :ruby => 'RubySol::Values::AsyncMessageExt'
+#      map :as => 'flex.messaging.messages.CommandMessage', :ruby => 'RubySol::Values::CommandMessage'
+#      map :as => 'DSC', :ruby => 'RubySol::Values::CommandMessageExt'
+#      map :as => 'flex.messaging.messages.AcknowledgeMessage', :ruby => 'RubySol::Values::AcknowledgeMessage'
+#      map :as => 'DSK', :ruby => 'RubySol::Values::AcknowledgeMessageExt'
+#      map :as => 'flex.messaging.messages.ErrorMessage', :ruby => 'RubySol::Values::ErrorMessage'
+      self
+    end
+
+    # Map a given AS class to a ruby class.
+    #
+    # Use fully qualified names for both.
+    #
+    # Example:
+    #
+    #   m.map :as => 'com.example.Date', :ruby => 'Example::Date'
+    def map params
+      [:as, :ruby].each {|k| params[k] = params[k].to_s} # Convert params to strings
+      @as_mappings[params[:as]] = params[:ruby]
+      @ruby_mappings[params[:ruby]] = params[:as]
+    end
+
+    # Returns the AS class name for the given ruby class name, returing nil if
+    # not found
+    def get_as_class_name class_name #:nodoc:
+      @ruby_mappings[class_name.to_s]
+    end
+
+    # Returns the ruby class name for the given AS class name, returing nil if
+    # not found
+    def get_ruby_class_name class_name #:nodoc:
+      @as_mappings[class_name.to_s]
+    end
+  end
+
+  # Handles class name mapping between actionscript and ruby and assists in
+  # serializing and deserializing data between them. Simply map an AS class to a
+  # ruby class and when the object is (de)serialized it will end up as the
+  # appropriate class.
+  #
+  # Example:
+  #
+  #   RubySol::ClassMapper.define do |m|
+  #     m.map :as => 'AsClass', :ruby => 'RubyClass'
+  #     m.map :as => 'vo.User', :ruby => 'Model::User'
+  #   end
+  #
+  # == Object Population/Serialization
+  #
+  # In addition to handling class name mapping, it also provides helper methods
+  # for populating ruby objects from AMF and extracting properties from ruby objects
+  # for serialization. Support for hash-like objects and objects using
+  # <tt>attr_accessor</tt> for properties is currently built in, but custom classes
+  # may require subclassing the class mapper to add support.
+  #
+  # == Complete Replacement
+  #
+  # In some cases, it may be beneficial to replace the default provider of class
+  # mapping completely. In this case, simply assign your class mapper class to
+  # <tt>RubySol::ClassMapper</tt> after loading RubySol. Through the magic of
+  # <tt>const_missing</tt>, <tt>ClassMapper</tt> is only defined after the first
+  # access by default, so you get no annoying warning messages. Custom class mappers
+  # must implement the following methods on instances: <tt>use_array_collection</tt>,
+  # <tt>get_as_class_name</tt>, <tt>get_ruby_obj</tt>, <tt>populate_ruby_obj</tt>,
+  # and <tt>props_for_serialization</tt>. In addition, it should have a class level
+  # <tt>mappings</tt> method that returns the mapping set it's using, although its
+  # not required. If you'd like to see an example of what complete replacement
+  # offers, check out RubyAMF (http://github.com/rubyamf/rubyamf).
+  #
+  # Example:
+  #
+  #   require 'rubygems'
+  #   require 'ruby_sol'
+  #
+  #   RubySol::ClassMapper = MyCustomClassMapper
+  #   # No warning about already initialized constant ClassMapper
+  #   RubySol::ClassMapper # MyCustomClassMapper
+  #
+  # == C ClassMapper
+  #
+  # The C class mapper, <tt>RubySol::Ext::FastClassMapping</tt>, has the same
+  # public API that <tt>RubyAMF::ClassMapping</tt> does, but has some additional
+  # performance optimizations that may interfere with the proper serialization of
+  # objects. To reduce the cost of processing public methods for every object,
+  # its implementation of <tt>props_for_serialization</tt> caches valid properties
+  # by class, using the class as the hash key for property lookup. This means that
+  # adding and removing properties from instances while serializing using a given
+  # class mapper instance will result in the changes not being detected.  As such,
+  # it's not enabled by default. So long as you aren't planning on modifying
+  # classes during serialization using <tt>encode_amf</tt>, the faster C class
+  # mapper should be perfectly safe to use.
+  #
+  # Activating the C Class Mapper:
+  #
+  #   require 'rubygems'
+  #   require 'ruby_sol'
+  #   RubySol::ClassMapper = RubySol::Ext::FastClassMapping
+  class ClassMapping
+    class << self
+      # Global configuration variable for sending Arrays as ArrayCollections.
+      # Defaults to false.
+      attr_accessor :use_array_collection
+
+      # Returns the mapping set with all the class mappings that is currently
+      # being used.
+      def mappings
+        @mappings ||= MappingSet.new
+      end
+
+      # Define class mappings in the block. Block is passed a <tt>MappingSet</tt> object
+      # as the first parameter.
+      #
+      # Example:
+      #
+      #   RubySol::ClassMapper.define do |m|
+      #     m.map :as => 'AsClass', :ruby => 'RubyClass'
+      #   end
+      def define &block #:yields: mapping_set
+        yield mappings
+      end
+
+      # Reset all class mappings except the defaults and return
+      # <tt>use_array_collection</tt> to false
+      def reset
+        @use_array_collection = false
+        @mappings = nil
+      end
+    end
+
+    attr_reader :use_array_collection
+
+    # Copies configuration from class level configs to populate object
+    def initialize
+      @mappings = self.class.mappings
+      @use_array_collection = self.class.use_array_collection === true
+    end
+
+    # Returns the ActionScript class name for the given ruby object. Will also
+    # take a string containing the ruby class name.
+    def get_as_class_name obj
+      # Get class name
+      if obj.is_a?(String)
+        ruby_class_name = obj
+      elsif obj.is_a?(Values::TypedHash)
+        ruby_class_name = obj.type
+      elsif obj.is_a?(Hash)
+        return nil
+      else
+        ruby_class_name = obj.class.name
+      end
+
+      # Get mapped AS class name
+      @mappings.get_as_class_name ruby_class_name
+    end
+
+    # Instantiates a ruby object using the mapping configuration based on the
+    # source ActionScript class name. If there is no mapping defined, it returns
+    # a <tt>RubySol::Values::TypedHash</tt> with the serialized class name.
+    def get_ruby_obj as_class_name
+      ruby_class_name = @mappings.get_ruby_class_name as_class_name
+      if ruby_class_name.nil?
+        # Populate a simple hash, since no mapping
+        return Values::TypedHash.new(as_class_name)
+      else
+        ruby_class = ruby_class_name.split('::').inject(Kernel) {|scope, const_name| scope.const_get(const_name)}
+        return ruby_class.new
+      end
+    end
+
+    # Populates the ruby object using the given properties. props and
+    # dynamic_props will be hashes with symbols for keys.
+    def populate_ruby_obj obj, props, dynamic_props=nil
+      props.merge! dynamic_props if dynamic_props
+
+      # Don't even bother checking if it responds to setter methods if it's a TypedHash
+      if obj.is_a?(Values::TypedHash)
+        obj.merge! props
+        return obj
+      end
+
+      # Some type of object
+      hash_like = obj.respond_to?("[]=")
+      props.each do |key, value|
+        if obj.respond_to?("#{key}=")
+          obj.send("#{key}=", value)
+        elsif hash_like
+          obj[key] = value
+        end
+      end
+      obj
+    end
+
+    # Extracts all exportable properties from the given ruby object and returns
+    # them in a hash. If overriding, make sure to return a hash wth string keys
+    # unless you are only going to be using the native C extensions, as the pure
+    # ruby serializer performs a sort on the keys to acheive consistent, testable
+    # results.
+    def props_for_serialization ruby_obj
+      # Handle hashes
+      if ruby_obj.is_a?(Hash)
+        # Stringify keys to make it easier later on and allow sorting
+        h = {}
+        ruby_obj.each {|k,v| h[k.to_s] = v}
+        return h
+      end
+
+      # Generic object serializer
+      props = {}
+      @ignored_props ||= Object.new.public_methods
+      (ruby_obj.public_methods - @ignored_props).each do |method_name|
+        # Add them to the prop hash if they take no arguments
+        method_def = ruby_obj.method(method_name)
+        props[method_name.to_s] = ruby_obj.send(method_name) if method_def.arity == 0
+      end
+      props
+    end
+  end
+end