parallel588_google_drive 0.3.3

data/README.rdoc

@@ -0,0 +1,91 @@
+This is a Ruby 1.8/1.9 library to read/write files/spreadsheets in Google Drive/Docs.
+
+NOTE: This is NOT a library to create Google Drive App.
+
+
+= How to install
+
+  $ sudo gem install google_drive
+
+
+= How to use
+
+Example to read/write files in Google Drive:
+
+  require "rubygems"
+  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")
+  
+  # Gets list of remote files.
+  for file in session.files
+    p file.title
+  end
+  
+  # Uploads a local file.
+  session.upload_from_file("/path/to/hello.txt", "hello.txt", :convert => false)
+  
+  # Downloads to a local file.
+  file = session.file_by_title("hello.txt")
+  file.download_to_file("/path/to/hello.txt")
+  
+  # Updates content of the remote file.
+  file.update_from_file("/path/to/hello.txt")
+
+Example to read/write spreadsheets:
+  
+  require "rubygems"
+  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")
+  
+  # First worksheet of
+  # https://docs.google.com/spreadsheet/ccc?key=pz7XtlQC-PYx-jrVMJErTcg
+  ws = session.spreadsheet_by_key("pz7XtlQC-PYx-jrVMJErTcg").worksheets[0]
+  
+  # Gets content of A2 cell.
+  p ws[2, 1]  #==> "hoge"
+  
+  # Changes content of cells.
+  # Changes are not sent to the server until you call ws.save().
+  ws[2, 1] = "foo"
+  ws[2, 2] = "bar"
+  ws.save()
+  
+  # Dumps all cells.
+  for row in 1..ws.num_rows
+    for col in 1..ws.num_cols
+      p ws[row, col]
+    end
+  end
+  
+  # Yet another way to do so.
+  p ws.rows  #==> [["fuga", ""], ["foo", "bar]]
+  
+  # Reloads the worksheet to get changes by other clients.
+  ws.reload()
+
+API document: http://gimite.net/doc/google-drive-ruby/
+
+
+= Source code
+
+http://github.com/gimite/google-drive-ruby
+
+The license of this source is "New BSD Licence"
+
+
+= Supported environments
+
+Ruby 1.8.x and Ruby 1.9.x. Checked with Ruby 1.8.7 and Ruby 1.9.3.
+
+
+= Author
+
+Hiroshi Ichikawa - http://gimite.net/en/index.php?Contact

data/doc_src/google_drive/acl.rb

@@ -0,0 +1,20 @@
+module GoogleDrive
+    
+    class Acl
+        
+        # Returns the number of entries.
+        def size
+        end
+        
+        # Returns GoogleDrive::AclEntry object at +index+.
+        def [](index)
+        end
+        
+        # Iterates over GoogleDrive::AclEntry objects.
+        def each(&block)
+          yield(entry)
+        end
+        
+    end
+    
+end

data/doc_src/google_drive/acl_entry.rb

@@ -0,0 +1,33 @@
+module GoogleDrive
+    
+    class AclEntry
+        
+        # Type of the scope. One of:
+        #
+        # - "user": scope is a user's email address.
+        # - "group": scope is a Google Group email address.
+        # - "domain": scope is a Google Apps domain.
+        # - "default": Publicly shared with all users. scope is +nil+.
+        attr_reader(:scope_type)
+        
+        # The scope. See scope_type.
+        attr_reader(:scope)
+        
+        # The role given to the scope. One of:
+        # - "owner": The owner.
+        # - "writer": With read/write access.
+        # - "reader": With read-only access.
+        attr_reader(:role)
+        
+        # Title of the entry.
+        attr_reader(:title)
+        
+        # Edit URL of the entry.
+        attr_reader(:edit_url)
+        
+        # E-tag of the entry.
+        attr_reader(:etag)
+        
+    end
+    
+end

data/lib/google_drive/acl.rb

@@ -0,0 +1,115 @@
+# Author: Guy Boertje <https://github.com/guyboertje>
+# Author: David R. Albrecht <https://github.com/eldavido>
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "google_drive/acl_entry"
+
+module GoogleDrive
+
+    # ACL (access control list) of a spreadsheet.
+    #
+    # Use GoogleDrive::Spreadsheet#acl to get GoogleDrive::Acl object.
+    # See GoogleDrive::Spreadsheet#acl for usage example.
+    #
+    # This code is based on https://github.com/guyboertje/gdata-spreadsheet-ruby .
+    class Acl
+
+        include(Util)
+        extend(Forwardable)
+
+        def initialize(session, acls_feed_url) #: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)) }
+        end
+
+        def_delegators(:@acls, :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
+        # GoogleDrive::AclEntry#role for the document of the fields.
+        #
+        # NOTE: This sends email to the new people.
+        #
+        # e.g.
+        #   # A specific user can read or write.
+        #   spreadsheet.acl.push(
+        #       {:scope_type => "user", :scope => "example2@gmail.com", :role => "reader"})
+        #   spreadsheet.acl.push(
+        #       {:scope_type => "user", :scope => "example3@gmail.com", :role => "writer"})
+        #   # Publish on the Web.
+        #   spreadsheet.acl.push(
+        #       {:scope_type => "default", :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"}
+          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
+
+        end
+
+        # Deletes an ACL entry.
+        #
+        # e.g.
+        #   spreadsheet.acl.delete(spreadsheet.acl[1])
+        def delete(entry)
+          header = {"GData-Version" => "3.0"}
+          @session.request(:delete, entry.edit_url, :header => header, :auth => :writely)
+          @acls.delete(entry)
+        end
+
+        def update_role(entry, role) #:nodoc:
+
+          header = {"GData-Version" => "3.0", "Content-Type" => "application/atom+xml"}
+          doc = @session.request(
+              :put, entry.edit_url, :data => entry.to_xml(), :header => header, :auth => :writely)
+
+          entry.params = entry_to_params(doc.root)
+          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"],
+          }
+          
+        end
+
+    end
+
+end

