fleakr 0.4.1 → 0.4.2

data/lib/fleakr/core_ext.rb

@@ -1 +1,3 @@
-require 'fleakr/core_ext/hash'
+require 'fleakr/core_ext/hash'
+require 'fleakr/core_ext/false_class'
+require 'fleakr/core_ext/true_class'

data/lib/fleakr/core_ext/false_class.rb

@@ -0,0 +1,7 @@
+class FalseClass # :nodoc:
+  
+  def to_i
+    0
+  end
+  
+end

data/lib/fleakr/core_ext/true_class.rb

@@ -0,0 +1,7 @@
+class TrueClass # :nodoc:
+  
+  def to_i
+    1
+  end
+  
+end

data/lib/fleakr/objects/authentication_token.rb

@@ -17,22 +17,39 @@ module Fleakr
       
       flickr_attribute :value, :from => 'auth/token'
       flickr_attribute :permissions, :from => 'auth/perms'
+      flickr_attribute :user_id, :from => 'auth/user@nsid'
+      flickr_attribute :user_name, :from => 'auth/user@username' 
+      flickr_attribute :full_name, :from => 'auth/user@fullname'
       
       # Retrieve a full authentication token from the supplied mini-token (e.g. 123-456-789)
       #
-      def self.from_mini_token(token)
-        parameters = {:mini_token => token, :sign? => true}
-        response = Fleakr::Api::MethodRequest.with_response!('auth.getFullToken', parameters)
-        
-        self.new(response.body)
+      def self.from_mini_token(mini_token)
+        from :mini_token, mini_token
       end
       
       # Retrieve a full authentication token from the supplied auth_token string
       # (e.g. 45-76598454353455)
       # 
-      def self.from_auth_token(token)
-        parameters = {:auth_token => token, :sign? => true}
-        response = Fleakr::Api::MethodRequest.with_response!('auth.checkToken', parameters)
+      def self.from_auth_token(auth_token)
+        from :auth_token, auth_token
+      end
+      
+      # Retrieve a full authentication token from the supplied frob
+      def self.from_frob(frob)
+        from :frob, frob
+      end
+      
+      def self.from(thing, value) # :nodoc:
+        api_methods = {
+          :mini_token => 'getFullToken',
+          :auth_token => 'checkToken',
+          :frob       => 'getToken'
+        }
+        
+        method = "auth.#{api_methods[thing]}"
+        
+        parameters = {thing => value, :authenticate? => false}
+        response = Fleakr::Api::MethodRequest.with_response!(method, parameters)
         
         self.new(response.body)
       end

data/lib/fleakr/objects/photo.rb

@@ -3,6 +3,9 @@ module Fleakr
     
     # = Photo
     #
+    # Handles both the retrieval of Photo objects from various associations (e.g. User / Set) as 
+    # well as the ability to upload images to the Flickr site.
+    # 
     # == Attributes
     #
     # [id] The ID for this photo
@@ -59,20 +62,32 @@ module Fleakr
       
       has_many :images
 
-      # Upload the photo specified by <tt>filename</tt> to the user's Flickr account.  This
-      # call requires authentication.
+      # Upload the photo specified by <tt>filename</tt> to the user's Flickr account. When uploading,
+      # there are several options available (none are required):
+      #
+      # [:title] The title for this photo. Any string is allowed.
+      # [:description] The description for this photo. Any string is allowed.
+      # [:tags] A collection of tags for this photo. This can be a string or array of strings.
+      # [:viewable_by] Who can view this photo?  Acceptable values are one of <tt>:everyone</tt>,
+      #                <tt>:friends</tt> or <tt>:family</tt>.  This can also take an array of values
+      #                (e.g. <tt>[:friends, :family]</tt>) to make it viewable by friends and family.
+      # [:level] The safety level of this photo.  Acceptable values are one of <tt>:safe</tt>,
+      #          <tt>:moderate</tt>, or <tt>:restricted</tt>.
+      # [:type] The type of image this is.  Acceptable values are one of <tt>:photo</tt>,
+      #         <tt>:screenshot</tt>, or <tt>:other</tt>.
+      # [:hide?] Should this photo be hidden from public searches? Takes a boolean.
       #
-      def self.upload(filename)
-        response = Fleakr::Api::UploadRequest.with_response!(filename)
+      def self.upload(filename, options = {})
+        response = Fleakr::Api::UploadRequest.with_response!(filename, :create, options)
         photo = Photo.new(response.body)
