googledrive-easy 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2e510a7a4388feec9cbfffcbf6095e2b90f73cd882b81558014b9bc9147d4ed
-  data.tar.gz: 5940d24cf857bd29da87277dfcf0135a47890b3d37b087eddc5cbeb19084c464
+  metadata.gz: 1111117a9dac04b800a1429cd0ce2a7bae5cdeb04b2ea29c9d7333c40a1306a7
+  data.tar.gz: 518fc4f98597d3a51dcbfbe10c613c979674bde30af6d6cae4c8b2a1094f57bb
 SHA512:
-  metadata.gz: 2f934c27d0bc9014b1f8f514e036bcfe2e22355a3e4125a11aaa287cfbec935fdef49eae7372ef18e11f76765dbb22e7b95ac466e2f432647459b7d0e8441bae
-  data.tar.gz: b5bf2997933c7e475e8f5d254a49ed029c52ec910b9653042f59661dccd6516bb4419962a35582b466b646da1aad4c4cea2c43e637e696d2048152b0641cf577
+  metadata.gz: d89f2d745dc6d890f811eb86f9067a4c236e3b074c07a61a5ac4c8e238ffccf72677adc34b5b76c31a7dc23c45a9f61ab9c369c675f018e33e6fe942736c487e
+  data.tar.gz: 0b15a348a056d7e102f7c8e948957b12ad7ecf57098e0484dd02b5212bbeda408484dde604f3fb43f81d674692c5a78c1e2cf9851ea7b2da5bd6fbf856270763

data/bin/googledrive

@@ -1,46 +1,91 @@
 #!/usr/bin/env ruby
+require 'optparse'
+require 'logger'
+# Attempt relative import first, for development/debugging purposes.
+begin
+  require_relative '../lib/googledrive-easy'
+rescue
+  require 'googledrive-easy'
+end
 
-require 'googledrive-easy'
+options = {
+  :persist=>false,
+  :file=>nil
+}
+OptionParser.new do |opts|
+  opts.banner = "Usage: googledrive [options]"
 
-if ARGV[0] == "gen_url"
-  if ARGV.length != 2
-    puts "gen_url requires to pass client_id as a parameter"
-    exit -1
+  opts.on("-l", "--loopback-auth", "Complete Oauth via loopback interface (may require interaction)") { |v| options[:authmode] = 'loopback'}
+  opts.on("-i", "--input-auth", "Complete Oauth via copy-paste interface (may require interaction)") { |v| options[:authmode] = 'input'}
+  opts.on("-e", "--environment-config", "Configure Oauth via environment vars. Does nothing here, unless --persist is also passed. (headless)") { |v| options[:authmode] = 'environment'}
+  opts.on("-f", "--file-config FILEPATH", "Configure Oauth via file. Persists to (#{DRIVE_ENV_FILE}). Requires  (headless)") do |v|
+    options[:authmode] = 'file'
+    options[:file] = v
   end
 
-  client_id = ARGV[1]
+  opts.on("-p", "--persist", "After completing Oauth or loading existing values, persist to environment file (#{DRIVE_ENV_FILE}) for future use.") { |v| options[:persist] = true}
+  opts.on("-c", "--cli-config", "Configure Oauth via passed values. requires --secret, --id, and --refresh. Always persists to environment file. (headless)") { |v| options[:authmode] = 'cli'}
+
+  opts.on("--id CLIENT_ID", String, "Google Client ID for CLI config mode") { |v| options[:id] = v}
+  opts.on("--secret CLIENT_SECRET", String, "Google Client Secret for CLI config mode") { |v| options[:secret] = v}
+  opts.on("--refresh REFRESH_TOKEN", String, "Google Refresh Token for CLI config mode") { |v| options[:refresh] = v}
+end.parse!
+
+# Checks
+unless options[:authmode]
+  puts("An auth mode must be chosen. Check `googledrive --help` for details")
+  exit 1
+end
+
+def print_hash_for_env_use(keys)
+  puts <<~TEXT
+    #{ENV_KEYS[:id]}='#{keys["client_id"]}'
+    #{ENV_KEYS[:secret]}='#{keys["client_secret"]}'
+    #{ENV_KEYS[:refresh]}='#{keys["refresh_token"]}'
+  TEXT
+end
 
-  puts "Access Code must be generated by going to the following URL:"
-  puts
-  puts GoogleDrive.generate_access_code_url(client_id)
-  puts
-  puts "This will create an access token."
-  puts
-  
-  exit 0
-  
-elsif ARGV[0] == "gen_refresh_token"
+def handle_auth(options)
+  drive = GoogleDrive::new(raise_error: false, loglevel: Logger::ERROR)
 
-  client_id = ARGV[1]
-  client_secret = ARGV[2]
-  access_code = ARGV[3]
+  # Handle special service mode cases
+  case options[:authmode]
 
-  refresh_token = GoogleDrive.generate_refresh_token(client_id, client_secret, access_code)
+  when "file"
+    drive.load_api_keys_from_file(options[:file])
+    options[:persist] = true
+    service_mode="manual"
+
+  when "cli"
+    unless options[:id] && options[:secret] && options[:refresh]
+      puts "--id, --secret, and --refresh must be provided for CLI mode"
+      exit 1
+    end
+    options[:persist] = true
+    drive.set_api_keys(
+      client_id: options[:id],
+      client_secret: options[:secret],
+      refresh_token: options[:refresh],
+    )
+    service_mode = "manual"
+
+  else
+    service_mode = options[:authmode]
+  end
+
+  unless drive.create_service(mode: service_mode)
+    puts "Failure creating drive service. See above for details."
+    exit 1
+  end
 
-  if refresh_token == false
-    puts "\nError creating refresh token.\n"
-    exit -1
+  print_hash_for_env_use(drive.dump_keys)
+  if options[:persist]
+    if drive.generate_env_file
+      puts "Configuration persisted to #{drive.instance_variable_get(:@api_key_file)}"
+    else
+      puts "Error persisting environment to #{drive.instance_variable_get(:@api_key_file)}"
+    end
   end
-  puts "\nRefresh Token: #{refresh_token}\n\n"
-
-  exit 0
-elsif ARGV[0] == "?" || ARGV[0] == "-?" || ARGV[0] == "-help"
-  puts "googledrive gen_url <client_id>"
-  puts "googledrive gen_refresh_token <client_id> <client_secret> <access_code>"
-  puts 
-  exit 0
-else
-  puts "Invalid argument #{ARGV[0]}"
-  exit -1
 end
 
