digitalpardoe-rflickr 1.1.4 → 2.0.0.pre.1

data/LICENSE

@@ -1,278 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-			    NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.

data/README.markdown

@@ -1,22 +0,0 @@
-# rFlickr
-
-**Warning**: This gem only works with Ruby 1.8, a new version compatible with Ruby 2.0 is coming soon.
-
-To use this version of rFlickr, first you will need to install
-the RubyGem using the following command:
-
-    $ sudo gem install digitalpardoe-rflickr
-
-Then you'll need to get a Flickr API key as detailed here:
-
-[http://www.flickr.com/services/api/misc.api_keys.html](http://www.flickr.com/services/api/misc.api_keys.html)
-
-You'll need to authorize your application's API key from each
-Flickr user account which wants to use it.
-
-A short guide to get you started can be found here:
-
-[http://digitalpardoe.co.uk/blog/show/87](http://digitalpardoe.co.uk/blog/show/87)
-
-The guide is a little out of date in it's gem installation technique,
-use the instructions above instead.

data/VERSION.yml

@@ -1,5 +0,0 @@
---- 
-:minor: 1
-:patch: 4
-:build: 
-:major: 1

data/lib/flickr/auth.rb

@@ -1,94 +0,0 @@
-# rFlickr: A Ruby based Flickr API implementation.
-# Copyright (C) 2009, Alex Pardoe (digital:pardoe)
-#
-# Derrived from work by Trevor Schroeder, see here:
-# http://rubyforge.org/projects/rflickr/.
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-require 'flickr/base'
-
-class Flickr::Auth < Flickr::APIBase
-	attr_accessor :cache_file, :token
-
-	def clear_cache
-		@token = nil
-		@frob = nil
-	end
-
-	def initialize(flickr,cache_file=nil)
-		super(flickr)
-		@frob = nil
-		@token = nil
-		@cache_file = cache_file
-		if @cache_file && File.exists?(@cache_file)
-			load_token
-		end
-	end
-
-	def login_link(perms='delete')
-		args={ 'api_key' => @flickr.api_key, 'perms' => perms}
-		args['frob'] = self.frob
-		args['api_sig'] = @flickr.sign(args)
-		return "http://flickr.com/services/auth/?"+
-		  args.to_a.map{|arr| arr.join('=')}.join('&')
-	end
-
-	def frob=(frob) @frob = frob end
-	def frob() return @frob || getFrob end
-
-	def cache_token
-		File.open(@cache_file,'w'){ |f| f.write @token.to_xml } if token
-	end
-
-	def load_token
-		token = nil
-		File.open(@cache_file,'r'){ |f| token = f.read }
-		# Dirt stupid check to see if it's probably XML or
-		# not.  If it is, then we don't call checkToken.
-		#
-		# Backwwards compatible with old token storage.
-		@token = token.include?('<') ?
-		  Flickr::Token.from_xml(REXML::Document.new(token)) :
-		  @token = checkToken(token)
-	end
-
-	def getToken(frob=nil)
-		frob ||= @frob
-		res=@flickr.call_unauth_method('flickr.auth.getToken',
-			'frob'=>frob)
-		@token = Flickr::Token.from_xml(res)
-	end
-
-	def getFullToken(mini_token)
-		res = flickr.call_unauth_method('flickr.auth.getFullToken',
-			'mini_token' => mini_token)
-		@token = Flickr::Token.from_xml(res)
-	end
-
-	def getFrob
-		doc = @flickr.call_unauth_method('flickr.auth.getFrob')
-		@frob = doc.elements['/frob'].text
-		return @frob
-	end
-
-	def checkToken(token=nil)
-		token ||= @token
-		token = token.token if token.class == Flickr::Token
-		res = @flickr.call_unauth_method('flickr.auth.checkToken',
-			'auth_token' => token)
-		@token = Flickr::Token.from_xml(res)
-	end
-end

data/lib/flickr/base.rb

@@ -1,810 +0,0 @@
-# rFlickr: A Ruby based Flickr API implementation.
-# Copyright (C) 2009, Alex Pardoe (digital:pardoe)
-#
-# Derrived from work by Trevor Schroeder, see here:
-# http://rubyforge.org/projects/rflickr/.
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-## Structure this class hierarchy the way the Flickr API is structured.
-## Flickr::Auth and so on.  At least think about whether it makes sense or
-## not.
-
-require 'xmlrpc/client'
-require 'md5'
-require 'rexml/document'
-require 'parsedate'
-
-class Flickr
-	API_KEY=''
-	SHARED_SECRET=''
-
-	attr_reader :api_key
-	attr_accessor :async, :debug, :caching, :auth_mode
-
-	############################### CACHE ACCESSORS ###########################
-	def ticket_cache_lookup(id) @ticket_by_id[id] if @caching end
-
-	def ticket_cache_store(ticket)
-		@ticket_by_id[ticket.id] = ticket if @caching
-	end
-
-	def person_cache_lookup(nsid) @person_by_nsid[nsid] if @caching end
-
-	def person_cache_store(person)
-		@person_by_nsid[person.nsid] = person if @caching
-	end
-
-	def photo_cache_lookup(id) @photo_by_id[id] if @caching end
-
-	def photo_cache_store(photo)
-		@photo_by_id[photo.id] = photo if @caching
-	end
-
-	def license_cache_lookup() @license_cache if @caching end
-
-	def license_cache_store(licenses)
-		@license_cache = licenses if @caching
-	end
-
-	def blog_cache_lookup() @blog_cache if @caching end
-
-	def blog_cache_store(blogs) @blog_cache = blogs if @caching end
-
-	def photoset_cache_lookup(id) @photoset_by_id[id] if @caching end
-
-	def photoset_cache_store(set)
-		@photoset_by_id[set.id] = set if @caching
-	end
-
-	def photopool_cache_lookup(id) @photopool_by_id[id] if @caching end
-
-	def photopool_cache_store(pool)
-		@photopool_by_id[pool.id] = pool if @caching
-	end
-
-	def group_cache_lookup(id) @group_by_id[id] if @caching end
-
-	def group_cache_store(group)
-		@group_by_id[group.id] = group if @caching
-	end
-	############################################################################
-
-	def debug(*args) $stderr.puts(sprintf(*args)) if @debug end
-
-	def Flickr.todo
-		[
-			'Refactor, especially more Class.from_xml methods',
-			'More logical OO design, wrap the API methods to make transparent',
-			'Class & method documentation',
-			'Unit tests',
-			'Implement missing methods (see flickr.reflection.missing_methods)'
-	  	]
-	end
-
-	def todo()
-		Flickr.todo+reflection.missing_methods.map{|m| 'Implement '+m}
-	end
-	
-	def initialize(token_cache=nil,api_key=API_KEY,
-			shared_secret=SHARED_SECRET,
-			endpoint='http://www.flickr.com/services/xmlrpc/')
-		@async = false
-		@caching = true
-		@auth_mode = true
-		@api_key=api_key
-		@shared_secret=shared_secret
-		@token_cache = token_cache
-		@endpoint=endpoint
-		proto,host,port,path,user,pass=parse_url(@endpoint)
-		raise ProtoUnknownError.new("Unhandled protocol '#{proto}'") if
-		proto.downcase != 'http'
-		@client=XMLRPC::Client.new(host,path,port)
-		clear_cache
-	end
-
-	def clear_cache()
-		@auth = nil
-		@blogs = nil
-		@contacts = nil
-		@favorites = nil
-		@groups = nil
-		@interestingness = nil
-		@reflection = nil
-		@people = nil
-		@photos = nil
-		@photosets = nil
-		@urls = nil
-
-		@ticket_by_id = {}
-		@person_by_nsid = {}
-		@photo_by_id = {}
-		@photoset_by_id = {}
-		@photopool_by_id = {}
-		@group_by_id = {}
-		@license_cache = nil
-		@blog_cache = nil
-	end
-
-	def auth() @auth ||= Auth.new(self,@token_cache) end
-	def blogs() @blogs ||= Blogs.new(self) end
-	def contacts() @contacts ||= Contacts.new(self) end
-	def favorites() @favorites ||= Favorites.new(self) end
-	def groups() @groups ||= Groups.new(self) end
-	def people() @people ||= People.new(self) end
-	def photos() @photos ||= Photos.new(self) end
-	def photosets() @photosets ||= PhotoSets.new(self) end
-	def reflection() @reflection ||= Reflection.new(self) end
-	def urls() @urls ||= Urls.new(self) end
-	def tags() @tags ||= Tags.new(self) end
-	def interestingness() @interestingness ||= Interestingness.new(self) end
-
-	def call_method(method,args={})
-		@auth_mode ? call_auth_method(method,args) :
-		  call_unauth_method(method,args)
-	end
-
-	def call_unauth_method(method,args={})
-		debug('%s(%s)', method, args.inspect)
-		tries = 3
-		args = args.dup
-		args['api_key'] = @api_key
-		api_sig=sign(args)
-		args['api_sig']=api_sig
-		begin
-			tries -= 1;
-			str = @async ? @client.call_async(method,args) :
-			  @client.call(method,args)
-			debug('RETURN: %s',str)
-			return REXML::Document.new(str)
-		rescue Timeout::Error => te
-			$stderr.puts "Timed out, will try #{tries} more times."
-			if tries > 0
-				retry
-			else
-				raise te
-			end
-		rescue REXML::ParseException => pe
-			return REXML::Document.new('<rsp>'+str+'</rsp>').
-			  elements['/rsp']
-		rescue XMLRPC::FaultException => fe
-			$stderr.puts "ERR: #{fe.faultString} (#{fe.faultCode})"
-			raise fe
-		end
-	end
-
-	def call_auth_method(method,args={})
-		at = args['auth_token']
-		args['auth_token'] ||= auth.token.token
-		res = call_unauth_method(method,args)
-		args.delete('auth_token') unless at
-		return res
-	end
-
-	def sign(args)
-		return MD5.md5(@shared_secret+args.sort.flatten.join).to_s
-	end
-
-	def parse_url(url)
-		url =~ /([^:]+):\/\/([^\/]*)(.*)/
-		proto = $1.to_s
-		hostplus = $2.to_s
-		path = $3.to_s
-
-		hostplus =~ /(?:(.*)@)?(.*)/
-		userpass = $1
-		hostport = $2
-		user,pass = userpass.to_s.split(':',2)
-		host,port = hostport.to_s.split(':',2)
-		port = port ? port.to_i : 80
-
-		return proto,host,port,path,user,pass
-	end
-
-	def mysql_datetime(time) time.strftime('%Y-%m-%d %H:%M:%S') end
-	def mysql_date(time) time.strftime('%Y-%m-%d') end
-end
-
-class Flickr::APIBase
-	attr_reader :flickr
-
-	def initialize(flickr) @flickr = flickr end
-end
-
-class Flickr::Token
-	attr_reader :token, :perms, :user
-
-	def initialize(token, perms, user)
-		@token = token
-		@perms = perms
-		@user = user
-	end
-
-	def self.from_xml(xml, flickr=nil)
-		token = xml.elements['/auth/token'].text
-		perms = xml.elements['/auth/perms'].text.intern
-		user = xml.elements['/auth/user']
-		nsid = user.attributes['nsid']
-		username = user.attributes['username']
-		fullname = user.attributes['fullname']
-
-		p = flickr.person_cache_lookup(nsid) if flickr
-		p ||= Flickr::Person.new(flickr,nsid,username)
-		p.realname=fullname
-		flickr.person_cache_store(p) if flickr
-
-		return Flickr::Token.new(token,perms,p)
-	end
-
-	def to_xml
-		return "<auth><token>#{self.token}</token>"+
-		  "<perms>#{self.perms}</perms>"+
-		  "<user nsid=\"#{self.user.nsid}\" "+
-		  "username=\"#{self.user.username}\" "+
-		  "fullname=\"#{self.user.realname}\" /></auth>"
-	end
-end
-
-class Flickr::Blog
-	attr_reader :id, :name, :needspassword, :url
-
-	def initialize(id,name,needspassword,url)
-		@id = id
-		@name = name
-		@needspassword = needspassword
-		@url = url
-	end
-end
-
-class Flickr::Person
-	attr_accessor :nsid, :username, :realname, :mbox_sha1sum, :location,
-	  :photosurl, :profileurl, :photos_firstdate, :photos_firstdatetaken,
-	  :photos_count, :info_fetched, :isadmin, :ispro, :iconserver,
-	  :bandwidth_max, :bandwidth_used, :filesize_max, :upload_fetched,
-	  :friend, :family, :ignored
-
-	def initialize(flickr, nsid, username)
-		@flickr = flickr
-		@nsid = nsid
-		@username = username
-		@info_fetched = false
-		@upload_fetched = false
-	end
-
-	def full_info()
-		self.info_fetched ? self : @flickr.people.getInfo(self)
-	end
-	def upload_status() self.upload_fetched ? self :
-		@flickr.people.getUploadStatus(self) end
-		
-
-	# I think this will define a class method.  You can't use
-	# Flickr::Person.from_xml and if you just say Person.from_xml, it
-	# can't resolve Flickr::Person::Person
-	def self.from_xml(xml,flickr=nil)
-		els = xml.elements
-		att = xml.root.attributes
-
-		nsid = cond_attr(att,'nsid')
-		username = cond_text(els,'/person/username')
-
-		p = flickr.person_cache_lookup(nsid) if flickr
-		p ||= Flickr::Person.new(flickr,nsid,username)
-		
-		p.username = username
-		p.isadmin = cond_attr(att,'isadmin') &&
-		  cond_attr(att,'isadmin') == '1'
-		p.ispro = cond_attr(att,'ispro') &&
-		  cond_attr(att,'ispro') == '1'
-		p.iconserver = cond_attr(att,'iconserver') &&
-		  cond_attr(att,'iconserver').to_i
-		p.realname = cond_text(els,'/person/realname')
-		p.mbox_sha1sum = cond_text(els,'/person/mbox_sha1sum')
-		p.location = cond_text(els,'/person/location')
-		p.photosurl = cond_text(els,'/person/photosurl')
-		p.profileurl = cond_text(els,'/person/profileurl')
-		tstr = cond_text(els,'/person/photos/firstdate')
-		p.photos_firstdate = Time.at(tstr.to_i) if tstr
-		tstr = cond_text(els, '/person/photos/firstdatetaken')
-		p.photos_firstdatetaken = Time.gm(*ParseDate.parsedate(tstr)) if
-		tstr
-		p.photos_count = cond_text(els,'/person/photos/count')
-		p.photos_count = p.photos_count if p.photos_count
-
-		p.info_fetched = true if p.photos_count
-
-		if els['/user/bandwidth']
-			att = els['/user/bandwidth'].attributes
-			p.bandwidth_max = cond_attr(att,'max') &&
-			  cond_attr(att,'max').to_i
-			p.bandwidth_used = cond_attr(att,'used') &&
-			  cond_attr(att,'used').to_i
-		end
-		if els['/user/filesize']
-			att = els['/user/filesize'].attributes
-			p.filesize_max = cond_attr(att,'max') &&
-			  cond_attr(att,'max').to_i
-		end
-
-		p.upload_fetched = true if p.bandwidth_max
-
-		flickr.person_cache_store(p) if flickr
-		return p
-	end
-
-	private
-	def self.cond_text(elements,index)
-		elements[index] ? elements[index].text : nil
-	end
-
-	def self.cond_attr(attributes,name) attributes[name] end
-end
-
-class Flickr::Size
-	attr_reader :label,:width,:height,:source,:url
-
-	def initialize(label,width,height,source,url)
-		@label = label
-		@width = width
-		@height = height
-		@source = source
-		@url = url
-	end
-
-	def self.from_xml(xml)
-		att = xml.attributes
-		return Flickr::Size.new(att['label'],att['width'].to_i,
-			att['height'].to_i,att['source'],att['url'])
-	end
-end
-
-class Flickr::Photo
-	attr_accessor :id, :owner_id, :secret, :server, :title, :ispublic,
-	  :isfriend, :isfamily, :ownername, :dateadded,
-	  :license_id, :description, :dates, :taken,
-	  :lastupdate, :takengranularity, :cancomment, :canaddmeta,
-	  :comments, :rotation, :notes, :urls, :permaddmeta,
-	  :permcomment, :originalformat, :farm
-
-	attr_reader :flickr
-
-	def owner() @owner ||= @flickr.people.getInfo(owner_id) end
-	def sizes() @sizes || @flickr.photos.getSizes(self).sizes end
-	def sizes=(sizes) @sizes = sizes end
-
-	def max_size
-		sizes[:Original] ||  sizes[:Large] || sizes[:Medium] ||
-		  sizes[:Small]
-	end
-
-	def initialize(flickr,id)
-		@flickr = flickr
-		@id = id
-	end
-
-	def exif() @exif ||= @flickr.photos.getExif(self) end
-	def exif=(set) @exif = set end
-
-	def tags() @tags ||= @flickr.tags.getListPhoto(self) end
-	def tags=(set) @tags = set end
-
-	def license() @flickr.photos.licenses.getInfo[@license_id] end
-
-	def contexts() @contexts ||= @flickr.photos.getAllContexts(self) end
-
-	def url(size=nil)
-		base = "http://farm#{@farm}.static.flickr.com"
-		ext = (size == 'o') ? self.originalformat : 'jpg'
-		return size ?
-		  "#{base}/#@server/#{@id}_#{@secret}_#{size}.#{ext}" :
-		  "#{base}/#@server/#{@id}_#{@secret}.jpg"
-	end
-
-	def delete() @flickr.photos.delete(self) end
-
-	def self.from_xml(xml,flickr=nil)
-		att = xml.attributes
-		phid = att['id']
-
-		photo = flickr.photo_cache_lookup(phid) if flickr
-		photo ||= Flickr::Photo.new(flickr,phid)
-
-		photo.owner_id ||= att['owner'] || (xml.elements['owner'] &&
-			  xml.elements['owner'].attributes['nsid'])
-		photo.secret = att['secret'] if att['secret']
-		photo.originalformat = att['originalformat'] if
-		att['originalformat']
-		photo.server = att['server'].to_i if att['server']
-		photo.title = att['title'] || cond_text(xml.elements,'title')
-		photo.license_id = att['license']
-		photo.rotation = att['rotation'].to_i if att['rotation']
-		photo.farm = att['farm'].to_i if att['farm']
-
-		photo.ispublic = (att['ispublic'].to_i == 1) if att['ispublic']
-		photo.isfriend = (att['isfriend'].to_i == 1) if att['isfriend']
-		photo.isfamily = (att['isfamily'].to_i == 1) if att['isfamily']
-		photo.ownername = att['ownername'] || (xml.elements['owner'] &&
-			  xml.elements['owner'].attributes['username'])
-		photo.description = cond_text(xml.elements,'description')
-		photo.dateadded = Time.at(att['dateadded'].to_i) if
-		att['dateadded']
-		if xml.elements['exif']
-			list = []
-			xml.elements.each('exif') do |el|
-				exif = Flickr::Exif.from_xml(el)
-				list << exif
-			end
-			photo.exif = list
-		end
-		if xml.elements['visibility']
-			att = xml.elements['visibility'].attributes
-			photo.ispublic = (att['ispublic'].to_i == 1)
-			photo.isfriend = (att['isfriend'].to_i == 1)
-			photo.isfamily = (att['isfamily'].to_i == 1)
-		end
-		if xml.elements['dates']
-			att = xml.elements['dates'].attributes
-			dates = {}
-			dates[:posted] = Time.at(att['posted'].to_i)
-			dates[:taken] = Time.gm(*ParseDate.parsedate(att['taken']))
-			dates[:lastupdate] = Time.at(att['lastupdate'].to_i)
-			dates[:takengranularity] = att['takengranularity'].to_i
-			photo.dates = dates
-		end
-		if xml.elements['editability']
-			att = xml.elements['editability'].attributes
-			photo.cancomment = (att['cancomment'].to_i == 1)
-			photo.canaddmeta = (att['canaddmeta'].to_i == 1)
-		end
-		photo.comments = cond_text(xml.elements,'comments')
-		photo.comments &&= photo.comments.to_i
-		if xml.elements['notes']
-			notes = []
-			xml.elements['notes'].each_element do |el|
-				notes << Flickr::Note.from_xml(el,photo)
-			end
-			photo.notes = notes
-		end
-		if xml.elements['tags']
-			tags = []
-			xml.elements['tags'].each_element do |el|
-				tags << Flickr::Tag.from_xml(el,photo)
-			end
-			photo.tags = tags
-		end
-		if xml.elements['urls']
-			urls = {}
-			xml.elements['urls'].each_element do |el|
-				att = el.attributes
-				urls[att['type'].intern] = el.text
-			end
-			photo.urls = urls
-		end
-			
-		flickr.photo_cache_store(photo) if flickr
-		return photo
-	end
-
-	private
-	def self.cond_text(elements,index)
-		elements[index] ? elements[index].text : nil
-	end
-end
-
-class Flickr::Exif
-	attr_reader :tagspace,:tagspaceid,:tag,:label
-	attr_accessor :raw,:clean
-	def initialize(tagspace,tagspaceid,tag,label)
-		@tagspace = tagspace
-		@tagspaceid = tagspaceid
-		@tag = tag
-		@label = label
-	end
-
-	def self.from_xml(element)
-		att = element.attributes
-		exif = Flickr::Exif.new(att['tagspace'],att['tagspaceid'].to_i,
-			att['tag'],att['label'])
-		exif.raw=element.elements['raw'].text if element.elements['raw']
-		exif.clean=element.elements['clean'].text if
-		element.elements['clean']
-		return exif
-	end
-end
-
-class Flickr::PhotoList < Array
-	attr_reader :page,:pages,:perpage,:total
-
-	def initialize(page,pages,perpage,total)
-		@page = page
-		@pages = pages
-		@perpage = perpage
-		@total = total
-	end
-
-	def self.from_xml(xml,flickr=self)
-		att = xml.root.attributes
-		list = Flickr::PhotoList.new(att['page'].to_i,att['pages'].to_i,
-			att['perpage'].to_i,att['total'].to_i)
-		xml.elements['/photos'].each_element do |e|
-			list << Flickr::Photo.from_xml(e,flickr)
-		end
-		return list
-	end
-end
-
-class Flickr::Category
-	attr_reader :name, :path, :pathids, :groups, :subcats, :id
-
-	def initialize(name,path,pathids)
-		@name = name
-		@path = path
-		@pathids = pathids
-		@groups = []
-		@subcats = []
-		@id = pathids.split('/').last
-	end
-end
-
-class Flickr::SubCategory
-	attr_reader :name, :id, :count
-
-	def initialize(name,id,count)
-		@name = name
-		@id = id
-		@count = count
-	end
-end
-
-class Flickr::Group
-	# The privacy attribute is 1 for private groups, 2 for invite-only public
-	# groups and 3 for open public groups.
-	PRIVACY = [nil,:private,:invite,:public]
-
-	attr_accessor :nsid, :name, :members, :online, :chatnsid, :inchat,
-	  :description, :privacy, :eighteenplus, :fully_fetched, :admin,
-	  :photo_count, :iconserver
-
-	def initialize(flickr,nsid, name=nil, members=nil, online=nil,
-			chatnsid=nil, inchat=nil)
-		@flickr = flickr
-		@nsid = nsid
-		@name = name
-		@members = members
-		@online = online
-		@chatnsid = chatnsid
-		@inchat = inchat
-		@fully_fetched = false
-	end
-	
-	def full_info
-		self.fully_fetched ? self : @flickr.groups.getInfo(self)
-	end
-end
-
-class Flickr::GroupList < Array
-	attr_reader :page,:pages,:perpage,:total
-
-	def initialize(page,pages,perpage,total)
-		@page = page
-		@pages = pages
-		@perpage = perpage
-		@total = total
-	end
-end
-
-class Flickr::Context
-	attr_reader :prev_id,:prev_secret,:prev_title,:prev_url,
-	  :next_id,:next_secret,:next_title,:next_url
-
-	def initialize(prev_id,prev_secret,prev_title,prev_url,
-			next_id,next_secret,next_title,next_url)
-		@prev_id = prev_id
-		@prev_secret = prev_secret
-		@prev_title = prev_title
-		@prev_url = prev_url
-		@next_id = next_id
-		@next_secret = next_secret
-		@next_title = next_title
-		@next_url = next_url
-	end
-
-	def self.from_xml(xml)
-		a0 = xml.elements['prevphoto'].attributes
-		a1 = xml.elements['nextphoto'].attributes
-		return Flickr::Context.new(
-			a0['id'],a0['secret'],a0['title'],a0['url'],
-			a1['id'],a1['secret'],a1['title'],a1['url'])
-	end
-end
-
-class Flickr::License
-	attr_reader :id, :name, :url
-	def initialize(id,name,url)
-		@id = id
-		@name = name
-		@url = url
-	end
-
-	def self.from_xml(xml)
-		att = xml.attributes
-		return Flickr::License.new(att['id'],att['name'],
-			att['url'])
-	end
-end
-
-class Flickr::Note
-	attr_accessor :photo, :x, :y, :w, :h, :text, :id, :author_id
-	def initialize(x, y, w, h, text, flickr = nil)
-		@x = x
-		@y = y
-		@w = w
-		@h = h
-		@text = text
-		@flickr = flickr
-	end
-
-	def author() @author_id && @flickr.people.getInfo(@author_id) end
-
-	def self.from_xml(xml,photo=nil)
-		att = xml.attributes
-		note = Flickr::Note.new(att['x'].to_i,att['y'].to_i,
-			att['w'].to_i,att['h'].to_i,xml.text,
-			photo && photo.flickr)
-		note.photo = photo
-		note.id = att['id']
-		note.author_id = att['author'] if att['author']
-	end
-end
-
-class Flickr::Count
-	attr_reader :fromdate, :todate, :count
-	def initialize(count,fromdate,todate)
-		@count = count
-		@fromdate = fromdate
-		@todate = todate
-	end
-	
-	def self.from_xml(xml)
-		att = xml.attributes
-		return Flickr::Count.new(att['count'].to_i,
-			Time.at(att['fromdate'].to_i),
-			Time.at(att['todate'].to_i))
-	end
-end
-
-class Flickr::Tag
-	attr_reader :id, :author_id, :raw, :clean
-
-	def initialize(flickr, id,author_id,raw,clean)
-		@flickr = flickr
-		@id = id
-		@author_id = author_id
-		@raw = raw
-		@clean = clean
-	end
-
-	def author() @flickr.people.getInfo(@author_id) end
-
-	def self.from_xml(xml,flickr=nil)
-		att = xml.attributes
-		clean = xml.text
-		return Flickr::Tag.new(flickr,att['id'],att['author'],
-			att['raw'], clean)
-	end
-end
-
-class Flickr::PhotoSet < Array
-	attr_accessor :id, :title, :url, :server, :primary_id,
-	  :photo_count, :description, :secret, :owner
-
-	def initialize(id,flickr)
-		@id = id
-		@flickr = flickr
-	end
-
-	def <<(photo,raw=false)
-		raw ? super(photo) : @flickr.photosets.addPhoto(self,photo)
-		return self
-	end
-
-	def fetch(extras=nil)
-		return self if @fetched
-		set = @flickr.photosets.getPhotos(self,extras)
-		@fetched = true
-		return set
-	end
-
-	alias photos fetch
-
-	def self.from_xml(xml,flickr=nil)
-		att = xml.attributes
-		psid = att['id']
-
-		set = flickr.photoset_cache_lookup(psid) if flickr
-		set ||= Flickr::PhotoSet.new(psid,flickr)
-
-		set.secret = att['secret']
-		set.owner = att['owner']
-		set.url = att['url']
-		set.server = att['server'].to_i
-		set.primary_id = att['primary'].to_i
-		set.photo_count = att['photos'].to_i
-		set.title = xml.elements['title'].text if xml.elements['title']
-		set.description = xml.elements['description'].text if
-		xml.elements['description']
-		if xml.elements['photo']
-			set.clear
-			xml.elements.each('photo') do |el|
-				set.<<(Flickr::Photo.from_xml(el,flickr),true)
-			end
-		end
-
-		flickr.photoset_cache_store(set) if flickr
-		return set
-	end
-
-	def url
-		owner = @owner || @flickr.photosets.getInfo(self).owner
-		return "http://www.flickr.com/photos/#{owner}/sets/#{@id}"
-	end
-
-	def primary() @primary ||= @flickr.photos.getInfo(@primary_id) end
-end
-
-class Flickr::PhotoPool < Array
-	attr_accessor :page, :pages, :perpage, :total, :title, :id
-
-	def initialize(id,flickr)
-		@id = id
-		@flickr = flickr
-	end
-
-	def <<(photo,raw=false)
-		raw ? super(photo) : @flickr.photosets.addPhoto(self,photo)
-		return self
-	end
-
-	def fetch(extras=nil)
-		return self if @fetched
-		pool = @flickr.groups.pools.getPhotos(self,nil,extras,500)
-		@fetched = true
-		return pool
-	end
-
-	def self.from_xml(xml,flickr=nil)
-		att = xml.attributes
-		ppid = att['id']
-
-		pool = flickr.photopool_cache_lookup(ppid)
-		pool ||= Flickr::PhotoPool.new(ppid,flickr)
-
-		pool.page = att['page'].to_i if att['page']
-		pool.pages = att['pages'].to_i if att['pages']
-		pool.perpage = att['perpage'].to_i if att['perpage']
-		pool.total = att['total'].to_i if att['total']
-		if xml.elements['photo']
-			# I'd like to clear the pool, but I can't because I don't know if I'm
-			# parsing the full set or just a single "page".
-			#			pool.clear
-			xml.elements.each('photo') do |el|
-				pool.<<(Flickr::Photo.from_xml(el,flickr),true)
-			end
-		end
-
-		flickr.photopool_cache_store(pool) if flickr
-		return pool
-	end
-end