google_drive 0.3.0

data/lib/google_drive/list_row.rb

@@ -0,0 +1,84 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "forwardable"
+
+require "google_drive/util"
+require "google_drive/error"
+
+
+module GoogleDrive
+
+    # Hash-like object returned by GoogleDrive::List#[].
+    class ListRow
+        
+        include(Enumerable)
+        extend(Forwardable)
+        
+        def_delegators(:to_hash,
+            :keys, :values, :each_key, :each_value, :each, :each_pair, :hash,
+            :assoc, :fetch, :flatten, :key, :invert, :size, :length, :rassoc,
+            :merge, :reject, :select, :sort, :to_a, :values_at)
+        
+        def initialize(list, index) #:nodoc:
+          @list = list
+          @index = index
+        end
+        
+        def [](key)
+          return @list.get(@index, key)
+        end
+        
+        def []=(key, value)
+          @list.set(@index, key, value)
+        end
+        
+        def has_key?(key)
+          return @list.keys.include?(key)
+        end
+        
+        alias include? has_key?
+        alias key? has_key?
+        alias member? has_key?
+        
+        def update(hash)
+          for k, v in hash
+            self[k] = v
+          end
+        end
+        
+        alias merge! update
+        
+        def replace(hash)
+          clear()
+          update(hash)
+        end
+        
+        def clear()
+          for key in @list.keys
+            self[key] = ""
+          end
+        end
+        
+        def to_hash()
+          result = {}
+          for key in @list.keys
+            result[key] = self[key]
+          end
+          return result
+        end
+        
+        def ==(other)
+          return self.class == other.class && self.to_hash() == other.to_hash()
+        end
+        
+        alias === ==
+        alias eql? ==
+        
+        def inspect
+          return "\#<%p %p>" % [self.class, to_hash()]
+        end
+        
+    end
+    
+end

data/lib/google_drive/oauth1_fetcher.rb

@@ -0,0 +1,26 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "rubygems"
+require "oauth"
+
+
+module GoogleDrive
+
+    class OAuth1Fetcher #:nodoc:
+        
+        def initialize(oauth1_token)
+          @oauth1_token = oauth1_token
+        end
+        
+        def request_raw(method, url, data, extra_header, auth)
+          if method == :delete || method == :get
+            return @oauth1_token.__send__(method, url, extra_header)
+          else
+            return @oauth1_token.__send__(method, url, data, extra_header)
+          end
+        end
+        
+    end
+    
+end

data/lib/google_drive/oauth2_fetcher.rb

@@ -0,0 +1,47 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "rubygems"
+require "oauth2"
+
+
+module GoogleDrive
+
+    class OAuth2Fetcher #:nodoc:
+        
+        class Response
+            
+            def initialize(raw_res)
+              @raw_res = raw_res
+            end
+            
+            def code
+              return @raw_res.status.to_s()
+            end
+            
+            def body
+              return @raw_res.body
+            end
+            
+            def [](name)
+              return @raw_res.headers[name]
+            end
+            
+        end
+        
+        def initialize(oauth2_token)
+          @oauth2_token = oauth2_token
+        end
+        
+        def request_raw(method, url, data, extra_header, auth)
+          if method == :delete || method == :get
+            raw_res = @oauth2_token.request(method, url, {:header => extra_header})
+          else
+            raw_res = @oauth2_token.request(method, url, {:header => extra_header, :body => data})
+          end
+          return Response.new(raw_res)
+        end
+        
+    end
+    
+end

data/lib/google_drive/record.rb

@@ -0,0 +1,31 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "google_drive/util"
+require "google_drive/error"
+
+
+module GoogleDrive
+
+    # DEPRECATED: Table and Record feeds are deprecated and they will not be available after
+    # March 2012.
+    #
+    # Use GoogleDrive::Table#records to get GoogleDrive::Record objects.
+    class Record < Hash
+        include(Util)
+
+        def initialize(session, entry) #:nodoc:
+          @session = session
+          entry.css("gs|field").each() do |field|
+            self[field["name"]] = field.inner_text
+          end
+        end
+
+        def inspect #:nodoc:
+          content = self.map(){ |k, v| "%p => %p" % [k, v] }.join(", ")
+          return "\#<%p:{%s}>" % [self.class, content]
+        end
+
+    end
+
+end

