threez-rack-rpc 0.0.8

data/AUTHORS

@@ -0,0 +1,3 @@
+* Arto Bendiken <arto.bendiken@gmail.com>
+* Josh Huckabee <joshhuckabee@gmail.com>
+* Vincent Landgraf <vincent.landgraf@1und1.de>

data/README

@@ -0,0 +1,149 @@
+JSON-RPC/XML-RPC Server for Rack Applications
+=============================================
+
+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)
+* [Builder](http://rubygems.org/gems/builder) (>= 2.1.2)
+
+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/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.0.8

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

@@ -0,0 +1,255 @@
+require 'json' unless defined?(JSON)
+
+class Rack::RPC::Endpoint
+  ##
+  # @see http://en.wikipedia.org/wiki/JSON-RPC
+  # @see http://groups.google.com/group/json-rpc/web/json-rpc-2-0
+  module JSONRPC
+    CONTENT_TYPE = 'application/json; charset=UTF-8'
+    VERSION      = 2.0
+
+    ##
+    # @see http://groups.google.com/group/json-rpc/web/json-rpc-2-0
+    class Server
+      ##
+      # @param  [Rack::RPC::Server] server
+      # @param  [Hash{Symbol => Object}] options
+      def initialize(server, options = {})
+        @server, @options = server, options.dup
+      end
+
+      ##
+      # @param  [Rack::Request] request
+      # @return [Rack::Response]
+      def execute(request)
+        # Store the request so that it can be accessed from the server methods:
+        @server.request = request if @server.respond_to?(:request=)
+
+        request_body = request.body.read
+        request_body.force_encoding(Encoding::UTF_8) if request_body.respond_to?(:force_encoding) # Ruby 1.9+
+
+        Rack::Response.new([process(request_body, request)], 200, {
+          'Content-Type' => (request.content_type || CONTENT_TYPE).to_s,
+        })
+      end
+
+      ##
+      # @param  [String] input
+      # @param  [Object] context
+      # @return [String]
+      def process(input, context = nil)
+        response = nil
+        begin
+          response = case (json = JSON.parse(input))
+            when Array then process_batch(json, context)
+            when Hash  then process_request(json, context)
+          end
+        rescue JSON::ParserError => exception
+          response = JSONRPC::Response.new
+          response.error = JSONRPC::ParseError.new(:message => exception.to_s)
+        end
+        response.to_json + "\n"
+      end
+
+      ##
+      # @param  [Array<Hash>] batch
+      # @param  [Object] context
+      # @return [Array]
+      def process_batch(batch, context = nil)
+        batch.map { |struct| process_request(struct, context) }
+      end
+
+      ##
+      # @param  [Hash] struct
+      # @param  [Object] context
+      # @return [Hash]
+      def process_request(struct, context = nil)
+        response = JSONRPC::Response.new
+        begin
+          request = JSONRPC::Request.new(struct, context)
+          response.id = request.id
+
+          raise ::TypeError, "invalid JSON-RPC request" unless request.valid?
+
+          case operator = @server.class[request.method]
+            when nil
+              raise ::NoMethodError, "undefined operation `#{request.method}'"
+            when Class # a Rack::RPC::Operation subclass
+              response.result = operator.new(request).execute
+            else
+              response.result = @server.__send__(operator, *request.params)
+          end
+
+        rescue ::TypeError => exception # FIXME
+          response.error = JSONRPC::ClientError.new(:message => exception.to_s)
+
+        rescue ::NoMethodError => exception
+          response.error = JSONRPC::NoMethodError.new(:message => exception.to_s)
+
+        rescue ::ArgumentError => exception
+          response.error = JSONRPC::ArgumentError.new(:message => exception.to_s)
+
+        rescue ::Rack::RPC::Error => exception
+          response.error = JSONRPC::Error.new(:message => exception.to_s,
+                                              :code => exception.code,
+                                              :data => exception.data)
+
+        rescue => exception
+          response.error = JSONRPC::InternalError.new(:message => exception.to_s)
+        end
+
+        response.to_hash.delete_if { |k, v| v.nil? }
+      end
+    end # Server
+
+    ##
+    # Base class for JSON-RPC objects.
+    class Object
+      OPTIONS = {}
+
+      ##
+      # @param  [String] input
+      # @return [Object]
+      def self.parse(input)
+        self.new(JSON.parse(input))
+      end
+
+      ##
+      # An arbitrary context associated with the object.
+      #
+      # @return [Object]
+      attr_reader :context
+
+      ##
+      # @param  [Hash] options
+      # @param  [Object] context
+      #   an optional context to associate with the object
+      def initialize(options = {}, context = nil)
+        options = self.class.const_get(:OPTIONS).merge(options)
+        options.each do |k, v|
+          instance_variable_set("@#{k}", v)
+        end
+        @context = context if context
+      end
+
+      ##
+      # @return [String]
+      def to_json
+        to_hash.delete_if { |k, v| v.nil? }.to_json
+      end
+    end # Object
+
+    ##
+    # JSON-RPC notification objects.
+    class Notification < Object
+      attr_accessor :version
+      attr_accessor :method
+      attr_accessor :params
+
+      ##
+      # @return [Boolean]
+      def valid?
+        true # TODO
+      end
+
+      ##
+      # @return [Hash]
+      def to_hash
+        {
+          :jsonrpc => (version || VERSION).to_s,
+          :method  => method.to_s,
+          :params  => params ? params.to_a : [], # NOTE: named arguments not supported
+        }
+      end
+    end # Notification
+
+    ##
+    # JSON-RPC request objects.
+    class Request < Notification
+      attr_accessor :id
+
+      ##
+      # @return [Boolean]
+      def valid?
+        super && !id.nil?
+      end
+
+      ##
+      # @return [Hash]
+      def to_hash
+        super.merge({
+          :id => id,
+        })
+      end
+
+      ##
+      # @return [Array]
+      def to_args
+        # used from Operation#initialize
+        params
+      end
+    end # Request
+
+    ##
+    # JSON-RPC response objects.
+    class Response < Object
+      attr_accessor :version
+      attr_accessor :result
+      attr_accessor :error
+      attr_accessor :id
+
+      ##
+      # @return [Hash]
+      def to_hash
+        {
+          :jsonrpc => (version || VERSION).to_s,
+          :result  => result,
+          :error   => error ? error.to_hash : nil,
+          :id      => id,
+        }
+      end
+    end # Response
+
+    ##
+    # JSON-RPC error objects.
+    class Error < Object
+      attr_accessor :code
+      attr_accessor :message
+      attr_accessor :data
+
+      ##
+      # @return [Hash]
+      def to_hash
+        {
+          :code    => code.to_i,
+          :message => message.to_s,
+          :data    => data,
+        }
+      end
+    end # Error
+
+    class ParseError < Error
+      OPTIONS = {:code => -32700, :message => "parse error"}
+    end # ParseError
+
+    class ClientError < Error
+      OPTIONS = {:code => -32600, :message => "invalid request"}
+    end # ClientError
+
+    class NoMethodError < Error
+      OPTIONS = {:code => -32601, :message => "undefined method"}
+    end # NoMethodError
+
+    class ArgumentError < Error
+      OPTIONS = {:code => -32602, :message => "invalid arguments"}
+    end # ArgumentError
+
+    class InternalError < Error
+      OPTIONS = {:code => -32603, :message => "internal error"}
+    end # InternalError
+
+    class ServerError < Error
+      OPTIONS = {:code => -32000, :message => "server error"}
+    end # ServerError
+  end # JSONRPC
+ end # Rack::RPC::Endpoint

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

@@ -0,0 +1,110 @@
+require 'xmlrpc/server' unless defined?(XMLRPC::BasicServer)
+require 'builder'       # @see http://rubygems.org/gems/builder
+
+class Rack::RPC::Endpoint
+  ##
+  # @see http://en.wikipedia.org/wiki/XML-RPC
+  # @see http://www.xmlrpc.com/spec
+  module XMLRPC
+    CONTENT_TYPE = 'application/xml; charset=UTF-8'
+
+    ##
+    # @see http://ruby-doc.org/stdlib/libdoc/xmlrpc/rdoc/classes/XMLRPC/BasicServer.html
+    class Server < ::XMLRPC::BasicServer
+      ##
+      # @param  [Rack::RPC::Server] server
+      # @param  [Hash{Symbol => Object}] options
+      def initialize(server, options = {})
+        @server = server
+        super()
+        add_multicall     unless options[:multicall]     == false
+        add_introspection unless options[:introspection] == false
+        add_capabilities  unless options[:capabilities]  == false
+        server.class.rpc.each do |rpc_name, method_name|
+          add_handler(rpc_name, nil, nil, &server.method(method_name))
+        end
+      end
+
+      ##
+      # @param  [Rack::Request] request
+      # @return [Rack::Response]
+      def execute(request)
+        @server.request = request # Store the request so it can be accessed from the server methods
+        request_body = request.body.read
+        request_body.force_encoding(Encoding::UTF_8) if request_body.respond_to?(:force_encoding) # Ruby 1.9+
+        Rack::Response.new([process(request_body)], 200, {
+          'Content-Type' => (request.content_type || CONTENT_TYPE).to_s,
+        })
+      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
+      # server.
+      #
+      # @param  [Hash{Symbol => Object}] options
+      # @option options [Boolean] :faults_interop (true)
+      #   whether to indicate support for the XMLRPC-EPI Specification for
+      #   Fault Code Interoperability
+      # @return [void]
+      # @see    http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php
+      def add_capabilities(options = {})
+        add_handler('system.getCapabilities', %w(struct), '') do
+          capabilities = {}
+          unless options[:faults_interop] == false
+            capabilities['faults_interop'] = {
+              'specUrl'     => 'http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php',
+              'specVersion' => 20010516,
+            }
+          end
+          capabilities
+        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/endpoint.rb

@@ -0,0 +1,47 @@
+module Rack::RPC
+  ##
+  # A Rack middleware for RPC endpoints.
+  class Endpoint < Middleware
+    autoload :JSONRPC, 'rack/rpc/endpoint/jsonrpc'
+    autoload :XMLRPC,  'rack/rpc/endpoint/xmlrpc'
+
+    DEFAULT_PATH = '/rpc'
+
+    # @return [Server]
+    attr_reader :server
+    def server
+      @server = @server.call if @server.is_a?(Proc)
+      @server
+    end
+
+    ##
+    # @param  [#call] app
+    # @param  [Server] server
+    # @param  [Hash] options
+    def initialize(app, server, options = {})
+      @server = server
+      super(app, options)
+    end
+
+    ##
+    # @return [String]
+    def path
+      @path ||= options[:path] || DEFAULT_PATH
+    end
+
+    ##
+    # @param  [Hash] env
+    # @return [Array]
+    def call(env)
+      return super unless env['PATH_INFO'].eql?(path)
+      return super unless env['REQUEST_METHOD'].eql?('POST')
+      case content_type = env['CONTENT_TYPE']
+        when %r(^application/xml), %r(^text/xml)
+          XMLRPC::Server.new(server).execute(Rack::Request.new(env)).finish
+        when %r(^application/json)
+          JSONRPC::Server.new(server).execute(Rack::Request.new(env)).finish
+        else super
+      end
+    end
+  end # Endpoint
+end # Rack::RPC

data/lib/rack/rpc/error.rb

@@ -0,0 +1,27 @@
+require "xmlrpc/parser" unless defined?(XMLRPC::FaultException)
+
+module Rack::RPC
+  ##
+  # Represents an RPC Exception service.
+  #
+  class Error < XMLRPC::FaultException
+    attr_reader :data
+
+    alias code faultCode
+    alias message faultString
+    alias to_s faultString
+
+    ##
+    # Creates a new rpc related exception. This is useful if one wants to define
+    # custom exceptions.
+    # @param  [Fixnum] code an error code for the exception (used for mapping
+    #   on the client side)
+    # @param  [String] message the message that should be send along
+    # @param  [Object] a data object that may contain additional data on the
+    #   error (CAUTION: this is not possible with XMLRPC)
+    def initialize(code, message, data = nil)
+      @data = data
+      super(code, message)
+    end
+  end
+end

data/lib/rack/rpc/middleware.rb

@@ -0,0 +1,25 @@
+module Rack::RPC
+  ##
+  # A Rack middleware base class.
+  class Middleware
+    # @return [#call]
+    attr_reader :app
+
+    # @return [Hash]
+    attr_reader :options
+
+    ##
+    # @param  [#call] app
+    # @param  [Hash] options
+    def initialize(app, options = {})
+      @app, @options = app, options.dup
+    end
+
+    ##
+    # @param  [Hash] env
+    # @return [Array]
+    def call(env)
+      @app.call(env)
+    end
+  end # Middleware
+end # Rack::RPC

data/lib/rack/rpc/operation.rb

@@ -0,0 +1,226 @@
+module Rack::RPC
+  ##
+  # Represents an RPC server operation.
+  #
+  class Operation
+    ##
+    # Defines an operand for this operation class.
+    #
+    # @example
+    #   class Multiply < Operation
+    #     operand :x, Numeric
+    #     operand :y, Numeric
+    #   end
+    #
+    # @param  [Symbol, #to_sym] name
+    # @param  [Class] type
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Boolean] :optional (false)
+    # @option options [Boolean] :nullable (false)
+    # @return [void]
+    def self.operand(name, type = Object, options = {})
+      raise TypeError, "expected a Class, but got #{type.inspect}" unless type.is_a?(Class)
+      operands[name.to_sym] = options.merge(:type => type)
+    end
+
+    ##
+    # Defines the `#prepare` instance method.
+    #
+    # @yield
+    # @return [void]
+    def self.prepare(&block)
+      self.send(:define_method, :prepare) do
+        begin
+          begin
+            before_prepare if respond_to?(:before_prepare)
+            instance_eval(&block)
+          ensure
+            after_prepare if respond_to?(:after_prepare)
+          end
+          self
+        rescue Exception => error
+          after_error(error) if respond_to?(:after_error)
+          raise
+        end
+      end
+    end
+
+    ##
+    # Defines the `#execute` instance method.
+    #
+    # @yield
+    # @return [void]
+    def self.execute(&block)
+      self.send(:define_method, :execute) do
+        begin
+          before_execute if respond_to?(:before_execute)
+          result = instance_eval(&block)
+          after_execute if respond_to?(:after_execute)
+          result
+        rescue Exception => error
+          after_error(error) if respond_to?(:after_error)
+          raise
+        end
+      end
+    end
+
+    ##
+    # Returns the operand definitions for this operation class.
+    #
+    # @return [Hash{Symbol => Hash}]
+    def self.operands
+      @operands ||= {}
+    end
+
+    ##
+    # Returns the arity range for this operation class.
+    #
+    # @return [Range]
+    def self.arity
+      @arity ||= begin
+        if const_defined?(:ARITY)
+          const_get(:ARITY)
+        else
+          min, max = 0, 0
+          operands.each do |name, options|
+            min += 1 unless options[:optional].eql?(true)
+            max += 1
+          end
+          Range.new(min, max)
+        end
+      end
+    end
+
+    ##
+    # @return [Object]
+    attr_reader :context
+    def context() @__context__ end
+
+    ##
+    # Initializes a new operation with the given arguments.
+    #
+    # @param  [Hash{Symbol => Object}] args
+    def initialize(args = [])
+      case args
+        when Array then initialize_from_array(args)
+        when Hash  then initialize_from_hash(args)
+        else case
+          when args.respond_to?(:to_args)
+            initialize_from_array(args.to_args)
+            @__context__ = args.context if args.respond_to?(:context)
+          else raise ArgumentError, "expected an Array or Hash, but got #{args.inspect}"
+        end
+      end
+
+      initialize! if respond_to?(:initialize!)
+    end
+
+    ##
+    # @private
+    def initialize_from_array(args)
+      validate_arity!(args)
+
+      pos = 0
+      self.class.operands.each do |param_name, param_options|
+        arg = args[pos]; pos += 1
+
+        validate_argument!(arg, param_name, param_options)
+
+        instance_variable_set("@#{param_name}", arg)
+      end
+    end
+    protected :initialize_from_array
+
+    ##
+    # @private
+    def initialize_from_hash(args)
+      validate_arity!(args)
+
+      params = self.class.operands
+      args.each do |param_name, arg|
+        param_options = params[param_name.to_sym]
+
+        raise ArgumentError, "unknown parameter name #{param_name.inspect}" unless param_options
+        validate_argument!(arg, param_name, param_options)
+
+        instance_variable_set("@#{param_name}", arg)
+      end
+    end
+    protected :initialize_from_hash
+
+    ##
+    # @private
+    def validate_arity!(args)
+      unless self.class.arity.include?(argc = args.count)
+        raise ArgumentError, (argc < self.class.arity.min) ?
+          "too few arguments (#{argc} for #{self.class.arity.min})" :
+          "too many arguments (#{argc} for #{self.class.arity.max})"
+      end
+    end
+    protected :validate_arity!
+
+    ##
+    # @private
+    def validate_argument!(arg, param_name, param_options)
+      return if arg.nil? && (param_options[:nullable] || param_options[:optional])
+
+      if (param_type = param_options[:type]) && !(param_type === arg)
+        case param_type
+          when Regexp
+            raise TypeError, "expected a String matching #{param_type.inspect}, but got #{arg.inspect}"
+          else
+            raise TypeError, "expected a #{param_type}, but got #{arg.inspect}"
+        end
+      end
+    end
+    protected :validate_argument!
+
+    ##
+    # Prepares this operation.
+    #
+    # @abstract
+    # @return [void] `self`
+    def prepare
+      self
+    end
+
+    ##
+    # Executes this operation.
+    #
+    # @abstract
+    # @return [void]
+    def execute
+      raise NotImplementedError, "#{self.class}#execute"
+    end
+
+    ##
+    # Returns the array representation of the arguments to this operation.
+    #
+    # @return [Array]
+    def to_a
+      self.class.operands.inject([]) do |result, (param_name, param_options)|
+        result << instance_variable_get("@#{param_name}")
+        result
+      end
+    end
+
+    ##
+    # Returns the hash representation of the arguments to this operation.
+    #
+    # @return [Hash]
+    def to_hash
+      self.class.operands.inject({}) do |result, (param_name, param_options)|
+        result[param_name] = instance_variable_get("@#{param_name}")
+        result
+      end
+    end
+
+    ##
+    # Returns the JSON representation of the arguments to this operation.
+    #
+    # @return [String] a serialized JSON object
+    def to_json
+      to_hash.to_json
+    end
+  end # Operation
+end # Rack::RPC

