restfulx 1.2.5 → 1.3.0

data/README.rdoc

@@ -19,7 +19,7 @@ Here's some of the things you can do with *RestfulX*:
   that use _ActiveRecord_, _DataMapper_, _CouchRest_, _ActiveCouch_ and so on.
 
 * *Communicate* between your Flex/AIR Rich Internet Application and service providers 
-  using either _XML_ or _JSON_.
+  using either _AMF_, _XML_ or _JSON_.
   
 * *Persist* your data directly in Adobe AIR _SQLite_ database or _CouchDB_ 
   without any additional infrastructure or intermediate servers.
@@ -33,7 +33,7 @@ Here's some of the things you can do with *RestfulX*:
 
 For details on how to get started with the RestfulX framework refer to:
     
-    http://restfulx.org
+    http://restfulx.github.com
     
 == Getting Involved
 
@@ -47,4 +47,4 @@ Get involved with the community:
     
 == License
 
-Copyright (c) 2008-2009 Dima Berastau and Contributors, released under MIT License
+Copyright (c) 2008-2010 Dima Berastau and Contributors, released under MIT License

data/Rakefile

@@ -5,6 +5,7 @@ begin
   Jeweler::Tasks.new do |gem|
     gem.name = "restfulx"
     gem.summary = "RestfulX Framework Code Generation Engine / Rails 2.1+ Integration Support"
+    gem.description = "RestfulX: The RESTful Way to develop Adobe Flex and AIR applications"
     gem.email = "dima.berastau@gmail.com"
     gem.homepage = "http://restfulx.org"
     gem.rubyforge_project = "restfulx"
@@ -12,19 +13,33 @@ begin
     gem.files =  FileList["[A-Z]*", "{bin,app_generators,rails_generators,rxgen_generators,lib,test,spec,tasks}/**/*"]
     gem.files.exclude 'test/**/*.log', 'test/**/*.sqlite3'
     gem.test_files.exclude 'test/**/*.log', 'test/**/*.sqlite3'
-    gem.add_dependency('rubigen', '>= 1.5.0')
+    gem.add_dependency('rubigen', '>= 1.5.2')
     gem.add_dependency('activesupport', '>=2.0.0')
   end
+  
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
 rescue LoadError
   puts "jeweler not available. Install it with: sudo gem install jeweler"
 end
 
+require 'rake/extensiontask'
+Rake::ExtensionTask.new do |ext|
+  ext.name            = 'serializer'
+  ext.gem_spec        = Rake.application.jeweler_tasks.gemspec
+  # ext.cross_compile   = true
+  # ext.cross_platform  = %w[i386-mswin32 i386-mingw32]
+  ext.ext_dir         = 'ext/restfulx/ext/amf/serializer'
+  ext.lib_dir         = 'lib/restfulx/amf/ext'
+end
+
 require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|
   config = YAML.load(File.read('VERSION.yml'))
   rdoc.rdoc_dir = 'doc/api'
   rdoc.title = "RestfulX #{config[:major]}.#{config[:minor]}.#{config[:patch]}"
-  rdoc.options << '--line-numbers' << '--inline-source' #<< '-Tjamis'
+  rdoc.options << '--line-numbers' << '--inline-source' # << '-Tjamis'
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/VERSION.yml

@@ -1,5 +1,4 @@
 --- 
-:patch: 5
-:build: 
 :major: 1
-:minor: 2
+:minor: 3
+:patch: 0

data/bin/rx-gen

@@ -22,7 +22,7 @@ require 'rubigen'
 require File.join(File.dirname(__FILE__), '..', 'lib', 'restfulx')
 
 if %w(-v --version).include? ARGV.first
-  puts "#{File.basename($0)} #{RestfulX::FRAMEWORK_VERSION}"
+  puts "#{File.basename($0)} #{RestfulX::VERSION}"
   exit(0)
 end
 

data/ext/restfulx/ext/amf/serializer/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile 'restfulx/ext/amf/serializer'

data/lib/restfulx.rb

@@ -1,90 +1,52 @@
-# Sets up all the relevant configuration options and brings together 
-# patches for Rails, Merb, ActiveRecord and Data Mapper.
-#
-# Loads RestfulX specific rake tasks if appropriate.
-module RestfulX
-
-  # :stopdoc:
-  FRAMEWORK_VERSION = '1.2.5'
-  LIB_DIR = File.join(File.dirname(__FILE__), 'restfulx/')
-  # :startdoc:
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'yaml'
+require 'restfulx/configuration'
 