+handle_auth(options)

data/lib/googledrive-easy-test.rb

@@ -0,0 +1,223 @@
+require "test/unit"
+require 'json'
+require 'google/apis/drive_v3'
+require_relative './googledrive-easy'
+
+class GoogleDriveEasyTest < Test::Unit::TestCase
+
+  def configure_environment
+    ENV['DRIVEAPI_CLIENT_ID'] = @client_id
+    ENV['DRIVEAPI_CLIENT_SECRET'] = @client_secret
+    ENV['DRIVEAPI_REFRESH_TOKEN'] = @refresh_token
+  end
+
+  def deconfigure_environment
+    vars = %w(DRIVEAPI_CLIENT_ID DRIVEAPI_CLIENT_SECRET DRIVEAPI_REFRESH_TOKEN)
+    vars.each do |v|
+      ENV.delete(v)
+    end
+  end
+
+  def configure_env_file
+    # Write temp json file to load from for test
+    @env_file = Tempfile.new("api_var_file")
+    @env_file.write(JSON.generate({
+                                    "CLIENT_ID": @client_id,
+                                    "REFRESH_TOKEN": @refresh_token,
+                                    "CLIENT_SECRET": @client_secret,
+                                  }))
+    @env_file.flush
+    return @env_file
+  end
+
+  def deconfigure_env_file
+    @env_file.delete
+  end
+
+  def setup
+    # Unset env variables before each test to keep things predictable
+    deconfigure_environment
+
+    # Used to omit tests that require real drive connectivity.
+    @test_env_vars_defined = (ENV['TEST_CLIENT_ID'] && ENV['TEST_CLIENT_SECRET'] && ENV['TEST_CLIENT_SECRET'])
+
+    # Init
+    @client_id = ENV['TEST_CLIENT_ID'] || 'test-id'
+    @client_secret = ENV['TEST_CLIENT_SECRET'] || 'test-secret'
+    @refresh_token = ENV['TEST_REFRESH_TOKEN'] || 'test-token'
+    @access_token = nil
+
+    @drive = GoogleDrive::new
+    @drive.instance_variable_set(:@api_key_file, "/tmp/test_drive_api_keys.json")
+  end
+
+  #######################
+  # Loading tests       #
+  #######################
+  def test_loading_api_vars_from_env_success
+    configure_environment
+
+    result = @drive.load_api_keys_from_env
+    assert(result, "load_api_keys_from_env should return true")
+    assert_equal(@client_id, @drive.instance_variable_get(:@client_id), "Client ID should be loaded")
+    assert_equal(@client_secret, @drive.instance_variable_get(:@client_secret), "Client Secret should be loaded")
+    assert_equal(@refresh_token, @drive.instance_variable_get(:@refresh_token), "Refresh Token should be loaded")
+  end
+
+  def test_loading_api_vars_from_env_missing_fail
+    ENV['DRIVEAPI_CLIENT_ID'] = @client_id
+    ENV.delete('DRIVEAPI_CLIENT_SECRET')
+    ENV['DRIVEAPI_REFRESH_TOKEN'] = @refresh_token
+
+    result = @drive.load_api_keys_from_env
+    assert(!result, "load_api_keys_from_env should return false")
+    assert_equal(nil, @drive.instance_variable_get(:@client_id), "Client ID should not be loaded")
+    assert_equal(nil, @drive.instance_variable_get(:@client_secret), "Client Secret should not be loaded")
+    assert_equal(nil, @drive.instance_variable_get(:@refresh_token), "Refresh Token should not be loaded")
+  end
+
+  def test_loading_api_vars_from_file_success
+    # Write temp json file to load from for test
+    configure_env_file
+
+    # Override default key file
+    # @drive.instance_variable_set(:@api_key_file, @env_file.path)
+
+    # Attempt load
+    result = @drive.load_api_keys_from_file(path:@env_file.path)
+    assert(result, "load_api_keys_from_file should return true")
+    assert_equal(@client_id, @drive.instance_variable_get(:@client_id), "Client ID should be loaded")
+    assert_equal(@client_secret, @drive.instance_variable_get(:@client_secret), "Client Secret should be loaded")
+    assert_equal(@refresh_token, @drive.instance_variable_get(:@refresh_token), "Refresh Token should be loaded")
+  end
+
+  def test_loading_api_vars_from_file_not_found
+    # Override default key file
+    @drive.instance_variable_set(:@api_key_file, '/tmp/bogons')
+
+    # Attempt load
+    result = @drive.load_api_keys_from_file
+    assert(!result, "load_api_keys_from_file should return false")
+    assert_equal(nil, @drive.instance_variable_get(:@client_id), "Client ID should be loaded")
+    assert_equal(nil, @drive.instance_variable_get(:@client_secret), "Client Secret should be loaded")
+    assert_equal(nil, @drive.instance_variable_get(:@refresh_token), "Refresh Token should be loaded")
+  end
+
+  ###########################
+  # Object generation tests #
+  ###########################
+
+  def test_generate_api_secret_hash
+    @drive.instance_variable_set(:@client_id, @client_id)
+    @drive.instance_variable_set(:@client_secret, @client_secret)
+
+    api_hash = @drive.generate_api_secret_hash
+    assert_equal(@client_id, api_hash['installed']['client_id'], 'Hash should contain client id')
+    assert_equal(@client_secret, api_hash['installed']['client_secret'], 'Hash should contain client secret')
+  end
+
+  def test_generate_token_yaml_success
+    # TODO: Test feels partial/fragile. Improve?
+    # Partially Configure object
+    @drive.instance_variable_set(:@client_id, @client_id)
+    @drive.instance_variable_set(:@refresh_token, @refresh_token)
+    token_file_user = @drive.instance_variable_get(:@token_file_user)
+
+    yaml_string = @drive.generate_token_yaml
+    assert(yaml_string.include?(token_file_user), "Result should contain token_file_user")
+    assert(yaml_string.include?(@client_id), "Result should contain client_id")
+    assert(yaml_string.include?(@refresh_token), "Result should contain refresh_token")
+
+  end
+
+  def test_generate_token_yaml_fail
+    # Partially Configure object
+    # @drive_wrapper.instance_variable_set(:@client_id, @client_id)
+    @drive.instance_variable_set(:@refresh_token, @refresh_token)
+    assert(!@drive.generate_token_yaml, "Generation of token yaml should fail with partial config")
+  end
+
+  def test_generate_temp_token_file
+    # Partially Configure object
+    @drive.instance_variable_set(:@client_id, @client_id)
+    @drive.instance_variable_set(:@refresh_token, @refresh_token)
+    token_file_user = @drive.instance_variable_get(:@token_file_user)
+
+    tmp_file_path = @drive.generate_temp_token_file
+    tmp_file_contents = File.read(tmp_file_path)
+    assert(tmp_file_contents.include?(token_file_user), "Result should contain token_file_user")
+    assert(tmp_file_contents.include?(@client_id), "Result should contain client_id")
+    assert(tmp_file_contents.include?(@refresh_token), "Result should contain refresh_token")
+  end
+
+  #########################################
+  # Auth tests (Require real credentials) #
+  #########################################
+
+  def test_create_service_environment_file
+    omit("Test Environment not correctly configured for live tests") unless @test_env_vars_defined
+    configure_env_file
+
+    # Load environment
+    # Use this, or just set the path directly.
+    @drive.load_api_keys_from_file(path:@env_file.path)
+
+    # Authorize
+    result = @drive.create_service(mode: 'manual')
+    assert(result, "Authorization from configured environment should succeed.")
+    assert(@drive.instance_variable_get(:@credentials), "Credentials should be set")
+    assert_instance_of(Google::Apis::DriveV3::DriveService, result, "Should return instance of Google Drive Service")
+  end
+
+  def test_create_service_environment
+    omit("Test Environment not correctly configured for live tests") unless @test_env_vars_defined
+    configure_environment
+
+    # Authorize
+    result = @drive.create_service(mode: 'environment')
+    assert(result, "Authorization from configured environment should succeed.")
+    assert(@drive.instance_variable_get(:@credentials), "Credentials should be set")
+    puts @drive.instance_variable_get(:@credentials)
+    assert_instance_of(Google::Apis::DriveV3::DriveService, result, "Should return instance of Google Drive Service")
+  end
+
+  def test_create_service_manual
+    omit("Test Environment not correctly configured for live tests") unless @test_env_vars_defined
+    @drive.set_api_keys(client_id: @client_id, client_secret: @client_secret, refresh_token: @refresh_token)
+
+    # Authorize
+    result = @drive.create_service(mode: 'manual')
+    assert(result, "Authorization from manual configuration should succeed.")
+    assert(@drive.instance_variable_get(:@credentials), "Credentials should be set")
+    assert_instance_of(Google::Apis::DriveV3::DriveService, result, "Should return instance of Google Drive Service")
+  end
+
+  ###########################################
+  # Action tests (Require real credentials) #
+  ###########################################
+
+  # def test_list_all_files
+  #   configure_environment
+  #   @drive_wrapper.create_service(mode:'environment')
+  #   p @drive_wrapper.list_all_files(query:'*')
+  # end
+
+  # No great way to unit test the following:
+  # get_oauth_credentials_via_loopback
+  # get_oauth_credentials_via_input
+  # find_directory_id
+  # download_file
+  # upload_file
+  # list_files
+
+  def test_get_all_files
+    omit("Test Environment not correctly configured for live tests") unless @test_env_vars_defined
+    # configure_environment
+
+    @drive.set_api_keys(client_id: @client_id, client_secret: @client_secret, refresh_token: @refresh_token)
+    @drive.create_service(mode:'manual')
+    res = @drive.get_all_files(name: "rxgos*")
+    assert_instance_of(Array, res, "Returns list")
+  end
+
+end

