flickr-objects 0.0.2 → 0.1.0

data/lib/flickr/client.rb

@@ -1,6 +1,6 @@
 require "faraday"
 require "faraday_middleware"
-require "flickr/client/middleware"
+require "flickr/middleware"
 
 class Flickr
   class Client < Faraday::Connection

data/lib/flickr/configuration.rb

@@ -12,6 +12,8 @@ class Flickr
     attr_accessor :secure
     attr_accessor :proxy
 
+    attr_accessor :pagination
+
     def fetch(*attributes)
       attributes.map { |attribute| send(attribute) }
     end

data/lib/flickr/errors.rb

@@ -0,0 +1,19 @@
+class Flickr
+  class Error < StandardError
+  end
+
+  class OAuthError < Error
+  end
+
+  class ApiError < Error
+    attr_reader :code
+
+    def initialize(message, code = nil)
+      super(message)
+      @code = code.to_i
+    end
+  end
+
+  class TimeoutError < Error
+  end
+end

data/lib/flickr/middleware.rb

@@ -0,0 +1,63 @@
+require "cgi"
+require "faraday"
+require "flickr/errors"
+require "faraday_middleware/response_middleware"
+
+class Flickr
+  module Middleware
+    class CheckStatus < Faraday::Response::Middleware
+      def on_complete(env)
+        env[:body] = env[:body]["rsp"] || env[:body]
+
+        if env[:body]["stat"] != "ok"
+          message = env[:body]["message"] || env[:body]["err"]["msg"]
+          code = env[:body]["code"] || env[:body]["err"]["code"]
+          raise ApiError.new(message, code)
+        end
+      end
+    end
+
+    class CheckOAuth < Faraday::Response::Middleware
+      def on_complete(env)
+        if env[:status] != 200
+          message = CGI.parse(env[:body])["oauth_problem"].first
+          pretty_message = message.gsub('_', ' ').capitalize
+          raise OAuthError, pretty_message
+        end
+      end
+    end
+
+    class ParseOAuth < FaradayMiddleware::ResponseMiddleware
+      define_parser do |body|
+        CGI.parse(body).inject({}) do |hash, (key, value)|
+          hash.update(key.to_sym => value.first)
+        end
+      end
+    end
+
+    # A copy from Faraday (credits to @mislav)
+    class Retry < Faraday::Middleware
+      def initialize(app, options = {})
+        super(app)
+        @retries, options = options, {} if options.is_a? Integer
+        @retries ||= options.fetch(:max, 2).to_i
+        @sleep     = options.fetch(:interval, 0).to_f
+        @errmatch  = options.fetch(:exceptions) { [Errno::ETIMEDOUT, 'Timeout::Error', Faraday::Error::TimeoutError] }
+      end
+
+      def call(env)
+        retries = @retries
+        begin
+          @app.call(env)
+        rescue *@errmatch => error
+          if retries > 0
+            retries -= 1
+            sleep @sleep if @sleep > 0
+            retry
+          end
+          raise Flickr::TimeoutError, error.message
+        end
+      end
+    end
+  end
+end

data/lib/flickr/oauth.rb

