url_shortener 0.0.3 → 0.0.4

data/History.txt

@@ -13,3 +13,18 @@
 * 2 additions:
   * adds url stats functionality
   * adds url info functionality
+
+=== 0.0.4 2009-11-15
+
+* 4 additions:
+	* adds UrlShortener::Response
+	* adds UrlShortener::Response::Shorten
+	* adds UrlShortener::Response::Expand
+	* adds some convenience methods to the returned results for shortening and expanding urls
+
+* 3 changes:
+  * api call method UrlShortener::Client#shorten now returns a UrlShortener::Response::Shorten object
+  * api call method UrlShortener::Client#expand now returns a UrlShortener::Response::Expand object
+  * other api call methods now return a UrlShortener::Response object
+  These changes are introduced to return the api call results in a flexible manner and provide more flexibility for manipulating result output
+

data/Manifest.txt

@@ -6,10 +6,16 @@ lib/url_shortener/authorize.rb
 lib/url_shortener/client.rb
 lib/url_shortener/error.rb
 lib/url_shortener/interface.rb
+lib/url_shortener/response.rb
+lib/url_shortener/response/shorten.rb
+lib/url_shortener/response/expand.rb
 spec/spec_helper.rb
 spec/url_shortener/authorize_spec.rb
 spec/url_shortener/client_spec.rb
 spec/url_shortener/interface_spec.rb
+spec/url_shortener/response_spec.rb
+spec/url_shortener/response/shorten_spec.rb
+spec/url_shortener/response/expand_spec.rb
 features/request_failure.feature
 features/api_calls.feature
 features/support/env.rb

data/README.rdoc

@@ -1,55 +1,83 @@
 ==Description
 
-Url Shortener is a Ruby library / gem and API wrapper for bit.ly to shorten the urls.
+Url Shortener is a Ruby library / gem and API wrapper for bit.ly to shorten/expand the urls and retrieve other information about them.
 
 To use the url_shortener gem you need a bit.ly login and Api key.
 
 * If you are registered at bit.ly then you already have it.
 * If you are not registered then you can get it easily by registering at bit.ly as they give an api key to every registered user
 
+==INSTALL
+
+	gem sources -a http://gemcutter.org
+
+	sudo gem install url_shortener
+
+
 ==USAGE
 
+===Quick Start
+
+* Start an irb session
+
+	require 'rubygems'
+	
+	require 'url_shortener'
+
 ===To Shorten Urls
 
-* authorize = UrlShortener::Authorize.new 'your_bitly_login', 'your_bitly_api_key'
+	authorize = UrlShortener::Authorize.new 'your_bitly_login', 'your_bitly_api_key'
 
-* For example; authorize = UrlShortener::Authorize.new 'bitlyapidemo', 'R_0da49e0a9118ff35f52f629d2d71bf07'
+	For example; authorize = UrlShortener::Authorize.new 'bitlyapidemo', 'R_0da49e0a9118ff35f52f629d2d71bf07'
 
-* client = UrlShortener::Client.new authorize
+	client = UrlShortener::Client.new authorize
 
-* results = client.shorten('http://www.yahoo.com') # => Hash containing short url
+	shorten = client.shorten('http://www.yahoo.com') # => UrlShortener::Response::Shorten object
 
-* results['shortUrl'] # => short url string 
+	shorten.result # => returns a hash of all data returned from bitly
 
-OR 
+	shorten.urls # => Only returns the short urls
+	
+	look for more convenience methods in the UrlShortener::Response::Shorten class
+  
 
-* results = client.shorten('http://www.yahoo.com', 'http://www.google.com', 'http://github.com')
+	OR 
 
-* results.each {|result| puts result['shortUrl']}
+	shorten = client.shorten('http://www.yahoo.com', 'http://www.google.com', 'http://github.com')
 
-===To Expand Urls
+	shorten.result
+
+	shorten.urls
 
