flickrmocks 0.8.5

data/lib/flickr_mocks/flickraw/custom_marshal.rb

@@ -0,0 +1,39 @@
+module FlickrMocks
+
+  module CustomMarshal
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      def _load(string)
+        data = Marshal.load(string)
+        type = data.delete('flickr_type')
+        FlickRaw::Response.build(data,type)
+      end
+    end
+
+    def _dump(level)
+      result = marshal_flickraw(self)
+      result["flickr_type"] = self.flickr_type
+      Marshal.dump result
+    end
+
+    private
+    def marshal_flickraw(obj)
+      r = {}
+      obj.methods(false).each do |k|
+        v = obj.send k.to_sym
+        r[k.to_s] = case v
+        when Array then v.collect {|e| marshal_flickraw(e)}
+        when FlickRaw::Response then marshal_flickraw(v)
+        when FlickRaw::ResponseList then marshal_flickraw(v)
+        else v
+        end
+      end
+      r
+    end
+
+  end
+end

data/lib/flickr_mocks/flickraw/flickraw.rb

@@ -0,0 +1,14 @@
+module FlickRaw
+
+  class Response
+    include FlickrMocks::CustomMarshal
+    include FlickrMocks::CustomCompare
+    include FlickrMocks::CustomClone
+  end
+
+  class ResponseList
+    include FlickrMocks::CustomMarshal
+    include FlickrMocks::CustomCompare
+    include FlickrMocks::CustomClone
+  end
+end

data/lib/flickr_mocks/helpers.rb

@@ -0,0 +1,52 @@
+module FlickrMocks
+  module Helpers
+
+    class << self
+      def extension
+        ".marshal"
+      end
+
+      def fname_fixture(symbol)
+        raise RunTimeError unless symbol.is_a? Symbol
+        symbol.to_s + extension
+      end
+
+      def equivalent?(a,b)
+        return false if a.class != b.class
+        case a
+        when FlickRaw::Response,FlickRaw::ResponseList then a.methods(false).collect do |m|
+            b.respond_to?(m) ? equivalent?(a.send(m),b.send(m)) : false
+          end.inject(true) {|r1,r2| r1 && r2}
+
+        when Hash then a.keys.collect  do |k|
+            b.has_key?(k) ? equivalent?(a[k],b[k]) : false
+          end.inject(true){|r1,r2| r1 && r2}
+
+        when Array then a.each_with_index.collect do |v,i|
+            b.length == a.length ? equivalent?(v,b[i]) : false
+          end.inject(true) {|r1,r2| r1 && r2}
+        else
+          a == b
+        end
+      end
+
+      def dump(response,file)
+        begin
+          f  = File.open(file,'w')
+          f.write Marshal.dump(response)
+        ensure
+          f.close
+        end
+      end
+
+      def load(file)
+        begin
+          f=File.open(file,'r')
+          Marshal.load(f)
+        ensure
+          f.close
+        end
+      end
+    end
+  end
+end

data/lib/flickr_mocks/models/helpers.rb

@@ -0,0 +1,14 @@
+module FlickrMocks
+  module Models
+    module Helpers
+      def self.array_accessor_methods
+        [:[], :first, :last,:empty?,:length,:size,:each,:each_index,
+         :map, :select, :keep_if,:at,:fetch, :reverse_each,
+         :find_index, :index,:rindex, :collect,:values_at]
+      end
+      def self.possible_sizes
+        [:square, :thumbnail, :small, :medium, :medium_640, :large, :original]
+      end
+    end
+  end
+end

data/lib/flickr_mocks/models/photo.rb

@@ -0,0 +1,101 @@
+module FlickrMocks
+
+  class Photo
+    def initialize(photo)
+      self.delegated_to_object = photo
+      @delegated_instance_methods = @delegated_to_object.methods(false).push(:flickr_type)
+      @extended_photo = photo.methods.include?(:originalsecret)
+    end
+
+    # Return urls for various sizes
+    def square
+      FlickRaw.url_s self
+    end
+
+    def original
+      respond_to?(:originalsecret) ? FlickRaw.url_o(self) : nil
+    end
+
+    def thumbnail
+      FlickRaw.url_t self
+    end
+
+    def small
+      FlickRaw.url_m self
+    end
+
+    def medium
+      FlickRaw.url self
+    end
+
+    def large
+      FlickRaw.url_b self
+    end
+
+    def medium_640
+      FlickRaw.url_z self
+    end
+
+    def owner_url
+      FlickRaw.url_photopage self
+    end
+
+
+    def owner_id
+      case owner
+      when String then owner
+      else
+        return owner.nsid if owner.respond_to?(:nsid)
+        return owner.to_s
+      end
+    end
+
+    def photo_id
+      id
+    end
+
+    def usable?
+      license.to_i > 3
+    end
+
+    def ==(other)
+      @delegated_to_object == other.instance_eval('@delegated_to_object')
+    end
+
+    def initialize_copy(orig)
+      super
+      @delegated_to_object = @delegated_to_object.clone
+    end
+
+    def delegated_instance_methods
+      @delegated_instance_methods
+    end
+
+
+    def method_missing(id,*args,&block)
+      return @delegated_to_object.send(id,*args,&block) if delegated_instance_methods.include?(id)
+      return medium_640 if id.to_sym == :'medium 640'
+      super
+    end
+
+    alias :old_respond_to? :respond_to?
+    def respond_to?(method,type=false)
+      return true if method.to_sym == :'medium 640'
+      return true if delegated_instance_methods.include?(method)
+      old_respond_to?(method,type)
+    end
+
+    alias :old_methods :methods
+    def methods
+      delegated_instance_methods + old_methods
+    end
+
+
+    private
+    def delegated_to_object=(object)
+      raise ArgumentError, "FlickRaw::ResponseList expected" if object.class == FlickRaw::ResponseList
+      raise ArgumentError, 'FlickRaw::Response expected' unless object.class ==  FlickRaw::Response
+      @delegated_to_object = object
+    end
+  end
+end

