weary 0.7.2 → 1.0.0.rc1

data/Rakefile

@@ -1,51 +1,10 @@
-begin
-  # Try to require the preresolved locked set of gems.
-  require File.expand_path('../.bundle/environment', __FILE__)
-rescue LoadError
-  # Fall back on doing an unlocked resolve at runtime.
-  require "rubygems"
-  require "bundler"
-  Bundler.setup
-end
-
-require 'spec/rake/spectask'
+require 'rspec/core/rake_task'
+require "bundler/gem_tasks"
+require 'yard'
 
 task :default => :spec
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'doc'
-  rdoc.title    = 'weary'
-  rdoc.main     = 'README.md'
-  rdoc.rdoc_files.include('README.*', 'lib/**/*.rb', 'LICENSE')
-  rdoc.options  << '--inline-source'
-end
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "weary"
-    gemspec.rubyforge_project = "weary"
-    gemspec.summary = "A little DSL for consuming RESTful web services"
-    gemspec.email = "mark@markwunsch.com"
-    gemspec.homepage = "http://github.com/mwunsch/weary"
-    gemspec.description = "A tiny DSL that makes the consumption of RESTful web services simple."
-    gemspec.authors = "Mark Wunsch"
-    gemspec.add_dependency 'crack', '>= 0.1.7'
-    gemspec.add_dependency 'oauth', '>= 0.3.5'
-    gemspec.add_development_dependency 'bundler', ">= 0.9.7"
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available.  Install it with: gem install jeweler"
-end
-
-desc "Open an irb session preloaded with this library"
-task :console do
-  sh "irb -rubygems -I lib -r weary.rb"
-end
+RSpec::Core::RakeTask.new(:spec)
 
-Spec::Rake::SpecTask.new do |t|
-  t.spec_files = FileList['spec/**/*_spec.rb']
-  t.spec_opts = ['--color','--format nested']
-end
+# The state of yard-tomdoc isn't so great right now
+YARD::Rake::YardocTask.new

data/lib/weary.rb

@@ -1,34 +1,8 @@
-require 'uri'
-require 'net/http'
-require 'net/https'
-
-require 'crack'
-require 'oauth'
-
-autoload :Yaml, 'yaml'
-
-require 'weary/request'
-require 'weary/response'
-require 'weary/resource'
-require 'weary/batch'
-require 'weary/exceptions'
-require 'weary/httpverb'
-require 'weary/base'
+require 'weary/version'
+require 'weary/client'
 
 module Weary
