slash 0.4.4

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Igor Gunko
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

data/README.rdoc

@@ -0,0 +1,11 @@
+== slash
+    @resource = Slash::Resource.new('http://api.something.com',
+      Slash::Formats.xml(:codec => Slash::Formats::PeanutsXML.new(Response)),
+      rewrite_options(options).update(:key => API_KEY))
+
+    cats = @resource['cats']
+    cats.get
+    cats.create(:name => 'Tom')
+    cats[123].update(:name => 'Tim')
+    cats[123].destroy
+

data/Rakefile

@@ -0,0 +1,29 @@
+$KCODE = 'u'
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+Rake::GemPackageTask.new(Gem::Specification.load('slash.gemspec')) do |p|
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.rdoc" # page to start on
+  rdoc.title = "Slash Documentation"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+desc 'Run specs'
+task :test => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+end

data/lib/slash.rb

@@ -0,0 +1,11 @@
+require 'extlib'
+require 'slash/formats'
+require 'slash/resource'
+
+module Slash
+  USER_AGENT = 'Slash 0.4.4 (http://github.com/omg/slash)'
+
+  class << self
+    attr_accessor :logger
+  end
+end

data/lib/slash/connection.rb

@@ -0,0 +1,122 @@
+require 'forwardable'
+require 'addressable/uri'
+require 'slash/exceptions'
+
+
+module Slash
+  class Queue
+  end
+
+  class Connection
+    extend Forwardable
+
+    attr_accessor :timeout, :proxy
+
+    # Execute a GET request.
+    # Used to get (find) resources.
+    def get(uri, options = {}, &block)
+      request(:get, uri, options, &block)
+    end
+
+    # Execute a DELETE request (see HTTP protocol documentation if unfamiliar).
+    # Used to delete resources.
+    def delete(uri, options = {}, &block)
+      request(:delete, uri, options, &block)
+    end
+
+    # Execute a PUT request.
+    # Used to update resources.
+    def put(uri, options = {}, &block)
+      request(:put, uri, options, &block)
+    end
+
+    # Execute a POST request.
+    # Used to create new resources.
+    def post(uri, options = {}, &block)
+      request(:post, uri, options, &block)
+    end
+
+    # Execute a HEAD request.
+    # Used to obtain meta-information about resources, such as whether they exist and their size (via response headers).
+    def head(uri, options = {}, &block)
+      request(:head, uri, options, &block)
+    end
+
+    private
+    def prepare_request(uri, options)
+      case options[:auth]
+      when nil, :basic
+        user, password = uri.normalized_user, uri.normalized_password
+        options.headers['Authorization'] = 'Basic ' + ["#{user}:#{ password}"].pack('m').delete("\r\n") if user || password
+      else
+        raise ArgumentError, 'unsupported auth'
+      end
+    end
+
+    # Handles response and error codes from remote service.
+    def handle_response(response)
+      response.exception = case response.code.to_i
+      when 301,302
+        Redirection.new(response)
+      when 200...400
+        nil
+      when 400
+        BadRequest.new(response)
+      when 401
+        UnauthorizedAccess.new(response)
+      when 403
+        ForbiddenAccess.new(response)
+      when 404
+        ResourceNotFound.new(response)
+      when 405
+        MethodNotAllowed.new(response)
+      when 409
+        ResourceConflict.new(response)
+      when 410
+        ResourceGone.new(response)
+      when 422
+        ResourceInvalid.new(response)
+      when 401...500
+        ClientError.new(response)
+      when 500...600
+        ServerError.new(response)
+      else
+        ConnectionError.new(response, "Unknown response code: #{response.code}")
+      end
+      response
+    end
+
+    def check_and_raise(response)
+      raise response.exception if response.exception
+      response
+    end
+
+    def logger #:nodoc:
+      Slash.logger
+    end
+
+    class << self
+      attr_writer :default
+
+      def default(&block)
+        @default = block if block_given?
+        @default
+      end
+
+      def create_default
+        if @default.respond_to?(:new)
+          return @default.new
+        else
+          return @default.call
+        end
+      end
+    end
+
+    self.default { NetHttpConnection.new }
+  end
+
+  autoload :NetHttpConnection, 'slash/nethttp'
+
+  autoload :TyphoeusConnection, 'slash/typhoeus'
+  autoload :TyphoeusQueue, 'slash/typhoeus'
+end

data/lib/slash/exceptions.rb

