reagent-fleakr 0.2.1 → 0.3.0

data/lib/fleakr/photo.rb

@@ -1,26 +0,0 @@
-module Fleakr
-  class Photo
-
-    include Fleakr::Object
-    
-    flickr_attribute :title, :attribute => 'title'
-    flickr_attribute :id, :attribute => 'id'
-    flickr_attribute :farm_id, :attribute => 'farm'
-    flickr_attribute :server_id, :attribute => 'server'
-    flickr_attribute :secret, :attribute => 'secret'
-    
-    find_all :by_photoset_id, :call => 'photosets.getPhotos', :path => 'photoset/photo'
-    find_all :by_user_id, :call => 'people.getPublicPhotos', :path => 'photos/photo'
-    
-    def base_url
-      "http://farm#{self.farm_id}.static.flickr.com/#{self.server_id}/#{self.id}_#{self.secret}"
-    end
-
-    [:square, :thumbnail, :small, :medium, :large].each do |size|
-      define_method(size) do
-        Image.new(self.base_url, size)
-      end
-    end
-    
-  end
-end

data/lib/fleakr/request.rb

@@ -1,45 +0,0 @@
-module Fleakr
-  class Request
-
-    class ApiError < StandardError; end
-
-    def self.api_key=(key)
-      @api_key = key
-    end
-    
-    def self.api_key
-      @api_key
-    end
-    
-    def self.with_response!(method, additional_parameters = {})
-      request = Request.new(method, additional_parameters)
-      response = request.send
-      
-      raise(ApiError, "Code: #{response.error.code} - #{response.error.message}") if response.error?
-      
-      response
-    end
-    
-    def endpoint_uri
-      uri = URI.parse('http://api.flickr.com/services/rest/')
-      uri.query = self.query_parameters
-      uri
-    end
-    
-    def query_parameters
-      @parameters.map {|key,value| "#{key}=#{CGI.escape(value)}" }.join('&')
-    end
-    
-    def initialize(method, additional_parameters = {})
-      method = method.sub(/^(flickr\.)?/, 'flickr.')
-      
-      default_parameters = {:api_key => self.class.api_key, :method => method}
-      @parameters = default_parameters.merge(additional_parameters)
-    end
-    
-    def send
-      Response.new(Net::HTTP.get(self.endpoint_uri))
-    end
-    
-  end
-end

data/lib/fleakr/response.rb

@@ -1,21 +0,0 @@
-module Fleakr
-  class Response
-    
-    def initialize(response_xml)
-      @response_xml = response_xml
-    end
-
-    def body
-      @body ||= Hpricot.XML(@response_xml)
-    end
-    
-    def error?
-      (self.body/'rsp').attr('stat') != 'ok'
-    end
-    
-    def error
-      Error.new(self.body) if self.error?
-    end
-    
-  end
-end

data/lib/fleakr/search.rb

@@ -1,31 +0,0 @@
-module Fleakr
-  class Search
-
-    def initialize(text = nil, search_options = {})
-      @text = text
-      @search_options = search_options
-    end
-
-    def tag_list
-      Array(@search_options[:tags]).join(',')
-    end
-    
-    def parameters
-      parameters = {}
-      parameters.merge!(:text => @text) if @text
-      parameters.merge!(:tags => self.tag_list) if self.tag_list.length > 0
-      parameters
-    end
-
-    def results
-      if @results.nil?
-        response = Request.with_response!('photos.search', self.parameters)
-        @results = (response.body/'rsp/photos/photo').map do |flickr_photo|
-          Photo.new(flickr_photo)
-        end
-      end
-      @results
-    end
-
-  end
-end

data/lib/fleakr/set.rb

@@ -1,22 +0,0 @@
-module Fleakr
-  class Set
-
-    include Fleakr::Object
-
-    has_many :photos, :using => :photoset_id
-    
-    flickr_attribute :id, :attribute => 'id'
-    flickr_attribute :title
-    flickr_attribute :description
-    
-    find_all :by_user_id, :call => 'photosets.getList', :path => 'photosets/photoset'
-    
-    def save_to(path, size)
-      target = "#{path}/#{self.title}"
-      FileUtils.mkdir(target) unless File.exist?(target)
-      
-      self.photos.each {|p| p.send(size).save_to(target) }
-    end
-    
-  end
-end

data/lib/fleakr/user.rb