data/lib/google_drive/session.rb

@@ -0,0 +1,436 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "cgi"
+require "stringio"
+
+require "rubygems"
+require "nokogiri"
+
+require "google_drive/util"
+require "google_drive/client_login_fetcher"
+require "google_drive/oauth1_fetcher"
+require "google_drive/oauth2_fetcher"
+require "google_drive/error"
+require "google_drive/authentication_error"
+require "google_drive/spreadsheet"
+require "google_drive/worksheet"
+require "google_drive/collection"
+require "google_drive/file"
+
+
+module GoogleDrive
+
+    # Use GoogleDrive.login or GoogleDrive.saved_session to get
+    # GoogleDrive::Session object.
+    class Session
+
+        include(Util)
+        extend(Util)
+
+        UPLOAD_CHUNK_SIZE = 512 * 1024
+        
+        # The same as GoogleDrive.login.
+        def self.login(mail, password, proxy = nil)
+          session = Session.new(nil, ClientLoginFetcher.new({}, proxy))
+          session.login(mail, password)
+          return session
+        end
+
+        # The same as GoogleDrive.login_with_oauth.
+        def self.login_with_oauth(oauth_token)
+          case oauth_token
+            when OAuth::AccessToken
+              fetcher = OAuth1Fetcher.new(oauth_token)
+            when OAuth2::AccessToken
+              fetcher = OAuth2Fetcher.new(oauth_token)
+            else
+              raise(GoogleDrive::Error,
+                  "oauth_token is neither OAuth::Token nor OAuth2::Token: %p" % oauth_token)
+          end
+          return Session.new(nil, fetcher)
+        end
+
+        # The same as GoogleDrive.restore_session.
+        def self.restore_session(auth_tokens, proxy = nil)
+          return Session.new(auth_tokens, nil, proxy)
+        end
+        
+        # Creates a dummy GoogleDrive::Session object for testing.
+        def self.new_dummy()
+          return Session.new(nil, Object.new())
+        end
+
+        # DEPRECATED: Use GoogleDrive.restore_session instead.
+        def initialize(auth_tokens = nil, fetcher = nil, proxy = nil)
+          if fetcher
+            @fetcher = fetcher
+          else
+            @fetcher = ClientLoginFetcher.new(auth_tokens || {}, proxy)
+          end
+        end
+
+        # Authenticates with given +mail+ and +password+, and updates current session object
+        # if succeeds. Raises GoogleDrive::AuthenticationError if fails.
+        # Google Apps account is supported.
+        def login(mail, password)
+          if !@fetcher.is_a?(ClientLoginFetcher)
+            raise(GoogleDrive::Error,
+                "Cannot call login for session created by login_with_oauth.")
+          end
+          begin
+            @fetcher.auth_tokens = {
+              :wise => authenticate(mail, password, :wise),
+              :writely => authenticate(mail, password, :writely),
+            }
+          rescue GoogleDrive::Error => ex
+            return true if @on_auth_fail && @on_auth_fail.call()
+            raise(AuthenticationError, "Authentication failed for #{mail}: #{ex.message}")
+          end
+        end
+
+        # Authentication tokens.
+        def auth_tokens
+          if !@fetcher.is_a?(ClientLoginFetcher)
+            raise(GoogleDrive::Error,
+                "Cannot call auth_tokens for session created by " +
+                "login_with_oauth.")
+          end
+          return @fetcher.auth_tokens
+        end
+
+        # Authentication token.
+        def auth_token(auth = :wise)
+          return self.auth_tokens[auth]
+        end
+
+        # Proc or Method called when authentication has failed.
+        # When this function returns +true+, it tries again.
+        attr_accessor :on_auth_fail
+
+        # Returns list of files for the user as array of GoogleDrive::File or its subclass.
+        # You can specify query parameters described at
+        # https://developers.google.com/google-apps/documents-list/#getting_a_list_of_documents_and_files
+        #
+        # e.g.
+        #   session.files
+        #   session.files("title" => "hoge", "title-exact" => "true")
+        def files(params = {})
+          url = concat_url(
+              "https://docs.google.com/feeds/default/private/full?v=3", "?" + encode_query(params))
+          doc = request(:get, url, :auth => :writely)
+          return doc.css("feed > entry").map(){ |e| entry_element_to_file(e) }
+        end
+        
+        # Returns GoogleDrive::File or its subclass whose title exactly matches +title+.
+        # Returns nil if not found. If multiple files with the +title+ are found, returns
+        # one of them.
+        def file_by_title(title)
+          return files("title" => title, "title-exact" => "true")[0]
+        end
+
+        # Returns list of spreadsheets for the user as array of GoogleDrive::Spreadsheet.
+        # You can specify query parameters described at
+        # http://code.google.com/apis/spreadsheets/docs/2.0/reference.html#Parameters
+        #
+        # e.g.
+        #   session.spreadsheets
+        #   session.spreadsheets("title" => "hoge")
+        def spreadsheets(params = {})
+          query = encode_query(params)
+          doc = request(
+              :get, "https://spreadsheets.google.com/feeds/spreadsheets/private/full?#{query}")
+          result = []
+          doc.css("feed > entry").each() do |entry|
+            title = entry.css("title").text
+            url = entry.css(
+              "link[rel='http://schemas.google.com/spreadsheets/2006#worksheetsfeed']")[0]["href"]
+            result.push(Spreadsheet.new(self, url, title))
+          end
+          return result
+        end
+
+        # Returns GoogleDrive::Spreadsheet with given +key+.
+        #
+        # e.g.
+        #   # http://spreadsheets.google.com/ccc?key=pz7XtlQC-PYx-jrVMJErTcg&hl=ja
+        #   session.spreadsheet_by_key("pz7XtlQC-PYx-jrVMJErTcg")
+        def spreadsheet_by_key(key)
+          url = "https://spreadsheets.google.com/feeds/worksheets/#{key}/private/full"
+          return Spreadsheet.new(self, url)
+        end
+
+        # Returns GoogleDrive::Spreadsheet with given +url+. You must specify either of:
+        # - URL of the page you open to access the spreadsheet in your browser
+        # - URL of worksheet-based feed of the spreadseet
+        #
+        # e.g.
+        #   session.spreadsheet_by_url(
+        #     "https://docs.google.com/spreadsheet/ccc?key=pz7XtlQC-PYx-jrVMJErTcg")
+        #   session.spreadsheet_by_url(
+        #     "https://spreadsheets.google.com/feeds/" +
+        #     "worksheets/pz7XtlQC-PYx-jrVMJErTcg/private/full")
+        def spreadsheet_by_url(url)
+          # Tries to parse it as URL of human-readable spreadsheet.
+          uri = URI.parse(url)
+          if ["spreadsheets.google.com", "docs.google.com"].include?(uri.host) &&
+              uri.path =~ /\/ccc$/
+            if (uri.query || "").split(/&/).find(){ |s| s=~ /^key=(.*)$/ }
+              return spreadsheet_by_key($1)
+            end
+          end
+          # Assumes the URL is worksheets feed URL.
+          return Spreadsheet.new(self, url)
+        end
+
+        # Returns GoogleDrive::Spreadsheet with given +title+.
+        # Returns nil if not found. If multiple spreadsheets with the +title+ are found, returns
+        # one of them.
+        def spreadsheet_by_title(title)
+          return spreadsheets({"title" => title})[0]
+        end
+        
+        # Returns GoogleDrive::Worksheet with given +url+.
+        # You must specify URL of cell-based feed of the worksheet.
+        #
+        # e.g.
+        #   session.worksheet_by_url(
+        #     "http://spreadsheets.google.com/feeds/" +
+        #     "cells/pz7XtlQC-PYxNmbBVgyiNWg/od6/private/full")
+        def worksheet_by_url(url)
+          return Worksheet.new(self, nil, url)
+        end
+
+        # Returns GoogleDrive::Collection with given +url+.
+        # You must specify either of:
+        # - URL of the page you get when you go to https://docs.google.com/ with your browser and
+        #   open a collection
+        # - URL of collection (folder) feed
+        #
+        # e.g.
+        #   session.collection_by_url(
+        #     "https://drive.google.com/#folders/" +
+        #     "0B9GfDpQ2pBVUODNmOGE0NjIzMWU3ZC00NmUyLTk5NzEtYaFkZjY1MjAyxjMc")
+        #   session.collection_by_url(
+        #     "http://docs.google.com/feeds/default/private/full/folder%3A" +
+        #     "0B9GfDpQ2pBVUODNmOGE0NjIzMWU3ZC00NmUyLTk5NzEtYaFkZjY1MjAyxjMc")
+        def collection_by_url(url)
+          uri = URI.parse(url)
+          if ["docs.google.com", "drive.google.com"].include?(uri.host) &&
+              uri.fragment =~ /^folders\/(.+)$/
+            # Looks like a URL of human-readable collection page. Converts to collection feed URL.
+            url = "https://docs.google.com/feeds/default/private/full/folder%3A#{$1}"
+          end
+          return Collection.new(self, url)
+        end
+
+        # Creates new spreadsheet and returns the new GoogleDrive::Spreadsheet.
+        #
+        # e.g.
+        #   session.create_spreadsheet("My new sheet")
+        def create_spreadsheet(
+            title = "Untitled",
+            feed_url = "https://docs.google.com/feeds/documents/private/full")
+          
+          xml = <<-"EOS"
+            <atom:entry
+                xmlns:atom="http://www.w3.org/2005/Atom"
+                xmlns:docs="http://schemas.google.com/docs/2007">
+              <atom:category
+                  scheme="http://schemas.google.com/g/2005#kind"
+                  term="http://schemas.google.com/docs/2007#spreadsheet"
+                  label="spreadsheet"/>
+              <atom:title>#{h(title)}</atom:title>
+            </atom:entry>
+          EOS
+
+          doc = request(:post, feed_url, :data => xml, :auth => :writely)
+          ss_url = doc.css(
+            "link[rel='http://schemas.google.com/spreadsheets/2006#worksheetsfeed']")[0]["href"]
+          return Spreadsheet.new(self, ss_url, title)
+          
+        end
+        
+        # Uploads a file with the given +title+ and +content+.
+        # Returns a GoogleSpreadsheet::File object.
+        #
+        # e.g.
+        #   # Uploads and converts to a Google Docs document:
+        #   session.upload_from_string(
+        #       "Hello world.", "Hello", :content_type => "text/plain")
+        #   
+        #   # Uploads without conversion:
+        #   session.upload_from_string(
+        #       "Hello world.", "Hello", :content_type => "text/plain", :convert => false)
+        def upload_from_string(content, title = "Untitled", params = {})
+          return upload_from_io(StringIO.new(content), title, params)
+        end
+        
+        # Uploads a local file.
+        # Returns a GoogleSpreadsheet::File object.
+        #
+        # e.g.
+        #   # Uploads and converts to a Google Docs document:
+        #   session.upload_from_file("/path/to/hoge.txt")
+        #   
+        #   # Uploads without conversion:
+        #   session.upload_from_file("/path/to/hoge.txt", "Hoge", :convert => false)
+        #   
+        #   # Uploads with explicit content type:
+        #   session.upload_from_file("/path/to/hoge", "Hoge", :content_type => "text/plain")
+        def upload_from_file(path, title = nil, params = {})
+          file_name = ::File.basename(path)
+          params = {:file_name => file_name}.merge(params)
+          open(path, "rb") do |f|
+            return upload_from_io(f, title || file_name, params)
+          end
+        end
+        
+        # Uploads a file. Reads content from +io+.
+        # Returns a GoogleSpreadsheet::File object.
+        def upload_from_io(io, title = "Untitled", params = {})
+          doc = request(:get, "https://docs.google.com/feeds/default/private/full?v=3",
+              :auth => :writely)
+          initial_url = doc.css(
+              "link[rel='http://schemas.google.com/g/2005#resumable-create-media']")[0]["href"]
+          return upload_raw(:post, initial_url, io, title, params)
+        end
+
+        def upload_raw(method, url, io, title = "Untitled", params = {}) #:nodoc:
+          
+          params = {:convert => true}.merge(params)
+          pos = io.pos
+          io.seek(0, IO::SEEK_END)
+          total_bytes = io.pos - pos
+          io.pos = pos
+          content_type = params[:content_type]
+          if !content_type && params[:file_name]
+            content_type = EXT_TO_CONTENT_TYPE[::File.extname(params[:file_name]).downcase]
+          end
+          if !content_type
+            content_type = "application/octet-stream"
+          end
+          
+          initial_xml = <<-"EOS"
+            <entry xmlns="http://www.w3.org/2005/Atom" 
+                xmlns:docs="http://schemas.google.com/docs/2007">
+              <title>#{h(title)}</title>
+            </entry>
+          EOS
+          
+          default_initial_header = {
+              "Content-Type" => "application/atom+xml",
+              "X-Upload-Content-Type" => content_type,
+              "X-Upload-Content-Length" => total_bytes.to_s(),
+          }
+          initial_full_url = concat_url(url, params[:convert] ? "?convert=true" : "?convert=false")
+          initial_response = request(method, initial_full_url,
+              :header => default_initial_header.merge(params[:header] || {}),
+              :data => initial_xml,
+              :auth => :writely,
+              :response_type => :response)
+          upload_url = initial_response["location"]
+          
+          sent_bytes = 0
+          while data = io.read(UPLOAD_CHUNK_SIZE)
+            content_range = "bytes %d-%d/%d" % [
+                sent_bytes,
+                sent_bytes + data.bytesize - 1,
+                total_bytes,
+            ]
+            upload_header = {
+                "Content-Type" => content_type,
+                "Content-Range" => content_range,
+            }
+            doc = request(
+                :put, upload_url, :header => upload_header, :data => data, :auth => :writely)
+            sent_bytes += data.bytesize
+          end
+          
+          return entry_element_to_file(doc.root)
+          
+        end
+        
+        def entry_element_to_file(entry) #:nodoc:
+          title = entry.css("title").text
+          worksheets_feed_link = entry.css(
+            "link[rel='http://schemas.google.com/spreadsheets/2006#worksheetsfeed']")[0]
+          if worksheets_feed_link
+            return Spreadsheet.new(self, worksheets_feed_link["href"], title)
+          else
+            return GoogleDrive::File.new(self, entry)
+          end
+        end
+
+        def request(method, url, params = {}) #:nodoc:
+          
+          # Always uses HTTPS.
+          url = url.gsub(%r{^http://}, "https://")
+          data = params[:data]
+          auth = params[:auth] || :wise
+          if params[:header]
+            extra_header = params[:header]
+          elsif data
+            extra_header = {"Content-Type" => "application/atom+xml"}
+          else
+            extra_header = {}
+          end
+          response_type = params[:response_type] || :xml
+
+          while true
+            response = @fetcher.request_raw(method, url, data, extra_header, auth)
+            if response.code == "401" && @on_auth_fail && @on_auth_fail.call()
+              next
+            end
+            if !(response.code =~ /^[23]/)
+              raise(
+                response.code == "401" ? AuthenticationError : GoogleDrive::Error,
+                "Response code #{response.code} for #{method} #{url}: " +
+                CGI.unescapeHTML(response.body))
+            end
+            return convert_response(response, response_type)
+          end
+          
+        end
+        
+        def inspect
+          return "#<%p:0x%x>" % [self.class, self.object_id]
+        end
+
+      private
+
+        def convert_response(response, response_type)
+          case response_type
+            when :xml
+              return Nokogiri.XML(response.body)
+            when :raw
+              return response.body
+            when :response
+              return response
+            else
+              raise(GoogleDrive::Error,
+                  "Unknown params[:response_type]: %s" % response_type)
+          end
+        end
+
+        def authenticate(mail, password, auth)
+          params = {
+            "accountType" => "HOSTED_OR_GOOGLE",
+            "Email" => mail,
+            "Passwd" => password,
+            "service" => auth.to_s(),
+            "source" => "Gimite-RubyGoogleDrive-1.00",
+          }
+          header = {"Content-Type" => "application/x-www-form-urlencoded"}
+          response = request(:post,
+            "https://www.google.com/accounts/ClientLogin",
+            :data => encode_query(params),
+            :auth => :none,
+            :header => header,
+            :response_type => :raw)
+          return response.slice(/^Auth=(.*)$/, 1)
+        end
+
+    end
+
+end