data/lib/rack/rpc/server.rb

@@ -0,0 +1,112 @@
+module Rack::RPC
+  ##
+  # A base class for RPC servers.
+  class Server
+    ##
+    # @private
+    def self.[](rpc_method_name)
+      @mappings ||= {}
+      @mappings[rpc_method_name]
+    end
+
+    ##
+    # @private
+    def self.rpc(mappings = {})
+      @mappings ||= {}
+      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 |*args|
+            self.class.hooks[:before].each{|command| command.call(self) if command.callable?(server_method)}
+            out = self.send(:"#{server_method}_without_callbacks", *args)
+            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
+
+    # @return [Rack::Request]
+    attr_accessor :request
+
+    ##
+    # @param  [Hash] options
+    def initialize(options = {}, &block)
+      @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 # Rack::RPC

data/lib/rack/rpc/service.rb

@@ -0,0 +1,67 @@
+module Rack::RPC
+  ##
+  # Represents an RPC service.
+  #
+  class Service
+    ##
+    # Defines an operator for this service class.
+    #
+    # @example
+    #   class Calculator < Service
+    #     operator Add
+    #     operator Subtract
+    #     operator Multiply
+    #     operator Divide
+    #   end
+    #
+    # @param  [Class] klass
+    # @param  [Hash{Symbol => Object}] options
+    # @return [void]
+    def self.operator(klass, options = {})
+      raise TypeError, "expected a Class, but got #{klass.inspect}" unless klass.is_a?(Class)
+      operators[klass] ||= options
+    end
+
+    ##
+    # Returns the operator definitions for this service class.
+    #
+    # @return [Hash{Class => Hash}]
+    def self.operators
+      @operators ||= {}
+    end
+
+    ##
+    # Returns the operator class for the given operator name.
+    #
+    # @param  [Symbol, #to_sym] operator_name
+    # @return [Class]
+    def self.[](operator_name)
+      operator_name = operator_name.to_sym
+      operators.find do |klass, options|
+        klass_name = klass.name.split('::').last # TODO: optimize this
+        return klass if operator_name.eql?(klass_name.to_sym)
+      end
+    end
+
+    ##
+    # @param  [Symbol, #to_sym] method_name
+    # @return [Boolean] `true` or `false`
+    def respond_to?(method_name)
+      super || (self.class[method_name] ? true : false)
+    end
+
+    ##
+    # @param  [Symbol, #to_sym] method_name
+    # @param  [Array] args
+    # @return [void]
+    # @raise  [NoMethodError] if `self` doesn't respond to `method_name`
+    def method_missing(method_name, *args, &block)
+      if (operator = self.class[method_name]).nil?
+        super # raises NoMethodError
+      else
+        operator.new(args).execute
+      end
+    end
+    protected :method_missing
+  end # Service
+end # Rack::RPC

