req 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzlmZDE1M2FiNzMwN2U3YzRkNTg0YjFmMGIxZTk0ODg5YjU5MzE3ZQ==
+  data.tar.gz: !binary |-
+    OTk0NzIxZmYxNTUyYTVmZGUwYzgyYjI5ZjMyMmM4YmFiMjMxMzk2Mg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZmQ4MDllNTBmMGMzNjc3NGNjYzAxODY2NjY4ZDFhMTE4ZTI3OTE3NDY4OWRk
+    ZTMwZDg3MGYyZDYyYmQzNDY1MzM3NzExOWY0ODQ4NmEyMzE5MmI1YzI3ZjEz
+    MzhkMGNmM2M0YzU3ZTllZTk3ZDgzODNmNTI4YzliYmJiZjkzNmM=
+  data.tar.gz: !binary |-
+    MjhmMzNlZDA2MzM0OWEyYjAzMjk5M2U1YzYyYzA4Y2FjZTJiNDA0OTY1ZWRk
+    OTA2NTFmZGViM2RiMjMzZjhmOWVjNjE4NDI2ZGU0ZjM0NmJlYzE1ZTA2OGUz
+    YjdjYjMxZjA0ZTE5MGZlZDcwN2ZmZGE0M2QyMTQ5N2FiMjk2YzE=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in request.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 wenjun.yan
+
+MIT License
+
+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.md

@@ -0,0 +1,72 @@
+# Req
+MAKE SIMPLE REQUEST SIMPLE.
+
+A simple http/net wrapper to make http request easy.
+
+Inspired by request.js
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'req'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install req
+
+## Usage
+
+> How to fork it?
+
+```ruby
+Req["https://api.github.com/repo/v2e4lisp/req/forks"].auth("user", "pass").post
+```
+
+> Send data(get).
+
+```ruby
+Req[url].send(a: 1, b: 2).get
+```
+
+> Post json
+
+```ruby
+Req[url].send(a: 1, b: 2).send(c: 3).type(:json).post
+```
+
+> Post form
+
+```ruby
+Req[url].send(field1: "username").send(field2: "password").type(:form).post
+```
+
+> Post form with file(multipart form)
+
+```ruby
+Req[url].send(field1: "username").send("file", csv_file, "optional-filename").post
+```
+
+> some other simple API
+
+* write(string): write to body
+* header(hash) : write to header
+* reset        : reset body and header
+* get(n)       : get with redirection limit default is 4
+* use_ssl(bool): turn on/off ssl. It will be auto turned on when scheme is "https"
+* mulit(bool)  : multipart form header. Auto turned on when files detected
+* type()       : specify content-type (:text,:json,:html,:xml,:form)
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Req

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/req.rb

@@ -0,0 +1,16 @@
+require 'net/http'
+require 'json'
+require 'base64'
+require 'mime/types'
+require "req/version"
+require "req/query"
+require "req/part"
+require "req/client"
+
+module Req
+  class << self
+    def [](url)
+      Client.new(url)
+    end
+  end
+end

data/lib/req/client.rb