@@ -0,0 +1,109 @@
+require "faraday"
+require "faraday_middleware"
+require "flickr/middleware"
+
+class Flickr
+  module OAuth
+    URL = "http://www.flickr.com/services/oauth".freeze
+    NO_CALLBACK = 'oob'.freeze
+    DEFAULTS = Client::DEFAULTS
+
+    extend self
+
+    def get_request_token(options = {})
+      response = connection.get "request_token" do |req|
+        req.params[:oauth_callback] = options[:callback_url] || NO_CALLBACK
+      end
+
+      RequestToken.new(response.body)
+    end
+
+    def get_access_token(verifier, request_token)
+      response = connection(request_token.to_a).get "access_token" do |req|
+        req.params[:oauth_verifier] = verifier
+      end
+
+      AccessToken.new(response.body)
+    end
+
+    class Token
+      attr_reader :token, :secret
+
+      def initialize(*args)
+        if args.first.is_a?(Hash)
+          @token = args.first[:oauth_token]
+          @secret = args.first[:oauth_token_secret]
+        else
+          @token = args.first
+          @secret = args.last
+        end
+      end
+
+      def to_a
+        [token, secret]
+      end
+    end
+
+    class RequestToken < Token
+      def authorize_url(params = {})
+        require 'uri'
+        url = URI.parse(URL)
+        url.path += '/authorize'
+        query_params = {oauth_token: token}.merge(params)
+        url.query = query_params.map { |k,v| "#{k}=#{v}" }.join('&')
+        url.to_s
+      end
+
+      def get_access_token(verifier)
+        OAuth.get_access_token(verifier, self)
+      end
+    end
+
+    class AccessToken < 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
+
+    private
+
+    def connection(request_token = nil)
+      api_key, shared_secret = Flickr.configuration.fetch(:api_key, :shared_secret)
+
+      open_timeout = Flickr.configuration.open_timeout || DEFAULTS[:open_timeout]
+      timeout      = Flickr.configuration.timeout      || DEFAULTS[:timeout]
+
+      url = URL
+      proxy = Flickr.configuration.proxy
+
+      params = {
+        url: url,
+        request: {
+          open_timeout: open_timeout,
+          timeout: timeout
+        },
+        proxy: proxy
+      }
+
+      Faraday.new(params) do |builder|
+        builder.use Middleware::Retry
+        builder.use FaradayMiddleware::OAuth,
+         consumer_key: api_key,
+         consumer_secret: shared_secret,
+         token: Array(request_token).first,
+         token_secret: Array(request_token).last
+
+        builder.use Middleware::ParseOAuth
+        builder.use Middleware::CheckOAuth
+
+        builder.adapter :net_http
+      end
+    end
+  end
+end

data/lib/flickr/object/attribute/finder.rb

@@ -5,12 +5,12 @@ class Flickr
         @instance = instance
       end
 
-      def find(attribute, *args)
+      def find(attribute)
         attribute_values = @instance.class.attribute_values[attribute] || []
         attribute_values << ->{ @hash.fetch(attribute.to_s) }
 
         try_each(attribute_values) do |attribute_value|
-          result = @instance.instance_exec(*args, &attribute_value)
+          result = @instance.instance_exec(&attribute_value)
           return result unless result.nil?
         end
 

data/lib/flickr/object/attribute.rb

@@ -1,5 +1,3 @@
-require "flickr/helpers/inheritable_attr_accessor"
-
 class Flickr
   class Object
     module Attribute
@@ -13,11 +11,9 @@ class Flickr
 
       def attribute(name, type = ::Object, options = {})
         attributes << name
-        children.each { |child| child.attributes << name } if respond_to?(:children)
 
-        define_method(name) do |*args|
-          value = attribute_finder.find(name, *args)
-          attribute_converter.convert(value, type)
+        define_method(name) do
+          retrieve_value(name, type)
         end
 
         Array(options[:aliases]).each do |alias_name|
@@ -33,10 +29,14 @@ class Flickr
         def attribute_converter
           Converter.new(self)
         end
+
+        def retrieve_value(name, type)
+          value = attribute_finder.find(name)
+          attribute_converter.convert(value, type)
+        end
       end
 
-      extend InheritableAttrAccessor
-      inheritable_attr_accessor :attribute_values
+      attr_accessor :attribute_values
     end
   end
 end

data/lib/flickr/object.rb

@@ -11,14 +11,17 @@ class Flickr
       child.send(:extend, Attribute)
       child.send(:include, ApiCaller)
 
-      children << child
-      Object.children << child if self != Object
+      Object.children << child
     end
 
     def self.find(id)
       new({"id" => id}, client)
     end
 
+    def self.new_list(hashes, client, list_hash)
+      List.new(hashes.map { |hash| new(hash, client) }, list_hash)
+    end
+
     def inspect
       attribute_values = {}
       self.class.attributes.each do |name|
