rack-rpc 0.0.0 → 0.0.1

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.0.1

data/lib/rack/rpc.rb

@@ -1,7 +1,10 @@
-require 'rack'
+require 'rack' # @see http://rubygems.org/gems/rack
 
 module Rack
   module RPC
-    autoload :VERSION, 'rack/rpc/version'
+    autoload :Endpoint,   'rack/rpc/endpoint'
+    autoload :Middleware, 'rack/rpc/middleware'
+    autoload :Server,     'rack/rpc/server'
+    autoload :VERSION,    'rack/rpc/version'
   end
 end

data/lib/rack/rpc/endpoint.rb

@@ -0,0 +1,47 @@
+module Rack; module 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; end # Rack::RPC

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

@@ -0,0 +1,212 @@
+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)
+        Rack::Response.new([process(request.body.read)], 200, {
+          'Content-Type' => (request.content_type || CONTENT_TYPE).to_s,
+        })
+      end
+
+      ##
+      # @param  [String] input
+      # @return [String]
+      def process(input)
+        begin
+          response = case json = JSON.parse(input)
+            when Array then process_batch(json)
+            when Hash  then process_request(json)
+          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
+      # @return [Array]
+      def process_batch(batch)
+        batch.map { |struct| process_request(struct) }
+      end
+
+      ##
+      # @param  [Hash] struct
+      # @return [Hash]
+      def process_request(struct)
+        response = JSONRPC::Response.new
+        begin
+          request = JSONRPC::Request.new(struct)
+          response.id = request.id
+          raise ::TypeError, "invalid request" unless request.valid?
+          method = @server.class.rpc[request.method]
+          raise ::NoMethodError, "undefined method `#{request.method}'" unless method && @server.respond_to?(method)
+          response.result = @server.__send__(method, *request.params)
+        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 => 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 = {}
+
+      ##
+      # @parse  [String] input
+      # @return [Object]
+      def self.parse(input)
+        self.new(JSON.parse(input))
+      end
+
+      ##
+      # @param  [Hash] options
+      def initialize(options = {})
+        options = self.class.const_get(:OPTIONS).merge(options)
+        options.each do |k, v|
+          instance_variable_set("@#{k}", v)
+        end
+      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
+    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,65 @@
+require 'xmlrpc/server' unless defined?(XMLRPC::BasicServer)
+begin
+  require 'builder/xchar' # @see http://rubygems.org/gems/builder
+rescue LoadError => e
+end
+
+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 = {})
+        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)
+        Rack::Response.new([process(request.body.read)], 200, {
+          'Content-Type' => (request.content_type || CONTENT_TYPE).to_s,
+        })
+      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
+    end # Server
+  end # XMLRPC
+end # Rack::RPC::Endpoint

data/lib/rack/rpc/middleware.rb

@@ -0,0 +1,25 @@
+module Rack; module 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; end # Rack::RPC

data/lib/rack/rpc/server.rb

@@ -0,0 +1,26 @@
+module Rack; module RPC
+  ##
+  # A base class for RPC servers.
+  class Server
+    ##
+    # @private
+    def self.rpc(mappings = {})
+      @mappings ||= {}
+      if mappings.empty?
+        @mappings
+      else
+        @mappings.merge!(mappings)
+      end
+    end
+
+    # @return [Hash]
+    attr_reader :options
+
+    ##
+    # @param  [Hash] options
+    def initialize(options = {}, &block)
+      @options = options.dup
+      block.call(self) if block_given?
+    end
+  end # Server
+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  = 0
+    TINY  = 1
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 0
-  version: 0.0.0
+  - 1
+  version: 0.0.1
 platform: ruby
 authors: 
 - Datagraph
@@ -86,6 +86,11 @@ files:
 - README
 - UNLICENSE
 - VERSION
+- lib/rack/rpc/endpoint/jsonrpc.rb
+- lib/rack/rpc/endpoint/xmlrpc.rb
+- lib/rack/rpc/endpoint.rb
+- lib/rack/rpc/middleware.rb
+- lib/rack/rpc/server.rb
 - lib/rack/rpc/version.rb
 - lib/rack/rpc.rb
 has_rdoc: false