-* result = client.expand(:shortUrl => 'http://bit.ly/1RmnUT') # => long url string
+===To Expand Urls
 
-OR
+	expand = client.expand(:shortUrl => 'http://bit.ly/1RmnUT') # => UrlShortener::Response::Expand object
+	
+	OR
 
-* result = client.expand(:hash => '2bYgqR') # => long url string
+	expand = client.expand(:hash => '1RmnUT')
+	expand.result # => returns a hash of all data returned from bitly
+	expand.url # => returns a long url string
 
 ===To get stats
 
-* result = client.stats(:shortUrl => 'http://bit.ly/1RmnUT') # => long url string
-
-OR
+	stats = client.stats(:shortUrl => 'http://bit.ly/1RmnUT')  # => UrlShortener::Response object
+	
+	OR
 
-* result = client.stats(:hash => '2bYgqR') # => long url string
+	stats = client.stats(:hash => '1RmnUT') # => UrlShortener::Response object
+	stats.result # => returns a hash of all data returned from bitly
+	#TODO: ADD convenience methods for stats
 
 ===To get url info
 
-* result = client.info(:shortUrl => 'http://bit.ly/1RmnUT') # => long url string
-
-OR
+	info = client.info(:shortUrl => 'http://bit.ly/1RmnUT') # => UrlShortener::Response object
+	
+	OR
 
-* result = client.info(:hash => '2bYgqR') # => long url string
+	info = client.info(:hash => '1RmnUT') # => UrlShortener::Response object
+	info.result # => returns a hash of all data returned from bitly
+	#TODO: ADD convenience methods for info api call
 
 ==Docs
 

data/features/api_calls.feature

@@ -30,7 +30,7 @@ Feature: REST calls to bit.ly API
 		And "bit.ly" is online
 		When I submit a request to expand a short url using the hash "2oV4lu"
 		Then I should get the response from "bit.ly"
-		And the expanded url should be "http://www.github.com/nas"
+		And the expanded url should be "http://www.github.com/nas" for "2oV4lu"
 	
 	Scenario: Expand the short url when correct login and api key is present
 		Given I use "correct" "bit.ly" login name as "bitlyapidemo"
@@ -39,7 +39,7 @@ Feature: REST calls to bit.ly API
 		And "bit.ly" is online
 		When I submit a request to expand a short url using the short url "http://bit.ly/6NaDb"
 		Then I should get the response from "bit.ly"
-		And the expanded url should be "http://www.github.com/nas"
+		And the expanded url should be "http://www.github.com/nas" for "6NaDb"
 	
 	Scenario: Get stats from the hash when correct login and api key is present
 		Given I use "correct" "bit.ly" login name as "bitlyapidemo"

data/features/step_definitions/api_call_steps.rb

@@ -2,82 +2,76 @@
 # = When Steps =
 # ==============
 When /^I submit a request to shorten the url "([^\"]*)"$/ do |url|
-  @result = client.shorten(url)
+  @response = client.shorten(url)
 end
 
 When /^I submit a request to shorten the urls "([^\"]*)" and "([^\"]*)"$/ do |url1, url2|
-  @result = client.shorten(url1, url2)
+  @response = client.shorten(url1, url2)
 end
 
 
 When /^I submit a request to expand a short url using the hash "([^\"]*)"$/ do |hash|
-  @result = client.expand(:hash => hash)
+  @response = client.expand(:hash => hash)
 end
 
 When /^I submit a request to expand a short url using the short url "([^\"]*)"$/ do |short_url|
-  @result = client.expand(:shortUrl => short_url)
+  @response = client.expand(:shortUrl => short_url)
 end
 
 When /^I submit a request to get stats for a short url using the hash "([^\"]*)"$/ do |hash|
-  @result = client.stats(:hash => hash)
+  @response = client.stats(:hash => hash)
 end
 
 When /^I submit a request to get stats for a short url using the short url "([^\"]*)"$/ do |short_url|