data/lib/googledrive-easy.rb

@@ -1,238 +1,436 @@
 require 'json'
-require 'httparty'
 require 'tempfile'
+require 'google/apis/drive_v3'
+require 'googleauth'
+require 'googleauth/stores/file_token_store'
+require 'highline'
+require 'logger'
+
+require_relative './utilities'
+require_relative './googledrive/wildcard'
+
+ENV_KEYS = {
+  :id => "DRIVEAPI_CLIENT_ID",
+  :secret => "DRIVEAPI_CLIENT_SECRET",
+  :refresh => "DRIVEAPI_REFRESH_TOKEN"
+}
+DRIVE_ENV_FILE = "#{Dir.home}/.drive_api_keys.json"
 
-require_relative 'googledrive/wildcard'
-#require 'googledrive/wildcard'
 
 class GoogleDrive
+  # TODO: Test the upload, download, list methods. Write tests for them.
+  # TODO: Test using the gem in another program.
+
+  def initialize(raise_error: false, loglevel: Logger::ERROR )
+    # Config
+    @raise_error = raise_error
+    @file_fields = "id,kind,mime_type,name,md5Checksum,size,parents"
+    @md5_command = 'md5 -q' # Needs to output only the sum, no filename or header info.
+
+    # Init and configure logger.
+    # TODO: Make this smarter/respect global loggers.
+    @logger = Logger.new(STDOUT)
+    @logger.level = loglevel
+    @logger.formatter = proc do |severity, datetime, progname, msg|
+      date_format = datetime.strftime("%Y-%m-%d %H:%M:%S")
+      "[%s] %-5s (%s): %s\n" % [date_format, severity, self.class.name, msg ]
+    end
 
-  def initialize(raise_error = false)
+    # Critical File Paths
+    @api_key_file = DRIVE_ENV_FILE
+    @loaded_api_key_file = @api_key_file
+    @drive_secret_path = "#{Dir.home}/.googledrive-secret.json" # Should contain Oauth2 data exactly as provided by GCloud Console
+    @drive_token_path = "#{Dir.home}/.googledrive-token.yaml"    # Created by script to hold the token store
+
+    # Oauth Config
+    @drive_scope = 'https://www.googleapis.com/auth/drive'
+    @auth_url_path = '/'
+    @oauth_address = 'localhost' # Should be `localhost`, `127.0.0.1`, or `[::1]`
+    @oauth_port = 8181 # Pick anything outside the privileged range [1-1023] to avoid running SSH as root.
+    @oauth_loopback_base_url = "http://#{@oauth_address}:#{@oauth_port}"
+
+    # Client vars
+    @token_file_user = 'cliuser'  # The user to store credentials as in the token file
     @client_id     = nil
     @client_secret = nil
     @refresh_token = nil
