restfulx 1.2.5 → 1.3.0

data/lib/restfulx/amf/pure/serializer.rb

@@ -0,0 +1,304 @@
+require 'amf/pure/io_helpers'
+
+module RestfulX::AMF
+  module Pure #:nodoc: all
+    # AMF3 Type Markers
+    AMF3_UNDEFINED_MARKER    =  0x00 #"\000"
+    AMF3_NULL_MARKER         =  0x01 #"\001"
+    AMF3_FALSE_MARKER        =  0x02 #"\002"
+    AMF3_TRUE_MARKER         =  0x03 #"\003"
+    AMF3_INTEGER_MARKER      =  0x04 #"\004"
+    AMF3_DOUBLE_MARKER       =  0x05 #"\005"
+    AMF3_STRING_MARKER       =  0x06 #"\006"
+    AMF3_XML_DOC_MARKER      =  0x07 #"\a"
+    AMF3_DATE_MARKER         =  0x08 #"\b"
+    AMF3_ARRAY_MARKER        =  0x09 #"\t"
+    AMF3_OBJECT_MARKER       =  0x0A #"\n"
+    AMF3_XML_MARKER          =  0x0B #"\v"
+    AMF3_BYTE_ARRAY_MARKER   =  0x0C #"\f"
+
+    # 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
+
+    # Other Constants
+    MAX_INTEGER               = 268435455
+    MIN_INTEGER               = -268435456
+    
+    class SerializerCache < Hash
+      attr_accessor :cache_index
+
+      def initialize
+        @cache_index = 0
+      end
+
+      def cache(obj)
+        self[obj] = @cache_index
+        @cache_index += 1
+      end
+    end
+    
+    class RxAMFSerializer
+      def initialize()
+        @stream = ""
+        @string_cache = SerializerCache.new
+        @object_cache = SerializerCache.new
+      end
+
+      def version
+        3
+      end
+      
+      def to_s
+        @stream
+      end
+      
+      def write_vr(name)
+        if name == ''
+          @stream << AMF3_EMPTY_STRING
+        elsif @string_cache[name] != nil
+          write_reference(@string_cache[name])
+        else
+          # Cache string
+          @string_cache.cache(name)
+
+          # Build AMF string
+          header = name.length << 1 # make room for a low bit of 1
+          header = header | 1 # set the low bit to 1
+          @stream << pack_integer(header)
+          @stream << name
+        end
+        
+        nil
+      end
+      
+      def serialize_property(prop)
+        if prop.is_a?(NilClass)
+          write_null
+        elsif prop.is_a?(TrueClass)
+          write_true
+        elsif prop.is_a?(FalseClass)
+          write_false
+        elsif prop.is_a?(Float) || prop.is_a?(Bignum) || prop.is_a?(BigDecimal)
+          write_float(prop)
+        elsif prop.is_a?(Integer)
+          write_integer(prop)
+        elsif prop.is_a?(Symbol) || prop.is_a?(String)
+          write_string(prop.to_s)
+        elsif prop.is_a?(Time) || prop.is_a?(DateTime)
+          write_time(prop)
+        elsif prop.is_a?(Date)
+          write_date(prop)
+        elsif prop.is_a?(Hash)
+          write_hash(prop)
+        end
+        
+        self
+      end
+      
+      def serialize_models_array(records, options = {})
+        @stream << AMF3_OBJECT_MARKER << AMF3_XML_DOC_MARKER
+        write_vr('org.restfulx.messaging.io.ModelsCollection')
+        @object_cache.cache_index += 2
+
+        serialize_records(records, options)      
+      end
+
+      def serialize_typed_array(records, options = {})
+        @stream << AMF3_OBJECT_MARKER << AMF3_XML_DOC_MARKER
+        write_vr('org.restfulx.messaging.io.TypedArray')
+        @object_cache.cache_index += 1
+        serialize_property(options[:attributes])
+        @object_cache.cache_index += 1
+
+        serialize_records(records, options)      
+      end
+
+      def serialize_errors(errors)
+        @stream << AMF3_OBJECT_MARKER << AMF3_XML_DOC_MARKER
+        write_vr('org.restfulx.messaging.io.ServiceErrors')
+        serialize_property(errors)
+        @stream << AMF3_CLOSE_DYNAMIC_OBJECT
+        self
+      end
+
+      def serialize_record(record, serializable_names = nil, options = {}, &block)
+        @stream << AMF3_OBJECT_MARKER
+        record_id = record.respond_to?(:unique_id) ? record.unique_id : record.object_id
+
+        partials = {}
+
+        if @object_cache[record_id] != nil
+          write_reference(@object_cache[record_id])
+        else
+          # Cache object
+          @object_cache.cache(record_id)
+
+          # Always serialize things as dynamic objects
+          @stream << AMF3_DYNAMIC_OBJECT
+
+          # Write class name/anonymous
+          class_name = RestfulX::AMF::ClassMapper.get_as_class_name(record)
+          if class_name
+            write_vr(class_name)
+          else
+            @stream << AMF3_ANONYMOUS_OBJECT
+          end
+
+          serializable_names.each do |prop|
+            if prop.is_a?(Hash)
+              record_name = prop[:name]
+              record_value = record[record_name]
+              ref_name = prop[:ref_name]
+              ref_class = prop[:ref_class]
+              
+              if ref_class == "polymorphic"
+                ref_class_name = record["#{prop[:orig_ref_name]}_type"]
+                ref_class = ref_class_name.constantize
+              else
+                ref_class_name = ref_class.class_name
+              end
+              
+              result_id = "#{ref_class_name}_#{record_value}" if record_value
+
+              write_vr(ref_name)
+              if result_id               
+                if @object_cache[result_id]
+                  @stream << AMF3_OBJECT_MARKER
+                  write_reference(@object_cache[result_id])
+                else
+                  partials[ref_name.to_s] = ref_class_name
+                  unless partial = options[:cached_instances][ref_class_name]
+                    options[:cached_instances][ref_class_name] = ref_class.new
+                    partial = options[:cached_instances][ref_class_name]
+                  end
+                  partial.id = record_value
+                  serialize_record(partial, ['id'])
+                end
+              else
+                write_null
+              end
+            else
+              write_vr(prop.to_s.camelize(:lower))
+              serialize_property(record[prop])
+            end
+          end
+
+          write_vr("partials")
+          serialize_property(partials)
+
+          block.call(self) if block_given?
+
+          # Write close
+          @stream << AMF3_CLOSE_DYNAMIC_OBJECT
+        end
+        self
+      end
+
+      private
+      def serialize_records(records, options = {})
+        @stream << AMF3_ARRAY_MARKER
+
+        header = records.length << 1 # make room for a low bit of 1
+        header = header | 1 # set the low bit to 1
+        @stream << pack_integer(header)
+
+        @stream << AMF3_CLOSE_DYNAMIC_ARRAY
+        records.each do |elem|
+          if elem.respond_to?(:to_amf)
+            elem.to_amf(options)
+          else
+            serialize_property(elem)
+          end
+        end
+
+        self
+      end
+
+      def write_reference(index)
+        header = index << 1 # shift value left to leave a low bit of 0
+        @stream << pack_integer(header)
+      end
+
+      def write_null
+        @stream << AMF3_NULL_MARKER
+      end
+
+      def write_true
+        @stream << AMF3_TRUE_MARKER
+      end
+
+      def write_false
+        @stream << AMF3_FALSE_MARKER
+      end
+
+      def write_integer(int)
+        if int < MIN_INTEGER || int > MAX_INTEGER # Check valid range for 29 bits
+          write_float(int.to_f)
+        else
+          @stream << AMF3_INTEGER_MARKER
+          @stream << pack_integer(int)
+        end
+      end
+
+      def write_float(float)
+        @stream << AMF3_DOUBLE_MARKER
+        @stream << pack_double(float)
+      end
+
+      def write_string(str)
+        @stream << AMF3_STRING_MARKER
+        write_vr(str)
+      end
+
+      def write_time(time)
+        @stream << AMF3_DATE_MARKER
+        
+        @object_cache.cache_index += 1
+
+        # Build AMF string
+        time.utc unless time.utc?
+        seconds = (time.to_f * 1000).to_i
+        @stream << pack_integer(AMF3_NULL_MARKER)
+        @stream << pack_double(seconds)
+      end
+
+      def write_date(date)
+        @stream << AMF3_DATE_MARKER
+        
+        @object_cache.cache_index += 1
+
+        # Build AMF string
+        seconds = ((date.strftime("%s").to_i) * 1000).to_i
+        @stream << pack_integer(AMF3_NULL_MARKER)
+        @stream << pack_double(seconds)
+      end
+      
+      def write_hash(hash)
+        @stream << AMF3_OBJECT_MARKER
+        if @object_cache[hash] != nil
+          write_reference(@object_cache[hash])
+        else
+          # Cache object
+          @object_cache.cache(hash)
+
+          # Always serialize things as dynamic objects
+          @stream << AMF3_DYNAMIC_OBJECT << AMF3_ANONYMOUS_OBJECT
+                    
+          hash.each do |key, value|
+            write_vr(key.to_s.camelize(:lower))
+            serialize_property(value)
+          end
+
+          # Write close
+          @stream << AMF3_CLOSE_DYNAMIC_OBJECT
+        end
+      end
+      
+      include RestfulX::AMF::Pure::WriteIOHelpers
+    end
+  end
+end

