parallel588_google_drive 0.3.3

data/lib/google_drive/file.rb

@@ -0,0 +1,251 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "cgi"
+require "stringio"
+
+require "google_drive/util"
+require "google_drive/acl"
+
+
+module GoogleDrive
+    
+    # A file in Google Drive, including Google Docs document/spreadsheet/presentation.
+    #
+    # Use GoogleDrive::Session#files or GoogleDrive::Session#file_by_title to
+    # get this object.
+    class File
+
+        include(Util)
+        
+        def initialize(session, entry_or_url) #:nodoc:
+          @session = session
+          if !entry_or_url
+            # TODO Delete this after editing spreadsheet.rb.
+            @document_feed_entry = nil
+            @document_feed_url = entry_or_url
+          elsif entry_or_url.is_a?(String)
+            @document_feed_entry = nil
+            @document_feed_url = entry_or_url
+          else
+            @document_feed_entry = entry_or_url
+            # This is usually equal to the URL in <link rel="self">. But the URL in
+            # <link rel="self"> in collection feed is e.g.
+            # https://docs.google.com/feeds/default/private/full/folder%3Aroot/contents/folder%3Axxx
+            # and deletion of the URL doesn't delete the file itself.
+            # So we construct the URL here using resource ID instead.
+            @document_feed_url = "%s/%s?v=3" % [DOCS_BASE_URL, CGI.escape(self.resource_id)]
+          end
+          @acl = nil
+        end
+        
+        # URL of feed used in document list feed API.
+        attr_reader(:document_feed_url)
+        
+        # <entry> element of document list feed as Nokogiri::XML::Element.
+        #
+        # Set <tt>params[:reload]</tt> to true to force reloading the feed.
+        def document_feed_entry(params = {})
+          if !@document_feed_entry || params[:reload]
+            @document_feed_entry =
+                @session.request(:get, self.document_feed_url, :auth => :writely).css("entry")[0]
+          end
+          return @document_feed_entry
+        end
+
+        # Resource ID.
+        def resource_id
+          return self.document_feed_entry.css("gd|resourceId").text
+        end
+
+        # The type of resourse. e.g. "document", "spreadsheet", "folder"
+        def resource_type
+          return self.resource_id.split(/:/)[0]
+        end
+
+        # Title of the file.
+        #
+        # Set <tt>params[:reload]</tt> to true to force reloading the title.
+        def title(params = {})
+          return document_feed_entry(params).css("title").text
+        end
+        
+        # URL to view/edit the file in a Web browser.
+        #
+        # e.g. "https://docs.google.com/file/d/xxxx/edit"
+        def human_url
+          return self.document_feed_entry.css("link[rel='alternate']")[0]["href"]
+        end
+        
+        # ACL feed URL of the file.
+        def acl_feed_url
+          orig_acl_feed_url = self.document_feed_entry.css(
+              "gd|feedLink[rel='http://schemas.google.com/acl/2007#accessControlList']")[0]["href"]
+          case orig_acl_feed_url
+            when %r{^https?://docs.google.com/feeds/default/private/full/.*/acl(\?.*)?$}
+              return orig_acl_feed_url
+            when %r{^https?://docs.google.com/feeds/acl/private/full/([^\?]*)(\?.*)?$}
+              # URL of old API version. Converts to v3 URL.
+              return "#{DOCS_BASE_URL}/#{$1}/acl"
+            else
+              raise(GoogleDrive::Error,
+                "ACL feed URL is in unknown format: #{orig_acl_feed_url}")
+          end
+        end
+
+        # Content types you can specify in methods download_to_file, download_to_string,
+        # download_to_io .
+        def available_content_types
+          return self.document_feed_entry.css("content").map(){ |c| c["type"] }
+        end
+        
+        # Downloads the file to a local file.
+        #
+        # e.g.
+        #   file.download_to_file("/path/to/hoge.txt")
+        #   file.download_to_file("/path/to/hoge", :content_type => "text/plain")
+        def download_to_file(path, params = {})
+          params = params.dup()
+          if !params[:content_type]
+            params[:content_type] = EXT_TO_CONTENT_TYPE[::File.extname(path).downcase]
+            params[:content_type_is_hint] = true
+          end
+          open(path, "wb") do |f|
+            download_to_io(f, params)
+          end
+        end
+        
+        # Downloads the file and returns as a String.
+        #
+        # e.g.
+        #   file.download_to_string()                               #=> "Hello world."
+        #   file.download_to_string(:content_type => "text/plain")  #=> "Hello world."
+        def download_to_string(params = {})
+          sio = StringIO.new()
+          download_to_io(sio, params)
+          return sio.string
+        end
+        
+        # Downloads the file and writes it to +io+.
+        def download_to_io(io, params = {})
+          all_contents = self.document_feed_entry.css("content")
+          if params[:content_type] && (!params[:content_type_is_hint] || all_contents.size > 1)
+            contents = all_contents.select(){ |c| c["type"] == params[:content_type] }
+          else
+            contents = all_contents
+          end
+          if contents.size == 1
+            url = contents[0]["src"]
+          else
+            if contents.empty?
+              raise(GoogleDrive::Error,
+                  ("Downloading with content type %p not supported for this file. " +
+                   "Specify one of these to content_type: %p") %
+                  [params[:content_type], self.available_content_types])
+            else
+              raise(GoogleDrive::Error,
+                  ("Multiple content types are available for this file. " +
+                   "Specify one of these to content_type: %p") %
+                  [self.available_content_types])
+            end
+          end
+          # TODO Use streaming if possible.
+          body = @session.request(:get, url, :response_type => :raw, :auth => :writely)
+          io.write(body)
+        end
+        
+        # Updates the file with the content of the local file.
+        #
+        # e.g.
+        #   file.update_from_file("/path/to/hoge.txt")
+        def update_from_file(path, params = {})
+          params = {:file_name => ::File.basename(path)}.merge(params)
+          open(path, "rb") do |f|
+            update_from_io(f, params)
+          end
+        end
+        
+        # Updates the file with +content+.
+        #
+        # e.g.
+        #   file.update_from_string("Good bye, world.")
+        def update_from_string(content, params = {})
+          update_from_io(StringIO.new(content), params)
+        end
+        
+        # Reads content from +io+ and updates the file with the content.
+        def update_from_io(io, params = {})
+          params = {:header => {"If-Match" => "*"}}.merge(params)
+          initial_url = self.document_feed_entry.css(
+              "link[rel='http://schemas.google.com/g/2005#resumable-edit-media']")[0]["href"]
+          @document_feed_entry = @session.upload_raw(
+              :put, initial_url, io, self.title, params)
+        end
+        
+        # If +permanent+ is +false+, moves the file to the trash.
+        # If +permanent+ is +true+, deletes the file permanently.
+        def delete(permanent = false)
+          url = to_v3_url(self.document_feed_url)
+          url = concat_url(url, "?delete=true") if permanent
+          @session.request(:delete, url,
+            :auth => :writely, :header => {"If-Match" => "*"})
+        end
+
+        # Renames title of the file.
+        def rename(title)
+          edit_url = self.document_feed_entry.css("link[rel='edit']").first["href"]
+          xml = <<-"EOS"
+            <atom:entry
+                xmlns:atom="http://www.w3.org/2005/Atom"
+                xmlns:docs="http://schemas.google.com/docs/2007">
+              <atom:title>#{h(title)}</atom:title>
+            </atom:entry>
+          EOS
+          header = {"Content-Type" => "application/atom+xml", "If-Match" => "*"}
+          @session.request(:put, edit_url, :data => xml, :auth => :writely, :header => header)
+        end
+        
+        alias title= rename
+        
+        # Returns GoogleDrive::Acl object for the file.
+        #
+        # With the object, you can see and modify people who can access the file.
+        # Modifications take effect immediately.
+        #
+        # Set <tt>params[:reload]</tt> to true to force reloading the data.
+        #
+        # e.g.
+        #   # Dumps people who have access:
+        #   for entry in file.acl
+        #     p [entry.scope_type, entry.scope, entry.role]
+        #     # => e.g. ["user", "example1@gmail.com", "owner"]
+        #   end
+        #   
+        #   # Shares the file with new people:
+        #   # NOTE: This sends email to the new people.
+        #   file.acl.push(
+        #       {:scope_type => "user", :scope => "example2@gmail.com", :role => "reader"})
+        #   file.acl.push(
+        #       {:scope_type => "user", :scope => "example3@gmail.com", :role => "writer"})
+        #   
+        #   # Changes the role of a person:
+        #   file.acl[1].role = "writer"
+        #   
+        #   # Deletes an ACL entry:
+        #   file.acl.delete(file.acl[1])
+        def acl(params = {})
+          if !@acl || params[:reload]
+            @acl = Acl.new(@session, self.acl_feed_url)
+          end
+          return @acl
+        end
+
+        def inspect
+          fields = {:document_feed_url => self.document_feed_url}
+          fields[:title] = self.title if @document_feed_entry
+          return "\#<%p %s>" % [self.class, fields.map(){ |k, v| "%s=%p" % [k, v] }.join(", ")]
+        end
+        
+    end
+    
+end

data/lib/google_drive/list.rb

@@ -0,0 +1,119 @@
+# 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/list_row"
+
+
+module GoogleDrive
+
+    # Provides access to cells using column names.
+    # Use GoogleDrive::Worksheet#list to get GoogleDrive::List object.
+    #--
+    # This is implemented as wrapper of GoogleDrive::Worksheet i.e. using cells
+    # feed, not list feed. In this way, we can easily provide consistent API as
+    # GoogleDrive::Worksheet using save()/reload().
+    class List
+        
+        include(Enumerable)
+        
+        def initialize(worksheet) #:nodoc:
+          @worksheet = worksheet
+        end
+        
+        # Number of non-empty rows in the worksheet excluding the first row.
+        def size
+          return @worksheet.num_rows - 1
+        end
+        
+        # Returns Hash-like object (GoogleDrive::ListRow) for the row with the
+        # index. Keys of the object are colum names (the first row).
+        # The second row has index 0.
+        #
+        # Note that updates to the returned object are not sent to the server until
+        # you call GoogleDrive::Worksheet#save().
+        def [](index)
+          return ListRow.new(self, index)
+        end
+        
+        # Updates the row with the index with the given Hash object.
+        # Keys of +hash+ are colum names (the first row).
+        # The second row has index 0.
+        #
+        # Note that update is not sent to the server until
+        # you call GoogleDrive::Worksheet#save().
+        def []=(index, hash)
+          self[index].replace(hash)
+        end
+        
+        # Iterates over Hash-like object (GoogleDrive::ListRow) for each row
+        # (except for the first row).
+        # Keys of the object are colum names (the first row).
+        def each(&block)
+          for i in 0...self.size
+            yield(self[i])
+          end
+        end
+        
+        # Column names i.e. the contents of the first row.
+        # Duplicates are removed.
+        def keys
+          return (1..@worksheet.num_cols).map(){ |i| @worksheet[1, i] }.uniq()
+        end
+        
+        # Updates column names i.e. the contents of the first row.
+        #
+        # Note that update is not sent to the server until
+        # you call GoogleDrive::Worksheet#save().
+        def keys=(ary)
+          for i in 1..ary.size
+            @worksheet[1, i] = ary[i - 1]
+          end
+          for i in (ary.size + 1)..@worksheet.num_cols
+            @worksheet[1, i] = ""
+          end
+        end
+        
+        # Adds a new row to the bottom.
+        # Keys of +hash+ are colum names (the first row).
+        # Returns GoogleDrive::ListRow for the new row.
+        #
+        # Note that update is not sent to the server until
+        # you call GoogleDrive::Worksheet#save().
+        def push(hash)
+          row = self[self.size]
+          row.update(hash)
+          return row
+        end
+        
+        # Returns all rows (except for the first row) as Array of Hash.
+        # Keys of Hash objects are colum names (the first row).
+        def to_hash_array()
+          return self.map(){ |r| r.to_hash() }
+        end
+        
+        def get(index, key) #:nodoc:
+          return @worksheet[index + 2, key_to_col(key)]
+        end
+        
+        def numeric_value(index, key) #:nodoc:
+          return @worksheet.numeric_value(index + 2, key_to_col(key))
+        end
+        
+        def set(index, key, value) #:nodoc:
+          @worksheet[index + 2, key_to_col(key)] = value
+        end
+        
+      private
+        
+        def key_to_col(key)
+          key = key.to_s()
+          col = (1..@worksheet.num_cols).find(){ |c| @worksheet[1, c] == key }
+          raise(GoogleDrive::Error, "Column doesn't exist: %p" % key) if !col
+          return col
+        end
+        
+    end
+    
+end

data/lib/google_drive/list_row.rb

@@ -0,0 +1,88 @@
+# 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 numeric_value(key)
+          return @list.numeric_value(@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, {:headers => extra_header})
+          else
+            raw_res = @oauth2_token.request(method, url, {:headers => 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