google_drive 2.1.12 → 3.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a6e8bc240087cb507a378a4ff02886cad3e2b7ed
-  data.tar.gz: 07a8f238c8cc89072248fd6db3b2ca0b7ab18d37
+SHA256:
+  metadata.gz: 8579ea758131c51c083928052abf518b1f327b9b9666e798c17007801f0c1476
+  data.tar.gz: c04c47fe2d0337bb2e471227ad66e90b857b33784f01f8d60d7406f63fcad92b
 SHA512:
-  metadata.gz: 55ff686961a787c15738c8177f6aada5b4df2851019116e120310e2523684fed2d389b9658ad7f7d832ce125bcaf608467e7f7244a76109c0c649491d14ac773
-  data.tar.gz: b89df0376ae01ef915ae88193059a809eccbfa410f2a84a0e30c35415f08789f4021567d8da52a85e8f7cddd53319b084ddbc161deeb6ba19f0a0dd072e3cfec
+  metadata.gz: d52bac1e4e05bd2dee4503a67a4c9da7eaeee700dfa9bca2f668bc88c04df065b5a7c209a4808d98a63610cb27318df3bef859e6e016ba4fbe1029782440aa58
+  data.tar.gz: 24facac6a6116210ea76b82f139fcd5c93e5624fbdb889f2fb89de65c98a6eb11ae31fb0c892cb221a5b689e2fc5271bb6636ad1215559e2689a8ef9b5edbf85

data/README.md

@@ -5,7 +5,7 @@ This is a Ruby library to read/write files/spreadsheets in Google Drive/Docs.
 NOTE: This is NOT a library to create Google Drive App.
 
 
