google_drive2 3.0.8

data/lib/google_drive/collection.rb

@@ -0,0 +1,207 @@
+# 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
+  # Represents a folder in Google Drive.
+  #
+  # 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)
+
+    alias collection_feed_url document_feed_url
+
+    # Adds the given GoogleDrive::File to the folder.
+    def add(file)
+      @session.drive_service.update_file(
+        file.id, add_parents: id, fields: '', supports_all_drives: true
+      )
+      nil
+    end
+
+    # Removes the given GoogleDrive::File from the folder.
+    def remove(file)
+      @session.drive_service.update_file(
+        file.id, remove_parents: id, fields: '', supports_all_drives: true
+      )
+    end
+
+    # Creates a sub-folder with given title in this folder.
+    # Returns GoogleDrive::Collection object.
+    def create_subcollection(title, file_properties = {})
+      create_file(title, file_properties.merge(mime_type: 'application/vnd.google-apps.folder'))
+    end
+
+    alias create_subfolder create_subcollection
+
+    # Creates a spreadsheet with given title in this folder.
+    # Returns GoogleDrive::Spreadsheet object.
+    def create_spreadsheet(title, file_properties = {})
+      create_file(title, file_properties.merge(mime_type: 'application/vnd.google-apps.spreadsheet'))
+    end
+
+    # Creates a file with given title and properties in this folder.
+    # Returns objects with the following types:
+    # GoogleDrive::Spreadsheet, GoogleDrive::File, GoogleDrive::Collection
+    #
+    # You can pass a MIME Type using the file_properties-function parameter,
+    # for example: create_file('Document Title', mime_type: 'application/vnd.google-apps.document')
+    #
+    # A list of available Drive MIME Types can be found here:
+    # https://developers.google.com/drive/v3/web/mime-types
+    def create_file(title, file_properties = {})
+      file_metadata = {
+        name: title,
+        parents: [id]
+      }.merge(file_properties)
+
+      file = @session.drive_service.create_file(
+        file_metadata, fields: '*', supports_all_drives: true
+      )
+
+      @session.wrap_api_file(file)
+    end
+
+    # Returns true if this is a root folder.
+    def root?
+      !api_file.parents || api_file.parents.empty?
+    end
+
+    # Returns all the files (including spreadsheets, documents, subfolders) in
+    # the folder. You can specify parameters documented at
+    # https://developers.google.com/drive/v3/web/search-parameters
+    #
+    # e.g.
+    #
+    #   # Gets all the files in the folder, including subfolders.
+    #   collection.files
+    #
+    #   # Gets only files with title "hoge".
+    #   collection.files(q: "name = 'hoge'")
+    #
+    #   # Same as above with a placeholder.
+    #   collection.files(q: ["name = ?", "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)
+      files_with_type(nil, params, &block)
+    end
+
+    # Uploads a file to this folder. See Session#upload_from_file for details.
+    def upload_from_file(path, title = nil, params = {})
+      params = { parents: [id] }.merge(params)
+      @session.upload_from_file(path, title, params)
+    end
+
+    # Uploads a file to this folder. See Session#upload_from_io for details.
+    def upload_from_io(io, title = 'Untitled', params = {})
+      params = { parents: [id] }.merge(params)
+      @session.upload_from_io(io, title, params)
+    end
+
+    # Uploads a file to this folder. See Session#upload_from_string for details.
+    def upload_from_string(content, title = 'Untitled', params = {})
+      params = { parents: [id] }.merge(params)
+      @session.upload_from_string(content, title, params)
+    end
+
+    alias contents files
+
+    # Returns all the spreadsheets in the folder.
+    #
+    # 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)
+      files_with_type('application/vnd.google-apps.spreadsheet', params, &block)
+    end
+
+    # Returns all the Google Docs documents in the folder.
+    #
+    # 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)
+      files_with_type('application/vnd.google-apps.document', params, &block)
+    end
+
+    # Returns all its subfolders.
+    #
+    # By default, it returns the first 100 subfolders. See document of
+    # GoogleDrive::Session#files method for how to get all subfolders.
+    def subcollections(params = {}, &block)
+      files_with_type('application/vnd.google-apps.folder', params, &block)
+    end
+
+    alias subfolders subcollections
+
+    # Returns a file (can be a spreadsheet, document, subfolder or other files)
+    # in the folder which exactly matches +title+ as GoogleDrive::File.
+    # Returns nil if not found. If multiple folders with the +title+ are found,
+    # returns one of them.
+    #
+    # If given an Array, does a recursive subfolder traversal.
+    def file_by_title(title)
+      file_by_title_with_type(title, nil)
+    end
+
+    alias file_by_name file_by_title
+
+    # Returns its subfolder whose title exactly matches +title+ as
+    # GoogleDrive::Collection.
+    # Returns nil if not found. If multiple folders with the +title+ are found,
+    # returns one of them.
+    #
+    # If given an Array, does a recursive subfolder traversal.
+    def subcollection_by_title(title)
+      file_by_title_with_type(title, 'application/vnd.google-apps.folder')
+    end
+
+    alias subfolder_by_name subcollection_by_title
+
+    # Returns URL of the deprecated contents feed.
+    def contents_url
+      document_feed_url + '/contents'
+    end
+
+    protected
+
+    def file_by_title_with_type(title, type)
+      if title.is_a?(Array)
+        rel_path = title
+        if rel_path.empty?
+          return self
+        else
+          parent = subcollection_by_title(rel_path[0...-1])
+          return parent && parent.file_by_title_with_type(rel_path[-1], type)
+        end
+      else
+        files_with_type(type, q: ['name = ?', title], page_size: 1)[0]
+      end
+    end
+
+    alias file_by_name_with_type file_by_title_with_type
+
+    private
+
+    def files_with_type(type, params = {}, &block)
+      params = convert_params(params)
+      query  = construct_and_query([
+                                     ['? in parents', 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.
+      @session.files(params, &block)
+    end
+  end
+
+  Folder = Collection
+end

data/lib/google_drive/config.rb

@@ -0,0 +1,36 @@
+# Author: Mateusz Czerwinski <mtczerwinski@gmail.com>
+# The license of this source is "New BSD Licence"
+
+require 'json'
+
+module GoogleDrive
+  # @api private
+  class Config
+    FIELDS = %w[client_id client_secret scope refresh_token type].freeze
+    attr_accessor(*FIELDS)
+
+    def initialize(config_path)
+      @config_path = config_path
+      if ::File.exist?(config_path)
+        JSON.parse(::File.read(config_path)).each do |key, value|
+          instance_variable_set("@#{key}", value) if FIELDS.include?(key)
+        end
+      end
+    end
+
+    def save
+      ::File.open(@config_path, 'w', 0o600) { |f| f.write(to_json) }
+    end
+
+    private
+
+    def to_json
+      hash = {}
+      FIELDS.each do |field|
+        value = __send__(field)
+        hash[field] = value if value
+      end
+      JSON.pretty_generate(hash)
+    end
+  end
+end

data/lib/google_drive/error.rb

@@ -0,0 +1,8 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+module GoogleDrive
+  # Raised on errors in this library.
+  class Error < RuntimeError
+  end
+end

data/lib/google_drive/file.rb

@@ -0,0 +1,266 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require 'cgi'
+require 'forwardable'
+require 'stringio'
+
+require 'google_drive/util'
+require 'google_drive/acl'
+
+module GoogleDrive
+  # A file in Google Drive, including a Google Docs
+  # document/spreadsheet/presentation and a folder.
+  #
+  # Use GoogleDrive::Session#files or GoogleDrive::Session#file_by_title to
+  # get this object.
+  #
+  # In addition to the methods below, properties defined here are also available
+  # as attributes:
+  # https://developers.google.com/drive/v3/reference/files#resource
+  #
+  # e.g.,
+  #   file.mime_type  # ==> "text/plain"
+  class File
+    include(Util)
+    extend(Forwardable)
+
+    # @api private
+    def initialize(session, api_file)
+      @session = session
+      @api_file = api_file
+      @acl = nil
+      delegate_api_methods(self, @api_file, [:title])
+    end
+
+    # Wrapped Google::APIClient::Schema::Drive::V3::File object.
+    attr_reader(:api_file)
+
+    # Reloads file metadata such as title and acl.
+    def reload_metadata
+      @api_file = @session.drive_service.get_file(
+        id, fields: '*', supports_all_drives: true
+      )
+      @acl = Acl.new(@session, self) if @acl
+    end
+
+    # Returns resource_type + ":" + id.
+    def resource_id
+      format('%s:%s', resource_type, id)
+    end
+
+    # URL of feed used in the deprecated document list feed API.
+    def document_feed_url
+      'https://docs.google.com/feeds/default/private/full/' +
+        CGI.escape(resource_id)
+    end
+
+    # Deprecated ACL feed URL of the file.
+    def acl_feed_url
+      document_feed_url + '/acl'
+    end
+
+    # The type of resourse. e.g. "document", "spreadsheet", "folder"
+    def resource_type
+      mime_type.slice(/^application\/vnd.google-apps.(.+)$/, 1) || 'file'
+    end
+
+    # Title of the file.
+    def title(params = {})
+      reload_metadata if params[:reload]
+      api_file.name
+    end
+
+    alias name title
+
+    # URL to view/edit the file in a Web browser.
+    #
+    # e.g. "https://docs.google.com/file/d/xxxx/edit"
+    def human_url
+      api_file.web_view_link
+    end
+
+    # Content types you can specify in methods download_to_file,
+    # download_to_string, download_to_io.
+    #
+    # This returns zero or one file type. You may be able to download the file
+    # in other formats using export_as_file, export_as_string, or export_to_io.
+    def available_content_types
+      api_file.web_content_link ? [api_file.mime_type] : []
+    end
+
+    # Downloads the file to a local file. e.g.
+    #   file.download_to_file("/path/to/hoge.txt")
+    #
+    # To export the file in other formats, use export_as_file.
+    def download_to_file(path, params = {})
+      @session.drive_service.get_file(
+        id,
+        { download_dest: path, supports_all_drives: true }.merge(params)
+      )
+    end
+
+    # Downloads the file and returns as a String.
+    #
+    # To export the file in other formats, use export_as_string.
+    def download_to_string(params = {})
+      sio = StringIO.new
+      download_to_io(sio, params)
+      sio.string
+    end
+
+    # Downloads the file and writes it to +io+.
+    #
+    # To export the file in other formats, use export_to_io.
+    def download_to_io(io, params = {})
+      @session.drive_service.get_file(
+        id,
+        **{ download_dest: io, supports_all_drives: true }.merge(params)
+      )
+    end
+
+    # Export the file to +path+ in content type +format+.
+    # If +format+ is nil, it is guessed from the file name.
+    #
+    # e.g.,
+    #   spreadsheet.export_as_file("/path/to/hoge.csv")
+    #   spreadsheet.export_as_file("/path/to/hoge", "text/csv")
+    #
+    # If you want to download the file in the original format,
+    # use download_to_file instead.
+    def export_as_file(path, format = nil)
+      unless format
+        format = EXT_TO_CONTENT_TYPE[::File.extname(path).downcase]
+        unless format
+          raise(ArgumentError,
+                format("Cannot guess format from the file name: %s\n" \
+                 'Specify format argument explicitly.', path))
+        end
+      end
+      export_to_dest(path, format)
+    end
+
+    # Export the file as String in content type +format+.
+    #
+    # e.g.,
+    #   spreadsheet.export_as_string("text/csv")
+    #
+    # If you want to download the file in the original format, use
+    # download_to_string instead.
+    def export_as_string(format)
+      sio = StringIO.new
+      export_to_dest(sio, format)
+      sio.string
+    end
+
+    # Export the file to +io+ in content type +format+.
+    #
+    # If you want to download the file in the original format, use
+    # download_to_io instead.
+    def export_to_io(io, format)
+      export_to_dest(io, format)
+    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
+
+    # 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 = {})
+      # Somehow it doesn't work if I specify the file name directly as
+      # upload_source.
+      open(path, 'rb') do |f|
+        update_from_io(f, params)
+      end
+      nil
+    end
+
+    # Reads content from +io+ and updates the file with the content.
+    def update_from_io(io, params = {})
+      params = { upload_source: io, supports_all_drives: true }.merge(params)
+      @session.drive_service.update_file(id, nil, **params)
+      nil
+    end
+
+    # If +permanent+ is +false+, moves the file to the trash.
+    # If +permanent+ is +true+, deletes the file permanently.
+    def delete(permanent = false)
+      if permanent
+        @session.drive_service.delete_file(id, supports_all_drives: true)
+      else
+        @session.drive_service.update_file(
+          id, { trashed: true }, supports_all_drives: true
+        )
+      end
+      nil
+    end
+
+    # Renames title of the file.
+    def rename(title)
+      @session.drive_service.update_file(
+        id, { name: title }, supports_all_drives: true
+      )
+      nil
+    end
+
+    alias title= rename
+
+    # Creates copy of this file with the given title.
+    def copy(title, file_properties = {})
+      api_file = @session.drive_service.copy_file(
+        id, { name: title }.merge(file_properties), fields: '*', supports_all_drives: true
+      )
+      @session.wrap_api_file(api_file)
+    end
+
+    alias duplicate copy
+
+    # 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.
+    #
+    # e.g.
+    #   # Dumps people who have access:
+    #   for entry in file.acl
+    #     p [entry.type, entry.email_address, 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(
+    #       {type: "user", email_address: "example2@gmail.com", role: "reader"})
+    #   file.acl.push(
+    #       {type: "user", email_address: "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 = {})
+      @acl = Acl.new(@session, self) if !@acl || params[:reload]
+      @acl
+    end
+
+    def inspect
+      format("\#<%p id=%p title=%p>", self.class, id, title)
+    end
+
+    private
+
+    def export_to_dest(dest, format)
+      mime_type = EXT_TO_CONTENT_TYPE['.' + format] || format
+      @session.drive_service.export_file(id, mime_type, download_dest: dest)
+      nil
+    end
+  end
+end

data/lib/google_drive/list.rb

@@ -0,0 +1,125 @@
+# 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)
+
+    # @api private
+    def initialize(worksheet)
+      @worksheet = worksheet
+    end
+
+    # Number of non-empty rows in the worksheet excluding the first row.
+    def size
+      @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)
+      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...size
+        yield(self[i])
+      end
+    end
+
+    # Column names i.e. the contents of the first row.
+    # Duplicates are removed.
+    def keys
+      (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[size]
+      row.update(hash)
+      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
+      map(&:to_hash)
+    end
+
+    # @api private
+    def get(index, key)
+      @worksheet[index + 2, key_to_col(key)]
+    end
+
+    # @api private
+    def numeric_value(index, key)
+      @worksheet.numeric_value(index + 2, key_to_col(key))
+    end
+
+    # @api private
+    def input_value(index, key)
+      @worksheet.input_value(index + 2, key_to_col(key))
+    end
+
+    # @api private
+    def set(index, key, value)
+      @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 }
+      unless col
+        raise(GoogleDrive::Error, format("Column doesn't exist: %p", key))
+      end
+      col
+    end
+  end
+end