flickr-objects 0.0.1

data/lib/flickr/client/upload_client.rb

@@ -0,0 +1,75 @@
+class Flickr
+  class UploadClient < Client
+    def initialize(access_token)
+      super(access_token) do |builder|
+        builder.use Faraday::Request::Multipart
+      end
+    end
+
+    def upload(media, params = {})
+      file = get_file(media)
+      response = post "upload", {photo: file}.merge(params)
+      response.body
+    end
+
+    def replace(media, id, params = {})
+      file = get_file(media)
+      response = post "replace", {photo: file, photo_id: id}.merge(params)
+      response.body
+    end
+
+    def parser
+      FaradayMiddleware::ParseXml
+    end
+
+    private
+
+    def get_file(object)
+      file, content_type, file_path =
+        case object.class.name
+        when "String"
+          [File.open(object), determine_content_type(object), object]
+        when "File"
+          [object, determine_content_type(object.path), object.path]
+        when "ActionDispatch::Http::UploadedFile"
+          [object, object.content_type, object.tempfile]
+        when "Hash" && defined?(Sinatra)
+          [object[:tempfile], object[:type], object[:tempfile].path]
+        else
+          raise Error, "invalid file format"
+        end
+
+      Faraday::UploadIO.new(file, content_type, file_path)
+    end
+
+    def determine_content_type(path)
+      extension = File.extname(path)
+      array = CONTENT_TYPES.keys.find { |array| array.include?(extension) }
+
+      if array
+        CONTENT_TYPES[array]
+      else
+        raise Error, "content type for #{extension} is not known"
+      end
+    end
+
+    CONTENT_TYPES = {
+      %w[.jpg .jpeg .jpe .jif .jfif .jfi] => 'image/jpeg',
+      %w[.gif]                            => 'image/gif',
+      %w[.png]                            => 'image/png',
+      %w[.svg .svgz]                      => 'image/svg+xml',
+      %w[.tiff .tif]                      => 'image/tiff',
+      %w[.ico]                            => 'image/vnd.microsoft.icon',
+
+      %w[.mpg .mpeg .m1v .m1a .m2a .mpa .mpv] => 'video/mpeg',
+      %w[.mp4 .m4a .m4p .m4b .m4r .m4v]       => 'video/mp4',
+      %w[.ogv .oga .ogx .ogg .spx]            => 'video/ogg',
+      %w[.mov .qt]                            => 'video/quicktime',
+      %w[.webm]                               => 'video/webm',
+      %w[.mkv .mk3d .mka .mks]                => 'video/x-matroska',
+      %w[.wmv]                                => 'video/x-ms-wmv',
+      %w[.flv .f4v .f4p .f4a .f4b]            => 'video/x-flv',
+      %w[.avi]                                => 'video/avi'
+    }
+  end
+end

data/lib/flickr/client.rb

@@ -0,0 +1,57 @@
+require "faraday"
+require "faraday_middleware"
+require "flickr/client/middleware"
+
+class Flickr
+  class Client < Faraday::Connection
+    DEFAULTS = {
+      open_timeout: 3,
+      timeout: 4
+    }
+
+    def initialize(access_token)
+      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 = Flickr.configuration.secure ? "https://secure.flickr.com/services" : "http://api.flickr.com/services"
+      proxy = Flickr.configuration.proxy
+
+      params = {
+        url: url,
+        params: {
+          format: "json",
+          nojsoncallback: 1,
+          api_key: api_key
+        },
+        request: {
+          open_timeout: open_timeout,
+          timeout: timeout
+        },
+        proxy: proxy
+      }
+
+      super(params) do |builder|
+        # Request
+        builder.use Middleware::Retry
+        builder.use FaradayMiddleware::OAuth,
+          consumer_key: api_key,
+          consumer_secret: shared_secret,
+          token: access_token.first,
+          token_secret: access_token.last
+        yield builder if block_given?
+
+        # Response
+        builder.use Middleware::CheckStatus
+        builder.use self.parser
+        builder.use Middleware::CheckOAuth
+
+        builder.adapter :net_http
+      end
+    end
+  end
+end
+
+require "flickr/client/methods_client"
+require "flickr/client/upload_client"

data/lib/flickr/configuration.rb

@@ -0,0 +1,23 @@
+class Flickr
+  class Configuration
+    attr_accessor :api_key
+    attr_accessor :shared_secret
+
+    attr_accessor :access_token_key
+    attr_accessor :access_token_secret
+
+    attr_accessor :open_timeout
+    attr_accessor :timeout
+
+    attr_accessor :secure
+    attr_accessor :proxy
+
+    def fetch(*attributes)
+      attributes.map { |attribute| send(attribute) }
+    end
+
+    def access_token
+      [access_token_key, access_token_secret]
+    end
+  end
+end

data/lib/flickr/helpers/base_58.rb

@@ -0,0 +1,15 @@
+class Flickr
+  module Base58
+    ALPHABET = '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'.chars.to_a.freeze
+
+    def to_base58(value)
+      value = Integer(value)
+      begin
+        value, remainder = value.divmod(58)
+        result = ALPHABET[remainder] + (result || '')
+      end while value > 0
+
+      result
+    end
+  end
+end