@@ -29,6 +32,14 @@ class Flickr
       "#<#{class_name}:#{id} #{attribute_values.map { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>"
     end
 
+    def ==(other)
+      if (self.respond_to?(:id) && self.id) && (other.respond_to?(:id) && other.id)
+        id == other.id
+      else
+        super
+      end
+    end
+
     protected
 
     def initialize(hash, client)

data/lib/flickr/objects/attribute_values/{collection.rb → list.rb}

@@ -1,5 +1,5 @@
 class Flickr
-  class Collection < Object
+  class List
     self.attribute_values = {
       current_page:  [->{ @hash["page"] }],
       per_page:      [->{ @hash["per_page"] }, ->{ @hash["perpage"] }],

data/lib/flickr/objects/attribute_values/photo.rb

@@ -1,19 +1,84 @@
 class Flickr
-  class Photo < Media
-    self.attribute_values = attribute_values.merge(
-      rotation:   [->{ @hash["rotation"] }],
-      source_url: [
-                    ->{ @hash["url_#{SIZES[size]}"] },
-                    ->{ @hash["size"].find { |hash| hash["label"] == OTHER_SIZES[size] }["source"] }
-                  ],
-      height:     [
-                    ->{ @hash["height_#{SIZES[size]}"] },
-                    ->{ @hash["size"].find { |hash| hash["label"] == OTHER_SIZES[size] }["height"] }
-                  ],
-      width:      [
-                    ->{ @hash["width_#{SIZES[size]}"] },
-                    ->{ @hash["size"].find { |hash| hash["label"] == OTHER_SIZES[size] }["width"] }
-                  ],
-    )
+  class Photo < Object
+    self.attribute_values = {
+      uploaded_at:          [->{ @hash["dateuploaded"] }, ->{ @hash["dateupload"] }],
+      favorite?:            [->{ @hash["isfavorite"] }],
+      posted_at:            [->{ @hash["dates"]["posted"] }],
+      taken_at:             [->{ @hash["dates"]["taken"] }, ->{ @hash["datetaken"] }],
+      taken_at_granularity: [->{ @hash["dates"]["takengranularity"] }, ->{ @hash["datetakengranularity"] }],
+      updated_at:           [->{ @hash["dates"]["lastupdate"] }, ->{ @hash["lastupdate"] }],
+      views_count:          [->{ @hash["views"] }],
+      public_editability:   [->{ @hash["publiceditability"] }],
+      comments_count:       [->{ @hash["comments"]["_content"] }],
+      has_people?:          [->{ @hash["people"]["haspeople"] }],
+      notes:                [->{ @hash["notes"]["note"] }],
+      tags:                 [
+                              ->{ @hash["tags"]["tag"].map { |h| h.merge("photo_id" => @hash["id"]) } },
+                              ->{
+                                [
+                                  *@hash["tags"].split(" ").map         {|content| {"_content" => content, "machine_tag" => 0} },
+                                  *@hash["machine_tags"].split(" ").map {|content| {"_content" => content, "machine_tag" => 1} }
+                                ]
+                              }
+                            ],
+      visibility:           [->{ @hash["visibility"] }, ->{ @hash.slice("ispublic", "isfriend", "isfamily") if @hash["ispublic"] }],
+      title:                [->{ @hash["title"]["_content"] }],
+      description:          [->{ @hash["description"]["_content"] }],
+      owner:                [
+                              ->{
+                                if @hash["owner"].is_a?(String)
+                                  {
+                                    "id"         => @hash["owner"],
+                                    "username"   => @hash["ownername"],
+                                    "iconserver" => @hash["iconserver"],
+                                    "iconfarm"   => @hash["iconfarm"],
+                                  }
+                                end
+                              }
+                            ],
+      path_alias:           [->{ @hash["pathalias"] }],
+      location_visibility:  [
+                              ->{ @hash["geoperms"] },
+                              ->{
+                                {
+                                  "isfamily"  => @hash.fetch("geo_is_family"),
+                                  "isfriend"  => @hash.fetch("geo_is_friend"),
+                                  "iscontact" => @hash.fetch("geo_is_contact"),
+                                  "ispublic"  => @hash.fetch("geo_is_public")
+                                }
+                              }
+                            ],
+      location:             [->{ @hash.slice("latitude", "longitude", "accuracy", "context", "place_id", "woeid") if @hash["latitude"] }],
+      largest_size:         [->{ SIZES.key(SIZES.values.reverse.find { |abbr| @hash["url_#{abbr}"] }) }],
+      available_sizes:      [->{ SIZES.select { |_, abbr| @hash["url_#{abbr}"] }.keys }],
+      rotation:             [->{ @hash["rotation"] }],
+      source_url:           [
+                              ->{ @hash["url_#{SIZES[size]}"] },
+                              ->{ @hash["size"].find { |hash| hash["label"] == OTHER_SIZES[size] }["source"] }
+                            ],
+      height:               [
+                              ->{ @hash["height_#{SIZES[size]}"] },
+                              ->{ @hash["size"].find { |hash| hash["label"] == OTHER_SIZES[size] }["height"] }
+                            ],
+      width:                [
+                              ->{ @hash["width_#{SIZES[size]}"] },
+                              ->{ @hash["size"].find { |hash| hash["label"] == OTHER_SIZES[size] }["width"] }
+                            ],
+    }
+
+    OTHER_SIZES = {
+      "Square 75"  => "Square",
+      "Thumbnail"  => "Thumbnail",
+      "Square 150" => "Large Square",
+      "Small 240"  => "Small",
+      "Small 320"  => "Small 320",
+      "Medium 500" => "Medium",
+      "Medium 640" => "Medium 640",
+      "Medium 800" => "Medium 800",
+      "Large 1024" => "Large",
+      "Large 1600" => "Large 1600",
+      "Large 2048" => "Large 2048",
+      "Original"   => "Original"
+    }
   end
 end

data/lib/flickr/objects/attribute_values/set.rb

@@ -3,19 +3,15 @@ class Flickr
     self.attribute_values = {
       owner:          [-> { {"id" => @hash.fetch("owner"), "username" => @hash["username"]} }],
       url:            [-> { "http://www.flickr.com/photos/#{owner.id}/sets/#{id}/" }],
-      media_count:    [-> { @hash["photos"] }],
+      photos_count:   [-> { @hash["photos"] }, -> { @hash["count_photos"] }],
       views_count:    [-> { @hash["count_views"] }],
       comments_count: [-> { @hash["count_comments"] }],
-      photos_count:   [-> { @hash["count_photos"] }, -> { @hash["photos"] }],
-      videos_count:   [-> { @hash["count_videos"] }, -> { @hash["videos"] }],
       title:          [-> { @hash["title"]["_content"] }],
       description:    [-> { @hash["description"]["_content"] }],
       permissions:    [-> { @hash.slice("can_comment") }],
       created_at:     [-> { @hash["date_create"] }],
       updated_at:     [-> { @hash["date_update"] }],
-      primary_media:  [-> { {"id" => @hash.fetch("primary")} }],
       primary_photo:  [-> { {"id" => @hash.fetch("primary")} }],
-      primary_video:  [-> { {"id" => @hash.fetch("primary")} }],
     }
   end
 end

data/lib/flickr/objects/attribute_values/upload_ticket.rb

@@ -1,11 +1,9 @@
 class Flickr
   class UploadTicket < Object
     self.attribute_values = {
-      status:   [->{ @hash["complete"] }],
-      invalid?: [->{ @hash["invalid"] || 0 }],
-      media:    [->{ {"id" => @hash.fetch("photoid")} }],
-      photo:    [->{ {"id" => @hash.fetch("photoid")} }],
-      video:    [->{ {"id" => @hash.fetch("photoid")} }],
+      status:  [->{ @hash["complete"] }],
+      invalid: [->{ @hash["invalid"] || 0}],
+      photo:   [->{ {"id" => @hash.fetch("photoid")} }],
     }
   end
 end

data/lib/flickr/objects/list.rb

@@ -0,0 +1,86 @@
+class Flickr
+  case Flickr.configuration.pagination
+  when nil
+
+    class List < Array
+      extend Flickr::Object::Attribute
+
+      attribute :current_page,  Integer
+      attribute :per_page,      Integer
+      attribute :total_pages,   Integer
+      attribute :total_entries, Integer
+
+      def initialize(objects, hash)
+        @hash = hash
+        super(objects)
+      end
+    end
+
+  when :will_paginate
+
+    require "will_paginate/collection"
+
+    class List < WillPaginate::Collection
+      extend Flickr::Object::Attribute
+
+      def initialize(objects, hash)
+        @hash = hash
+        super(
+          retrieve_value(:current_page, Integer),
+          retrieve_value(:per_page, Integer),
+          retrieve_value(:total_entries, Integer)
+        )
+        replace(objects)
+      end
+    end
+
+  when :kaminari
+
+    require "kaminari"
+    require "kaminari/models/array_extension"
+
+    class List < Kaminari::PaginatableArray
+      extend Flickr::Object::Attribute
+
+      def initialize(objects, hash)
+        @hash = hash
+        super(objects,
+          offset:      retrieve_value(:current_page, Integer),
+          limit:       retrieve_value(:per_page, Integer),
+          total_count: retrieve_value(:total_entries, Integer)
+        )
+      end
+    end
+
+  else
+    raise Error, "supported paginations are :will_paginate or :kaminari (you put \":#{Flickr.configuration.pagination}\")"
+  end
+end
+
+require_relative "attribute_values/list"
+
+class Flickr
+  class List
+    def find(id = nil)
+      if block_given?
+        super
+      else
+        if id.is_a?(Array)
+          ids = id.map(&:to_s)
+          select { |object| ids.include?(object.id) }
+        else
+          super() { |object| object.id == id.to_s }
+        end
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      if name.to_s =~ /find_by_\w+/
+        attribute_name = name[/(?<=find_by_)\w+/]
+        find { |object| object.send(attribute_name) == args.first }
+      else
+        super
+      end
+    end
+  end
+end

data/lib/flickr/objects/location.rb

@@ -1,3 +1,5 @@
+require_relative "attribute_values/location"
+
 class Flickr
   class Location < Object
 

data/lib/flickr/objects/note.rb

@@ -1,9 +1,11 @@
+require_relative "attribute_values/note"
+
 class Flickr
   class Note < Object
 
     attribute :id,          String
     attribute :author,      Person
-    attribute :coordinates, Array(Integer)
+    attribute :coordinates, Array[Integer]
     attribute :width,       Integer
     attribute :height,      Integer
     attribute :content,     String

data/lib/flickr/objects/permissions.rb

@@ -1,3 +1,5 @@
+require_relative "attribute_values/permissions"
+
 class Flickr
   class Permissions < Object
 

data/lib/flickr/objects/person.rb

@@ -1,3 +1,6 @@
+require_relative "attribute_values/person"
+require "flickr/api/person"
+
 class Flickr
   class Person < Object
 
@@ -13,15 +16,15 @@ class Flickr
     attribute :icon_server,          Integer
     attribute :icon_farm,            Integer
 
-    attribute :photos_url,           String, aliases: [:videos_url, :media_url]
+    attribute :photos_url,           String
     attribute :profile_url,          String
     attribute :mobile_url,           String
 
-    attribute :first_photo_taken,    Time, aliases: [:first_video_taken, :first_media_taken]
-    attribute :first_photo_uploaded, Time, aliases: [:first_video_uploaded, :first_media_uploaded]
+    attribute :first_photo_taken,    Time
+    attribute :first_photo_uploaded, Time
 
-    attribute :photos_count,         Integer, aliases: [:videos_count, :media_count]
-    attribute :photo_views_count,    Integer, aliases: [:video_views_count, :media_views_count]
+    attribute :photos_count,         Integer
+    attribute :photo_views_count,    Integer
 
     attribute :path_alias,           String