http 0.0.0 → 0.0.1

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--backtrace

data/CHANGES.md

@@ -0,0 +1,7 @@
+0.0.1
+-----
+* Initial half-baked release
+
+0.0.0
+-----
+* Vapoware release to claim the "http" gem name >:D

data/README.md

@@ -1,8 +1,74 @@
-HTTP
+Http
 ====
 
-This is an HTTP toolkit for doing HTTP things in Ruby. Ruby is a great
-language but one of its great shortcomings is its inability to speak
-HTTP properly.
+Ruby has always been this extremely web-focused language, and yet despite the
+selection of HTTP libraries out there, I always find myself falling back on
+Net::HTTP, and Net::HTTP sucks.
 
-Maybe I can fix that! Trololol...
+Ruby should be simple and elegant and beautiful. Net::HTTP is not. I've often
+found myself falling back on the Perlish horrors of open-uri just because I
+found Net::HTTP to be too much of a pain. This shouldn't be!
+
+HTTP should be simple and easy! It should be so straightforward it makes
+you happy with how delightful it is to use!
+
+Making Requests
+---------------
+
+Let's start with getting things:
+
+    Http.get "http://www.google.com"
+
+That's it! The result is the response body.
+
+Don't like "Http"? No worries, this works as well:
+
+    HTTP.get "http://www.google.com"
+
+After all, There Is More Than One Way To Do It!
+
+Making POST requests is simple too. Want to POST a form?
+
+	Http.post "http://example.com/resource", :form => {:foo => "42"}
+
+It's easy!
+
+Adding Headers
+--------------
+
+The Http library uses the concept of chaining to simplify requests. Let's say
+you want to get the latest commit of this library from Github in JSON format.
+One way we could do this is by tacking a filename on the end of the URL:
+
+    Http.get "https://github.com/tarcieri/http/commit/HEAD.json"
+
+The Github API happens to support this approach, but really this is a bit of a
+hack that makes it easy for people typing URLs into the address bars of
+browsers to perform the act of content negotiation. Since we have access to
+the full, raw power of HTTP, we can perform content negotiation the way HTTP
+intends us to, by using the Accept header:
+
+    Http.with_headers(:accept => 'application/json').
+      get("https://github.com/tarcieri/http/commit/HEAD")
+
+This requests JSON from Github. Github is smart enough to understand our
+request and returns a response with Content-Type: application/json. If you
+happen to have a library loaded which defines the JSON constant and implements
+JSON.parse, the Http library will attempt to parse the JSON response.
+
+A shorter alias exists for HTTP.with_headers:
+
+	Http.with(:accept => 'application/json').
+	  get("https://github.com/tarcieri/http/commit/HEAD")
+
+Content Negotiation
+-------------------
+
+As important a concept as content negotiation is HTTP, it sure should be easy,
+right? But usually it's not, and so we end up adding ".json" onto the ends of
+our URLs because the existing mechanisms make it too hard. It should be easy:
+
+    Http.accept(:json).get("https://github.com/tarcieri/http/commit/HEAD")
+
+This adds the appropriate Accept header for retrieving a JSON response for the
+given resource.

data/Rakefile

@@ -1,2 +1,7 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/http.gemspec

@@ -14,4 +14,8 @@ Gem::Specification.new do |gem|
   gem.name          = "http"
   gem.require_paths = ["lib"]
   gem.version       = Http::VERSION
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec', '>= 2.6.0'
+  gem.add_development_dependency 'json'
 end

data/lib/http/chainable.rb

