flickrmocks 0.8.15 → 0.9.0

data/lib/flickr_mocks/models/photo_dimensions.rb

@@ -1,103 +1,105 @@
 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+)*$/
+  module Models
+    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
+      class << self
+        attr_reader :regexp_size
+      end
     
-    def initialize(data)
-      self.delegated_to_object = data
-    end
+      def initialize(data)
+        self.delegated_to_object = data
+      end
 
-    def available_sizes
-      map do |dimension|
-        dimension.size
-      end     
-    end
+      def available_sizes
+        map do |dimension|
+          dimension.size
+        end
+      end
 
-    def dimensions
-      @delegated_to_object
-    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)
+      def collection
+        @collection ||= ::WillPaginate::Collection.create(1, available_sizes.length, available_sizes.length) do |obj|
+          obj.replace(dimensions)
+        end
+        @collection
       end
-      @collection
-    end
     
-    def to_s
-      dimensions.map do  |dimension|
-        [dimension.size,[dimension.width,dimension.height].join('x')].join(':')
-      end.join(',')
-    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
+      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
+      # 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
+      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
+      alias :old_methods :methods
+      def methods
+        available_sizes + delegated_instance_methods + old_methods
+      end
 
-    def delegated_instance_methods
-      Models::Helpers.array_accessor_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
+      # custom cloning methods
+      def initialize_copy(other)
+        super
+        @delegated_to_object = @delegated_to_object.map do |object|
+          object.clone
+        end
       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
+      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
-    end
 
-    def valid_size?(data)
-      possible_sizes.include?(data.to_sym)
-    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
+      def get_size(size)
+        dimensions.keep_if do |dimension|
+          dimension.size == size
+        end.first
+      end
 
+    end
   end
 end

data/lib/flickr_mocks/models/photo_search.rb

@@ -1,115 +1,142 @@
 module FlickrMocks
-  class PhotoSearch
-    attr_reader :search_terms,:page,:date
+  module Models
+    class PhotoSearch
+      attr_reader :search_terms,:page,:date
 
-    @defaults =  {
-      :page => 1
-    }
+      @defaults =  {
+        :page => 1
+      }
     
-    @delegated_instance_methods = [:current_page, :per_page, :total_entries, :capped_entries,:perpage, :capped?,
-                                            :max_entries, :collection]
+      @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
+      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 initialize(data,options={})
+        self.delegated_to_object = data
+        self.search_terms = extract_search_terms(options)
+        self.page = extract_page(options)
+        self.date = extract_date(options)
+      end
 
-    def default(value)
-      PhotoSearch.defaults[value.to_sym]
-    end
 
-    def photos
-      @delegated_to_object
-    end
-    
-    def total_results
-      total_entries
-    end
+      # returns the string stored in the :search_terms tag. The string is stripped
+      # of spurious spaces and is made to be lower case.
+      def extract_search_terms(params)
+        Api::Sanitize.tags(params[:search_terms])
+      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 extract_date(params)
+        date = params[:date]
+        case date
+        when NilClass
+          nil
+        when String
+          Api::Helpers.valid_date?(date) ? Api::Helpers.date(date) : raise(ArgumentError)
+        else
+          raise ArgumentError
+        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))
+      def extract_page(params)
+        Api::Sanitize.page(params[:page])
       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
+      # returns the default class instance value corresponding to the supplied key.
+      def default(value)
+        PhotoSearch.defaults[value.to_sym]
+      end
 
-    alias :old_respond_to? :respond_to?
-    def respond_to?(method)
-      delegated_instance_methods.include?(method) || old_respond_to?(method)
-    end
+      # returns the list of photo objects returned by search
+      def photos
+        @delegated_to_object
+      end
+    
+      def total_results
+        total_entries
+      end
 
-    alias :old_methods :methods
-    def methods
-      delegated_instance_methods  + old_methods
-    end
+      def url_params
+        { :search_terms => search_terms,
+          :date => (date.nil? && search_terms.empty?) ? Api::Helpers.date : date
+        }.keep_if do |k,v|  !(v.nil? || v.to_s.empty?) end
+      end
 
-    def delegated_instance_methods
-      PhotoSearch.delegated_instance_methods + delegated_array_accessor_methods
-    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
 
-    # custom cloning methods
-    def initialize_copy(other)
-      super
-      @delegated_to_object = @delegated_to_object.clone
-    end
+      alias :old_respond_to? :respond_to?
+      def respond_to?(method)
+        delegated_instance_methods.include?(method) || old_respond_to?(method)
+      end
 
-    private
+      alias :old_methods :methods
+      def methods
+        delegated_instance_methods  + old_methods
+      end
 
-    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"
+      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
+      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 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 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 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
+      def delegated_array_accessor_methods
+        FlickrMocks::Models::Helpers.array_accessor_methods
+      end
     
+    end
   end
 end

data/lib/flickr_mocks/models/photo_size.rb

@@ -1,60 +1,61 @@
 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
+  module Models
+    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
 end