flickrie 0.7.3 → 1.0.0

data/lib/flickrie/media.rb

@@ -24,28 +24,22 @@ module Flickrie
     #   photo.exif.get('X-Resolution', :data => 'raw')   # => '180'
     #   photo.exif.get('X-Resolution', :data => 'clean') # => '180 dpi'
     #   photo.exif.get('X-Resolution')                   # => '180 dpi'
-    #
     def exif() Exif.new(@info['exif']) rescue nil end
 
     def views_count()    Integer(@info['views'])          rescue nil end
     def comments_count() Integer(@info['comments_count']) rescue nil end
 
     # Returns an instance of Flickrie::Location
-    #
     def location() Location.new(@info['location']) rescue nil end
     # Returns an instance of Flickrie::Media::Visibility
-    #
     def geo_permissions() Visibility.new(@info['geoperms']) rescue nil end
 
     # Returns an array of Flickrie::Media::Tag
-    #
     def tags() @info['tags'].map { |info| Tag.new(info) }     rescue nil end
     # Returns an array of Flickrie::Media::Tag
-    #
     def machine_tags() tags.select { |tag| tag.machine_tag? } rescue nil end
 
     # Returns an instance of Flickrie::License
-    #
     def license() License.new(@info['license']) rescue nil end
 
     def posted_at()   Time.at(Integer(@info['dates']['posted']))           rescue nil end
@@ -55,7 +49,6 @@ module Flickrie
     def taken_at_granularity() Integer(@info['dates']['takengranularity']) rescue nil end
 
     # Returns an instance of Flickrie::User
-    #
     def owner() User.new(@info['owner']) rescue nil end
 
     def safety_level() Integer(@info['safety_level']) rescue nil end
@@ -75,7 +68,6 @@ module Flickrie
     end
 
     # Returns an instance of Flickrie::Media::Visibility
-    #
     def visibility() Visibility.new(@info['visibility']) rescue nil end
 
     def primary?() Integer(@info['isprimary']) == 1 rescue nil end
@@ -98,11 +90,9 @@ module Flickrie
     def faved?() Integer(@info['is_faved']) == 1 rescue nil end
 
     # Returns an array of Flickrie::Media::Note
-    #
     def notes() @info['notes']['note'].map { |hash| Note.new(hash) } rescue nil end
 
     # Returns an array of Flickrie::User
-    #
     def favorites() @info['person'].map { |info| User.new(info) } rescue nil end
 
     def [](key) @info[key] end
@@ -221,17 +211,11 @@ module Flickrie
       end
 
       def from_context(hash)
-        hash['count'] = hash['count']['_content'].to_i
-
-        ['prevphoto', 'nextphoto'].each do |media|
-          unless hash[media]['media'].nil?
-            hash[media] = new(hash[media])
-          else
-            hash[media] = nil
-          end
-        end
-
-        hash
+        count = hash['count']['_content'].to_i
+        previous_photo = new(hash['prevphoto']) rescue nil
+        next_photo = new(hash['nextphoto']) rescue nil
+        Struct.new(:count, :previous, :next).new \
+          count, previous_photo, next_photo
       end
 
       def from_exif(info)

data/lib/flickrie/media_count.rb

@@ -17,6 +17,10 @@ module Flickrie
 
       dates.first..dates.last
     end
+    alias time_interval date_range
+
+    def from() date_range.begin end
+    def to()   date_range.end   end
 
     def [](key) @info[key] end
     def hash() @info end

data/lib/flickrie/middleware.rb

