bitly4r 0.1.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+= 0.1.0
+
+	* Initial gem release of 0.1 coebase.

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Dan Foley / CantRemember.com
+
+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.rdoc

@@ -0,0 +1,67 @@
+= Bitly4R
+
+A Ruby API for the http://bit.ly URL-shortening service
+
+== SimpleClient
+
+This example uses a simpler construction and invocation technique.
+For when you just need the URLs, and not any additional data.
+
+   require 'rubygems'
+   require 'bitly4r'
+
+   login, api_key = 'bitlyapidemo', 'R_0da49e0a9118ff35f52f629d2d71bf07'
+   long_url = 'http://rubyforge.org/'
+
+   client = Bitly4R.Keyed(login, api_key)
+
+   # shorten
+   short_url = client.shorten(long_url)
+
+   # re-expand
+   raise 'what the?' unless (long_url == client.expand(short_url))
+
+== Client
+
+This example uses a full-fledged construction and invocation technique.
+The URLs are returned by the <tt>to_s</tt> methods of the Response objects, and additional data is made available.
+
+   require 'rubygems'
+   require 'bitly4r'
+
+   login, api_key = 'bitlyapidemo', 'R_0da49e0a9118ff35f52f629d2d71bf07'
+   long_url = 'http://rubyforge.org/'
+
+   client = Bitly4R::Client.new(:login => login, :api_key => api_key)
+
+   # shorten
+   short_url = client.shorten(long_url).to_s
+
+   # re-expand
+   raise 'aww, cmon!' unless (long_url == client.expand(short_url).to_s)
+
+== Support
+
+This gem supports the following API commands:
+
+* shorten
+* expand
+* info
+* stats
+* errors
+
+For more information, see the API documentation:
+
+* http://code.google.com/p/bitly-api/wiki/ApiDocumentation
+
+== Contributing
+
+=== Issue Tracking and Feature Requests
+
+* http://bitly4r.rubyforge.org
+
+== Community
+
+=== Wiki
+
+* http://wiki.cantremember.com/Bitly4R

data/Rakefile