-  @result = client.stats(:shortUrl => short_url)
+  @response = client.stats(:shortUrl => short_url)
 end
 
 When /^I submit a request to get info for a short url using the hash "([^\"]*)"$/ do |hash|
-  @result = client.info(:hash => hash)
+  @response = client.info(:hash => hash)
 end
 
 When /^I submit a request to get info for a short url using the short url "([^\"]*)"$/ do |short_url|
-  @result = client.info(:shortUrl => short_url)
+  @response = client.info(:shortUrl => short_url)
 end
 
 # ==============
 # = Then Steps =
 # ==============
 Then /^I should get the response from "([^\"]*)"$/ do |arg1|
-  @result.should_not be_nil
+  @response.should_not be_nil
 end
 
 Then /^the shorten url should be "([^\"]*)"$/ do |short_url|
-  @result['shortUrl'].should eql(short_url)
+  @response.urls.should eql(short_url)
 end
 
 Then /^the shorten url should be "([^\"]*)" and "([^\"]*)"$/ do |expanded_url1, expanded_url2|
-  @result.each do |res|
-    res['shortUrl'].should eql(expanded_url1) if res['nodeKey'] == 'http://www.github.com/nas'
-    res['shortUrl'].should eql(expanded_url2) if res['nodeKey'] == 'http://www.google.com'
-  end
+  @response.urls.should include(expanded_url1, expanded_url2)
 end
 
 Then /^the hash values should be "([^\"]*)" and "([^\"]*)"$/ do |hash1, hash2|
-  @result.each do |res|
-    res['hash'].should eql(hash1) if res['nodeKey'] == 'http://www.github.com/nas'
-    res['hash'].should eql(hash2) if res['nodeKey'] == 'http://www.google.com'
-  end
+  @response.hashes.should include(hash1, hash2)
 end
 
 
 Then /^the hash should be "([^\"]*)"$/ do |hash|
-  @result['hash'].should eql(hash)
+  @response.hashes.should eql(hash)
 end
 
-Then /^the expanded url should be "([^\"]*)"$/ do |expanded_url|
-  @result.should eql(expanded_url)
+Then /^the expanded url should be "([^\"]*)" for "([^\"]*)"$/ do |expanded_url, request_parameter|
+  @response.url.should eql(expanded_url)
 end
 
 Then /^the result should have "([^\"]*)" and "([^\"]*)" keys in the returned hash$/ do |key1,key2|
-  @result.keys.should include(key1, key2)
+  @response.result.keys.should include(key1, key2)
 end
 
 Then /^the result should have "([^\"]*)" key in the returned hash$/ do |key|
-  @result.keys.should include(key)
+  @response.result.keys.should include(key)
 end
 
 Then /^the result doc hash should have "([^\"]*)", "([^\"]*)", "([^\"]*)", etc keys$/ do |key1, key2, key3|
-  @result['doc'].keys.should include(key1, key2, key3)
+  @response.result['doc'].keys.should include(key1, key2, key3)
 end
 
 private

data/lib/url_shortener/client.rb

@@ -16,29 +16,30 @@ module UrlShortener
       # duplicate keys in a hash hence this solution
       urls.collect!{|url| CGI.escape(url)}
       end_point_with_params = "#{end_point('shorten')}?longUrl=#{urls.join('&longUrl=')}"
-      interface(end_point_with_params).get['nodeKeyVal']
+      response = interface(end_point_with_params).get
+      UrlShortener::Response::Shorten.new(response)
     end
     
     # Provide parameter as a key value pair of existing short url or its hash
     # e.g. expand :shortUrl => 'http://bit.ly/15DlK' OR :hash => '31IqMl'
     def expand(option)
       check_request_parameters(option)