data/lib/flickr/helpers/boolean.rb

@@ -0,0 +1,4 @@
+class Flickr
+  class Boolean
+  end
+end

data/lib/flickr/helpers/core_ext.rb

@@ -0,0 +1,5 @@
+class Hash
+  def slice(*keys)
+    select { |key, value| keys.include?(key) }
+  end unless method_defined?(:slice)
+end

data/lib/flickr/helpers/inheritable_attr_accessor.rb

@@ -0,0 +1,18 @@
+class Flickr
+  module InheritableAttrAccessor
+    def inheritable_attr_accessor(*names)
+      names.each do |name|
+        attr_reader name
+
+        define_method("#{name}=") do |value|
+          instance_variable_set("@#{name}", value)
+          if respond_to?(:children)
+            children.each do |child|
+              child.send("#{name}=", send(name))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require "date"
+require "flickr/helpers/boolean"
+
+class Flickr
+  class Object
+    class Attribute::Converter
+      def initialize(instance)
+        @instance = instance
+      end
+
+      def convert(value, type)
+        return value if value.nil?
+
+        if type.is_a?(Array)
+          return value.map {|item| convert(item, type.first) }
+        elsif Object.children.include?(type)
+          return type.new(value, @instance.client)
+        else
+          try_each(CONVERTERS[type]) do |converter|
+            return converter.call(value)
+          end
+        end
+
+        value
+      end
+
+      CONVERTERS = {
+        ::Object  => [->(value) { value }],
+        String    => [->(value) { String(value) }],
+        Time      => [->(value) { Time.at(Integer(value)) }, ->(value) { DateTime.parse(value).to_time }],
+        Boolean   => [->(value) { Integer(value) == 1 }],
+        Integer   => [->(value) { Integer(value) }],
+        Float     => [->(value) { Float(value) }],
+        Hash      => [->(value) { value }],
+      }
+
+      private
+
+      def try_each(enum, &block)
+        enum.each do |element|
+          begin
+            yield element
+          rescue
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+class Flickr
+  class Object
+    class Attribute::Finder
+      def initialize(instance)
+        @instance = instance
+      end
+
+      def find(attribute, *args)
+        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)
+          return result unless result.nil?
+        end
+
+        nil
+      end
+
+      private
+
+      def try_each(enum, &block)
+        enum.each do |element|
+          begin
+            yield element
+          rescue
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flickr/object/attribute.rb

@@ -0,0 +1,45 @@
+require "flickr/helpers/inheritable_attr_accessor"
+
+class Flickr
+  class Object
+    module Attribute
+      def self.extended(base)
+        base.send(:include, InstanceMethods)
+      end
+
+      def attributes
+        @attributes ||= []
+      end
+
+      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)
+        end
+
+        Array(options[:aliases]).each do |alias_name|
+          alias_method alias_name, name
+        end
+      end
+
+      module InstanceMethods
+        def attribute_finder
+          Finder.new(self)
+        end
+
+        def attribute_converter
+          Converter.new(self)
+        end
+      end
+
+      extend InheritableAttrAccessor
+      inheritable_attr_accessor :attribute_values
+    end
+  end
+end
+
+require_relative "attribute/finder"
+require_relative "attribute/converter"

data/lib/flickr/object.rb

@@ -0,0 +1,39 @@
+require "flickr/object/attribute"
+require "flickr/api_caller"
+
+class Flickr
+  class Object
+    def self.children
+      @children ||= []
+    end
+
+    def self.inherited(child)
+      child.send(:extend, Attribute)
+      child.send(:include, ApiCaller)
+
+      children << child
+      Object.children << child if self != Object
+    end
+
+    def self.find(id)
+      new({"id" => id}, client)
+    end
+
+    def inspect
+      attribute_values = {}
+      self.class.attributes.each do |name|
+        attribute_values[name] = send(name) unless send(name).nil?
+      end
+      class_name = self.class.name
+      id = "0x%x" % (object_id << 1)
+      "#<#{class_name}:#{id} #{attribute_values.map { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>"
+    end
+
+    protected
+
+    def initialize(hash, client)
+      @hash = hash || {}
+      @client = client
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+class Flickr
+  class Collection < Object
+    self.attribute_values = {
+      current_page:  [->{ @hash["page"] }],
+      per_page:      [->{ @hash["per_page"] }, ->{ @hash["perpage"] }],
+      total_entries: [->{ @hash["total"] }],
+      total_pages:   [->{ @hash["pages"] }],
+    }
+  end
+end

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

@@ -0,0 +1,14 @@
+class Flickr
+  class Location < Object
+    class Area < Object
+      self.attribute_values = {
+        name:   [->{ @hash["_content"] }],
+        woe_id: [->{ @hash["woeid"] }],
+      }
+    end
+
+    self.attribute_values = {
+      woe_id: [->{ @hash["woeid"] }],
+    }
+  end
+end

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

@@ -0,0 +1,70 @@
+class Flickr
+  class Media < 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}"] }) }],
+    }
+
+    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/note.rb