-
     @access_token = nil
+    @expiration = 1665718429000
 
-    @raise_error = raise_error
+    # Core runtime vars
+    @drive_service = nil
+    @authorizer = nil
+    @credentials = nil
   end
 
+  def print_config_hints
+    puts <<~TEXT.chomp
+      To run in headless modes (environment or file configuration), you must provide either:
+      * A json file at #{@api_key_file} containing the following structure:
+      {
+        "CLIENT_ID": "your Google Cloud Oauth client ID",
+        "CLIENT_SECRET": "your Google Cloud Oauth client secret",
+        "REFRESH_TOKEN": "A valid refresh token from a prior Oauth completion with the ID and SECRET",
+      }
 
-  def self.generate_access_code_url(client_id)
-    scope = "https://www.googleapis.com/auth/drive"
-
-    return "https://accounts.google.com/o/oauth2/auth?scope=#{scope}&redirect_uri=urn:ietf:wg:oauth:2.0:oob&response_type=code&client_id=#{client_id}"
+      * The following environment variables:
+        #{ENV_KEYS[:id]}='your Google Cloud Oauth client ID'
+        #{ENV_KEYS[:secret]}='your Google Cloud Oauth client secret'
+        #{ENV_KEYS[:refresh]}='A valid refresh token from a prior Oauth completion with the ID and SECRET'
+    
+      For the interactive auth modes (loopback or input) you can omit the refresh token from either of the above.
+      If you later switch to a headless mode, you will need to add the refresh token.
+    TEXT
   end
 
-  def self.generate_refresh_token(client_id, client_secret, access_code)
-    options = {
-      body: {
-        client_id: client_id,
-        client_secret: client_secret,
-        code: access_code,
-        redirect_uri: 'urn:ietf:wg:oauth:2.0:oob',
-        grant_type: 'authorization_code'
-      },
-      headers: {
-        'Content-Type' => 'application/x-www-form-urlencoded'
-      }
-    }
-  
-    response = HTTParty.post('https://accounts.google.com/o/oauth2/token', options)
+  def log_error_and_raise(msg)
+    @logger.error(msg)
+    raise "msg" if @raise_error
+  end
 
-    if (response.code == 400) || (response.code == 401)
-      puts "Error: #{response.parsed_response["error"]} : #{response.parsed_response["error_description"]}"
-      return false
-    elsif (response.code != 200) 
-      puts "Non-200 HTTP error code: #{response.code}."
+  def set_api_keys(client_id:nil, client_secret:nil, refresh_token:nil, access_token:nil, require_refresh_token:true)
+    # Recommended service mode if manually called: manual
+    unless client_id && client_secret && (refresh_token || !require_refresh_token)
+      log_error_and_raise("Not all tokens provided.")
       return false
     end
+    @client_id     = client_id if client_id
+    @client_secret = client_secret if client_secret
+    @refresh_token = refresh_token if refresh_token
+    @access_token = access_token if access_token
+    return true
+  end
+
+  def load_api_keys_from_file(path:nil, require_refresh_token:true)
+    @loaded_api_key_file = path ? path : @api_key_file
+    if(File.exist?(@loaded_api_key_file))
+      @logger.info("API key file #{@loaded_api_key_file} exists")
+      begin
+        api_hash = JSON.parse(File.read(@loaded_api_key_file))
+      rescue => error
+        log_error_and_raise("Error opening api key file: " + error.inspect)
+        return false
+      end
 
-    # see if error field is present 
-    if response.parsed_response["refresh_token"].nil?
-      puts "refresh_token field not found"
+      @logger.debug("api_hash: " + api_hash.inspect)
+
+      @client_id     = api_hash["CLIENT_ID"]
+      @client_secret = api_hash["CLIENT_SECRET"]
+      @refresh_token = api_hash["REFRESH_TOKEN"]
+
+      if set_api_keys(
+        client_id:api_hash["CLIENT_ID"],
+        client_secret:api_hash["CLIENT_SECRET"],
+        refresh_token:api_hash["REFRESH_TOKEN"],
+        require_refresh_token:require_refresh_token
+      )
+        @logger.info("Using Google Drive API information from #{@loaded_api_key_file}")
+      else
+        log_error_and_raise("Not all API keys were in file #{@loaded_api_key_file}.")
+        return false
+      end
+    else
+      log_error_and_raise("Cannot find #{@loaded_api_key_file}")
       return false
     end
+    true
+  end
 
-    puts "Refresh Token: " + response.parsed_response["refresh_token"]
-    
-    return response.parsed_response["refresh_token"]
-
-    # Possible return values
-    # {"error"=>"invalid_client", "error_description"=>"The OAuth client was not found."}
-    # {"error"=>"invalid_grant", "error_description"=>"Malformed auth code."}
-    # {"access_token"=>"XXXXXXX", "expires_in"=>3599, "refresh_token"=>"YYYYYY", "scope"=>"https://www.googleapis.com/auth/drive", "token_type"=>"Bearer"}
-  end  
+  def load_api_keys_from_env(require_refresh_token:true)
+    # Google Drive Credentials from ENV if not derived from JSON file in home.
+    vars = [ENV_KEYS[:id], ENV_KEYS[:secret]]
+    vars << ENV_KEYS[:refresh] if require_refresh_token
+    vars.each do |v|
+      if ENV[v].nil?
+        log_error_and_raise("#{v} export variable not set.")
+        return false
+      end
+    end
 
+    # Set
+    return set_api_keys(
+      client_id:ENV[ENV_KEYS[:id]],
+      client_secret:ENV[ENV_KEYS[:secret]],
+      refresh_token:ENV[ENV_KEYS[:refresh]],
+      require_refresh_token:require_refresh_token
+    )
+  end
 
+  def generate_api_secret_hash
+    {
+      "installed" => {
+        "client_id"     => @client_id,
+        "client_secret" => @client_secret,
+        #    "project_id"=>"super-secret-project",
+        #    "auth_uri"=>"https://accounts.google.com/o/oauth2/auth",
+        #    "token_uri"=>"https://oauth2.googleapis.com/token",
+        #    "auth_provider_x509_cert_url"=>"https://www.googleapis.com/oauth2/v1/certs",
+        #    "redirect_uris"=>["http://localhost"]
+      }
+    }
+  end
 
