wrest 0.0.7-java → 0.0.8-java

data/lib/wrest/resource/base.rb

@@ -13,11 +13,25 @@ module Wrest::Resource #:nodoc:
   class Base
     include Wrest::Components::AttributesContainer
     include Wrest::Components::AttributesContainer::Typecaster
-    
-    always_has  :id
+
+    always_has      :id
     typecast        :id => as_integer
     attr_reader     :attributes
 
+    def ==(other)
+      return true if self.equal?(other)
+      return false unless other.class == self.class
+      return self.attributes == other.attributes
+    end
+
+    def hash
+      id.hash
+    end
+
+    def to_xml(options={})
+      attributes.to_xml({:root => self.class.resource_name.gsub('_', '-')}.merge(options))
+    end
+
     class << self
       def inherited(klass)
         klass.set_resource_name klass.name
@@ -29,7 +43,7 @@ module Wrest::Resource #:nodoc:
       # we often do while writing tests.
       # By default, the resource name is set to the name of the class.
       def set_resource_name(resource_name)
-        self.class_eval "def self.resource_name; '#{resource_name}';end"
+        self.class_eval "def self.resource_name; '#{resource_name.underscore}';end"
       end
 
       # Allows the host url at which the resource is found to be configured
@@ -42,43 +56,44 @@ module Wrest::Resource #:nodoc:
       def set_host(host)
         self.class_eval "def self.host; '#{host}';end"
       end
-      
+
       def set_default_format(format)
         self.class_eval "def self.default_format; '#{format.to_s}';end"
       end
-      
-      def set_redirect_handler(method_object)
-      end
 
-      def resource_path
-        @resource_path ||= "/#{resource_name.underscore.pluralize}"
-      end
-
-      def resource_collection_url
-        "#{host}#{resource_path}"
+      def set_redirect_handler(method_object)
       end
 
-      def find_all
+      def resource_collection_name
+        @resource_collection_name ||= "#{resource_name.underscore.pluralize}"
       end
 
-      def find(resource_type = [:one, :collection, :singleton], from = "")
+      def find_one_uri_template
+        @find_one_template ||= Wrest::UriTemplate.new(':host/:resource_collection_name/:id.:format')
       end
 
       def find(id)
-        response_hash = "#{resource_collection_url}/#{id}.#{default_format}".to_uri.get.deserialise.mutate_using(
-                                                                                          Wrest::Components::Mutators.chain(
-                                                                                            :xml_mini_type_caster, :camel_to_snake_case
-                                                                                          )
-                                                                                        )
-        resource_type = response_hash.keys.first
-        if(resource_type.underscore.camelize == self.name)
-          self.new(response_hash[resource_type])
-        else
-          response_hash
-        end
+        response = find_one_uri_template.to_uri(
+          :host => host,
+          :resource_collection_name => resource_collection_name,
+          :id => id,
+          :format => default_format
+        ).get
+        self.new(response.deserialise.mutate_using(
+          Wrest::Components::Mutators.chain(:xml_mini_type_caster, :camel_to_snake_case)
+        ).shift.last)
       end
 
-      def objectify(hash)
+      def create(attributes = {})
+        response = Wrest::UriTemplate.new(':host/:resource_collection_name.:format').to_uri(
+          :host => host,
+          :resource_collection_name => resource_collection_name,
+          :format => default_format
+        ).post(self.new(attributes).to_xml, 'Content-Type' => "application/#{default_format}")
+
+        self.new(response.deserialise.mutate_using(
+          Wrest::Components::Mutators.chain(:xml_mini_type_caster, :camel_to_snake_case)
+        ).shift.last)
       end
     end
   end

data/lib/wrest/uri.rb

@@ -11,10 +11,44 @@ module Wrest #:nodoc:
   # Wrest::Uri provides a simple api for
   # REST calls. String#to_uri is a convenience
   # method to build a Wrest::Uri from a string url.
+  # Note that a Wrest::Uri is immutable.
+  #
+  # Basic HTTP Authentication is supported.
+  # Example:
+  #  "http://kaiwren:fupuppies@coathangers.com/portal/1".to_uri
+  #  "http://coathangers.com/portal/1".to_uri(:username => 'kaiwren', :password => 'fupuppies')
+  # 
+  # The second form is preferred as it can handle passwords with special characters like ^ and @
+  #
+  # You can find examples that use real APIs (like delicious) under the wrest/examples directory.
   class Uri
