rack-rpc 0.0.2 → 0.0.3

data/AUTHORS

@@ -1 +1,2 @@
 * Arto Bendiken <arto.bendiken@gmail.com>
+* Josh Huckabee <joshhuckabee@gmail.com>

data/README

@@ -1,4 +1,148 @@
 JSON-RPC/XML-RPC Server for Rack Applications
 =============================================
 
-* <http://github.com/datagraph/rack-rpc>
+This is a [Rack][] middleware that facilitates the creation of
+protocol-agnostic RPC servers. The current implementation provides support
+for [JSON-RPC 2.0][] and [XML-RPC][].
+
+* <https://github.com/datagraph/rack-rpc>
+
+Features
+--------
+
+* Handles JSON-RPC and XML-RPC requests with the same code.
+* Compatible with any Rack application and any Rack-based framework.
+* Provides Rails-style controller filtering for your RPC methods.
+
+Examples
+--------
+
+### A basic RPC server
+
+    require 'rack/rpc'
+    
+    class Server < Rack::RPC::Server
+      def hello_world
+        "Hello, world!"
+      end
+      rpc 'hello_world' => :hello_world
+    end
+
+### Simple filtering
+
+    require 'rack/rpc'
+    
+    class Server < Rack::RPC::Server
+      before_filter :check_auth
+
+      def hello_world
+        "Hello, world!"
+      end
+      rpc 'hello_world' => :hello_world
+
+      private
+
+      def check_auth
+        raise "Not authorized" unless authorized
+      end
+    end
+
+### Filtering via a proc with more options
+
+    require 'rack/rpc'
+    
+    class Server < Rack::RPC::Server
+      before_filter :check_auth, :only => :super_secret_hello_world do
+        raise "Not authorized" unless authorized
+      end
+
+      def hello_world
+        "Hello, world!"
+      end
+      rpc 'hello_world' => :hello_world
+
+      def super_secret_hello_world
+        'super_secret_hello_world'
+      end
+      rpc 'super_secret_hello_world' => :super_secret_hello_world
+    end
+
+### Running the server
+
+    # config.ru
+    use Rack::RPC::Endpoint, Server.new
+    
+    run MyApplication
+
+### Customizing the default RPC path
+
+    # config.ru
+    use Rack::RPC::Endpoint, Server.new, :path => '/api'
+    
+    run MyApplication
+
+More on Filters
+---------------
+
+The `:only` and `:except` options for filters can take a single method or an
+array of methods.
+
+You can halt execution in a filter by raising an exception. An error
+response will be returned with the exception's message set as the error
+object's message text.
+
+Communicationg with the Server
+------------------------------
+
+By default, methods will only be invoked on `POST` requests to "/rpc". The
+default path can be overridden by sending a `:path` option when creating
+your middleware (see example above).
+
+The protocol used is determined by the `CONTENT_TYPE` header
+("application/xml" and "text/xml" for XML and "application/json" for JSON).
+
+Dependencies
+------------
+
+* [Rack](http://rubygems.org/gems/rack) (>= 1.0.0)
+
+Installation
+------------
+
+The recommended installation method is via [RubyGems](http://rubygems.org/).
+To install the latest official release of the gem, do:
+
+    % [sudo] gem install rack-rpc
+
+Download
+--------
+
+To get a local working copy of the development repository, do:
+
+    % git clone git://github.com/datagraph/rack-rpc.git
+
+Alternatively, download the latest development version as a tarball as
+follows:
+
+    % wget http://github.com/datagraph/rack-rpc/tarball/master
+
+Mailing List
+------------
+
+* <http://groups.google.com/group/rack-devel>
+
+Authors
+-------
+
+* [Arto Bendiken](https://github.com/bendiken) - <http://ar.to/>
+* [Josh Huckabee](https://github.com/jhuckabee) - <http://joshhuckabee.com/>
+
+License
+-------
+
+This is free and unencumbered public domain software. For more information,
+see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+
+[Rack]:           http://rack.rubyforge.org/
+[JSON-RPC 2.0]:   http://groups.google.com/group/json-rpc/web/json-rpc-2-0
+[XML-RPC]:        http://www.xmlrpc.com/

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/rack/rpc/endpoint/xmlrpc.rb

@@ -38,6 +38,18 @@ class Rack::RPC::Endpoint
         })
       end
 
+      ##
+      # Process requests and ensure errors are handled properly
+      #
+      # @param [String] request body
+      def process(request_body)
+        begin
+          super(request_body)
+        rescue RuntimeError => e
+          error_response(-32500, "application error - #{e.message}")
+        end
+      end
+
       ##
       # Implements the `system.getCapabilities` standard method, enabling
       # clients to determine whether a given capability is supported by this
@@ -62,6 +74,38 @@ class Rack::RPC::Endpoint
         end
         self
       end
+
+
+      ##  
+      # Create a valid error response for a given code and message
+      #
+      # @param [Int] error code
+      # @param [String] error message
+      # @return [String] response xml string
+      def error_response(code, message)
+        xml = Builder::XmlMarkup.new
+        xml.instruct! :xml, :version=>"1.0"
+        xml.methodResponse{ 
+          xml.fault {
+            xml.value{
+              xml.struct{
+                xml.member{
+                  xml.name('faultCode')
+                  xml.value{
+                    xml.int(code)
+                  }
+                }
+                xml.member{
+                  xml.name('faultString')
+                  xml.value{
+                    xml.string(message)
+                  } 
+                }
+              } 
+            } 
+          } 
+        }
+      end
     end # Server
   end # XMLRPC
 end # Rack::RPC::Endpoint

data/lib/rack/rpc/server.rb

@@ -9,10 +9,34 @@ module Rack; module RPC
       if mappings.empty?
         @mappings
       else
+        # Store the mappings
         @mappings.merge!(mappings)
+
+        # Wrap each method so we can inject before and after callbacks
+        mappings.each do |rpc_method_name, server_method|
+          self.send(:alias_method, :"#{server_method}_without_callbacks", server_method.to_sym)
+          self.send(:define_method, server_method) do
+            self.class.hooks[:before].each{|command| command.call(self) if command.callable?(server_method)}
+            out = self.send(:"#{server_method}_without_callbacks")
+            self.class.hooks[:after].each{|command| command.call(self) if command.callable?(server_method)}
+            out
+          end
+        end
       end
     end
 
+    def self.hooks
+      @hooks ||= {:before => [], :after => []}
+    end
+
+    def self.before_filter(method_sym = nil, options = {}, &block)
+      setup_hook(:before, method_sym, options, block)
+    end
+
+    def self.after_filter(method_sym = nil, options = {}, &block)
+      setup_hook(:after, method_sym, options, block)
+    end
+
     # @return [Hash]
     attr_reader :options
 
@@ -22,5 +46,57 @@ module Rack; module RPC
       @options = options.dup
       block.call(self) if block_given?
     end
+
+    private
+
+    def self.setup_hook(type, method, options, proc)
+      hooks[type] << if proc
+        ProcCommand.new(proc, options)
+      else
+        MethodCommand.new(method, options)
+      end
+    end
+
   end # Server
+
+  class Command
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+
+      # Convert non-array options to arrays
+      [:only, :except].each do |option|
+        options[option] = [options[option]] if !options[option].nil? && !options[option].is_a?(Array)
+      end
+    end
+
+    def callable?(method)
+      options.empty? ||
+      (!options[:only].nil? && options[:only].include?(method)) ||
+      (!options[:except].nil? && !options[:except].include?(method))
+    end
+  end
+
+  class ProcCommand < Command
+    def initialize(proc, options)
+      @proc = proc.to_proc
+      super(options)
+    end
+
+    def call(server)
+      server.instance_eval(&@proc)
+    end
+  end # ProcCommand
+
+  class MethodCommand < Command
+    def initialize(method, options)
+      @method = method.to_sym
+      super(options)
+    end
+
+    def call(server)
+      server.__send__(@method)
+    end
+  end # MethodCommand
 end; end # Rack::RPC

data/lib/rack/rpc/version.rb

@@ -2,7 +2,7 @@ module Rack; module RPC
   module VERSION
     MAJOR = 0
     MINOR = 0
-    TINY  = 2
+    TINY  = 3
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Datagraph
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-30 00:00:00 +02:00
+date: 2011-01-13 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,10 +52,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
+        - 2
         - 1
-        - 3
         - 0
-        version: 1.3.0
+        version: 2.1.0
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -72,6 +72,20 @@ dependencies:
         version: 0.5.6
   type: :development
   version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 4
+        version: 1.4.4
+  type: :development
+  version_requirements: *id005
 description: Rack middleware for serving up RPC endpoints.
 email: datagraph@googlegroups.com
 executables: []