google_drive 0.3.11 → 1.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA512: 
-  metadata.gz: aacfb80c76656613c5a1735977c6e39796a1df82a5a8a97944381c289362eaefdfee229b1c586f94378f46a8357caec0030f00b7a032404e27f2f93f69934137
-  data.tar.gz: d8f9abf36d3406863e85520041adc04b5a1c9e64b344331982ed89ae6d2296d27d54fc13bb000bdf1ca0dce497f5f0a740ea40441ee18d2100c4cc6fdf4e724c
-SHA1: 
-  metadata.gz: cc0c279d89eeff98e5a5a85f82287db36343402d
-  data.tar.gz: 9cb3dff31f112e16654f61bef9049b938487e33c
+---
+SHA1:
+  metadata.gz: 76b903fb2d84303774103ab6da528579367ce8a5
+  data.tar.gz: 04f591af34df950ba24d46a0ba0f6e099447f291
+SHA512:
+  metadata.gz: e5253faaa7c32a502d296354cc1aa1728c79136d009f45fb05801c21b490b4f6ec81c6995d3486c5742b9ecf96f7408ced12d08b3b46d2c9a729ba1d3379a148
+  data.tar.gz: f52470706946884dd09e400b8fff2bd22af076947083910f58b92177566a80c96c8a9c833307c6f4ce9bc181ed7f6fa69723eff4a4e23faa31c0c91dd91a9c60

data/README.rdoc

@@ -1,4 +1,4 @@
-This is a Ruby 1.9/2.0 library to read/write files/spreadsheets in Google Drive/Docs.
+This is a Ruby 1.8/1.9/2.0 library to read/write files/spreadsheets in Google Drive/Docs.
 
 NOTE: This is NOT a library to create Google Drive App.
 
@@ -10,15 +10,31 @@ NOTE: This is NOT a library to create Google Drive App.
 
 = How to use
 