data/lib/google_drive/acl_entry.rb

@@ -0,0 +1,89 @@
+# Author: Guy Boertje <https://github.com/guyboertje>
+# Author: David R. Albrecht <https://github.com/eldavido>
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# Author: Phuogn Nguyen <https://github.com/phuongnd08>
+# The license of this source is "New BSD Licence"
+
+module GoogleDrive
+
+    # An entry of an ACL (access control list) of a spreadsheet.
+    #
+    # Use GoogleDrive::Acl#[] to get GoogleDrive::AclEntry object.
+    #
+    # This code is based on https://github.com/guyboertje/gdata-spreadsheet-ruby .
+    class AclEntry
+
+        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
+          end
+        end
+
+        attr_accessor(:params)  #:nodoc:
+
+        PARAM_NAMES.each() do |name|
+          define_method(name) do
+            return @params[name]
+          end
+        end
+
+        # Changes the role of the scope.
+        #
+        # e.g.
+        #   spreadsheet.acl[1].role = "writer"
+        def role=(role)
+          @params[:acl].update_role(self, role)
+        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]]
+        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
+          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
+          
+        end
+
+    end
+
+end
+

data/lib/google_drive/authentication_error.rb

@@ -0,0 +1,14 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "google_drive/error"
+
+
+module GoogleDrive
+
+    # Raised when GoogleDrive.login has failed.
+    class AuthenticationError < GoogleDrive::Error
+
+    end
+    
+end

data/lib/google_drive/client_login_fetcher.rb

@@ -0,0 +1,56 @@
+# 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 ClientLoginFetcher #:nodoc:
+        
+        def initialize(auth_tokens, proxy)
+          @auth_tokens = auth_tokens
+          if proxy
+            @proxy = proxy
+          elsif ENV["http_proxy"] && !ENV["http_proxy"].empty?
+            proxy_url = URI.parse(ENV["http_proxy"])
+            @proxy = Net::HTTP.Proxy(proxy_url.host, proxy_url.port)
+          else
+            @proxy = Net::HTTP
+          end
+        end
+        
+        attr_accessor(:auth_tokens)
+        
+        def request_raw(method, url, data, extra_header, auth)
+          uri = URI.parse(url)
+          http = @proxy.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          http.start() do
+            path = uri.path + (uri.query ? "?#{uri.query}" : "")
+            header = auth_header(auth).merge(extra_header)
+            if method == :delete || method == :get
+              return http.__send__(method, path, header)
+            else
+              return http.__send__(method, path, data, header)
+            end
+          end
+        end
+        
+      private
+        
+        def auth_header(auth)
+          token = auth == :none ? nil : @auth_tokens[auth]
+          if token
+            return {"Authorization" => "GoogleLogin auth=#{token}"}
+          else
+            return {}
+          end
+        end
+
+    end
+    
+end

data/lib/google_drive/collection.rb

@@ -0,0 +1,139 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "google_drive/util"
+require "google_drive/error"
+require "google_drive/spreadsheet"
+
+
+module GoogleDrive
+
+    # Use GoogleDrive::Session#root_collection, GoogleDrive::Collection#subcollections,
+    # or GoogleDrive::Session#collection_by_url to get GoogleDrive::Collection object.
+    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.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"}
+          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)
+          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"}
+          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)
+        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" => "*"})
+        end
+
+        # Returns true if this is a root collection
+        def root?
+          self.document_feed_url == ROOT_URL
+        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
+        #
+        # 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)
+        end
+
+        alias contents files
+
+        # Returns all the spreadsheets in the collection.
+        def spreadsheets(params = {})
+          return files_with_type("spreadsheet", params)
+        end
+        
+        # Returns all the Google Docs documents in the collection.
+        def documents(params = {})
+          return files_with_type("document", params)
+        end
+        
+        # Returns all its subcollections.
+        def subcollections(params = {})
+          return files_with_type("folder", params)
+        end
+        
+        # Returns its subcollection whose title exactly matches +title+ as GoogleDrive::Collection.
+        # Returns nil if not found. If multiple collections with the +title+ are found, returns
+        # one of them.
+        def subcollection_by_title(title)
+          return subcollections("title" => title, "title-exact" => "true")[0]
+        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"}
+          doc = @session.request(:get, contents_url, :header => header, :auth => :writely)
+          return doc.css("feed > entry").map(){ |e| @session.entry_element_to_file(e) }
+        end
+        
+    end
+    
+end

data/lib/google_drive/error.rb

@@ -0,0 +1,12 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+
+module GoogleDrive
+
+    # Raised when spreadsheets.google.com has returned error.
+    class Error < RuntimeError
+
+    end
+    
+end