rubyamf-ouvrages 2.0.0

data/lib/rubyamf/rails/rails3_bootstrap.rb

@@ -0,0 +1,53 @@
+require 'rubyamf/rails/controller'
+require 'rubyamf/rails/model'
+require 'rubyamf/rails/request_processor'
+require 'rubyamf/rails/routing'
+require 'rubyamf/rails/time'
+require 'action_controller'
+
+# Hook up MIME type
+Mime::Type.register RubyAMF::MIME_TYPE, :amf
+
+# Hook routing into routes
+ActionDispatch::Routing::Mapper.send(:include, RubyAMF::Rails::Routing)
+
+# Add some utility methods to ActionController
+ActionController::Base.send(:include, RubyAMF::Rails::Controller)
+
+# Hook up ActiveRecord Model extensions and make sure Relation objects work
+if defined?(ActiveRecord)
+  ActiveRecord::Base.send(:include, RubyAMF::Rails::Model)
+  class ActiveRecord::Relation
+    def encode_amf ser
+      ser.serialize ser.version, self.to_a
+    end
+  end
+end
+
+# Hook up rendering
+ActionController::Renderers.add :amf do |amf, options|
+  @amf_response = amf
+  @mapping_scope = options[:class_mapping_scope] || options[:mapping_scope] || nil
+  self.content_type ||= Mime::AMF
+  self.response_body = " "
+end
+
+# Add custom responder so respond_with works
+class ActionController::Responder
+  def to_amf
+    display resource
+  end
+end
+
+class RubyAMF::Railtie < Rails::Railtie #:nodoc:
+  config.rubyamf = RubyAMF.configuration
+
+  initializer "rubyamf.configured" do
+    RubyAMF.bootstrap
+  end
+
+  initializer "rubyamf.middleware" do
+    config.app_middleware.use RubyAMF::RequestParser
+    config.app_middleware.use RubyAMF::Rails::RequestProcessor
+  end
+end

data/lib/rubyamf/rails/request_processor.rb

@@ -0,0 +1,90 @@
+module RubyAMF::Rails
+  # Rack middleware that handles dispatching AMF calls to the appropriate controller
+  # and action.
+  class RequestProcessor
+    def initialize app
+      @app = app
+    end
+
+    # Processes the AMF request and forwards the method calls to the corresponding
+    # rails controllers. No middleware beyond the request processor will receive
+    # anything if the request is a handleable AMF request.
+    def call env
+      return @app.call(env) unless env['rubyamf.response']
+
+      # Handle each method call
+      req = env['rubyamf.request']
+      res = env['rubyamf.response']
+      res.each_method_call req do |method, args|
+        handle_method method, args, env
+      end
+    end
+
+    # Actually dispatch a fake request to the appropriate controller and extract
+    # the response for serialization
+    def handle_method method, args, env
+      # Parse method and load service
+      path = method.split('.')
+      method_name = path.pop
+      controller_name = path.pop
+      controller, method_name = get_service controller_name, method_name
+
+      # Setup request and controller
+      new_env = env.dup
+      new_env['HTTP_ACCEPT'] = RubyAMF::MIME_TYPE # Force amf response only
+      if defined? ActionDispatch::Request then
+        # rails 3.1
+        req = ActionDispatch::Request.new(new_env)
+      else
+        # older rails
+        req = ActionController::Request.new(new_env)
+      end
+      con = controller.new
+
+      # Populate with AMF data
+      amf_req = env['rubyamf.request']
+      params_hash = amf_req.params_hash(controller.name, method_name, args)
+      req.params.merge!(params_hash) if RubyAMF.configuration.populate_params_hash
+      con.instance_variable_set("@is_amf", true)
+      con.instance_variable_set("@rubyamf_params", params_hash)
+      con.instance_variable_set("@credentials", amf_req.credentials)
+
+      # Dispatch the request to the controller
+      rails_version = ::Rails::VERSION::MAJOR
+      if rails_version == 3
+        res = con.dispatch(method_name, req)
+      else # Rails 2
+        req.params['controller'] = controller.controller_name
+        req.params['action'] = method_name
+        con.process(req, ActionController::Response.new)
+      end
+
+      # Copy mapping scope over to response so it can be used when serialized
+      env['rubyamf.response'].mapping_scope = con.send(:mapping_scope)
+
+      return con.send(:amf_response)
+    end
+
+    # Validate the controller and method name and return the controller class
+    def get_service controller_name, method_name
+      # Check controller and validate against hacking attempts
+      begin
+        controller_name += "Controller" unless controller_name =~ /^.+Controller$/
+        controller = controller_name.constantize
+        raise "not controller" unless controller.respond_to?(:controller_name) && controller.respond_to?(:action_methods)
+      rescue Exception => e
+        raise "Service #{controller_name} does not exist"
+      end
+
+      # Check action both plain and underscored
+      actions = controller.action_methods
+      if actions.include?(method_name)
+        return [controller, method_name]
+      elsif actions.include?(method_name.underscore)
+        return [controller, method_name.underscore]
+      else
+        raise "Service #{controller_name} does not respond to #{method_name}"
+      end
+    end
+  end
+end

