picasa 0.3.3 → 0.4.0

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+.rvmrc
 .bundle
 .config
 .yardoc

data/.travis.yml

@@ -2,5 +2,10 @@ notifications:
   disabled: true
 rvm:
   - 1.8.7
-  - 1.9.2
   - 1.9.3
+env:
+  - XML_PARSER=rexml
+  - XML_PARSER=nokogiri
+  - XML_PARSER=libxml
+  # does not work yet
+  # - XML_PARSER=ox

data/Gemfile

@@ -4,3 +4,9 @@ gemspec
 
 gem "rake"
 gem "minitest", :platform => :ruby_18
+gem "debugger", :platform => :ruby_19
+
+# xml parsers
+gem "nokogiri"
+gem "libxml-ruby"
+gem "ox"

data/README.md

@@ -1,7 +1,6 @@
 # Picasa
 
-Simple google picasa managment.
-Only for public albums so far.
+Ruby library for [Picasa Web Albums Data API](https://developers.google.com/picasa-web/)
 
 ## Installation
 
@@ -12,34 +11,27 @@ gem install picasa
 ## Usage
 
 ``` ruby
-Picasa.albums(:google_user => 'google_username')
-# => [ {:id => "666", :title => "satan-album", :photos_count => 6, :photo => "url",
-#      :thumbnail => "url", :slideshow => "url", :summary => "summary"},
-#     {another one} ]
-
-Picasa.photos(:google_user => 'google_username', :album_id => 'album_id')
-#=> {:photos => [{ :title, :thumbnail_1, :thumbnail_2, :thumbnail_3, :photo },{}],
-#    :slideshow => "link to picasa slideshow"}
-```
-
-or you can set google user for all requests like this:
+client = Picasa::Client.new(user_id: "username@gmail.com")
+client.album.list
+# => Picasa::Presenter::AlbumList
 
-``` ruby
-Picasa.config do |c|
-  c.google_user = 'google.user'
-end
+client.album.show("album_id")
+# => Picasa::Presenter::Album
 ```
 
-and use it:
-
-``` ruby
-Picasa.albums
-Picasa.photos(:album_id => 'album_id')
-```
+If password is specified, all requests will be authenticated.
+This affect results to contain private data.
 
 ## Continuous Integration
 [![Build Status](https://secure.travis-ci.org/morgoth/picasa.png)](http://travis-ci.org/morgoth/picasa)
 
+## Contributors
+
+* [Bram Wijnands](https://github.com/BRamBoo)
+* [Rafael Souza](https://github.com/rafaels)
+* [jsaak](https://github.com/jsaak)
+* [Javier Guerra](https://github.com/javierg)
+
 ## Copyright
 
-Copyright (c) 2011 Wojciech Wnętrzak, released under the MIT license.
+Copyright (c) Wojciech Wnętrzak, released under the MIT license.

data/Rakefile

@@ -4,7 +4,7 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 Rake::TestTask.new(:test) do |test|
   test.libs << "lib" << "test"
-  test.pattern = "test/**/test_*.rb"
+  test.pattern = "test/**/*_test.rb"
   test.verbose = true
 end
 

data/lib/picasa.rb

@@ -1,16 +1,22 @@
-require "picasa/web_albums"
-require "picasa/config"
+require "multi_xml"
+
 require "picasa/version"
+require "picasa/utils"
+require "picasa/exceptions"
+require "picasa/connection"
+require "picasa/client"
+require "picasa/api/album"
 
-module Picasa
-  def self.albums(options = {})
-    web_albums = Picasa::WebAlbums.new(options.delete(:google_user))
-    web_albums.albums(options)
-  end
+require "picasa/presenter/album"
+require "picasa/presenter/album_list"
+require "picasa/presenter/author"
+require "picasa/presenter/link"
+require "picasa/presenter/media"
+require "picasa/presenter/photo"
+require "picasa/presenter/thumbnail"
 
-  def self.photos(options = {})
-    raise ArgumentError.new("You must specify album_id") unless options[:album_id]
-    web_albums = Picasa::WebAlbums.new(options.delete(:google_user))
-    web_albums.photos(options.delete(:album_id), options)
-  end
+module Picasa
+  API_URL      = "https://picasaweb.google.com"
+  API_AUTH_URL = "https://www.google.com"
+  API_VERSION  = "2"
 end

data/lib/picasa/api/album.rb

@@ -0,0 +1,45 @@
+module Picasa
+  module API
+    class Album
+      attr_reader :user_id, :credentials
+
+      # @param [Hash] credentials
+      #   @option options [String] :user_id google username/email
+      #   @option options [String] :password password for given username/email
+      def initialize(credentials)
+        if MultiXml.parser.to_s == "MultiXml::Parsers::Ox"
+          raise StandardError, "MultiXml parser is set to :ox - picasa gem will not work with it currently, use one of: :libxml, :nokogiri, :rexml"
+        end
+        @user_id  = credentials.fetch(:user_id)
+        @credentials = credentials
+      end
+
+      # Returns album list
+      #
+      # @param [Hash] additional options included in request
+      #
+      # @return [Presenter::AlbumList]
+      def list(options = {})
+        uri = URI.parse("/data/feed/api/user/#{user_id}")
+        parsed_body = Connection.new(credentials).get(uri.path, options)
+
+        Presenter::AlbumList.new(parsed_body["feed"])
+      end
+
+      # Returns photo list for given album
+      #
+      # @param [String] id of album
+      # @param [Hash] additional options included in request
+      #   @option options [String, Integer] :max_results max number of returned results
+      #   @option options [String] :tag include photos with given tag only
+      #
+      # @return [Presenter::Album]
+      def show(album_id, options = {})
+        uri = URI.parse("/data/feed/api/user/#{user_id}/albumid/#{album_id}")
+        parsed_body = Connection.new(credentials).get(uri.path, options)
+
+        Presenter::Album.new(parsed_body["feed"])
+      end
+    end
+  end
+end

data/lib/picasa/client.rb

@@ -0,0 +1,14 @@
+module Picasa
+  class Client
+    attr_reader :credentials
+
+    def initialize(credentials = {})
+      credentials[:user_id] || raise(ArgumentError, "You must specify user_id")
+      @credentials = credentials
+    end
+
+    def album
+      API::Album.new(credentials)
+    end
+  end
+end

data/lib/picasa/connection.rb

@@ -0,0 +1,86 @@
+require "net/https"
+require "cgi"
+require "uri"
+
+module Picasa
+  class Connection
+    attr_reader :user_id, :password, :response
+
+    def initialize(credentials = {})
+      @user_id  = credentials.fetch(:user_id)
+      @password = credentials.fetch(:password, nil)
+    end
+
+    def http(url = API_URL)
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http
+    end
+
+    def get(path, params = {})
+      authenticate if auth?
+
+      path = path_with_params(path, params)
+      request = Net::HTTP::Get.new(path, headers)
+      @response = http.request(request)
+      parsed_body
+    end
+
+    def parsed_body
+      @parsed_body ||= MultiXml.parse(response.body)
+    end
+
+    def inline_params(params)
+      params.map do |key, value|
+        dasherized = key.to_s.gsub("_", "-")
+        "#{CGI.escape(dasherized)}=#{CGI.escape(value.to_s)}"
+      end.join("&")
+    end
+
+    def path_with_params(path, params = {})
+      path = path + "?" + inline_params(params) unless params.empty?
+      URI.parse(path).to_s
+    end
+
+    private
+
+    def headers
+      {"User-Agent" => "ruby-gem-v#{Picasa::VERSION}", "GData-Version" => API_VERSION}.tap do |headers|
+        headers["Authorization"] = "GoogleLogin auth=#{@auth_key}" if @auth_key
+      end
+    end
+
+    def auth?
+      !password.nil?
+    end
+
+    def validate_email!
+      unless user_id =~ /[a-z0-9][a-z0-9._%+-]+[a-z0-9]@[a-z0-9][a-z0-9.-][a-z0-9]+\.[a-z]{2,6}/i
+        raise ArgumentError.new("user_id must be a valid E-mail address when authentication is used.")
+      end
+    end
+
+    def authenticate
+      return @auth_key if defined?(@auth_key)
+      validate_email!
+
+      data = inline_params({"accountType" => "HOSTED_OR_GOOGLE",
+                            "Email"       => user_id,
+                            "Passwd"      => password,
+                            "service"     => "lh2",
+                            "source"      => "ruby-gem-v#{Picasa::VERSION}"})
+
+      response = http(API_AUTH_URL).post("/accounts/ClientLogin", data)
+      raise ResponseError.new(response.body, response) unless response.is_a? Net::HTTPSuccess
+
+      @auth_key = extract_auth_key(response.body)
+    end
+
+    def extract_auth_key(data)
+      response = data.split("\n").map { |v| v.split("=") }
+      params = Hash[response]
+      params["Auth"]
+    end
+  end
+end

data/lib/picasa/exceptions.rb

@@ -0,0 +1,17 @@
+module Picasa
+  # All Picasa exceptions can be cought by rescuing:
+  # Picasa::StandardError
+  #
+  class StandardError < StandardError; end
+
+  class ArgumentError < StandardError; end
+
+  class ResponseError < StandardError
+    attr_reader :response
+
+    def initialize(message, response)
+      @response = response
+      super(message)
+    end
+  end
+end

data/lib/picasa/presenter/album.rb

@@ -0,0 +1,76 @@
+require "picasa/presenter/base"
+
+module Picasa
+  module Presenter
+    class Album < Base
+      def author
+        @author ||= Author.new(safe_retrieve(parsed_body, "author"))
+      end
+
+      def entries
+        @entries ||= array_wrap(safe_retrieve(parsed_body, "entry")).map { |photo| Photo.new(photo) }
+      end
+      alias :photos :entries
+
+      def links
+        @links ||= safe_retrieve(parsed_body, "link").map { |link| Link.new(link) }
+      end
+
+      def media
+        @media ||= Media.new(safe_retrieve(parsed_body, "group"))
+      end
+
+      def published
+        @published ||= map_to_date(safe_retrieve(parsed_body, "published"))
+      end
+
+      def updated
+        @updated ||= map_to_date(safe_retrieve(parsed_body, "updated"))
+      end
+
+      def title
+        @title ||= safe_retrieve(parsed_body, "title")
+      end
+
+      def summary
+        @summary ||= safe_retrieve(parsed_body, "summary")
+      end
+
+      def rights
+        @rights ||= safe_retrieve(parsed_body, "rights")
+      end
+
+      def id
+        @id ||= array_wrap(safe_retrieve(parsed_body, "id"))[1]
+      end
+
+      def name
+        @name ||= safe_retrieve(parsed_body, "name")
+      end
+
+      def location
+        @location ||= safe_retrieve(parsed_body, "location")
+      end
+
+      def access
+        @access ||= safe_retrieve(parsed_body, "access")
+      end
+
+      def timestamp
+        @timestamp ||= safe_retrieve(parsed_body, "timestamp")
+      end
+
+      def numphotos
+        @numphotos ||= map_to_integer(safe_retrieve(parsed_body, "numphotos"))
+      end
+
+      def user
+        @user ||= safe_retrieve(parsed_body, "user")
+      end
+
+      def nickname
+        @nickname ||= safe_retrieve(parsed_body, "nickname")
+      end
+    end
+  end
+end

data/lib/picasa/presenter/album_list.rb

@@ -0,0 +1,60 @@
+require "picasa/presenter/base"
+
+module Picasa
+  module Presenter
+    class AlbumList < Base
+      def author
+        @author ||= Author.new(safe_retrieve(parsed_body, "author"))
+      end
+
+      def entries
+        @entries ||= array_wrap(safe_retrieve(parsed_body, "entry")).map { |entry| Album.new(entry) }
+      end
+      alias :albums :entries
+
+      def links
+        @links ||= safe_retrieve(parsed_body, "link").map { |link| Link.new(link) }
+      end
+
+      def title
+        @title ||= safe_retrieve(parsed_body, "title")
+      end
+
+      def updated
+        @updated ||= map_to_date(safe_retrieve(parsed_body, "updated"))
+      end
+
+      def icon
+        @icon ||= safe_retrieve(parsed_body, "icon")
+      end
+
+      def generator
+        @generator ||= safe_retrieve(parsed_body, "generator", "__content__")
+      end
+
+      def total_results
+        @total_results ||= map_to_integer(safe_retrieve(parsed_body, "totalResults"))
+      end
+
+      def start_index
+        @start_index ||= map_to_integer(safe_retrieve(parsed_body, "startIndex"))
+      end
+
+      def items_per_page
+        @items_per_page ||= map_to_integer(safe_retrieve(parsed_body, "itemsPerPage"))
+      end
+
+      def user
+        @user ||= safe_retrieve(parsed_body, "user")
+      end
+
+      def nickname
+        @nickname ||= safe_retrieve(parsed_body, "nickname")
+      end
+
+      def thumbnail
+        @thumbnail ||= safe_retrieve(parsed_body, "thumbnail")
+      end
+    end
+  end
+end

data/lib/picasa/presenter/author.rb

@@ -0,0 +1,15 @@
+require "picasa/presenter/base"
+
+module Picasa
+  module Presenter
+    class Author < Base
+      def name
+        @name ||= safe_retrieve(parsed_body, "name")
+      end
+
+      def uri
+        @uri ||= safe_retrieve(parsed_body, "uri")
+      end
+    end
+  end
+end