+First, follow "Create a client ID and client secret" in {this page}[https://developers.google.com/drive/web/auth/web-server] to get a client ID and client secret for OAuth.
+
 Example to read/write files in Google Drive:
 
   require "rubygems"
+  require "google/api_client"
   require "google_drive"
-  
-  # Logs in.
-  # You can also use OAuth. See document of
-  # GoogleDrive.login_with_oauth for details.
-  session = GoogleDrive.login("username@gmail.com", "mypassword")
+
+  # Authorizes with OAuth and gets an access token.
+  client = Google::APIClient.new
+  auth = client.authorization
+  auth.client_id = "YOUR CLIENT ID"
+  auth.client_secret = "YOUR CLIENT SECRET"
+  auth.scope =
+      "https://www.googleapis.com/auth/drive " +
+      "https://spreadsheets.google.com/feeds/"
+  auth.redirect_uri = "urn:ietf:wg:oauth:2.0:oob"
+  print("1. Open this page:\n%s\n\n" % auth.authorization_uri)
+  print("2. Enter the authorization code shown in the page: ")
+  auth.code = $stdin.gets.chomp
+  auth.fetch_access_token!
+  access_token = auth.access_token
+
+  # Creates a session.
+  session = GoogleDrive.login_with_oauth(access_token)
   
   # Gets list of remote files.
   for file in session.files
@@ -38,12 +54,13 @@ Example to read/write files in Google Drive:
 Example to read/write spreadsheets:
   
   require "rubygems"
+  require "google/api_client"
   require "google_drive"
+
+  # Same as the code above to get access_token...
   
-  # Logs in.
-  # You can also use OAuth. See document of
-  # GoogleDrive.login_with_oauth for details.
-  session = GoogleDrive.login("username@gmail.com", "mypassword")
+  # Creates a session.
+  session = GoogleDrive.login(access_token)
   
   # First worksheet of
   # https://docs.google.com/spreadsheet/ccc?key=pz7XtlQC-PYx-jrVMJErTcg

data/lib/google_drive/acl.rb

@@ -18,15 +18,16 @@ module GoogleDrive
         include(Util)
         extend(Forwardable)
 
-        def initialize(session, acls_feed_url) #:nodoc:
+        def initialize(session, file) #:nodoc:
           @session = session
-          @acls_feed_url = acls_feed_url
-          header = {"GData-Version" => "3.0"}
-          doc = @session.request(:get, @acls_feed_url, :header => header, :auth => :writely)
-          @acls = doc.css("entry").map(){ |e| AclEntry.new(entry_to_params(e)) }
+          @file = file
+          api_result = @session.execute!(
+              :api_method => @session.drive.permissions.list,
+              :parameters => { "fileId" => @file.id })
+          @entries = api_result.data.items.map(){ |i| AclEntry.new(i, self) }
         end
 
-        def_delegators(:@acls, :size, :[], :each)
+        def_delegators(:@entries, :size, :[], :each)
 
         # Adds a new entry. +entry+ is either a GoogleDrive::AclEntry or a Hash with keys
         # :scope_type, :scope and :role. See GoogleDrive::AclEntry#scope_type and
@@ -37,27 +38,28 @@ module GoogleDrive
         # e.g.
         #   # A specific user can read or write.
         #   spreadsheet.acl.push(
-        #       {:scope_type => "user", :scope => "example2@gmail.com", :role => "reader"})
+        #       {:type => "user", :value => "example2@gmail.com", :role => "reader"})
         #   spreadsheet.acl.push(
-        #       {:scope_type => "user", :scope => "example3@gmail.com", :role => "writer"})
+        #       {:type => "user", :value => "example3@gmail.com", :role => "writer"})
         #   # Publish on the Web.
         #   spreadsheet.acl.push(
-        #       {:scope_type => "default", :role => "reader"})
+        #       {:type => "anyone", :role => "reader"})
         #   # Anyone who knows the link can read.
         #   spreadsheet.acl.push(
-        #       {:scope_type => "default", :with_key => true, :role => "reader"})
-        def push(entry)
-
-          entry = AclEntry.new(entry) if entry.is_a?(Hash)
-
-          header = {"GData-Version" => "3.0", "Content-Type" => "application/atom+xml;charset=utf-8"}
-          doc = @session.request(
-              :post, @acls_feed_url, :data => entry.to_xml(), :header => header, :auth => :writely)
-
-          entry.params = entry_to_params(doc.root)
-          @acls.push(entry)
-          return entry
-
+        #       {:type => "anyone", :withLink => true, :role => "reader"})
+        #
+        # See here for parameter detais:
+        # https://developers.google.com/drive/v2/reference/permissions/insert
+        def push(params_or_entry)
+          entry = params_or_entry.is_a?(AclEntry) ? params_or_entry : AclEntry.new(params_or_entry)
+          new_permission = @session.drive.permissions.insert.request_schema.new(entry.params)
+          api_result = @session.execute!(
+              :api_method => @session.drive.permissions.insert,
+              :body_object => new_permission,
+              :parameters => { "fileId" => @file.id })
+          new_entry = AclEntry.new(api_result.data, self)
+          @entries.push(new_entry)
+          return new_entry
         end
 
         # Deletes an ACL entry.
@@ -65,49 +67,29 @@ module GoogleDrive
         # e.g.
         #   spreadsheet.acl.delete(spreadsheet.acl[1])
         def delete(entry)
-          header = {"GData-Version" => "3.0"}
-          @session.request(:delete, entry.edit_url_internal, :header => header, :auth => :writely)
-          @acls.delete(entry)
+          @session.execute!(
+              :api_method => @session.drive.permissions.delete,
+              :parameters => {
+                  "fileId" => @file.id,
+                  "permissionId" => entry.id,
+                })
+          @entries.delete(entry)
         end
 
         def update_role(entry) #:nodoc:
-
-          header = {"GData-Version" => "3.0", "Content-Type" => "application/atom+xml;charset=utf-8"}
-          doc = @session.request(
-              :put, entry.edit_url_internal, :data => entry.to_xml(), :header => header, :auth => :writely)
-
-          entry.params = entry_to_params(doc.root)
+          api_result = @session.execute!(
+              :api_method => @session.drive.permissions.update,
+              :body_object => entry.api_permission,
+              :parameters => {
+                  "fileId" => @file.id,
+                  "permissionId" => entry.id,
+              })
+          entry.api_permission = api_result.data
           return entry
-
         end
 
         def inspect
-          return "\#<%p %p>" % [self.class, @acls]
-        end
-
-      private
-
-        def entry_to_params(entry)
-          
-          if !entry.css("gAcl|withKey").empty?
-            with_key = true
-            role = entry.css("gAcl|withKey gAcl|role")[0]["value"]
-          else
-            with_key = false
-            role = entry.css("gAcl|role")[0]["value"]
-          end
-
-          return {
-            :acl => self,
-            :scope_type => entry.css("gAcl|scope")[0]["type"],
-            :scope => entry.css("gAcl|scope")[0]["value"],
-            :with_key => with_key,
-            :role => role,
-            :title => entry.css("title").text,
-            :edit_url => entry.css("link[rel='edit']")[0]["href"],
-            :etag => entry["etag"],
-          }
-          
+          return "\#<%p %p>" % [self.class, @entries]
         end
 
     end

data/lib/google_drive/acl_entry.rb

@@ -15,83 +15,103 @@ module GoogleDrive
 
         include(Util)
 
-        PARAM_NAMES = [:acl, :scope_type, :scope, :with_key, :role, :title, :edit_url, :etag]  #:nodoc:
-
-        # +params+ is a Hash object with keys +:scope_type+, +:scope+ and +:role+.
-        # See scope_type and role for the document of the fields.
-        def initialize(params)
-          @params = {:role => "reader"}
-          for name, value in params
-            if !name.is_a?(Symbol)
-              raise(ArgumentError, "Key must be Symbol, but is %p" % name)
-            elsif !PARAM_NAMES.include?(name)
-              raise(ArgumentError, "Invalid key: %p" % name)
-            end
-            @params[name] = value
+        # +params_or_api_permission+ is a Hash object with keys +:type+, +:value+, +:role+ and +:withLink+.
+        # See GoogleDrive::Acl#push for description of the parameters.
+        def initialize(params_or_api_permission, acl = nil)
+          @acl = acl
+          if acl
+            @api_permission = params_or_api_permission
+            @params = nil
+            delegate_api_methods(self, @api_permission)
+          else
+            @api_permission = nil
+            @params = convert_params(params_or_api_permission)
           end
         end
 
-        attr_accessor(:params)  #:nodoc:
+        attr_reader(:acl)
+        attr_reader(:params) #:nodoc:
+        attr_accessor(:api_permission) #:nodoc:
 
-        PARAM_NAMES.each() do |name|
-          define_method(name) do
-            return @params[name]
-          end
+        # The role given to the scope. One of:
+        # - "owner": The owner.
+        # - "writer": With read/write access.
+        # - "reader": With read-only access.
+        def role
+          return @params ? @params["role"] : @api_permission.role
+        end
+
+        # Type of the scope. One of:
+        #
+        # - "user": value is a user's email address.
+        # - "group": value is a Google Group email address.
+        # - "domain": value is a Google Apps domain.
+        # - "anyone": Publicly shared with all users. value is +nil+.
+        def type
+          return @params ? @params["type"] : @api_permission.type
+        end
+
+        alias scope_type type
+
+        def additional_roles
+          return @params ? @params["additionalRoles"] : @api_permission.additional_roles
         end
 
-        def edit_url
-          warn(
-              "WARNING: GoogleDrive::AclEntry\#edit_url is deprecated and will be removed in the next version.")
-          return self.edit_url_internal
+        def id
+          return @params ? @params["id"] : @api_permission.id
         end
 
-        def edit_url_internal #:nodoc:
-          return @params[:edit_url]
+        # The value of the scope. See type.
+        def value
+          return @params ? @params["value"] : @api_permission.value
         end
 
+        alias scope value
+
+        # If +true+, the file is shared only with people who know the link.
+        def with_link
+          return @params ? @params["withLink"] : @api_permission.with_link
+        end
+
+        alias with_key with_link
+
         # Changes the role of the scope.
         #
         # e.g.
         #   spreadsheet.acl[1].role = "writer"
         def role=(role)
-          @params[:role] = role
-          @params[:acl].update_role(self)
+          if @params
+            @params["role"] = role
+          else
+            @api_permission.role = role
+            @acl.update_role(self)
+          end
         end
 
         def inspect
-          return "\#<%p scope_type=%p, scope=%p, with_key=%p, role=%p>" %
-              [self.class, @params[:scope_type], @params[:scope], @params[:with_key], @params[:role]]
+          return "\#<%p type=%p, name=%p, role=%p>" %
+              [self.class, self.type, self.name, self.role]
         end
 
-        def to_xml()  #:nodoc:
-          
-          etag_attr = self.etag ? "gd:etag='#{h(self.etag)}'" : ""
-          value_attr = self.scope ? "value='#{h(self.scope)}'" : ""
-          if self.with_key
-            role_tag = <<-EOS
-                <gAcl:withKey key='[ACL KEY]'>
-                  <gAcl:role value='#{h(self.role)}'/>
-                </gAcl:withKey>
-            EOS
-          else
-            role_tag = <<-EOS
-              <gAcl:role value='#{h(self.role)}'/>
-            EOS
+      private
+
+        # Normalizes the key to String, and converts parameters in the old version.
+        def convert_params(orig_params)
+          new_params = {}
+          for k, v in orig_params
+            k = k.to_s()
+            case k
+              when "scope_type"
+                new_params["type"] = (v == "default" ? "anyone" : v)
+              when "scope"
+                new_params["value"] = v
+              when "with_key"
+                new_params["withLink"] = v
+              else
+                new_params[k] = v
+            end
           end
-          
-          return <<-EOS
-            <entry
-                xmlns='http://www.w3.org/2005/Atom'
-                xmlns:gAcl='http://schemas.google.com/acl/2007'
-                xmlns:gd='http://schemas.google.com/g/2005'
-                #{etag_attr}>
-              <category scheme='http://schemas.google.com/g/2005#kind'
-                  term='http://schemas.google.com/acl/2007#accessRule'/>
-              #{role_tag}
-              <gAcl:scope type='#{h(self.scope_type)}' #{value_attr}/>
-            </entry>
-          EOS
-          
+          return new_params
         end
 
     end

data/lib/google_drive/api_client_fetcher.rb

@@ -0,0 +1,49 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "net/https"
+require "uri"
+Net::HTTP.version_1_2
+
+
+module GoogleDrive
+
+    class ApiClientFetcher
+        
+        class Response
+
+            def initialize(client_response)
+              @client_response = client_response
+            end
+
+            def code
+              return @client_response.status.to_s()
+            end
+
+            def body
+              return @client_response.body
+            end
+
+            attr_reader(:client_response)
+
+        end
+
+        def initialize(client)
+          @client = client
+          @drive = @client.discovered_api("drive", "v2")
+        end
+
+        attr_reader(:client, :drive)
+        
+        def request_raw(method, url, data, extra_header, auth)
+          client_response = @client.execute(
+              :http_method => method,
+              :uri => url,
+              :body => data,
+              :headers => extra_header)
+          return Response.new(client_response)
+        end
+        
+    end
+    
+end

data/lib/google_drive/collection.rb

@@ -13,107 +13,97 @@ module GoogleDrive
     class Collection < GoogleDrive::File
 
         include(Util)
-        
-        ROOT_URL = "#{DOCS_BASE_URL}/folder%3Aroot"  #:nodoc:
 
         alias collection_feed_url document_feed_url
         
-        def contents_url
-          if self.root?
-            # The root collection doesn't have document feed.
-            return concat_url(ROOT_URL, "/contents")
-          else
-            return self.document_feed_entry_internal.css(
-                "content[type='application/atom+xml;type=feed']")[0]["src"]
-          end
-        end
-        
-        # Title of the collection.
-        #
-        # Set <tt>params[:reload]</tt> to true to force reloading the title.
-        def title(params = {})
-          if self.root?
-            # The root collection doesn't have document feed.
-            return nil
-          else
-            return super
-          end
-        end
-
-        def resource_id
-          return self.root? ? nil : super
-        end
-        
         # Adds the given GoogleDrive::File to the collection.
         def add(file)
-          header = {"GData-Version" => "3.0", "Content-Type" => "application/atom+xml;charset=utf-8"}
-          xml = <<-"EOS"
-            <entry xmlns="http://www.w3.org/2005/Atom">
-              <id>#{h(file.document_feed_url)}</id>
-            </entry>
-          EOS
-          @session.request(
-              :post, self.contents_url, :data => xml, :header => header, :auth => :writely)
+          new_child = @session.drive.children.insert.request_schema.new({
+              "id" => file.id,
+          })
+          @session.execute!(
+              :api_method => @session.drive.children.insert,
+              :body_object => new_child,
+              :parameters => {
+                  "folderId" => self.id,
+                  "childId" => file.id,
+              })
           return nil
         end
 
         # Creates a sub-collection with given title. Returns GoogleDrive::Collection object.
         def create_subcollection(title)
-          header = {"GData-Version" => "3.0", "Content-Type" => "application/atom+xml;charset=utf-8"}
-          xml = <<-EOS
-            <entry xmlns="http://www.w3.org/2005/Atom">
-              <category scheme="http://schemas.google.com/g/2005#kind"
-                term="http://schemas.google.com/docs/2007#folder"/>
-              <title>#{h(title)}</title>
-            </entry>
-          EOS
-          doc = @session.request(
-              :post, contents_url, :data => xml, :header => header, :auth => :writely)
-          return @session.entry_element_to_file(doc)
+          file = @session.drive.files.insert.request_schema.new({
+              "title" => title,
+              "mimeType" => "application/vnd.google-apps.folder",
+              "parents" => [{"id" => self.id}],
+          })
+          api_result = @session.execute!(
+              :api_method => @session.drive.files.insert,
+              :body_object => file)
+          return @session.wrap_api_file(api_result.data)
         end
 
         # Removes the given GoogleDrive::File from the collection.
         def remove(file)
-          url = to_v3_url("#{contents_url}/#{file.resource_id}")
-          @session.request(:delete, url, :auth => :writely, :header => {"If-Match" => "*"})
+          @session.execute!(
+              :api_method => @session.drive.children.delete,
+              :parameters => {
+                  "folderId" => self.id,
+                  "childId" => file.id,
+              })
+          return nil
         end
 
         # Returns true if this is a root collection
         def root?
-          self.document_feed_url == ROOT_URL
+          return self.api_file.parents.empty?
         end
 
         # Returns all the files (including spreadsheets, documents, subcollections) in the collection.
         #
-        # You can specify query parameters described at
-        # https://developers.google.com/google-apps/documents-list/#getting_a_list_of_documents_and_files
+        # You can specify parameters documented at
+        # https://developers.google.com/drive/v2/reference/files/list
         #
         # e.g.
         #
         #   # Gets all the files in collection, including subcollections.
         #   collection.files
-        #   
         #   # Gets only files with title "hoge".
-        #   collection.files("title" => "hoge", "title-exact" => "true")
-        def files(params = {})
-          return files_with_type(nil, params)
+        #   collection.files("q" => "title = 'hoge'")
+        #   # Same as above with a placeholder.
+        #   collection.files("q" => ["title = ?", "hoge"])
+        #
+        # By default, it returns the first 100 files. See document of GoogleDrive::Session#files method
+        # for how to get all files.
+        def files(params = {}, &block)
+          return files_with_type(nil, params, &block)
         end
 
         alias contents files
 
         # Returns all the spreadsheets in the collection.
-        def spreadsheets(params = {})
-          return files_with_type("spreadsheet", params)
+        #
+        # By default, it returns the first 100 spreadsheets. See document of GoogleDrive::Session#files method
+        # for how to get all spreadsheets.
+        def spreadsheets(params = {}, &block)
+          return files_with_type("application/vnd.google-apps.spreadsheet", params, &block)
         end
         
         # Returns all the Google Docs documents in the collection.
-        def documents(params = {})
-          return files_with_type("document", params)
+        #
+        # By default, it returns the first 100 documents. See document of GoogleDrive::Session#files method
+        # for how to get all documents.
+        def documents(params = {}, &block)
+          return files_with_type("application/vnd.google-apps.document", params, &block)
         end
         
         # Returns all its subcollections.
-        def subcollections(params = {})
-          return files_with_type("folder", params)
+        #
+        # By default, it returns the first 100 subcollections. See document of GoogleDrive::Session#files method
+        # for how to get all subcollections.
+        def subcollections(params = {}, &block)
+          return files_with_type("application/vnd.google-apps.folder", params, &block)
         end
         
         # Returns a file (can be a spreadsheet, document, subcollection or other files) in the
@@ -132,7 +122,12 @@ module GoogleDrive
         #
         # If given an Array, does a recursive subcollection traversal.
         def subcollection_by_title(title)
-          return file_by_title_with_type(title, "folder")
+          return file_by_title_with_type(title, "application/vnd.google-apps.folder")
+        end
+
+        # Returns URL of the deprecated contents feed.
+        def contents_url
+          self.document_feed_url + "/contents"
         end
         
       protected
@@ -147,19 +142,22 @@ module GoogleDrive
               return parent && parent.file_by_title_with_type(rel_path[-1], type)
             end
           else
-            return files_with_type(type, "title" => title, "title-exact" => "true")[0]
+            return files_with_type(type, "q" => ["title = ?", title], "maxResults" => 1)[0]
           end
         end
         
       private
 
-        def files_with_type(type, params = {})
-          contents_url = self.contents_url
-          contents_url = concat_url(contents_url, "/-/#{type}") if type
-          contents_url = concat_url(contents_url, "?" + encode_query(params))
-          header = {"GData-Version" => "3.0", "Content-Type" => "application/atom+xml;charset=utf-8"}
-          doc = @session.request(:get, contents_url, :header => header, :auth => :writely)
-          return doc.css("feed > entry").map(){ |e| @session.entry_element_to_file(e) }
+        def files_with_type(type, params = {}, &block)
+          params = convert_params(params)
+          query = construct_and_query([
+              ["? in parents", self.id],
+              type ? ["mimeType = ?", type] : nil,
+              params["q"],
+          ])
+          params = params.merge({"q" => query})
+          # This is faster than calling children.list and then files.get for each file.
+          return @session.files(params, &block)
         end
         
     end