myflickr 0.0.2

data/History.txt

@@ -0,0 +1,8 @@
+== 0.0.1 2007-12-15
+
+* Initial release
+
+== 0.0.2 2007-12-19
+
+* Specs written, classes revised
+  * All 'works'

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Ben Schwarz
+
+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/Manifest.txt

@@ -0,0 +1,24 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/myflickr.rb
+lib/myflickr/machine_tag.rb
+lib/myflickr/photo.rb
+lib/myflickr/query.rb
+lib/myflickr/set.rb
+lib/myflickr/size.rb
+lib/myflickr/tag.rb
+lib/myflickr/version.rb
+lib/vendor/parallel/parallel.rb
+setup.rb
+spec/machine_tag_spec.rb
+spec/photo_spec.rb
+spec/query_spec.rb
+spec/set_spec.rb
+spec/size_spec.rb
+spec/spec_helper.rb
+spec/tag_spec.rb

data/README.txt

@@ -0,0 +1,20 @@
+MyFlickr is for when you're using flickr for only your own images, 
+not the rest of the worlds'. 
+
+All of the methods within the few classes that exist are built around this need for 
+personal images, with the plan of building a portfolio using only flickr as the backend.
+
+The stats
+* Using the REST interface because its easy to parse and transport
+* Using MenTaLguY's parallel_map method to thread all the calls to flickr (for speed)
+* Most everything else is home-baked, a little code style stolen from toolmantim; Its all love
+
+Usage
+  require 'myflickr'
+  include Myflickr
+  Myflickr::Photo.search "hk"
+
+Which will return an array of photo objects
+
+Questions and comments can be directed to ben at germanforblack.com
+All code is provided with no warranty and should be considered experimental until otherwise stated (Don't let your mother or girlfriend *near* it)

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,71 @@
+require 'myflickr/version'
+
+AUTHOR = 'Ben Schwarz'  # can also be an array of Authors
+EMAIL = "ben@germanforblack.com"
+DESCRIPTION = "A wrapper around flickr for you, not the community aspects of flickr, only for you."
+GEM_NAME = 'myflickr' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'schwarz' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "bschwarz"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = Myflickr::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'myflickr documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' } 
+    @extra_deps
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.extra_deps = %w(hpricot)     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+hoe.rsync_args = '-av --delete --ignore-errors'

data/config/requirements.rb

@@ -0,0 +1,17 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+require 'myflickr'

data/lib/myflickr/machine_tag.rb

@@ -0,0 +1,7 @@
+module Myflickr
+  class MachineTag < Struct.new :namespace, :predicate, :value #:nodoc:
+    def self.from_s string
+      new($1, $2, $3) if string =~ /(.*)\:(.*)\=(.*)/
+    end
+  end
+end

data/lib/myflickr/photo.rb

@@ -0,0 +1,47 @@
+module Myflickr
+  class Photo < Struct.new :id, :title, :description, :tags, :machine_tags
+    attr_reader :sizes
+    
+    # Get recent photos
+    def self.recent
+      parse(Query.api_call('flickr.photos.search'))
+    end
+    
+    # Find a collection of photos by text
+    def self.search(search_string)
+      parse(Query.api_call('flickr.photos.search', "text=#{search_string}"))
+    end
+    
+    # Find will grab all sizes of images, process the tags and standard attributes of a photo
+    def self.find(id)
+      photo_call = Query.api_call('flickr.photos.getInfo', "photo_id=#{id}")
+      
+      # Set basic attributes
+      photo = Photo.new(id, *%w(title description).map {|a| (photo_call/a).inner_text })
+      
+      # Set tags for photo
+      photo.tags = (photo_call/:tag).map{|tag| Tag.new tag.inner_text}
+      photo.machine_tags = (photo_call/:tag).map{|tag| MachineTag.new tag.inner_text }
+      
+      return photo
+    end
+    
+    # Get the photo sizes for the photo in an array
+    def sizes
+      hash = {}
+      (Query.api_call('flickr.photos.getSizes', "photo_id=#{id}")/:size).parallel_each(MAX_THREADS) do |size|
+        hash[size['label'].downcase.to_sym] = Size.new(*%w(width height source url).map{|a| size[a]})
+      end
+      hash
+    end
+    
+    private
+    # Parse applies Hpricot to the photos and maps them to a Photo class instance
+    def self.parse collection
+      photos = (collection/:photo)
+      photos.empty? ? [] : photos.parallel_map(MAX_THREADS) do |photo|
+        self.find(photo[:id])
+      end
+    end
+  end
+end

data/lib/myflickr/query.rb

@@ -0,0 +1,10 @@
+module Myflickr
+  class Query #:nodoc:
+    def self.api_call(method, resource_uri='') #:nodoc:
+      resource = "#{API_BASE}/?method=#{method}&api_key=#{API_KEY}&user_id=#{USER_ID}"
+      resource += "&#{resource_uri}" unless resource_uri.empty?
+      puts "Querying: #{resource}"
+      Hpricot.XML(open(resource))
+    end
+  end
+end