@@ -1,33 +0,0 @@
-module Fleakr
-  class User
-
-    include Fleakr::Object
-
-    flickr_attribute :id, :xpath => 'rsp/user', :attribute => 'nsid'
-    flickr_attribute :username, :xpath => 'rsp/user/username'
-    flickr_attribute :photos_url, :xpath => 'rsp/person/photosurl'
-    flickr_attribute :profile_url, :xpath => 'rsp/person/profileurl'
-    flickr_attribute :photos_count, :xpath => 'rsp/person/photos/count'
-    flickr_attribute :icon_server, :xpath => 'rsp/person', :attribute => 'iconserver'
-    flickr_attribute :icon_farm, :xpath => 'rsp/person', :attribute => 'iconfarm'
-    
-    has_many :sets, :groups, :photos
-    
-    find_one :by_username, :call => 'people.findByUsername'
-    find_one :by_email, :using => :find_email, :call => 'people.findByEmail'
-
-    def load_info
-      response = Request.with_response!('people.getInfo', :user_id => self.id)
-      self.populate_from(response.body)
-    end
-
-    def icon_url
-      if self.icon_server.to_i > 0
-        "http://farm#{self.icon_farm}.static.flickr.com/#{self.icon_server}/buddyicons/#{self.id}.jpg"
-      else
-        'http://www.flickr.com/images/buddyicon.jpg'
-      end
-    end
-
-  end
-end

data/test/fleakr/image_test.rb

@@ -1,82 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-module Fleakr
-  class ImageTest < Test::Unit::TestCase
-
-    def self.should_know_the_suffix_for(options)
-      it "should know the suffix for the :#{options.keys.first} size" do
-        Image.suffix_for(options.keys.first).should == options.values.first
-      end
-    end
-    
-    
-    describe "The Image class" do
-      
-      should_know_the_suffix_for :square    => '_s.jpg'
-      should_know_the_suffix_for :thumbnail => '_t.jpg'
-      should_know_the_suffix_for :small     => '_m.jpg'
-      should_know_the_suffix_for :medium    => '.jpg'
-      should_know_the_suffix_for :large     => '_b.jpg'
-      
-    end
-    
-    describe "An instance of the Image class" do
-      
-      before do
-        @base_filename = 'filename'
-        @base_url      = "http://foo.bar/#{@base_filename}"
-        @size          = :thumbnail
-
-        @image = Image.new(@base_url, @size)
-      end
-      
-      it "should know its full URL" do
-        Image.stubs(:suffix_for).with(@size).returns('.jpg')
-        @image.url.should == "#{@base_url}.jpg"
-      end
-      
-      it "should know its filename" do
-        Image.stubs(:suffix_for).with(@size).returns('.jpg')
-        @image.filename.should == "#{@base_filename}.jpg"
-      end
-      
-      context "when saving the file" do
-        
-        before do
-          @tmp_dir = create_temp_directory
-          
-          @url = 'http://host.com/image.jpg'
-          @image_filename = 'image.jpg'
-          
-          @image = Image.new('http://host/image', :thumbnail)
-          @image.stubs(:url).with().returns(@url)
-          @image.stubs(:filename).with().returns(@image_filename)
-        end
-        
-        after do
-          FileUtils.rm_rf(@tmp_dir)
-        end
-        
-        should "be able to save to a directory with the original filename" do
-          Net::HTTP.expects(:get).with(URI.parse(@url)).returns('image_data')
-          
-          @image.save_to(@tmp_dir)
-          File.read("#{@tmp_dir}/image.jpg").should == 'image_data'
-        end
-        
-        should "be able to save to a specified file" do
-          Net::HTTP.expects(:get).with(URI.parse(@url)).returns('image_data')
-          existing_file = "#{@tmp_dir}/existing_file.jpg"
-          
-          FileUtils.touch(existing_file)
-          
-          @image.save_to(existing_file)
-          File.read(existing_file).should == 'image_data'
-        end
-        
-      end
-
-    end
-    
-  end
-end

data/test/fleakr/photo_test.rb