@@ -0,0 +1,162 @@
+require 'rubygems'
+require 'rake/clean'
+require 'fileutils'
+
+task :default => :test
+
+# SPECS ===============================================================
+
+desc 'Run specs with story style output'
+task :spec do
+  sh 'specrb --specdox -Ilib:test test/*_test.rb'
+end
+
+desc 'Run specs with unit test style output'
+task :test => FileList['test/*_test.rb'] do |t|
+  suite = t.prerequisites.map{|f| "-r#{f.chomp('.rb')}"}.join(' ')
+  sh "ruby -Ilib:test #{suite} -e ''", :verbose => false
+end
+
+# PACKAGING ============================================================
+
+# Load the gemspec using the same limitations as github
+def spec
+  @spec ||=
+    begin
+      require 'rubygems/specification'
+      data = File.read('sinatra.gemspec')
+      spec = nil
+      Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+      spec
+    end
+end
+
+def package(ext='')
+  "dist/sinatra-#{spec.version}" + ext
+end
+
+desc 'Build packages'
+task :package => %w[.gem .tar.gz].map {|e| package(e)}
+
+desc 'Build and install as local gem'
+task :install => package('.gem') do
+  sh "gem install #{package('.gem')}"
+end
+
+directory 'dist/'
+
+file package('.gem') => %w[dist/ sinatra.gemspec] + spec.files do |f|
+  sh "gem build sinatra.gemspec"
+  mv File.basename(f.name), f.name
+end
+
+file package('.tar.gz') => %w[dist/] + spec.files do |f|
+  sh "git archive --format=tar HEAD | gzip > #{f.name}"
+end
+
+# Rubyforge Release / Publish Tasks ==================================
+
+desc 'Publish website to rubyforge'
+task 'publish:doc' => 'doc/api/index.html' do
+  sh 'scp -rp doc/* rubyforge.org:/var/www/gforge-projects/sinatra/'
+end
+
+task 'publish:gem' => [package('.gem'), package('.tar.gz')] do |t|
+  sh <<-end
+    rubyforge add_release sinatra sinatra #{spec.version} #{package('.gem')} &&
+    rubyforge add_file    sinatra sinatra #{spec.version} #{package('.tar.gz')}
+  end
+end
+
+# Website ============================================================
+# Building docs requires HAML and the hanna gem:
+#   gem install mislav-hanna --source=http://gems.github.com
+
+task 'doc'     => ['doc:api','doc:site']
+
+desc 'Generate Hanna RDoc under doc/api'
+task 'doc:api' => ['doc/api/index.html']
+
+file 'doc/api/index.html' => FileList['lib/**/*.rb','README.rdoc'] do |f|
+  rb_files = f.prerequisites
+  sh((<<-end).gsub(/\s+/, ' '))
+    hanna --charset utf8 \
+          --fmt html \
+          --inline-source \
+          --line-numbers \
+          --main README.rdoc \
+          --op doc/api \
+          --title 'Sinatra API Documentation' \
+          #{rb_files.join(' ')}
+  end
+end
+CLEAN.include 'doc/api'
+
+def rdoc_to_html(file_name)
+  require 'rdoc/markup/to_html'
+  rdoc = RDoc::Markup::ToHtml.new
+  rdoc.convert(File.read(file_name))
+end
+
+def haml(locals={})
+  require 'haml'
+  template = File.read('doc/template.haml')
+  haml = Haml::Engine.new(template, :format => :html4, :attr_wrapper => '"')
+  haml.render(Object.new, locals)
+end
+
+desc 'Build website HTML and stuff'
+task 'doc:site' => ['doc/index.html', 'doc/book.html']
+
+file 'doc/index.html' => %w[README.rdoc doc/template.haml] do |file|
+  File.open(file.name, 'w') do |file|
+    file << haml(:title => 'Sinatra', :content => rdoc_to_html('README.rdoc'))
+  end
+end
+CLEAN.include 'doc/index.html'
+
+file 'doc/book.html' => ['book/output/sinatra-book.html'] do |file|
+  File.open(file.name, 'w') do |file|
+    book_content = File.read('book/output/sinatra-book.html')
+    file << haml(:title => 'Sinatra Book', :content => book_content)
+  end
+end
+CLEAN.include 'doc/book.html'
+
+file 'book/output/sinatra-book.html' => FileList['book/**'] do |f|
+  unless File.directory?('book')
+    sh 'git clone git://github.com/cschneid/sinatra-book.git book'
+  end
+  sh((<<-SH).strip.gsub(/\s+/, ' '))
+    cd book &&
+    git fetch origin &&
+    git rebase origin/master &&
+    thor book:build
+  SH
+end
+CLEAN.include 'book/output/sinatra-book.html'
+
+desc 'Build the Sinatra book'
+task 'doc:book' => ['book/output/sinatra-book.html']
+
+# Gemspec Helpers ====================================================
+
+file 'sinatra.gemspec' => FileList['{lib,test,images}/**','Rakefile'] do |f|
+  # read spec file and split out manifest section
+  spec = File.read(f.name)
+  parts = spec.split("  # = MANIFEST =\n")
+  fail 'bad spec' if parts.length != 3
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject{ |file| file =~ /^\./ }.
+    reject { |file| file =~ /^doc/ }.
+    map{ |file| "    #{file}" }.
+    join("\n")
+  # piece file back together and write...
+  parts[1] = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = parts.join("  # = MANIFEST =\n")
+  File.open(f.name, 'w') { |io| io.write(spec) }
+  puts "updated #{f.name}"
+end

data/lib/bitly4r.rb

@@ -0,0 +1,20 @@
+#Requires all the individual Bitly4R components, in the proper sequence.
+#That makes the use of this gem as easy as:
+#
+#   require 'bitly4r'
+#
+#See:
+#* Bitly4R::Client
+#--
+
+#	external
+%w{ net/http cgi }.each {|lib| require lib }
+
+#	internal, and in the proper sequence
+%w{
+	bitly4r/objects
+	bitly4r/client
+	bitly4r/definitions
+}.each do |file|
+	require File.expand_path(File.join(File.dirname(__FILE__), file))
+end