-      /^.*\/(.*)$/.match option[:shortUrl] if option[:shortUrl]
-      request_param = option[:hash] ? option[:hash] : $1
-      result = interface(nil, {:rest_url => end_point('expand')}.merge(option)).get[request_param]
-      return result['longUrl'] if result
+      response = interface(nil, endpoint_with_options('expand',option)).get
+      UrlShortener::Response::Expand.new(response)
     end
     
     # Provide parameter as a key value pair of existing short url or its hash
     # e.g. stats :shortUrl => 'http://bit.ly/15DlK' #OR :hash => '31IqMl'
     def stats(option)
       check_request_parameters(option)
-      interface(nil, {:rest_url => end_point('stats')}.merge(option)).get
+      response = interface(nil, endpoint_with_options('stats',option)).get
+      UrlShortener::Response.new(response)
     end
     
     def info(option)
       check_request_parameters(option)
-      interface(nil, {:rest_url => end_point('info')}.merge(option)).get
+      response = interface(nil, endpoint_with_options('info',option)).get
+      UrlShortener::Response.new(response)
     end
     
     # If a complex url need to be passed then use end_point_with_params else
@@ -69,6 +70,10 @@ module UrlShortener
     
     private
     
+    def endpoint_with_options(resource, option)
+      {:rest_url => end_point(resource)}.merge(option)
+    end
+    
     def check_request_parameters(option)
       unless (option[:hash] || option[:shortUrl])
         raise UrlShortener::IncompleteRequestParameter, "Either hash or the shorUrl is required to complete the operation."

data/lib/url_shortener/error.rb

@@ -16,7 +16,7 @@ module UrlShortener
   class NoResult < Error
   end
   
-  class UrlShortener::IncompleteRequestParameter < Error
+  class IncompleteRequestParameter < Error
     
   end
 end

data/lib/url_shortener/response/expand.rb

@@ -0,0 +1,28 @@
+module UrlShortener
+  
+  class Response::Expand < UrlShortener::Response
+    
+    def initialize(response)
+      super
+    end
+    
+    def url
+      return unless result_present?
+      return unless key_present?
+      url_hash = result.keys.first
+      result[url_hash]['longUrl']
+    end
+    
+    private
+    
+    def result_present?
+      result && !result.empty?
+    end
+    
+    def key_present?
+      result_present?
+      result.keys && !result.keys.empty?
+    end
+  end
+  
+end

data/lib/url_shortener/response/shorten.rb

@@ -0,0 +1,55 @@
+module UrlShortener
+  class Response::Shorten < UrlShortener::Response
+    
+    def initialize(response)
+      super
+    end
+    
+    def urls
+      raise_if_no_result
+      return result['nodeKeyVal']['shortUrl'] unless result['nodeKeyVal'].is_a?(Array)
+      result['nodeKeyVal'].collect{|res| res['shortUrl']}
+    end
+    
+    def urls_with_long_url_keys
+      raise_if_no_result
+      return_single_or_mutiple_hash_values('shortUrl')
+    end
+    
+    def hashes
+      raise_if_no_result
+      return result['nodeKeyVal']['hash'] unless result['nodeKeyVal'].is_a?(Array)
+      result['nodeKeyVal'].collect{|res| res['hash']}
+    end
+    
+    def hashes_with_long_url_keys
+      raise_if_no_result
+      return_single_or_mutiple_hash_values('hash')
+    end
+    
+    private
+    
+    def return_single_or_mutiple_hash_values(value)
+      return long_url_with_result(value) unless result['nodeKeyVal'].is_a?(Array)
+      return array_of_long_url_with_result(value)
+    end
+    
+    def long_url_with_result(value)
+      hash = {}
+      hash[result['nodeKeyVal']['nodeKey']] = result['nodeKeyVal'][value]
+      return hash
+    end
+    
+    def array_of_long_url_with_result(value)
+      hash = {}
+      result['nodeKeyVal'].collect{|res| hash[res['nodeKey']] = res[value]}
+      return hash
+    end
+    
+    def raise_if_no_result
+      if result.nil? || result['nodeKeyVal'].nil?
+        raise UrlShortener::NoResult, "Empty Result set."
+      end
+    end
+  end
+end

