fleakr 0.6.3 → 0.7.0

data/lib/fleakr/objects/set.rb

@@ -1,17 +1,17 @@
 module Fleakr
   module Objects # :nodoc:
-    
+
     # = Set
     #
     # == Attributes
-    # 
+    #
     # [id] The ID for this photoset
     # [title] The title of this photoset
     # [description] The description of this set
     # [count] Count of photos in this set
-    # 
+    #
     # == Associations
-    # 
+    #
     # [photos] The collection of photos for this set. See Fleakr::Objects::Photo
     # [comments] All comments associated with this set. See Fleakr::Objects::Comment
     #
@@ -27,18 +27,18 @@ module Fleakr
       flickr_attribute :user_id, :from => '@owner'
 
       find_all :by_user_id, :call => 'photosets.getList', :path => 'photosets/photoset'
-      
+
       find_one :by_id, :using => :photoset_id, :call => 'photosets.getInfo', :path => 'photoset'
 
       lazily_load :user_id, :with => :load_info
 
       # Save all photos in this set to the specified directory for the specified size.  Allowed
-      # Sizes include <tt>:square</tt>, <tt>:small</tt>, <tt>:thumbnail</tt>, <tt>:medium</tt>,  
-      # <tt>:large</tt>, and <tt>:original</tt>.  When saving the set, this method will create 
+      # Sizes include <tt>:square</tt>, <tt>:small</tt>, <tt>:thumbnail</tt>, <tt>:medium</tt>,
+      # <tt>:large</tt>, and <tt>:original</tt>.  When saving the set, this method will create
       # a subdirectory based on the set's title.
       #
       def save_to(path, size)
-        target = "#{path}/#{self.title}"
+        target = "#{path}/#{folder_name}"
         FileUtils.mkdir(target) unless File.exist?(target)
 
         self.photos.each_with_index do |photo, index|
@@ -46,34 +46,38 @@ module Fleakr
           image.save_to(target, file_prefix(index)) unless image.nil?
         end
       end
-      
+
       def file_prefix(index) # :nodoc:
         sprintf("%0#{self.count.length}d_", (index + 1))
       end
 
+      def folder_name # :nodoc:
+        title.gsub("/", ' ').squeeze(' ')
+      end
+
       # Primary photo for this set. See Fleakr::Objects::Photo for more details.
       #
       def primary_photo
         @primary_photo ||= Photo.find_by_id(primary_photo_id)
       end
-      
+
       # The URL for this set.
       #
       def url
         "http://www.flickr.com/photos/#{user_id}/sets/#{id}/"
       end
-      
+
       # The user who created this set.
       #
       def user
         User.find_by_id(user_id)
       end
-   
+
       def load_info # :nodoc:
         response = Fleakr::Api::MethodRequest.with_response!('photosets.getInfo', :photoset_id => self.id)
         self.populate_from(response.body)
       end
-      
+
     end
   end
 end

data/lib/fleakr/objects/url.rb

@@ -0,0 +1,83 @@
+module Fleakr
+  module Objects
+
+    class Url
+
+      def initialize(url)
+        @url = url
+      end
+
+      def path
+        expanded_path || original_path
+      end
+
+      def user_identifier
+        (resource_type == Set) ? parts[1] : parts[2]
+      end
+
+      def shortened?
+        !original_path.match(%r{^/p/[123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ]+$}).nil?
+      end
+
+      def resource_identifier
+        parts[3]
+      end
+
+      def user
+        @user ||= User.find_by_identifier(user_identifier)
+      end
+
+      def resource_type
+        if parts[1] == 'people'
+          User
+        elsif parts[1] == 'photos'
+          Photo
+        elsif parts[2] == 'sets'
+          Set
+        end
+      end
+
+      def collection?
+        resource_identifier.nil?
+      end
+
+      def resource
+        if resource_type == User
+          user
+        else
+          collection? ? resource_type.find_all_by_user_id(user.id) : resource_type.find_by_id(resource_identifier)
+        end
+      end
+
+      private
+
+      def expanded_path
+        Fleakr::Support::UrlExpander.expand(@url) if shortened?
+      end
+
+      def original_path
+        URI.parse(@url).path
+      end
+
+      def parts
+        path.match(matching_pattern)
+      end
+
+      def matching_pattern
+        @matching_pattern ||= patterns.detect {|p| path.match(p) }
+      end
+
+      def patterns
+        [
+          %r{^/photos/([^/]+)/(sets)/(\d+)},
+          %r{^/photos/([^/]+)/(sets)},
+          %r{^/(photos)/([^/]+)/(\d+)},
+          %r{^/(people)/([^/]+)},
+          %r{^/(photos)/([^/]+)}
+        ]
+      end
+
+    end
+
+  end
+end

