zephyr 1.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,10 @@
+
+source "http://rubygems.org"
+gem "typhoeus", ">= 0.2.4"
+
+
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+end
+

data/Gemfile.lock

@@ -0,0 +1,21 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    mime-types (1.16)
+    rake (0.9.2)
+    typhoeus (0.2.4)
+      mime-types
+      mime-types
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  typhoeus (>= 0.2.4)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Matt Knopp
+
+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 @@
+## Simple HTTP client using Typheous, derived from the Riak client

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "zephyr"
+  gem.homepage = "http://github.com/mhat/zephyr"
+  gem.license = "MIT"
+  gem.summary = %Q{Simple HTTP client using Typheous, derived from the Riak client}
+  gem.description = %Q{Simple HTTP client using Typheous, derived from the Riak client}
+  gem.email = "matt.knopp@gmail.com"
+  gem.authors = ["Matt Knopp"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+##require 'rcov/rcovtask'
+##Rcov::RcovTask.new do |test|
+##  test.libs << 'test'
+##  test.pattern = 'test/**/test_*.rb'
+##  test.verbose = true
+##  test.rcov_opts << '--exclude "gems/*"'
+##end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "zephyr #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/zephyr.rb

@@ -0,0 +1,350 @@
+# Stolen with a fair bit of modification from the riak-client gem, which is
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+# Splits headers into < 8KB chunks
+# @private
+module Net::HTTPHeader
+  def each_capitalized
+    # 1.9 check
+    respond_to?(:enum_for) and (block_given? or return enum_for(__method__))
+    @header.each do |k,v|
+      base_length = "#{k}: \r\n".length
+      values = v.map { |i| i.to_s.split(', ') }.flatten
+      while !values.empty?
+        current_line = ""
+        while values.first && current_line.length + base_length + values.first.length + 2 < 8192
+          val = values.shift.strip
+          current_line += current_line.empty? ? val : ", #{val}"
+        end
+        yield capitalize(k), current_line
+      end
+    end
+  end
+end
+
+# A simple front-end for doing HTTP requests quickly and simply.
+class Zephyr
+  def initialize(root_uri = '')
+    @root_uri = URI.parse(root_uri.to_s).freeze
+  end
+
+  def default_headers
+    {
+      'Accept'      => 'application/json;q=0.7, */*;q=0.5',
+      'User-Agent'  => 'lib-http.rb',
+    }
+  end
+
+  # Performs a HEAD request to the specified resource.
+  #
+  # A request to /users/#{@user.id}/things?q=woof with an Accept header of
+  # "text/plain" which is expecting a 200 OK within 50ms
+  #
+  #   http.head(200, 50, ["users", @user.id, "things", {"q" => "woof"}], "Accept" => "text/plain")
+  #
+  # This returns a hash with three keys:
+  #   :status       The numeric HTTP status code
+  #   :body         The body of the response entity, if any
+  #   :headers      A hash of header values
+  def head(expected_statuses, timeout, path_components, headers={})
+    headers = default_headers.merge(headers)
+    verify_path!(path_components)
+    perform(:head, path_components, headers, expected_statuses, timeout)
+  end
+
+  Workfeed::Timer.time_method self, :head, 'http_head'
+
+  # Performs a GET request to the specified resource.
+  #
+  # A request to /users/#{@user.id}/things?q=woof with an Accept header of
+  # "text/plain" which is expecting a 200 OK within 50ms
+  #
+  #   http.get(200, 50 ["users", @user.id, "things", {"q" => "woof"}], "Accept" => "text/plain")
+  #
+  # This returns a hash with three keys:
+  #   :status       The numeric HTTP status code
+  #   :body         The body of the response entity, if any
+  #   :headers      A hash of header values
+  def get(expected_statuses, timeout, path_components, headers={})
+    headers   = default_headers.merge(headers)
+    verify_path!(path_components)
+    perform(:get, path_components, headers, expected_statuses, timeout)
+  end
+
+  Workfeed::Timer.time_method self, :get, 'http_get'
+
+  # The same thing as #get, but decodes the response entity as JSON (if it's
+  # application/json) and adds it under the :json key in the returned hash.
+  def get_json(expected_statuses, timeout, path_components, headers={}, yajl_opts={})
+    response = get(expected_statuses, timeout, path_components, headers)
+
+    content_type = response[:headers]['content-type']
+    content_type = content_type.first if content_type.respond_to?(:first)
+
+    if content_type.to_s.strip.match /^application\/json/
+      response[:json] = Yajl::Parser.parse(response[:body], yajl_opts)
+    end
+
+    response
+  end
+
+  # Performs a PUT request to the specified resource.
+  #
+  # A request to /users/#{@user.id}/things?q=woof with an Content-Type header of
+  # "text/plain" and a request entity of "yay" which is expecting a 204 No
+  # Content within 1000ms
+  #
+  #   http.put(204, 1000, ["users", @user.id, "things", {"q" => "woof"}], "yay", "Content-Type" => "text/plain")
+  #
+  # This returns a hash with three keys:
+  #   :status       The numeric HTTP status code
+  #   :body         The body of the response entity, if any
+  #   :headers      A hash of header values
+  def put(expected_statuses, timeout, path_components, entity, headers={})
+    headers = default_headers.merge(headers)
+    verify_path_and_entity!(path_components, entity)
+    perform(:put, path_components, headers, expected_statuses, timeout, entity)
+  end
+
+  Workfeed::Timer.time_method self, :put, 'http_put'
+
+  # The same thing as #put, but encodes the entity as JSON and specifies
+  # "application/json" as the request entity content type.
+  def put_json(expected_statuses, timeout, path_components, entity, headers={})
+    put(expected_statuses, timeout, path_components, Yajl::Encoder.encode(entity), headers.merge("Content-Type" => "application/json"))
+  end
+
+  # Performs a POST request to the specified resource.
+  #
+  # A request to /users/#{@user.id}/things?q=woof with an Content-Type header of
+  # "text/plain" and a request entity of "yay" which is expecting a 201 Created
+  # within 500ms
+  #
+  #   http.post(201, 500, ["users", @user.id, "things", {"q" => "woof"}], "yay", "Content-Type" => "text/plain")
+  #
+  # This returns a hash with three keys:
+  #   :status       The numeric HTTP status code
+  #   :body         The body of the response entity, if any
+  #   :headers      A hash of header values
+  def post(expected_statuses, timeout, path_components, entity, headers={})
+    headers   = default_headers.merge(headers)
+    verify_path_and_entity!(path_components, entity)
+    perform(:post, path_components, headers, expected_statuses, timeout, entity)
+  end
+
+  Workfeed::Timer.time_method self, :post, 'http_post'
+
+  # The same thing as #post, but encodes the entity as JSON and specifies
+  # "application/json" as the request entity content type.
+  def post_json(expected_statuses, timeout, path_components, entity, headers={})
+    post(
+         expected_statuses,
+         timeout,
+         path_components,
+         Yajl::Encoder.encode(entity),
+         headers.merge("Content-Type" => "application/json")
+         )
+  end
+
+  # Performs a DELETE request to the specified resource.
+  #
+  # A request to /users/#{@user.id}/things?q=woof which is expecting a 204 No
+  # Content within 666ms
+  #
+  #   http.put(200, 666, ["users", @user.id, "things", {"q" => "woof"}])
+  #
+  # This returns a hash with three keys:
+  #   :status       The numeric HTTP status code
+  #   :body         The body of the response entity, if any
+  #   :headers      A hash of header values
+  def delete(expected_statuses, timeout, path_components, headers={})
+    headers = default_headers.merge(headers)
+    verify_path!(path_components)
+    perform(:delete, path_components, headers, expected_statuses, timeout)
+  end
+
+  Workfeed::Timer.time_method self, :delete, 'http_delete'
+
+  # Creates a URI object, combining the root_uri passed on initialization
+  # with the given parts.
+  #
+  # Example:
+  #
+  #   http = Zephyr.new 'http://host/'
+  #   http.uri(['hi', 'bob', {:foo => 'bar'}]) => http://host/hi/bob?foo=bar
+  #
+  def uri(given_parts = [])
+    @root_uri.dup.tap do |uri|
+      parts     = given_parts.dup.unshift(uri.path) # URI#merge is broken.
+      uri.query = build_query_string(parts.pop) if parts.last.is_a? Hash
+      uri.path  = ('/%s/' % parts.join('/')).gsub(/\/+/, '/')
+    end
+  end
+
+  # Comes handy in IRB
+  #
+  def inspect
+    '#<%s:0x%s root_uri=%s>' % [ self.class.to_s, object_id.to_s(16), uri.to_s ]
+  end
+
+  def cleanup!
+    Typheous::Hydra.hydra.cleanup
+  end
+
+  # Assembles a query string from a Hash, escaping values and keys. If a
+  # value is an Array, the query parameter simply appears twice.
+  #
+  # Stolen from Rack (with minor changes for sorting).
+  #
+  def build_query_string(params)
+    params.map do |k, v|
+      if v.kind_of? Array
+        build_query_string(v.map { |x| [k, x] })
+      else
+        "#{percent_encode(k)}=#{percent_encode(v)}"
+      end
+    end.sort.join '&'
+  end
+
+  def percent_encode(value)
+    typhoeus_easy.send(:easy_escape, value.to_s, value.to_s.bytesize)
+  end
+
+  private
+
+  # NOTE: This is here only because it provides a binding to
+  # Curb's 'easy_escape' function, which does what we want.
+  # Don't use it to perform requests. Ever.
+  #
+  def typhoeus_easy
+    @_typhoeus_easy ||= Typhoeus::Easy.new.freeze
+  end
+
+  def verify_path_and_entity!(path_components, entity)
+    begin
+      verify_path!(path_components)
+    rescue ArgumentError
+      raise ArgumentError, "You must supply both a resource path and a body."
+    end
+
+    raise ArgumentError, "Request body must be a string or IO." unless String === entity || IO === entity
+  end
+
+  def verify_path!(path_components)
+    path_components = Array(path_components).flatten
+    raise ArgumentError, "Resource path too short" unless path_components.length > 0
+  end
+
+  def valid_response?(expected, actual)
+    Array(expected).map { |code| code.to_i }.include?(actual.to_i)
+  end
+
+  def return_body?(method, code)
+    method != :head && !valid_response?([204,205,304], code)
+  end
+
+  def perform(method, path_components, headers, expect, timeout, data=nil)
+    params           = {}
+    params[:headers] = headers
+    params[:timeout] = timeout
+    params[:follow_location] = false
+
+    # if you want debugging
+    # params[:verbose]         = true 
+
+    # have a vague feeling this isn't going to work as expected
+    if method == :post || method == :put
+      data = data.read if data.respond_to?(:read)
+      params[:body] = data
+    end
+
+    # request has class methods for :delete, :get, :head, :put, and :post
+    response = Typhoeus::Request.send(method, uri(path_components).to_s, params)
+
+    if defined?(Rails)
+      Rails.logger.info "lib/http.rb: #{method.to_s.upcase} #{uri(path_components).to_s}"
+    end
+
+    # be consistent with what came before
+    response_headers = Headers.new.tap do |h|
+      response.headers.split(/\n/).each do |header_line|
+        h.parse(header_line)
+      end
+    end
+
+    if valid_response?(expect, response.code)
+      result = { :headers => response_headers.to_hash, :status => response.code }
+      if return_body?(method, response.code)
+        result[:body] = response.body
+      end
+      result
+    else
+      response_body = response.timed_out? || response.code == 0 ? "Exceeded #{timeout}ms" : response.body
+      raise FailedRequest.new(method, expect, response.code, response_headers.to_hash, response_body, response.timed_out?)
+    end
+  end
+
+  def create_request_headers(hash)
+    h = Headers.new
+    hash.each {|k,v| h.add_field(k,v) }
+    [].tap do |arr|
+      h.each_capitalized do |k,v|
+        arr << "#{k}: #{v}"
+      end
+    end
+  end
+end
+Http = YammerHttp
+
+# Represents headers from an HTTP request or response.
+# Used internally by HTTP backends for processing headers.
+class Headers
+  include Net::HTTPHeader
+
+  def initialize
+    initialize_http_header({})
+  end
+
+  # Parse a single header line into its key and value
+  # @param [String] chunk a single header line
+  def self.parse(chunk)
+    line = chunk.strip
+    # thanks Net::HTTPResponse
+    return [nil,nil] if chunk =~ /\AHTTP(?:\/(\d+\.\d+))?\s+(\d\d\d)\s*(.*)\z/in
+    m = /\A([^:]+):\s*/.match(line)
+    [m[1], m.post_match] rescue [nil, nil]
+  end
+
+  # Parses a header line and adds it to the header collection
+  # @param [String] chunk a single header line
+  def parse(chunk)
+    key, value = self.class.parse(chunk)
+    add_field(key, value) if key && value
+  end
+end
+
+class FailedRequest < StandardError
+  attr_reader :method
+  attr_reader :expected
+  attr_reader :code
+  attr_reader :headers
+  attr_reader :body
+  attr_reader :timed_out
+
+  def initialize(method, expected_code, received_code, headers, body, timed_out)
+    @method, @expected, @code, @headers, @body, @timed_out = method, expected_code, received_code, headers, body, timed_out
+    super "Expected #{@expected.inspect} from the server but received #{@code}. #{@body}"
+  end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'zephyr'
+
+class Test::Unit::TestCase
+end

data/test/test_zephyr.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestZephyr < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/zephyr.gemspec

@@ -0,0 +1,56 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{zephyr}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Matt Knopp"]
+  s.date = %q{2011-09-30}
+  s.description = %q{Simple HTTP client using Typheous, derived from the Riak client}
+  s.email = %q{matt.knopp@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/zephyr.rb",
+    "test/helper.rb",
+    "test/test_zephyr.rb",
+    "zephyr.gemspec"
+  ]
+  s.homepage = %q{http://github.com/mhat/zephyr}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.2}
+  s.summary = %q{Simple HTTP client using Typheous, derived from the Riak client}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<typhoeus>, [">= 0.2.4"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+    else
+      s.add_dependency(%q<typhoeus>, [">= 0.2.4"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    end
+  else
+    s.add_dependency(%q<typhoeus>, [">= 0.2.4"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+  end
+end
+

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification 
+name: zephyr
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Matt Knopp
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-30 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: typhoeus
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 2
+        - 4
+        version: 0.2.4
+  prerelease: false
+  type: :runtime
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  prerelease: false
+  type: :development
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 6
+        - 4
+        version: 1.6.4
+  prerelease: false
+  type: :development
+  requirement: *id003
+description: Simple HTTP client using Typheous, derived from the Riak client
+email: matt.knopp@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/zephyr.rb
+- test/helper.rb
+- test/test_zephyr.rb
+- zephyr.gemspec
+has_rdoc: true
+homepage: http://github.com/mhat/zephyr
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Simple HTTP client using Typheous, derived from the Riak client
+test_files: []
+