data/lib/url_shortener/response.rb

@@ -0,0 +1,11 @@
+module UrlShortener
+  class Response
+    
+    attr_reader :result
+    
+    def initialize(result)
+      @result = result
+    end
+    
+  end
+end

data/lib/url_shortener.rb

@@ -7,4 +7,7 @@ require 'cgi'
 require 'url_shortener/error.rb'
 require 'url_shortener/authorize.rb'
 require 'url_shortener/client.rb'
-require 'url_shortener/interface.rb'
+require 'url_shortener/interface.rb'
+require 'url_shortener/response.rb'
+require 'url_shortener/response/shorten.rb'
+require 'url_shortener/response/expand.rb'

data/spec/url_shortener/client_spec.rb

@@ -115,6 +115,10 @@ describe UrlShortener::Client do
         @interface.should_receive(:get)
         @client.shorten(@url)
       end
+      
+      it "should return the UrlShortener::Response::Shorten object" do
+        @client.shorten(@url).should be_instance_of(UrlShortener::Response::Shorten)
+      end
 
     end
     
@@ -218,12 +222,16 @@ describe UrlShortener::Client do
       
       it "should return the long url of the hash provided" do
         @interface.should_receive(:get).and_return('qweWE' => {'longUrl' => 'http://www.goog.com'})
-        @client.expand(:hash => @hash).should eql('http://www.goog.com')
+        @client.expand(:hash => @hash).result['qweWE'].values.should include('http://www.goog.com')
       end
       
       it "should return the long url for the shortUrl provided" do
         @interface.should_receive(:get).and_return('wesSD' => {'longUrl' => 'http://www.goog.com'})
-        @client.expand(:shortUrl => @short_url).should eql('http://www.goog.com')
+        @client.expand(:shortUrl => @short_url).result['wesSD'].values.should include('http://www.goog.com')
+      end
+      
+      it "should return the UrlShortener::Response::Expand object" do
+        @client.expand(:hash => @hash).should be_instance_of(UrlShortener::Response::Expand)
       end
       
     end

data/spec/url_shortener/response/expand_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe UrlShortener::Response::Expand do
+  
+  describe "#url" do
+    before(:each) do
+      @result_hash = {"1RmnUT" => {"longUrl" => "http://google.com"}}
+      @expand = UrlShortener::Response::Expand.new(@result_hash)
+      @expand.stub!(:result).and_return(@result_hash)
+      @keys = ['1RmnUT']
+      @key = '1RmnUT'
+      @result_hash.stub!(:keys).and_return(@keys)
+      @keys.stub!(:first).and_return(@key)
+      @expand.stub!(:result_present?).and_return(true)
+      @expand.stub!(:key_present?).and_return(true)
+    end
+    
+    it "should check if keys are present when results are present" do
+      @expand.stub!(:result_present?).and_return(true)
+      @expand.should_receive(:key_present?)
+      @expand.url.should
+    end
+    
+    it "should not check if keys are present when results are not present" do
+      @expand.stub!(:result_present?).and_return(false)
+      @expand.should_receive(:key_present?).never
+      @expand.url.should
+    end
+    
+    it "should return nil if there are no keys" do
+      @expand.stub!(:key_present?).and_return(nil)
+      @expand.url.should eql(nil)
+    end
+    
+    it "should check if results are present" do
+      @expand.should_receive(:result_present?)
+      @expand.url.should
+    end
+    
+    it "should return nil is result is not present" do
+      @expand.stub!(:result_present?).and_return(nil)
+      @expand.url.should eql(nil)
+    end
+    
+    it "should get the result" do
+      @expand.should_receive(:result).and_return(@result_hash)
+      @expand.url
+    end
+    
+    it "should find the keys in the result returned from bitley" do
+      @result_hash.should_receive(:keys).and_return(@keys)
+      @expand.url
+    end
+    
+    it "should get first key as there will be only key returning from bitly" do
+      @keys.should_receive(:first).and_return(@key)
+      @expand.url
+    end
+    
+    it "should return the longUrl" do
+      @expand.url.should eql("http://google.com")
+    end
+  end
+end