data/lib/flickr_mocks/models/photo_details.rb

@@ -0,0 +1,86 @@
+module FlickrMocks
+  class PhotoDetails
+    attr_reader :dimensions
+    
+    def initialize(photo,dimensions)
+      self.dimensions = dimensions
+      self.delegated_to_object=  photo
+      raise ArgumentError 'owner id for photo did not match owner id for at least one size' unless valid_owner_for_dimensions?
+    end
+
+    def owner_name
+      self.owner.realname
+    end
+    
+    def owner_username
+      self.owner.username
+    end
+    
+    def dimensions
+      @dimensions
+    end
+
+    def photo
+      @delegated_to_object
+    end
+
+    def possible_sizes
+      FlickrMocks::Models::Helpers.possible_sizes
+    end
+
+    def ==(other)
+      return false unless other.class == PhotoDetails
+      (dimensions == other.dimensions) && (@delegated_to_object == other.instance_eval('@delegated_to_object'))
+    end
+
+    # metaprogramming methods
+    def method_missing(id,*args,&block)
+      return dimensions.sizes.send(id,*args,&block) if array_accessor_methods.include?(id)
+      return @delegated_to_object.send(id,*args,&block) if delegated_instance_methods.include?(id)
+      super
+    end
+
+    alias :old_respond_to? :respond_to?
+    def respond_to?(method,type=false)
+      delegated_instance_methods.include?(method) || old_respond_to?(method)
+    end
+
+    alias :old_methods :methods
+    def methods
+      delegated_instance_methods + old_methods
+    end
+
+    def delegated_instance_methods
+      @delegated_to_object.delegated_instance_methods + array_accessor_methods + [:owner_id] + possible_sizes
+    end
+
+    # custom cloning methods
+    def initialize_copy(orig)
+      super
+      @dimensions = @dimensions.clone
+      @delegated_to_object = @delegated_to_object.clone
+    end
+
+
+
+    private
+    def dimensions=(object)
+      @dimensions = object.class == PhotoSizes ?  object : PhotoSizes.new(object)
+    end
+
+    def delegated_to_object=(object)
+      @delegated_to_object = object.is_a?(Photo) ?  object : Photo.new(object)
+    end
+
+    def valid_owner_for_dimensions?
+      dimensions.map do |size|
+        photo.id == size.id
+      end.inject(true) do |prev,cur| prev && cur end
+    end
+
+    def array_accessor_methods
+      FlickrMocks::Models::Helpers.array_accessor_methods
+    end
+
+  end
+end

data/lib/flickr_mocks/models/photo_dimensions.rb