-  # refreh token may be nil if you dont have it yet. 
-  def set_api_keys(client_id, client_secret, refresh_token)
-    @client_id     = client_id
-    @client_secret = client_secret
-    @refresh_token = refresh_token
+  def dump_keys
+    {
+      "client_id"               => @client_id,
+      "client_secret"           => @client_id,
+      "access_token"            => @access_token,
+      "refresh_token"           => @refresh_token,
+    }
+  end
 
-    if !client_id || !client_secret || !refresh_token
-      if @raise_error; raise "Not all tokens provided." end
+  # Generates token yaml
+  def generate_token_yaml
+    unless @client_id && @refresh_token
+      api_config = {"client_id" => @client_id, "refresh_token" => @refresh_token }
+      @logger.debug("API Config: #{api_config}")
+      log_error_and_raise("Some required API config for token hasn't been configured yet")
       return false
     end
 
-    return generate_access_token()
+    drive_token_hash = {
+      "client_id"               => @client_id,
+      "access_token"            => @access_token,
+      "refresh_token"           => @refresh_token,
+      "scope"                   => [@drive_scope],
+      "expiration_time_millis"  => @expiration
+    }
+    return {@token_file_user => drive_token_hash.to_json}.to_hash.to_yaml
   end
 
-  def set_api_keys_from_file(json_api_key_file)
-    if !File.file?(json_api_key_file) # file doesnt exist.
-      if @raise_error; raise "JSON API Key '#{json_api_key_file}' does not exist." end
+  # Generates temp token file and return path to it
+  def generate_temp_token_file
+    tmpfile = Tempfile.new('drive_token')
+    token_yaml = generate_token_yaml
+    unless token_yaml
       return false
     end
+    tmpfile.write(token_yaml)
+    tmpfile.flush # flush file contents before continuing.
+    return @drive_token_path = File.expand_path(tmpfile.path)
+  end
 
-    begin
-      api_hash = JSON.parse(File.read(json_api_key_file))
-    rescue => error
-      if @raise_error; raise "Unable to parse JSON: '" + error.message + "' in file '#{json_api_key_file}'." end
-      return false
+  def generate_env_file(path=@api_key_file)
+    File.open(path,"w") do |f|
+      return f.write({
+                "CLIENT_ID" => @client_id,
+                "CLIENT_SECRET" => @client_secret,
+                "REFRESH_TOKEN" => @refresh_token,
+              }.to_json)
+    end
+  end
+
+  # Sets up a webserver to receive a 'localhost' query for 3-legged OAUTH. Requires that @oauth_port is forwarded
+  # from the machine running the authenticating browser to the machine running this script,
+  # likely via `ssh user@host -L @oauth_port:@oauth_address:@oauth_port`
+  def get_oauth_credentials_via_loopback(authorizer)
+    # TODO: This a raw copy, refactor
+    # Print instructions and URL for user to click
+    # TODO: Should this be puts or @logger? it's a user interaction...
+    puts "Listening on #{@oauth_address}:#{@oauth_port}."
+    puts "If this a remote system, you need to forward this port via SSH Tunneling, if you haven't already."
+    puts("eg: ssh user@host -L#{@oauth_port}:#{@oauth_address}:#{@oauth_port}")
+    puts "After you have done so, follow this link:", authorizer.get_authorization_url(base_url: @oauth_loopback_base_url)
+
+    # Start webserver to listen for response:
+    socket = TCPServer.new(@oauth_address, @oauth_port)
+    loop do
+      client = socket.accept
+      first_line = client.gets
+      verb, path, _ = first_line.split
+
+      if verb == 'GET'
+        if result = path.match(/^\/\?code=(.*)&scope=(.*)/)
+          code = result[1]
+          scope = result[2]
+          response = "HTTP/1.1 200\r\n\r\nAuthorized for scope `#{scope}`! Code is #{code}"
+          client.puts(response)
+          client.close
+          socket.close
+
+          puts "Authorized for scope `#{scope}`! Code is #{code}"
+          # Extract response
+          puts 'Oauth flow complete. You can close the local port forward if desired.'
+          return authorizer.get_and_store_credentials_from_code(
+            user_id: @token_file_user,
+            code: code,
+            base_url: @oauth_loopback_base_url
+          )
+        else
+          # Default response for testing/sanity checks
+          response = "HTTP/1.1 200\r\n\r\nI respond to auth requests."
+          client.puts(response)
+        end
+      end
+      client.close
     end
+    socket.close
+  end
 
-    # expected values in JSON 
-    @client_id     = api_hash["CLIENT_ID"]
-    @client_secret = api_hash["CLIENT_SECRET"]
-    @refresh_token = api_hash["REFRESH_TOKEN"]
+  def get_oauth_credentials_via_input(authorizer)
+    # TODO: This a raw copy, refactor
+    puts 'Follow this url and complete the sign-in process. The login will result in an error, do not close it.'
+    puts 'Instead, copy and paste the value of the `code` parameter (begins with 4/)'
+    puts authorizer.get_authorization_url(base_url: "http://localhost:1")
+    puts ''
+    code = HighLine::ask "Please enter code:"
+    puts "Got code: #{code}"
+
+    return authorizer.get_and_store_credentials_from_code(
+      user_id: @token_file_user,
+      code: code,
+      base_url: "http://localhost:1"
+    )
+  end
 
-    if !@client_id || !@client_secret || !@refresh_token
-      if @raise_error; raise "Not all tokens provided." end
+  def create_service(mode:'environment')
+    @logger.debug("Passed authorization mode: #{mode}")
+
+    unless %w(environment loopback input manual).include?(mode)
+      log_error_and_raise("Unknown authorization mode")
       return false
     end
 
-    return generate_access_token()
-  end
+    # TODO: Figure out balance between always requiring env config and just reading from the token store if it already exists
 
+    interactive_mode = %w(loopback input).include?(mode)
+    # Attempt to load keys from environment, unless manual. Doing ahead for the benefit of both cases.
 