@@ -0,0 +1,167 @@
+module Req
+  TYPE = {json: 'application/json',
+          form: 'application/x-www-form-urlencoded',
+          text: 'text/plain',
+          html: 'text/html',
+          xml: 'application/xml'}
+
+  class Client
+    attr_accessor :data, :files, :body, :headers
+    attr_reader :client, :url
+
+    def initialize(url)
+      self.url = url
+      @data = {}
+      @headers = {}
+      @files = []
+      @body = ''
+      @client = Net::HTTP.new(uri.hostname, uri.port)
+      use_ssl if uri.scheme == "https"
+    end
+
+    def get limit=4
+      update_uri
+      res = client.get(uri.request_uri, headers)
+      limit.times do
+        break unless res.is_a? Net::HTTPRedirection
+        # reset url and http client in case of the url scheme changed
+        # if no location found, Invalid response! CRUSH DOWN.
+        self.url = res['location']
+        @client = Net::HTTP.new(uri.hostname, uri.port)
+        use_ssl if uri.scheme == "https"
+        res = client.get(res['location'], headers)
+      end
+      block_given? ? yield(res) : res
+    end
+
+    # http verbs
+    [:head, :delete, :options].each do |method|
+      define_method method do |&block|
+        update_uri
+        res = client.send(method, uri.request_uri, headers)
+        block ? block.call(res) : res
+      end
+    end
+
+    [:post, :put, :patch].each do |method|
+      define_method method do |&block|
+        build
+        res = client.send(method, uri.request_uri, body, headers)
+        block ? block.call(res) : res
+      end
+    end
+
+    def use_ssl use=true
+      client.use_ssl = use
+      self
+    end
+
+    # basic authentication
+    def auth user, pass
+      set "Authorization" => "Basic #{Base64.encode64(user + ":" + pass).chop}"
+    end
+
+    def send name, file=nil, filename=nil
+      if file
+        upload name, file, filename
+      else
+        query name
+      end
+    end
+
+    def upload field, file, filename = nil
+      file = File.open(file)
+      @files << [field, file, filename || file.path]
+      self
+    end
+    alias_method :attach, :upload
+
+    def query option
+      data.merge! option
+      self
+    end
+
+    def header option
+      headers.merge! option
+      self
+    end
+    alias_method :set, :header
+
+    def write body
+      @body << body
+      self
+    end
+
+    def type t
+      # Set `Content-Type` header
+      tp = t.to_sym
+      t = TYPE[tp] if TYPE[tp]
+      set "Content-Type" => t
+    end
+
+    def multi on=true
+      @multi = on
+      self
+    end
+
+    def clear
+      @data = {}
+      @headers = {}
+      @files = []
+      @body = ''
+      self
+    end
+    alias_method :reset, :clear
+
+    private
+
+    def build
+      if not files.empty? or @multi
+        build_multipart
+      else
+        build_body
+      end
+      build_header
+    end
+
+    def build_header
+      return if headers['Content-Length']
+      headers['Content-Length'] = body.bytesize.to_s
+    end
+
+    def build_body
+      case headers['Content-Type']
+      when nil, TYPE[:form] then write data.to_query
+      when TYPE[:json] then write data.to_json
+      end
+    end
+
+    def build_multipart
+      m = Multipart.create(files, data)
+      write m.body
+      header m.header
+    end
+
+    def update_uri
+      unless data.empty?
+        url << "?" unless url["?"]
+        url << data.to_query
+        @uri = nil
+      end
+    end
+
+    def uri
+      @uri ||= URI(url).tap do |u|
+        # If the url is something like this: http://user:password@localhost",
+        # we setup the basic authorization header.
+        auth(u.user, u.password) if u.user and u.password
+      end
+    end
+
+    # if not schema is given, default is `http`
+    def url= url
+      @uri = nil
+      @url = (url['://'] ? '' : 'http://') << url
+    end
+  end
+end

data/lib/req/part.rb

@@ -0,0 +1,53 @@
+module Req
+  module Multipart
+    BOUNDARY = "--ruby-request--"
+    DEFAULT_MIME = "application/octet-stream"
+
+    def self.create files, data
+      Fields.new(files, data)
+    end
+
+    class Fields
+      def initialize files, data
+        @files = files || []
+        @params = data || []
+      end
+
+      def body
+        @body ||= '' << @files.inject("") { |acc, file|
+          acc << Attachment.new(*file).part
+        } << @params.inject("") { |acc, param|
+          acc << Param.new(*param).part
+        } << "--#{BOUNDARY}--\r\n\r\n"
+      end
+
+      def header
+        @header ||= {"Content-Length" => @body.bytesize.to_s,
+                     "Content-Type"   => "multipart/form-data; boundary=#{BOUNDARY}"}
+      end
+    end
+
+    class Attachment < Struct.new(:field, :file, :filename)
+      def part
+        return @part if @part
+        type = ::MIME::Types.type_for(filename).first || DEFAULT_MIME
+        @part = ''
+        @part << "--#{BOUNDARY}\r\n"
+        @part << "Content-Disposition: form-data; name=\"#{field}\"; filename=\"#{filename}\"\r\n"
+        @part << "Content-Type: #{type}\r\n\r\n"
+        @part << "#{file.read}\r\n"
+      end
+    end
+
+    class Param < Struct.new(:field, :value)
+      def part
+        return @part if @part
+        @part = ''
+        @part << "--#{BOUNDARY}\r\n"
+        @part << "Content-Disposition: form-data; name=\"#{field}\"\r\n"
+        @part << "\r\n"
+        @part << "#{value}\r\n"
+      end
+    end
+  end
+end