@@ -0,0 +1,103 @@
+require 'ostruct'
+
+module FlickrMocks
+  class PhotoDimensions
+    # sizes that are recognized by class. The sizes are in order from smallest to largest
+    @regexp_size = /^[a-z]+(_\d+)?:\d+x\d+(,[a-z]+(_\d+)?:\d+x\d+)*$/
+
+
+    class << self
+      attr_reader :regexp_size
+    end
+    
+    def initialize(data)
+      self.delegated_to_object = data
+    end
+
+    def available_sizes
+      map do |dimension|
+        dimension.size
+      end     
+    end
+
+    def dimensions
+      @delegated_to_object
+    end
+
+    def collection
+      @collection ||= ::WillPaginate::Collection.create(1, available_sizes.length, available_sizes.length) do |obj|
+        obj.replace(dimensions)
+      end
+      @collection
+    end
+    
+    def to_s
+      dimensions.map do  |dimension|
+        [dimension.size,[dimension.width,dimension.height].join('x')].join(':')
+      end.join(',')
+    end
+
+    def ==(other)
+      return false unless other.class.should == self.class
+      to_s == other.to_s
+    end
+
+    # metaprogramming methods
+    alias :old_respond_to? :respond_to?
+    def respond_to?(method)
+      valid_size?(method) || delegated_instance_methods.include?(method) || old_respond_to?(method)
+    end
+
+    def method_missing(id,*args,&block)
+      return get_size(id,*args,&block) if  valid_size?(id)
+      return dimensions.send(id,*args,&block) if delegated_instance_methods.include?(id)
+      super
+    end
+
+    alias :old_methods :methods
+    def methods
+      available_sizes + delegated_instance_methods + old_methods
+    end
+
+    def delegated_instance_methods
+      Models::Helpers.array_accessor_methods
+    end
+    
+    # custom cloning methods
+    def initialize_copy(other)
+      super
+      @delegated_to_object = @delegated_to_object.map do |object|
+        object.clone
+      end
+    end
+
+    def possible_sizes
+      FlickrMocks::Models::Helpers.possible_sizes
+    end
+    private
+    def delegated_to_object=(data)
+      raise(ArgumentError, "Invalid #{data} must respond to :to_s") unless data.respond_to?(:to_s)
+      # expecting strings of type: "square:1x1,thumbnail:2x2,small:3x3,medium:4x4,medium_640:4x4,large:5x5,original:6x6"
+      raise(ArgumentError, "Invalid string format") unless data =~ PhotoDimensions.regexp_size
+
+      @delegated_to_object= data.to_s.split(',').map do |fields|
+        size,dim = fields.split(':')
+        size= size.to_sym
+        raise(ArgumentError,"Invalid size provided #{size}") unless valid_size?(size)
+        width,height=dim.split(/x/)
+        OpenStruct.new :size => size,:width => width.to_i,:height => height.to_i
+      end
+    end
+
+    def valid_size?(data)
+      possible_sizes.include?(data.to_sym)
+    end
+
+    def get_size(size)
+      dimensions.keep_if do |dimension|
+        dimension.size == size
+      end.first
+    end
+
+  end
+end

data/lib/flickr_mocks/models/photo_search.rb

@@ -0,0 +1,115 @@
+module FlickrMocks
+  class PhotoSearch
+    attr_reader :search_terms,:page,:date
+
+    @defaults =  {
+      :page => 1
+    }
+    
+    @delegated_instance_methods = [:current_page, :per_page, :total_entries, :capped_entries,:perpage, :capped?,
+                                            :max_entries, :collection]
+
+    class << self
+      attr_accessor :defaults
+      attr_accessor :delegated_instance_methods
+    end
+
+    def initialize(data,options={})
+      self.delegated_to_object = data
+      self.search_terms = options[:search_terms]  
+      self.page = options[:page]
+      self.date = options[:date]
+    end
+
+    def default(value)
+      PhotoSearch.defaults[value.to_sym]
+    end
+
+    def photos
+      @delegated_to_object
+    end
+    
+    def total_results
+      total_entries
+    end
+
+    def url_params
+      { :search_terms => search_terms,
+        :date => (date.nil? && search_terms.empty?) ? Api.time : date
+      }.keep_if do |k,v|  !(v.nil? || v.to_s.empty?) end
+    end
+
+    def ==(other)
+      return false unless other.class == self.class
+      (photos == other.photos) && [:search_terms,:page,:date].inject(true) do |state,method|
+        state && (self.send(method) == other.send(method))
+      end
+    end
+
+    # metaprogramming methods
+    def method_missing(id,*args,&block)
+      return photos.photos.send(id,*args,&block)  if delegated_array_accessor_methods.include?(id)
+      return photos.send(id,*args,&block) if delegated_instance_methods.include?(id)
+      super
+    end
+
+    alias :old_respond_to? :respond_to?
+    def respond_to?(method)
+      delegated_instance_methods.include?(method) || old_respond_to?(method)
+    end
+
+    alias :old_methods :methods
+    def methods
+      delegated_instance_methods  + old_methods
+    end
+
+    def delegated_instance_methods
+      PhotoSearch.delegated_instance_methods + delegated_array_accessor_methods
+    end
+
+
+    # custom cloning methods
+    def initialize_copy(other)
+      super
+      @delegated_to_object = @delegated_to_object.clone
+    end
+
+    private
+
+    def delegated_to_object=(data)
+      @delegated_to_object = case data
+      when FlickRaw::ResponseList then Photos.new(data)
+      when Photos then data
+      else raise ArgumentError, "expecting object of class Photos or FlickRaw::ResponseList"
+      end
+      
+    end
+
+    def search_terms=(terms=nil)
+      terms ||= ''
+      raise ArgumentError, "Expecting String but got #{terms.class}" unless terms.is_a?(String)
+      @search_terms = terms
+    end
+
+    def page=(page=nil)
+      page ||= default(:page)
+      raise ArgumentError, "Expecting Fixnum but got #{page.class}" unless page.is_a?(Fixnum) or page.is_a?(String)
+      @page = page.to_i
+    end
+
+    def date=(date=nil)
+      raise ArgumentError, "Expecting String but got #{date.class}" unless date.is_a?(String) or date.nil?
+      begin
+        Chronic.parse(date) unless date.nil?
+      rescue
+        raise ArgumentError, "#{date} string can not be converted to Time object"
+      end   
+      @date = date
+    end
+
+    def delegated_array_accessor_methods
+      FlickrMocks::Models::Helpers.array_accessor_methods
+    end
+    
+  end
+end

