flickr-objects 0.2.0 → 0.3.0

data/lib/flickr/object.rb

@@ -1,49 +1,140 @@
-require "flickr/object/attribute"
-require "flickr/api_caller"
+require "flickr/attributes"
 
-class Flickr
+module Flickr
+
+  ##
+  # Every Flickr object inherits from this class. It provides interface for defining
+  # attributes and some helper methods.
+  #
   class Object
-    def self.children
-      @children ||= []
+
+    extend Flickr::Attributes
+    extend Flickr::AutoloadHelper
+
+    autoload_names \
+      :List, :Photo, :Person, :Set, :UploadTicket, :Permissions, :Location,
+      :Visibility
+
+    ##
+    # @private
+    #
+    def self.api_class
+      Flickr::Api.const_get(name.match(/^Flickr::Object::/).post_match)
+    end
+
+    ##
+    # Overriding Flickr::Attributes#attribute to add a default location.
+    # This means that `:<attribute>` will always first be searched in
+    # `@attributes["<attribute>"]`.
+    #
+    # @!macro [attach] attribute
+    #   @attribute [r] $1
+    #   @return [$2]
+    #
+    # @private
+    #
+    def self.attribute(name, type)
+      new_attribute = super
+      new_attribute.add_locations([-> { @attributes[name.to_s] }])
     end
 
-    def self.inherited(child)
-      child.send(:extend, Attribute)
-      child.send(:include, ApiCaller)
+    ##
+    # @private
+    #
+    def initialize(attributes, access_token = [])
+      raise ArgumentError, "attributes should not be nil" if attributes.nil?
 
-      Object.children << child
+      @attributes = attributes
+      @access_token = access_token
     end
 
-    def self.find(id)
-      new({"id" => id}, client)
+    ##
+    # @private
+    #
+    attr_reader :access_token
+    ##
+    # The raw hash of attributes returned from Flickr.
+    #
+    # @return [Hash]
+    # @see #[]
+    #
+    attr_reader :attributes
+
+    ##
+    # Shorthand for accessing the raw hash of attributes returned
+    # from Flickr.
+    #
+    # @see #attributes
+    #
+    def [](key)
+      @attributes[key]
     end
 
-    def self.new_list(hashes, client, list_hash)
-      List.new(hashes.map { |hash| new(hash, client) }, list_hash)
+    ##
+    # Compares by ID (if that object has an ID), otherwise compares by attributes.
+    #
+    def ==(other)
+      if not other.is_a?(Flickr::Object)
+        raise ArgumentError "can't compare Flickr::Object with #{other.class}"
+      end
+
+      if [self, other].all? { |object| object.respond_to?(:id) && object.id }
+        self.id == other.id
+      else
+        self.attributes == other.attributes
+      end
     end
+    alias eql? ==
 
+    ##
+    # Displays all the attributes and their values.
+    #
     def inspect
-      attribute_values = {}
-      self.class.attributes.each do |name|
-        attribute_values[name] = send(name) unless send(name).nil?
-      end
+      attribute_values = self.class.attributes
+        .inject({}) { |hash, attribute| hash.update(attribute.name => send(attribute.name)) }
+        .reject { |name, value| value.nil? or (value.respond_to?(:empty?) and value.empty?) }
+      attributes = attribute_values
+        .map { |name, value| "#{name}=#{value.inspect}" }
+        .join(" ")
+
       class_name = self.class.name
-      "#<#{class_name}: #{attribute_values.map { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>"
+      hex_code = "0x#{(object_id >> 1).to_s(16)}"
+
+      "#<#{class_name}:#{hex_code} #{attributes}>"
     end
 
-    def ==(other)
-      if (self.respond_to?(:id) && self.id) && (other.respond_to?(:id) && other.id)
-        id == other.id
-      else
-        super
+    ##
+    # Tests if the object matches a hash of attributes. Supports nesting
+    # (see the example).
+    #
+    # @param attributes [Hash]
+    # @return [Boolean]
+    # @example
+    #   photo.matches?(owner: {username: "janko"})
+    #
+    def matches?(attributes)
+      attributes.all? do |name, value|
+        if send(name).is_a?(Flickr::Object) and value.is_a?(Hash)
+          send(name).matches?(value)
+        else
+          send(name) == value
+        end
       end
     end
 
-    protected
+    ##
+    # @private
+    #
+    def update(attributes)
+      @attributes.update(attributes)
+      self
+    end
 
-    def initialize(hash, client)
-      @hash = hash || {}
-      @client = client
+    private
+
+    def api
+      self.class.api_class.new(@access_token)
     end
   end
+
 end

data/lib/flickr/sanitized_file.rb