@@ -0,0 +1,66 @@
+module Slash
+  class ConnectionError < StandardError # :nodoc:
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @response = response
+      @message  = message
+    end
+
+    def to_s
+      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
+    end
+  end
+
+  # Raised when a Timeout::Error occurs.
+  class TimeoutError < ConnectionError
+    def initialize(message)
+      @message = message
+    end
+    def to_s; @message ;end
+  end
+
+  # Raised when a OpenSSL::SSL::SSLError occurs.
+  class SSLError < ConnectionError
+    def initialize(message)
+      @message = message
+    end
+    def to_s; @message ;end
+  end
+
+  # 3xx Redirection
+  class Redirection < ConnectionError # :nodoc:
+    def to_s; response.headers['Location'] ? "#{super} => #{response.headers['Location']}" : super; end
+  end
+
+  # 4xx Client Error
+  class ClientError < ConnectionError; end # :nodoc:
+
+  # 400 Bad Request
+  class BadRequest < ClientError; end # :nodoc
+
+  # 401 Unauthorized
+  class UnauthorizedAccess < ClientError; end # :nodoc
+
+  # 403 Forbidden
+  class ForbiddenAccess < ClientError; end # :nodoc
+
+  # 404 Not Found
+  class ResourceNotFound < ClientError; end # :nodoc:
+
+  # 409 Conflict
+  class ResourceConflict < ClientError; end # :nodoc:
+
+  # 410 Gone
+  class ResourceGone < ClientError; end # :nodoc:
+
+  # 5xx Server Error
+  class ServerError < ConnectionError; end # :nodoc:
+
+  # 405 Method Not Allowed
+  class MethodNotAllowed < ClientError # :nodoc:
+    def allowed_methods
+      @response['Allow'].split(',').map { |verb| verb.strip.downcase.to_sym }
+    end
+  end
+end

data/lib/slash/formats.rb

@@ -0,0 +1,67 @@
+module Slash
+  module Formats
+    autoload :JSON, 'slash/json'
+    autoload :PeanutsXML, 'slash/peanuts'
+
+    def self.xml(options = {})
+      Format.new({:mime => 'application/xml'}.update(options))
+    end
+
+    def self.json(options = {})
+      options = {:mime => 'application/json'}.update(options)
+      options[:codec] ||= JSON
+      Format.new(options)
+    end
+
+    class Format
+      attr_reader :mime, :codec
+
+      def initialize(options)
+        @codec = options[:codec]
+        @mime = options[:mime] || (@codec.respond_to?(:mime) ? @codec.mime : nil)
+      end
+
+      def prepare_request(options)
+        headers = options[:headers]
+        headers['Accept'] = mime if mime
+        data = options.delete(:data)
+        if data
+          options[:body] = codec.encode(data)
+          headers['Content-Type'] = mime if mime
+        end
+        options
+      end
+
+      def interpret_response(response)
+        bs = response.body_stream
+        bs && codec.decode(bs)
+      end
+    end
+
+    class WithSuffix < Format
+      attr_reader :suffix
+
+      def initialize(mime, suffix, codec)
+        super(mime, codec)
+        @suffix = suffix
+      end
+
+      def prepare_request(options, &block)
+        options[:path] += suffix if suffix
+        super
+      end
+
+      def self.xml(options = {})
+        WithSuffix.new(options.fetch(:mime, 'application/xml'),
+          options.fetch(:suffix, '.xml'),
+          options.fetch(:codec))
+      end
+
+      def self.json(options = {})
+        WithSuffix.new(options.fetch(:mime, 'application/json'),
+          options.fetch(:suffix, '.json'),
+          options.fetch(:codec) { JSON })
+      end
+    end
+  end
+end

data/lib/slash/json.rb

@@ -0,0 +1,16 @@
+require 'json'
+require 'slash/formats'
+
+module Slash
+  module Formats
+    class JSON
+      def encode(data)
+        ::JSON.generate(data)
+      end
+
+      def decode(data)
+        ::JSON.parse(data.read)
+      end
+    end
+  end
+end

data/lib/slash/nethttp.rb