data/lib/bitly4r/client.rb

@@ -0,0 +1,211 @@
+#Client objects for Bitly4R.
+#
+#See:
+#* Bitly4R::Client
+#* Bitly4R::SimpleClient
+
+module Bitly4R
+	#= Client
+	#
+	#A client object for accessing the bit.ly API.
+	#
+	#* Supports both API key and HTTP Auth credentials (although HTTP Auth / password-based doesn't seem to work)
+	#* Works with version 2.0.1 of the API
+	#* Uses XML for marshalling, for cheap & easy text parsing.
+	#
+	#See the API documentation:
+	#* http://code.google.com/p/bitly-api/wiki/ApiDocumentation
+	#* http://bit.ly
+	class Client
+		#:nodoc:
+		BASE_PARAMS = Params.new
+		BASE_PARAMS[:version] = '2.0.1'
+		BASE_PARAMS[:format] = 'xml'
+
+		#The login credential provided at construction.
+		attr_reader :login
+		#The password credential provided at construction.
+		attr_reader :password
+		#The API key credential provided at construction.
+		attr_reader :api_key
+
+		#Constructs a new client.
+		#
+		#Any tuples provided in the optional Hash are injected into instance variables.
+		#
+		#You must provide a login, and either an API key (<tt>api_key</tt>) or a password.
+		def initialize(ops={})
+			#	for the readers
+			#	not necessary, but polite
+			ops.each do |k, v|
+				instance_variable_set "@#{k}".to_sym, v
+			end
+
+			raise Error.new("you must provide a login") unless self.login
+			raise Error.new("you must provide either an API key or a password") unless (self.api_key or self.password)
+
+			#	now, a client-izec set of parameters
+			@client_params = BASE_PARAMS.clone.merge(ops)
+		end
+
+
+		#Invokes the API's <b>shorten</b> method.
+		#That's pretty much what makes bit.ly a valuable service.
+		#
+		#A Response is returned.
+		#Response.to_s will return the <tt>shortUrl</tt> / <tt>short_url</tt> value.
+		#
+		#You can take the shortened URL and re- expand it.
+		def shorten(long_url)
+			return nil unless long_url
+			assert_codes(execute(:shorten, :short_url) do |params|
+				params[:longUrl] = long_url
+			end)
+		end
+
+		#Invokes the API's <b>expand</b> method.
+		#It reverses a shorten; the original full URL is re-hydrated.
+		#
+		#For <i>param</i>, you can provide a previously-shortened URL from the bit.ly service.
+		#If so, you do not need to provide <i>param_type</i> (though <tt>:short_url</tt> would be the proper symbol).
+		#
+		#Alternately, you can provide a hash code returned by the bit.ly service.
+		#In this case, provide <tt>:hash</tt> as the <i>param_type</i>.
+		#
+		#A Response is returned.
+		#Response.to_s will return the <tt>longUrl</tt> / <tt>long_url</tt> value.
+		def expand(param, param_type=:short_url)
+			return nil unless param && param_type
+			assert_codes(execute(:expand, :long_url) do |params|
+				params[Utility::camelize(param_type).to_sym] = param
+			end)
+		end
+
+		#Invokes the API's <b>info</b> method.
+		#Information about the shortened URL is returned by the service.
+		#
+		#For <i>param</i>, you can provide a previously-shortened URL from the bit.ly service.
+		#If so, you do not need to provide <i>param_type</i> (though <tt>:short_url</tt> would be the proper symbol).
+		#
+		#Alternately, you can provide a hash code returned by the bit.ly service.
+		#In this case, provide <tt>:hash</tt> as the <i>param_type</i>.
+		#
+		#You can optionally provide an arbitrary Hash of HTTP parameters.
+		#The one that bit.ly cares about is called <tt>:key</tt>.
+		#It should be an array of camel-cased or underscored element names which you would like to receive.
+		#In theory, this should limit the response content, but I haven't seen that work yet.
+		#The arbitrary Hash capability is left intact for future re-purposing.
+		#
+		#A Response is returned.
+		#Response.to_s will return the <tt>longUrl</tt> / <tt>long_url</tt> value.
+		#
+		#There is plenty of other data in the response besides the original full URL.
+		#Feel free to access the Response.body and use Response.method_missing to pull out specific element values.
+		def info(param, param_type=:short_url, ops={})
+			return nil unless param_type && param
+			assert_codes(execute(:info, :long_url) do |params|
+				params[Utility::camelize(param_type).to_sym] = param
+
+				#	optional keys
+				if (keys = ops[:keys])
+					keys = [keys] unless Array === keys
+					params[:keys] = (keys.inject([]) do |a, key|
+						a << Utility::camelize(key)
+						a
+					end).join(',')
+				end
+			end)
+		end
+
+		#Invokes the API's <b>stats</b> method.
+		#Statistics about the shortened URL are returned by the service.
+		#
+		#For <i>param</i>, you can provide a previously-shortened URL from the bit.ly service.
+		#If so, you do not need to provide <i>param_type</i> (though <tt>:short_url</tt> would be the proper symbol).
+		#
+		#Alternately, you can provide a hash code returned by the bit.ly service.
+		#In this case, provide <tt>:hash</tt> as the <i>param_type</i>.
+		#
+		#A Response is returned.
+		#Response.to_s will return the <tt>longUrl</tt> / <tt>long_url</tt> value.
+		#
+		#There is plenty of other data in the response besides the original full URL.
+		#Feel free to access the Response.body and use Response.method_missing to pull out specific element values.
+		def stats(param, param_type=:short_url)
+			return nil unless param_type && param
+			assert_codes(execute(:info, :long_url) do |params|
+				params[Utility::camelize(param_type).to_sym] = param
+			end)
+		end
+
+		def errors
+			execute(:errors)
+		end
+
+
+
+		#	- - - - -
+		protected
+
+		def execute(command, to_s_sym=nil) #:nodoc:
+			#http://api.bit.ly/shorten?version=2.0.1&longUrl=http://cnn.com&login=bitlyapidemo&apiKey=R_0da49e0a9118ff35f52f629d2d71bf07
+			uri = URI.parse('http://api.bit.ly')
+
+			#	the client-izec set
+			params = @client_params.clone
+			params[:login] = self.login
+			params[:apiKey] = self.api_key if self.api_key
+
+			#	altered in whatever way the caller desires
+			yield params if block_given?
+
+			response = Net::HTTP.start(uri.host, uri.port) do |http|
+				path = "/#{command}?#{params}"
+				request = Net::HTTP::Get.new(path)
+				if self.password
+					#	HTTP auth expected
+					request.basic_auth self.login, self.password
+				end
+
+				http.request request
+			end
+
+			raise Error.new('did not receive HTTP 200 OK') unless Net::HTTPOK === response
+
+			#	a parsing response
+			Response.new(response, to_s_sym)
+		end
+
+		def assert_error_code(response) #:nodoc:
+			raise Error.new("errorCode #{response.errorCode} : #{response.errorMesage}") unless '0' == response.errorCode
+			response
+		end
+
+		def assert_status_code(response) #:nodoc:
+			raise Error.new("status #{response.statusCode}") unless 'OK' == response.statusCode
+			response
+		end
+
+		def assert_codes(response) #:nodoc:
+			assert_error_code(assert_status_code(response))
+		end
+	end
+
+
+
+	#Constructs a new 'simple' client.
+	#
+	#Just like a standard Client, except that several methods are overridden to provide the 'likely' value, vs. a Response.
+	class SimpleClient < Client
+		#Same as Client.shorten, except that the shortened URL is returned (vs. a Response)
+		def shorten(*args)
+			(super *args).to_s
+		end
+
+		#Same as Client.expand, except that the long URL is returned (vs. a Response)
+		def expand(*args)
+			#	just the default value, not the Response
+			(super *args).to_s
+		end
+	end
+end