data/lib/req/query.rb

@@ -0,0 +1,75 @@
+# FOLLOWING CODE IS FROM `rails/activesupport'
+class Object
+  # Alias of <tt>to_s</tt>.
+  def to_param
+    to_s
+  end
+
+  # Converts an object into a string suitable for use as a URL query string, using the given <tt>key</tt> as the
+  # param name.
+  #
+  # Note: This method is defined as a default implementation for all Objects for Hash#to_query to work.
+  def to_query(key)
+    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+    "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
+  end
+end
+
+class NilClass
+  def to_param
+    self
+  end
+end
+
+class TrueClass
+  def to_param
+    self
+  end
+end
+
+class FalseClass
+  def to_param
+    self
+  end
+end
+
+class Array
+  # Calls <tt>to_param</tt> on all its elements and joins the result with
+  # slashes. This is used by <tt>url_for</tt> in Action Pack.
+  def to_param
+    collect { |e| e.to_param }.join '/'
+  end
+
+  # Converts an array into a string suitable for use as a URL query string,
+  # using the given +key+ as the param name.
+  #
+  #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
+  def to_query(key)
+    prefix = "#{key}[]"
+    collect { |value| value.to_query(prefix) }.join '&'
+  end
+end
+
+class Hash
+  # Returns a string representation of the receiver suitable for use as a URL
+  # query string:
+  #
+  #   {:name => 'David', :nationality => 'Danish'}.to_param
+  #   # => "name=David&nationality=Danish"
+  #
+  # An optional namespace can be passed to enclose the param names:
+  #
+  #   {:name => 'David', :nationality => 'Danish'}.to_param('user')
+  #   # => "user[name]=David&user[nationality]=Danish"
+  #
+  # The string pairs "key=value" that conform the query string
+  # are sorted lexicographically in ascending order.
+  #
+  # This method is also aliased as +to_query+.
+  def to_param(namespace = nil)
+    collect do |key, value|
+      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+    end.sort * '&'
+  end
+  alias_method :to_query, :to_param
+end

data/lib/req/version.rb

@@ -0,0 +1,3 @@
+module Req
+  VERSION = "0.0.1"
+end

data/req.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'req/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "req"
+  spec.version       = Req::VERSION
+  spec.authors       = ["wenjun.yan"]
+  spec.email         = ["mylastnameisyan@gmail.com"]
+  spec.description   = %q{an easy way to deal with simple http request}
+  spec.summary       = %q{FORK ME => Req["https://api.github.com/repo/v2e4lisp/req/forks"].auth("user", "pass").post }
+  spec.homepage      = "https://github.com/v2e4lisp/req"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "mime-types"
+  spec.add_dependency "json"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'sinatra'
+  spec.add_development_dependency 'sinatra-contrib'
+end

data/server.rb