@@ -0,0 +1,153 @@
+require 'net/https'
+require 'date'
+require 'time'
+require 'benchmark'
+require 'stringio'
+require 'slash/connection'
+
+
+module Slash
+  # Class to handle connections to remote web services.
+  # This class is used by ActiveResource::Base to interface with REST
+  # services.
+  class NetHttpConnection < Connection
+    @@request_types = {
+      :get => Net::HTTP::Get,
+      :post => Net::HTTP::Post,
+      :put => Net::HTTP::Put,
+      :delete => Net::HTTP::Delete
+    }
+
+    def self.request_types
+      @@request_types
+    end
+
+    attr_reader :proxy, :ssl_options
+
+    # Set the proxy for remote service.
+    def proxy=(proxy)
+      @http = nil
+      @proxy = proxy.is_a?(URI) ? proxy : URI.parse(proxy)
+    end
+
+    # Set the number of seconds after which HTTP requests to the remote service should time out.
+    def timeout=(timeout)
+      @timeout = timeout
+      configure_http(@http) if @http
+    end
+
+    # Hash of options applied to Net::HTTP instance when +site+ protocol is 'https'.
+    def ssl_options=(opts={})
+      @ssl_options = opts
+      configure_http(@http) if @http
+    end
+
+    def request(method, uri, options = {})
+      raise ArgumentError, 'this connection does not support async mode' if options[:async]
+
+      options = options.dup
+      prepare_request(uri, options)
+
+      rqtype = @@request_types[method] || raise(ArgumentError, "Unsupported method #{method}")
+      params = options[:params]
+      if !params.blank?
+        if [:post, :put].include?(method)
+          form_data = params
+        else
+          uri = uri.dup
+          uri.query_values = (uri.query_values(:notation => :flat) || {}).to_mash.update(params)
+        end
+      end
+      rq = rqtype.new(uri.query.blank? ? uri.path : "#{uri.path}?#{uri.query}", options[:headers])
+      rq.form_data = form_data if form_data
+      rq.body = options[:body] if options[:body]
+
+      resp = http_request(uri, rq)
+      if block_given?
+        yield resp
+      else
+        check_and_raise(resp)
+      end
+    end
+
+    private
+    # Makes request to remote service.
+    def http_request(uri, rq)
+      logger.debug "#{rq.method.to_s.upcase} #{uri}" if logger
+      result = nil
+      ms = 1000 * Benchmark.realtime { result = http(uri).request(rq) }
+      logger.debug "--> %d %s (%d %.0fms)" % [result.code, result.message, result.body ? result.body.length : 0, ms] if logger
+      augment_response(result)
+    rescue Timeout::Error => e
+      raise TimeoutError.new(e.message)
+    rescue OpenSSL::SSL::SSLError => e
+      raise SSLError.new(e.message)
+    end
+
+    def augment_response(response)
+      class << response
+        attr_accessor :exception
+        alias headers to_hash
+        def body_stream
+          body && StringIO.new(body)
+        end
+        def success?
+          exception.nil?
+        end
+      end
+      handle_response(response)
+    end
+
+    # Creates new Net::HTTP instance for communication with
+    # remote service and resources.
+    def http(uri)
+      if !@http || @host != uri.normalized_host || @port != uri.inferred_port || @scheme != uri.normalized_scheme
+        @host, @port, @scheme = uri.normalized_host, uri.inferred_port, uri.normalized_scheme
+        @http = configure_http(new_http)
+      end
+      @http
+    end
+
+    def new_http
+      if @proxy
+        Net::HTTP.new(@host, @port, @proxy.host, @proxy.port, @proxy.user, @proxy.password)
+      else
+        Net::HTTP.new(@host, @port)
+      end
+    end
+
+    def configure_http(http)
+      http = apply_ssl_options(http)
+
+      # Net::HTTP timeouts default to 60 seconds.
+      if @timeout
+        http.open_timeout = http.read_timeout = @timeout
+      end
+
+      http
+    end
+
+    def apply_ssl_options(http)
+      return http unless @scheme == 'https'
+
+      http.use_ssl     = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      return http unless defined?(@ssl_options)
+
+      http.ca_path     = @ssl_options[:ca_path] if @ssl_options[:ca_path]
+      http.ca_file     = @ssl_options[:ca_file] if @ssl_options[:ca_file]
+
+      http.cert        = @ssl_options[:cert] if @ssl_options[:cert]
+      http.key         = @ssl_options[:key]  if @ssl_options[:key]
+
+      http.cert_store  = @ssl_options[:cert_store]  if @ssl_options[:cert_store]
+      http.ssl_timeout = @ssl_options[:ssl_timeout] if @ssl_options[:ssl_timeout]
+
+      http.verify_mode     = @ssl_options[:verify_mode]     if @ssl_options[:verify_mode]
+      http.verify_callback = @ssl_options[:verify_callback] if @ssl_options[:verify_callback]
+      http.verify_depth    = @ssl_options[:verify_depth]    if @ssl_options[:verify_depth]
+
+      http
+    end
+  end
+end

data/lib/slash/peanuts.rb