data/spec/url_shortener/response/shorten_spec.rb

@@ -0,0 +1,278 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe UrlShortener::Response::Shorten do
+  
+  describe "#urls" do
+    before(:each) do
+      @response = {'nodeKeyVal' => {'shortUrl' => 'http://a/short/url'}}
+      @shorten_response = UrlShortener::Response::Shorten.new(@response)
+      @shorten_response.stub!(:result).and_return(@response)
+    end
+    
+    it "should get the result" do
+      @shorten_response.should_receive(:result).at_least(1).and_return(@response)
+      @shorten_response.urls
+    end
+    
+    it "should check whether result's nodeKeyVal values is an array" do
+      @response['nodeKeyVal'].should_receive(:is_a?).with(Array)
+      @shorten_response.urls
+    end
+    
+    it "should raise when there are no results" do
+      @shorten_response.should_receive(:raise_if_no_result)
+      @shorten_response.urls
+    end
+    
+    describe "when no results are returned" do
+      before(:each) do
+        @response = {}
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+      end
+      
+      it "should raise error if there is no 'nodeKeyVal' key in the response parameter" do
+        lambda { @shorten_response.urls }.should raise_error(UrlShortener::NoResult, "Empty Result set.")
+      end
+      
+      it "should raise error when if the response parameter  or result is empty?" do
+        @response = nil
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+        lambda { @shorten_response.urls }.should raise_error(UrlShortener::NoResult, "Empty Result set.")      
+      end
+    end
+    
+    describe "when returned result is not an array" do
+      before(:each) do
+        @response['nodeKeyVal'].stub!(:is_a?).and_return(false)
+      end
+      
+      it "should return the short url" do
+        @shorten_response.urls.should eql('http://a/short/url')
+      end
+      
+    end
+    
+    describe "when returned result is an array" do
+      before(:each) do
+        @response = {'nodeKeyVal' => [{'shortUrl' => 'http://a/short/url'}, {'shortUrl' => 'http://another/short/url'}]}
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+        @shorten_response.stub!(:result).and_return(@response)
+      end
+      
+      it "should return an array of short urls" do
+        @shorten_response.urls.should include('http://a/short/url', 'http://another/short/url')
+      end
+      
+    end
+    
+  end
+  
+  describe "#urls with long url keys" do
+    before(:each) do
+      @response = {'nodeKeyVal' => {'shortUrl' => 'http://a/short/url', 'nodeKey' => 'http://a/long/url'}}
+      @shorten_response = UrlShortener::Response::Shorten.new(@response)
+      @shorten_response.stub!(:result).and_return(@response)
+    end
+    
+    describe "when no results are returned" do
+      before(:each) do
+        @response = {}
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+      end
+      
+      it "should raise error if there is no 'nodeKeyVal' key in the response parameter" do
+        lambda { @shorten_response.urls_with_long_url_keys }.should raise_error(UrlShortener::NoResult, "Empty Result set.")
+      end
+      
+      it "should raise error when if the response parameter  or result is empty?" do
+        @response = nil
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+        lambda { @shorten_response.urls_with_long_url_keys }.should raise_error(UrlShortener::NoResult, "Empty Result set.")      
+      end
+    end
+    
+    describe "when returned result is not an array" do
+      before(:each) do
+        @response['nodeKeyVal'].stub!(:is_a?).and_return(false)
+      end
+      
+      it "should return the long url as the hash key" do
+        @shorten_response.urls_with_long_url_keys.keys.should include('http://a/long/url')
+      end
+      
+      it "should return the short url as the hash value" do
+        @shorten_response.urls_with_long_url_keys.values.should include('http://a/short/url')
+      end
+      
+    end
+    
+    describe "when returned result is an array" do
+      before(:each) do
+        @response = {'nodeKeyVal' => [{'shortUrl' => 'http://a1/short/url', 'nodeKey' => 'http://a1/long/url'}, 
+                                      {'shortUrl' => 'http://a2/short/url', 'nodeKey' => 'http://a2/long/url'}]}
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+        @shorten_response.stub!(:result).and_return(@response)
+      end
+
+      it "should return long urls as keys" do
+        @shorten_response.urls_with_long_url_keys.keys.should include('http://a1/long/url', 'http://a2/long/url')
+      end
+      
+      it "should return short urls as values" do
+        @shorten_response.urls_with_long_url_keys.values.should include('http://a1/short/url', 'http://a2/short/url')
+      end
+      
+      it "should have the first long url key value set to the first short url" do
+        @shorten_response.urls_with_long_url_keys['http://a1/long/url'].should eql('http://a1/short/url')
+      end
+      
+      it "should have the second long url key value set to the second short url" do
+        @shorten_response.urls_with_long_url_keys['http://a2/long/url'].should eql('http://a2/short/url')
+      end
+      
+      it "should only have two keys values when two short urls are returned" do
+        @shorten_response.urls_with_long_url_keys.size.should eql(2)
+      end
+
+    end
+    
+  end
+  
+  describe "#hashes" do
+
+    before(:each) do
+      @response = {'nodeKeyVal' => {'hash' => 'aHash'}}
+      @shorten_response = UrlShortener::Response::Shorten.new(@response)
+      @shorten_response.stub!(:result).and_return(@response)
+    end
+
+    it "should get the result" do
+      @shorten_response.should_receive(:result).at_least(1).and_return(@response)
+      @shorten_response.hashes
+    end
+
+    it "should check whether result's nodeKeyVal values is an array" do
+      @response['nodeKeyVal'].should_receive(:is_a?).with(Array)
+      @shorten_response.hashes
+    end
+
+    it "should raise when there are no results" do
+      @shorten_response.should_receive(:raise_if_no_result)
+      @shorten_response.hashes
+    end
+      
+    describe "when no results are returned" do
+      before(:each) do
+        @response = {}
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+      end
+      
+      it "should raise error if there is no 'nodeKeyVal' key in the response parameter" do
+        lambda { @shorten_response.hashes }.should raise_error(UrlShortener::NoResult, "Empty Result set.")
+      end
+    
+      it "should raise error when if the response parameter  or result is empty?" do
+        @response = nil
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+        lambda { @shorten_response.hashes }.should raise_error(UrlShortener::NoResult, "Empty Result set.")      
+      end
+    end
+    
+    describe "when returned result is not an array" do
+      before(:each) do
+        @response['nodeKeyVal'].stub!(:is_a?).and_return(false)
+      end
+      
+      it "should return the short url" do
+        @shorten_response.hashes.should eql('aHash')
+      end
+      
+    end
+    
+    describe "when returned result is an array" do
+      before(:each) do
+        @response = {'nodeKeyVal' => [{'hash' => 'aHash'}, {'hash' => 'anHash'}]}
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+        @shorten_response.stub!(:result).and_return(@response)
+      end
+      
+      it "should return an array of hashes" do
+        @shorten_response.hashes.should include('aHash', 'anHash')
+      end
+      
+    end
+    
+  end
+  
+  describe "#hashes with long url keys" do
+    before(:each) do
+      @response = {'nodeKeyVal' => {'hash' => 'aHash', 'nodeKey' => 'http://a/long/url'}}
+      @shorten_response = UrlShortener::Response::Shorten.new(@response)
+      @shorten_response.stub!(:result).and_return(@response)
+    end
+    
+    describe "when no results are returned" do
+      before(:each) do
+        @response = {}
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+      end
+      
+      it "should raise error if there is no 'nodeKeyVal' key in the response parameter" do
+        lambda { @shorten_response.hashes_with_long_url_keys }.should raise_error(UrlShortener::NoResult, "Empty Result set.")
+      end
+      
+      it "should raise error when if the response parameter  or result is empty?" do
+        @response = nil
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+        lambda { @shorten_response.hashes_with_long_url_keys }.should raise_error(UrlShortener::NoResult, "Empty Result set.")      
+      end
+    end
+    
+    describe "when returned result is not an array" do
+      before(:each) do
+        @response['nodeKeyVal'].stub!(:is_a?).and_return(false)
+      end
+      
+      it "should return the long url as the hash key" do
+        @shorten_response.hashes_with_long_url_keys.keys.should include('http://a/long/url')
+      end
+      
+      it "should return the short url as the hash value" do
+        @shorten_response.hashes_with_long_url_keys.values.should include('aHash')
+      end
+      
+    end
+    
+    describe "when returned result is an array" do
+      before(:each) do
+        @response = {'nodeKeyVal' => [{'hash' => 'a1Hash', 'nodeKey' => 'http://a1/long/url'}, 
+                                      {'hash' => 'a2Hash', 'nodeKey' => 'http://a2/long/url'}]}
+        @shorten_response = UrlShortener::Response::Shorten.new(@response)
+        @shorten_response.stub!(:result).and_return(@response)
+      end
+
+      it "should return long urls as keys" do
+        @shorten_response.hashes_with_long_url_keys.keys.should include('http://a1/long/url', 'http://a2/long/url')
+      end
+      
+      it "should return hashes as values" do
+        @shorten_response.hashes_with_long_url_keys.values.should include('a1Hash', 'a2Hash')
+      end
+      
+      it "should have the first long url key value set to the first hash value" do
+        @shorten_response.hashes_with_long_url_keys['http://a1/long/url'].should eql('a1Hash')
+      end
+      
+      it "should have the second long url key value set to the second hash value" do
+        @shorten_response.hashes_with_long_url_keys['http://a2/long/url'].should eql('a2Hash')
+      end
+      
+      it "should only have two keys values when two short urls are returned" do
+        @shorten_response.hashes_with_long_url_keys.size.should eql(2)
+      end
+
+    end
+    
+  end
+  
+end

