google_drive2 3.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4abb83f41fbf856832cb27e8fbdb51f11ef889111f1270486b71f26a0621fb05
+  data.tar.gz: 6143e95fd466821eae41bb017b8e119cd901fe7992de05470fab4ddd871f3ab9
+SHA512:
+  metadata.gz: 2dcc26743a2a00658af5b8d38c9172e09af0b63c1ddbc8c32171f52f5a0f85438dc08961234365f3529d2ca92ec0a3cbbbd7b763e0e331cd8b787d51db85a64a
+  data.tar.gz: 1f7e58c9bde943005f1c4b4c9a7da9589dadeeeab533f85f25253ea041a65e799ee2350c35290e0750ce9d738e9163a664865d589ea3625daddbf4c5b4fb476e

data/README.md

@@ -0,0 +1,136 @@
+# google-drive-ruby [![Build Status](https://travis-ci.org/gimite/google-drive-ruby.svg?branch=master)](https://travis-ci.org/gimite/google-drive-ruby)
+
+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. 2.x.x or before](#migration)
+* [How to install](#install)
+* [How to use](#use)
+* [API documentation](http://www.rubydoc.info/gems/google_drive)
+* [Authorization](https://github.com/gimite/google-drive-ruby/blob/master/doc/authorization.md)
+* [Github](http://github.com/gimite/google-drive-ruby)
+* [License](#license)
+* [Supported environments](#environments)
+* [Author](#author)
+
+
+## <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).
+
+
+## <a name="install">How to install</a>
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'google_drive'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install google_drive
+```
+
+If you need system wide installation, execute below:
+
+```
+$ sudo gem install google_drive
+```
+
+## <a name="use">How to use</a>
+
+### Authorization
+
+Follow one of the options in [Authorization](https://github.com/gimite/google-drive-ruby/blob/master/doc/authorization.md) to construct a session object. The example code below assumes "On behalf of you" option.
+
+### Example to read/write files in Google Drive
+
+```ruby
+require "google_drive"
+
+# Creates a session. This will prompt the credential via command line for the
+# first time and save it to config.json file for later usages.
+# See this document to learn how to create config.json:
+# https://github.com/gimite/google-drive-ruby/blob/master/doc/authorization.md
+session = GoogleDrive::Session.from_config("config.json")
+
+# Gets list of remote files.
+session.files.each do |file|
+  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
+
+```ruby
+require "google_drive"
+
+# Creates a session. This will prompt the credential via command line for the
+# first time and save it to config.json file for later usages.
+# See this document to learn how to create config.json:
+# https://github.com/gimite/google-drive-ruby/blob/master/doc/authorization.md
+session = GoogleDrive::Session.from_config("config.json")
+
+# First worksheet of
+# https://docs.google.com/spreadsheet/ccc?key=pz7XtlQC-PYx-jrVMJErTcg
+# Or https://docs.google.com/a/someone.com/spreadsheets/d/pz7XtlQC-PYx-jrVMJErTcg/edit?usp=drive_web
+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.
+(1..ws.num_rows).each do |row|
+  (1..ws.num_cols).each do |col|
+    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
+```
+
+
+## <a name="license">License</a>
+
+New BSD Licence.
+
+
+## <a name="environments">Supported environments</a>
+
+Ruby 2.0.0 or later. Checked with Ruby 2.4.1.
+
+
+## <a name="author">Author</a>
+
+[Hiroshi Ichikawa](http://gimite.net/en/index.php?Contact)

data/lib/google_drive/access_token_credentials.rb

@@ -0,0 +1,19 @@
+module GoogleDrive
+  # A simple credentials class using an existing OAuth2 access_token.
+  #
+  # Based on:
+  # https://github.com/google/google-api-ruby-client/issues/296
+  #
+  # @api private
+  class AccessTokenCredentials
+    attr_reader :access_token
+
+    def initialize(access_token)
+      @access_token = access_token
+    end
+
+    def apply!(headers)
+      headers['Authorization'] = "Bearer #{@access_token}"
+    end
+  end
+end

data/lib/google_drive/acl.rb

@@ -0,0 +1,111 @@
+# 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)
+    include(Enumerable)
+    extend(Forwardable)
+
+    # @api private
+    def initialize(session, file)
+      @session = session
+      @file = file
+      api_permissions = @session.drive_service.list_permissions(
+        @file.id, fields: '*', supports_all_drives: true
+      )
+      @entries =
+        api_permissions.permissions.map { |perm| AclEntry.new(perm, self) }
+    end
+
+    def_delegators(:@entries, :size, :[], :each)
+
+    # Adds a new entry. +entry+ is either a GoogleDrive::AclEntry or a Hash with
+    # keys +:type+, +:email_address+, +:domain+, +:role+ and
+    # +:allow_file_discovery+. See GoogleDrive::AclEntry#type and
+    # GoogleDrive::AclEntry#role for the document of the fields.
+    #
+    # Also you can pass the second hash argument +options+, which specifies
+    # optional query parameters for the API.
+    # Possible keys of +options+ are,
+    # * :email_message  -- A custom message to include in notification emails
+    # * :send_notification_email  -- Whether to send notification emails
+    #   when sharing to users or groups. (Default: true)
+    # * :transfer_ownership  -- Whether to transfer ownership to the specified
+    #   user and downgrade the current owner to a writer. This parameter is
+    #   required as an acknowledgement of the side effect. (Default: false)
+    #
+    # e.g.
+    #   # A specific user can read or write.
+    #   spreadsheet.acl.push(
+    #       {type: "user", email_address: "example2@gmail.com", role: "reader"})
+    #   spreadsheet.acl.push(
+    #       {type: "user", email_address: "example3@gmail.com", role: "writer"})
+    #   # Share with a Google Apps domain.
+    #   spreadsheet.acl.push(
+    #       {type: "domain", domain: "gimite.net", role: "reader"})
+    #   # Publish on the Web.
+    #   spreadsheet.acl.push(
+    #       {type: "anyone", role: "reader"})
+    #   # Anyone who knows the link can read.
+    #   spreadsheet.acl.push(
+    #       {type: "anyone", allow_file_discovery: false, role: "reader"})
+    #   # Set ACL without sending notification emails
+    #   spreadsheet.acl.push(
+    #       {type: "user", email_address: "example2@gmail.com", role: "reader"},
+    #       {send_notification_email: false})
+    #
+    # See here for parameter detais:
+    # https://developers.google.com/drive/v3/reference/permissions/create
+    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_service.create_permission(
+        @file.id,
+        entry.params,
+        **{ fields: '*', supports_all_drives: true }.merge(options)
+      )
+      new_entry = AclEntry.new(api_permission, self)
+      @entries.push(new_entry)
+      new_entry
+    end
+
+    # Deletes an ACL entry.
+    #
+    # e.g.
+    #   spreadsheet.acl.delete(spreadsheet.acl[1])
+    def delete(entry)
+      @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_service.update_permission(
+        @file.id,
+        entry.id,
+        { role: entry.role },
+        fields: '*',
+        supports_all_drives: true
+      )
+      entry.api_permission = api_permission
+      entry
+    end
+
+    def inspect
+      format("\#<%p %p>", self.class, @entries)
+    end
+  end
+end

data/lib/google_drive/acl_entry.rb

@@ -0,0 +1,181 @@
+# 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)
+
+    # +params_or_api_permission+ is a Hash object with keys
+    # +:type+, +:email_address+, +:domain+, +:role+ and +:allow_file_discovery+.
+    # See GoogleDrive::Acl#push for description of the parameters.
+    def initialize(params_or_api_permission, acl = nil)
+      @acl = acl
+      if acl
+        @api_permission = params_or_api_permission
+        @params = nil
+        delegate_api_methods(self, @api_permission)
+      else
+        @api_permission = nil
+        @params = convert_params(params_or_api_permission)
+      end
+    end
+
+    attr_reader(:acl)
+
+    # @api private
+    attr_reader(:params)
+
+    # @api private
+    attr_accessor(:api_permission)
+
+    # The role given to the scope. One of:
+    # - "owner": The owner.
+    # - "writer": With read/write access.
+    # - "reader": With read-only access.
+    def role
+      @params ? @params[:role] : @api_permission.role
+    end
+
+    # Type of the scope. One of:
+    #
+    # - "user": a Google account specified by the email_address field.
+    # - "group": a Google Group specified by the email_address field.
+    # - "domain": a Google Apps domain specified by the domain field.
+    # - "anyone": Publicly shared with all users.
+    def type
+      @params ? @params[:type] : @api_permission.type
+    end
+
+    alias scope_type type
+
+    def additional_roles
+      @params ? @params[:additionalRoles] : @api_permission.additional_roles
+    end
+
+    def id
+      @params ? @params[:id] : @api_permission.id
+    end
+
+    # Email address of the user or the group.
+    def email_address
+      @params ? @params[:email_address] : @api_permission.email_address
+    end
+
+    # The Google Apps domain name.
+    def domain
+      @params ? @params[:domain] : @api_permission.domain
+    end
+
+    def value
+      if @params
+        case @params[:type]
+        when 'user', 'group'
+          @params[:email_address]
+        when 'domain'
+          @params[:domain]
+        end
+      else
+        case @api_permission.type
+        when 'user', 'group'
+          @api_permission.email_address
+        when 'domain'
+          @api_permission.domain
+        end
+      end
+    end
+
+    alias scope value
+
+    # If +false+, the file is shared only with people who know the link.
+    # Only used for type "anyone".
+    def allow_file_discovery
+      @params ?
+        @params[:allow_file_discovery] : @api_permission.allow_file_discovery
+    end
+
+    # If +true+, the file is shared only with people who know the link.
+    # Only used for type "anyone".
+    def with_link
+      allow_file_discovery == false
+    end
+
+    alias with_key with_link
+
+    # Changes the role of the scope.
+    #
+    # e.g.
+    #   spreadsheet.acl[1].role = "writer"
+    def role=(role)
+      if @params
+        @params[:role] = role
+      else
+        @api_permission.role = role
+        @acl.update_role(self)
+      end
+    end
+
+    def inspect
+      case type
+      when 'user', 'group'
+        format(
+          "\#<%p type=%p, email_address=%p, role=%p>",
+          self.class, type, email_address, role
+        )
+      when 'domain'
+        format(
+          "\#<%p type=%p, domain=%p, role=%p>",
+          self.class, type, domain, role
+        )
+      when 'anyone'
+        format(
+          "\#<%p type=%p, role=%p, allow_file_discovery=%p>",
+          self.class, type, role, allow_file_discovery
+        )
+      else
+        format("\#<%p type=%p, role=%p>", self.class, type, role)
+      end
+    end
+
+    private
+
+    # Normalizes the key to Symbol, and converts parameters in the old version.
+    def convert_params(orig_params)
+      new_params = {}
+      value = nil
+      orig_params.each do |k, v|
+        k = k.to_s
+        case k
+        when 'scope_type'
+          new_params[:type] = (v == 'default' ? 'anyone' : v)
+        when 'scope'
+          new_params[:value] = v
+        when 'with_key', 'withLink'
+          new_params[:allow_file_discovery] = !v
+        when 'value'
+          value = v
+        else
+          new_params[k.intern] = v
+        end
+      end
+
+      if value
+        case new_params[:type]
+        when 'user', 'group'
+          new_params[:email_address] = value
+        when 'domain'
+          new_params[:domain] = value
+        end
+      end
+
+      new_params
+    end
+  end
+end

data/lib/google_drive/api_client_fetcher.rb

@@ -0,0 +1,59 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require 'net/https'
+require 'uri'
+require 'google/apis/drive_v3'
+require 'google/apis/sheets_v4'
+Net::HTTP.version_1_2
+
+module GoogleDrive
+  class ApiClientFetcher
+    class Response
+      def initialize(code, body)
+        @code = code
+        @body = body
+      end
+
+      attr_reader(:code, :body)
+    end
+
+    def initialize(authorization, client_options, request_options)
+      @drive = Google::Apis::DriveV3::DriveService.new
+      @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
+
+        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)
+      body = @drive.http(method, url, body: data, options: options)
+      Response.new('200', body)
+    end
+  end
+end

data/lib/google_drive/authentication_error.rb

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