data/lib/bitly4r/definitions.rb

@@ -0,0 +1,34 @@
+#Simple constructor methods, so that you don't have to deal directly with Client if you don't want to.
+#
+#See also:
+#* Bitly4R.Keyed
+#* Bitly4R.Authed
+#
+#--
+#Many thanks to Hpricot for introducing me to this convention.
+#++
+
+#Constructs a SimpleClient with the usual Hash of arguments.
+
+def Bitly4R(ops={})
+	#	general options
+	Bitly4R::SimpleClient.new(ops)
+end
+
+#Constructs a SimpleClient with login and API key credentials.
+#
+#No password is involved.
+#Simple HTTP GETs will be the order of the day.
+def Bitly4R.Keyed(login, api_key)
+	#	using an API key
+	Bitly4R::SimpleClient.new(:login => login, :api_key => api_key)
+end
+
+#Constructs a SimpleClient with login and password credentials.
+#
+#No API key is involved.
+#HTTP GETs with HTTP Basic Auth will be the order of the day.
+def Bitly4R.Authed(login, password)
+	#	using an API key
+	Bitly4R::SimpleClient.new(:login => login, :password => password)
+end

data/lib/bitly4r/objects.rb

@@ -0,0 +1,123 @@
+#Supporting objects for Bitly4R.
+#
+#See:
+#* Bitly4R::Error
+#* Bitly4R::Params
+#* Bitly4R::Response
+
+module Bitly4R
+
+	#= Error
+	#
+	#A Module-specific Exception class
+	#
+	#--
+	# i would have called it Bitly4R::Exception
+	# except that i don't know how to access Kernel::Exception within the initialize logic
+	#++
+	class Error < Exception
+		#The propagated cause of this Exception, if appropriate
+		attr_accessor :cause
+
+		#Provide a message and an optional 'causing' Exception.
+		#
+		#If no message is passed -- eg. only an Exception -- then this Exception inherits its message.
+		def initialize(message, cause=nil)
+			if (Exception === message)
+				super message.to_s
+				@cause = message
+			else
+				super message
+				@cause = cause
+			end
+		end
+	end
+
+	#= Params
+	#
+	#Extends the Hash class to provide simply composition of a URL-encoded string.
+	#
+	#Could have extended Hash, but chose instead to 'leave no trace'.
+	class Params < Hash
+		#	An encoded composite of the parameters, ready for use in a URL
+		def to_s
+			(self.to_a.collect do |k, v|
+				"#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"
+			end).join('&')
+		end
+	end
+
+
+
+	#= Response
+	#
+	#A response from the bit.ly API.
+	#
+	#The to_s method should always return the 'likely' value, assuming that there is a likely one.
+	#For example:
+	#* <tt>shorten => shortUrl</tt>
+	#* <tt>expand => longUrl</tt>
+	#
+	#All other response values can be retrieved via method_missing.
+	#
+	#<b>NOTE:</b> This is <i>not</i> a sophisticated XML parser.  It's just Regexp's, with handling for CDATA blocks.
+	class Response
+		#The body of the bit.ly API response, as XML
+		attr_reader :body
+
+		#Constructs a bit.ly API response wrapper.
+		#
+		#<i>response</i> can be:
+		#* a String, which becomes the body
+		#* a Net::HTTPResponse, in which case its body is extracted
+		#
+		#<i>to_s_sym</i> is optional, and it references the element which will become the to_s value of this Response.
+		#It can be either camel-case or underscored.
+		#See method_missing.
+		def initialize(response, to_s_sym=nil)
+			response = response.body if Net::HTTPResponse === response
+			@body = response
+			@to_s_sym = to_s_sym
+		end
+
+		#Provides access the other text elements of the response via camel-case or underscored names.
+		#For example, <tt>longUrl</tt> and <tt>long_url</tt> are equivalent.
+		#If no such element exists, you'll get nil.
+		def method_missing(sym, *args)
+			sym = Utility::camelize(sym.to_s)
+			match = (self.body || '').match(%r{<#{sym}>(.*)</#{sym}>})
+
+			unless match
+				nil
+			else
+				match[1].gsub(/^<!\[CDATA\[(.*)\]\]>$/, '\1')
+			end
+		end
+
+		#Provides the 'likely' value from the response.
+		def to_s
+			@to_s_sym  ? self.__send__(@to_s_sym)  : super
+		end
+		alias :to_str :to_s
+
+		#Provides the 'likely' value from the response, as a symbol.
+		def to_sym
+			@to_s_sym  ? self.to_s.to_sym  : super
+		end
+	end
+
+	class Utility #:nodoc: all
+		class << self
+			def camelize(string)
+				((string || '').to_s.split(/_/).inject([]) do |a, s|
+					s = s[0].chr.upcase + s[1..s.size] unless a.empty?
+					a << s
+					a
+				end).join('')
+			end
+			def decamelize(string)
+				(string.to_s || '').gsub(/([^_])([A-Z])/, '\1_\2').downcase
+			end
+		end
+	end
+end

data/test/client_test.rb

@@ -0,0 +1,130 @@
+#--
+
+require 'test_helper'
+
+
+
+class ClientTest < Test::Unit::TestCase #:nodoc: all
+	def test_construction
+		any = 'any'
+
+		assert_raises Bitly4R::Error do
+			#	no login
+			Bitly4R::Client.new
+		end
+
+		assert_raises Bitly4R::Error do
+			#	needs API key or password
+			Bitly4R::Client.new(:login => any)
+		end
+
+		Bitly4R::Client.new(:login => any, :api_key => any)
+		Bitly4R::Client.new(:login => any, :password => any)
+	end
+
+	def test_shorten
+		#	shorten
+		client = new_client
+		response = client.shorten LONG_URL
+
+		assert_is_response_ok response
+
+		#	we get back what we provided
+		assert_equal LONG_URL, response.node_key
+
+		#	no assumption as to the value, just how they inter-relate
+		hash = response.user_hash
+		assert hash && (! hash.empty?)
+		short = response.short_url
+		assert short =~ Regexp.compile(hash + '$')
+	end
+
+	def test_expand
+		#	shorten ...
+		client = new_client
+
+		response = client.shorten(LONG_URL)
+		assert_is_response_ok response
+
+		hash = response.user_hash
+		short = response.to_s
+
+		#	... and re-expand
+		#	again, we don't have to know anything
+		response = client.expand(short)
+		assert_is_response_ok response
+
+		assert_equal LONG_URL, response.to_s
+
+		#	note sure what purpose it serves
+		#	but it will contain a hash-wrapped element
+		assert ! response.__send__(hash.to_sym).empty?
+
+		#	... and re-expand
+		#	again, we don't have to know anything
+		response = client.expand(hash, :hash)
+		assert_is_response_ok response
+
+		assert_equal LONG_URL, response.to_s
+
+		#	again...
+		assert ! response.__send__(hash.to_sym).empty?
+	end
+
+	def test_info
+		#	shorten ...
+		client = new_client
+
+		response = client.shorten(LONG_URL)
+		assert_is_response_ok response
+
+		hash = response.user_hash
+		short = response.to_s
+
+		#	short url, with no key limit
+		response = client.info(short)
+		assert_is_response_ok response
+
+		assert_equal LONG_URL, response.long_url
+
+		#	hash, key limit
+		response = client.info(hash, :hash, :keys => [:long_url, :html_title])
+		assert_is_response_ok response
+
+		#	well, we're getting non-included keys back
+		#	then again, the demo doesn't constrain the keys either
+		#		http://code.google.com/p/bitly-api/wiki/ApiDocumentation
+		###assert response.thumbnail.empty?
+		###assert ! response.html_title.empty?
+		assert_equal LONG_URL, response.to_s
+	end
+
+	def test_stats
+		#	shorten ...
+		client = new_client
+
+		response = client.shorten(LONG_URL)
+		assert_is_response_ok response
+
+		hash = response.user_hash
+		short = response.to_s
+
+		{ :hash => hash, :short_url => short }.each do |param_type, param|
+			response = client.info(param, param_type)
+			assert_is_response_ok response
+
+			#	we could choose anything
+			assert_equal LONG_URL, response.to_s
+		end
+	end
+
+	def test_errors
+		#	errors ...
+		client = new_client
+
+		response = client.errors
+		assert ! response.results.empty?
+		assert ! response.error_code.empty?
+		assert ! response.status_code.empty?
+	end
+end

data/test/definitions_test.rb

@@ -0,0 +1,50 @@
+#--
+
+require 'test_helper'
+
+
+
+class DefinitionsTest < Test::Unit::TestCase #:nodoc: all
+	def test_keyed
+		#	shorten ...
+		client = Bitly4R(:login => LOGIN, :api_key => API_KEY)
+		short = client.shorten(LONG_URL)
+		assert short && (! short.empty?)
+
+		#	... and expand
+		assert_equal LONG_URL, Bitly4R.Keyed(LOGIN, API_KEY).expand(short)
+	end
+
+	def test_authed
+		unless PASSWORD
+			puts %Q{
+NOTE:
+	the text login (#{LOGIN}) did not publish a password
+	cannot be tested without that private information
+			}.strip
+			return
+		end
+
+		#	http://code.google.com/p/bitly-api/wiki/ApiDocumentation
+		#		sure, the documentation claims there's HTTP Auth support
+		#		but i don't see it yet
+		short = nil
+		assert_raises Bitly4R::Error do
+			#	shorten ...
+			client = Bitly4R(:login => LOGIN, :password => API_KEY)
+			short = client.shorten(LONG_URL)
+			assert short && (! short.empty?)
+		end
+
+		#	alright, let's use the API key
+		client = Bitly4R(:login => LOGIN, :api_key => API_KEY)
+		short = client.shorten(LONG_URL)
+		assert short && (! short.empty?)
+
+		#	same deal.  *sigh*
+		assert_raises Bitly4R::Error do
+			#	... and expand
+			assert_equal LONG_URL, Bitly4R.Authed(LOGIN, PASSWORD).expand(short)
+		end
+	end
+end

data/test/objects_test.rb

@@ -0,0 +1,101 @@
+#--
+
+require 'test_helper'
+
+
+
+class ObjectsTest < Test::Unit::TestCase #:nodoc: all
+	def test_decamelize
+		u = Bitly4R::Utility
+
+		assert_equal '', u.decamelize(nil)
+		assert_equal '', u.decamelize('')
+		assert_equal 'a', u.decamelize('a')
+		assert_equal 'a', u.decamelize('A')
+		assert_equal 'aa', u.decamelize('Aa')
+		assert_equal 'a_a', u.decamelize('aA')
+		assert_equal 'a_a', u.decamelize('AA')
+		assert_equal 'a_a', u.decamelize('a_a')
+		assert_equal 'a_a', u.decamelize(:A_A)
+	end
+
+	def test_camelize
+		u = Bitly4R::Utility
+
+		assert_equal '', u.camelize(nil)
+		assert_equal '', u.camelize('')
+		assert_equal '', u.camelize('_')
+		assert_equal 'a', u.camelize('a_')
+		assert_equal 'A', u.camelize('_a')
+		assert_equal 'aA', u.camelize('aA')
+		assert_equal 'aA', u.camelize('a_a')
+		assert_equal 'AA', u.camelize(:A_A)
+		assert_equal 'aA1.', u.camelize('a_A_1_.')
+	end
+
+	def test_error
+		#	string only
+		e = Bitly4R::Error.new('message')
+		assert_equal 'message', e.message
+		assert_nil e.cause
+
+		e = Bitly4R::Error.new(Exception.new('exception'))
+		assert_equal 'exception', e.message
+		assert_not_nil e.cause
+
+		#	exception
+		ee = nil
+		begin
+			1/0
+		rescue ZeroDivisionError => raised
+			ee = raised
+			e = Bitly4R::Error.new('rescued', raised)
+		end
+		assert_equal 'rescued', e.message
+		assert_not_nil e.cause
+		assert_equal ee, e.cause
+	end
+
+	def test_params
+		params = Bitly4R::Params.new
+		assert_equal '', params.to_s
+
+		params[1] = :one
+		assert_equal '1=one', params.to_s
+
+		params[:b] = Exception.new('an exception')
+		assert_equal ['1=one', 'b=an+exception'], params.to_s.split('&').sort
+
+		params['key is'] = '&escaped'
+		assert_equal ['1=one', 'b=an+exception', 'key+is=%26escaped'], params.to_s.split('&').sort
+	end
+
+	def test_response
+		#	nil response *and* to_s symbol
+		response = Bitly4R::Response.new(nil)
+		assert_nil response.body
+		assert_not_nil response.to_s
+		assert_nil response.to_sym
+
+		#	crap
+		response = Bitly4R::Response.new('string', :bogus)
+		assert_equal 'string', response.body
+		assert_nil response.to_s
+
+		#	simple
+		response = Bitly4R::Response.new('<a>value</a>', :b)
+		assert_equal 'value', response.a
+		assert_nil response.to_s
+
+		#	camelization
+		response = Bitly4R::Response.new('<uD>down</uD><dU>up</dU>', :d_u)
+		assert_equal 'down', response.uD
+		assert_equal 'down', response.u_d
+		assert_equal 'up', response.dU
+		assert_equal 'up', response.to_s
+
+		#	CDATA, plus to_sym
+		response = Bitly4R::Response.new('<a><b>b</b><cData><![CDATA[data]]></cData><c>c</c></a>', :c_data)
+		assert_equal :data, response.to_sym
+	end
+end

data/test/test_helper.rb

@@ -0,0 +1,41 @@
+#--
+
+#
+#	Thank you masked man.  Or, rather, Hpricot.
+#
+$LOAD_PATH.unshift File.dirname(File.dirname(__FILE__)) + "/../lib"
+
+%w{ rubygems bitly4r test/unit }.each {|lib| require lib }
+
+#	if we're lucky...
+begin
+	require 'ruby-debug'
+rescue Object => e
+end
+
+
+
+class Test::Unit::TestCase #:nodoc: all
+
+	#	trailing slash makes a difference!  they normalize!
+	LONG_URL = 'http://rubyforge.org/'
+
+	#	credentials from
+	#		http://code.google.com/p/bitly-api/wiki/ApiDocumentation
+	#		no password provided
+	LOGIN = 'bitlyapidemo'
+	API_KEY = 'R_0da49e0a9118ff35f52f629d2d71bf07'
+	PASSWORD = nil
+
+
+
+	def new_client
+		Bitly4R::Client.new(:login => LOGIN, :api_key => API_KEY)
+	end
+
+	def assert_is_response_ok(response)
+		assert_equal '0', response.error_code
+		assert_equal '', response.error_message
+		assert_equal 'OK', response.status_code
+	end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: bitly4r
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Dan Foley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-02 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: "Bitly4R : A Ruby API for the http://bit.ly URL-shortening service"
+email: admin@cantremember.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- CHANGELOG
+- LICENSE
+files: 
+- CHANGELOG
+- LICENSE
+- README.rdoc
+- Rakefile
+- lib/bitly4r/client.rb
+- lib/bitly4r/definitions.rb
+- lib/bitly4r/objects.rb
+- lib/bitly4r.rb
+has_rdoc: true
+homepage: http://wiki.cantremember.com/Bitly4R
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Bitly4R
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.8"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: bitly4r
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: bitly4r 0.1.0
+test_files: 
+- test/client_test.rb
+- test/definitions_test.rb
+- test/objects_test.rb
+- test/test_helper.rb