-  # Utility method used to require all files ending in .rb that lie in the
-  # directory below this file that has the same name as the filename passed
-  # in. Optionally, a specific _directory_ name can be passed in such that
-  # the _filename_ does not have to be equivalent to the directory.
-  #
-  def self.require_all_libs_relative_to( fname, dir = nil )
-    dir ||= ::File.basename(fname, '.*')
-    search_me = ::File.expand_path(
-        ::File.join(::File.dirname(fname), dir, '*', '*.rb'))
-
-    Dir.glob(search_me).sort.each {|rb| require rb}
+# Settings
+module RestfulX
+  # Valid types supported internally on top of standard Rails types  
+  module Types
+    APPLICATION_FXML = 'application/xml'.freeze
+    APPLICATION_AMF = 'application/x-amf'.freeze
+  end
+  
+  # get the currently defined AMF serializer
+  def self.amf_serializer
+    @amf_serializer
+  end
+  
+  # set the amf serializer to use
+  # valid options are :native and :pure, using :pure is recommended as it is as fast
+  # as native but currently better tested/supported
+  def self.amf_serializer=(value)
+    @amf_serializer = value
   end
-end
 
-require RestfulX::LIB_DIR + 'configuration'
+  VERSION_SOURCE = YAML.load(File.read(File.join(File.dirname(__FILE__), '..', 'VERSION.yml')))
+  VERSION = "#{VERSION_SOURCE[:major]}.#{VERSION_SOURCE[:minor]}.#{VERSION_SOURCE[:patch]}"
+end
 
-# make sure we're running inside Merb
-if defined?(Merb::Plugins)
-  Merb::Plugins.add_rakefiles RestfulX::LIB_DIR + 'tasks'
+# ActiveRecord extensions
+if defined?(ActiveRecord::Base)
+  ['rx_active_support', 'rx_active_record'].each { |lib| require "restfulx/#{lib}" }
+  ActiveRecord::Base.send :include, 
+    RestfulX::ActiveRecord unless ActiveRecord::Base.included_modules.include?(RestfulX::ActiveRecord)
+end
 
-  Merb::BootLoader.before_app_loads do
-    
-    if defined?(ActiveRecord::Base)
-      Merb.add_mime_type(:fxml,  :to_fxml,  %w[application/xml text/xml application/x-xml], :charset => "utf-8")
-      ['active_foo', 'active_record_default_methods'].each { |lib| require RestfulX::LIB_DIR + lib }
-      Merb::Plugins.add_rakefiles RestfulX::LIB_DIR + 'active_record_tasks'
-    else
-      Merb.add_mime_type(:fxml,  :to_xml,  %w[application/xml text/xml application/x-xml], :charset => "utf-8")
-      if defined?(Merb::Orms::DataMapper)
-        require RestfulX::LIB_DIR + 'datamapper_foo'
-      end
-    end
-  end    
-elsif defined?(ActionController::Base)
-  # if we are not running in Merb, try to hook up Rails
-  Mime::Type.register_alias "application/xml", :fxml
+# ActionController/ActionView extensions
+if defined?(ActionController::Base)
+  Mime::Type.register_alias RestfulX::Types::APPLICATION_FXML, :fxml
+  Mime::Type.register RestfulX::Types::APPLICATION_AMF, :amf
   
-  ['active_foo', 'rails/swf_helper', 'rails/schema_to_yaml'].each { |lib| require RestfulX::LIB_DIR + lib }
-
-  ActionView::Base.send :include, SWFHelper unless ActionView::Base.included_modules.include?(SWFHelper)
-  ActiveRecord::Migration.send :include, SchemaToYaml
+  ['rx_action_controller', 'swf_helper'].each { |lib| require "restfulx/#{lib}" }
 
-  # We mess with default +render+ implementation a bit to add support for expressions
-  # such as format.fxml { render :fxml => @foo }
-  module ActionController
-    # Override render to add support for render :fxml
-    class Base
-      alias_method :old_render, :render unless method_defined?(:old_render)
+  ActionController::Base.send :include, 
+    RestfulX::ActionController unless ActionController::Base.included_modules.include?(RestfulX::ActionController)
+  ActionView::Base.send :include, 
+    RestfulX::SWFHelper unless ActionView::Base.included_modules.include?(RestfulX::SWFHelper)
+end
 