data/lib/flickr_mocks/models/photo_size.rb

@@ -0,0 +1,60 @@
+module FlickrMocks
+
+  class PhotoSize
+    def initialize(object)
+      self.delegated_to_object= object
+    end
+
+    def size
+      label.to_s.downcase.sub(/\s+/,'_')
+    end
+
+    def id
+      source.split('/')[-1].split('_')[0]
+    end
+
+    def secret
+      source.split('/')[-1].split('_')[1]
+    end
+
+    def ==(other)
+      @delegated_to_object == other.instance_eval('@delegated_to_object')
+    end
+
+    # metaprogramming methods
+    def delegated_instance_methods
+      @delegated_to_object.methods(false).push(:flickr_type)
+    end
+
+    def method_missing(id,*args,&block)
+      return @delegated_to_object.send(id,*args,&block) if delegated_instance_methods.include?(id)
+      super
+    end
+
+    alias :old_respond_to? :respond_to?
+    def respond_to?(method,type=false)
+      return true if delegated_instance_methods.include?(method)
+      old_respond_to?(method,type)
+    end
+
+    alias :old_methods :methods
+    def methods
+      delegated_instance_methods + old_methods
+    end
+
+    # cloning and copying methods
+    def initialize_copy(orig)
+      super
+      @delegated_to_object = @delegated_to_object.clone
+    end
+
+
+  private
+
+    def delegated_to_object=(data)
+      raise ArgumentError, 'FlickRaw::Response expected' if data.class == FlickRaw::ResponseList
+      raise ArgumentError, 'FlickRaw::Response expected' unless data.is_a? FlickRaw::Response
+      @delegated_to_object = data
+    end
+  end
+end

data/lib/flickr_mocks/models/photo_sizes.rb

@@ -0,0 +1,93 @@
+module FlickrMocks
+  class PhotoSizes
+
+    def initialize(object)
+      self.delegated_to_object= object
+    end
+
+    def id
+      @delegated_to_object.first.id
+    end
+
+    def secret
+      @delegated_to_object.first.secret
+    end
+
+    def sizes
+      @delegated_to_object
+    end
+
+    def available_sizes
+      @available_sizes ||= sizes.map do |size|
+        size.size.to_sym
+      end
+      @available_sizes
+    end
+
+    def collection
+      @collection ||= ::WillPaginate::Collection.create(1, sizes.length, sizes.length) do |obj|
+        obj.replace(sizes)
+      end
+      @collection
+    end
+
+
+    def to_s
+      PhotoDimensions.new(@delegated_to_object.map do |size|
+          "#{size.size}:#{size.width}x#{size.height}"
+        end.join(',')).to_s
+    end
+
+    def ==(other)
+      return false unless self.class == other.class
+      @delegated_to_object == other.instance_eval('@delegated_to_object')
+    end
+
+    def possible_sizes
+      Models::Helpers.possible_sizes
+    end
+
+    # metaprogramming methods
+    alias :old_methods :methods
+    def methods
+      delegated_instance_methods + old_methods
+    end
+
+    def method_missing(id,*args,&block)
+      return @delegated_to_object.send(id,*args,&block) if  delegated_instance_methods.include?(id)
+      return nil if possible_sizes.include?(name)
+      super
+    end
+
+    alias :old_respond_to? :respond_to?
+    def respond_to?(method)
+      old_respond_to?(method) || delegated_instance_methods.include?(method)
+    end
+
+    def delegated_instance_methods
+      possible_sizes + FlickrMocks::Models::Helpers.array_accessor_methods
+    end
+
+    # cloning methods
+    def initialize_copy(orig)
+      super
+      @delegated_to_object = @delegated_to_object.map do |data|
+        data.clone
+      end
+    end
+
+
+    private
+
+    def delegated_to_object=(data)
+      raise ArgumentError, 'FlickRaw::Response expected' unless data.class == FlickRaw::ResponseList
+      @delegated_to_object = []
+      data.each do |datum|
+        @delegated_to_object.push PhotoSize.new datum
+      end
+    end
+    
+
+  end
+end
+