data/spec/url_shortener/response_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe UrlShortener::Response do
+  
+  describe ".new" do
+    before(:each) do
+      @response = {:a_key => 'value'}
+    end
+    
+    it "should set the result attribute" do
+      response = UrlShortener::Response.new(@response)
+      response.result.should eql(@response)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: url_shortener
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Nasir Jamal
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-10 00:00:00 +00:00
+date: 2009-11-15 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.4.5
     version: 
-description: Url Shortener is a Ruby library / gem and API wrapper for bit.ly to shorten, expand urls and other APIs.
+description: Url Shortener is a Ruby library / gem and API wrapper for bit.ly to shorten/expand the urls and retrieve other information about them.
 email: nas35_in@yahoo.com
 executables: []
 
@@ -39,6 +39,9 @@ files:
 - lib/url_shortener/client.rb
 - lib/url_shortener/error.rb
 - lib/url_shortener/interface.rb
+- lib/url_shortener/response.rb
+- lib/url_shortener/response/shorten.rb
+- lib/url_shortener/response/expand.rb
 has_rdoc: true
 homepage: http://github.com/nas/url_shortener
 licenses: []
@@ -72,6 +75,9 @@ test_files:
 - spec/url_shortener/authorize_spec.rb
 - spec/url_shortener/client_spec.rb
 - spec/url_shortener/interface_spec.rb
+- spec/url_shortener/response_spec.rb
+- spec/url_shortener/response/shorten_spec.rb
+- spec/url_shortener/response/expand_spec.rb
 - features/api_calls.feature
 - features/request_failure.feature
 - features/support/env.rb