@@ -0,0 +1,70 @@
+require "delegate"
+
+module Flickr
+
+  ##
+  # File that users provide for uploading can come from various sources (Rails, Sinatra
+  # etc). This class attempts to sanitize it, pulling out the path, content type,
+  # and the actual file.
+  #
+  # @private
+  #
+  class SanitizedFile < SimpleDelegator
+
+    attr_reader :file, :content_type, :path
+
+    ##
+    # @param original [String, File, Rails, Sinatra]
+    #
+    def initialize(original)
+      @original = original
+      sanitize!
+      super(@file)
+    end
+
+    private
+
+    ##
+    # Extracts the tempfile, content type and path.
+    #
+    def sanitize!
+      if rails_file?
+        @file = @original
+        @content_type = @original.content_type
+        @path = @original.tempfile
+      elsif sinatra_file?
+        @file = @original[:tempfile]
+        @content_type = @original[:type]
+        @path = @original[:tempfile].path
+      elsif file?
+        @file = @original
+        @content_type = @original.content_type if @original.respond_to?(:content_type)
+        @path = @original.path
+      elsif string?
+        @file = File.open(@original)
+        @content_type = nil
+        @path = @original
+      else
+        raise ArgumentError, "invalid file format"
+      end
+    end
+
+    def rails_file?
+      defined?(Rails) and @original.is_a?(ActionDispatch::Http::UploadedFile)
+    end
+
+    def sinatra_file?
+      defined?(Sinatra) and @original.is_a?(Hash)
+    end
+
+    def file?
+      @original.respond_to?(:read) and @original.respond_to?(:path)
+    end
+
+    def string?
+      @original.is_a?(String)
+    end
+
+  end
+
+end

data/lib/flickr/version.rb

@@ -1,3 +1,5 @@
-class Flickr
-  VERSION = "0.2.0"
+module Flickr
+
+  VERSION = "0.3.0"
+
 end

data/lib/flickr.rb

@@ -1,26 +1,80 @@
-require "flickr/helpers/core_ext"
-require "flickr/configuration"
+module Flickr
 
-class Flickr
-  def self.configuration
-    @configuration ||= Configuration.new
+  ##
+  # @private
+  #
+  module AutoloadHelper
+    def autoload_dir(directory, mappings)
+      mappings.each do |const_name, path|
+        autoload const_name, File.join(directory, path)
+      end
+    end
+
+    ##
+    # Flickr::Object and Flickr::Api contain too many constants, so rather than
+    # providing an explicit filename we rather use the underscored constant name.
+    #
+    def autoload_names(*class_names)
+      mappings = class_names.inject({}) do |mappings, class_name|
+        mappings.update(class_name => Flickr.underscore(class_name.to_s))
+      end
+      directory = Flickr.underscore(name)
+
+      autoload_dir directory, mappings
+    end
   end
 
-  def self.configure
-    yield configuration if block_given?
-    @client = @upload_client = nil
-    configuration
+  extend AutoloadHelper
+
+  autoload_dir "flickr",
+    :Configuration => "configuration",
+    :Api           => "api",
+    :OAuth         => "oauth",
+    :Object        => "object",
+    :Client        => "client"
+
+  ##
+  # ActiveSupport's `underscore` (simpler version), used in
+  # Flickr::AutoloadHelper#autoload_names
+  #
+  # @example
+  #   Flickr.underscore("Foo::Bar::Baz") # => "foo/bar/baz"
+  # @private
+  #
+  def self.underscore(class_name)
+    class_name
+      .split("::")
+      .map { |s| s.split(/(?=[A-Z])/).map(&:downcase).join("_") }
+      .join("/")
   end
 
-  def self.api_methods
-    @api_methods ||= Hash.new { |hash, key| hash[key] = [] }
+  extend Flickr::Configuration
+
+  ##
+  # If you're obtaining the access token dynamically, then you can't set it in
+  # the global configuration. This method allows you to create a temporary
+  # instance with the access token.
+  #
+  # @example
+  #   flickr = Flickr.new("KEY", "SECRET")
+  #   flickr.photos.get_recent
+  #   # ...
+  # @return [Flickr]
+  #
+  def self.new(access_token_key, access_token_secret)
+    dup.configure do |config|
+      config.access_token_key    = access_token_key
+      config.access_token_secret = access_token_secret
+    end
   end
 
+  extend Flickr::Api
+
+  ##
+  # @private
+  #
   def self.deprecation_warn(message)
     warn "[FLICKR OBJECTS] #{message}"
   end
-end
 
-require "flickr/objects"
-require "flickr/api"
-require "flickr/oauth"
+end