@@ -0,0 +1,71 @@
+require 'faraday'
+require 'faraday_middleware/response_middleware'
+
+module Flickrie
+  class Error < StandardError
+    attr_reader :code
+
+    def initialize(message, code = nil)
+      super(message)
+      @code = code.to_i
+    end
+  end
+
+  # Internal
+  module Middleware # :nodoc:
+    class StatusCheck < Faraday::Response::Middleware
+      def on_complete(env)
+        if env[:body]['stat'] != 'ok'
+          raise Error.new(env[:body]['message'], env[:body]['code'])
+        end
+      end
+    end
+
+    class UploadStatusCheck < Faraday::Response::Middleware
+      def on_complete(env)
+        if env[:body]['rsp']['stat'] != 'ok'
+          error = env[:body]['rsp']['err']
+          raise Error.new(error['msg'], error['code'])
+        end
+      end
+    end
+
+    class OAuthCheck < Faraday::Response::Middleware
+      def on_complete(env)
+        if env[:status] != 200
+          message = env[:body][/(?<=oauth_problem=)[^&]+/]
+          pretty_message = message.gsub('_', ' ').capitalize
+          raise Error.new(pretty_message)
+        end
+      end
+    end
+
+    class Retry < Faraday::Middleware
+      def initialize(app, retries = 2)
+        @retries = retries
+        super(app)
+      end
+
+      def call(env)
+        retries = @retries
+        begin
+          @app.call(env)
+        rescue Faraday::Error::TimeoutError
+          if retries > 0
+            retries -= 1
+            retry
+          end
+          raise
+        end
+      end
+    end
+
+    class ParseOAuthParams < FaradayMiddleware::ResponseMiddleware
+      define_parser do |body|
+        CGI.parse(body).inject({}) do |hash, (key, value)|
+          hash.update(key.to_sym => value.first)
+        end
+      end
+    end
+  end
+end

data/lib/flickrie/oauth.rb

@@ -1,92 +1,101 @@
 require 'faraday_middleware'
-require 'faraday_middleware/response_middleware'
 
 module Flickrie
   module OAuth
     URL = 'http://www.flickr.com/services/oauth'.freeze
     NO_CALLBACK = 'oob'.freeze
 
-    # :nodoc:
-    def self.new_connection(additional_oauth_params = {})
-      Faraday.new(URL) do |conn|
-        conn.use FaradayMiddleware::OAuth, {
-            :consumer_key => Flickrie.api_key,
-            :consumer_secret => Flickrie.shared_secret
-          }.merge(additional_oauth_params)
+    private
 
-        conn.use StatusCheck
-        conn.use ParseResponseParams
+      def self.new_connection(request_token = nil) # :nodoc:
+        Faraday.new(params) do |b|
+          b.use Middleware::Retry
+          b.use FaradayMiddleware::OAuth,
+            :consumer_key => Flickrie.api_key,
+            :consumer_secret => Flickrie.shared_secret,
+            :token => request_token.to_a.first,
+            :token_secret => request_token.to_a.last
 
-        conn.adapter :net_http
-      end
-    end
+          b.use Middleware::ParseOAuthParams
+          b.use Middleware::OAuthCheck
 
-    class StatusCheck < Faraday::Response::Middleware # :nodoc:
-      def on_complete(env)
-        if env[:status] != 200
-          raise Error, env[:body]['oauth_problem'].gsub('_', ' ').capitalize
+          b.adapter :net_http
         end
       end
-    end
 
-    class Error < StandardError
-    end
-
-    class ParseResponseParams < FaradayMiddleware::ResponseMiddleware # :nodoc:
-      define_parser do |body|
-        params_array = body.split('&').map { |param| param.split('=') }
-        params_array.map! { |params| params.count == 1 ? params << "" : params}
-        Hash[*params_array.flatten]
+      def self.params
+        {
+          :url => URL,
+          :request => {
+            :open_timeout => Flickrie.open_timeout || OPEN_TIMEOUT,
+            :timeout => Flickrie.timeout || TIMEOUT
+          }
+        }
       end
-    end
 
-    # :doc:
+    public
+
     def self.get_request_token(options = {})
       connection = new_connection
-
       response = connection.get "request_token" do |req|
         req.params[:oauth_callback] = options[:callback_url] || NO_CALLBACK
       end
 
-      RequestToken.from_response(response.body)
+      RequestToken.new(response.body)
     end
 
     def self.get_access_token(verifier, request_token)
