flickru 0.0.1

data/bin/flickru

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+#flickru_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+#$LOAD_PATH.unshift(flickru_dir) unless $LOAD_PATH.include?(flickru_dir)
+
+require 'flickru'
+
+photo_dir = ARGV[0]
+
+if ARGV.length > 1
+  Flickru.usage
+  Flickru.die __LINE__, "wrong number of arguments: #{ARGV[1,ARGV.length]}"
+elsif photo_dir.nil? or photo_dir.empty?
+  Flickru.usage
+  Flickru.die __LINE__, "missing photo directory"
+end
+
+Flickru.flickru photo_dir

data/bin/geowiki

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+
+APP_NAME=`basename $0`
+
+function error {
+	echo -e "\E[31m$APP_NAME: $1: $2$(tput sgr0)" 1>&2
+}
+
+if [ $# -ne 1 ]; then
+	echo "$APP_NAME - find coordinates of a place described by Wikipedia"
+	echo "usage: $APP_NAME <place Wikipedia page>"
+	echo "example: $APP_NAME 'Mille-Isles, Quebec'"
+	error $LINENO "wrong number of arguments"
+	exit 1
+fi
+
+PAGE=`echo "$1" | tr ' ' '_'`
+
+# temporal file management
+if [ -d /tmp ]; then
+	TMP="/tmp/$PAGE.tmp.$$.$RANDOM.html"
+else
+	TMP="$PAGE.tmp.html"
+fi
+function clean_up {
+        rm -f "$TMP"
+        exit $1
+}
+trap clean_up SIGHUP SIGINT SIGTERM
+
+curl "http://en.wikipedia.org/wiki/$PAGE" > "$TMP" 2> /dev/null
+
+	if [ $? -ne 0 ]; then
+		error $LINENO "Wikipedia page '$PAGE' not found"
+		clean_up 1
+	fi
+
+URL=`cat "$TMP" | tr '"' '\n' | grep geohack | head -n 1 | sed -e 's|&amp;|\&|'`
+
+	if [ -z "$URL" ]; then
+		error $LINENO "location not found in Wikipedia page '$PAGE'"
+		clean_up 1
+	fi
+
+curl "$URL" > "$TMP" 2> /dev/null
+
+	if [ $? -ne 0 ]; then
+		error $LINENO "GeoHack URL '$URL' not found"
+		clean_up 1
+	fi
+
+cat "$TMP" | grep '<span class="geo"' | sed -e 's|^.*"Latitude">\([^<]*\)</span>, .*"Longitude">\([^<]*\)</span>.*$|\1, \2|'
+
+clean_up

data/lib/flickru.rb

@@ -0,0 +1,112 @@
+# ruby
+require 'etc'
+require 'set'
+# gems
+require 'rubygems'
+require 'bundler/setup'
+# flickru
+require 'flickru/file'
+require 'flickru/flickr'
+require 'flickru/journey'
+require 'flickru/printer'
+
+FlickRaw.api_key       = "aaf7253e0f88f03aa59f9d3074bf2d4b"
+FlickRaw.shared_secret = "138ee268f76cd780"
+
+module Flickru
+
+def Flickru.usage
+  filename = File.basename __FILE__
+  Printer.show "#{filename} -- command-line Flickr upload automator\n"
+  Printer.show "usage: #{filename} <photo directory>\n"
+  Printer.show "example: #{filename} my_photos\n"
+  Printer.show "\n#{IO.read('README')}\n"
+end
+
+def Flickru.die code, message
+  Printer.error "error:#{code}: #{message}"
+  exit 1
+end
+
+def Flickru.config_filename
+  File.join Etc.getpwuid.dir, "." + File.basename(__FILE__, File.extname(__FILE__)) + "rc"
+end
+
+def self.read_config
+  file = File.open config_filename, "r"
+  token, secret = file.readlines.map { |line| line.sub(/\#.*$/, '').strip } # remove line comments
+  file.close
+  Flickr.access token, secret
+rescue
+  raise RuntimeError, "unable to open configuration file #{config_filename}"
+end
+
+def Flickru.write_config token, secret
+    Printer.show "writing configuration file #{config_filename}... "
+  if File.exists? config_filename
+    file = File.new config_filename, "w"
+  else
+    file = File.open config_filename, "w"
+  end
+  file.puts "#{token} \# access token"
+  file.puts "#{secret} \# access secret"
+  file.close
+    Printer.success
+rescue
+  raise RuntimeError, "unable to write configuration file #{config_filename}"
+end
+
+def self.flickru photo_dir
+  begin
+    Flickru.read_config
+  rescue RuntimeError
+    token, secret = Flickr.login
+    write_config token, secret
+  end
+
+  # upload and classify
+  photos       = File.find(photo_dir) {|f| File.image? f or File.video? f }
+  total_size   = photos.reduce(0) {|t,p| t + File.size(p)}
+  Printer.info "#{File.human_readable_size total_size} to upload"
+  journey      = Journey.new total_size
+  photoset_ids = Set.new
+  photos.each do |photo|
+      Printer.info "file '#{File.join File.basename(File.dirname(photo)), File.basename(photo)}' under process"
+    begin
+      photo_id = Flickr.upload_photo photo
+      photoset_ids << Flickr.classify(photo, photo_id)
+    rescue ArgumentError || Errno::ENOENT || Errno::EAGAIN || FlickRaw::FailedResponse
+      Printer.failure "#{photo}: #{$!}"
+    end
+    journey.take File.size(photo)
+    Printer.info "#{File.human_readable_size journey.progress} uploaded, " +
+                 "#{File.human_readable_size journey.distance} remaining. " +
+                 "ETA: #{Printer.human_readable_seconds journey.eta}" if journey.eta > 0
+  end
+
+  photoset_ids.each do |set_id|
+    Flickr.arrangePhotos set_id
+  end
+
+  Printer.ask "Please, review whether: any of your photos need to be rotated,\n" +
+              "  better primary photos for your sets have been uploaded,\n" +
+              "  and better collection mosaics can be randomised."
+rescue
+  die __LINE__, $!
+end
+
+end # module Flickru
+
+if __FILE__ == $0
+  photo_dir = ARGV[0]
+
+  if ARGV.length > 1
+    Flickru.usage
+    Flickru.die __LINE__, "wrong number of arguments: #{ARGV[1,ARGV.length]}"
+  elsif not photo_dir or photo_dir.empty?
+    Flickru.usage
+    Flickru.die __LINE__, "missing photo directory"
+  end
+
+  Flickru.flickru photo_dir
+end

data/lib/flickru/file.rb

@@ -0,0 +1,64 @@
+# ruby
+require 'escape'
+require 'find'
+
+class File
+
+  def File.find dir
+    found = Array.new
+    Find.find dir do |file|
+      if File.directory? file
+        if File.basename(file)[0] == ?.
+          Find.prune # don't look any further into this directory
+        else
+          next
+        end
+      else
+        if yield file
+          found << file
+        end
+      end
+    end
+    found
+  end
+
+  def File.image? file
+    IMAGE_EXTENSIONS.include? File.extname(file).downcase
+  end
+
+  def File.video? file
+    VIDEO_EXTENSIONS.include? File.extname(file).downcase
+  end
+
+  def File.duration video
+    s = `#{Escape.shell_command ["ffmpeg", "-i", video]} 2>&1`
+    if s =~ /Duration: ([\d][\d]):([\d][\d]):([\d][\d]).([\d]+)/
+      hours     = $1.to_i
+      mins      = $2.to_i
+      seconds   = $3.to_i
+      # fractions = ("." + $4).to_f
+
+      hours * 60 * 60 + mins * 60 + seconds
+    else
+      0
+    end
+  end
+
+  def File.human_readable_size file_size
+    if file_size < 1000
+      file_size.to_s + " bytes"
+    elsif file_size < 1000000
+      (file_size / 1000).to_s + "KB"
+    elsif file_size < 1000000000
+      (file_size / 1000000).to_s + "MB"
+    else
+      (file_size / 1000000000).to_s + "GB"
+    end
+  end
+
+private
+
+  IMAGE_EXTENSIONS = [".gif", ".jpg", ".jpeg", ".png"] # lowercase
+  VIDEO_EXTENSIONS = [".mpeg", ".mpg", ".avi"] # lowercase
+
+end

data/lib/flickru/flickr.rb

@@ -0,0 +1,150 @@
+# gems
+require 'flickraw'
+require 'unicode_utils'
+# flickru
+require 'flickru/file'
+require 'flickru/location'
+require 'flickru/printer'
+require 'flickru/ruby'
+
+module Flickr
+
+  def self.access token, secret
+    flickr.access_token  = token
+    flickr.access_secret = secret
+  end
+
+  def self.login
+    token    = flickr.get_request_token
+    auth_url = flickr.get_authorize_url token['oauth_token'], :perms => 'write' # read, delete
+    Printer.ask  "Open this URL in your process to complete the authentication process:\n#{auth_url}\n"
+    Printer.enter "Copy the number given when you complete the process here"
+
+    verify = STDIN.gets.strip
+    flickr.get_access_token token['oauth_token'], token['oauth_token_secret'], verify
+
+    login = flickr.test.login
+      Printer.show "you are now authenticated as #{login.username} " +
+                   "with token #{flickr.access_token} and secret #{flickr.access_secret}\n"
+    [flickr.access_token, flickr.access_secret]
+  end
+
+  def self.size_limit_exceeded? file
+    if File.image? file
+      File.size(file).to_i > 20000000 # 20MB
+    elsif File.video? file
+      File.size(file).to_i > 500000000 # 500MB
+    else
+      raise ArgumentError, "#{file}: not an image nor a video"
+    end
+  end
+
+  def self.upload_photo photo
+    Ruby.assert("not Flickr.size_limit_exceeded?(photo)") \
+               { not Flickr.size_limit_exceeded?(photo) }
+
+      if File.duration(photo) > 90 # seconds
+        description = "video duration (#{File.duration photo} sec) exceeds Flickr's duration limit (90 sec)."
+        Printer.warn description
+        description = "This " + description + "\nDownload original file to play full video."
+      end
+
+    date = File.mtime(photo).strftime("%y-%m-%d %H:%M:%S")
+    loc  = Location.new photo
+      Printer.show "uploading as " +
+                   (loc.nil? ? "\"#{loc.name.black}\" (no location given)" : loc.to_s.black) +
+                   " taken on #{date}... "
+    begin
+      id = flickr.upload_photo photo, :title => UnicodeUtils.nfkc(loc.name), :is_public => 0,
+                                      :description => description, :tags => UPLOADING_TAG,
+                                      :is_friend => 1, :is_family => 1, :safety_level => 1, # Safe,
+                                      :content_type => 1, :hidden => 2 # Photo/Video
+# TODO visibility MAY be configurable
+      req = flickr.photos.getNotInSet(:extras => 'tags').to_hash["photo"][-1]
+    rescue Timeout::Error
+      Flickru.read_config
+      req = flickr.photos.getNotInSet(:extras => 'tags').to_hash["photo"][-1]
+      if req.nil?
+        raise RuntimeError, "unrecoverable timeout due to large file size"
+      else
+        if req.to_hash["tags"] != UPLOADING_TAG
+          raise RuntimeError, "unrecoverable timeout due to large file size"
+        end
+        id = req.to_hash["id"]
+      end
+    end
+    flickr.photos.setTags :photo_id => id, :tags => ''
+
+    flickr.photos.setDates :photo_id => id, :date_taken => date
+    flickr.photos.setPerms :photo_id => id, :perm_comment => 1, :perm_addmeta => 0
+# TODO permission MAY be configurable
+    if not loc.nil?
+      flickr.photos.geo.setLocation :photo_id => id, :lat => loc.latitude,
+                                    :lon => loc.longitude, :accuracy => loc.accuracy                             
+    end
+
+    Printer.success
+
+    return id
+  end
+
+# TODO face tagging (http://developers.face.com http://github.com/rociiu/face) MAY be available
+
+  def self.classify photo_path, photo_id
+    set_title  = File.basename(File.dirname(File.dirname(photo_path)))
+    set_id     = Flickr.photoset_id set_title
+    photo_name = File.basename(photo_path, File.extname(photo_path))
+    if set_id
+        Printer.show "classifying #{photo_name.black} under set #{set_title}... "
+      flickr.photosets.addPhoto :photoset_id => set_id, :photo_id => photo_id
+        Printer.success
+    else
+        Printer.show "creating photoset #{set_title.black} with primary photo #{photo_name}... "
+      response = flickr.photosets.create :title => set_title, :primary_photo_id => photo_id
+      set_id   = response.to_hash["id"]
+        Printer.success
+
+# TODO new photosets MAY be included in some collection. Unfortunately, collections cannot be yet modified by the Flickr API.
+# TODO photosets MAY be ordered alphabetically (flickr.photosets.orderSets API function)
+      Printer.ask "Please, choose yourself a better primary photo for this photoset,\n" +
+                  "  order your photosets for positioning this new addition,\n" +
+                  "  and include the new photoset in some collection."
+    end
+
+    return set_id
+  end
+
+  def self.arrangePhotos set_id
+    set_title = flickr.photosets.getInfo(:photoset_id => set_id).to_hash["title"]
+
+      Printer.show "arranging photos in photoset #{set_title.black} by date taken (older first)... "
+    response = flickr.photosets.getPhotos(:photoset_id => set_id, :extras => "date_taken").to_hash
+    if response["pages"] == 1
+      photos    = response["photo"].sort! { |a,b| a["datetaken"] <=> b["datetaken"] } # older first
+      photo_ids = photos.map { |photo| photo["id"].to_s }
+      if not photo_ids.empty?
+        photo_ids = photo_ids[1,photo_ids.length].reduce photo_ids[1] do |s,i| s + ',' + i end
+        flickr.photosets.reorderPhotos :photoset_id => set_id, :photo_ids => photo_ids
+      end
+        Printer.success
+    else
+        Printer.failure "photoset #{set_title} has more than #{response['perpage']} photos."
+      Printer.ask "Please, arrange by date taken (older first) within Flickr Organizr."
+    end
+  end
+
+  def self.photoset_id set_title
+    flickr.photosets.getList.each do |photoset|
+      if photoset["title"] == set_title
+        return photoset["id"]
+      end
+    end
+
+    return nil
+  end
+
+private
+
+  UPLOADING_TAG = "uploading"
+
+end

data/lib/flickru/journey.rb

@@ -0,0 +1,38 @@
+# flickru
+require 'flickru/ruby'
+
+class Journey
+
+  def initialize destination
+    Ruby.assert("destination >= 0") { destination >= 0 }
+
+    @distance    = destination
+    @destination = destination
+    @beginning   = Time.now
+    @current     = Time.now
+  end
+
+  def take step
+    Ruby.assert("@distance >= step") { @distance >= step }
+
+    @distance -= step
+    @current   = Time.now
+  end
+
+  def progress
+    @destination - @distance
+  end
+
+  def distance
+    @distance
+  end
+
+  def elapsed
+    @current - @beginning
+  end
+
+  def eta # seconds
+    @distance * elapsed / progress 
+  end
+
+end

data/lib/flickru/location.rb

@@ -0,0 +1,96 @@
+# gems
+require 'escape'
+# flickru
+require 'flickru/ruby'
+require 'flickru/string'
+
+class Location
+
+  GEOWIKI = File.expand_path(File.join File.dirname(__FILE__), '..', '..', 'bin', 'geowiki')
+  DEFAULT_ACCURACY = "street"
+  COORD_PATTERN = "-?[0-9]+\.?[0-9]*"
+
+  attr_accessor :name, :place, :latitude, :longitude, :accuracy
+
+  def initialize photo
+    dir   = File.basename File.dirname(photo)
+    name, place, accuracy = Location.parse dir
+    raise RuntimeError, "unnamed location #{dir}" if name.nil?
+    @name = name
+    begin
+      @place    = place.nil? ? name : place
+      @latitude, @longitude = Location.locate @place
+      @accuracy = Location.s_to_accuracy(accuracy ? accuracy : DEFAULT_ACCURACY)
+    rescue RuntimeError
+      raise if place
+      raise RuntimeError, "location #{name} not found" if accuracy
+      @place, @latitude, @longitude, @accuracy = nil # no location
+    end
+  end
+
+  def nil?
+    Ruby.assert("@accuracy.nil? implies @latitude.nil? and @longitude.nil?") {
+      @accuracy.nil? or not (@latitude.nil? and @longitude.nil?)
+    }
+
+    @accuracy.nil?
+  end
+
+  def to_s
+    place = @place.nil? ? "an undefined place" : @place
+    "\"#{@name}\" at #{place} (~#{accuracy_to_s}) " +
+    "on lat: #{@latitude}, lon: #{@longitude}"
+  end
+
+private
+
+  def self.parse location
+# TODO special characters MAY be escaped
+    idx_accuracy = location.index('#') ? location.index('#') : location.length
+    idx_place    = location.index('@') ? location.index('@') : idx_accuracy
+
+    name     = location.sub(/[@#].*$/, '').strip | nil
+    place    = location.index('@') ? location.sub(/^.*@/, '').sub(/\#.*$/, '').strip : nil
+    accuracy = location.index('#') ? location.sub(/^.*#/, '').strip : nil
+
+    [name, place, accuracy]
+  end
+
+  def self.locate place
+    the_place = place # needed for RuntimeError reporting
+    begin
+      place = `#{Escape.shell_command [GEOWIKI, place]} 2> /dev/null`[0..-2] \
+        if place !~ /^#{COORD_PATTERN}, *#{COORD_PATTERN}$/
+      if place =~ /^#{COORD_PATTERN}, *#{COORD_PATTERN}$/
+        # latitude, longitude
+        [place.sub(/, *#{COORD_PATTERN}$/, ''), place.sub(/^#{COORD_PATTERN}, */, '')]
+      else
+        raise RuntimeError
+      end
+    rescue
+      raise RuntimeError, "location #{the_place} not found"
+    end
+  end
+
+  def Location.s_to_accuracy str
+    case str.downcase
+    when "world"   then 1
+    when "country" then 3
+    when "region"  then 6
+    when "city"    then 11
+    when "street"  then 16
+    else raise ArgumentError, "unknown accuracy label '#{str}'"
+    end
+  end
+
+  def accuracy_to_s
+    case @accuracy
+    when  1 then "world"
+    when  3 then "country"
+    when  6 then "region"
+    when 11 then "city"
+    when 16 then "street"
+    else         @accuracy
+    end
+  end
+end

data/lib/flickru/printer.rb

@@ -0,0 +1,52 @@
+# gems
+require 'colorize'
+# flickru
+require 'flickru/ruby'
+
+module Printer
+
+  def self.human_readable_seconds seconds
+    Ruby.assert("seconds >= 0") { seconds >= 0 }
+
+    return "%.1f" % seconds + " seconds" if seconds < 60
+    minutes  = seconds / 60
+    return "%.1f" % minutes + " minutes" if minutes < 60
+    hours    = minutes / 60
+    return "%.1f" % hours   + " hours"   if hours   < 24
+    days     = hours / 24
+    return "%.1f" % days    + " days"
+  end
+
+  def self.show msg
+    print msg
+  end
+
+  def self.info msg
+    puts msg.cyan
+  end
+
+  def self.warn msg
+    puts ("warning: " + msg).magenta
+  end
+
+  def self.error msg
+    STDERR.puts msg.red
+  end
+
+  def self.enter msg
+    print (">>> " + msg + ": ").black
+  end
+
+  def self.ask msg
+    puts ("*** " + msg + " ***").light_blue
+  end
+
+  def self.success
+    puts "done".green
+  end
+
+  def self.failure msg=nil
+    puts ("fail" + (msg.nil? ? "" : ": " + msg)).red
+  end
+
+end

data/lib/flickru/ruby.rb

@@ -0,0 +1,24 @@
+module Ruby
+
+  def self.assert msg=nil
+    if $DEBUG
+      raise ArgumentError, msg || "assertion failed" unless yield
+    end
+  end
+
+  def self.caller_method_name
+    parse_caller(caller(2).first).last
+  end
+
+private
+
+  def self.parse_caller at
+    if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
+      file = Regexp.last_match[1]
+      line = Regexp.last_match[2].to_i
+      method = Regexp.last_match[3]
+      [file, line, method]
+    end
+  end
+
+end

data/lib/flickru/string.rb

@@ -0,0 +1,5 @@
+class String
+  def | what
+    self.strip.empty? ? what : self
+  end
+end

data/lib/flickru/version.rb

@@ -0,0 +1,5 @@
+module Flickru
+  unless defined? VERSION
+    VERSION = "0.0.1"
+  end
+end

data/spec/flickru_spec.rb

@@ -0,0 +1,41 @@
+# gems
+require 'colorize'
+require 'simplecov'
+SimpleCov.coverage_dir(File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'var', 'cov')))
+SimpleCov.start # should be before loading flickru code!
+# flickru
+require 'flickru'
+
+describe Flickru do
+  it "accents work" do
+    Flickru.flickru "var/ts/tc_accents"
+  end
+
+  it "different accuracies work case-insensitively" do
+    Flickru.flickru "var/ts/tc_accuracies"
+  end
+
+  it "several collections, several sizes" do
+    Flickru.flickru "var/ts/tc_collections"
+  end
+
+  it "various filetypes available, skipping garbage" do
+    Flickru.flickru "var/ts/tc_filetypes"
+  end
+
+  it "large files work" do
+    Flickru.flickru "var/ts/tc_large_files"
+  end
+
+  it "locations can be specified in many ways" do
+    Flickru.flickru "var/ts/tc_locations"
+  end
+
+  it "leading and trailing whitespaces are removed" do
+    Flickru.flickru "var/ts/tc_whitespaces"
+  end
+
+  after(:all) do
+    puts "\nRemember to delete the testing files that have been just uploaded to your Flickr's collection 'Testing Collection*'.".red
+  end
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification 
+name: flickru
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Jes\xC3\xBAs Pardillo"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-18 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: colorize
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.5.8
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: escape
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.0.4
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: flickraw
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.4
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rubygems-update
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.8.11
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.5.4
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: unicode_utils
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.1.2
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.7.0
+  type: :development
+  version_requirements: *id007
+description: |
+  Command-line tool 'flickru' automatises photos/videos uploads to Flickr.
+  
+  Entering 'flickru <directory>' in your command line, any photos under 'directory' (and subdirs)
+  are uploaded to your Flickr account (interactively entered at the first time you start flickru).
+  
+  Photos are identified by case-insensitive extensions: GIF, JPEG, JPG, and PNG.
+  Videos are identified by case-insensitive extensions: AVI, MPEG, and MPG.
+  
+  The following Flickr metadata for photos (as well as videos) is set:
+   - date-taken from the file (last) modification time
+   - private, visible by friends & family, hidden for public searches
+   - safety level to safe
+   - permission for friends & family to add comments to the photo and it's notes
+   - permission for nobody to add notes and tags to the photo
+   - for videos larger than the Flickr's longer than 90s (but shorter than 500MB,
+     Flickr's maximum permisible size), the description will contain an annotation
+     about its large duration.
+   - title, geolocation, and accuracy from the owner directory's name.
+  Owner directory name format is given by the format 'TITLE[@LOCATION[#PRECISION]]',
+  where:
+   - TITLE is the desired title for the photos directly stored in the directory
+   - LOCATION is the location of the stored photos specified as either:
+     - the Wikipedia page name (whitespaces allowed) of the location (if exists) or
+     - its coordinates LATITUDE,LONGITUDE
+   - PRECISION is the Flickr geolocation precision given by one of the following
+     case insentitive literals: street, city, region, country, world.
+  
+  Photos are classified into a photoset (existing or not) entitled with the
+  second-level directory name containing the photo. The photoset is arranged by
+  date taken (older first).
+  
+  To see some examples on the directory structure recognised by flickru, please
+  explore the subdirectories under var/ts.
+
+email: 
+- dev@jesuspardillo.com
+executables: 
+- flickru
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/flickru
+- bin/geowiki
+- lib/flickru.rb
+- lib/flickru/file.rb
+- lib/flickru/flickr.rb
+- lib/flickru/journey.rb
+- lib/flickru/location.rb
+- lib/flickru/printer.rb
+- lib/flickru/ruby.rb
+- lib/flickru/string.rb
+- lib/flickru/version.rb
+- spec/flickru_spec.rb
+homepage: http://rubygems.org/gems/flickru
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Command-line Flickr Upload Automator
+test_files: 
+- spec/flickru_spec.rb