data/lib/myflickr/set.rb

@@ -0,0 +1,33 @@
+module Myflickr
+  class Set < Struct.new :id, :photo_count, :title, :description
+    attr_reader :photos
+    
+    # Get a list of available photosets
+    def self.list
+      parse(Query.api_call('flickr.photosets.getList'))
+    end
+    
+    # Get information regarding set by searching with the set's ID
+    def self.find id
+      parse(Query.api_call('flickr.photosets.getInfo', "photoset_id=#{id}"))[0]
+    end
+    
+    # Get the photos within a set 
+    # Queries:
+    # > photosets.getPhotos (1 call)
+    # > Photo.find ID (n calls)
+    def photos
+      (Query.api_call('flickr.photosets.getPhotos', "photoset_id=#{id}")/:photo).parallel_map(MAX_THREADS) do |photo|
+        Photo.find photo[:id]
+      end
+    end
+    
+    private 
+    def self.parse(collection) #:nodoc:
+      photosets = (collection/:photoset)
+      photosets.empty? ? [] : photosets.parallel_map(MAX_THREADS) do |set|
+        Set.new(set[:id], set[:photos], (set/:title).inner_text, (set/:description).inner_text)
+      end
+    end
+  end
+end

data/lib/myflickr/size.rb

@@ -0,0 +1,4 @@
+module Myflickr
+  class Size < Struct.new :width, :height, :source, :url #:nodoc:
+  end
+end

data/lib/myflickr/tag.rb

@@ -0,0 +1,10 @@
+module Myflickr
+  class Tag < Struct.new :value
+    # List all tags
+    def self.list
+     (Query.api_call('flickr.tags.getListUser')/:tag).parallel_map(MAX_THREADS) do |tag| 
+       Tag.new(tag.to_s)
+     end
+    end
+  end
+end

data/lib/myflickr/version.rb

@@ -0,0 +1,9 @@
+module Myflickr
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 2
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/myflickr.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'hpricot'
+require 'open-uri'
+require 'vendor/parallel/parallel'
+
+module Myflickr
+  API_BASE = "http://api.flickr.com/services/rest"
+  MAX_THREADS = 100
+end
+
+%w(query photo tag size set machine_tag version).each do |r|
+  require File.join(File.dirname(__FILE__), './myflickr/' + r)
+end

data/lib/vendor/parallel/parallel.rb

@@ -0,0 +1,121 @@
+# Stolen from http://rubyforge.org/projects/concurrent
+
+#
+# concurrent/parallel - data-parallel programming for Ruby
+#
+# Copyright (C) 2007  MenTaLguY <mental@rydia.net>
+#
+# This file is made available under the same terms as Ruby.
+#
+
+module Concurrent #:nodoc:
+module Parallel #:nodoc:
+end
+end
+
+module Enumerable #:nodoc:
+  def parallel_each( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.each &block }
+    end.each do |thread|
+      thread.join
+    end
+    self
+  end
+
+  def parallel_map( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.map &block }
+    end.inject( [] ) do |a, thread|
+      a.push *thread.value
+    end
+  end
+
+  def parallel_select( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.select &block }
+    end.inject( [] ) do |a, results|
+      a.push *thread.value
+    end
+  end
+
+  def parallel_reject( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.reject &block }
+    end.inject( [] ) do |a, thread|
+      a.push *thread.value
+    end
+  end
+
+  def parallel_max( n )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.max }
+    end.map { |t| t.value }.max
+  end
+
+  def parallel_min( n )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.min }
+    end.map { |t| t.value }.min
+  end
+
+  def parallel_partition( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.partition &block }
+    end.inject( [ [], [] ] ) do |acc, thread|
+      pair = thread.value
+      acc[0].push *pair[0]
+      acc[1].push *pair[1]
+      acc
+    end
+  end
+
+  def parallel_grep( re, n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.grep( re, &block ) }
+    end.inject( [] ) do |acc, thread|
+      acc.push *thread.value
+    end
+  end
+
+  def parallel_all?( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.all? &block }
+    end.inject( true ) do |acc, thread|
+      acc && thread.value
+    end
+  end
+
+  def parallel_any?( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.any? &block }
+    end.inject( false ) do |acc, thread|
+      acc || thread.value
+    end
+  end
+
+  def parallel_include?( n, obj )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.include? obj }
+    end.inject( false ) do |acc, thread|
+      acc || thread.value
+    end
+  end
+
+  def parallel_subsets( n )
+    to_a.parallel_subsets( n )
+  end
+end
+
+class Array #:nodoc:
+  def parallel_subsets( n )
+    if n > 1
+      slice_size = (size.to_f / n.to_f).ceil
+      (0...(size.to_f / slice_size)).map do |i|
+        self[i*slice_size, slice_size.ceil]
+      end
+    else
+      [ self ]
+    end
+  end
+end