-  
-  # Supported HTTP Verbs
-  Methods = [:get, :post, :put, :delete, :head]
-  
-  # Supported Content Types
-  ContentTypes = { :json  => [:json, 'json', 'application/json', 'text/json', 'application/javascript', 'text/javascript'],
-                   :xml   => [:xml, 'xml', 'text/xml', 'application/xml'],
-                   :html  => [:html, 'html', 'text/html'],
-                   :yaml  => [:yaml, 'yaml', 'application/x-yaml', 'text/yaml'],
-                   :plain => [:plain, 'plain', 'text/plain'] }
-                   
-  # A collection of User Agent strings that I stole from HURL (http://hurl.it)
-  UserAgents = {
+  USER_AGENTS = {
     "Firefox 1.5.0.12 - Mac" => "Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; en-US; rv:1.8.0.12) Gecko/20070508 Firefox/1.5.0.12",
     "Firefox 1.5.0.12 - Windows" => "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.12) Gecko/20070508 Firefox/1.5.0.12",
     "Firefox 2.0.0.12 - Mac" => "Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en-US; rv:1.8.1.12) Gecko/20080201 Firefox/2.0.0.12",
@@ -58,40 +32,4 @@ module Weary
     "Safari 4.0.2 - Mac" => "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_7; en-us) AppleWebKit/530.19.2 (KHTML, like Gecko) Version/4.0.2 Safari/530.19",
     "Safari 4.0.2 - Windows" => "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/530.19.2 (KHTML, like Gecko) Version/4.0.2 Safari/530.19.1"
   }
-  
-  class << self
-    def get(url,&block)
-      request url, :get, &block
-    end
-    
-    def post(url,&block)
-      request url, :post, &block
-    end
-    
-    def put(url,&block)
-      request url, :put, &block
-    end
-    
-    def delete(url,&block)
-      request url, :delete, &block
-    end
-    
-    def head(url,&block)
-      request url, :head, &block
-    end
-    
-    # Create a Request for the URL.
-    # Defaults to a GET Request. Use a block to further modify the Request
-    def request(url,via = :get, &block)
-      req = Request.new(url,via)
-      yield req if block_given?
-      req
-    end
-    
-    # Create a Batch for a group of Requests
-    def batch(*requests)
-      Batch.new(requests)
-    end
-  end
-  
-end
+end

data/lib/weary/adapter.rb

@@ -0,0 +1,23 @@
+require 'weary/response'
+require 'weary/adapters/net_http'
+module Weary
+  # An abstract interface. A subclass should be something that actually opens
+  # a socket to make the request, e.g. Net/HTTP, Curb, etc.
+  module Adapter
+
+    def initialize(app=nil)
+      @app = app
+    end
+
+    def call(env)
+      connect(Rack::Request.new(env)).finish
+    end
+
+    # request is a Rack::Request
+    # This computation is performed in a Promise/Future
+    # Returns a Rack::Response
+    def connect(request)
+      Rack::Response.new [""], 501, {"Content-Type" => "text/plain"}
+    end
+  end
+end

data/lib/weary/adapters/net_http.rb

@@ -0,0 +1,68 @@
+require 'net/http'
+require 'net/https'
+
+module Weary
+  module Adapter
+    class NetHttp
+      include Weary::Adapter
+
+      def self.call(env)
+        connect(Rack::Request.new(env)).finish
+      end
+
+      def self.connect(request)
+        connection = socket(request)
+        response = connection.request prepare(request)
+        Rack::Response.new response.body, response.code, normalize_response(response.to_hash)
+      end
+
+      def self.prepare(request)
+        req_class = request_class(request.request_method)
+        req = req_class.new(request.fullpath, normalize_request_headers(request.env))
+        if req.request_body_permitted? # What's the best way of passing the body?
+          req.body = request.body.read
+          request.body.rewind
+        end
+        req.content_type = request.content_type if request.content_type
+        req.content_length = request.content_length if request.content_length
+        req
+      end
+
+      def self.normalize_request_headers(env)
+        req_headers = env.reject {|k,v| !k.start_with? "HTTP_" }
+        normalized = req_headers.map do |k, v|
+          new_key = k.sub("HTTP_",'').split('_').map(&:capitalize).join('-')
+          [new_key, v] unless UNWANTED_REQUEST_HEADERS.include? new_key
+        end
+        Hash[normalized]
+      end
+
+      def self.normalize_response(headers)
+        headers.reject {|k,v| k.downcase == 'status' }
+      end
+
+      def self.socket(request)
+        host = request.env['HTTP_HOST'] || request.env['SERVER_NAME']
+        port = request.env['SERVER_PORT'].to_s
+        connection = Net::HTTP.new host, port
+        connection.use_ssl = request.scheme == 'https'
+        connection.verify_mode = OpenSSL::SSL::VERIFY_NONE if connection.use_ssl?
+        connection
+      end
+
+      def self.request_class(method)
+        capitalized = method.capitalize
+        Net::HTTP.const_get capitalized
+      end
+
+      def call(env)
+        self.class.call(env)
+      end
+
+      private
+
+      UNWANTED_REQUEST_HEADERS = []
+
+    end
+  end
+end

data/lib/weary/client.rb

@@ -0,0 +1,243 @@
+require 'weary/resource'
+
+module Weary
+  autoload :Route, 'weary/route'
+
+  # An abstract class used to construct client libraries and the primary
+  # entrance point to use the Weary framework. Client defines a DSL to describe
+  # and construct a set of Resources, which in turn can generate Requests that
+  # can perform HTTP actions.
+  #
+  # Resources are defined and stored by one of the class methods corresponding
+  # to an HTTP request method. Every Resource is declared with a name that
+  # acts as both a key to access the resource, and, when the class is
+  # instantiated, the name of a dynamically generated instance method.
+  #
+  # Examples
+  #
+  #   class GiltSales < Weary::Client
+  #     domain "https://api.gilt.com/v1"
+  #
+  #     required :apikey
+  #
+  #     optional :affid
+  #
+  #     get :active, "/sales/active.json"
+  #
+  #     get :active_in_store, "/sales/:store/active.json"
+  #
+  #     get :upcoming, "/sales/upcoming.json"
+  #
+  #     get :upcoming_in_store, "/sales/:store/upcoming.json"
+  #
+  #     get :detail, "/sales/:store/:sale_key/detail.json"
+  #   end
+  #
+  #   sales = GiltSales.new
+  #   sales.active_in_store :store => :women, :apikey => "my-key"
+  #   # => A Weary::Request object
+  #
+  class Client
+
+    # Internal: HTTP Request verbs supported by Weary. These translate to class
+    # methods of Client.
+    REQUEST_METHODS = [
+      :copy, :delete, :get, :head, :lock, :mkcol, :move, :options,
+      :patch, :post, :propfind, :proppatch, :put, :trace, :unlock
+    ]
+
+    class << self
+
+      REQUEST_METHODS.each do |request_method|
+        # Generate a resource of the specified REQUEST_METHOD. This
+        # method is defined for each of the REQUEST_METHODS.
+        #
+        # name  - A Symbol name or descriptor of a resource to dynamically
+        #         generate an instance method of the same name.
+        # path  - A String path to the resource. If the class's domain is set it
+        #         will be prepended to this path to form the resource's uri.
+        # block - An optional block to be used to further customize the resource.
+        #
+        # Returns a Response object describing an HTTP endpoint.
+        #
+        # Signature
+        #
+        #   <method>(name, path, &block)
+        #
+        # method - An HTTP request method (and member of REQUEST_METHODS).
+        define_method request_method do |name, path, &block|
+          resource(name, request_method.to_s.upcase, path, &block)
+        end
+      end
+
+      # An accessor to set the domain where the client's resources are
+      # located. This is prepended to the resources' path to form the resource
+      # uri.
+      #
+      # host - An optional String to set the client domain.
+      #
+      # Returns the domain String.
+      def domain(host=nil)
+        @domain = host unless host.nil?
+        @domain ||= ""
+      end
+
+      # An accessor to set optional parameters permitted by all
+      # resources described by the client.
+      #
+      # params - Zero or more Symbol parameters expected by the resources.
+      #
+      # Returns an Array of parameters.
+      def optional(*params)
+        @optional = params unless params.empty?
+        @optional ||= []
+      end
+
+      # An accessor to set parameters required by the all of the
+      # resources of the client.
+      #
+      # params - Zero or more Symbol parameters required by the resources.
+      #
+      # Returns an Array of parameters.
+      def required(*params)
+        @required = params unless params.empty?
+        @required ||= []
+      end
+
+      # An accessor to set default parameters to be used by the all of
+      # the resources described by the client.
+      #
+      # hash - An optional Hash of key/value pairs describing the
+      #        default parameters to be sent to the resources
+      #
+      # Returns a Hash of the default parameters sent to all resources.
+      def defaults(hash=nil)
+        @defaults = hash unless hash.nil?
+        @defaults ||= {}
+      end
+
+      # An accessor to set HTTP request headers for all of the client's
+      # resources.
+      #
+      # hash - An optional Hash of key/value pairs that are sent as HTTP
+      #        request headers when a resource's request is performed.
+      #
+      # Returns a Hash of the headers.
+      def headers(hash=nil)
+        @headers = hash unless hash.nil?
+        @headers ||= {}
+      end
+
+      # Send a Rack middleware to all of the requests generated by
+      # the client.
+      #
+      # middleware - An object that implements the rack middleware interface.
+      # args       - Zero or more optional arguments to send to the middleware.
+      # block      - An optional block to send to the middleware.
+      #
+      # Returns an Array of middlewares.
+      def use(middleware, *args, &block)
+        @middlewares ||= []
+        @middlewares << [middleware, args, block]
+      end
+
+      # Internal: Create and build a resource description of a request. The
+      # resource is then stored in an internal hash, generating an instance
+      # method.
+      #
+      # name   - A Symbol name/descriptor of the resource.
+      # method - A Symbol or String of the request method used in the request.
+      # path   - A String path to the resource that is appended to the domain
+      #          to form the uri.
+      #
+      # Yields the Resource for further construction.
+      #
+      # Returns the generated Resource.
+      def resource(name, method, path="")
+        resource = Weary::Resource.new method, "#{domain}#{path}"
+        resource.optional *optional
+        resource.required *required
+        resource.defaults defaults
+        resource.headers headers
+        if !@middlewares.nil? && !@middlewares.empty?
+          @middlewares.each {|middleware| resource.use *middleware }
+        end
+        yield resource if block_given?
+        self[name] = resource
+      end
+
+      # A getter for the stored table of Resources.
+      #
+      # Returns a Hash of Resources stored by their name keys.
+      def resources
+        @resources ||= {}
+      end
+
+      # Store a Resource at the given key. A method is built for the
+      # instances with the same name as the key that calls the request method
+      # of the Resource.
+      #
+      # name     - A Symbol name of the Resource and the eventual name of the
+      #            method that will build the request.
+      # resource - The Resource object to store. When the named method is
+      #            called on the client instance, this resource's request
+      #            method will be called.
+      #
+      # Returns the stored Resource.
+      def []=(name,resource)
+        store name, resource
+      end
+
+      # A quick getter to retrieve a Resource from the client's
+      # internal store.
+      #
+      # name - The Symbol name of the Resource.
+      #
+      # Returns the Resource stored at name.
+      def [](name)
+        resources[name]
+      end
+
+      # Internal: Build a Rack router for the client's resources.
+      #
+      # Returns a Route object of the resources at the domain.
+      def route
+        Weary::Route.new resources.values, domain
+      end
+
+      # A Rack middleware interface that uses the internal router to
+      # determine the best Resource available.
+      #
+      # Returns an Array resembling a Rack response tuple.
+      def call(env)
+        route.call(env)
+      end
+
+      private
+
+      # Private: Store the resource in a hash keyed by the name (as a Symbol).
+      #
+      # Returns the saved Resource.
+      # Raises ArgumentError if you try to store anything but a Resource.
+      def store(name, resource)
+        raise ArgumentError, "Expected a Weary::Resource but got #{resource.inspect}" \
+          unless resource.is_a? Weary::Resource
+        key = name.to_sym
+        build_method(key, resource)
+        resources[key] = resource
+      end
+
+      # Private: Do the metaprogramming necessary for the resource names to
+      # become instance methods.
+      def build_method(key, resource)
+        define_method(key) do |*parameters, &block|
+          parameters = parameters.first || {}
+          @defaults ||= {}
+          request = resource.request(@defaults.merge(parameters), &block)
+          request
+        end
+      end
+    end
+
+  end
+end