-      # so that we can have handling for :fxml option and write code like
-      # format.fxml  { render :fxml => @projects }
-      def render(options = nil, extra_options = {}, &block)
-        if options.is_a?(Hash) && options[:fxml]
-          xml = options[:fxml]
-          response.content_type ||= Mime::XML
-          render_for_text(xml.respond_to?(:to_fxml) ? xml.to_fxml : xml, options[:status])
-        else
-          old_render(options, extra_options, &block)
-        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+ 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
-      end
-    end
-  end
-elsif defined?(DataMapper)
-  require RestfulX::LIB_DIR + 'datamapper_foo'
-elsif defined?(ActiveRecord::Base)
-  require RestfulX::LIB_DIR + 'active_foo'  
+# DataMapper extensions
+if defined?(DataMapper)
+  require 'restfulx/rx_datamapper'
 end

data/lib/restfulx/active_record_tasks.rb

@@ -1,12 +1,14 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
 # ActiveRecord specific Rake tasks. Namely, nice little extras such as:
 # - db:mysql:stage
 # - db:refresh
-require File.join(File.dirname(__FILE__), 'tasks')
-require File.join(File.dirname(__FILE__), 'rails', 'schema_to_yaml')
+require 'tasks'
+require 'schema_to_rx_yaml'
 
 # stores local copy of the application environment ('production', 'test', etc)
 # so that appropriate values in config/database.yml are used
-APP_ENV = defined?(ENV['RAILS_ENV']) ? ENV['RAILS_ENV'] : ENV['MERB_ENV']
+APP_ENV = ENV['RAILS_ENV']
 
 namespace :db do
   namespace :mysql do
@@ -82,9 +84,9 @@ namespace :db do
   
   # used to analyze your schema and dump out a model.yml file for converting old rails projects
   namespace :schema do
-    desc "Create model.yml from schema.rb"
-    task :to_yaml => :environment do
-      SchemaToYaml.schema_to_yaml
+    desc "Create RestfulX model.yml from schema.rb"
+    task :to_rx_yaml => :environment do
+      SchemaToRxYaml.schema_to_rx_yaml
     end
   end
 end

data/lib/restfulx/active_record_uuid_helper.rb

@@ -2,16 +2,15 @@
 require 'uuidtools'
 
 # Extends ActiveRecord models with UUID based IDs
-module RestfulX
-  module UUIDHelper
-    def self.included(base)
-      base.class_eval do 
-        before_create :generate_uuid
-      end
-    end
-  
-    def generate_uuid
-      self.id = UUIDTools::UUID.random_create.to_s.gsub("-", "") unless self.id
+module RestfulX::UUIDHelper
+  def self.included(base)
+    base.class_eval do 
+      before_create :generate_uuid
     end
   end
+
+  # generates new UUID for the record
+  def generate_uuid
+    self.id = UUIDTools::UUID.random_create.to_s.gsub("-", "") unless self.id
+  end
 end

data/lib/restfulx/amf.rb

@@ -0,0 +1,14 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'amf/class_mapping'
+
+# implements ruby-side AMF support for RestfulX
+module RestfulX::AMF
+  
+  ClassMapper = RestfulX::AMF::ClassMapping.new
+  
+  begin
+    require RestfulX.amf_serializer == :native ? 'amf/ext' : 'amf/pure'
+  rescue LoadError
+    require 'amf/pure'
+  end
+end

data/lib/restfulx/amf/class_mapping.rb