data/lib/rubyamf/rails/routing.rb

@@ -0,0 +1,97 @@
+module RubyAMF::Rails
+  # The prefered method for parameter mapping in Rails is through the routing
+  # file. RubyAMF supports namespacing for controllers and several different
+  # syntax styles for better integration into Rails 2 or Rails 3. This module
+  # can also be used outside of Rails by including it wherever you want.
+  module Routing
+    RAILS2_NAMESPACE_OPTIONS = [:path_prefix, :name_prefix, :namespace]
+
+    # Define a parameter mapping
+    #
+    # ===Rails 2
+    #
+    #   ActionController::Routing::Routes.draw do |map|
+    #     map.amf :controller => "controller", :action => "action", :params => [:param1, :param2]
+    #     map.namespace :admin do |admin|
+    #       admin.amf "controller#action", [:param1, :param2]
+    #     end
+    #     map.amf "controller", "action1" => [:param1, :param2],
+    #                           "action2" => [:param1, :param2],
+    #                           "action3" => [:param1]
+    #   end
+    #
+    # ===Rails 3
+    #
+    #   AmfApplication::Application.routes.draw do |map|
+    #     map_amf "controller#action", [:param1, :param2]
+    #     namespace :admin do
+    #       map_amf "controller#action", [:param1, :param2]
+    #     end
+    #     map_amf "controller", "action1" => [:param1, :param2],
+    #                           "action2" => [:param1, :param2],
+    #                           "action3" => [:param1]
+    #   end
+    #
+    # ===Generic Framework
+    #
+    #   include Routing
+    #   # Namespace is WillBe::Camelized
+    #   map_amf "controller#action", [:param1, :param2]
+    #   map_amf "controller#action", [:param1, :param2], {:namespace => "will_be/camelized"}
+    #   map_amf :controller => "controller", :action => "action", :params => [:param1, :param2], :namespace => "will_be/camelized"
+    def map_amf *args
+      # Rails 2 namespace uses ActiveSupport::OptionMerger, which adds namespace
+      # options to last hash, or passes it as an additional parameter
+      # Rails 3 stores current namespace info in @scope variable
+
+      # Process args
+      if args.length == 2 && args[1].is_a?(Hash) # "controller", "action" => [], "action" => []
+        # Extract the rails2_with_options hash and separate it from the actions
+        rails2_with_options = {}
+        actions = {}
+        args[1].each do |k,v|
+          if RAILS2_NAMESPACE_OPTIONS.include?(k)
+            rails2_with_options[k] = v
+          else
+            actions[k] = v
+          end
+        end
+
+        # Call map_amf for all actions
+        actions.each do |k, v|
+          map_amf({:controller => args[0].to_s, :action => k.to_s, :params => v}.merge(rails2_with_options))
+        end
+        return nil
+      elsif args[0].is_a?(String) # "controller#action", []
+        (controller, action) = args[0].split("#")
+        params = args[1]
+        rails2_with_options = args[2] || {}
+      else # :controller => "con", :action => "act", :params => []
+        controller = args[0].delete(:controller)
+        action = args[0].delete(:action)
+        params = args[0].delete(:params)
+        rails2_with_options = args[0]
+      end
+
+      # Convert controller name to actual controller class name
+      controller = controller.camelize(:upper)+"Controller" unless controller =~ /Controller$/
+
+      # Namespace controller name if used
+      modules = if @scope && @scope[:module]
+        # Rails 3 code path
+        @scope[:module].split("/").map {|n| n.camelize(:upper)}
+      elsif rails2_with_options[:namespace]
+        # Rails 2 code path
+        namespaces = rails2_with_options[:namespace].split("/")
+        namespaces.map {|n| n.camelize(:upper)}
+      else
+        []
+      end
+      modules << controller
+      controller = modules.join("::")
+
+      RubyAMF.configuration.map_params controller, action, params
+    end
+    alias_method :amf, :map_amf
+  end
+end

