weary 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+examples
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Mark Wunsch
+
+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,14 @@
+# Weary
+
+_The Weary need REST_
+
+Weary is a tiny DSL for making the consumption of RESTful web services simple. It is the little brother to [HTTParty](http://github.com/jnunemaker/httparty/ "JNunemaker's HTTParty"). It provides a thin, gossamer-like layer over the Net/HTTP library.
+
+The things it do:
+
++ Quickly build an interface to your favorite REST API.
++ Parse XML and JSON with the [Crack](http://github.com/jnunemaker/crack) library.
+
+## Requirements
+
++ Crack

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+
+task :default => :spec
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "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 = "The Weary need REST: a tiny DSL that makes the consumption of RESTful web services simple."
+    gemspec.authors = "Mark Wunsch"
+    gemspec.has_rdoc = false
+    gemspec.rubyforge_project = "weary"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"  
+end
+
+begin
+  require 'rake/contrib/sshpublisher'
+  namespace :rubyforge do
+
+    desc "Release gem and RDoc documentation to RubyForge"
+    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+
+    namespace :release do
+      desc "Publish RDoc to RubyForge."
+      task :docs => [:rdoc] do
+        config = YAML.load(
+            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+        )
+
+        host = "#{config['username']}@rubyforge.org"
+        remote_dir = "/var/www/gforge-projects/weary/"
+        local_dir = 'rdoc'
+
+        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+      end
+    end
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['--color','--format nested']
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/weary.rb

@@ -0,0 +1,150 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+require 'rubygems'
+require 'crack'
+
+gem 'nokogiri'
+autoload :Yaml, 'yaml'
+autoload :Nokogiri, 'nokogiri'
+
+require 'weary/request'
+require 'weary/response'
+require 'weary/resource'
+require 'weary/exceptions'
+
+
+module Weary
+  
+  Methods = { :get    => [:get, :GET, /\bget\b/i],
+              :post   => [:post, :POST, /\bpost\b/i],
+              :put    => [:put, :PUT, /\bput\b/i],
+              :delete => [:delete, :del, :DELETE, :DEL, /\bdelete\b/i],
+              :head   => [:head, :HEAD, /\bhead\b/i] }
+  
+  # Weary::Query quickly performs a :get request on a URL and parses the request
+  def self.Query(url)
+    req = Weary::Request.new(url, :get).perform
+    req.parse
+  end
+  
+  attr_reader :domain, :resources
+  
+  def on_domain(domain)
+    parse_domain = URI.extract(domain)
+    raise ArgumentError, 'The domain must be a URL.' if parse_domain.empty?
+    @domain = parse_domain[0]
+  end
+  alias domain= on_domain
+
+  def as_format(format)
+    @default_format = format.to_sym
+  end
+  alias format= as_format
+  
+  def construct_url(pattern)
+    @url_pattern = pattern.to_s
+  end
+  alias url= construct_url
+
+  def authenticates_with(username,password)
+    @username = username
+    @password = password
+    return nil
+  end
+
+  def declare_resource(resource, options={})
+    # available options:
+    # :via = get, post, etc. defaults to get
+    # :with = paramaters passed to body or query
+    # :requires = members of :with that must be in the action
+    # :authenticates = boolean; uses basic_authentication
+    # :url = a pattern
+    # :format = to set format, defaults to :json
+    # :no_follow = boolean; defaults to false. do not follow redirects
+      
+    
+    @resources ||= []
+        
+    r = Weary::Resource.new(resource, set_defaults(options))
+    declaration = r.to_hash
+    
+    @resources << declaration
+    
+    craft_methods(r)
+    return declaration
+  end
+  
+  def get(resource,options={})
+    options[:via] = :get
+    declare_resource(resource,options)
+  end
+  
+  def post(resource,options={})
+    options[:via] = :post
+    declare_resource(resource,options)
+  end
+  
+  def put(resource,options={})
+    options[:via] = :put
+    declare_resource(resource,options)
+  end
+  
+  def delete(resource,options={})
+    options[:via] = :delete
+    declare_resource(resource,options)
+  end
+
+  private
+    def set_defaults(hash)
+      hash[:domain] = @domain
+      hash[:via] ||= :get
+      hash[:with] ||= []
+      hash[:with] = hash[:with] | hash[:requires] unless hash[:requires].nil?
+      hash[:format] ||= (@default_format || :json)
+      hash[:authenticates] ||= false
+      hash[:authenticates] = false if hash[:authenticates] == "false"
+      if hash[:authenticates]
+        raise StandardError, "Can not authenticate unless username and password are defined" unless (@username && @password)
+      end
+      hash[:url] ||= (@url_pattern || "<domain><resource>.<format>")
+      hash[:no_follow] ||= false
+      return hash
+    end
+    
+    def craft_methods(resource)
+      code = %Q{
+        def #{resource.name}(params={})
+          options ||= {}
+          url = "#{resource.url}"
+      }
+      unless resource.requires.nil?
+        resource.requires.each do |required|
+          code << %Q{raise ArgumentError, "This resource requires parameter: ':#{required}'" unless params.has_key?(:#{required}) \n}
+        end
+      end
+      unless resource.with.nil?
+        with = %Q\[#{resource.with.collect {|x| ":#{x}"}.join(',')}]\
+        code << "unnecessary = params.keys - #{with} \n"
+        code << "unnecessary.each { |x| params.delete(x) } \n"
+      end
+      if resource.via == (:post || :put)
+        code << "options[:body] = params unless params.empty? \n"
+      else
+        code << "options[:query] = params unless params.empty? \n"
+        code << %Q{url << "?" + options[:query].to_params unless options[:query].nil? \n}
+      end
+      if resource.authenticates?
+        code << %Q{options[:basic_auth] = {:username => "#{@username}", :password => "#{@password}"} \n}
+      end
+      code << %Q{
+          Weary::Request.new(url, :#{resource.via}, options).perform
+        end
+      }
+      class_eval code
+    end
+
+end

data/lib/weary/exceptions.rb

@@ -0,0 +1,3 @@
+module Weary
+  class HTTPError < StandardError; end 
+end

data/lib/weary/request.rb

@@ -0,0 +1,80 @@
+module Weary
+  class Request
+    
+    attr_reader :uri
+    attr_accessor :options
+  
+    def initialize(url, http_verb= :get, options={})
+      self.method = http_verb
+      self.uri = url
+      self.options = options
+    end
+  
+    def uri=(url)
+      @uri = URI.parse(url)
+    end
+    
+    def method=(http_verb)
+      @http_verb = case http_verb
+        when *Methods[:get]
+          :get
+        when *Methods[:post]
+          :post
+        when *Methods[:put]
+          :put
+        when *Methods[:delete]
+          :delete
+        when *Methods[:head]
+          :head
+        else
+          raise ArgumentError, "Only GET, POST, PUT, DELETE, and HEAD methods are supported"
+      end
+    end
+    
+    def method
+      @http_verb
+    end
+  
+    def perform
+      req = http.request(request)
+      response = Response.new(req, @http_verb)
+      unless options[:no_follow]
+        if response.redirected?
+          response.follow_redirect
+        else
+          response
+        end
+      else
+        response
+      end
+    end
+    alias make perform
+    
+    private
+      def http
+        connection = Net::HTTP.new(@uri.host, @uri.port)
+        connection.use_ssl = @uri.is_a?(URI::HTTPS)
+        connection.verify_mode = OpenSSL::SSL::VERIFY_NONE if connection.use_ssl
+        connection
+      end
+    
+      def request
+        prepare = case @http_verb
+          when :get
+            Net::HTTP::Get.new(@uri.request_uri)
+          when :post
+            Net::HTTP::Post.new(@uri.request_uri)
+          when :put
+            Net::HTTP::Put.new(@uri.request_uri)
+          when :delete
+            Net::HTTP::Delete.new(@uri.request_uri)
+          when :head
+            Net::HTTP::Head.new(@uri.request_uri)
+        end
+        prepare.body = options[:body].is_a?(Hash) ? options[:body].to_params : options[:body] if options[:body]
+        prepare.basic_auth(options[:basic_auth][:username], options[:basic_auth][:password]) if options[:basic_auth]
+        prepare
+      end
+
+  end
+end

data/lib/weary/resource.rb

@@ -0,0 +1,74 @@
+module Weary
+  class Resource
+    attr_reader :name, :with, :requires, :via, :format, :url
+    
+    def initialize(name,options={})
+      @domain = options[:domain]
+      self.name = name
+      self.via = options[:via]
+      self.with = options[:with]
+      self.requires = options[:requires]
+      self.format = options[:format]
+      self.url = options[:url]
+      @authenticates = (options[:authenticates] != false)
+      @follows = (options[:no_follow] == false)
+    end
+    
+    def name=(resource)
+      @name = resource.to_s
+    end
+    
+    def via=(verb)
+      @via = verb
+    end
+    
+    def with=(params)
+      if params.empty?
+        @with = nil
+      else
+        @with = params.collect {|x| x.to_sym }
+      end
+    end
+    
+    def url=(pattern)
+      if pattern.index("<domain>")
+        raise StandardError, "Domain flag found but the domain is not defined" if @domain.nil?
+        pattern = pattern.gsub("<domain>", @domain)
+      end
+      pattern = pattern.gsub("<resource>", @name)
+      pattern = pattern.gsub("<format>", @format.to_s)
+      @url = pattern
+    end
+    
+    def requires=(params)
+      if (params.nil? || params.empty?)
+        @requires = nil
+      else
+        @requires = params
+      end
+    end
+    
+    def format=(type)
+      @format = type
+    end
+    
+    def authenticates?
+      @authenticates
+    end
+    
+    def follows_redirects?
+      @follows
+    end
+    
+    def to_hash
+      {@name.to_sym => {:via => @via,
+                        :with => @with,
+                        :requires => @requires,
+                        :authenticates => authenticates?,
+                        :format => @format,
+                        :url => @url},
+                        :no_follow => !follows_redirects?}
+    end
+    
+  end
+end

data/lib/weary/response.rb

@@ -0,0 +1,109 @@
+module Weary
+  class Response
+  
+    attr_reader :raw, :method, :code, :message, :header, :content_type, :cookie, :body
+    alias mime_type content_type
+    
+    def initialize(http_response, http_method)
+      raise ArgumentError, "Must be a Net::HTTPResponse" unless http_response.is_a?(Net::HTTPResponse)
+      @raw = http_response
+      @method = http_method
+      @code = http_response.code.to_i
+      @message = http_response.message
+      @header = http_response.to_hash
+      @content_type = http_response.content_type
+      @cookie = http_response['Set-Cookie']
+      @body = http_response.body
+      self.format = http_response.content_type
+    end
+    
+    def redirected?
+      @raw.is_a?(Net::HTTPRedirection)
+    end
+
+    def success?
+      (200..299).include?(@code)
+    end
+    
+    def format=(type)
+      @format = case type
+        when 'text/xml', 'application/xml'
+          :xml
+        when 'application/json', 'text/json', 'application/javascript', 'text/javascript'
+          :json
+        when 'text/html'
+          :html
+        when 'application/x-yaml', 'text/yaml'
+          :yaml
+        when 'text/plain'
+          :plain
+        else
+          nil
+      end
+    end
+    
+    def format
+      @format
+    end
+    
+    def follow_redirect
+      if redirected?
+        Request.new(@raw['location'], @method).perform
+      else
+        nil
+      end
+    end
+    
+    def parse
+      raise StandardError, "The Response has no body. #{@method.to_s.upcase} request sent." unless @body
+      handle_errors
+      case @format
+        when :xml, :html
+          Crack::XML.parse @body
+        when :json
+          Crack::JSON.parse @body
+        when :yaml
+          YAML::load @body
+        else
+          @body
+      end
+    end
+    
+    def search(selector)
+      raise ArgumentError, "Search can only be used with an XML or HTML document." unless @format != (:xml || :html)
+      doc = Nokogiri.parse(@body)
+      doc.search(selector)
+    end
+    
+    private
+      def handle_errors
+        case @code
+          when 301,302
+            raise HTTPError, "#{@message} to #{@raw['location']}"
+          when 200...400
+            return
+          when 400
+            raise HTTPError, "Failed with #{@code}: #{@message}"
+          when 401
+            raise HTTPError, "Failed with #{@code}: #{@message}"
+          when 403
+            raise HTTPError, "Failed with #{@code}: #{@message}"
+          when 404
+            raise HTTPError, "Failed with #{@code}: #{@message}"
+          when 405
+            raise HTTPError, "Failed with #{@code}: #{@message}"
+          when 409
+            raise HTTPError, "Failed with #{@code}: #{@message}"
+          when 422
+            raise HTTPError, "Failed with #{@code}: #{@message}"
+          when 401...500
+            raise HTTPError, "Failed with #{@code}: #{@message}"
+          when 500...600
+            raise HTTPError, "Failed with #{@code}: #{@message}"
+          else
+            raise HTTPError, "Unknown response code: #{@code}"
+        end
+      end
+          
+  end
+end

data/spec/weary/request_spec.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+gem 'rspec'
+require 'spec'
+require File.join(File.dirname(__FILE__), '../..', 'lib', 'weary')
+
+describe Weary::Request do
+  
+  it "should contain a url" do
+    test = Weary::Request.new("http://google.com")
+    test.uri.is_a?(URI).should == true
+  end
+  
+  it "should parse the http method" do
+    test = Weary::Request.new("http://google.com", "POST")
+    test.method.should == :post
+  end
+  
+  it "should craft a Net/HTTP Request" do
+    test = Weary::Request.new("http://google.com").send :http
+    test.class.should == Net::HTTP
+  end
+  
+  it "should follow redirects" do
+    pending "Not sure how to test this"
+  end
+end

data/spec/weary_spec.rb

@@ -0,0 +1,140 @@
+require 'rubygems'
+gem 'rspec'
+require 'spec'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'weary')
+
+describe Weary do
+  before do
+    @test = Class.new
+    @test.instance_eval { extend Weary }
+  end
+  
+  describe "default domain" do
+    it 'should be set with a url' do
+      @test.on_domain("http://twitter.com/")
+      @test.domain.should == "http://twitter.com/"
+    end
+    
+    it "should also be set by it's alias" do
+      @test.domain = "http://twitter.com/"
+      @test.domain.should == "http://twitter.com/"
+    end
+    
+    it 'should raise an exception when a url is not present' do
+      lambda { @test.on_domain("foobar") }.should raise_error
+    end
+    
+    it 'should only take the first url given' do
+      @test.on_domain("with http://google.com/ and http://yahoo.com/")
+      @test.domain.should == "http://google.com/"
+    end
+  end
+  
+  describe "default format" do
+    it 'can be set' do
+      @test.as_format("xml")
+      @test.instance_variable_defined?(:@default_format).should == true
+    end
+    
+    it "should also be set by it's alias" do
+      @test.format = "xml"
+      @test.instance_variable_defined?(:@default_format).should == true
+    end
+    
+    it 'should be a symbol' do
+      @test.as_format("xml")
+      @test.instance_variable_get(:@default_format).class.should == Symbol
+    end
+  end
+  
+  describe "default url pattern" do
+    it 'can be set' do
+      @test.construct_url("<domain><resource>.<format>")
+      @test.instance_variable_defined?(:@url_pattern).should == true
+    end
+    
+    it "should also be set by it's alias" do
+      @test.url = "<domain><resource>.<format>"
+      @test.instance_variable_defined?(:@url_pattern).should == true
+    end
+    
+    it 'should be a string' do
+      @test.construct_url(123)
+      @test.instance_variable_get(:@url_pattern).class.should == String
+    end
+  end
+  
+  describe "basic authentication credentials" do
+    it "should accept a username and password" do
+      @test.authenticates_with("foo","bar")
+      @test.instance_variable_get(:@username).should == "foo"
+      @test.instance_variable_get(:@password).should == "bar"
+    end  
+  end
+  
+  describe "resource declaration" do  
+    before do
+      @test.domain = "http://twitter.com/"
+    end
+    
+    it "should adds a new resource" do
+      @test.declare_resource("resource")
+      @test.resources[0].has_key?(:resource).should == true
+    end
+    
+    it "should default to a GET request" do
+      @test.declare_resource("resource")[:resource][:via].should == :get
+    end
+    
+    it "should default to JSON if no format is defined" do
+      @test.declare_resource("resource")[:resource][:format].should == :json
+    end
+    
+    it "should use the declared format, if a specific format is not defined" do
+      @test.format = :xml
+      @test.declare_resource("resource")[:resource][:format].should == :xml
+    end
+    
+    it "should override the default format with it's own format" do
+      @test.format = :xml
+      @test.declare_resource("resource",{:format => :yaml})[:resource][:format].should == :yaml
+    end
+    
+    it "should form a url if there is a default pattern" do
+      @test.declare_resource("resource")[:resource][:url].should == "http://twitter.com/resource.json"
+    end
+    
+    it "should override the default pattern with it's own url" do
+      @test.declare_resource("resource",{:url => "http://foobar.com/<resource>"})[:resource][:url].should == "http://foobar.com/resource"
+    end
+    
+    it "should be able to contain a set of allowed parameters" do
+      @test.declare_resource("resource",{:with => [:id]})[:resource][:with].empty?.should == false
+    end
+    
+    it "should be able to contain a set of required parameters" do
+      @test.declare_resource("resource",{:requires => [:id]})[:resource][:requires].empty?.should == false
+    end
+    
+    it "should merge required parameters into allowed parameters" do
+      @test.declare_resource("resource",{:requires => [:id]})[:resource][:with].empty?.should == false
+    end
+    
+    it "should authenticate with username and password" do
+      @test.authenticates_with("foo","bar")
+      @test.declare_resource("resource",{:authenticates => true})[:resource][:authenticates].should == true      
+    end
+    
+    it "should raise an exception if authentication is required but no credentials are supplied" do
+      lambda do
+        @test.declare_resource("resource",{:authenticates => true})
+      end.should raise_error
+    end
+    
+    it "should create a method for an instantiated object" do
+      @test.declare_resource("resource")
+      @test.public_method_defined?(:resource).should == true
+    end
+    
+  end 
+end

data/weary.gemspec

@@ -0,0 +1,52 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{weary}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mark Wunsch"]
+  s.date = %q{2009-06-08}
+  s.description = %q{The Weary need REST: a tiny DSL that makes the consumption of RESTful web services simple.}
+  s.email = %q{mark@markwunsch.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "lib/weary.rb",
+     "lib/weary/exceptions.rb",
+     "lib/weary/request.rb",
+     "lib/weary/resource.rb",
+     "lib/weary/response.rb",
+     "spec/weary/request_spec.rb",
+     "spec/weary_spec.rb",
+     "weary.gemspec"
+  ]
+  s.homepage = %q{http://github.com/mwunsch/weary}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{weary}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{A little DSL for consuming RESTful web services}
+  s.test_files = [
+    "spec/weary/request_spec.rb",
+     "spec/weary_spec.rb",
+     "examples/test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: weary
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mark Wunsch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-08 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: "The Weary need REST: a tiny DSL that makes the consumption of RESTful web services simple."
+email: mark@markwunsch.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/weary.rb
+- lib/weary/exceptions.rb
+- lib/weary/request.rb
+- lib/weary/resource.rb
+- lib/weary/response.rb
+- spec/weary/request_spec.rb
+- spec/weary_spec.rb
+- weary.gemspec
+has_rdoc: false
+homepage: http://github.com/mwunsch/weary
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: weary
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A little DSL for consuming RESTful web services
+test_files: 
+- spec/weary/request_spec.rb
+- spec/weary_spec.rb
+- examples/test.rb