@@ -0,0 +1,11 @@
+class Flickr
+  class Note < Object
+    self.attribute_values = {
+      author:      [->{ {"id" => @hash.fetch("author"), "username" => @hash["authorname"]} }],
+      coordinates: [->{ [@hash.fetch("x"), @hash.fetch("y")] }],
+      width:       [->{ @hash["w"] }],
+      height:      [->{ @hash["h"] }],
+      content:     [->{ @hash["_content"] }],
+    }
+  end
+end

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

@@ -0,0 +1,12 @@
+class Flickr
+  class Permissions < Object
+    self.attribute_values = {
+      can_comment?:  [->{ @hash["cancomment"] }, ->{ @hash["can_comment"] }],
+      can_add_meta?: [->{ @hash["canaddmeta"] }],
+      can_download?: [->{ @hash["candownload"] }],
+      can_blog?:     [->{ @hash["canblog"] }],
+      can_print?:    [->{ @hash["canprint"] }],
+      can_share?:    [->{ @hash["canshare"] }],
+    }
+  end
+end

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

@@ -0,0 +1,23 @@
+class Flickr
+  class Person < Object
+    self.attribute_values = {
+      id:                   [->{ @hash["nsid"] }],
+      nsid:                 [->{ id }],
+      username:             [->{ @hash["username"]["_content"] }],
+      real_name:            [->{ @hash["realname"] }, ->{ @hash["realname"]["_content"] }],
+      icon_server:          [->{ @hash["iconserver"] }],
+      icon_farm:            [->{ @hash["iconfarm"] }],
+      has_pro_account?:     [->{ @hash["ispro"] }],
+      location:             [->{ @hash["location"]["_content"] }],
+      time_zone:            [->{ @hash["timezone"] }],
+      description:          [->{ @hash["description"]["_content"] }],
+      photos_url:           [->{ @hash["photosurl"]["_content"] }],
+      profile_url:          [->{ @hash["profileurl"]["_content"] }],
+      mobile_url:           [->{ @hash["mobileurl"]["_content"] }],
+      first_photo_taken:    [->{ @hash["photos"]["firstdatetaken"]["_content"] }],
+      first_photo_uploaded: [->{ @hash["photos"]["firstdate"]["_content"] }],
+      photos_count:         [->{ @hash["photos"]["count"]["_content"] }],
+      photo_views_count:    [->{ @hash["photos"]["views"]["_content"] }],
+    }
+  end
+end

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

@@ -0,0 +1,19 @@
+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"] }
+                  ],
+    )
+  end
+end

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

@@ -0,0 +1,21 @@
+class Flickr
+  class Set < Object
+    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"] }],
+      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/tag.rb

@@ -0,0 +1,9 @@
+class Flickr
+  class Tag < Object
+    self.attribute_values = {
+      author:       [->{ {"id" => @hash.fetch("author")} }],
+      content:      [->{ @hash["_content"] }],
+      machine_tag?: [->{ @hash["machine_tag"] }],
+    }
+  end
+end

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

@@ -0,0 +1,11 @@
+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")} }],
+    }
+  end
+end

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

@@ -0,0 +1,27 @@
+class Flickr
+  class Video < Media
+    self.attribute_values = attribute_values.merge(
+      ready?:              [->{ @hash["video"]["ready"] }],
+      failed?:             [->{ @hash["video"]["failed"] }],
+      pending?:            [->{ @hash["video"]["pending"] }],
+      duration:            [->{ @hash["video"]["duration"] }],
+      width:               [->{ @hash["video"]["width"] }],
+      height:              [->{ @hash["video"]["height"] }],
+      thumbnail_url:       [
+                             ->(size){ @hash["url_#{SIZES[size]}"] },
+                             ->(size){ @hash["size"].find { |hash| hash["label"] == OTHER_SIZES[size] }["source"] }
+                           ],
+      thumbnail_width:     [
+                             ->(size){ @hash["width_#{SIZES[size]}"] },
+                             ->(size){ @hash["size"].find { |hash| hash["label"] == OTHER_SIZES[size] }["width"] }
+                           ],
+      thumbnail_height:    [
+                             ->(size){ @hash["height_#{SIZES[size]}"] },
+                             ->(size){ @hash["size"].find { |hash| hash["label"] == OTHER_SIZES[size] }["height"] }
+                           ],
+      source_url:          [->{ @hash["size"].find { |hash| hash["label"] == "Video Player" }["source"] }],
+      download_url:        [->{ @hash["size"].find { |hash| hash["label"] == "Site MP4" }["source"] }],
+      mobile_download_url: [->{ @hash["size"].find { |hash| hash["label"] == "Mobile MP4" }["source"] }],
+    )
+  end
+end

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

@@ -0,0 +1,10 @@
+class Flickr
+  class Visibility < Object
+    self.attribute_values = {
+      public?:   [->{ @hash["ispublic"] }],
+      friends?:  [->{ @hash["isfriend"] }],
+      family?:   [->{ @hash["isfamily"] }],
+      contacts?: [->{ @hash["iscontact"] }],
+    }
+  end
+end