-        Photo.find_by_id(photo.id, :authenticate? => true)
+        Photo.find_by_id(photo.id)
       end
 
       # Replace the current photo's image with the one specified by filename.  This 
       # call requires authentication.
       #
       def replace_with(filename)
-        response = Fleakr::Api::UploadRequest.with_response!(filename, :photo_id => self.id, :type => :update)
+        response = Fleakr::Api::UploadRequest.with_response!(filename, :update, :photo_id => self.id)
         self.populate_from(response.body)
         self
       end

data/lib/fleakr/support/object.rb

@@ -33,8 +33,10 @@ module Fleakr
           target_class = options[:class_name].nil? ? self.name : "Fleakr::Objects::#{options[:class_name]}"
         
           class_eval <<-CODE
-            def self.find_all_#{condition}(value)
-              response = Fleakr::Api::MethodRequest.with_response!('#{options[:call]}', :#{attribute} => value)
+            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) }
             end
           CODE

data/lib/fleakr/version.rb

@@ -3,7 +3,7 @@ module Fleakr
     
     MAJOR = 0
     MINOR = 4
-    TINY  = 1
+    TINY  = 2
     
     def self.to_s
       [MAJOR, MINOR, TINY].join('.')

data/test/fixtures/auth.getToken.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<rsp stat="ok">
+<auth>
+	<token>abc-123</token>
+	<perms>delete</perms>
+	<user nsid="31066442@N69" fullname="Sir Froot Pants" username="frootpantz"></user>
+</auth>
+</rsp>

data/test/unit/fleakr/api/method_request_test.rb

@@ -26,16 +26,6 @@ module Fleakr::Api
           request.parameters[:method].value.should == 'flickr.people.findByUsername'
         end
         
-        it "should know that it needs to sign the request" do
-          ParameterList.expects(:new).with(:sign? => true).returns(stub(:<< => nil))
-          request = MethodRequest.new('people.findByUsername', :sign? => true)
-        end
-        
-        it "should know that it needs to authenticate the request" do
-          ParameterList.expects(:new).with(:authenticate? => true).returns(stub(:<< => nil))
-          request = MethodRequest.new('activity.userPhotos', :authenticate? => true)
-        end
-
         it "should know the endpoint with full parameters" do
           query_parameters = 'foo=bar'
         

data/test/unit/fleakr/api/option_test.rb