-      connection = new_connection \
-        :token => request_token.token,
-        :token_secret => request_token.secret
-
+      connection = new_connection(request_token)
       response = connection.get "access_token" do |req|
         req.params[:oauth_verifier] = verifier
       end
 
-      AccessToken.from_response(response.body)
+      AccessToken.new(response.body)
     end
 
-    module Token # :nodoc:
-      def from_response(body)
-        new(body['oauth_token'], body['oauth_token_secret'])
+    module Token
+      attr_reader :token, :secret
+
+      def initialize(info)
+        @token = info[:oauth_token]
+        @secret = info[:oauth_token_secret]
+      end
+
+      def to_a
+        [token, secret]
       end
     end
 
-    class RequestToken < Struct.new(:token, :secret)
-      extend Token
+    class RequestToken
+      include Token
 
-      def get_authorization_url(options = {})
+      def get_authorization_url(params = {})
         require 'uri'
         url = URI.parse(URL)
-        url.path += "/authorize"
-        params = {
-          :oauth_token => token,
-          :perms => options[:permissions] || options[:perms]
-        }
-        url.query = params.map { |k, v| "#{k}=#{v}" }.join('&')
+        url.path += '/authorize'
+        query_params = {:oauth_token => token}.merge(params)
+        url.query = query_params.map { |k,v| "#{k}=#{v}" }.join('&')
         url.to_s
       end
+      alias authorize_url get_authorization_url
+
+      def get_access_token(verifier)
+        OAuth.get_access_token(verifier, self)
+      end
     end
 
-    class AccessToken < Struct.new(:token, :secret)
-      extend Token
+    class AccessToken
+      include Token
+
+      attr_reader :user_info
+
+      def initialize(info)
+        super
+        @user_info = info.tap do |info|
+          info.delete(:oauth_token)
+          info.delete(:oauth_token_secret)
+        end
+      end
     end
   end
 end

data/lib/flickrie/photo.rb

@@ -1,6 +1,5 @@
 module Flickrie
   # See Flickrie::Media for the other methods.
-  #
   class Photo
     include Media
 
@@ -66,7 +65,6 @@ module Flickrie
     def rotation() Integer(@info['rotation']) rescue nil end
 
     # Same as calling <tt>Flickrie.get_photo_sizes(photo.id)</tt>
-    #
     def get_sizes(params = {}, info = nil)
       info ||= Flickrie.client.get_media_sizes(id, params).body['sizes']
       @info['usage'] ||= {}

data/lib/flickrie/set.rb

@@ -20,17 +20,13 @@ module Flickrie
     end
 
     # Returns an instance of Flickrie::User
-    #
     def owner() User.new('nsid' => @info['owner']) if @info['owner'] end
 
     # Same as calling <tt>Flickrie.photos_from_set(set.id)</tt>
-    #
     def photos(params = {}) Flickrie.photos_from_set(id, params) end
     # Same as calling <tt>Flickrie.videos_from_set(set.id)</tt>
-    #
     def videos(params = {}) Flickrie.videos_from_set(id, params) end
     # Same as calling <tt>Flickrie.media_from_set(set.id)</tt>
-    #
     def media(params = {})  Flickrie.media_from_set(id, params)  end
 
     def can_comment?() Integer(@info['can_comment']) == 1 rescue nil end
@@ -51,7 +47,6 @@ module Flickrie
     def hash() @info end
 
     # Same as calling <tt>Flickrie.get_set_info(set.id)</tt>
-    #
     def get_info(info = nil)
       info ||= Flickrie.client.get_set_info(id).body['photoset']
       @info.update(info)

data/lib/flickrie/upload_client.rb

@@ -1,3 +1,5 @@
+require 'faraday_middleware'
+
 module Flickrie
   class << self
     # :nodoc:
@@ -6,19 +8,20 @@ module Flickrie
     end
 
     def new_upload_client(access_token_hash = {})