-    attr_reader :uri
-    def initialize(uri_string)
+    attr_reader :uri, :username, :password
+    def initialize(uri_string, options = {})
+      @options = options
+      @uri_string = uri_string.clone
       @uri = URI.parse(uri_string)
+      @options = options
+      @username = (@options[:username] ||= @uri.user)
+      @password = (@options[:password] ||= @uri.password)
+    end
+    
+    # Build a new Wrest::Uri by appending _path_ to
+    # the current uri. If the original Wrest::Uri
+    # has a username and password, that will be
+    # copied to the new Wrest::Uri as well.
+    #
+    # Example:
+    #  uri = "https://localhost:3000/v1".to_uri
+    #  uri['/oogas/1'].get
+    #
+    # To change the username and password on the new
+    # instance, simply pass them as an options map.
+    #
+    # Example:
+    #  uri = "https://localhost:3000/v1".to_uri(:username => 'foo', :password => 'bar')
+    #  uri['/oogas/1', {:username => 'meh', :password => 'baz'}].get
+    def [](path, options = nil)
+      Uri.new(@uri_string+path, options || @options)
     end
     
     def eql?(other)
@@ -23,56 +57,74 @@ module Wrest #:nodoc:
     
     def ==(other)
       return false if other.class != self.class
-      return other.uri == self.uri
+      return other.uri == self.uri && self.username == other.username && self.password == other.password
     end
     
     def hash
-      self.uri.hash + 20090423
+      @uri.hash + @username.hash + @password.hash + 20090423
     end
     
-    # Make a HTTP get request to this URI.
-    # Remember to escape the parameter strings using URI.escape 
+    # Make a GET request to this URI. This is a convenience API
+    # that creates a Wrest::Http::Get, executes it and returns a Wrest::Http::Response.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
     def get(parameters = {}, headers = {})
-      do_request 'get', parameters.empty? ? @uri.request_uri : "#{@uri.request_uri}?#{parameters.to_query}", headers.stringify_keys
+      Http::Get.new(self, parameters, headers, @options).invoke
     end
 
-    def put(body = '', headers = {})
-      do_request 'put', @uri.request_uri, body.to_s, headers.stringify_keys
+    # Make a PUT request to this URI. This is a convenience API
+    # that creates a Wrest::Http::Put, executes it and returns a Wrest::Http::Response.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    def put(body = '', headers = {}, parameters = {})
+      Http::Put.new(self, body.to_s, headers, parameters, @options).invoke
     end
 
-    def post(body = '', headers = {})
-      do_request 'post', @uri.request_uri, body.to_s, headers.stringify_keys
+    # Makes a POST request to this URI. This is a convenience API
+    # that creates a Wrest::Http::Post, executes it and returns a Wrest::Http::Response.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    def post(body = '', headers = {}, parameters = {})
+      Http::Post.new(self, body.to_s, headers, parameters, @options).invoke
     end
 
+    # Makes a DELETE request to this URI. This is a convenience API
+    # that creates a Wrest::Http::Delete, executes it and returns a Wrest::Http::Response.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
     def delete(parameters = {}, headers = {})
-      do_request 'delete', parameters.empty? ? @uri.request_uri : "#{@uri.request_uri}?#{parameters.to_query}", headers.stringify_keys
+      Http::Delete.new(self, parameters, headers, @options).invoke
     end
 
+    # Makes an OPTIONS request to this URI. This is a convenience API
+    # that creates a Wrest::Http::Options, executes it and returns the Wrest::Http::Response.
     def options
-      do_request 'options', @uri.request_uri
+      Http::Options.new(self, @options).invoke
     end
-    
-    def do_request(method, url, *args)
-      response = nil
-
-      Wrest.logger.info "--> (#{method}) #{@uri.scheme}://#{@uri.host}:#{@uri.port}#{url}"
-      time = Benchmark.realtime { response = Wrest::Response.new(http.send(method, url, *args)) }
-      Wrest.logger.info "--> %d %s (%d %.2fs)" % [response.code, response.message, response.body ? response.body.length : 0, time]
 