@@ -0,0 +1,108 @@
+require 'sinatra'
+require "sinatra/multi_route"
+require "sinatra/cookies"
+require 'json'
+
+def header_titleize header
+  header.split("_").map {|w| w.capitalize }.join "-"
+end
+
+class Httpbin < Sinatra::Base
+  register Sinatra::MultiRoute
+  helpers Sinatra::Cookies
+  include FileUtils::Verbose
+
+  def authorized? user="test", pass="test"
+    @auth ||=  Rack::Auth::Basic::Request.new(request.env)
+    @auth.provided? &&
+      @auth.basic? &&
+      @auth.credentials &&
+      @auth.credentials == [user, pass]
+  end
+
+  def echo
+    request.env.inject({}) { |acc, item|
+      acc.tap do |result|
+        if item[0]["HTTP_"]
+          result[header_titleize(item[0].gsub(/^HTTP_/, ""))] = item[1]
+        end
+      end
+    }.tap {|header|
+      header["Content-Type"] = env["CONTENT_TYPE"] if env["CONTENT_TYPE"]
+    }.to_json
+  end
+
+  def data
+    if request.env["CONTENT_TYPE"] == "application/json"
+      request.body
+    else
+      params.to_json
+    end
+  end
+
+  def render_cookies
+    cookies.to_hash.to_json
+  end
+
+  before '/auth*' do
+    path = params[:splat].first
+    user, pass = path["/"] ? path[1..-1].split("/") : ["test", "test"]
+    unless authorized? user, pass
+      response['WWW-Authenticate'] = %(Basic realm="Restricted Area")
+      throw(:halt, [401, "Oops... we need your login name & password\n"])
+    end
+  end
+
+  get "/cookie" do
+    render_cookies
+  end
+
+  get "/cookie/delete/:name" do
+    #response.delete_cookie params[:name]
+    response.set_cookie(params[:name],
+                        value: "",
+                        path: "/cookie",
+                        :expires => Time.now - 3600*24)
+    params[:name]
+  end
+
+  get "/cookie/:name/:value" do
+    response.set_cookie(params[:name],
+                        value: params[:value],
+                        path: "/cookie")
+    render_cookies
+  end
+
+  get "/upload" do
+    <<-FORM
+    <form action='/upload' enctype="multipart/form-data" method='post'>
+    <input name="file" type="file" />
+    <input name="var" type="text" />
+    <input type="submit" value="Upload" />
+</form>
+FORM
+  end
+
+  route :post, :put, "/upload" do
+    params[:file][:tempfile].read
+    # request.body
+  end
+
+  route :get, :post, :put, :patch, :delete, "/auth" do
+    data
+  end
+
+  route :get, :post, :put, :patch, :delete, "/auth/:user/:pass" do
+    data
+  end
+
+  route :get, :post, :put, :patch, :delete, "/headers" do
+    echo
+  end
+
+  route :get, :post, :put, :patch, :delete, "/" do
+    data
+  end
+end
+
+Httpbin.run!

data/spec/auth_spec.rb

@@ -0,0 +1,32 @@
+require "./spec_helper"
+include Helpers
+
+describe "basic auth" do
+  describe "using auth method for basic authentication" do
+    url = base + "/auth"
+    it "should return ok" do
+      req = request(url).auth("test", "test")
+      request(url).auth("test", "test").get.body.should eq("{}")
+    end
+
+    it "should fail when no user or password" do
+      request(url).get.should respond_status(401)
+    end
+
+    it "should fail when invalid user and password" do
+      request(url).auth("fake", "test").get.should respond_status(401)
+    end
+  end
+
+  describe "using url for basic authentication" do
+    it "should return ok" do
+      url = "http://test:test@localhost:4567/auth"
+      request(url).get.body.should eq("{}")
+    end
+
+    it "should fail when invalid user and password" do
+      url = "http://fake:test@localhost:4567/auth"
+      request(url).get.should respond_status(401)
+    end
+  end
+end

data/spec/get_spec.rb

@@ -0,0 +1,27 @@
+require "./spec_helper"
+
+describe "Get from localhost:4567" do
+  url = base
+  it "should success" do
+    request(url).get.should respond_status(200)
+  end
+
+  it "should return the query data" do
+    query = "x=1"
+    request("#{url}?#{query}").get.body.from_json.should eq({"x" => "1"})
+  end
+
+  describe "Using query or send to set query data" do
+    it "Set data in one query" do
+      request(url).send(hello: "x", world: 1).get.body.from_json
+      .should eq({"hello" => "x", "world" => "1"})
+    end
+
+    it "Multiple query call will merge the data" do
+      request(url).send(hello: "x").send(world: 1).get.body.from_json
+      .should eq({"hello" => "x", "world" => "1"})
+      request(url).query(hello: "x").query(world: 1).get.body.from_json
+      .should eq({"hello" => "x", "world" => "1"})
+    end
+  end
+end

data/spec/header_spec.rb