data/lib/restfulx/configuration.rb

@@ -1,15 +1,19 @@
-# Interestingly enough there's no way to *just* upper-case or down-case first letter of a given
-# string. Ruby's own +capitalize+ actually downcases all the rest of the characters in the string
-# We patch the class to add our own implementation.
-require "yaml" 
-require "erb" 
-require File.dirname(__FILE__) + "/rails/schema_to_yaml/settings/config" 
-require File.dirname(__FILE__) + "/rails/schema_to_yaml/settings/core" 
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'erb'
+require 'schema_to_rx_yaml' if !defined?(SchemaToRxYaml)
 
-Dir[File.dirname(__FILE__) + "/rails/schema_to_yaml/extensions/*.rb"].each do |f|
-  require f
+# Enumerable extensions
+module Enumerable
+  # Helps you find duplicates
+  # used in schema_to_yaml.rb for cleanup
+  def dups
+    inject({}) { |h,v| h[v] = h[v].to_i + 1; h }.reject{ |k,v| v == 1 }.keys
+  end
 end
 
+# Interestingly enough there's no way to *just* upper-case or down-case first letter of a given
+# string. Ruby's own +capitalize+ actually downcases all the rest of the characters in the string
+# We patch the class to add our own implementation.
 class String
   # Upper-case first character of a string leave the rest of the string intact
   def ucfirst