-      response
-    end
-    
     def https?
       @uri.is_a?(URI::HTTPS)
     end
-
-    def http
-      http = Net::HTTP.new(@uri.host, @uri.port)
-      if https?
-        http.use_ssl     = true
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      end
-      http
+    
+    # Provides the full path of a request.
+    # For example, for
+    #  http://localhost:3000/demons/1/chi?sort=true
+    # this would return
+    #  /demons/1/chi?sort=true
+    def full_path
+      uri.request_uri
+    end
+    
+    def protocol
+      uri.scheme
+    end
+    
+    def host
+      uri.host
+    end
+    
+    def port
+      uri.port
     end
   end
 end

data/lib/wrest/uri_template.rb

@@ -19,9 +19,26 @@ module Wrest
     # the corressponding values.
     #
     # Example:
-    # template = UriTemplate.new("http://localhost:3000/:resource/:id.:format")
+    # template = UriTemplate.new("http://coathangers.com/:resource/:id.:format")
     # template.to_uri(:resource => 'shen_coins', :id => 5, :format => :json)
     # => #<Wrest::Uri:0x1225514 @uri=#<URI::HTTP:0x9127d8 URL:http://localhost:3000/shen_coins/5.json>>
+    #
+    # This feature can also be used to handle HTTP authentication where the username
+    # and password needs changing at runtime. However, this approach _will_ fail if
+    # the password contains characters like ^ and @.
+    #
+    # Note that beacuse because both HTTP Auth and UriTemplate
+    # use ':' as a delimiter, the pattern does look slightly weird, but it still works.
+    #
+    # Example:
+    # template = UriTemplate.new("http://:username::password@coathangers.com/:resource/:id.:format")
+    # template.to_uri(
+    #  :user => 'kaiwren',
+    #  :password => 'fupuppies',
+    #  :resource => 'portal',
+    #  :id => '1'
+    # )
+    #  => #<Wrest::Uri:0x18e0bec @uri=#<URI::HTTP:0x18e09a8 URL:http://kaiwren:fupuppies@coathangers.com/portal/1>>
     def to_uri(options = {})
       options.inject(uri_pattern.clone) do |uri_string, tuple| 
         key, value = tuple

data/lib/wrest/version.rb

@@ -12,7 +12,7 @@ module Wrest
     unless defined? MAJOR
       MAJOR  = 0
       MINOR  = 0
-      TINY   = 7
+      TINY   = 8
 
       STRING = [MAJOR, MINOR, TINY].join('.')
 

data/spec/wrest/components/attributes_container_spec.rb

@@ -179,6 +179,17 @@ module Wrest::Components
         @li_piao.id = 6
         @li_piao.id.should == 6
       end
+      
+      it "should provide getter and query methods to instance which has corresponding attribute" do
+        zotoh_zhaan = HumanBeing.new(:species => "Delvian")
+        zotoh_zhaan.species.should == "Delvian"
+        zotoh_zhaan.species?.should be_true
+        zotoh_zhaan.species = "Human"
+        lambda{@li_piao.species}.should raise_error(NoMethodError)
+        lambda{@li_piao.species?}.should raise_error(NoMethodError)
+        @li_piao.should_not respond_to(:species=)
+        @li_piao.methods.grep(/:species=/).should be_empty
+      end
     end
   end
 end

data/spec/wrest/core_ext/string/conversions_spec.rb

@@ -13,4 +13,13 @@ describe String, 'conversions' do
   it "should know how to convert a string to a Wrest::Uri" do
     'http://localhost:3000'.to_uri.should == Wrest::Uri.new('http://localhost:3000')
   end
+  
+  it "should accept username and password as options" do
+    uri = 'http://localhost:3000'.to_uri(
+      :username => 'ooga',
+      :password => 'booga'
+    )
+    uri.username.should == 'ooga'
+    uri.password.should == 'booga'
+  end
 end

data/spec/wrest/http/request_spec.rb