@@ -0,0 +1,53 @@
+require "./spec_helper"
+include Helpers
+
+describe "Request.header" do
+  url = base + "/headers"
+
+  it "set multiple header" do
+    request(url).header("X-1" => "x1").header("X-2" => "x2").get
+    .should send_header("X-1" => "x1","X-2" => "x2")
+  end
+
+  describe "Content-Type" do
+    describe "#header" do
+      it "set to application/json" do
+        request(url).header("Content-Type" => "xxx").post
+        .should send_header("content-type" => "xxx")
+      end
+    end
+
+    describe "#type" do
+      it "set Content-Type to customized type" do
+        request(url).type("xxx").post
+        .should send_header("content-type" => "xxx")
+      end
+
+      it "set Content-Type to text/html" do
+        request(url).type(:html).post
+        .should send_header("content-type" => "text/html")
+      end
+
+      it "set Content-Type to application/json" do
+        request(url).type(:json).post
+        .should send_header("content-type" => "application/json")
+      end
+
+      it "set Content-Type to application/x-www-form-urlencoded" do
+        request(url).type(:form).post
+        .should send_header("content-type" =>
+                            "application/x-www-form-urlencoded")
+      end
+
+      it "set Content-Type to application/xml" do
+        request(url).type(:xml).post
+        .should send_header("content-type" => "application/xml")
+      end
+
+      it "set Content-Type to text/plain" do
+        request(url).type(:text).post
+        .should send_header("content-type" => "text/plain")
+      end
+    end
+  end
+end

data/spec/post_spec.rb

@@ -0,0 +1,33 @@
+require "./spec_helper"
+
+describe "Post to localhost:4567" do
+  url = base
+  query = {"x" => 1}
+
+  it "should success" do
+    request(url).post.should respond_status(200)
+  end
+
+  describe "Post form" do
+    context "with param" do
+      it "should return the same query data" do
+        request(url).query(query).post.body.from_json.should eq({"x" => "1"})
+      end
+    end
+    context "with file" do
+      it "should return the same text in the uploaded file" do
+        text = "uploading"
+        tmpfile = "./tmp.txt"
+        File.open(tmpfile, "w") { |f| f << text }
+        request(url + "/upload").upload("file", tmpfile)
+        .post.body.should eq(text)
+      end
+    end
+  end
+
+  describe "Post json" do
+    it "should reutrn the same json data" do
+      request(url).query(query).type(:json).post.body.from_json.should eq(query)
+    end
+  end
+end

data/spec/schema_spec.rb

@@ -0,0 +1,13 @@
+require "./spec_helper"
+
+describe "schema" do
+  describe "without a schema defualt is http" do
+    it "should be ok" do
+      request("localhost:4567").get.should respond_status(200)
+    end
+  end
+
+  describe "https and ssl" do
+    # todo
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require '../lib/req.rb'
+require "json"
+
+class String
+  def from_json
+    JSON.parse self
+  end
+end
+
+def base
+  "http://localhost:4567"
+end
+
+# API
+def request url
+  Req::Client.new(url)
+end
+
+RSpec.configure do |config|
+end
+
+module Helpers
+  extend RSpec::Matchers::DSL
+  matcher :respond_status do |code|
+    match do |actual|
+      actual.code.to_i == code.to_i
+    end
+  end
+
+  matcher :send_header do |header|
+    match do |actual|
+      actual_header = actual.body.from_json
+      header.inject(true) do |acc, item|
+        key = item.first.split("-").map {|w| w.capitalize }.join "-"
+        acc and (actual_header[key] == item.last)
+      end
+    end
+  end
+end

data/spec/tmp.txt

@@ -0,0 +1 @@
+uploading

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: req
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- wenjun.yan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: 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: rspec
+  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: sinatra
+  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: sinatra-contrib
+  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'
+description: an easy way to deal with simple http request
+email:
+- mylastnameisyan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/req.rb
+- lib/req/client.rb
+- lib/req/part.rb
+- lib/req/query.rb
+- lib/req/version.rb
+- req.gemspec
+- server.rb
+- spec/auth_spec.rb
+- spec/get_spec.rb
+- spec/header_spec.rb
+- spec/post_spec.rb
+- spec/schema_spec.rb
+- spec/spec_helper.rb
+- spec/tmp.txt
+homepage: https://github.com/v2e4lisp/req
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: FORK ME => Req["https://api.github.com/repo/v2e4lisp/req/forks"].auth("user",
+  "pass").post
+test_files:
+- spec/auth_spec.rb
+- spec/get_spec.rb
+- spec/header_spec.rb
+- spec/post_spec.rb
+- spec/schema_spec.rb
+- spec/spec_helper.rb
+- spec/tmp.txt