@@ -1,64 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-module Fleakr
-  class PhotoTest < Test::Unit::TestCase
-
-    describe "The Photo class" do
-
-      should_find_all :photos, :by => :user_id, :call => 'people.getPublicPhotos', :path => 'rsp/photos/photo'
-      should_find_all :photos, :by => :photoset_id, :call => 'photosets.getPhotos', :path => 'rsp/photoset/photo'
-
-    end
-
-    describe "An instance of the Photo class" do
-      context "when populating from an XML document" do
-        before do
-          @object = Photo.new(Hpricot.XML(read_fixture('people.getPublicPhotos')).at('rsp/photos/photo'))
-        end
-
-        should_have_a_value_for :id        => '2924549350'
-        should_have_a_value_for :title     => 'Photo #1'
-        should_have_a_value_for :farm_id   => '4'
-        should_have_a_value_for :server_id => '3250'
-        should_have_a_value_for :secret    => 'cbc1804258'
-
-      end
-    end
-
-    context "in general" do
-
-      before do
-        @photo = Photo.new
-
-        @photo.stubs(:id).with().returns('1')
-        @photo.stubs(:farm_id).with().returns('2')
-        @photo.stubs(:server_id).with().returns('3')
-        @photo.stubs(:secret).with().returns('secret')
-      end
-
-      it "should know the base URL to retrieve images" do
-        @photo.base_url.should == "http://farm2.static.flickr.com/3/1_secret"
-      end
-
-    end
-
-    context "with a base URL" do
-
-      before do
-        @photo = Photo.new
-        @photo.stubs(:base_url).with().returns('url')
-      end
-
-      [:square, :thumbnail, :small, :medium, :large].each do |size|
-        it "should have a :#{size} image" do
-          image = stub()
-          Image.expects(:new).with('url', size).returns(image)
-          
-          @photo.send(size).should == image
-        end
-      end
-
-    end
-  end
-
-end

data/test/fleakr/request_test.rb

@@ -1,99 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-module Fleakr
-  class RequestTest < Test::Unit::TestCase
-
-    describe "A Request instance" do
-
-      it "should be able to set an API key" do
-        key = 'f00b4r'
-        Request.api_key = key
-        key.should == Request.api_key
-      end
-      
-      context "with an API key" do
-
-        before do
-          @api_key = 'f00b4r'
-          Request.stubs(:api_key).with().returns(@api_key)
-        end
-        
-        it "should know the full query parameters" do
-          request = Request.new('flickr.people.findByUsername', :username => 'foobar')
-          
-          expected = [
-            "api_key=#{@api_key}",
-            "method=flickr.people.findByUsername",
-            "username=foobar"
-          ]
-          
-          request.query_parameters.split('&').sort.should == expected
-        end
-
-        it "should escape the keys and values in the parameter list" do
-          request = Request.new('flickr.people.findByUsername', :username => 'the decapitator')
-          request.query_parameters.split('&').include?("username=#{CGI.escape('the decapitator')}").should be(true)
-        end
-        
-        it "should translate a shorthand API call" do
-          request = Request.new('people.findByUsername')
-          request.query_parameters.split('&').include?('method=flickr.people.findByUsername').should be(true)
-        end
-        
-        it "should know the endpoint with full parameters" do
-          query_parameters = 'foo=bar'
-          
-          request = Request.new('people.getInfo')
-          request.stubs(:query_parameters).with().returns(query_parameters)
-          
-          uri_mock = mock() {|m| m.expects(:query=).with(query_parameters)}
-          
-          URI.expects(:parse).with("http://api.flickr.com/services/rest/").returns(uri_mock)
-          
-          request.endpoint_uri.should == uri_mock
-        end
-        
-        it "should be able to make a request" do
-          endpoint_uri = stub()
-        
-          request = Request.new('flickr.people.findByUsername')
-          
-          request.stubs(:endpoint_uri).with().returns(endpoint_uri)
-          Net::HTTP.expects(:get).with(endpoint_uri).returns('<xml>')
-          
-          request.send
-        end
-        
-        it "should create a response from the request" do
-          response_xml  = '<xml>'
-          response_stub = stub()
-          
-          request = Request.new('flickr.people.findByUsername')
-          
-          Net::HTTP.stubs(:get).returns(response_xml)
-          Response.expects(:new).with(response_xml).returns(response_stub)
-          
-          request.send.should == response_stub
-        end
-        
-        it "should be able to make a full request and response cycle" do
-          response = stub(:error? => false)
-          Response.expects(:new).with(kind_of(String)).returns(response)
-          
-          Request.with_response!('flickr.people.findByUsername', :username => 'foobar').should == response
-        end
-        
-        it "should raise an exception when the full request / response cycle has errors" do
-          response = stub(:error? => true, :error => stub(:code => '1', :message => 'User not found'))
-          Response.stubs(:new).with(kind_of(String)).returns(response)
-          
-          lambda do
-            Request.with_response!('flickr.people.findByUsername', :username => 'foobar')
-          end.should raise_error(Fleakr::Request::ApiError)
-        end
-        
-      end
-
-    end
-  end
-end