@@ -0,0 +1,22 @@
+# Copyright 2009 Sidu Ponnappa
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under the License.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Wrest::Http::Request do
+  it "should convert all symbols in header keys to strings" do
+    Wrest::Http::Request.new(
+                'http://localhost/foo'.to_uri, Net::HTTP::Get, {}, 
+                nil, 'Content-Type' => 'application/xml', :per_page => '10'
+                ).headers.should == {
+                  'Content-Type' => 'application/xml',
+                  'per_page' => '10'
+                }
+  end
+end

data/spec/wrest/{response_spec.rb → http/response_spec.rb}

@@ -1,18 +1,18 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 module Wrest
-  describe Response do
+  describe Http::Response do
     it "should know how to delegate to a translator" do
       http_response = mock('response')
       Components::Translators::Xml.should_receive(:deserialise).with(http_response)
-      Response.new(http_response).deserialise_using(Components::Translators::Xml)
+      Http::Response.new(http_response).deserialise_using(Components::Translators::Xml)
     end
 
     it "should know how to load a translator based on content type" do
       http_response = mock('response')
       http_response.should_receive(:content_type).and_return('application/xml')
 
-      response = Response.new(http_response)
+      response = Http::Response.new(http_response)
       response.should_receive(:deserialise_using).with(Components::Translators::Xml)
 
       response.deserialise

data/spec/wrest/resource/base_spec.rb

@@ -5,11 +5,12 @@ class Glassware < Wrest::Resource::Base
 end
 
 class BottledUniverse < Glassware
-  set_host "http://localhost:3001"
+  set_host            "http://localhost:3001"
+  set_default_format  :xml
 end
 
 module Wrest
-  describe Resource::Base do
+  describe Wrest::Resource::Base do
     it "should not affect other classes when setting up its macros" do
       Class.should_not respond_to(:host=)
       Object.should_not respond_to(:host=)
@@ -23,21 +24,80 @@ module Wrest
       before(:each) do
         @BottledUniverse = Class.new(Resource::Base)
         @BottledUniverse.class_eval do
-          set_resource_name 'BottledUniverse'
+          set_resource_name   'BottledUniverse'
+        end
+      end
+
+      describe 'equality' do
+        it "should be equal if it is the same instance" do
+          universe = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          (universe == universe).should be_true
+        end
+
+        it "should be equal if it has the same state" do
+          (
+          @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1) == @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          ).should be_true
+        end
+
+        it "should not be equal to nil" do
+          (@BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1) == nil).should be_false
+        end
+
+        it "should not be equal if it is not the same class" do
+          (
+          @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1) == Glassware.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          ).should be_false
+        end
+
+        it "should not be equal if it is has a different state" do
+          (
+          @BottledUniverse.new(:universe_id=>3, :name=>"Wooz", :id=>1) == @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          ).should be_false
+        end
+
+        it "should be symmetric" do
+          universe_one = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          universe_two = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          (universe_one == universe_one).should be_true
+          (universe_two == universe_two).should be_true
+        end
+
+        it "should be transitive" do
+          universe_one = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          universe_two = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          universe_three = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          (universe_one == universe_two).should be_true
+          (universe_two == universe_three).should be_true
+          (universe_one == universe_three).should be_true
+        end
+
+        it "should ensure that the hashcode is a fixnum" do
+          @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1).hash.should be_kind_of(Fixnum)
+        end
+
+        it "should ensure that instances with the same ids have the same hashcode" do
+          universe_one = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          universe_two = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          universe_one.hash.should == universe_two.hash
+        end
+
+        it "should ensure that instances with different ids have the different hashcodes" do
+          universe_one = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+          universe_two = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>2)
+          universe_one.hash.should_not == universe_two.hash
         end
       end
 
       it "should know its name as a resource by default" do
-        BottledUniverse.resource_name.should == 'BottledUniverse'
+        BottledUniverse.resource_name.should == 'bottled_universe'
       end
 
       it "should allow its name as a resource to be configured for anonymous classes" do
-        @BottledUniverse.resource_name.should == 'BottledUniverse'
+        @BottledUniverse.resource_name.should == 'bottled_universe'
       end
 
       it "should know how to create an instance using deserialised attributes" do