@@ -0,0 +1,84 @@
+module Http
+  module Chainable
+    # Request a get sans response body
+    def head(uri, options = {})
+      request :head, uri, options
+    end
+
+    # Get a resource
+    def get(uri, options = {})
+      request :get, uri, options
+    end
+
+    # Post to a resource
+    def post(uri, options = {})
+      request :post, uri, options
+    end
+
+    # Put to a resource
+    def put(uri, options = {})
+      request :put, uri, options
+    end
+
+    # Delete a resource
+    def delete(uri, options = {})
+      request :delete, uri, options
+    end
+
+    # Echo the request back to the client
+    def trace(uri, options = {})
+      request :trace, uri, options
+    end
+
+    # Return the methods supported on the given URI
+    def options(uri, options = {})
+      request :options, uri, options
+    end
+
+    # Convert to a transparent TCP/IP tunnel
+    def connect(uri, options = {})
+      request :connect, uri, options
+    end
+
+    # Apply partial modifications to a resource
+    def patch(uri, options = {})
+      request :patch, uri, options
+    end
+
+    # Make an HTTP request with the given verb
+    def request(verb, uri, options = {})
+      if options[:headers]
+        headers = default_headers.merge options[:headers]
+      else
+        headers = default_headers
+      end
+
+      Client.new(uri).request verb, options.merge(:headers => headers)
+    end
+
+    # Make a request with the given headers
+    def with_headers(headers)
+      Parameters.new default_headers.merge(headers)
+    end
+    alias_method :with, :with_headers
+
+    # Accept the given MIME type(s)
+    def accept(type)
+      if type.is_a? String
+        with :accept => type
+      else
+        mime_type = Http::MimeType[type]
+        raise ArgumentError, "unknown MIME type: #{type}" unless mime_type
+        with :accept => mime_type.type
+      end
+    end
+
+    def default_headers
+      @default_headers ||= {}
+    end
+
+    def default_headers=(headers)
+      @default_headers = headers
+    end
+  end
+end

data/lib/http/client.rb

@@ -0,0 +1,100 @@
+module Http
+  # We all know what HTTP clients are, right?
+  class Client
+    # I swear I'll document that nebulous options hash
+    def initialize(uri, options = {})
+      if uri.is_a? URI
+        @uri = uri
+      else
+        # Why the FUCK can't Net::HTTP do this?
+        @uri = URI(uri)
+      end
+
+      @options = {:response => :parsed_body}.merge(options)
+    end
+
+    # Request a get sans response body
+    def head(uri, options = {})
+      request :head, options
+    end
+
+    # Get a resource
+    def get(uri, options = {})
+      request :get, options
+    end
+
+    # Post to a resource
+    def post(uri, options = {})
+      request :post, options
+    end
+
+    # Put to a resource
+    def put(uri, options = {})
+      request :put, options
+    end
+
+    # Delete a resource
+    def delete(uri, options = {})
+      request :delete, options
+    end
+
+    # Echo the request back to the client
+    def trace(uri, options = {})
+      request :trace, options
+    end
+
+    # Return the methods supported on the given URI
+    def options(uri, options = {})
+      request :options, options
+    end
+
+    # Convert to a transparent TCP/IP tunnel
+    def connect(uri, options = {})
+      request :connect, options
+    end
+
+    # Apply partial modifications to a resource
+    def patch(uri, options = {})
+      request :patch, options
+    end
+
+    # Make an HTTP request
+    def request(verb, options = {})
+      # Red, green, refactor tomorrow :/
+      options = @options.merge(options)
+      raw_headers = options[:headers] || {}
+
+      # Stringify keys :/
+      headers = {}
+      raw_headers.each { |k,v| headers[k.to_s] = v }
+
+      http = Net::HTTP.new(@uri.host, @uri.port)
+
+      # Why the FUCK can't Net::HTTP do this either?!
+      http.use_ssl = true if @uri.is_a? URI::HTTPS
+
+      request_class = Net::HTTP.const_get(verb.to_s.capitalize)
+      request = request_class.new(@uri.request_uri, headers)
+      request.set_form_data(options[:form]) if options[:form]
+
+      response = http.request(request)
+
+      case options[:response]
+      when :parsed_body
+        parse_response response
+      else
+        response.body
+      end
+    end
+
+    # Parse the response body according to its content type
+    def parse_response(response)
+      if response['content-type']
+        mime_type = MimeType[response['content-type'].split(/;\s*/).first]
+        return mime_type.parse(response.body) if mime_type
+      end
+
+      response.body
+    end
+  end
+end

data/lib/http/mime_type.rb