data/lib/fleakr/objects/user.rb

@@ -68,6 +68,14 @@ module Fleakr
 
       scoped_search
       
+      def self.user_id?(username_or_user_id)
+        (username_or_user_id =~ /^\d+@N\d{2}$/) ? true : false
+      end
+      
+      def self.find_by_identifier(identifier)
+        user_id?(identifier) ? find_by_id(identifier) : find_by_username(identifier)
+      end
+      
       # Is this a pro account?
       def pro?
         (self.pro.to_i == 0) ? false : true

data/lib/fleakr/support.rb

@@ -1,3 +1,5 @@
 require 'fleakr/support/attribute'
 require 'fleakr/support/object'
-require 'fleakr/support/request'
+require 'fleakr/support/request'
+require 'fleakr/support/url_expander'
+require 'fleakr/support/utility'

data/lib/fleakr/support/attribute.rb

@@ -15,7 +15,7 @@ module Fleakr
 
       def split(source)
         location, attribute = source.split('@')
-        location = self.name.to_s if location.blank?
+        location = self.name.to_s if Utility.blank?(location)
 
         [location, attribute]
       end
@@ -36,7 +36,7 @@ module Fleakr
       def value_from(document)
         values = sources.map do |source|
           node = node_for(document, source)
-          [node.attributes[attribute(source)], node.inner_text].reject{|v| v.blank?}.first unless node.nil?
+          [node.attributes[attribute(source)], node.inner_text].reject{|v| Utility.blank?(v) }.first unless node.nil?
         end
         values.compact.first
       end

data/lib/fleakr/support/object.rb

@@ -1,72 +1,76 @@
 module Fleakr
   module Support # :nodoc:all
     module Object
-    
+
       module ClassMethods
-      
+
         def attributes
           @attributes ||= []
         end
-      
+
         def flickr_attribute(*names_and_options)
-          options = names_and_options.extract_options!
+          attributes, options = Utility.extract_options(names_and_options)
 
-          names_and_options.each do |name|
+          attributes.each do |name|
             self.attributes << Attribute.new(name, options[:from])
             class_eval "attr_accessor :#{name}"
           end
         end
-      
+
         def has_many(*attributes)
           class_name = self.name
 
           attributes.each do |attribute|
-            target           = "Fleakr::Objects::#{attribute.to_s.classify}"
-            finder_attribute = "#{class_name.demodulize.underscore}_id"
+            target           = Utility.class_name_for('Fleakr::Objects', attribute)
+            finder_attribute = Utility.id_attribute_for(class_name)
 
             class_eval <<-CODE
-              def #{attribute}
-                @#{attribute} ||= #{target}.send("find_all_by_#{finder_attribute}".to_sym, self.id, self.authentication_options)
+              def #{attribute}(options = {})
+                options        = authentication_options.merge(options)
+                sorted_options = options.sort {|a, b| a[0].to_s <=> b[0].to_s }
+                key            = '#{attribute}_' + sorted_options.to_s
+
+                associations[key] ||= #{target}.send("find_all_by_#{finder_attribute}".to_sym, self.id, options)
               end
             CODE
           end
         end
-      
+
         def find_all(condition, options)
           attribute    = options[:using].nil? ? condition.to_s.sub(/^by_/, '') : options[:using]
           target_class = options[:class_name].nil? ? self.name : "Fleakr::Objects::#{options[:class_name]}"