-  def generate_access_token
-    # Refresh auth token from google_oauth2 and then requeue the job.
-    # https://stackoverflow.com/questions/12792326/how-do-i-refresh-my-google-oauth2-access-token-using-my-refresh-token
-    options = {
-      body: {
-        client_id:     @client_id,
-        client_secret: @client_secret,
-        refresh_token: @refresh_token,
-        grant_type: 'refresh_token'
-      },
-      headers: {
-        'Content-Type' => 'application/x-www-form-urlencoded'
-      }
-    }
-    response = HTTParty.post('https://accounts.google.com/o/oauth2/token', options)
-    if response.code != 200
-      if @raise_error; raise "Non-200 HTTP error code: #{response.code}." end
+    if mode == "manual"
+      key_load_result = false
+    else
+      key_load_result = (load_api_keys_from_env(require_refresh_token:!interactive_mode) || load_api_keys_from_file(require_refresh_token:!interactive_mode))
+    end
+
+    if interactive_mode && !key_load_result
+      print_config_hints
+    end
+
+    # If environment, we need key load to have succeeded completely
+    # If manual, it should pull from memory.
+    if %w(environment manual).include?(mode)
+      tmp_token_path = generate_temp_token_file
+      unless tmp_token_path
+        log_error_and_raise("Failed to generate temporary token file")
+        return false
+      end
+      @logger.debug(File.read(tmp_token_path))
+      unless key_load_result || mode=='manual'
+        log_error_and_raise("Unable to load api keys from environment")
+        return false
+      end
+      token_store = Google::Auth::Stores::FileTokenStore.new(file: tmp_token_path)
+    else
+      # Otherwise, just the ID and secret are enough
+      unless @client_secret && @client_id
+        log_error_and_raise("Client Secret or ID missing.")
+        return false
+      end
+      token_store = Google::Auth::Stores::FileTokenStore.new(file: @drive_token_path)
+    end
+
+    @authorizer = Google::Auth::UserAuthorizer.new(
+      Google::Auth::ClientId::from_hash(generate_api_secret_hash),
+      @drive_scope,
+      token_store,
+      @auth_url_path
+    )
+    @logger.debug("google_authorizer: " + @authorizer.inspect)
+
+    # Attempt to retrieve credentials
+    @credentials = @authorizer.get_credentials(@token_file_user)
+    if @credentials.nil?
+      case mode
+      when 'input'
+        @credentials = get_oauth_credentials_via_input(@authorizer)
+      when 'loopback'
+        @credentials = get_oauth_credentials_via_loopback(@authorizer)
+      end
+    end
+
+    # Final cred check
+    if @credentials.nil?
+      @logger.error('Unable to retrieve credentials')
       return false
     end
 
-    @access_token = response.parsed_response['access_token']
-    return true
+    # Update internal credentials based on credentials loaded
+    @client_id = @credentials.client_id
+    @client_secret = @credentials.client_secret
+    @refresh_token = @credentials.refresh_token
+
+    @drive_service = Google::Apis::DriveV3::DriveService.new
+    @drive_service.authorization = @credentials
+    return @drive_service
+  end
+
+  def process_file(file)
+    file_hash = { }
+    file_hash[:name] = file.name
+    file_hash[:id] = file.id
+    file_hash[:isfolder] = file.mime_type == 'application/vnd.google-apps.folder'
+    file_hash[:size] = file.size if file.size
+    file_hash[:md5] = file.md5_checksum if file.md5_checksum
+    file_hash[:parents] = file.parents if file.parents
+    return file_hash
   end
 
   # parentfolderid: "root" gets the root directory. Not all folders are under the root. Has to do with permissions
-  # and how Google Drive works. 
+  # and how Google Drive works.
+  # https://developers.google.com/drive/api/v3/reference/query-ref
   def get_all_files(justfiles: false, justfolders: false, parentfolderid: nil, name: nil)
+    unless @drive_service
+      log_error_and_raise("Drive service not initialized.")
+      return false
+    end
 
     # Number of files/directories to be returned each call to /files.
     # multiple page sizes are handled with the pageToken return value.
-    # 100 is default from google. 
-    pageSize = 100
-    
+    # 100 is default from google.
+    page_size = 100
+
+    # Fields param gives us extra juicy info like MD5 sums and file sizes
+    fields = "kind,incomplete_search,next_page_token,files(#{@file_fields})"
+
+    # Build query:
+    query = "(trashed = false)"
+    query +=" and (mimeType != 'application/vnd.google-apps.folder')" if justfiles && !justfolders
+    query += " and (mimeType = 'application/vnd.google-apps.folder')" if justfolders && !justfiles
+    # parent folder has to be surrounded by single quotes in query
+    query += " and ('#{parentfolderid}' in parents)" if parentfolderid
+    # filename has to be surrounded by single quotes in query
+    query += " and (name #{ name =~ /\*/ ? "contains" : "=" } '#{name}')" if name
+
     files = [ ]
-    nextPageToken = nil
+    next_page_token = nil
     loop do
-      headers = { 
-        "GData-Version"  => "3.0",
-        "Authorization" => "Bearer #{@access_token}" 
-      }
-      
-      url = "https://www.googleapis.com/drive/v3/files"
-      url = url + "?pageSize=#{pageSize}"
-  
-      # If a query, it must be appended to all URL
-      # From SO: https://stackoverflow.com/questions/62069155/how-to-filter-google-drive-api-v3-mimetype
-      #var query = "('GoogleDriveFolderKey01' in parents or 'GoogleDriveFolderKey02' in parents) and trashed = false and mimeType = 'application/vnd.google-apps.folder'"
-      
-      # default query is non-trashed folders
-      query = "(trashed = false)"
-      
-      if justfiles && !justfolders
-        query = query + " and (mimeType != 'application/vnd.google-apps.folder')"
-      end
-  
-      if justfolders && !justfiles
-        query = query + " and (mimeType = 'application/vnd.google-apps.folder')"
-      end
-  
-      if parentfolderid # parent folder has to be surrounded by single quotes in query
-        query = query + " and ('#{parentfolderid}' in parents)"
-      end
-  
-      if name # filename has to be surrounded by single quotes in query
-        if name =~ /\*/ # if name contains wildcard
-          query = query + " and (name contains '#{name}')"
-        else
-          query = query + " and (name = '#{name}')"
-        end
-      end
-  
-      url = url + "&q=" +  URI.escape(query)
-  
-      if nextPageToken
-        url = url + "&pageSize=1&pageToken=#{nextPageToken}"
-      end
-  
-      response = HTTParty.get(url, :headers => headers)
-  
-      if response.code == 404 # file not found, not an error
-        break
-      elsif response.code != 200
-        if @raise_error; raise "Non-200 HTTP error code: #{response.code}: " + response.parsed_response.inspect end
-        return false
-      end
-    
-      if response.parsed_response.has_key?("nextPageToken")
-        nextPageToken = response.parsed_response["nextPageToken"]
-      else 
-        nextPageToken = nil
-      end
-  
-      if !response.parsed_response.has_key?("files")
-        if @raise_error; raise "Required key not in response: 'files'." end
-        return false
-      end
+      # TODO: Should this be converted to block form and then use that to gracefully handle failure and errors?
+      files_page = @drive_service.list_files(page_size: page_size, q: query, page_token: next_page_token, fields: fields)
+      files_page.files.each {|f| files << f}
+      next_page_token = files_page.next_page_token
+      break unless next_page_token
+    end
 
