rack-rpc 0.0.6 → 0.0.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 311298de76636a71b540962d19cbeb05d0e9da44
+  data.tar.gz: 0f3ec631aa8e0d4e4e7f8390298a849296d50557
+SHA512:
+  metadata.gz: d952513a405edada9932f9ee5aabb5cb7d03018cc078d5be9d61ab63f519db857819f45c61b5189a76feccd630a9fb2d756e3d6304450d11125139c4ac6524f6
+  data.tar.gz: 0b3413eddcd109138d7fe6c015f6a8869446ca97e9a8e59f414c8e48da81724657eef9cf8a9d87d902920d6e49523e58db5dbc3c6ce31130b4491760c6a8514b

data/AUTHORS

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

data/README

@@ -1,4 +1,4 @@
-JSON-RPC/XML-RPC Server for Rack Applications
+JSON-RPC/XML-RPC Server for Rack Applications [![Build Status](https://secure.travis-ci.org/threez/rack-rpc.png?branch=master)](http://travis-ci.org/threez/rack-rpc)
 =============================================
 
 This is a [Rack][] middleware that facilitates the creation of

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.11

data/lib/rack/rpc.rb

@@ -4,7 +4,10 @@ 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

data/lib/rack/rpc/endpoint.rb

@@ -1,4 +1,4 @@
-module Rack; module RPC
+module Rack::RPC
   ##
   # A Rack middleware for RPC endpoints.
   class Endpoint < Middleware
@@ -44,4 +44,4 @@ module Rack; module RPC
       end
     end
   end # Endpoint
-end; end # Rack::RPC
+end # Rack::RPC

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

@@ -22,22 +22,27 @@ class Rack::RPC::Endpoint
       # @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
+        # 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)], 200, {
+
+        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)
+      def process(input, context = nil)
+        response = nil
         begin
-          response = case json = JSON.parse(input)
-            when Array then process_batch(json)
-            when Hash  then process_request(json)
+          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
@@ -48,32 +53,51 @@ class Rack::RPC::Endpoint
 
       ##
       # @param  [Array<Hash>] batch
+      # @param  [Object] context
       # @return [Array]
-      def process_batch(batch)
-        batch.map { |struct| process_request(struct) }
+      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)
+      def process_request(struct, context = nil)
         response = JSONRPC::Response.new
         begin
-          request = JSONRPC::Request.new(struct)
+          request = JSONRPC::Request.new(struct, context)
           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)
+
+          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
@@ -90,13 +114,22 @@ class Rack::RPC::Endpoint
         self.new(JSON.parse(input))
       end
 
+      ##
+      # An arbitrary context associated with the object.
+      #
+      # @return [Object]
+      attr_reader :context
+
       ##
       # @param  [Hash] options
-      def initialize(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
 
       ##
@@ -148,6 +181,13 @@ class Rack::RPC::Endpoint
           :id => id,
         })
       end
+
+      ##
+      # @return [Array]
+      def to_args
+        # used from Operation#initialize
+        params
+      end
     end # Request
 
     ##

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

@@ -1,5 +1,14 @@
 require 'xmlrpc/server' unless defined?(XMLRPC::BasicServer)
-require 'builder/xchar' # @see http://rubygems.org/gems/builder
+require 'builder'       # @see http://rubygems.org/gems/builder
+
+# Monkey patch the xml writer for problems with double arrays
+# Problem is filed as: http://jira.codehaus.org/browse/JRUBY-6670
+class XMLRPC::XMLWriter::Simple
+  alias_method :unsave_element, :element
+  def element(name, attrs, *children)
+    unsave_element(name, attrs, *children.flatten)
+  end
+end
 
 class Rack::RPC::Endpoint
   ##

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

@@ -1,4 +1,4 @@
-module Rack; module RPC
+module Rack::RPC
   ##
   # A Rack middleware base class.
   class Middleware
@@ -22,4 +22,4 @@ module Rack; module RPC
       @app.call(env)
     end
   end # Middleware
-end; end # Rack::RPC
+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

@@ -1,7 +1,14 @@
-module Rack; module RPC
+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 = {})
@@ -17,7 +24,8 @@ module Rack; module RPC
           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)
+            method = :"#{server_method}_without_callbacks"
+            out = args.any? ? self.send(method, *args) : self.send(method)
             self.class.hooks[:after].each{|command| command.call(self) if command.callable?(server_method)}
             out
           end
@@ -102,4 +110,4 @@ module Rack; module RPC
       server.__send__(@method)
     end
   end # MethodCommand
-end; end # Rack::RPC
+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

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

metadata

@@ -1,165 +1,172 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: rack-rpc
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 6
-  version: 0.0.6
+version: !ruby/object:Gem::Version
+  version: 0.0.11
 platform: ruby
-authors: 
+authors:
 - Datagraph
+- Vincent Landgraf
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-01-26 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2014-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: builder
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 1
-        - 2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
         version: 2.1.2
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rack
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 0
-        version: "1.0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: nokogiri
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 4
-        - 4
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.3
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
         version: 1.4.4
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: yard
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 6
-        - 0
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.4
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
         version: 0.6.0
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 1
-        - 0
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
         version: 2.1.0
   type: :development
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: rack-test
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 5
-        - 6
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
         version: 0.5.6
   type: :development
-  version_requirements: *id006
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.6
 description: Rack middleware for serving up RPC endpoints.
-email: datagraph@googlegroups.com
+email: pieter@djinnit.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - AUTHORS
 - CREDITS
 - README
 - UNLICENSE
 - VERSION
+- lib/rack/rpc.rb
+- lib/rack/rpc/endpoint.rb
 - 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
-has_rdoc: false
-homepage: http://github.com/datagraph
-licenses: 
+homepage: https://github.com/rack-rpc/rack-rpc
+licenses:
 - Public Domain
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 1
-      - 8
-      - 1
-      version: 1.8.1
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: datagraph
-rubygems_version: 1.3.7
+rubyforge_project: 
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: JSON-RPC/XML-RPC server for Rack applications.
 test_files: []
-
+has_rdoc: false