-        
+
           class_eval <<-CODE
             def self.find_all_#{condition}(value, options = {})
               options.merge!(:#{attribute} => value)
-              
+
               response = Fleakr::Api::MethodRequest.with_response!('#{options[:call]}', options)
               (response.body/'rsp/#{options[:path]}').map {|e| #{target_class}.new(e, options) }
             end
           CODE
         end
-      
+
         def find_one(condition, options)
           attribute = options[:using].nil? ? condition.to_s.sub(/^by_/, '') : options[:using]
-        
+
           class_eval <<-CODE
             def self.find_#{condition}(value, options = {})
               options.merge!(:#{attribute} => value)
-              
+
               response = Fleakr::Api::MethodRequest.with_response!('#{options[:call]}', options)
               #{self.name}.new(response.body, options)
             end
           CODE
         end
-        
+
         def scoped_search
-          key = "#{self.name.demodulize.underscore.downcase}_id".to_sym
+          key = Utility.id_attribute_for(self.name)
 
           class_eval <<-CODE
             def search(*parameters)
               options = {:#{key} => self.id}
               options.merge!(self.authentication_options)
-              
+
               parameters << options
               Fleakr::Objects::Search.new(*parameters).results
             end
@@ -74,30 +78,30 @@ module Fleakr
         end
 
         def lazily_load(*attributes)
-          options = attributes.extract_options!
+          attributes, options = Utility.extract_options(attributes)
 
           attributes.each do |attribute|
             class_eval <<-CODE
-              def #{attribute}_with_loading
+              alias_method :#{attribute}_without_loading, :#{attribute}
+              def #{attribute}
                 self.send(:#{options[:with]}) if @#{attribute}.nil?
                 #{attribute}_without_loading
               end
-              alias_method_chain :#{attribute}, :loading
             CODE
           end
         end
-      
+
       end
-    
+
       module InstanceMethods
-      
+
         attr_reader :document, :authentication_options
-      
+
         def initialize(document = nil, options = {})
           self.populate_from(document) unless document.nil?
           @authentication_options = options.extract!(:auth_token)
         end
-      
+
         def populate_from(document)
           @document = document
           self.class.attributes.each do |attribute|
@@ -105,14 +109,25 @@ module Fleakr
             self.send("#{attribute.name}=".to_sym, value) unless value.nil?
           end
         end
-      
+
+        def inspect
+          names      = instance_variables.reject {|n| %w(@associations @document).include?(n.to_s) }
+          attributes = names.map {|n| "#{n}=#{instance_variable_get(n).inspect}" }
+
+          "#<#{self.class} #{attributes.join(', ')}>"
+        end
+
+        def associations
+          @associations ||= {}
+        end
+
       end
 
       def self.included(other)
         other.send(:extend, Fleakr::Support::Object::ClassMethods)
         other.send(:include, Fleakr::Support::Object::InstanceMethods)
       end
-      
+
     end
   end
 end

data/lib/fleakr/support/url_expander.rb

@@ -0,0 +1,37 @@
+module Fleakr
+  module Support # :nodoc:all
+
+    class UrlExpander
+
+      def self.expand(url)
+        new(url).expanded_path
+      end
+
+      def initialize(source_url)
+        @source_url = source_url
+      end
+
+      def path_to_expand
+        "/photo.gne?short=#{short_photo_id}"
+      end
+
+      def expanded_path
+        response_headers['location']
+      end
+
+      private
+
+      def response_headers
+        response = nil
+        Net::HTTP.start('www.flickr.com', 80) {|c| response = c.head(path_to_expand) }
+        response
+      end
+
+      def short_photo_id
+        @source_url.match(%r{([^/]+)$})[1]
+      end
+
+    end
+
+  end
+end

data/lib/fleakr/support/utility.rb

@@ -0,0 +1,66 @@
+module Fleakr
+  module Support # :nodoc:
+
+    # = Utility
+    #
+    # Helpful utility methods.
+    #
+    class Utility
+
+      # Given a module name and an underscored name, generate the fully
+      # namespaced class name.  For example:
+      #
+      #   >> Utility.class_name_for('Fleakr::Api', 'method_request')
+      #   => "Fleakr::Api::MethodRequest"
+      #
+      def self.class_name_for(module_name, name)
+        class_name = name.to_s.sub(/^(\w)/) {|m| m.upcase }
+        class_name = class_name.sub(/(_(\w))/) {|m| $2.upcase }
+        class_name = class_name.sub(/s$/, '')
+
+        "#{module_name}::#{class_name}"
+      end
+
+      # Given a class name as a string with an optional namespace, generate
+      # an attribute ID parameter suitable for retrieving the ID of an associated
+      # object.  For example:
+      #
+      #   >> Utility.id_attribute_for('Fleakr::Objects::Set')
+      #   => "set_id"
+      #
+      def self.id_attribute_for(class_name)
+        class_name = class_name.match(/([^:]+)$/)[1]
+        class_name.gsub!(/([A-Z])([A-Z][a-z])/, '\1_\2')
+        class_name.gsub!(/([a-z])([A-Z])/, '\1_\2')
+
+        "#{class_name.downcase}_id"
+      end
+
+      # Determine if the passed value is blank.  Blank values include nil,
+      # the empty string, and a string with only whitespace.
+      #
+      def self.blank?(object)
+        object.to_s.sub(/\s+/, '') == ''
+      end
+
+      # Extract the options from an array if present and return the new array
+      # and any available options.  For example:
+      #
+      #   >> Utility.extract_options([:sets, {:using => :key}])
+      #   => [[:sets], {:using => :key}]
+      #
+      # Note that this method does not modify the supplied parameter.
+      #
+      def self.extract_options(array_with_possible_options)
+        array = array_with_possible_options.dup
+
+        options = array.pop if array.last.is_a?(Hash)
+        options ||= {}
+
+        [array, options]
+      end
+
+    end
+
+  end
+end