-      # clean google drive response and only return relavent information. 
-      response.parsed_response["files"].each do |gd_file_entry|
-        # each entry has the following fields: name, kind, mimeType, id
-        file_hash = { }
-        file_hash[:name] = gd_file_entry["name"]
-        file_hash[:id] = gd_file_entry["id"]
-        file_hash[:isfolder] = false
-        if gd_file_entry["mimeType"] == 'application/vnd.google-apps.folder'
-          file_hash[:isfolder] = true
-        end
-        
-        files << file_hash
-      end
- 
-      break if nextPageToken.nil?
+    # Process the returned files
+    # Todo: Do we really need to convert these now that the API returns real objects?
+    processed_files = []
+    files.each do |file|
+      processed_files << process_file(file)
     end
 
+    # Todo: Is this still really necessary? I think the list_files function can do this server-side. Need to research.
     # we have additional processing to do it a wildcard character was passed. Because Google Drive "contains" returns all portions of it.
     # so we need to filter here
     if name =~ /\*/ # if name contains wildcard
       ret_files = [ ]
-      files.each do |file|
+      processed_files.each do |file|
         if GoogleDriveWildcard.new(name) =~ file[:name]
           ret_files << file
         end
       end
       return ret_files
     else
-      return files
+      return processed_files
     end
   end
 
@@ -241,143 +439,91 @@ class GoogleDrive
     return get_all_files(justfiles: true, parentfolderid: parentfolderid, name: name)
   end
 
-
-  def get_file_info(fileid)
-
-    headers = { 
-      "GData-Version"  => "3.0",
-      "Authorization" => "Bearer #{@access_token}" 
-    }
-    
-    url = "https://www.googleapis.com/drive/v3/files/#{fileid}"
-    response = HTTParty.get(url, :headers => headers)
-
-    if response.code == 404 # not found. Could be normal
-      #puts "404 not found"
-      return false
-    elsif response.code != 200
-      if @raise_error; raise "Non-200 HTTP error code: #{response.code}: " + response.parsed_response.inspect end
+  def get_file_info(file_id)
+    unless @drive_service
+      log_error_and_raise("Drive service not initialized.")
       return false
     end
 
-    if !response.parsed_response.has_key?("kind")
-      return false
-    elsif response.parsed_response["kind"] != "drive#file"
-      return false
-    elsif !response.parsed_response.has_key?("name")
-      return false
-    end
-
-    # returns the following keys: kind, id, name, mimeType
-    file_hash = { }
-    file_hash[:name] = response.parsed_response["name"]
-    file_hash[:id] = response.parsed_response["id"]
-    file_hash[:isfolder] = false
-    if response.parsed_response["mimeType"] == 'application/vnd.google-apps.folder'
-      file_hash[:isfolder] = true
-    end
-
-    return file_hash
+    # TODO: Maybe convert this to block format and handle errors like in other places
+    file = @drive_service.get_file(file_id:file_id, acknowledge_abuse:true, fields: "files(#{@file_fields})")
+    return process_file(file)
   end
 
   def find_directory_id(directory_name, parentfolderid: nil)
-
     file_list = get_all_files(justfolders: true, name: directory_name, parentfolderid: parentfolderid)
 
     if !file_list || (file_list.count == 0)
-      if @raise_error; raise "Directory not found." end
+      log_error_and_raise("Directory not found.")
       return false
     end
-  
-    return file_list.first[:id]  
-end
-    
+
+    return file_list.first[:id]
+  end
+
   def upload_file(file, directory_id: nil)
+    unless @drive_service
+      log_error_and_raise("Drive service not initialized.")
+      return false
+    end
 
     file_basename = File.basename(file)
-  
+    # TODO: If no parent directory is passed, it will deny upload if a file by that name exists in any visible folder on any visible drive. How to fix?
     # see if file exists on Drive
     file_list = self.get_all_files(justfiles: true, parentfolderid: directory_id, name: file_basename)
     if file_list.count > 0
-      if @raise_error; raise "ERROR: File '#{file_basename}' already exists." end
-      return false
-    end
-  
-    metadata = "name : '#{file_basename}'"
-  
-    if !directory_id.nil? # if directory if specified, add it to the parent
-      metadata = metadata + ", parents : [ '#{directory_id}' ]"
-    end
-  
-    metadata = "{#{metadata}}" # wrap metadata in braces
-  
-    # Upload with CURL. HTTPParty and RestClient seem to be incompatible. 
-    cmd = "curl -X POST -L " +
-          "--silent " +
-          "-H \"Authorization: Bearer #{@access_token}\" " +
-          "-F \"metadata=#{metadata};type=application/json;charset=UTF-8\" " +
-          "-F \"file=@#{file};\" " +
-          "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart"
-  
-    # puts "cmd:\n#{cmd}"
-  
-    response = `#{cmd} 2>/dev/null`
-    exit_status = $?.exitstatus
-  
-    if exit_status != 0
-      if @raise_error; raise "CURL existed with non-0 error code: #{exit_status}." end
+      log_error_and_raise("ERROR: File '#{file_basename}' already exists.")
       return false
     end