@@ -24,13 +28,13 @@ end
 
 # Primary RestfulX configuration options
 module RestfulX
-  # Computes necessary configuration options from the environment. This can be used in Rails, Merb
+  # Computes necessary configuration options from the environment. This can be used in Rails
   # or standalone from the command line.
   module Configuration
     # We try to figure out the application root using a number of possible options
-    APP_ROOT = defined?(RAILS_ROOT) ? RAILS_ROOT : defined?(Merb) ? Merb.root : File.expand_path(".")
+    APP_ROOT = defined?(RAILS_ROOT) ? RAILS_ROOT : File.expand_path(".")
     
-    RxSettings = SchemaToYaml::Settings::Core
+    RxSettings = SchemaToRxYaml::Settings::Core
 
     # Extract project, package, controller name, etc from the environment. This will respect
     # config/restfulx.yml if it exists, you can override all of the defaults there.

data/lib/restfulx/{rails/recipes.rb → recipes.rb}

@@ -2,7 +2,7 @@
 #
 # To use these recipes, add the following to your Capfile:
 #
-#   require 'restfulx/rails/recipes'
+#   require 'restfulx/recipes'
 require 'find'
 
 Capistrano::Configuration.instance(:must_exist).load do
@@ -17,7 +17,6 @@ Capistrano::Configuration.instance(:must_exist).load do
 
   namespace :deploy do
     namespace :flex do
-    
       desc "Creates the flex_files directory in the shared directory"
       task :setup do
         flex_dir = File.join(shared_path, 'flex_files')

data/lib/restfulx/rx_action_controller.rb

