httprb 0.1.3

data/lib/httprb.rb

@@ -0,0 +1,14 @@
+require 'httprb/dsl'
+require 'httprb/delegate'
+
+module HTTPrb
+  require 'httprb/version'
+  
+  begin
+    require 'net/https'
+  rescue LoadError
+    $stderr << "HTTPS not found- disabled"
+  end
+end
+
+include HTTPrb::Delegator

data/lib/httprb/delegate.rb

@@ -0,0 +1,75 @@
+# Delegator
+#
+# inspired by Sinatra, required to play nicely with Sinatra
+# (and any other colliding namespace).
+#
+# It is important to note that all methods defined by HTTPrb
+# (get, head, put, post, delete), if defined by the programmer
+# or by an included module (ahem, Sinatra), Delegator will
+# alias them to a dispatch method, which will do the following:
+# 1. print a warning to the user that a collision was
+#    deteted and handled.
+# 2. tell the user how to call HTTPrb's methods
+# 3. call the original method (not HTTPrb's)
+
+require 'irb/completion'
+
+module HTTPrb
+
+module Delegator
+  def self.delegate_collision(method)
+    ENV['HTTPRB_COLLISION_PREFIX'] ||= 'client_'
+    ENV['HTTPRB_IGNORE_COLLISIONS'] ||= 'true'
+    eval <<-RUBY, binding, '(__DELEGATE__)', 1
+      alias_method #{method.inspect}_original, #{method.inspect}
+      
+      def #{method}(*args, &b)
+        if ENV['HTTPRB_IGNORE_COLLISIONS'] == 'true'
+          puts "WARNING: Namespace collision detected"
+          puts "HTTPrb::#{method} has been renamed to #{ENV['HTTPRB_COLLISION_PREFIX']}#{method}"
+          puts "To disable this message, set HTTPRB_IGNORE_COLLISIONS to false"
+        end
+        #{method}_original(*args, &b)
+      end
+      
+      def #{ENV['HTTPRB_COLLISION_PREFIX']}#{method}(*args, &b)
+        ::HTTPrb.send(#{method.inspect}, *args, &b)
+      end
+      private #{method.inspect}
+    RUBY
+  end
+  
+  def self.collides?(method)
+    unless Object.const_defined?(:IRB) and IRB.respond_to?(:conf)
+      eval <<-RUBY
+        module ::IRB
+          def IRB.binding
+            #{binding}
+          end
+          def IRB.workspace; IRB; end
+          def IRB.conf; {:MAIN_CONTEXT => IRB}; end
+        end
+      RUBY
+    end
+    ::IRB::InputCompletor::CompletionProc.call(method.to_s).include?(method.to_s)
+  end
+  
+  def self.delegate(*methods)
+    methods.each do |method_name|
+      if self.collides?(method_name)
+        self.delegate_collision(method_name)
+      else
+        eval <<-RUBY, binding, '(__DELEGATE__)', 1
+          def #{method_name}(*args, &b)
+            ::HTTPrb.send(#{method_name.inspect}, *args, &b)
+          end
+          private #{method_name.inspect}
+        RUBY
+      end
+    end
+  end
+
+  delegate :get, :put, :post, :delete, :head
+end
+
+end

data/lib/httprb/dsl.rb

@@ -0,0 +1,91 @@
+# where the magic happens
+
+# this mixin sets up the DSL, wrapping net/http for
+# your programming pleasure
+
+# note that each of the following methods accepts a
+# block- this is the beauty of the whole thing.
+
+# if you're wondering about the code duplication, read:
+#
+# http://blog.sidu.in/2007/11/ruby-blocks-gotchas.html
+#
+# implicit invocation of blocks is just faster. so we
+# duplicate code. :(
+
+require 'httprb/request'
+require 'httprb/http_cache'
+
+module HTTPrb
+  public
+  # get request
+  # 
+  # * options are not generally used; HTTPrb::Request
+  #   offers additional methods for option generation/
+  #   handling.
+  # * accepts a block, handing off the HTTPrb::Request
+  #   object to it, if provided.
+  def HTTPrb.get(url, options = {})
+    options[:type] = 'GET'
+    req = Request.new(url, options)
+    yield(req) if block_given?
+    HTTPrb::HTTPCache.instance.make_request(req)
+  end
+
+  # head request
+  # 
+  # * options are not generally used; HTTPrb::Request
+  #   offers additional methods for option generation/
+  #   handling.
+  # * accepts a block, handing off the HTTPrb::Request
+  #   object to it, if provided.
+  def HTTPrb.head(url, options = {})
+    options[:type] = 'HEAD'
+    req = Request.new(url, options)
+    yield(req) if block_given?
+    HTTPrb::HTTPCache.instance.make_request(req)
+  end
+  
+  # post request
+  # 
+  # * options are not generally used; HTTPrb::Request
+  #   offers additional methods for option generation/
+  #   handling.
+  # * accepts a block, handing off the HTTPrb::Request
+  #   object to it, if provided.
+  def HTTPrb.post(url, options = {})
+    options[:type] = 'POST'
+    req = Request.new(url, options)
+    yield(req) if block_given?
+    HTTPrb::HTTPCache.instance.make_request(req)
+  end
+  
+  # put request
+  # 
+  # * options are not generally used; HTTPrb::Request
+  #   offers additional methods for option generation/
+  #   handling.
+  # * accepts a block, handing off the HTTPrb::Request
+  #   object to it, if provided.
+  def HTTPrb.put(url, options = {})
+    options[:type] = 'PUT'
+    req = Request.new(url, options)
+    yield(req) if block_given?
+    HTTPrb::HTTPCache.instance.make_request(req)
+  end
+  
+  # delete request
+  # 
+  # * options are not generally used; HTTPrb::Request
+  #   offers additional methods for option generation/
+  #   handling.
+  # * accepts a block, handing off the HTTPrb::Request
+  #   object to it, if provided.
+  def HTTPrb.delete(url, options = {})
+    options[:type] = 'DELETE'
+    req = Request.new(url, options)
+    yield(req) if block_given?
+    HTTPrb::HTTPCache.instance.make_request(req)
+  end
+
+end

data/lib/httprb/http_cache.rb

@@ -0,0 +1,33 @@
+# a bit of insanity. a singleton representation
+# of a Net::HTTP object. provides connection
+# caching when the host is the same. no real
+# benefit when changing servers (the underlying
+# connection changes when changing servers, no
+# way around that).
+
+require 'singleton'
+require 'net/http'
+require 'net/https'
+
+module HTTPrb
+
+class HTTPCache
+  include Singleton
+  attr_reader :http
+  
+  # accepts an HTTPrb::Request object, performs
+  # the request, and returns the Net::HTTP result
+  def make_request(req)
+    if @http && @http.address == req.uri.host && !@http.started?
+      @http.start
+    else
+      @http = Net::HTTP.new(req.uri.host, req.uri.port)
+      @http.use_ssl = req.ssl?
+      @http.set_debug_output($stderr) if req.debug
+      @http.start
+    end
+    @http.request(req.http_request)
+  end
+end
+
+end

data/lib/httprb/request.rb

@@ -0,0 +1,160 @@
+# more magic found here.
+
+# HTTPrb::Request is where most of the actual
+# functionality is provided. URI parsing,
+# Net::HTTP::Request generation, etc., are all
+# handled here.
+
+require 'uri'
+require 'cgi'
+
+module HTTPrb
+  
+class Request
+  attr_accessor :uri, :headers, :parameters, :ssl, :debug
+  attr_reader :options
+  
+  # create an HTTPrb::Request object
+  #
+  # the uri can be formatted however is most
+  # convenient to you- if the scheme (http://)
+  # is provided, it will be respected. if not
+  # provided, the default is http.
+  #
+  # if https:// is given as the scheme and the
+  # necesary openssl library is installed
+  # (meaning "require 'net/http'" doesn't fail)
+  # then ssl will be used.
+  #
+  # note that the 'options' parameter is only
+  # truly useful (or good) when not passing a
+  # block to the DSL. when a block is provided,
+  # using the accessor methods for each option
+  # (headers, parameters, etc.) is vastly
+  # preferred.
+  def initialize(uri, options = {})
+    if uri.is_a? URI
+      @uri = uri
+    elsif uri.is_a? String
+      @uri = URI.parse(uri)
+      if !@uri.scheme
+        @uri = URI.parse("http://" + uri)
+      end
+    else
+      raise Exception, "Invalid URL"
+    end
+    @uri.path = "/" if @uri.path.empty?
+    @ssl = true if @uri.scheme == "https"
+    
+    @options = options
+    @options[:type] = 'GET' unless @options[:type]
+    @debug = options[:debug] ? true : false
+    
+    @parameters = {}
+    if @uri.query
+      CGI.parse(@uri.query).each do |k,v|
+        if v.length == 1
+          @parameters[k] = v.first
+        else
+          @parameters[k] = v
+        end
+      end
+    end
+    @headers = {}
+  end
+  
+  # sets up HTTP basic auth- identical to
+  # Net::HTTP request objects.
+  def basic_auth(user, pass)
+    @options[:basic_auth] = true
+    @options[:user] = user
+    @options[:pass] = pass
+  end
+
+  # set or add to a query parameter key/value pair
+  # if you wish to set multiple values for a key,
+  # provide an array of values as the second argument.
+  def parameter(key, value = nil)
+    @parameters[key] = value
+  end
+  
+  # set a header key/value pair
+  def header(key, value)
+    if @headers[key]
+      if @headers[key].is_a? Array
+        @headers[key] << value
+      else
+        cur = @headers[key]
+        @headers[key] = [cur, value]
+      end
+    else
+      @headers[key] = value
+    end
+  end
+  
+  # generates the query string based on the provided
+  # parameter dictionary
+  def query_string
+    if !@parameters.empty?
+      # this is crabby because query strings can have more than
+      # one value per key- the key, in that case, is simply
+      # repeated with the additional value.
+      queries = []
+      @parameters.each do |k,v|
+        if v.is_a?(Array)
+          v.each {|val| queries << "#{k}=#{CGI.escape(val.to_s)}"}
+        else
+          queries << "#{k}=#{CGI.escape(v.to_s)}"
+        end
+      end
+      return queries.join('&')
+    end
+    return ""
+  end
+  
+  # generates a Net::HTTP request object. for use
+  # when the request is passed to Net::HTTP.
+  def http_request
+    path = "#{@uri.path}?#{query_string}"
+    http_req = case @options[:type].upcase
+    when 'GET'
+      Net::HTTP::Get.new(path)
+    when 'POST'
+      Net::HTTP::Post.new(path)
+    when 'PUT'
+      Net::HTTP::Put.new(path)
+    when 'HEAD'
+      Net::HTTP::Head.new(path)
+    when 'DELETE'
+      Net::HTTP::Delete.new(path)
+    else
+      Net::HTTP::Get.new(path)
+    end
+    if @options[:basic_auth] && @options[:user] && @options[:pass]
+      http_req.basic_auth(@options[:user], @options[:pass])
+    end
+    
+    @headers.each do |key, value|
+      if value.is_a? Array
+        value.each {|v| http_req.add_field(key, v)}
+      else
+        http_req.add_field(key, value)
+      end
+    end
+    
+    return http_req
+  end
+  
+  # yep, you got it. we're messing with your mind
+  # here. nothing to see here, move along...
+  def method_missing(method)
+    if method == :"ssl?"
+      return @ssl
+    elsif @options.keys.include?(method)
+      return @options[method]
+    end
+    super
+  end
+end
+
+end

data/lib/httprb/version.rb

@@ -0,0 +1,8 @@
+module HTTPrb
+  # HTTPrb version
+  VERSION         = '0.1.3'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/tests/disabled/test_collisions.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+
+$:.unshift File.join(File.dirname(File.dirname(__FILE__)), 'lib')
+require 'httprb'
+
+class TestDSL < Test::Unit::TestCase
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  def test_collisions
+    assert_not_nil res = client_get('http://mozy.com')
+    assert_not_nil res = client_head('mozy.com')
+    assert_not_nil res = client_put('mozy.com')
+    assert_not_nil res = client_post('mozy.com')
+    assert_not_nil res = client_delete('mozy.com')
+  end
+  
+  def test_custom_prefix
+    ENV['HTTPRB_COLLISION_PREFIX'] = 'my_client'
+    load 'httprb.rb'
+    assert_not_nil res = my_client_get('mozy.com')
+    assert_not_nil res = my_client_head('mozy.com')
+    assert_not_nil res = my_client_put('mozy.com')
+    assert_not_nil res = my_client_post('mozy.com')
+    assert_not_nil res = my_client_delete('mozy.com')
+  end
+end

data/tests/test_dsl.rb

@@ -0,0 +1,124 @@
+require 'test/unit'
+
+$:.unshift File.join(File.dirname(File.dirname(__FILE__)), 'lib')
+require 'httprb'
+
+class TestDSL < Test::Unit::TestCase
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  def test_get_urls
+    assert_not_nil res = get('http://mozy.com')
+    assert_not_nil res = get('mozy.com')
+  end
+  
+  def test_get
+    assert_not_nil res = get('http://mozy.com')
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+  
+  def test_get_block
+    res = get 'http://google.com' do |req|
+      assert_not_nil req
+      assert req.options[:type] == 'GET'
+      assert req.uri.host = 'mozy.com'
+    end
+    assert_not_nil res
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+  
+  def test_get_ssl
+    assert_not_nil res = get('https://mozy.com/', {:use_ssl => true})
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+  
+  def test_get_ssl_block
+    res = get 'https://mozy.com/' do |req|
+      assert_not_nil req
+      assert req.options[:type] == 'GET'
+      assert req.uri.host = 'mozy.com'
+    end
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+  
+  def test_head
+    assert_not_nil res = head('http://mozy.com')
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+  
+  def test_head_block
+    res = head 'http://google.com' do |req|
+      assert_not_nil req
+      assert req.options[:type] == 'HEAD'
+      assert req.uri.host = 'mozy.com'
+    end
+    assert_not_nil res
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+  
+  def test_put
+    assert_not_nil res = put('http://mozy.com')
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+  
+  def test_put_block
+    res = put 'http://google.com' do |req|
+      assert_not_nil req
+      assert req.options[:type] == 'PUT'
+      assert req.uri.host = 'mozy.com'
+    end
+    assert_not_nil res
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+
+  def test_post
+    assert_not_nil res = post('http://mozy.com')
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+
+  def test_post_block
+    res = post 'http://google.com' do |req|
+      assert_not_nil req
+      assert req.options[:type] == 'POST'
+      assert req.uri.host = 'mozy.com'
+    end
+    assert_not_nil res
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+
+  def test_delete
+    assert_not_nil res = delete('http://mozy.com')
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+
+  def test_delete_block
+    res = delete 'http://google.com' do |req|
+      assert_not_nil req
+      assert req.options[:type] == 'DELETE'
+      assert req.uri.host = 'mozy.com'
+    end
+    assert_not_nil res
+    assert res.code =~ /2[0-9].|3[0-9]./
+  end
+  
+  def test_params
+    res = get 'http://mozy.com' do |req|
+      assert req.parameter "key", "value"
+      assert req.parameter "key2", "value"
+      assert req.parameters.include?("key")
+      assert req.parameters.include?("key2")
+      assert req.http_request.path.include?("key=value")
+    end
+  end
+  
+  def test_headers
+    res = get 'http://mozy.com' do |req|
+      assert req.header "x-key", "value"
+      assert req.headers["x-key"] == "value"
+      assert req.http_request["x-key"] == "value"
+    end
+  end
+end

data/tests/test_http_cache.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+
+require File.join(File.dirname(File.dirname(__FILE__)), 'lib/httprb/http_cache.rb')
+require File.join(File.dirname(File.dirname(__FILE__)), 'lib/httprb/request.rb')
+
+class TestHTTPCache < Test::Unit::TestCase
+  def setup; end
+  def teardown; end
+  
+  def test_connection_caching
+    assert_not_nil cache = HTTPrb::HTTPCache.instance
+    
+    # start things out with a little google...
+    assert_not_nil req = HTTPrb::Request.new("http://google.com")
+    assert_not_nil res = cache.make_request(req)
+    assert res.code =~ /2[0-9].|3[0-9]./
+    assert cache.http
+    assert cache.http.started?
+    
+    # play it again, sam... (to test connection caching)
+    assert_not_nil res = cache.make_request(req)
+    assert res.code =~ /2[0-9].|3[0-9]./
+    assert cache.http
+    assert cache.http.started?
+    
+    # try a different host- should transparently stop
+    # caching, start over, and make the request
+    assert_not_nil req = HTTPrb::Request.new("http://yahoo.com")
+    assert_not_nil res = cache.make_request(req)
+    assert res.code =~ /2[0-9].|3[0-9]./
+    assert cache.http
+    assert cache.http.started?
+  end
+  
+  def test_ssl
+    assert_not_nil cache = HTTPrb::HTTPCache.instance
+    
+    assert_not_nil req = HTTPrb::Request.new("https://www.bankofamerica.com")
+    assert_not_nil res = cache.make_request(req)
+  end
+end

data/tests/test_request.rb

@@ -0,0 +1,53 @@
+require 'test/unit'
+
+require File.join(File.dirname(File.dirname(__FILE__)), 'lib/httprb/request.rb')
+require 'net/http'
+
+class TestRequest < Test::Unit::TestCase
+  def setup; end
+  def teardown; end
+  
+  def test_request_types
+    assert_not_nil req = HTTPrb::Request.new('http://google.com', {:type => 'POST'})
+    assert req.http_request.is_a? Net::HTTP::Post
+    assert_not_nil req = HTTPrb::Request.new('http://google.com', {:type => 'PUT'})
+    assert req.http_request.is_a? Net::HTTP::Put
+    assert_not_nil req = HTTPrb::Request.new('http://google.com', {:type => 'HEAD'})
+    assert req.http_request.is_a? Net::HTTP::Head
+    assert_not_nil req = HTTPrb::Request.new('http://google.com', {:type => 'DELETE'})
+    assert req.http_request.is_a? Net::HTTP::Delete
+    assert_not_nil req = HTTPrb::Request.new('http://google.com', {:type => 'GET'})
+    assert req.http_request.is_a? Net::HTTP::Get
+    assert_not_nil req = HTTPrb::Request.new('http://google.com')
+    assert req.http_request.is_a? Net::HTTP::Get
+  end
+  
+  def test_ssl
+    assert_not_nil req = HTTPrb::Request.new("https://www.bankofamerica.com")
+    assert req.ssl?
+    assert req.ssl
+  end
+  
+  def test_paramaters
+    assert_not_nil req = HTTPrb::Request.new('http://localhost', {:type => 'GET'})
+    assert req.parameter "key", "value"
+    assert req.http_request.path == '/?key=value'
+    assert req.parameter "key", ["value", "value2"]
+    assert req.http_request.path == '/?key=value&key=value2' || req.http_request.path == '/?key=value2&key=value'
+  end
+  
+  def test_query_string_params
+    assert_not_nil req = HTTPrb::Request.new('http://localhost?key=value&key2=value2', {:type => 'GET'})
+    assert req.parameters["key"] == "value"
+    assert req.parameters["key2"] == "value2"
+    assert_not_nil req = HTTPrb::Request.new('http://localhost?key=value&key=value2', {:type => 'GET'})
+    assert req.parameters["key"].is_a?(Array)
+    assert req.parameters["key"].include?('value') && req.parameters["key"].include?('value2')
+  end
+  
+  def test_headers
+    assert_not_nil req = HTTPrb::Request.new('http://localhost', {:type => 'GET'})
+    assert(req.header "key", "value")
+    assert(req.http_request["key"] == "value")
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: httprb
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 3
+  version: 0.1.3
+platform: ruby
+authors: 
+- thomas metge
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: HTTP client DSL, inspired by sinatra.
+email: tom@accident-prone.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/httprb/delegate.rb
+- lib/httprb/dsl.rb
+- lib/httprb/http_cache.rb
+- lib/httprb/request.rb
+- lib/httprb/version.rb
+- lib/httprb.rb
+has_rdoc: true
+homepage: http://github.com/tommetge/httprb
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: 3
+summary: "http the ruby way: sinatra-like http client DSL"
+test_files: 
+- tests/disabled/test_collisions.rb
+- tests/test_dsl.rb
+- tests/test_http_cache.rb
+- tests/test_request.rb