@@ -0,0 +1,179 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+    
+  class OptionTest < Test::Unit::TestCase
+    
+    def self.should_know_the_class_for(type, options)
+      it "should know the class for the :#{type} type" do
+        Option.class_for(type).should == options[:is]
+      end
+    end
+    
+    describe "The Option class" do
+      should_know_the_class_for :title,       :is => Fleakr::Api::SimpleOption
+      should_know_the_class_for :description, :is => Fleakr::Api::SimpleOption
+      should_know_the_class_for :tags,        :is => Fleakr::Api::TagOption
+      should_know_the_class_for :viewable_by, :is => Fleakr::Api::ViewOption
+      should_know_the_class_for :level,       :is => Fleakr::Api::LevelOption
+      should_know_the_class_for :type,        :is => Fleakr::Api::TypeOption
+      should_know_the_class_for :hide?,       :is => Fleakr::Api::HiddenOption
+      
+      it "should be able to create an option for a type" do
+        option = stub()
+        
+        Option.expects(:class_for).with(:title).returns(Fleakr::Api::SimpleOption)
+        Fleakr::Api::SimpleOption.expects(:new).with(:title, 'blip').returns(option)
+        
+        Option.for(:title, 'blip').should == option
+      end
+    end
+    
+  end
+  
+  class SimpleOptionTest < Test::Unit::TestCase
+    
+    describe "An instance of the SimpleOption class" do
+      it "should have a type" do
+        so = SimpleOption.new(:title, 'blip')
+        so.type.should == :title
+      end
+      
+      it "should have a value" do
+        so = SimpleOption.new(:title, 'blip')
+        so.value.should == 'blip'
+      end
+      
+      it "should be able to generate a hash representation of itself" do
+        so = SimpleOption.new(:title, 'blip')
+        so.to_hash.should == {:title => 'blip'}
+      end
+    end
+    
+  end
+
+  class TagOptionTest < Test::Unit::TestCase
+    
+    describe "An instance of the TagOption class" do
+      
+      it "should normalize the input value to an array" do
+        to = TagOption.new(:tags, 'blip')
+        to.value.should == ['blip']
+      end
+      
+      it "should be able to generate a hash representation of itself with tags joined on spaces" do
+        to = TagOption.new(:tags, %w(bop bip))
+        to.to_hash.should == {:tags => '"bop" "bip"'}
+      end
+      
+      it "should quote tag values with spaces" do
+        to = TagOption.new(:tags, ['tag', 'one with spaces'])
+        to.to_hash.should == {:tags => '"tag" "one with spaces"'}
+      end
+    end
+    
+  end
+  
+  class ViewOptionTest < Test::Unit::TestCase
+    
+    describe "An instance of the ViewOption class" do
+      it "should be able to generate a hash representation for viewing by :everyone" do
+        vo = ViewOption.new(:viewable_by, :everyone)
+        vo.to_hash.should == {:is_public => 1, :is_family => 0, :is_friend => 0}
+      end
+
+      it "should be able to generate a hash representation for viewing by :family" do
+        vo = ViewOption.new(:viewable_by, :family)
+        vo.to_hash.should == {:is_public => 0, :is_family => 1, :is_friend => 0}
+      end
+      
+      it "should be able to generate a hash representation for viewing by :friends" do
+        vo = ViewOption.new(:viewable_by, :friends)
+        vo.to_hash.should == {:is_public => 0, :is_family => 0, :is_friend => 1}
+      end
+      
+      it "should know the visibility is public if value is set to :everyone" do
+        vo = ViewOption.new(:viewable_by, :everyone)
+        vo.public?.should be(true)
+      end
+      
+      it "should know the visibility is not public if :everyone is not the only value" do
+        vo = ViewOption.new(:viewable_by, [:everyone, :family])
+        vo.public?.should be(false)
+      end
+      
+      it "should know that its visible to friends and family if specified as such" do
+        vo = ViewOption.new(:viewable_by, [:friends, :family])
+        vo.friends?.should be(true)
+        vo.family?.should be(true)
+      end
+      
+    end
+    
+  end
+
+  class LevelOptionTest < Test::Unit::TestCase
+    
+    describe "An instance of the LevelOption class" do
+      
+      it "should be able to generate a hash representation for the :safe level" do
+        lo = LevelOption.new(:level, :safe)
+        lo.to_hash.should == {:safety_level => 1}
+      end
+      
+      it "should be able to generate a hash representation for the :moderate level" do
+        lo = LevelOption.new(:level, :moderate)
+        lo.to_hash.should == {:safety_level => 2}
+      end
+      
+      it "should be able to generate a hash representation for the :restricted level" do
+        lo = LevelOption.new(:level, :restricted)
+        lo.to_hash.should == {:safety_level => 3}
+      end
+      
+    end
+    
+  end
+
+  class TypeOptionTest < Test::Unit::TestCase
+    
+    describe "An instance of the TypeOption class" do
+      
+      it "should be able to generate a hash representation for the :photo type" do
+        to = TypeOption.new(:type, :photo)
+        to.to_hash.should == {:content_type => 1}
+      end
+      
+      it "should be able to generate a hash representation for the :screenshot type" do
+        to = TypeOption.new(:type, :screenshot)
+        to.to_hash.should == {:content_type => 2}
+      end
+      
+      it "should be able to generate a hash representation for the :other type" do
+        to = TypeOption.new(:type, :other)
+        to.to_hash.should == {:content_type => 3}
+      end
+      
+    end
+    
+  end
+  
+  class HiddenOptionTest < Test::Unit::TestCase
+    
+    describe "An instance of the HiddenOption class" do
+      
+      it "should be able to generate a hash representation when set to true" do
+        ho = HiddenOption.new(:hide?, true)
+        ho.to_hash.should == {:hidden => 2}
+      end
+      
+      it "should be able to generate a hash representation when set to false" do
+        ho = HiddenOption.new(:hide?, false)
+        ho.to_hash.should == {:hidden => 1}
+      end
+      
+    end
+    
+  end
+
+end

data/test/unit/fleakr/api/parameter_list_test.rb

@@ -9,7 +9,6 @@ module Fleakr::Api
         @api_key = 'key'
         @secret  = 'foobar'
 