-        # Json => {"lead_bottle"=>{"name"=>"Wooz", "id"=>1, "universe_id"=>nil}}
-        # Xml =>  {"lead-bottle"=>[{"name"=>["Wooz"], "universe-id"=>[{"type"=>"integer", "nil"=>"true"}], "id"=>[{"type"=>"integer", "content"=>"1"}]}]}
         universe = @BottledUniverse.new "name"=>"Wooz", "id"=>'1', "universe_id"=>nil, 'owner_id'=>nil
         universe.name.should == "Wooz"
         universe.owner_id.should be_nil
@@ -69,8 +129,48 @@ module Wrest
         @BottledUniverse.host.should == "http://localhost:3000"
       end
 
-      it "should know its resource path" do
-        Glassware.resource_path.should == '/glasswares'
+      it "should know its resource collection name" do
+        Glassware.resource_collection_name.should == 'glasswares'
+      end
+
+      it "should know its uri template for find one" do
+        Glassware.find_one_uri_template.to_uri(
+          :host => 'http://localhost:3000', 
+          :resource_collection_name => 'glasswares',
+          :id => 1,
+          :format => 'json'
+        ).should == 'http://localhost:3000/glasswares/1.json'.to_uri
+      end
+
+      it "should know how to serialise itself to xml" do
+        BottledUniverse.new(:name => 'Foo').to_xml.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bottled-universe>\n  <name>Foo</name>\n</bottled-universe>\n"
+      end
+            
+      describe 'finders' do
+        # Json =>
+        #         body => {"lead_bottle": {"name": "Wooz", "id": 1, "universe_id": null}}
+        #         hash => {"lead_bottle"=>{"name"=>"Wooz", "id"=>1, "universe_id"=>nil}}
+        # Xml =>
+        #         body =>
+        #         <?xml version="1.0" encoding="UTF-8"?>
+        #         <lead-bottle>
+        #           <id type="integer">1</id>
+        #           <name>Wooz</name>
+        #           <universe-id type="integer" nil="true"></universe-id>
+        #         </lead-bottle>
+        #         hash =>
+        #         {"lead-bottle"=>{"name"=>{"__content__"=>"Wooz"}, "universe-id"=>{"type"=>"integer", "nil"=>"true"}, "id"=>{"__content__"=>"1", "type"=>"integer"}}}
+        #         typecast =>
+        #         {"lead_bottle"=>{"name"=>"Wooz", "id"=>1, "universe_id"=>nil}}
+        it "should know how to find a resource by id" do
+          uri = 'http://localhost:3001/bottled_universe/1.xml'.to_uri
+          Wrest::Uri.should_receive(:new).with('http://localhost:3001/bottled_universes/1.xml', {}).and_return(uri)
+          response = mock(Wrest::Http::Response)
+          uri.should_receive(:get).with(no_args).and_return(response)
+          response.should_receive(:deserialise).and_return({"bottled-universe"=>{"name"=>{"__content__"=>"Wooz"}, "universe-id"=>{"type"=>"integer", "nil"=>"true"}, "id"=>{"__content__"=>"1", "type"=>"integer"}}})
+
+          BottledUniverse.find(1).should == BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
+        end
       end
     end
 
@@ -80,8 +180,23 @@ module Wrest
         BottledUniverse.host.should == "http://localhost:3001"
       end
 
-      it "should know its resource path when it is a subclass of a subclass" do
-        BottledUniverse.resource_path.should == '/bottled_universes'
+      it "should know its resource collection name when it is a subclass of a subclass" do
+        BottledUniverse.resource_collection_name.should == 'bottled_universes'
+      end
+      
+      
+      it "should know how to create a new resource" do
+        uri = mock(Uri)
+        mock_http_response = mock(Net::HTTPResponse)
+        mock_http_response.stub!(:content_type).and_return('application/xml')
+        mock_http_response.stub!(:body).and_return("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bottled-universe>\n  <name>Woot</name>\n <id>1</id>\n </bottled-universe>\n")
+        
+        Uri.should_receive(:new).with("http://localhost:3001/bottled_universes.xml", {}).and_return(uri)
+        uri.should_receive(:post).with(
+                                      "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bottled-universe>\n  <name>Woot</name>\n</bottled-universe>\n", 
+                                      'Content-Type' => 'application/xml'
+                                      ).and_return(Wrest::Http::Response.new(mock_http_response))
+        ware = BottledUniverse.create(:name => 'Woot')
       end
     end