-      UploadClient.new(upload_params) do |conn|
-        conn.use FaradayMiddleware::OAuth,
+      UploadClient.new(upload_params) do |b|
+        b.use Middleware::Retry
+        b.use FaradayMiddleware::OAuth,
           :consumer_key => api_key,
           :consumer_secret => shared_secret,
           :token => access_token_hash[:token] || access_token,
           :token_secret => access_token_hash[:secret] || access_secret
-        conn.request :multipart
+        b.request :multipart
 
-        conn.use UploadStatusCheck
-        conn.use FaradayMiddleware::ParseXml
-        conn.use OAuthStatusCheck
+        b.use Middleware::UploadStatusCheck
+        b.use FaradayMiddleware::ParseXml
+        b.use Middleware::OAuthCheck
 
-        conn.adapter :net_http
+        b.adapter :net_http
       end
     end
 
@@ -28,40 +31,35 @@ module Flickrie
       {
         :url => 'http://api.flickr.com/services',
         :request => {
-          :open_timeout => open_timeout || DEFAULTS[:open_timeout]
+          :open_timeout => open_timeout || OPEN_TIMEOUT
         }
       }
     end
   end
 
-  class UploadStatusCheck < Faraday::Response::Middleware # :nodoc:
-    def on_complete(env)
-      if env[:body]['rsp']['stat'] != 'ok'
-        error = env[:body]['rsp']['err']
-        raise Error.new(error['msg'], error['code']),
-          error['msg']
-      end
-    end
-  end
-
   class UploadClient < Faraday::Connection # :nodoc:
     def upload(media, params = {})
-      media_file = get_file(media, params[:mime_type])
-      media_title = get_title(media)
-      post "upload", {:photo => media_file,
-        :title => media_title}.merge(params)
+      file = get_file(media, params[:content_type])
+      title = file.original_filename.match(/\.\w{3,4}$/).pre_match
+      post "upload", {
+        :photo => file,
+        :title => title
+      }.merge(params)
     end
 
     def replace(media, media_id, params = {})
-      media_file = get_file(media, params[:mime_type])
-      media_title = get_title(media)
-      post "replace", {:photo => media_file,
-        :photo_id => media_id, :title => media_title}.merge(params)
+      file = get_file(media, params[:content_type])
+      title = file.original_filename.match(/\.\w{3,4}$/).pre_match
+      post "replace", {
+        :photo => file,
+        :photo_id => media_id,
+        :title => title
+      }.merge(params)
     end
 
     private
 
