http_objects 0.0.1

data/.gitignore

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

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Roger Leite
+
+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,56 @@
+# HttpObjects
+
+HTTP 1.1 by the spec, specially headers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'http_objects'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install http_objects
+
+## Usage
+
+``` ruby
+#require 'rubygems'
+require 'http_objects'
+
+headers = HttpObjects::HeadersHash.new
+
+# it's a normal hash (for normal keys)
+headers["key"] = "value"
+
+# for HTTP headers, you have objects
+headers["Content-Type"] = "text/html;Charset=utf-8"
+
+# one can check if header exist
+puts headers.content_type? # => true
+
+# one can access raw value
+puts headers.content_type! # => "text/html;Charset=utf-8"
+
+# one can access the value
+puts headers.content_type.value # => "text/html"
+
+# one can read directives
+puts headers.content_type['charset'] # => "utf-8"
+
+# finally one can access the object
+puts headers.content_type.inspect # => #<HttpObjects::EntityHeaders::ContentType ...>
+
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+ENV["RUBYOPT"] = "rubygems" if ENV["RUBYOPT"].nil?
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/http_objects/**/*_test.rb']
+end
+
+task :default => :test

data/http_objects.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/http_objects/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Roger Leite"]
+  gem.email         = ["roger.barreto@gmail.com"]
+  gem.description   = %q{HTTP 1.1 by the spec, specially headers}
+  gem.summary       = %q{HTTP 1.1 by the spec, specially headers}
+  gem.homepage      = "https://github.com/rogerleite/http_objects"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "http_objects"
+  gem.require_paths = ["lib"]
+  gem.version       = HttpObjects::VERSION
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "minitest", "~> 3"
+  gem.add_development_dependency "minitest-reporters", "~> 0.7.0"
+end

data/lib/http_objects/hash.rb

@@ -0,0 +1,51 @@
+module HttpObjects
+
+  class Hash < ::Hash
+    extend HttpObjects::Headers::Attributes
+
+    # Public: Block that creates method based on attribute name.
+    MethodCreator = Proc.new do |name, header|
+      attr_name = name.downcase.gsub("-", "_")
+      self.class_eval(%{
+        def #{attr_name}                          # def content_type
+          self.fetch("#{name}", nil)       #   self.fetch("Content-Type", nil)
+        end                                       # end
+        def #{attr_name}!                         # def content_type!
+          self.#{attr_name}.raw if #{attr_name}?  #   self.content_type.raw if content_type?
+        end                                       # end
+        def #{attr_name}?                         # def content_type?
+          !!self.fetch("#{name}", nil)     #   !!self.fetch("Content-Type", nil)
+        end                                       # end
+      })
+    end
+
+    # Public: Register attribute class with *MethodCreator* block.
+    def self.add_attribute(attr_class)
+      register_attribute(attr_class.header_name, attr_class, &MethodCreator)
+    end
+
+    def self.new(hash = nil)
+      hash.kind_of?(HttpObjects::Hash) ? hash : super(hash)
+    end
+
+    def initialize(hash = nil)
+      super()
+      hash.each { |(key, value)| self[key] = value } unless hash.nil?
+    end
+
+    # Public: Associates key with value. If key is a valid HTTP Header name,
+    # like "Content-Type", it parses as HTTP Object.
+    #
+    # key - key or HTTP Header name.
+    # value - object. If key is HTTP Header name, value should be a String.
+    def []=(key, value)
+      if (header_class = self.class.attributes[key])
+        value = header_class.parse(value)
+      end
+      super(key, value)
+    end
+    alias :store :[]=
+
+  end
+
+end

data/lib/http_objects/headers/attributes.rb

@@ -0,0 +1,38 @@
+module HttpObjects::Headers
+
+  # Public: Extend this module and you be able to retrieve and register
+  # attributes in your class.
+  #
+  # Examples
+  #
+  #    class SampleAttributes
+  #      extend HttpObjects::Headers::Attributes
+  #      register_attribute "MyAttributeName", MyObject do |object|
+  #        # optional hook
+  #      end
+  #    end
+  #
+  #    SampleAttributes.attributes # => {"MyAttributeName" => MyObject}
+  module Attributes
+
+    # Returns Hash of registered attributes.
+    def attributes
+      @attributes ||= {}
+    end
+
+    # Public: Register on *attributes*, the pair name and attr_class.
+    #
+    # name - String identifying attribute.
+    # attr_class - Class to identify the attribute.
+    #
+    # Yields name and attr_class informed. Optional.
+    #
+    # Returns nothing.
+    def register_attribute(name, attr_class)
+      attributes[name] = attr_class
+      yield(name, attr_class) if block_given?
+    end
+
+  end
+
+end

data/lib/http_objects/headers/directives/cache.rb

@@ -0,0 +1,80 @@
+module HttpObjects::Headers
+  module Directives
+
+    BasicRules = HttpObjects::Parameters::BasicRules
+
+    class RawValue < BasicRules::Base
+      def self.parse(value)
+        self.new(value, value)
+      end
+    end
+
+    # Cache-Control   = "Cache-Control" ":" 1#cache-directive
+    #
+    # cache-directive = cache-request-directive
+    #      | cache-response-directive
+    #
+    # cache-request-directive =
+    #        "no-cache"                          ; Section 14.9.1
+    #      | "no-store"                          ; Section 14.9.2
+    #      | "max-age" "=" delta-seconds         ; Section 14.9.3, 14.9.4
+    #      | "max-stale" [ "=" delta-seconds ]   ; Section 14.9.3
+    #      | "min-fresh" "=" delta-seconds       ; Section 14.9.3
+    #      | "no-transform"                      ; Section 14.9.5
+    #      | "only-if-cached"                    ; Section 14.9.4
+    #      | cache-extension                     ; Section 14.9.6
+    #
+    #  cache-response-directive =
+    #        "public"                               ; Section 14.9.1
+    #      | "private" [ "=" <"> 1#field-name <"> ] ; Section 14.9.1
+    #      | "no-cache" [ "=" <"> 1#field-name <"> ]; Section 14.9.1
+    #      | "no-store"                             ; Section 14.9.2
+    #      | "no-transform"                         ; Section 14.9.5
+    #      | "must-revalidate"                      ; Section 14.9.4
+    #      | "proxy-revalidate"                     ; Section 14.9.4
+    #      | "max-age" "=" delta-seconds            ; Section 14.9.3
+    #      | "s-maxage" "=" delta-seconds           ; Section 14.9.3
+    #      | cache-extension                        ; Section 14.9.6
+    #
+    # cache-extension = token [ "=" ( token | quoted-string ) ]
+    class Cache < HttpObjects::Hash
+
+      # token [ "=" ( token | quoted-string ) ]
+      TOKEN = /([^,=]+)(?:=\s*(?:\"([^\"]*)\"|\'([^\']*)\'|([^,]*)))?/
+
+      attr_reader :raw, :value
+
+      register_attribute "no-cache",         RawValue, &MethodCreator
+      register_attribute "no-store",         RawValue, &MethodCreator
+      register_attribute "max-age",          BasicRules::Digit, &MethodCreator
+      register_attribute "max-stale",        BasicRules::Digit, &MethodCreator
+      register_attribute "min-fresh",        BasicRules::Digit, &MethodCreator
+      register_attribute "no-transform",     RawValue, &MethodCreator
+      register_attribute "only-if-cached",   RawValue, &MethodCreator
+      register_attribute "public",           RawValue, &MethodCreator
+      register_attribute "private",          RawValue, &MethodCreator
+      register_attribute "must-revalidate",  RawValue, &MethodCreator
+      register_attribute "proxy-revalidate", RawValue, &MethodCreator
+      register_attribute "s-maxage",         BasicRules::Digit, &MethodCreator
+
+      def self.parse(value)
+        cache = self.new(value)
+        value.scan(TOKEN).each do |key, v1, v2, v3|
+          key = key.strip
+          next if key.length.zero?
+          key.downcase!
+          key_value = (v1 || v2 || v3).to_s
+          cache[key] = key_value.strip
+        end
+        cache
+      end
+
+      def initialize(value)
+        @raw = value
+        @value = value
+      end
+
+    end
+
+  end
+end

data/lib/http_objects/headers/entity.rb

@@ -0,0 +1,43 @@
+module HttpObjects::Headers::Entity
+
+  extend HttpObjects::Headers::Tools
+
+  # 14.7 Allow
+  #     Allow: GET, HEAD, PUT
+  Allow = Header("Allow", HttpObjects::Parameters::BasicRules::UpAlpha)
+
+  # 14.11 Content-Encoding
+  # Pending: implement spec
+  ContentEncoding = Header("Content-Encoding", HttpObjects::Parameters::BasicRules::LoAlpha)
+
+  # 14.12 Content-Language
+  #     Content-Language: mi, en
+  ContentLanguage = Header("Content-Language", HttpObjects::Parameters::LanguageTags)
+
+  # 14.13 Content-Length
+  #     Content-Length: 3495
+  ContentLength = Header("Content-Length", HttpObjects::Parameters::BasicRules::Digit)
+
+  # 14.14 Content-Location
+  ContentLocation = Header("Content-Location", HttpObjects::Parameters::Uri)
+
+  # 14.15 Content-MD5
+  ContentMD5 = Header("Content-MD5", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.16 Content-Range
+  # Pending: implement spec
+  ContentRange = Header("Content-Range", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.21 Expires
+  #     Expires: Thu, 01 Dec 1994 16:00:00 GMT
+  Expires = Header("Expires", HttpObjects::Parameters::DateTime)
+
+  # 14.23 Content-Type
+  #     Content-Type: text/html; charset=ISO-8859-4
+  ContentType = Header("Content-Type", HttpObjects::Parameters::MediaType)
+
+  # Last-Modified
+  #     Last-Modified: Tue, 15 Nov 1994 12:45:26 GMT
+  LastModified = Header("Last-Modified", HttpObjects::Parameters::DateTime)
+
+end

data/lib/http_objects/headers/general.rb

@@ -0,0 +1,42 @@
+module HttpObjects::Headers::General
+
+  extend HttpObjects::Headers::Tools
+
+  # 14.9 Cache-Control
+  # Pending: implement spec
+  CacheControl = Header("Cache-Control", HttpObjects::Headers::Directives::Cache)
+
+  # 14.10 Connection
+  #     Connection: close
+  Connection = Header("Connection", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.18 Date
+  #     Date: Tue, 15 Nov 1994 08:12:31 GMT
+  Date = Header("Date", HttpObjects::Parameters::DateTime)
+
+  # 14.32 Pragma
+  Pragma = Header("Pragma", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.40 Trailer
+  Trailer = Header("Trailer", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.41 Transfer-Encoding
+  #    Transfer-Encoding: chunked
+  # Pending: implement spec
+  TransferEncoding = Header("Transfer-Encoding", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.42 Upgrade
+  #     Upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11
+  Upgrade = Header("Upgrade", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.45 Via
+  #     Via: 1.0 fred, 1.1 nowhere.com (Apache/1.1)
+  #     Via: 1.0 ricky, 1.1 ethel, 1.1 fred, 1.0 lucy
+  # Pending: implement spec
+  Via = Header("Via", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.46 Warning
+  # Pending: implement spec
+  Warning = Header("Warning", HttpObjects::Parameters::BasicRules::Token)
+
+end

data/lib/http_objects/headers/request.rb

@@ -0,0 +1,116 @@
+module HttpObjects::Headers::Request
+
+  extend HttpObjects::Headers::Tools
+
+  # 14.1 Accept
+  #    Accept: audio/*; q=0.2, audio/basic
+  # Pending: implement spec
+  Accept = Header("Accept", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.2 Accept-Charset
+  #   Accept-Charset: iso-8859-5, unicode-1-1;q=0.8
+  # Pending: implement spec
+  AcceptCharset = Header("Accept-Charset", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.3 Accept-Encoding
+  #   Accept-Encoding: compress, gzip
+  #   Accept-Encoding:
+  #   Accept-Encoding: *
+  #   Accept-Encoding: compress;q=0.5, gzip;q=1.0
+  #   Accept-Encoding: gzip;q=1.0, identity; q=0.5, *;q=0
+  # Pending: implement spec
+  AcceptEncoding = Header("Accept-Encoding", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.4 Accept-Language
+  #   Accept-Language: da, en-gb;q=0.8, en;q=0.7
+  # Pending: implement spec
+  AcceptLanguage = Header("Accept-Language", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.8 Authorization
+  # Pending: implement spec
+  Authorization = Header("Authorization", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.20 Expect
+  # Pending: implement spec
+  Expect = Header("Expect", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.22 From
+  #    From: webmaster@w3.org
+  # Pending: implement spec
+  From = Header("From", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.23 Host
+  #    Host: www.w3.org
+  Host = Header("Host", HttpObjects::Parameters::Uri)
+
+  # 14.24 If-Match
+  #    If-Match: "xyzzy"
+  #    If-Match: "xyzzy", "r2d2xxxx", "c3piozzzz"
+  #    If-Match: *
+  IfMatch = Header("If-Match") do
+    # ( "*" | 1#entity-tag )
+    def self.parse(value)
+      if value == "*"
+        HttpObjects::Parameters::BasicRules::Token.parse("*")
+      else
+        HttpObjects::Parameters::EntityTags.parse(value)
+      end
+    end
+  end
+
+  # 14.25 If-Modified-Since
+  #    If-Modified-Since: Sat, 29 Oct 1994 19:43:31 GMT
+  IfModifiedSince = Header("If-Modified-Since", HttpObjects::Parameters::DateTime)
+
+  # 14.26 If-None-Match
+  #    If-None-Match: "xyzzy"
+  #    If-None-Match: W/"xyzzy"
+  #    If-None-Match: "xyzzy", "r2d2xxxx", "c3piozzzz"
+  #    If-None-Match: W/"xyzzy", W/"r2d2xxxx", W/"c3piozzzz"
+  #    If-None-Match: *
+  IfNoneMatch = Header("If-None-Match", IfMatch)
+
+  # 14.27 If-Range
+  IfRange = Header("If-Range") do
+    # ( entity-tag | HTTP-date )
+    def self.parse(value)
+      result = HttpObjects::Parameters::EntityTags.parse(value)
+      if value != "" && result.value == ""
+        result = HttpObjects::Parameters::DateTime.parse(value)
+      end
+      result
+    end
+  end
+
+  # 14.28 If-Unmodified-Since
+  #    If-Unmodified-Since: Sat, 29 Oct 1994 19:43:31 GMT
+  IfUnmodifiedSince = Header("If-Unmodified-Since", HttpObjects::Parameters::DateTime)
+
+  # 14.31 Max-Forwards
+  MaxForwards = Header("Max-Forwards", HttpObjects::Parameters::BasicRules::Digit)
+
+  # 14.34 Proxy-Authorization
+  # Pending: implement spec
+  ProxyAuthorization = Header("Proxy-Authorization", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.35 Range
+  # Pending: implement spec
+  Range = Header("Range", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.36 Referer
+  #    Referer: http://www.w3.org/hypertext/DataSources/Overview.html
+  Referer = Header("Referer", HttpObjects::Parameters::Uri)
+
+  # 14.39 TE
+  #    TE: deflate
+  #    TE:
+  #    TE: trailers, deflate;q=0.5
+  # Pending: implement spec
+  TE = Header("TE", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.43 User-Agent
+  #    User-Agent: CERN-LineMode/2.15 libwww/2.17b3
+  # Pending: implement spec
+  UserAgent = Header("User-Agent", HttpObjects::Parameters::BasicRules::Token)
+
+end

data/lib/http_objects/headers/response.rb

@@ -0,0 +1,55 @@
+module HttpObjects::Headers::Response
+
+  extend HttpObjects::Headers::Tools
+
+  # 14.5 Accept-Ranges
+  # Pending: implement spec
+  AcceptRanges = Header("Accept-Ranges", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.6 Age
+  Age = Header("Age", HttpObjects::Parameters::BasicRules::Digit)
+
+  # 14.19 ETag
+  #    ETag: "xyzzy"
+  #    ETag: W/"xyzzy"
+  #    ETag: ""
+  ETag = Header("ETag", HttpObjects::Parameters::EntityTags)
+
+  # 14.30 Location
+  #    Location: http://www.w3.org/pub/WWW/People.html
+  Location = Header("Location", HttpObjects::Parameters::Uri)
+
+  # 14.36 Proxy-Authenticate
+  # Pending: implement spec
+  ProxyAuthenticate = Header("Proxy-Authenticate", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.37 Retry-After
+  #    Retry-After: Fri, 31 Dec 1999 23:59:59 GMT
+  #    Retry-After: 120
+  RetryAfter = Header("Retry-After") do
+
+    #    Retry-After  = "Retry-After" ":" ( HTTP-date | delta-seconds )
+    def self.parse(value)
+      header_obj = HttpObjects::Parameters::DateTime.parse(value)
+      if header_obj.value.nil?
+        header_obj = HttpObjects::Parameters::BasicRules::Digit.parse(value)
+      end
+      header_obj
+    end
+
+  end
+
+  # 14.38 Server
+  #    Server: CERN/3.0 libwww/2.17
+  # Pending: implement spec
+  Server = Header("Server", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.44 Vary
+  # Pending: implement spec
+  Vary = Header("Vary", HttpObjects::Parameters::BasicRules::Token)
+
+  # 14.47 WWW-Authenticate
+  # Pending: implement spec
+  WWWAuthenticate = Header("WWW-Authenticate", HttpObjects::Parameters::BasicRules::Token)
+
+end

data/lib/http_objects/headers/tools.rb

@@ -0,0 +1,29 @@
+module HttpObjects
+  module Headers
+
+    # **Extend** this and be happy declaring HTTP Headers
+    module Tools
+
+      def Header(name, klass = nil, &block)
+        header_class = if block_given?
+                         Class.new(&block)
+                       else
+                         Class.new(klass)
+                       end
+        header_class.instance_eval %{
+          def header_name
+            "#{name}"
+          end
+        }
+        header_class
+      end
+
+      # Returns Array of Header classes.
+      def headers
+        self.constants.map { |header| self.const_get(header) }
+      end
+
+    end
+
+  end
+end

data/lib/http_objects/headers.rb

@@ -0,0 +1,27 @@
+require "http_objects/headers/tools"
+require "http_objects/headers/attributes"
+require "http_objects/hash"
+
+require "http_objects/headers/directives/cache"
+
+require "http_objects/headers/entity"
+require "http_objects/headers/general"
+require "http_objects/headers/request"
+require "http_objects/headers/response"
+
+module HttpObjects
+
+  module Headers
+
+    # Returns Array of all HTTP Headers
+    def self.headers
+      [HttpObjects::Headers::General,
+       HttpObjects::Headers::Entity,
+       HttpObjects::Headers::Request,
+       HttpObjects::Headers::Response].inject([]) do |headers, header_module|
+         headers.concat(header_module.headers)
+       end
+    end
+
+  end
+end

data/lib/http_objects/headers_hash.rb

@@ -0,0 +1,25 @@
+module HttpObjects
+
+  # Public: Hash with HTTP Headers methods.
+  #
+  # Examples
+  #
+  #    headers = HttpObjects::Headers.new
+  #    headers["key"] = "value" # is kind of Hash
+  #
+  #    # And for HTTP headers, you have objects
+  #    headers["Content-Type"] = "text/html;Charset=utf-8"
+  #    headers.content_type? # => true
+  #    headers.content_type! # => "text/html;Charset=utf-8"
+  #    headers.content_type.value # => "text/html"
+  #    headers.content_type['charset'] # => "utf-8"
+  #    headers.content_type.inspect # => #<HttpObjects::Headers::MediaType ...>
+  class HeadersHash < HttpObjects::Hash
+
+    HttpObjects::Headers.headers.each do |header|
+      add_attribute(header)
+    end
+
+  end
+
+end