@@ -0,0 +1,51 @@
+module Http
+  # Yes, Http bundles its own MIME type library. Maybe it should be spun off
+  # as a separate gem or something.
+  class MimeType
+    @mime_types, @shortcuts = {}, {}
+
+    class << self
+      def register(obj)
+        @mime_types[obj.type] = obj
+        @shortcuts[obj.shortcut] = obj if obj.shortcut
+      end
+
+      def [](type)
+        if type.is_a? Symbol
+          @shortcuts[type]
+        else
+          @mime_types[type]
+        end
+      end
+    end
+
+    attr_reader :type, :shortcut
+
+    def initialize(type, shortcut = nil)
+      @type, @shortcut = type, shortcut
+      @parse_with = @emit_with = nil
+
+      self.class.register self
+    end
+
+    # Define
+    def parse_with(&block)
+      @parse_with = block
+    end
+
+    def emit_with(&block)
+      @emit_with = block
+    end
+
+    def parse(obj)
+      @parse_with ? @parse_with[obj] : obj
+    end
+
+    def emit(obj)
+      @emit_with  ? @emit_with[obj]  : obj
+    end
+  end
+end
+
+# MIME type registry
+require 'http/mime_types/json'

data/lib/http/mime_types/json.rb

@@ -0,0 +1,19 @@
+json = Http::MimeType.new 'application/json', :json
+
+json.parse_with do |obj|
+  if defined?(JSON) and JSON.respond_to? :parse
+    JSON.parse(obj)
+  else
+    obj
+  end
+end
+
+json.emit_with do |obj|
+  if obj.is_a? String
+    obj
+  elsif obj.respond_to? :to_json
+    obj.to_json
+  else
+    obj
+  end
+end

data/lib/http/parameters.rb

@@ -0,0 +1,17 @@
+module Http
+  class Parameters
+    include Chainable
+
+    def initialize(headers = {})
+      self.default_headers = headers
+    end
+
+    def []=(field, value)
+      default_headers[field.downcase] = value
+    end
+
+    def [](field)
+      default_headers[field.downcase]
+    end
+  end
+end

data/lib/http/version.rb

@@ -1,3 +1,3 @@
 module Http
-  VERSION = "0.0.0"
+  VERSION = "0.0.1"
 end

data/lib/http.rb

@@ -1,5 +1,18 @@
-require "http/version"
+require 'http/version'
+require 'http/chainable'
+require 'http/client'
+require 'http/mime_type'
+require 'http/parameters'
 
+# THIS IS ENTIRELY TEMPORARY, I ASSURE YOU
+require 'net/https'
+require 'uri'
+
+# Http, it can be simple!
 module Http
-  # Coming soon!
+  extend Chainable
 end
+
+# TIMTOWTDI!
+HTTP = Http
+HttpClient = Http::Client

data/spec/http_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'json'
+
+describe Http do
+  context "getting resources" do
+    it "should be easy" do
+      # Fuck it, we'll do it live! (Testing against WEBRick or something coming soon)
+      response = Http.get "http://www.google.com"
+      response.should match(/<!doctype html>/)
+    end
+
+    context "with headers" do
+      it "should be easy" do
+        response = Http.accept(:json).get("https://github.com/tarcieri/http/commit/HEAD")
+
+        # Congratulations first committer, your prize is to break the build!
+        response['commit']['author']['name'].should == "Tony Arcieri"
+      end
+    end
+  end
+
+  context "posting to resources" do
+    it "should be easy" do
+      fragment = "<!doctype html><html><head><title>example</title></head></html>"
+      response = Http.post "http://validator.w3.org/check", :form => {:fragment => fragment}
+
+      response.should match(/HTML5/)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$:.push File.expand_path("../lib")
+require 'http'

metadata

@@ -2,7 +2,7 @@
 name: http
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors: 
 - Tony Arcieri
@@ -11,9 +11,41 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-06 00:00:00 Z
-dependencies: []
-
+date: 2011-10-11 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: HTTP so awesome it will lure Catherine Zeta Jones into your unicorn petting zoo
 email: 
 - tony.arcieri@gmail.com
@@ -25,16 +57,25 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- .rspec
+- CHANGES.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - http.gemspec
 - lib/http.rb
+- lib/http/chainable.rb
+- lib/http/client.rb
+- lib/http/mime_type.rb
+- lib/http/mime_types/json.rb
+- lib/http/parameters.rb
 - lib/http/version.rb
 - parser/common.rl
 - parser/http.rl
 - parser/multipart.rl
+- spec/http_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/tarcieri/http
 licenses: []
 
@@ -62,5 +103,6 @@ rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Made entirely of Ruby (and Ragel and C and Java)
-test_files: []
-
+test_files: 
+- spec/http_spec.rb
+- spec/spec_helper.rb