-  
-    begin
-      response = JSON.load(response)
-    rescue => e
-      if @raise_error; raise "CURL response is not in valid JSON." end
-      return false 
-    end
-  
-    # example of response.
-    #   {
-    #  "kind": "drive#file",
-    #  "id": "1Zw9YD3TXci3Ja_wU0g7f30DHpsEbk2zf",
-    #  "name": "ruby-3.1.0.tar.gz",
-    #  "mimeType": "application/gzip"
-    #   }
- 
-    # check that name = filename
-    # check that kind = drive#file
-    if !response.key?("name") # name key does not exist
-      if @raise_error; raise "no name key specified in response." end
-      return false
-    elsif !response.key?("kind") # kind key does not exist
-      if @raise_error; raise "no kind key specified in response." end
-      return false
-    elsif response["kind"] != "drive#file" # Not of file type
-      if @raise_error; raise "kind is of non-file type." end
-      return false
-    elsif response["name"] != file_basename # file name mismatch
-      if @raise_error; raise "file name mismatch." end
-      return false
+
+    file_obj =  Google::Apis::DriveV3::File.new(name: file_basename)
+    file_obj.parents = [directory_id] if directory_id
+    @drive_service.create_file(
+      file_obj,
+      upload_source: file,
+      fields: @file_fields
+    ) do |resfile, err|
+      if err
+        log_error_and_raise("Error: #{err}.")
+        return false
+      end
+
+      # check that name = filename
+      # check that kind = drive#file
+      if !resfile.name # name key does not exist
+        log_error_and_raise("no name key specified in response.")
+        return false
+      elsif !resfile.kind # kind key does not exist
+        log_error_and_raise("no kind key specified in response.")
+        return false
+      elsif resfile.kind != "drive#file" # Not of file type
+        log_error_and_raise("kind is of non-file type.")
+        return false
+      elsif resfile.name != file_basename # file name mismatch
+        log_error_and_raise("file name mismatch.")
+        return false
+      end
+      # TODO: Add MD5 check, since we're now capable.
     end
-  
     return true
   end
-  
+
   # returns full path of downloaded file
   def download_file(file_name_or_id, parentfolderid: nil, file_path: nil)
+    unless @drive_service
+      log_error_and_raise("Drive service not initialized.")
+      return false
+    end
 
-    # https://stackoverflow.com/questions/60608901/how-to-download-a-big-file-from-google-drive-via-curl-in-bash
-    # curl -H "Authorization: Bearer $token" "https://www.googleapis.com/drive/v3/files/$id?alt=media" -o "$file"
-    
-    # if file path passed, check it is valid. 
+    # if file path passed, check it is valid.
     if file_path && !Dir.exist?(file_path)
-      if @raise_error; raise "File path '#{file_path}' does not exist." end
+      log_error_and_raise("File path '#{file_path}' does not exist.")
       return false
     elsif !file_path # no path passed, use current directory
       file_path = Dir.getwd
-    end 
-    
-    # path passed and valid. Append forward slash if not already there. 
+    end
+
+    # path passed and valid. Append forward slash if not already there.
     file_path = file_path.gsub(/\/$/, '') + "/"
 
     # 1) assume file_name_or_id is a filename
@@ -385,43 +531,27 @@ end
     if files && (files.count == 1)
       file_info = files.first
     elsif files && (files.count > 1)
-      if @raise_error; raise "Multiple files with name '#{file_name_or_id}' exist. dowload_file() can only handle a single filename." end
+      log_error_and_raise("Multiple files with name '#{file_name_or_id}' exist. download_file() can only handle a single filename.")
       return false
-    else # either files is false or count is 0. assume file_name_or_id is an id. 
+    else # either files is false or count is 0. assume file_name_or_id is an id.
       file_info = get_file_info(file_name_or_id)
       if !file_info
-        if @raise_error; raise "No file with ID  '#{file_name_or_id}' exist." end
+        log_error_and_raise("No file with ID  '#{file_name_or_id}' exist.")
         return false
       end
     end
 
-    file_name = file_info[:name]
-
+    output_file = "#{file_path + file_info[:name]}"
     # Delete local file if it exists
-    `rm #{file_path + file_name} > /dev/null 2>&1`
+    `rm #{output_file} > /dev/null 2>&1`
 
-    # temp file is automatically unlinked at end of function. 
-    output_file = Tempfile.new('driveapi_').path
-
-    url = "https://www.googleapis.com/drive/v3/files/#{file_info[:id]}?alt=media"
-
-    # --write-out \"%{http_code}\" \"$@\" returns http code in stdout
-    cmd = "curl --silent --write-out \"%{http_code}\" \"$@\" -H \"Authorization: Bearer #{@access_token}\" \"#{url}\" -o \"#{output_file}\""
-    response = `#{cmd} 2>/dev/null` # this is the http code as string.
-    exit_status = $?.exitstatus
-
-    if exit_status != 0
-      if @raise_error; raise "non-0 exit status #{exit_status}." end
-      return false
-    elsif response.to_i != 200
-      if @raise_error; raise "Non HTTP 200 code for download: '#{response}'" end
-      return false
+    @drive_service.get_file(file_info[:id], acknowledge_abuse:true, download_dest: output_file ) do |resfile, err|
+      if err
+        log_error_and_raise("Error: #{err}.")
+        return false
+      end
     end
-
-    # file temp file to file
-    `cp #{output_file} #{file_path + file_name}`
-
-    return file_path + file_name
+    return output_file
   end
 end # end of class GoogleDrive
 

data/lib/utilities.rb

@@ -0,0 +1,16 @@
+
+module Utilities
+  # Reads files with K-V pairs in the style of
+  # KEY=value
+  # KEY2="really long value"
+  # and strips surrounding spaces, then surrounding double-quotes, then returns K-V pairs as a hash
+  def read_conf_file(filepath)
+    text = File.read(filepath)
+    data = text.scan(/(\S+)\s*=\s*(.+)/)
+    hash = Hash[data]
+    return hash.map { |k, v| [k, v.strip.delete_prefix('"').delete_suffix('"')] }.to_h
+    # TODO: Support comments (starting with #). Possibly non-leading # (such as after value, but outside quotes.)
+    # TODO: Handle quotes more elegantly. State machine?
+  end
+
+end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: googledrive-easy
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Mike Bullock
-autorequire: 
+- Michael Ketchel
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-16 00:00:00.000000000 Z
+date: 2022-10-19 00:00:00.000000000 Z
 dependencies: []
 description: Easy File interface to Google Drive
 email: jmb@rgnets.com
@@ -18,13 +19,15 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/googledrive
+- lib/googledrive-easy-test.rb
 - lib/googledrive-easy.rb
 - lib/googledrive/wildcard.rb
+- lib/utilities.rb
 homepage: https://rubygems.org/gems/googledrive-easy
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -39,9 +42,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Easy File interface to Google Drive
 test_files: []