data/lib/rack/rpc/version.rb

@@ -0,0 +1,22 @@
+module Rack; module RPC
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 8
+    EXTRA = nil
+
+    STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+    ##
+    # @return [String]
+    def self.to_s() STRING end
+
+    ##
+    # @return [String]
+    def self.to_str() STRING end
+
+    ##
+    # @return [Array(Integer, Integer, Integer)]
+    def self.to_a() [MAJOR, MINOR, TINY] end
+  end
+end; end

data/lib/rack/rpc.rb

@@ -0,0 +1,13 @@
+require 'rack' # @see http://rubygems.org/gems/rack
+
+module Rack
+  module RPC
+    autoload :Endpoint,   'rack/rpc/endpoint'
+    autoload :Middleware, 'rack/rpc/middleware'
+    autoload :Operation,  'rack/rpc/operation'
+    autoload :Server,     'rack/rpc/server'
+    autoload :Service,    'rack/rpc/service'
+    autoload :VERSION,    'rack/rpc/version'
+    autoload :Error,      'rack/rpc/error'
+  end
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: threez-rack-rpc
+version: !ruby/object:Gem::Version
+  version: 0.0.8
+  prerelease: 
+platform: ruby
+authors:
+- Datagraph
+- Vincent Landgraf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.4
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+description: Rack middleware for serving up RPC endpoints.
+email: vincent.landgraf@1und1.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AUTHORS
+- CREDITS
+- README
+- UNLICENSE
+- VERSION
+- lib/rack/rpc/endpoint/jsonrpc.rb
+- lib/rack/rpc/endpoint/xmlrpc.rb
+- lib/rack/rpc/endpoint.rb
+- lib/rack/rpc/error.rb
+- lib/rack/rpc/middleware.rb
+- lib/rack/rpc/operation.rb
+- lib/rack/rpc/server.rb
+- lib/rack/rpc/service.rb
+- lib/rack/rpc/version.rb
+- lib/rack/rpc.rb
+homepage: https://github.com/threez/rack-rpc
+licenses:
+- Public Domain
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: JSON-RPC/XML-RPC server for Rack applications.
+test_files: []
+has_rdoc: false