@@ -0,0 +1,106 @@
+module RestfulX::AMF
+  class ClassMapping
+    class MappingSet
+      attr_accessor :default_as_prefix
+      
+      def initialize #:nodoc:
+        @as_mappings = {}
+        @ruby_mappings = {}
+        @default_as_prefix = ""
+      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 if params[k] } # Convert params to strings
+        
+        if params.key?(:as) and params.key?(:ruby)
+          @as_mappings[params[:as]] = params[:ruby]
+          @ruby_mappings[params[:ruby]] = params[:as]
+        end
+        
+        if params.key?(:as)
+          params[:ruby] = get_ruby_class_name(params[:as])
+        end
+      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:
+        unless as_class_name = @ruby_mappings[class_name.to_s]
+          as_class_name = "#{@default_as_prefix}.#{class_name}"
+          @as_mappings[as_class_name] = class_name.to_s
+          @ruby_mappings[class_name.to_s] = as_class_name
+        end
+        as_class_name
+      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:
+        unless ruby_class_name = @as_mappings[class_name.to_s]
+          ruby_class_name = class_name.sub("#{default_as_prefix}.", "")
+          @ruby_mappings[ruby_class_name] = class_name.to_s
+          @as_mappings[class_name.to_s] = ruby_class_name
+        end
+        ruby_class_name
+      end
+    end
+
+    # Define class mappings in the block. Block is passed a MappingSet object as
+    # the first parameter.
+    #
+    # Example:
+    #
+    #   RestfulX::AMF::ClassMapper.define do |m|
+    #     m.map :as => 'AsClass', :ruby => 'RubyClass'
+    #   end
+    def define #:yields: mapping_set
+      yield mappings
+    end
+    
+    # Return default ActionScript prefix to use. This is recommended compared to
+    # defining mappings manually
+    def default_as_prefix
+      mappings.default_as_prefix
+    end
+    
+    # Set the default ActionScript prefix (typically a package e.g. com.foobar) to 
+    # use for all models
+    def default_as_prefix=(value)
+      mappings.default_as_prefix = value
+    end
+
+    # Returns the AS 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
+      else
+        ruby_class_name = obj.class.name
+      end
+      
+      if obj.respond_to?(:unique_id)
+        mappings.get_as_class_name(ruby_class_name)
+      else
+        nil
+      end
+    end
+    
+    # Return ruby model class name for a given ActionScript model class name
+    def get_ruby_class_name(as_class_name)
+      mappings.get_ruby_class_name(as_class_name.to_s)
+    end
+
+    private
+    def mappings
+      @mappings ||= MappingSet.new
+    end
+  end
+end

data/lib/restfulx/amf/ext.rb

@@ -0,0 +1,11 @@
+require 'restfulx/amf/ext/serializer'
+
+module RestfulX::AMF #:nodoc:
+  # This module holds all the modules/classes that implement AMF's
+  # functionality in native C code
+  module Ext
+    $DEBUG and warn "Using native extension for AMF."
+  end
+
+  include RestfulX::AMF::Ext
+end

data/lib/restfulx/amf/pure.rb

@@ -0,0 +1,11 @@
+require 'amf/pure/serializer'
+
+module RestfulX::AMF #:nodoc:
+  # This module holds all the modules/classes that implement AMF's
+  # functionality in pure ruby.
+  module Pure
+    $DEBUG and warn "Using pure library for AMF."
+  end
+
+  include RestfulX::AMF::Pure
+end

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

@@ -0,0 +1,52 @@
+module RestfulX::AMF::Pure
+  module WriteIOHelpers #:nodoc:
+    def pack_integer(integer)
+      integer = integer & 0x1fffffff
+      if(integer < 0x80)
+        [integer].pack('c')
+      elsif(integer < 0x4000)
+        [integer >> 7 & 0x7f | 0x80].pack('c')+
+        [integer & 0x7f].pack('c')
+      elsif(integer < 0x200000)
+        [integer >> 14 & 0x7f | 0x80].pack('c') +
+        [integer >> 7 & 0x7f | 0x80].pack('c') +
+        [integer & 0x7f].pack('c')
+      else
+        [integer >> 22 & 0x7f | 0x80].pack('c')+
+        [integer >> 15 & 0x7f | 0x80].pack('c')+
+        [integer >> 8 & 0x7f | 0x80].pack('c')+
+        [integer & 0xff].pack('c')
+      end
+    end
+
+    def pack_double(double)
+      [double].pack('G')
+    end
+
+    def pack_int8(val)
+      [val].pack('c')
+    end
+
+    def pack_int16_network(val)
+      [val].pack('n')
+    end
+
+    def pack_word32_network(val)
+      str = [val].pack('L')
+      str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+      str
+    end
+
+    def byte_order
+      if [0x12345678].pack("L") == "\x12\x34\x56\x78"
+        :BigEndian
+      else
+        :LittleEndian
+      end
+    end
+
+    def byte_order_little?
+      (byte_order == :LittleEndian) ? true : false;
+    end
+  end
+end