@@ -0,0 +1,34 @@
+module RestfulX::ActionController
+  def self.included(base)
+    base.class_eval do
+      alias_method_chain :render, :amf
+      alias_method_chain :render, :fxml
+    end
+  end
+  
+  # Defines support for rendering :amf blocks from within Rails constrollers
+  def render_with_amf(options=nil, extra_options={}, &block)
+    if Hash === options and options.key?(:amf)
+      object = options.delete(:amf)
+      unless String === object
+        object = object.to_amf(options, &block) if object.respond_to?(:to_amf)
+      end
+      render_without_amf(:text => object, :content_type => RestfulX::Types::APPLICATION_AMF)
+    else
+      render_without_amf(options, extra_options, &block)
+    end
+  end
+  
+  # Defines support for rendering :fxml blocks from within Rails controllers
+  def render_with_fxml(options=nil, extra_options={}, &block)
+    if Hash === options and options.key?(:fxml)
+      object = options.delete(:fxml)
+      unless String === object
+        object = object.to_fxml(options, &block) if object.respond_to?(:to_fxml)
+      end
+      render_without_fxml(:text => object, :content_type => RestfulX::Types::APPLICATION_FXML)
+    else
+      render_without_fxml(options, extra_options, &block)
+    end
+  end
+end

data/lib/restfulx/rx_active_record.rb