@@ -0,0 +1,24 @@
+require 'peanuts'
+require 'slash/formats'
+
+module Slash
+  module Formats
+    class PeanutsXML
+      attr_reader :response_type
+      attr_accessor :to_xml_options, :from_xml_options
+
+      def initialize(response_type, from_xml_options = {}, to_xml_options = {})
+        @response_type = response_type
+        @to_xml_options, @from_xml_options = to_xml_options, from_xml_options
+      end
+
+      def encode(data)
+        data.to_xml(:string, to_xml_options)
+      end
+
+      def decode(data)
+        response_type.from_xml(data, from_xml_options)
+      end
+    end
+  end
+end

data/lib/slash/resource.rb

@@ -0,0 +1,195 @@
+require 'forwardable'
+require 'addressable/uri'
+require 'slash/connection'
+require 'slash/formats'
+
+
+module Slash
+  class Resource
+    class Response
+      extend Forwardable
+
+      def initialize(result, response, exception)
+        @result, @response, @exception = result, response, exception
+      end
+
+      attr_reader :result, :response, :exception
+
+      def_delegators :response, :code, :headers
+
+      def result!
+        raise exception if exception
+        result
+      end
+
+      def success?
+        exception.nil?
+      end
+    end
+
+    extend Forwardable
+
+    attr_accessor :connection, :uri, :params, :headers, :user, :password, :timeout, :proxy
+
+    def_delegator :uri, :path
+    def_delegator :uri, :query_values, :query
+
+    def user_agent
+      headers['User-Agent']
+    end
+
+    def user_agent=(value)
+      headers['User-Agent'] = value
+    end
+
+    def self.new!(*args, &block)
+      r = allocate
+      r.send(:initialize!, *args, &block)
+      r
+    end
+
+    def initialize(connection, uri, options = {})
+      @connection = connection
+      @uri = Addressable::URI.parse(uri)
+      query = options[:query]
+      unless query.blank?
+        @uri = @uri.dup
+        uq = @uri.query_values
+        @uri.query_values = uq ? uq.merge(query) : query
+      end
+      @params, @headers = (options[:params] || {}).to_mash, options[:headers] || {}
+      self.user_agent ||= options[:user_agent] || Slash::USER_AGENT
+    end
+
+    def initialize!(from, options)
+      @connection = from.connection
+      options = _merge(from, options)
+      @uri, @params, @headers = options[:uri], options[:params], options[:headers]
+    end
+    private :initialize!
+
+    def slash(options = {})
+      self.class.new!(self, options)
+    end
+
+    def [](path)
+      slash(:path => path)
+    end
+
+    # Execute a GET request.
+    # Used to get (find) resources.
+    def get(options = {}, &block)
+      request(options.merge(:method => :get), &block)
+    end
+
+    # Execute a DELETE request (see HTTP protocol documentation if unfamiliar).
+    # Used to delete resources.
+    def delete(options = {}, &block)
+      request(options.merge(:method => :delete), &block)
+    end
+
+    # Execute a PUT request.
+    # Used to update resources.
+    def put(options = {}, &block)
+      request(options.merge(:method => :put), &block)
+    end
+
+    # Execute a POST request.
+    # Used to create new resources.
+    def post(options = {}, &block)
+      request(options.merge(:method => :post), &block)
+    end
+
+    # Execute a HEAD request.
+    # Used to obtain meta-information about resources, such as whether they exist and their size (via response headers).
+    def head(options = {}, &block)
+      request(options.merge(:method => :head), &block)
+    end
+
+    def request(options)
+      rq = prepare_request(merge(options))
+      connection.request(rq.delete(:method), rq.delete(:uri), rq) do |response|
+        resp = handle_response(response)
+        block_given? ? yield(resp) : resp
+      end
+    end
+
+    private
+    def prepare_request(options)
+      options[:body] = options.delete(:data).to_s
+      options
+    end
+
+    def handle_response(response)
+      begin
+        exception = response.exception
+      rescue => e
+        exception = e
+      end
+      Response.new(prepare_result(response), response, exception)
+    end
+
+    def prepare_result(response)
+      response.body
+    end
+
+    def merge(options, &block)
+      _merge(self, options, &block)
+    end
+
+    def _merge(from, options)
+      options = options.dup
+      path, query, params, headers = options[:path], options[:query], options[:params], options[:headers]
+
+      u = options[:uri] = from.uri.dup
+
+      uq = u.query_values(:notation => :flat)
+      uq = uq ? (query ? uq.to_mash.merge(query) : uq) : query
+      if path
+        upath = u.path
+        u.path = upath + '/' unless upath =~ /\/\z/
+        u.join!(path)
+      end
+      if uq
+        u.query_values = uq
+      else
+        u.query = nil
+      end
+
+      p = options[:params] = from.params.dup
+      p.merge!(params) unless params.blank?
+
+      h = options[:headers] = from.headers.dup
+      h.merge!(headers) unless headers.blank?
+
+      options
+    end
+  end
+
+  class SimpleResource < Resource
+    attr_accessor :format
+
+    def initialize(uri, options = {})
+      super(options[:connection] || create_connection, uri, options)
+      self.format = options[:format]
+    end
+
+    private
+    def initialize!(from, options)
+      super
+      self.format = from.format
+    end
+
+    def create_connection
+      Connection.create_default
+    end
+
+    def prepare_request(options)
+      format ? format.prepare_request(options) : super
+    end
+
+    def prepare_result(response)
+      response.success? && format ? format.interpret_response(response) : super
+    end
+  end
+end