-    MIME_TYPES = {
+    CONTENT_TYPES = {
       %w[.jpg .jpeg .jpe .jif .jfif .jfi] => 'image/jpeg',
       %w[.gif]                            => 'image/gif',
       %w[.png]                            => 'image/png',
@@ -80,40 +78,31 @@ module Flickrie
       %w[.avi]                                => 'video/avi'
     }.freeze
 
-    def get_file(object, mime_type = nil)
-      if object.class.name == "String" # file path
-        file_path = object
-        mime_type ||= get_mime_type(file_path)
-      elsif object.class.name == "ActionDispatch::Http::UploadedFile" # Rails
-        file_path = object.tempfile
-        mime_type ||= object.content_type
-      elsif object.class.name == "Hash" # Sinatra
-        file_path = object[:tempfile].path
-        mime_type ||= object[:type]
-      end
+    def get_file(object, content_type = nil)
+      file, content_type, file_path =
+        case object.class.name
+        when "String"
+          # file path
+          [File.open(object), content_type || determine_content_type(object), object]
+        when "ActionDispatch::Http::UploadedFile"
+          # file from Rails
+          [object, object.content_type, object.tempfile]
+        when "Hash"
+          # file from Sinatra
+          [object[:tempfile], object[:type], object[:tempfile].path]
+        else
+          raise Error, "Invalid file format"
+        end
 
-      Faraday::UploadIO.new(file_path, mime_type)
+      Faraday::UploadIO.new(file, content_type, file_path)
     end
 
-    def get_mime_type(file_path)
-      extension = file_path[/\.\w{3,4}$/]
-      mime_type = MIME_TYPES.find { |k,v| k.include?(extension) }.last
+    def determine_content_type(file_path)
+      extension = file_path[/\.\w+$/]
+      content_type = CONTENT_TYPES.find { |k,v| k.include?(extension) }.last
 
     rescue NoMethodError
-      raise Error, "Don't know mime type for this extension (#{extension})"
-    end
-
-    def get_title(object)
-      filename =
-        if object.class.name == "String" # file path
-          File.basename(object)
-        elsif object.class.name == "ActionDispatch::Http::UploadedFile" # Rails
-          object.original_filename
-        elsif object.class.name == "Hash" # Sinatra
-          object[:filename]
-        end
-
-      filename.match(/\.\w{3,4}$/).pre_match
+      raise Error, "Don't know the content type for this extension (#{extension})"
     end
   end
 end

data/lib/flickrie/user.rb

@@ -7,11 +7,7 @@ module Flickrie
     def username()     @info['username']    end
     def real_name()    @info['realname']    end
     def location()     @info['location']    end
-    def time_zone()    @info['timezone']    end
     def description()  @info['description'] end
-    def profile_url()  @info['profileurl']  end
-    def mobile_url()   @info['mobileurl']   end
-    def photos_url()   @info['photosurl']   end
     def path_alias()   @info['path_alias']  end
     def icon_server()  @info['iconserver']  end
     def icon_farm()    @info['iconfarm']    end
@@ -26,21 +22,26 @@ module Flickrie
       end
     end
 
+    # ==== Example
+    #
+    #   user.time_zone.offset # => "+01:00"
+    #   user.time_zone.label  # => "Sarajevo, Skopje, Warsaw, Zagreb"
+    def time_zone() Struct.new(:label, :offset).new(*@info['timezone'].values) rescue nil end
+
+    def photos_url()  @info['photosurl']  || "http://www.flickr.com/photos/#{nsid || id}" end
+    def profile_url() @info['profileurl'] || "http://www.flickr.com/people/#{nsid || id}" end
+    def mobile_url()  @info['mobileurl'] end
+
     def first_taken() DateTime.parse(@info['photos']['firstdatetaken']).to_time rescue nil end
     def first_uploaded() Time.at(Integer(@info['photos']['firstdate'])) rescue nil end
 
     def favorited_at() Time.at(Integer(@info['favedate'])) rescue nil end
 
-    def favorited_at
-      Time.at(@info['favedate'].to_i)
-    end
-
     def media_count() Integer(@info['photos']['count']) rescue nil end
     alias photos_count media_count
     alias videos_count media_count
 
     # The same as calling <tt>Flickrie.public_photos_from_user(user.nsid)</tt>
-    #
     def public_photos() Flickrie.public_photos_from_user(nsid || id) end
 
     def pro?() Integer(@info['ispro']) == 1 rescue nil end
@@ -49,7 +50,6 @@ module Flickrie
     def hash() @info end
 
     # The same as calling <tt>Flickrie.get_user_info(user.nsid)</tt>
-    #
     def get_info(params = {}, info = nil)
       info ||= Flickrie.client.get_user_info(nsid || id, params).body['person']
       @info.update(info)

data/lib/flickrie/version.rb

@@ -1,3 +1,3 @@
 module Flickrie
-  VERSION = "0.7.3"
+  VERSION = "1.0.0"
 end

data/lib/flickrie/video.rb

@@ -1,6 +1,5 @@
 module Flickrie
   # See Flickrie::Media for the other methods.
-  #
   class Video
     include Media
 
@@ -18,7 +17,6 @@ module Flickrie
     def mobile_download_url() @video['mobile_download_url'] end
 
     # This fetches the #source_url, #download_url and the #mobile_download_url
-    #
     def get_sizes(params = {}, info = nil)
       info ||= Flickrie.client.get_media_sizes(id, params).body['sizes']
       @info['usage'] ||= {}

data/spec/{api_methods_spec.rb → flickrie/api_methods_spec.rb}

@@ -1,42 +1,42 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'spec_helper'
 
 describe Flickrie::ApiMethods do
   it "should upload and delete correctly", :vcr, :cassette => "upload and delete" do
-    media_id = @flickrie.upload(PHOTO_PATH)
-    @flickrie.public_media_from_user(USER_NSID).map(&:id).should include(media_id)
-    @flickrie.delete_media(media_id)
-    @flickrie.public_media_from_user(USER_NSID).map(&:id).should_not include(media_id)
+    media_id = Flickrie.upload(PHOTO_PATH)
+    Flickrie.public_media_from_user(USER_NSID).map(&:id).should include(media_id)
+    Flickrie.delete_media(media_id)
+    Flickrie.public_media_from_user(USER_NSID).map(&:id).should_not include(media_id)
   end
 
   it "should upload asynchronously correctly", :vcr, :cassette => "asynchronous upload" do
-    ticket_id = @flickrie.upload(PHOTO_PATH, :async => 1)
+    ticket_id = Flickrie.upload(PHOTO_PATH, :async => 1)
     begin
-      ticket = @flickrie.check_upload_tickets([ticket_id]).first
+      ticket = Flickrie.check_upload_tickets([ticket_id]).first
     end until ticket.complete?
     photo_id = ticket.photo_id
     Flickrie.get_photo_info(photo_id).id.should eq(photo_id)
-    @flickrie.delete_photo(photo_id)
+    Flickrie.delete_photo(photo_id)
   end
 
   it "should replace correctly", :vcr, :cassette => "replace" do
     begin
-      id = @flickrie.upload(PHOTO_PATH)
-      @flickrie.replace(PHOTO_PATH, id)
+      id = Flickrie.upload(PHOTO_PATH)
+      Flickrie.replace(PHOTO_PATH, id)
     rescue => exception
       exception.code.should eq(1) # Not a pro account
     ensure
-      @flickrie.delete_media(id)
+      Flickrie.delete_media(id)
     end
   end
 
   it "should manipulate tags correctly", :vcr, :cassette => "tag manipulation" do
-    media = @flickrie.get_media_info(PHOTO_ID)
+    media = Flickrie.get_media_info(PHOTO_ID)
     tags_before_change = media.tags.join(' ')
-    @flickrie.add_media_tags(PHOTO_ID, "janko")
+    Flickrie.add_media_tags(PHOTO_ID, "janko")
     media.get_info
     media.tags.join(' ').should eq([tags_before_change, "janko"].join(' '))
     tag_id = media.tags.find { |tag| tag.content == "janko" }.id
-    @flickrie.remove_media_tag(tag_id)
+    Flickrie.remove_media_tag(tag_id)
     media.get_info
     media.tags.join(' ').should eq(tags_before_change)
   end

data/spec/{error_spec.rb → flickrie/error_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'spec_helper'
 
 describe Flickrie::Error do
   before(:all) do

data/spec/{instance_spec.rb → flickrie/instance_spec.rb}

@@ -1,19 +1,16 @@
-# encoding: utf-8
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'spec_helper'
 
 describe Flickrie::Instance do
   it "should be able to call API methods", :vcr, :cassette => "calling api methods" do
     # this is to see if the client and upload_client were reset
     Flickrie.get_photo_info(PHOTO_ID)
-    Flickrie.access_token = ENV['FLICKR_ACCESS_TOKEN']
-    Flickrie.access_secret = ENV['FLICKR_ACCESS_SECRET']
     id = Flickrie.upload(PHOTO_PATH)
     Flickrie.delete_photo(id)
     Flickrie.access_token = Flickrie.access_secret = nil
 
     instance = Flickrie::Instance.new(ENV['FLICKR_ACCESS_TOKEN'], ENV['FLICKR_ACCESS_SECRET'])
     user = instance.test_login
-    user.username.should eq("Janko Marohnić")
+    user.username.should eq(USER_USERNAME)
     id = instance.upload(PHOTO_PATH)
     instance.delete_photo(id)
   end

data/spec/{license_spec.rb → flickrie/license_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'spec_helper'
 
 describe Flickrie::License do
   context "get" do