@@ -0,0 +1,360 @@
+module RestfulX
+  module Serialization #:nodoc:
+    class FXMLSerializer < ::ActiveRecord::Serialization::Serializer #:nodoc:
+      def builder
+        @builder ||= begin
+          options[:indent] ||= 2
+          builder = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+          unless options[:skip_instruct]
+            builder.instruct!
+            options[:skip_instruct] = true
+          end
+
+          builder
+        end
+      end
+
+      def root
+        root = (options[:root] || @record.class.to_s.underscore).to_s
+        reformat_name(root)
+      end
+
+      def dasherize?
+        !options.has_key?(:dasherize) || options[:dasherize]
+      end
+
+      def camelize?
+        options.has_key?(:camelize) && options[:camelize]
+      end
+
+      def reformat_name(name)
+        name = name.camelize if camelize?
+        dasherize? ? name.dasherize : name
+      end
+
+      def serializable_attributes
+        serializable_attribute_names.collect { |name| Attribute.new(name, @record) }
+      end
+
+      def serializable_method_attributes
+        Array(options[:methods]).inject([]) do |method_attributes, name|
+          method_attributes << MethodAttribute.new(name.to_s, @record) if @record.respond_to?(name.to_s)
+          method_attributes
+        end
+      end
+
+      def add_attributes
+        (serializable_attributes + serializable_method_attributes).each do |attribute|
+          add_tag(attribute)
+        end
+      end
+
+      def add_procs
+        if procs = options.delete(:procs)
+          [ *procs ].each do |proc|
+            proc.call(options)
+          end
+        end
+      end
+
+      def add_tag(attribute)
+        builder.tag!(
+          reformat_name(attribute.name),
+          attribute.value.to_s,
+          attribute.decorations(!options[:skip_types])
+        )
+      end
+
+      def add_associations(association, records, opts)
+        if records.is_a?(Enumerable)
+          tag = reformat_name(association.to_s)
+          type = options[:skip_types] ? {} : {:type => "array"}
+
+          if records.empty?
+            builder.tag!(tag, type)
+          else
+            builder.tag!(tag, type) do
+              association_name = association.to_s.singularize
+              records.each do |record|
+                if options[:skip_types]
+                  record_type = {}
+                else
+                  record_class = (record.class.to_s.underscore == association_name) ? nil : record.class.name
+                  record_type = {:type => record_class}
+                end
+
+                record.to_fxml opts.merge(:root => association_name).merge(record_type)
+              end
+            end
+          end
+        else
+          if record = @record.send(association)
+            record.to_fxml(opts.merge(:root => association))
+          end
+        end
+      end
+
+      def serialize
+        args = [root]
+        if options[:namespace]
+          args << {:xmlns=>options[:namespace]}
+        end
+
+        if options[:type]
+          args << {:type=>options[:type]}
+        end
+
+        builder.tag!(*args) do
+          add_attributes
+          procs = options.delete(:procs)
+          add_includes { |association, records, opts| add_associations(association, records, opts) }
+          options[:procs] = procs
+          add_procs
+          yield builder if block_given?
+        end
+      end
+      
+      class Attribute #:nodoc:
+        attr_reader :name, :value, :type
+
+        def initialize(name, record)
+          @name, @record = name, record
+
+          @type  = compute_type
+          @value = compute_value
+        end
+
+        # There is a significant speed improvement if the value
+        # does not need to be escaped, as <tt>tag!</tt> escapes all values
+        # to ensure that valid XML is generated. For known binary
+        # values, it is at least an order of magnitude faster to
+        # Base64 encode binary values and directly put them in the
+        # output XML than to pass the original value or the Base64
+        # encoded value to the <tt>tag!</tt> method. It definitely makes
+        # no sense to Base64 encode the value and then give it to
+        # <tt>tag!</tt>, since that just adds additional overhead.
+        def needs_encoding?
+          ![ :binary, :date, :datetime, :boolean, :float, :integer ].include?(type)
+        end
+
+        def decorations(include_types = true)
+          decorations = {}
+
+          if type == :binary
+            decorations[:encoding] = 'base64'
+          end
+
+          if include_types && type != :string
+            decorations[:type] = type
+          end
+
+          if value.nil?
+            decorations[:nil] = true
+          end
+
+          decorations
+        end
+
+        protected
+          def compute_type
+            type = @record.class.serialized_attributes.has_key?(name) ? :yaml : @record.class.columns_hash[name].type
+
+            case type
+              when :text
+                :string
+              when :time
+                :datetime
+              else
+                type
+            end
+          end
+
+          def compute_value
+            value = @record.send(name)
+
+            if formatter = Hash::XML_FORMATTING[type.to_s]
+              value ? formatter.call(value) : nil
+            else
+              value
+            end
+          end
+      end
+
+      class MethodAttribute < Attribute #:nodoc:
+        protected
+          def compute_type
+            Hash::XML_TYPE_NAMES[@record.send(name).class.name] || :string
+          end
+      end
+    end
+    
+    class AMFSerializer < ::ActiveRecord::Serialization::Serializer #:nodoc:
+      def initialize(record, options = {})
+        super(record, options)
+        @options[:methods] ||= []
+        @options[:amf_version] = 3
+        @options[:serializer] ||= RestfulX::AMF::RxAMFSerializer.new
+        
+        # options are duplicated by default so we need a copy for caching attributes
+        @original_options = options
+        @original_options[:cached_attributes] ||= {}
+        @options[:cached_instances] = @original_options[:cached_instances] ||= {}
+      end
+
+      def serialize
+        @options[:serializer].serialize_record(@record, serializable_attributes, @options) do |serializer|
+          ([].concat(@options[:methods])).each do |method|
+            if @record.respond_to?(method)
+              serializer.write_vr(method.to_s.camelcase(:lower))
+              serializer.serialize_property(@record.send(method))
+            end
+          end
+          add_includes do |association, records, opts|
+            add_associations(association, records, opts, serializer)
+          end
+        end.to_s
+      end
+      
+      def serializable_attributes
+        includes = @options[:include] ||= {}
+        
+        # if we are serializing an array we only need to compute serializable_attributes for the
+        # objects of the same type at the same level once
+        if @original_options[:cached_attributes].has_key?(@record.class.name)
+          @original_options[:cached_attributes][@record.class.name]
+        else
+          associations = Hash[*@record.class.reflect_on_all_associations(:belongs_to).collect do |assoc|
+            if assoc.options.has_key?(:polymorphic) && assoc.options[:polymorphic]
+              @options[:except] = ([] << @options[:except] << "#{assoc.name}_type".to_sym).flatten
+              # class_name = @record[assoc.options[:foreign_type]].constantize
+              class_name = "polymorphic"
+            else
+              class_name = assoc.klass
+            end
+            [assoc.primary_key_name, {:name => assoc.name, :klass => class_name}]
+          end.flatten]
+                                
+          attributes = serializable_names.select do |name| 
+            !includes.include?(associations[name][:name]) rescue true
+          end.map do |name| 
+            associations.has_key?(name) ? {:name => name, :ref_name => associations[name][:name].to_s.camelize(:lower), 
+              :ref_class => associations[name][:klass], :orig_ref_name => associations[name][:name].to_s } : name.to_sym
+          end
+          @original_options[:cached_attributes][@record.class.name] = attributes
+          attributes
+        end
+      end
+      
+      def add_associations(association, records, opts, serializer)        
+        serializer.write_vr(association.to_s.camelcase(:lower))
+        if records.is_a?(Enumerable)
+          serializer.serialize_models_array(records, opts)
+        else
+          if record = @record.send(association)
+            record.to_amf(opts)
+          end
+        end
+      end
+    end
+  end
+  
+  module ActiveRecord
+    def self.included(base)
+      base.send :include, InstanceMethods
+    end
+    
+    module InstanceMethods
+      def unique_id
+        "#{self.class.to_s}_#{self.attributes()['id']}"
+      end
+      
+      # serialize this model as AMF
+      def to_amf(options = {})
+        default_except = [:crypted_password, :salt, :remember_token, :remember_token_expires_at, :created_at, :updated_at]
+        options[:except] = (options[:except] ? options[:except] + default_except : default_except)
+        
+        RestfulX::Serialization::AMFSerializer.new(self, options).to_s
+      end
+    
+      # serialize this model as fXML
+      def to_fxml(options = {})
+        options.merge!(:dasherize => false)
+        default_except = [:crypted_password, :salt, :remember_token, :remember_token_expires_at, :created_at, :updated_at]
+        options[:except] = (options[:except] ? options[:except] + default_except : default_except)
+        
+        RestfulX::Serialization::FXMLSerializer.new(self, options).to_s
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  # ActiveRecord named scopes are computed *before* restfulx gem gets loaded
+  # this patch addresses that and makes sure +to_fxml/to_amf+ calls are properly
+  # delegated
+  module NamedScope
+    # make sure we properly delegate +to_fxml+ calls to the proxy
+    class Scope
+      delegate :to_fxml, :to => :proxy_found
+      delegate :to_amf,  :to => :proxy_found
+    end
+  end
+  
+  # Change the xml serializer so that '?'s are stripped from attribute names.
+  # This makes it possible to serialize methods that end in a question mark, like 'valid?' or 'is_true?'
+  class XmlSerializer
+    # Strips '?' from serialized method names
+    def add_tag(attribute)
+      builder.tag!(
+        dasherize? ? attribute.display_name.dasherize : attribute.display_name,
+        attribute.value.to_s,
+        attribute.decorations(!options[:skip_types])
+      )
+    end
+    # Strips '?' from serialized method names
+    class Attribute
+      # Strips '?' from serialized method names
+      def display_name
+        @name.gsub('?','')
+      end
+    end
+  end
+
+  # Add more extensive reporting on errors including field name along with a message
+  # when errors are serialized to XML and JSON
+  class Errors
+    alias_method :to_json_original, :to_json
+    
+    # serializer errors to fXML
+    def to_fxml(options = {})
+      options[:root] ||= "errors"
+      options[:indent] ||= 2
+      options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+      options[:builder].instruct! unless options.delete(:skip_instruct)
+      options[:builder].errors do |e|
+        # The @errors instance variable is a Hash inside the Errors class
+        @errors.each do |attr, msg|
+          next if msg.nil?
+          if attr == "base"
+            options[:builder].error("message", msg.to_s)
+          else
+            options[:builder].error("field" => attr.camelcase(:lower), "message" => msg.to_s)
+          end
+        end
+      end
+    end
+    
+    # serialize errors to JSON
+    def to_json(options = {})
+      "{#{'errors'.inspect}:#{to_json_original(options)}}"
+    end
+    
+    # serialize errors to AMF
+    def to_amf(options = {})
+      options[:amf_version] = 3
+      options[:serializer] ||= RestfulX::AMF::RxAMFSerializer.new
+      options[:serializer].serialize_errors(Hash[*@errors.to_a.flatten]).to_s
+    end
+  end
+end