-        Fleakr.stubs(:shared_secret).with().returns(@secret)
         Fleakr.stubs(:api_key).with().returns(@api_key)
         @parameter_list = ParameterList.new
       end
@@ -24,7 +23,7 @@ module Fleakr::Api
         parameter_list = ParameterList.new(:one => 'two')
         parameter_list[:one].value.should == 'two'
       end
-
+      
       it "should be able to add parameters to its list" do
         parameter = ValueParameter.new('foo', 'bar')
         
@@ -47,11 +46,15 @@ module Fleakr::Api
       end
       
       it "should be able to calculate the signature of the parameters" do
+        Fleakr.stubs(:shared_secret).with().returns(@secret)
+        
         @parameter_list << ValueParameter.new('foo', 'bar')
         @parameter_list.signature.should == Digest::MD5.hexdigest("#{@secret}api_key#{@api_key}foobar")
       end
       
       it "should use the correct order when signing a list of multiple parameters" do
+        Fleakr.stubs(:shared_secret).with().returns(@secret)
+        
         @parameter_list << ValueParameter.new('z', 'a')
         @parameter_list << ValueParameter.new('a', 'z')
         
@@ -59,6 +62,8 @@ module Fleakr::Api
       end
       
       it "should ignore the parameters that aren't included in the signature" do
+        Fleakr.stubs(:shared_secret).with().returns(@secret)
+        
         @parameter_list << ValueParameter.new('foo', 'bar')
         @parameter_list << ValueParameter.new('yes', 'no', false)
         
@@ -76,15 +81,30 @@ module Fleakr::Api
         @parameter_list.sign?.should be(false)
       end
       
-      it "should know that it needs to sign the request when asked" do
-        parameter_list = ParameterList.new(:sign? => true)
-        parameter_list.sign?.should be(true)
+      it "should know that it needs to sign the request when a shared secret is available" do
+        Fleakr.expects(:shared_secret).with().returns(@secret)
+        @parameter_list.sign?.should be(true)
       end
       
       it "should know that it doesn't need to authenticate the request by default" do
         @parameter_list.authenticate?.should be(false)
       end
       
+      it "should know to authenticate the request when a token is available" do
+        Fleakr.stubs(:token).with().returns(stub(:value => 'toke'))
+        parameter_list = ParameterList.new
+
+        parameter_list.authenticate?.should be(true)
+      end
+      
+      it "should not authenticate the request if it's been specifically told not to" do
+        Fleakr.expects(:token).with().never
+        
+        parameter_list = ParameterList.new(:authenticate? => false)
+        parameter_list.authenticate?.should be(false)
+      end
+      
+      
       it "should know to authenticate the request when asked" do
         Fleakr.expects(:token).with().returns(stub(:value => 'toke'))
         
@@ -103,15 +123,10 @@ module Fleakr::Api
         auth_param.include_in_signature?.should be(true)
       end
       
-      it "should know that it needs to sign the request when it is to be authenticated" do
-        Fleakr.expects(:token).with().returns(stub(:value => 'toke'))
-        
-        parameter_list = ParameterList.new(:authenticate? => true)
-        parameter_list.sign?.should be(true)
-      end
-      
       it "should include the signature in the list of parameters if the request is to be signed" do
-        parameter_list = ParameterList.new(:sign? => true)
+        parameter_list = ParameterList.new
+        
+        parameter_list.stubs(:sign?).with().returns(true)
         parameter_list.stubs(:signature).with().returns('sig')
         
         signature_param = parameter_list[:api_sig]
@@ -122,24 +137,24 @@ module Fleakr::Api
       end
       
       context "with associated parameters" do
-
+      
         before do
           @p1 = ValueParameter.new('a', 'b')
           @p2 = ValueParameter.new('c', 'd')
-
+      
           @p1.stubs(:to_query).with().returns('q1')
           @p1.stubs(:to_form).with().returns('f1')
           
           @p2.stubs(:to_query).with().returns('q2')
           @p2.stubs(:to_form).with().returns('f2')
-
+      
           @parameter_list.stubs(:list).with().returns('a' => @p1, 'c' => @p2)
         end
-
+      
         it "should be able to generate a query representation of itself" do
           @parameter_list.to_query.should == 'q1&q2'
         end
-
+      
         it "should be able to represent a form representation of itself" do
           @parameter_list.stubs(:boundary).returns('bound')