data/lib/rubyamf/rails/time.rb

@@ -0,0 +1,6 @@
+# Make sure ActiveSupport::TimeWithZone serializes correctly
+class ActiveSupport::TimeWithZone
+  def encode_amf ser
+    ser.serialize ser.version, self.to_datetime
+  end
+end

data/lib/rubyamf/request_parser.rb

@@ -0,0 +1,99 @@
+module RubyAMF
+  # RubyAMF uses a two-stage middleware strategy. RequestParser is the first
+  # stage, and is responsible for parsing the stream and setting
+  # <tt>env ['rubyamf.request']</tt> and <tt>env ['rubyamf.response']</tt> to
+  # an instance of RubyAMF::Envelope. If the response envelope is marked as
+  # constructed, it will send back the serialized response. The second stage is
+  # RubyAMF::Rails::RequestProcessor.
+  class RequestParser
+    def initialize app
+      @app = app
+    end
+
+    # Determine how to handle the request and pass off to <tt>handle_amf</tt>,
+    # <tt>handle_image</tt>, or <tt>handle_html</tt>. If the <tt>show_html_gateway</tt>
+    # config is set to false, it will not serve an HTML page for non-amf requests
+    # to the gateway.
+    def call env
+      # Show HTML gateway page if it's enabled for non-amf requests
+      if RubyAMF.configuration.show_html_gateway
+        if env['PATH_INFO'] == gateway_image_path
+          return handle_image
+        elsif env['PATH_INFO'] == gateway_path && env['CONTENT_TYPE'] != RubyAMF::MIME_TYPE
+          return handle_html
+        end
+      end
+
+      # Handle if it's AMF or pass it up the chain
+      if env['PATH_INFO'] == gateway_path && env['CONTENT_TYPE'] == RubyAMF::MIME_TYPE
+        return handle_amf(env)
+      else
+        return @app.call(env)
+      end
+    end
+
+    # It parses the request, creates a response object, and forwards the call
+    # to the next middleware. If the amf response is constructed, then it serializes
+    # the response and returns it as the response.
+    def handle_amf env
+      # Wrap request and response
+      env['rack.input'].rewind
+      begin
+        env['rubyamf.request'] = RubyAMF::Envelope.new.populate_from_stream(env['rack.input'].read)
+      rescue Exception => e
+        RubyAMF.logger.log_error(e)
+        msg = "Invalid AMF request"
+        return [400, {"Content-Type" => "text/plain", 'Content-Length' => msg.length.to_s}, [msg]]
+      end
+      env['rubyamf.response'] = RubyAMF::Envelope.new
+
+      # Pass up the chain to the request processor, or whatever is layered in between
+      result = @app.call(env)
+
+      # Calculate length and return response
+      if env['rubyamf.response'].constructed?
+        RubyAMF.logger.info "Sending back AMF"
+        response = env['rubyamf.response'].to_s
+        return [200, {"Content-Type" => RubyAMF::MIME_TYPE, 'Content-Length' => response.length.to_s}, [response]]
+      else
+        return result
+      end
+    end
+
+    # It returns a simple HTML page confirming that the gateway is properly running
+    def handle_html
+      info_url = "https://github.com/rubyamf/rubyamf"
+      html = <<END_OF_HTML
+<html>
+  <head>
+    <title>RubyAMF Gateway</title>
+    <style>body{margin:0;padding:0;color:#c8c8c8;background-color:#222222;}</style>
+  </head>
+  <body>
+    <table width="100%" height="100%" align="center" valign="middle">
+      <tr><td align="center"><a href="#{info_url}"><img border="0" src="#{gateway_image_path}" /></a></td></tr>
+    </table>
+  </body>
+</html>
+END_OF_HTML
+      return [200, {'Content-Type' => 'text/html', 'Content-Length' => html.length.to_s}, [html]]
+    end
+
+    # Serve rubyamf logo for html page
+    def handle_image
+      path = File.join(File.dirname(__FILE__), 'gateway.png')
+      content = File.read(path)
+      size = content.respond_to?(:bytesize) ? content.bytesize : content.size
+      return [200, {'Content-Type' => 'image/png', 'Content-Length' => size.to_s}, [content]]
+    end
+
+    def gateway_path #:nodoc:
+      path = RubyAMF.configuration.gateway_path
+      path.end_with?("/") ? path[0...-1] : path
+    end
+
+    def gateway_image_path #:nodoc:
+      gateway_path + "/gateway.png"
+    end
+  end
+end

data/lib/rubyamf/test.rb

@@ -0,0 +1,61 @@
+require 'rack/mock'
+
+module RubyAMF
+  # Contains helpers to make testing AMF controller testing simple. Rails users
+  # can simply use <tt>create_call</tt> and <tt>create_flex_call</tt> to create
+  # requests and run them using <tt>dispatch_rails</tt>. Users of other rack-based
+  # frameworks will need to handle properly dispatching the request to the right
+  # middleware. <tt>create_call_type</tt> creates a rack environment similar to
+  # what you would get from RubyAMF::RequestParser, so you can just pass it to
+  # whatever your processing middleware is.
+  #
+  # Rails Example:
+  #
+  #    env = RubyAMF::Test.create_call 3, "TestController.get_user", 5
+  #    res = RubyAMF::Test.dispatch_rails env
+  #    res.mapping_scope.should == "testing"
+  #    res.result.class.name.should == "User"
+  module Test
+    class << self
+      # Creates a rack environment hash that can be used to dispatch the given
+      # call. The environment that is created can be directly dispatched to
+      # RubyAMF::Rails::RequestProcessor or your own middleware. The type can either
+      # be <tt>:standard</tt> or <tt>:flex</tt>, with the flex type using the same
+      # style as <tt>RemoteObject</tt> does.
+      def create_call_type type, amf_version, target, *args
+        amf_req = RubyAMF::Envelope.new :amf_version => amf_version
+        if type == :standard
+          amf_req.call target, *args
+        elsif type == :flex
+          amf_req.call_flex target, *args
+        else
+          raise "Invalid call type: #{type}"
+        end
+
+        env = ::Rack::MockRequest.env_for(RubyAMF.configuration.gateway_path, :method => "post", :input => amf_req.to_s, "CONTENT_TYPE" => RubyAMF::MIME_TYPE)
+        env["REQUEST_URI"] = env["PATH_INFO"] # Rails 2.3.X needs this
+        env['rubyamf.request'] = amf_req
+        env['rubyamf.response'] = RubyAMF::Envelope.new
+        env
+      end
+
+      # Creates a rack environment for the standard call type
+      def create_call amf_version, target, *args
+        create_call_type :standard, amf_version, target, *args
+      end
+
+      # Creates a rack environment for the flex call type
+      def create_flex_call target, *args
+        create_call_type :flex, 3, target, *args
+      end
+
+      # Dispatches the given rack environment to RubyAMF::Rails::RequestProcessor,
+      # which calls the specified controllers. Returns the response RubyAMF::Envelope.
+      def dispatch_rails env
+        middleware = RubyAMF::Rails::RequestProcessor.new nil
+        middleware.call env
+        env['rubyamf.response']
+      end
+    end
+  end
+end

data/lib/rubyamf/version.rb

@@ -0,0 +1,3 @@
+module RubyAMF
+  VERSION = "2.0.0"
+end

data/rubyamf.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rubyamf/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rubyamf-ouvrages"
+  s.version     = RubyAMF::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Stephen Augenstein"]
+  s.email       = ["perl.programmer@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{AMF remoting for Ruby and Rails}
+  s.description = %q{RubyAMF is an open source flash remoting gateway for Ruby on Rails and other Rack-based web frameworks.}
+  s.rubyforge_project = "rubyamf"
+
+  s.add_dependency('activesupport', '>= 2.3')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ['README.rdoc']
+  s.rdoc_options     = ['--line-numbers', '--main', 'README.rdoc']
+end