-* [Migration from ver. 0.x.x / 1.x.x](#migration)
+* [Migration from ver. 2.x.x or before](#migration)
 * [How to install](#install)
 * [How to use](#use)
 * [API documentation](http://www.rubydoc.info/gems/google_drive)
@@ -16,7 +16,7 @@ NOTE: This is NOT a library to create Google Drive App.
 * [Author](#author)
 
 
-## <a name="migration">Migration from ver. 0.x.x / 1.x.x</a>
+## <a name="migration">Migration from ver. 2.x.x or before</a>
 
 There are some incompatible API changes. See
 [MIGRATING.md](https://github.com/gimite/google-drive-ruby/blob/master/MIGRATING.md).

data/lib/google_drive/acl.rb

@@ -21,8 +21,8 @@ module GoogleDrive
     def initialize(session, file)
       @session = session
       @file = file
-      api_permissions = @session.drive.list_permissions(
-        @file.id, fields: '*', supports_team_drives: true
+      api_permissions = @session.drive_service.list_permissions(
+        @file.id, fields: '*', supports_all_drives: true
       )
       @entries =
         api_permissions.permissions.map { |perm| AclEntry.new(perm, self) }
@@ -70,10 +70,10 @@ module GoogleDrive
     def push(params_or_entry, options = {})
       entry = params_or_entry.is_a?(AclEntry) ?
         params_or_entry : AclEntry.new(params_or_entry)
-      api_permission = @session.drive.create_permission(
+      api_permission = @session.drive_service.create_permission(
         @file.id,
         entry.params,
-        { fields: '*', supports_team_drives: true }.merge(options)
+        **{ fields: '*', supports_all_drives: true }.merge(options)
       )
       new_entry = AclEntry.new(api_permission, self)
       @entries.push(new_entry)
@@ -85,20 +85,20 @@ module GoogleDrive
     # e.g.
     #   spreadsheet.acl.delete(spreadsheet.acl[1])
     def delete(entry)
-      @session.drive.delete_permission(
-        @file.id, entry.id, supports_team_drives: true
+      @session.drive_service.delete_permission(
+        @file.id, entry.id, supports_all_drives: true
       )
       @entries.delete(entry)
     end
 
     # @api private
     def update_role(entry)
-      api_permission = @session.drive.update_permission(
+      api_permission = @session.drive_service.update_permission(
         @file.id,
         entry.id,
         { role: entry.role },
         fields: '*',
-        supports_team_drives: true
+        supports_all_drives: true
       )
       entry.api_permission = api_permission
       entry

data/lib/google_drive/api_client_fetcher.rb

@@ -4,6 +4,7 @@
 require 'net/https'
 require 'uri'
 require 'google/apis/drive_v3'
+require 'google/apis/sheets_v4'
 Net::HTTP.version_1_2
 
 module GoogleDrive
@@ -19,30 +20,35 @@ module GoogleDrive
 
     def initialize(authorization, client_options, request_options)
       @drive = Google::Apis::DriveV3::DriveService.new
-      @drive.authorization = authorization
-
-      # Make the timeout virtually infinite because some of the operations
-      # (e.g., uploading a large file) can take very long.
-      # This value is the maximal allowed timeout in seconds on JRuby.
-      t = (2**31 - 1) / 1000
-      @drive.client_options.open_timeout_sec = t
-      @drive.client_options.read_timeout_sec = t
-      @drive.client_options.send_timeout_sec = t
-
-      if client_options
-        @drive.client_options.members.each do |name|
-          if !client_options[name].nil?
-            @drive.client_options[name] = client_options[name]
+      @sheets = Google::Apis::SheetsV4::SheetsService.new
+
+      [@drive, @sheets].each do |service|
+        service.authorization = authorization
+
+        # Make the timeout virtually infinite because some of the operations
+        # (e.g., uploading a large file) can take very long.
+        # This value is the maximal allowed timeout in seconds on JRuby.
+        t = (2**31 - 1) / 1000
+        service.client_options.open_timeout_sec = t
+        service.client_options.read_timeout_sec = t
+        service.client_options.send_timeout_sec = t
+
+        if client_options
+          service.client_options.members.each do |name|
+            if !client_options[name].nil?
+              service.client_options[name] = client_options[name]
+            end
           end
         end
-      end
 
-      if request_options
-        @drive.request_options = @drive.request_options.merge(request_options)
+        if request_options
+          service.request_options = service.request_options.merge(request_options)
+        end
       end
     end
 
     attr_reader(:drive)
+    attr_reader(:sheets)
 
     def request_raw(method, url, data, extra_header, _auth)
       options = @drive.request_options.merge(header: extra_header)

data/lib/google_drive/collection.rb

@@ -19,16 +19,16 @@ module GoogleDrive
 
     # Adds the given GoogleDrive::File to the folder.
     def add(file)
-      @session.drive.update_file(
-        file.id, add_parents: id, fields: '', supports_team_drives: true
+      @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.update_file(
-        file.id, remove_parents: id, fields: '', supports_team_drives: true
+      @session.drive_service.update_file(
+        file.id, remove_parents: id, fields: '', supports_all_drives: true
       )
     end
 
@@ -61,8 +61,8 @@ module GoogleDrive
         parents: [id]
       }.merge(file_properties)
 
-      file = @session.drive.create_file(
-        file_metadata, fields: '*', supports_team_drives: true
+      file = @session.drive_service.create_file(
+        file_metadata, fields: '*', supports_all_drives: true
       )
 
       @session.wrap_api_file(file)

data/lib/google_drive/file.rb

@@ -38,8 +38,8 @@ module GoogleDrive
 
     # Reloads file metadata such as title and acl.
     def reload_metadata
-      @api_file = @session.drive.get_file(
-        id, fields: '*', supports_team_drives: true
+      @api_file = @session.drive_service.get_file(
+        id, fields: '*', supports_all_drives: true
       )
       @acl = Acl.new(@session, self) if @acl
     end
@@ -94,9 +94,9 @@ module GoogleDrive
     #
     # To export the file in other formats, use export_as_file.
     def download_to_file(path, params = {})
-      @session.drive.get_file(
+      @session.drive_service.get_file(
         id,
-        { download_dest: path, supports_team_drives: true }.merge(params)
+        { download_dest: path, supports_all_drives: true }.merge(params)
       )
     end
 
@@ -113,9 +113,9 @@ module GoogleDrive
     #
     # To export the file in other formats, use export_to_io.
     def download_to_io(io, params = {})
-      @session.drive.get_file(
+      @session.drive_service.get_file(
         id,
-        { download_dest: io, supports_team_drives: true }.merge(params)
+        **{ download_dest: io, supports_all_drives: true }.merge(params)
       )
     end
 
@@ -184,8 +184,8 @@ module GoogleDrive
 
     # Reads content from +io+ and updates the file with the content.
     def update_from_io(io, params = {})
-      params = { upload_source: io, supports_team_drives: true }.merge(params)
-      @session.drive.update_file(id, nil, params)
+      params = { upload_source: io, supports_all_drives: true }.merge(params)
+      @session.drive_service.update_file(id, nil, **params)
       nil
     end
 
@@ -193,10 +193,10 @@ module GoogleDrive
     # If +permanent+ is +true+, deletes the file permanently.
     def delete(permanent = false)
       if permanent
-        @session.drive.delete_file(id, supports_team_drives: true)
+        @session.drive_service.delete_file(id, supports_all_drives: true)
       else
-        @session.drive.update_file(
-          id, { trashed: true }, supports_team_drives: true
+        @session.drive_service.update_file(
+          id, { trashed: true }, supports_all_drives: true
         )
       end
       nil
@@ -204,8 +204,8 @@ module GoogleDrive
 
     # Renames title of the file.
     def rename(title)
-      @session.drive.update_file(
-        id, { name: title }, supports_team_drives: true
+      @session.drive_service.update_file(
+        id, { name: title }, supports_all_drives: true
       )
       nil
     end
@@ -214,8 +214,8 @@ module GoogleDrive
 
     # Creates copy of this file with the given title.
     def copy(title, file_properties = {})
-      api_file = @session.drive.copy_file(
-        id, { name: title }.merge(file_properties), fields: '*', supports_team_drives: true
+      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
@@ -259,7 +259,7 @@ module GoogleDrive
 
     def export_to_dest(dest, format)
       mime_type = EXT_TO_CONTENT_TYPE['.' + format] || format
-      @session.drive.export_file(id, mime_type, download_dest: dest)
+      @session.drive_service.export_file(id, mime_type, download_dest: dest)
       nil
     end
   end

data/lib/google_drive/session.rb

@@ -141,15 +141,13 @@ module GoogleDrive
         config.client_id = options[:client_id]
         config.client_secret = options[:client_secret]
       end
-      if !config.client_id && !config.client_secret
-        config.client_id =
-          '452925651630-egr1f18o96acjjvphpbbd1qlsevkho1d.' \
-          'apps.googleusercontent.com'
-        config.client_secret = '1U3-Krii5x1oLPrwD5zgn-ry'
-      elsif !config.client_id || !config.client_secret
+      if !config.client_id || !config.client_secret
         raise(
           ArgumentError,
-          'client_id and client_secret must be both specified or both omitted'
+          'client_id or client_secret is missing in the config. Follow ' \
+          'https://github.com/gimite/google-drive-ruby/blob/master/doc/authorization.md ' \
+          'to provide a valid config. google_drive library no longer provides ' \
+          'the default credential due to a limitation of Google API.'
         )
       end
 
@@ -219,10 +217,17 @@ module GoogleDrive
     attr_accessor :on_auth_fail
 
     # Returns an instance of Google::Apis::DriveV3::DriveService.
-    def drive
+    def drive_service
       @fetcher.drive
     end
 
+    alias drive drive_service
+
+    # Returns an instance of Google::Apis::SheetsV4::SheetsService.
+    def sheets_service
+      @fetcher.sheets
+    end
+
     # Returns list of files for the user as array of GoogleDrive::File or its
     # subclass. You can specify parameters documented at
     # https://developers.google.com/drive/v3/web/search-parameters
@@ -247,8 +252,8 @@ module GoogleDrive
     def files(params = {}, &block)
       params = convert_params(params)
       execute_paged!(
-        method: drive.method(:list_files),
-        parameters: { fields: '*', supports_team_drives: true }.merge(params),
+        method: drive_service.method(:list_files),
+        parameters: { fields: '*', supports_all_drives: true, include_items_from_all_drives: true }.merge(params),
         items_method_name: :files,
         converter: proc { |af| wrap_api_file(af) },
         &block
@@ -280,7 +285,7 @@ module GoogleDrive
     # Returns an instance of GoogleDrive::File or its subclass
     # (GoogleDrive::Spreadsheet, GoogleDrive::Collection).
     def file_by_id(id)
-      api_file = drive.get_file(id, fields: '*', supports_team_drives: true)
+      api_file = drive_service.get_file(id, fields: '*', supports_all_drives: true)
       wrap_api_file(api_file)
     end
 
@@ -379,13 +384,12 @@ module GoogleDrive
     #     "1smypkyAz4STrKO4Zkos5Z4UPUJKvvgIza32LnlQ7OGw/od7/private/full")
     def worksheet_by_url(url)
       case url
-      when %r{^https?://spreadsheets.google.com/feeds/worksheets/.*/.*/full/.*$}
-        worksheet_feed_url = url
-      when %r{^https?://spreadsheets.google.com/feeds/cells/(.*)/(.*)/private/full((\?.*)?)$}
-        worksheet_feed_url =
-          'https://spreadsheets.google.com/feeds/worksheets/' \
-          "#{Regexp.last_match(1)}/private/full/" \
-          "#{Regexp.last_match(2)}#{Regexp.last_match(3)}"
+      when %r{^https?://spreadsheets.google.com/feeds/worksheets/(.*)/.*/full/(.*)$}
+        spreadsheet_id = Regexp.last_match(1)
+        worksheet_feed_id = Regexp.last_match(2)
+      when %r{^https?://spreadsheets.google.com/feeds/cells/(.*)/(.*)/private/full(\?.*)?$}
+        spreadsheet_id = Regexp.last_match(1)
+        worksheet_feed_id = Regexp.last_match(2)
       else
         raise(
           GoogleDrive::Error,
@@ -394,8 +398,15 @@ module GoogleDrive
         )
       end
 
-      worksheet_feed_entry = request(:get, worksheet_feed_url)
-      Worksheet.new(self, nil, worksheet_feed_entry)
+      spreadsheet = spreadsheet_by_key(spreadsheet_id)
+      worksheet = spreadsheet.worksheets.find{ |ws| ws.worksheet_feed_id == worksheet_feed_id }
+      unless worksheet
+        raise(
+          GoogleDrive::Error,
+          "Worksheet not found for the given URL: #{url}"
+        )
+      end
+      worksheet
     end
 
     # Returns the root folder.
@@ -496,8 +507,8 @@ module GoogleDrive
         name: title,
       }.merge(file_properties)
 
-      file = drive.create_file(
-        file_metadata, fields: '*', supports_team_drives: true
+      file = drive_service.create_file(
+        file_metadata, fields: '*', supports_all_drives: true
       )
 
       wrap_api_file(file)
@@ -587,7 +598,7 @@ module GoogleDrive
         end
 
       elsif opts[:parameters] && opts[:parameters].key?(:page_token)
-        response = opts[:method].call(opts[:parameters])
+        response = opts[:method].call(**opts[:parameters])
         items    = response.__send__(opts[:items_method_name]).map do |item|
           opts[:converter] ? opts[:converter].call(item) : item
         end
@@ -643,7 +654,7 @@ module GoogleDrive
         upload_source: source,
         content_type: 'application/octet-stream',
         fields: '*',
-        supports_team_drives: true
+        supports_all_drives: true
       }
       for k, v in params
         unless %i[convert convert_mime_type parents].include?(k)
@@ -661,7 +672,7 @@ module GoogleDrive
       end
       file_metadata[:parents] = params[:parents] if params[:parents]
 
-      file = drive.create_file(file_metadata, api_params)
+      file = drive_service.create_file(file_metadata, **api_params)
       wrap_api_file(file)
     end
 

data/lib/google_drive/spreadsheet.rb

@@ -16,6 +16,10 @@ module GoogleDrive
   # create_spreadsheet in GoogleDrive::Session to get GoogleDrive::Spreadsheet
   # object.
   class Spreadsheet < GoogleDrive::File
+    
+    # TODO: Bump up the major version before switching the existing methods to
+    # v4 API because it requires to turn on a new API in the API console.
+
     include(Util)
 
     SUPPORTED_EXPORT_FORMAT = Set.new(%w[xlsx csv pdf])
@@ -45,16 +49,8 @@ module GoogleDrive
 
     # Returns worksheets of the spreadsheet as array of GoogleDrive::Worksheet.
     def worksheets
-      doc = @session.request(:get, worksheets_feed_url)
-      if doc.root.name != 'feed'
-        raise(GoogleDrive::Error,
-              format(
-                "%s doesn't look like a worksheets feed URL because its root " \
-                'is not <feed>.',
-                worksheets_feed_url
-              ))
-      end
-      doc.css('entry').map { |e| Worksheet.new(@session, self, e) }.freeze
+      api_spreadsheet = @session.sheets_service.get_spreadsheet(id, fields: 'sheets.properties')
+      api_spreadsheet.sheets.map{ |s| Worksheet.new(@session, self, s.properties) }
     end
 
     # Returns a GoogleDrive::Worksheet with the given title in the spreadsheet.
@@ -68,24 +64,32 @@ module GoogleDrive
     # Returns a GoogleDrive::Worksheet with the given gid.
     #
     # Returns nil if not found.
-    def worksheet_by_gid(gid)
-      gid = gid.to_s
-      worksheets.find { |ws| ws.gid == gid }
+    def worksheet_by_sheet_id(sheet_id)
+      sheet_id = sheet_id.to_i
+      worksheets.find { |ws| ws.sheet_id == sheet_id }
     end
 
+    alias worksheet_by_gid worksheet_by_sheet_id
+
     # Adds a new worksheet to the spreadsheet. Returns added
     # GoogleDrive::Worksheet.
-    def add_worksheet(title, max_rows = 100, max_cols = 20)
-      xml = <<-"EOS"
-            <entry xmlns='http://www.w3.org/2005/Atom'
-                   xmlns:gs='http://schemas.google.com/spreadsheets/2006'>
-              <title>#{h(title)}</title>
-              <gs:rowCount>#{h(max_rows)}</gs:rowCount>
-              <gs:colCount>#{h(max_cols)}</gs:colCount>
-            </entry>
-          EOS
-      doc = @session.request(:post, worksheets_feed_url, data: xml)
-      Worksheet.new(@session, self, doc.root)
+    #
+    # When +index+ is specified, the worksheet is inserted at the given
+    # +index+.
+    def add_worksheet(title, max_rows = 100, max_cols = 20, index: nil)
+      (response,) = batch_update([{
+        add_sheet: {
+          properties: {
+            title: title,
+            index: index,
+            grid_properties: {
+              row_count: max_rows,
+              column_count: max_cols,
+            },
+          },
+        },
+      }])
+      Worksheet.new(@session, self, response.add_sheet.properties)
     end
 
     # Not available for GoogleDrive::Spreadsheet. Use export_as_file instead.
@@ -114,5 +118,18 @@ module GoogleDrive
         'Use export_to_io instead.'
       )
     end
+
+    # Performs batch update of the spreadsheet.
+    #
+    # +requests+ is an Array of Google::Apis::SheetsV4::Request or its Hash
+    # equivalent. Returns an Array of Google::Apis::SheetsV4::Response.
+    def batch_update(requests)
+      batch_request =
+        Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest.new(
+          requests: requests)
+      batch_response =
+        @session.sheets_service.batch_update_spreadsheet(id, batch_request)
+      batch_response.replies
+    end
   end
 end

data/lib/google_drive/worksheet.rb

@@ -16,51 +16,104 @@ module GoogleDrive
   class Worksheet
     include(Util)
 
+    # A few default color instances that match the colors from the Google Sheets web UI.
+    #
+    # TODO: Add more colors from
+    # https://github.com/denilsonsa/gimp-palettes/blob/master/palettes/Google-Drive.gpl
+    module Colors
+      RED = Google::Apis::SheetsV4::Color.new(red: 1.0)
+      DARK_RED_1 = Google::Apis::SheetsV4::Color.new(red: 0.8)
+      RED_BERRY = Google::Apis::SheetsV4::Color.new(red: 0.596)
+      DARK_RED_BERRY_1 = Google::Apis::SheetsV4::Color.new(red: 0.659, green: 0.11)
+      ORANGE = Google::Apis::SheetsV4::Color.new(red: 1.0, green: 0.6)
+      DARK_ORANGE_1 = Google::Apis::SheetsV4::Color.new(red: 0.9, green: 0.569, blue: 0.22)
+      YELLOW = Google::Apis::SheetsV4::Color.new(red: 1.0, green: 1.0)
+      DARK_YELLOW_1 = Google::Apis::SheetsV4::Color.new(red: 0.945, green: 0.76, blue: 0.196)
+      GREEN = Google::Apis::SheetsV4::Color.new(green: 1.0)
+      DARK_GREEN_1 = Google::Apis::SheetsV4::Color.new(red: 0.416, green: 0.659, blue: 0.31)
+      CYAN = Google::Apis::SheetsV4::Color.new(green: 1.0, blue: 1.0)
+      DARK_CYAN_1 = Google::Apis::SheetsV4::Color.new(red: 0.27, green: 0.506, blue: 0.557)
+      CORNFLOWER_BLUE = Google::Apis::SheetsV4::Color.new(red: 0.29, green: 0.525, blue: 0.91)
+      DARK_CORNFLOWER_BLUE_1 = Google::Apis::SheetsV4::Color.new(red: 0.235, green: 0.47, blue: 0.847)
+      BLUE = Google::Apis::SheetsV4::Color.new(blue: 1.0)
+      DARK_BLUE_1 = Google::Apis::SheetsV4::Color.new(red: 0.239, green: 0.522, blue: 0.776)
+      PURPLE = Google::Apis::SheetsV4::Color.new(red: 0.6, blue: 1.0)
+      DARK_PURPLE_1 = Google::Apis::SheetsV4::Color.new(red: 0.404, green: 0.306, blue: 0.655)
+      MAGENTA = Google::Apis::SheetsV4::Color.new(red: 1.0, blue: 1.0)
+      DARK_MAGENTA_1 = Google::Apis::SheetsV4::Color.new(red: 0.651, green: 0.302, blue: 0.475)
+      WHITE = Google::Apis::SheetsV4::Color.new(red: 1.0, green: 1.0, blue: 1.0)
+      BLACK = Google::Apis::SheetsV4::Color.new(red: 0.0, green: 0.0, blue: 0.0)
+      GRAY = Google::Apis::SheetsV4::Color.new(red: 0.8, green: 0.8, blue: 0.8)
+      DARK_GRAY_1 = Google::Apis::SheetsV4::Color.new(red: 0.714, green: 0.714, blue: 0.714)
+    end
+
     # @api private
     # A regexp which matches an invalid character in XML 1.0:
     # https://en.wikipedia.org/wiki/Valid_characters_in_XML#XML_1.0
-    XML_INVAILD_CHAR_REGEXP =
+    XML_INVALID_CHAR_REGEXP =
       /[^\u0009\u000a\u000d\u0020-\ud7ff\ue000-\ufffd\u{10000}-\u{10ffff}]/
 
     # @api private
-    def initialize(session, spreadsheet, worksheet_feed_entry)
+    def initialize(session, spreadsheet, properties)
       @session = session
       @spreadsheet = spreadsheet
-      set_worksheet_feed_entry(worksheet_feed_entry)
-
+      set_properties(properties)
       @cells = nil
       @input_values = nil
       @numeric_values = nil
       @modified = Set.new
       @list = nil
+      @v4_requests = []
     end
 
     # Nokogiri::XML::Element object of the <entry> element in a worksheets feed.
-    attr_reader(:worksheet_feed_entry)
+    #
+    # DEPRECATED: This method is deprecated, and now requires additional
+    # network fetch. Consider using properties instead.
+    def worksheet_feed_entry
+      @worksheet_feed_entry ||= @session.request(:get, worksheet_feed_url).root
+    end
+
+    # Google::Apis::SheetsV4::SheetProperties object for this worksheet.
+    attr_reader :properties
 
     # Title of the worksheet (shown as tab label in Web interface).
-    attr_reader(:title)
+    attr_reader :title
+
+    # Index of the worksheet (affects tab order in web interface).
+    attr_reader :index
+
+    # GoogleDrive::Spreadsheet which this worksheet belongs to.
+    attr_reader :spreadsheet
 
     # Time object which represents the time the worksheet was last updated.
-    attr_reader(:updated)
+    #
+    # DEPRECATED: From google_drive 3.0.0, it returns the time the
+    # *spreadsheet* was last updated, instead of the worksheet. This is because
+    # it looks the information is not available in Sheets v4 API.
+    def updated
+      spreadsheet.modified_time.to_time
+    end
 
     # URL of cell-based feed of the worksheet.
+    #
+    # DEPRECATED: This method is deprecated, and now requires additional
+    # network fetch.
     def cells_feed_url
-      @worksheet_feed_entry.css(
+      worksheet_feed_entry.css(
         "link[rel='http://schemas.google.com/spreadsheets/2006#cellsfeed']"
       )[0]['href']
     end
 
     # URL of worksheet feed URL of the worksheet.
     def worksheet_feed_url
-      @worksheet_feed_entry.css("link[rel='self']")[0]['href']
+      return '%s/%s' % [spreadsheet.worksheets_feed_url, worksheet_feed_id]
     end
 
     # URL to export the worksheet as CSV.
     def csv_export_url
-      @worksheet_feed_entry.css(
-        "link[rel='http://schemas.google.com/spreadsheets/2006#exportcsv']"
-      )[0]['href']
+      'https://docs.google.com/spreadsheets/d/%s/export?gid=%s&format=csv' %
+        [spreadsheet.id, gid]
     end
 
     # Exports the worksheet as String in CSV format.
@@ -74,10 +127,14 @@ module GoogleDrive
       open(path, 'wb') { |f| f.write(data) }
     end
 
-    # gid of the worksheet.
+    # ID of the worksheet.
+    def sheet_id
+      @properties.sheet_id
+    end
+
+    # Returns sheet_id.to_s.
     def gid
-      # A bit tricky but couldn't find a better way.
-      CGI.parse(URI.parse(csv_export_url).query)['gid'].last
+      sheet_id.to_s
     end
 
     # URL to view/edit the worksheet in a Web browser.
@@ -85,18 +142,22 @@ module GoogleDrive
       format("%s\#gid=%s", spreadsheet.human_url, gid)
     end
 
-    # GoogleDrive::Spreadsheet which this worksheet belongs to.
-    def spreadsheet
-      unless @spreadsheet
-        unless worksheet_feed_url =~
-               %r{https?://spreadsheets\.google\.com/feeds/worksheets/(.*)/(.*)$}
-          raise(GoogleDrive::Error,
-                'Worksheet feed URL is in unknown format: ' \
-                "#{worksheet_feed_url}")
-        end
-        @spreadsheet = @session.file_by_id(Regexp.last_match(1))
-      end
-      @spreadsheet
+    # Copy worksheet to specified spreadsheet.
+    # This method can take either instance of GoogleDrive::Spreadsheet or its id.
+    def copy_to(spreadsheet_or_id)
+      destination_spreadsheet_id =
+        spreadsheet_or_id.respond_to?(:id) ?
+          spreadsheet_or_id.id : spreadsheet_or_id
+      request = Google::Apis::SheetsV4::CopySheetToAnotherSpreadsheetRequest.new(
+        destination_spreadsheet_id: destination_spreadsheet_id,
+      )
+      @session.sheets_service.copy_spreadsheet(spreadsheet.id, sheet_id, request)
+      nil
+    end
+
+    # Copy worksheet to owner spreadsheet.
+    def duplicate
+      copy_to(spreadsheet)
     end
 
     # Returns content of the cell as String. Arguments must be either
@@ -240,6 +301,13 @@ module GoogleDrive
       @meta_modified = true
     end
 
+    # Updates index of the worksheet.
+    # Note that update is not sent to the server until you call save().
+    def index=(index)
+      @index = index
+      @meta_modified = true
+    end
+
     # @api private
     def cells
       reload_cells unless @cells
@@ -314,8 +382,19 @@ module GoogleDrive
     # Note that changes you made by []= etc. is discarded if you haven't called
     # save().
     def reload
-      set_worksheet_feed_entry(@session.request(:get, worksheet_feed_url).root)
-      reload_cells
+      api_spreadsheet =
+        @session.sheets_service.get_spreadsheet(
+          spreadsheet.id,
+          ranges: "'%s'" % @title,
+          fields:
+            'sheets(properties,data.rowData.values' \
+            '(formattedValue,userEnteredValue,effectiveValue))'
+        )
+      api_sheet = api_spreadsheet.sheets[0]
+      set_properties(api_sheet.properties)
+      update_cells_from_api_sheet(api_sheet)
+      @v4_requests = []
+      @worksheet_feed_entry = nil
       true
     end
 
@@ -324,122 +403,59 @@ module GoogleDrive
       sent = false
 
       if @meta_modified
+        add_request({
+          update_sheet_properties: {
+            properties: {
+              sheet_id: sheet_id,
+              title: title,
+              index: index,
+              grid_properties: {row_count: max_rows, column_count: max_cols},
+            },
+            fields: '*',
+          },
+        })
+      end
 
-        edit_url = @worksheet_feed_entry.css("link[rel='edit']")[0]['href']
-        xml = <<-"EOS"
-              <entry xmlns='http://www.w3.org/2005/Atom'
-                     xmlns:gs='http://schemas.google.com/spreadsheets/2006'>
-                <title>#{h(title)}</title>
-                <gs:rowCount>#{h(max_rows)}</gs:rowCount>
-                <gs:colCount>#{h(max_cols)}</gs:colCount>
-              </entry>
-            EOS
-
-        result = @session.request(
-          :put,
-          edit_url,
-          data: xml,
-          header: {
-            'Content-Type' => 'application/atom+xml;charset=utf-8',
-            'If-Match' => '*'
-          }
-        )
-        set_worksheet_feed_entry(result.root)
-
+      if !@v4_requests.empty?
+        self.spreadsheet.batch_update(@v4_requests)
+        @v4_requests = []
         sent = true
       end
 
-      unless @modified.empty?
-        # Gets id and edit URL for each cell.
-        # Note that return-empty=true is required to get those info for empty cells.
-        cell_entries = {}
-        rows = @modified.map { |r, _c| r }
-        cols = @modified.map { |_r, c| c }
-        url = concat_url(
-          cells_feed_url,
-          "?return-empty=true&min-row=#{rows.min}&max-row=#{rows.max}" \
-          "&min-col=#{cols.min}&max-col=#{cols.max}"
-        )
-        doc = @session.request(:get, url)
+      @remote_title = @title
 
-        doc.css('entry').each do |entry|
-          row                      = entry.css('gs|cell')[0]['row'].to_i
-          col                      = entry.css('gs|cell')[0]['col'].to_i
-          cell_entries[[row, col]] = entry
+      unless @modified.empty?
+        min_modified_row = 1.0 / 0.0
+        max_modified_row = 0
+        min_modified_col = 1.0 / 0.0
+        max_modified_col = 0
+        @modified.each do |r, c|
+          min_modified_row = r if r < min_modified_row
+          max_modified_row = r if r > max_modified_row
+          min_modified_col = c if c < min_modified_col
+          max_modified_col = c if c > max_modified_col
         end
 
-        xml = <<-EOS
-              <feed xmlns="http://www.w3.org/2005/Atom"
-                    xmlns:batch="http://schemas.google.com/gdata/batch"
-                    xmlns:gs="http://schemas.google.com/spreadsheets/2006">
-                <id>#{h(cells_feed_url)}</id>
-            EOS
-        @modified.each do |row, col|
-          value     = @cells[[row, col]]
-          entry     = cell_entries[[row, col]]
-          id        = entry.css('id').text
-          edit_link = entry.css("link[rel='edit']")[0]
-          unless edit_link
-            raise(
-              GoogleDrive::Error,
-              format(
-                "The user doesn't have write permission to the spreadsheet: %p",
-                spreadsheet
-              )
-            )
+        # Uses update_spreadsheet_value instead batch_update_spreadsheet with
+        # update_cells. batch_update_spreadsheet has benefit that the request
+        # can be batched with other requests. But it has drawback that the
+        # type of the value (string_value, number_value, etc.) must be
+        # explicitly specified in user_entered_value. Since I don't know exact
+        # logic to determine the type from text, I chose to use
+        # update_spreadsheet_value here.
+        range = "'%s'!R%dC%d:R%dC%d" %
+            [@title, min_modified_row, min_modified_col, max_modified_row, max_modified_col]
+        values = (min_modified_row..max_modified_row).map do |r|
+          (min_modified_col..max_modified_col).map do |c|
+            @modified.include?([r, c]) ? (@cells[[r, c]] || '') : nil
           end
-          edit_url = edit_link['href']
-          xml << <<-EOS
-                <entry>
-                  <batch:id>#{h(row)},#{h(col)}</batch:id>
-                  <batch:operation type="update"/>
-                  <id>#{h(id)}</id>
-                  <link
-                    rel="edit"
-                    type="application/atom+xml"
-                    href="#{h(edit_url)}"/>
-                  <gs:cell
-                    row="#{h(row)}"
-                    col="#{h(col)}"
-                    inputValue="#{h(value)}"/>
-                </entry>
-          EOS
-        end
-        xml << <<-"EOS"
-          </feed>
-        EOS
-
-        batch_url = concat_url(cells_feed_url, '/batch')
-        result = @session.request(
-          :post,
-          batch_url,
-          data: xml,
-          header: {
-            'Content-Type' => 'application/atom+xml;charset=utf-8',
-            'If-Match' => '*'
-          }
-        )
-        result.css('entry').each do |entry|
-          interrupted = entry.css('batch|interrupted')[0]
-          if interrupted
-            raise(
-              GoogleDrive::Error,
-              format('Update has failed: %s', interrupted['reason'])
-            )
-          end
-          next if entry.css('batch|status').first['code'] =~ /^2/
-          raise(
-            GoogleDrive::Error,
-            format(
-              'Updating cell %s has failed: %s',
-              entry.css('id').text, entry.css('batch|status')[0]['reason']
-            )
-          )
         end
+        value_range = Google::Apis::SheetsV4::ValueRange.new(values: values)
+        @session.sheets_service.update_spreadsheet_value(
+            spreadsheet.id, range, value_range, value_input_option: 'USER_ENTERED')
 
         @modified.clear
         sent = true
-
       end
 
       sent
@@ -454,17 +470,20 @@ module GoogleDrive
     # Deletes this worksheet. Deletion takes effect right away without calling
     # save().
     def delete
-      ws_doc = @session.request(:get, worksheet_feed_url)
-      edit_url = ws_doc.css("link[rel='edit']")[0]['href']
-      @session.request(:delete, edit_url)
+      spreadsheet.batch_update([{
+        delete_sheet: Google::Apis::SheetsV4::DeleteSheetRequest.new(sheet_id: sheet_id),
+      }])
     end
 
-    # Returns true if you have changes made by []= which haven't been saved.
+    # Returns true if you have changes made by []= etc. which haven't been saved.
     def dirty?
-      !@modified.empty?
+      !@modified.empty? || !@v4_requests.empty?
     end
 
     # List feed URL of the worksheet.
+    #
+    # DEPRECATED: This method is deprecated, and now requires additional
+    # network fetch.
     def list_feed_url
       @worksheet_feed_entry.css(
         "link[rel='http://schemas.google.com/spreadsheets/2006#listfeed']"
@@ -517,7 +536,7 @@ module GoogleDrive
     end
 
     def inspect
-      fields = { worksheet_feed_url: worksheet_feed_url }
+      fields = { spreadsheet_id: spreadsheet.id, gid: gid }
       fields[:title] = @title if @title
       format(
         "\#<%p %s>",
@@ -526,39 +545,170 @@ module GoogleDrive
       )
     end
 
-    private
+    # Merges a range of cells together. "MERGE_COLUMNS" is another option for merge_type
+    def merge_cells(top_row, left_col, num_rows, num_cols, merge_type: 'MERGE_ALL')
+      range = v4_range_object(top_row, left_col, num_rows, num_cols)
+      add_request({
+        merge_cells:
+          Google::Apis::SheetsV4::MergeCellsRequest.new(
+            range: range, merge_type: merge_type),
+      })
+    end
+
+    # Changes the formatting of a range of cells to match the given number format.
+    # For example to change A1 to a percentage with 1 decimal point:
+    #   worksheet.set_number_format(1, 1, 1, 1, "##.#%")
+    # Google API reference: https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets#numberformat
+    def set_number_format(top_row, left_col, num_rows, num_cols, pattern, type: "NUMBER")
+      number_format = Google::Apis::SheetsV4::NumberFormat.new(type: type, pattern: pattern)
+      format = Google::Apis::SheetsV4::CellFormat.new(number_format: number_format)
+      fields = 'userEnteredFormat(numberFormat)'
+      format_cells(top_row, left_col, num_rows, num_cols, format, fields)
+    end
+
+    # Changes text alignment of a range of cells.
+    # Horizontal alignment can be "LEFT", "CENTER", or "RIGHT".
+    # Vertical alignment can be "TOP", "MIDDLE", or "BOTTOM".
+    # Google API reference: https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets#HorizontalAlign
+    def set_text_alignment(
+        top_row, left_col, num_rows, num_cols,
+        horizontal: nil, vertical: nil)
+      return if horizontal.nil? && vertical.nil?
+
+      format = Google::Apis::SheetsV4::CellFormat.new(
+        horizontal_alignment: horizontal, vertical_alignment: vertical)
+      subfields =
+        (horizontal.nil? ? [] : ['horizontalAlignment']) +
+        (vertical.nil? ? [] : ['verticalAlignment'])
+
+      fields = 'userEnteredFormat(%s)' % subfields.join(',')
+      format_cells(top_row, left_col, num_rows, num_cols, format, fields)
+    end
+
+    # Changes the background color on a range of cells. e.g.:
+    #   worksheet.set_background_color(1, 1, 1, 1, GoogleDrive::Worksheet::Colors::DARK_YELLOW_1)
+    #
+    # background_color is an instance of Google::Apis::SheetsV4::Color.
+    def set_background_color(top_row, left_col, num_rows, num_cols, background_color)
+      format = Google::Apis::SheetsV4::CellFormat.new(background_color: background_color)
+      fields = 'userEnteredFormat(backgroundColor)'
+      format_cells(top_row, left_col, num_rows, num_cols, format, fields)
+    end
+
+    # Change the text formatting on a range of cells. e.g., To set cell
+    # A1 to have red text that is bold and italic:
+    #   worksheet.set_text_format(
+    #     1, 1, 1, 1,
+    #     bold: true,
+    #     italic: true,
+    #     foreground_color: GoogleDrive::Worksheet::Colors::RED_BERRY)
+    #
+    # foreground_color is an instance of Google::Apis::SheetsV4::Color.
+    # Google API reference:
+    # https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets#textformat
+    def set_text_format(top_row, left_col, num_rows, num_cols, bold: false,
+                          italic: false, strikethrough: false, font_size: nil,
+                          font_family: nil, foreground_color: nil)
+      text_format = Google::Apis::SheetsV4::TextFormat.new(
+        bold: bold,
+        italic: italic,
+        strikethrough: strikethrough,
+        font_size: font_size,
+        font_family: font_family,
+        foreground_color: foreground_color
+      )
 
-    def set_worksheet_feed_entry(entry)
-      @worksheet_feed_entry = entry
-      @title = entry.css('title').text
-      set_max_values(entry)
-      @updated = Time.parse(entry.css('updated').text)
-      @meta_modified = false
+      format = Google::Apis::SheetsV4::CellFormat.new(text_format: text_format)
+      fields = 'userEnteredFormat(textFormat)'
+      format_cells(top_row, left_col, num_rows, num_cols, format, fields)
+    end
+
+    # Update the border styles for a range of cells.
+    # borders is a Hash of Google::Apis::SheetsV4::Border keyed with the
+    # following symbols: :top, :bottom, :left, :right, :innerHorizontal, :innerVertical
+    # e.g., To set a black double-line on the bottom of A1:
+    #   update_borders(
+    #     1, 1, 1, 1,
+    #     {bottom: Google::Apis::SheetsV4::Border.new(
+    #       style: "DOUBLE", color: GoogleDrive::Worksheet::Colors::BLACK)})
+    def update_borders(top_row, left_col, num_rows, num_cols, borders)
+      request = Google::Apis::SheetsV4::UpdateBordersRequest.new(borders)
+      request.range = v4_range_object(top_row, left_col, num_rows, num_cols)
+      add_request({update_borders: request})
+    end
+
+    # Add an instance of Google::Apis::SheetsV4::Request (or its Hash
+    # equivalent) which will be applied on the next call to the save method.
+    def add_request(request)
+      @v4_requests.push(request)
     end
 
-    def set_max_values(entry)
-      @max_rows = entry.css('gs|rowCount').text.to_i
-      @max_cols = entry.css('gs|colCount').text.to_i
+    # @api private
+    def worksheet_feed_id
+      gid_int = sheet_id
+      xor_val = gid_int > 31578 ? 474 : 31578
+      letter = gid_int > 31578 ? 'o' : ''
+      letter + (gid_int ^ xor_val).to_s(36)
+    end
+
+    private
+
+    def format_cells(top_row, left_col, num_rows, num_cols, format, fields)
+      add_request({
+        repeat_cell:
+          Google::Apis::SheetsV4::RepeatCellRequest.new(
+            range: v4_range_object(top_row, left_col, num_rows, num_cols),
+            cell: Google::Apis::SheetsV4::CellData.new(user_entered_format: format),
+            fields: fields
+          ),
+      })
+    end
+
+    def set_properties(properties)
+      @properties = properties
+      @title = @remote_title = properties.title
+      @index = properties.index
+      if properties.grid_properties.nil?
+        @max_rows = @max_cols = 0
+      else
+        @max_rows = properties.grid_properties.row_count
+        @max_cols = properties.grid_properties.column_count
+      end
+      @meta_modified = false
     end
 
     def reload_cells
-      doc = @session.request(:get, cells_feed_url)
+      response =
+          @session.sheets_service.get_spreadsheet(
+              spreadsheet.id,
+              ranges: "'%s'" % @remote_title,
+              fields: 'sheets.data.rowData.values(formattedValue,userEnteredValue,effectiveValue)'
+          )
+      update_cells_from_api_sheet(response.sheets[0])
+    end
 
-      @num_cols = nil
-      @num_rows = nil
+    def update_cells_from_api_sheet(api_sheet)
+      rows_data = api_sheet.data[0].row_data || []
 
+      @num_rows = rows_data.size
+      @num_cols = 0
       @cells = {}
       @input_values = {}
       @numeric_values = {}
-      doc.css('feed > entry').each do |entry|
-        cell = entry.css('gs|cell')[0]
-        row = cell['row'].to_i
-        col = cell['col'].to_i
-        @cells[[row, col]] = cell.inner_text
-        @input_values[[row, col]] = cell['inputValue'] || cell.inner_text
-        numeric_value = cell['numericValue']
-        @numeric_values[[row, col]] = numeric_value ? numeric_value.to_f : nil
+
+      rows_data.each_with_index do |row_data, r|
+        next if !row_data.values
+        @num_cols = row_data.values.size if row_data.values.size > @num_cols
+        row_data.values.each_with_index do |cell_data, c|
+          k = [r + 1, c + 1]
+          @cells[k] = cell_data.formatted_value || ''
+          @input_values[k] = extended_value_to_str(cell_data.user_entered_value)
+          @numeric_values[k] =
+              cell_data.effective_value && cell_data.effective_value.number_value ?
+                  cell_data.effective_value.number_value.to_f : nil
+        end
       end
+
       @modified.clear
     end
 
@@ -589,12 +739,32 @@ module GoogleDrive
     end
 
     def validate_cell_value(value)
-      if value =~ XML_INVAILD_CHAR_REGEXP
+      if value =~ XML_INVALID_CHAR_REGEXP
         raise(
           ArgumentError,
           format('Contains invalid character %p for XML 1.0: %p', $&, value)
         )
       end
     end
+
+    def v4_range_object(top_row, left_col, num_rows, num_cols)
+      Google::Apis::SheetsV4::GridRange.new(
+        sheet_id: sheet_id,
+        start_row_index: top_row - 1,
+        start_column_index: left_col - 1,
+        end_row_index: top_row + num_rows - 1,
+        end_column_index: left_col + num_cols - 1
+      )
+    end
+
+    def extended_value_to_str(extended_value)
+      return '' if !extended_value
+      value =
+          extended_value.number_value ||
+          extended_value.string_value ||
+          extended_value.bool_value ||
+          extended_value.formula_value
+      value.to_s
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google_drive
 version: !ruby/object:Gem::Version
-  version: 2.1.12
+  version: 3.0.7
 platform: ruby
 authors:
 - Hiroshi Ichikawa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-10 00:00:00.000000000 Z
+date: 2021-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -31,25 +31,45 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.0.0
 - !ruby/object:Gem::Dependency
-  name: google-api-client
+  name: google-apis-drive_v3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 0.5.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 0.5.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: google-apis-sheets_v4
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: googleauth
   requirement: !ruby/object:Gem::Requirement
@@ -168,8 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: A library to read/write files/spreadsheets in Google Drive/Docs.