data/lib/slash/typhoeus.rb

@@ -0,0 +1,86 @@
+require 'typhoeus'
+require 'forwardable'
+require 'stringio'
+require 'slash/connection'
+
+
+module Slash
+  class TyphoeusQueue < Queue
+    extend Forwardable
+
+    def initialize(hydra_or_options = nil)
+      case hydra_or_options
+      when nil
+        @hydra = Typhoeus::Hydra.new
+        @hydra.disable_memoization
+      when Hash
+        @hydra = Typhoeus::Hydra.new(hydra_or_options)
+        @hydra.disable_memoization
+      else
+        @hydra = hydra_or_options
+      end
+    end
+    
+    attr_accessor :hydra
+
+    def_delegator :hydra, :queue, :submit
+    def_delegator :hydra, :run
+  end
+
+  class TyphoeusConnection < Connection
+    def initialize(options = {})
+      @queue = options[:queue] || TyphoeusQueue.new
+    end
+
+    attr_accessor :queue
+
+    def request(method, uri, options = {})
+      options = options.dup
+      prepare_request(uri, options)
+
+      params, headers = options[:params], options[:headers]
+      rq = Typhoeus::Request.new(uri.to_s,
+        :method => method,
+        :headers => headers,
+        :params => !params.blank? ? params.inject({}) {|h, x| h[x[0].to_s] = x[1] || ''; h } : nil,
+        :body => options[:body],
+        :timeout => options[:timeout] || timeout,
+        :user_agent => headers['User-Agent']
+      )
+      ret = nil
+      rq.on_complete do |response|
+        if logger
+          logger.debug "%s %s --> %d (%d %.0fs)" % [rq.method.to_s.upcase, rq.url,
+            response.code, response.body ? response.body.length : 0, response.time]
+        end
+        ret = response = augment_response(response)
+        ret = yield response if block_given?
+        response
+      end
+      async = options[:async]
+      queue = [true, false, nil].include?(async) ? self.queue : async
+      queue.submit(rq)
+      if async
+        queue
+      else
+        queue.run
+        block_given? ? ret : check_and_raise(rq.handled_response)
+      end
+    end
+
+    private
+    def augment_response(response)
+      class << response
+        attr_accessor :exception
+        def body_stream
+          body && StringIO.new(body)
+        end
+        def success?
+          exception.nil?
+        end
+      end
+
+      handle_response(response)
+    end
+  end
+end

data/spec/resource_spec.rb

@@ -0,0 +1,15 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+require 'resource'
+
+describe Slash::Resource do
+  before(:each) do
+    
+  end
+
+  it "should desc" do
+    # TODO
+  end
+end
+

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification 
+name: slash
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 4
+  version: 0.4.4
+platform: ruby
+authors: 
+- Igor Gunko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-10 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: extlib
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 14
+        version: 0.9.14
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        - 1
+        version: 2.1.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 8
+        version: 1.2.8
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: typhoeus
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 22
+        version: 0.1.22
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: peanuts
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        - 1
+        version: 2.1.1
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 2
+        version: 1.2.2
+  type: :development
+  version_requirements: *id006
+description: "    REST-client\n"
+email: tekmon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- README.rdoc
+- MIT-LICENSE
+- Rakefile
+- lib/slash.rb
+- lib/slash/exceptions.rb
+- lib/slash/connection.rb
+- lib/slash/nethttp.rb
+- lib/slash/typhoeus.rb
+- lib/slash/resource.rb
+- lib/slash/formats.rb
+- lib/slash/json.rb
+- lib/slash/peanuts.rb
+has_rdoc: true
+homepage: http://github.com/omg/slash
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 2
+summary: REST-client
+test_files: 
+- spec/resource_spec.rb