googledrive-easy 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e56a24359754fc58fb6a56cfc7197c4bd96834d8a4918e944385d2642ab900e
-  data.tar.gz: 8963a1f491e20b479814a5da6495e5654f0627a80f4520627e5b2ad9357b319a
+  metadata.gz: 980d20ae39d421ac858a8ccceabd2d6d7ba95ea9e8e0181ffbf96d068d217b99
+  data.tar.gz: 1593952ec9b4d4a4746a95039816eee6cd6cbda6c86757fbeea28688caf84423
 SHA512:
-  metadata.gz: b57117941614a74a66ad3f787d20e92356931e20d266bac57eb51bd07d29814af36014306bdf4c70e6076399c338ef15bc7d41d5317ea96b541e9cbc9b9a1e9a
-  data.tar.gz: f058b48cbce3e482b682676150ff6f51c76a0dd35339b0bce16dc51abfdc45b14a11578938eb0458c36b3f7d74fcc1a8e5790b7604482d93af8be3af38eafbc9
+  metadata.gz: 0d2b9e15ea96f2a7eecd9c510463ce4dc5628515aec068c06cc6360260bbb030fe636bfc11f8202f5bf69a9abf48c71d7d705235675c4b5d720f101c0a9b501d
+  data.tar.gz: 682e5cf1e0e3ca41518ea3ef55c1b47351519bf1132999418950ea2689c71b8fdf8947b0f0b691456d8fef17e26c332de0a17749f5e4bacb7d6fd7b4fffc5717

data/bin/googledrive

@@ -46,7 +46,7 @@ def print_hash_for_env_use(keys)
 end
 
 def handle_auth(options)
-  drive = GoogleDrive::new(raise_error: false, loglevel: Logger::ERROR)
+  drive = GoogleDrive::new(raise_error: true, loglevel: Logger::ERROR)
 
   # Handle special service mode cases
   case options[:authmode]

data/lib/googledrive-easy-test.rb

@@ -57,11 +57,16 @@ class GoogleDriveEasyTest < Test::Unit::TestCase
   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")
+    2.times do |i|
+      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")
+
+      # Enable raise error for second run.
+      @drive.set_raise_error
+    end
   end
 
   def test_loading_api_vars_from_env_missing_fail
@@ -74,6 +79,10 @@ class GoogleDriveEasyTest < Test::Unit::TestCase
     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")
+
+    @drive.set_raise_error
+    exception = assert_raise(RuntimeError) { @drive.load_api_keys_from_env }
+    assert_equal("DRIVEAPI_CLIENT_SECRET export variable not set.", exception.message)
   end
 
   def test_loading_api_vars_from_file_success
@@ -82,13 +91,16 @@ class GoogleDriveEasyTest < Test::Unit::TestCase
 
     # 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")
+    2.times do |i|
+      # 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")
+      # Enable raise error for second run.
+      @drive.set_raise_error
+    end
   end
 
   def test_loading_api_vars_from_file_not_found
@@ -101,6 +113,10 @@ class GoogleDriveEasyTest < Test::Unit::TestCase
     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")
+
+    @drive.set_raise_error
+    exception = assert_raise(RuntimeError) { @drive.load_api_keys_from_file }
+    assert_equal("Cannot find /tmp/bogons", exception.message)
   end
 
   ###########################
@@ -111,9 +127,12 @@ class GoogleDriveEasyTest < Test::Unit::TestCase
     @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')
+    2.times do
+      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')
+      @drive.set_raise_error
+    end
   end
 
   def test_generate_token_yaml_success
@@ -123,11 +142,13 @@ class GoogleDriveEasyTest < Test::Unit::TestCase
     @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")
-
+    2.times do
+      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")
+      @drive.set_raise_error
+    end
   end
 
   def test_generate_token_yaml_fail
@@ -135,6 +156,9 @@ class GoogleDriveEasyTest < Test::Unit::TestCase
     # @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")
+
+    @drive.set_raise_error
+    assert_raise(RuntimeError) { @drive.generate_token_yaml }
   end
 
   def test_generate_temp_token_file
@@ -143,11 +167,14 @@ class GoogleDriveEasyTest < Test::Unit::TestCase
     @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")
+    2.times do
+      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")
+      @drive.set_raise_error
+    end
   end
 
   #########################################
@@ -162,34 +189,43 @@ class GoogleDriveEasyTest < Test::Unit::TestCase
     # 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")
+    2.times do
+      # 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")
+      @drive.set_raise_error
+    end
   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")
+    2.times do
+      # 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")
+      @drive.set_raise_error
+    end
   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")
+    2.times do
+      # 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")
+      @drive.set_raise_error
+    end
   end
 
   ###########################################
@@ -216,18 +252,65 @@ class GoogleDriveEasyTest < Test::Unit::TestCase
 
     @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")
+
+    2.times do
+      res = @drive.get_all_files(name: "rxgos*")
+      assert_instance_of(Array, res, "Returns list")
+      @drive.set_raise_error
+    end
   end
 
   def test_get_file_info
     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)
     @drive.create_service(mode:'manual')
-    res = @drive.get_file_info("10l2ahCetnm1_147rRcuaObTwrntqQuRz")
-    assert_instance_of(Hash, res, 'Should return a Hash')
-    assert_equal("rxg", res[:name], "Name should be 'rxg'")
-    # assert_instance_of(Google::Apis::DriveV3::File, res, 'Should be instance of Google::Apis::DriveV3::File')
+
+    2.times do
+      res = @drive.get_file_info("10l2ahCetnm1_147rRcuaObTwrntqQuRz")
+      assert_instance_of(Hash, res, 'Should return a Hash')
+      assert_equal("rxg", res[:name], "Name should be 'rxg'")
+      # assert_instance_of(Google::Apis::DriveV3::File, res, 'Should be instance of Google::Apis::DriveV3::File')
+      @drive.set_raise_error
+    end
   end
 
+  def test_get_file_info_nofile
+    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)
+    @drive.create_service(mode:'manual')
+
+    res = @drive.get_file_info("10l2ahCetnm1_147rRcuaObTwrntqQZZZ")
+    assert_false(res, "Result should be false")
+
+    # Doesn't raise on not-found
+  end
+
+  def test_find_directory_id
+    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)
+    @drive.create_service(mode:'manual')
+
+    2.times do
+      res = @drive.find_directory_id("rxg")
+      assert_equal("10l2ahCetnm1_147rRcuaObTwrntqQuRz", res)
+      # assert_instance_of(Google::Apis::DriveV3::File, res, 'Should be instance of Google::Apis::DriveV3::File')
+      res = @drive.get_file_info("10l2ahCetnm1_147rRcuaObTwrntqQuRz")
+      @drive.set_raise_error
+    end
+  end
+
+  def test_find_directory_id_nodir
+    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)
+    @drive.create_service(mode:'manual')
+
+    res = @drive.find_directory_id("nonexistantdirectory")
+    assert_false(res, "Result should be false")
+
+    @drive.set_raise_error
+    assert_raise(RuntimeError) { res = @drive.find_directory_id("nonexistantdirectory") }
+    # Doesn't raise on not-found
+  end
+
+
 end

data/lib/googledrive-easy.rb

@@ -85,16 +85,20 @@ class GoogleDrive
     TEXT
   end
 
-  def log_error_and_raise(msg)
+  def set_raise_error(raise_error=true)
+    @raise_error = raise_error
+  end
+
+  def log_error_and_raise(msg, raise_error=@raise_error)
     @logger.error(msg)
-    raise "msg" if @raise_error
+    raise "#{msg}" if raise_error
+    false
   end
 
-  def set_api_keys(client_id:nil, client_secret:nil, refresh_token:nil, access_token:nil, require_refresh_token:true)
+  def set_api_keys(client_id:nil, client_secret:nil, refresh_token:nil, access_token:nil, require_refresh_token:true, raise_error: @raise_error )
     # 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
+      return log_error_and_raise("Not all tokens provided.", raise_error)
     end
     @client_id     = client_id if client_id
     @client_secret = client_secret if client_secret
@@ -103,15 +107,14 @@ class GoogleDrive
     return true
   end
 
-  def load_api_keys_from_file(path:nil, require_refresh_token:true)
+  def load_api_keys_from_file(path:nil, require_refresh_token:true, raise_error: @raise_error)
     @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
+        return log_error_and_raise("Error opening api key file: " + error.inspect, raise_error)
       end
 
       @logger.debug("api_hash: " + api_hash.inspect)
@@ -124,38 +127,41 @@ class GoogleDrive
         client_id:api_hash["CLIENT_ID"],
         client_secret:api_hash["CLIENT_SECRET"],
         refresh_token:api_hash["REFRESH_TOKEN"],
-        require_refresh_token:require_refresh_token
+        require_refresh_token:require_refresh_token,
+        raise_error: false
       )
         @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
+        return log_error_and_raise("Not all API keys were in file #{@loaded_api_key_file}.", raise_error)
       end
     else
-      log_error_and_raise("Cannot find #{@loaded_api_key_file}")
-      return false
+      return log_error_and_raise("Cannot find #{@loaded_api_key_file}", raise_error)
     end
     true
   end
 
-  def load_api_keys_from_env(require_refresh_token:true)
+  def load_api_keys_from_env(require_refresh_token:true, raise_error: @raise_error)
     # 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
+        return log_error_and_raise("#{v} export variable not set.", raise_error)
       end
     end
 
     # Set
-    return set_api_keys(
+    if 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
+      require_refresh_token:require_refresh_token,
+      raise_error: raise_error
     )
+      @logger.info("Using Google Drive API information from environment.")
+    else
+      return log_error_and_raise("Not all API keys were in environment.", raise_error)
+    end
   end
 
   def generate_api_secret_hash
@@ -182,12 +188,11 @@ class GoogleDrive
   end
 
   # Generates token yaml
-  def generate_token_yaml
+  def generate_token_yaml(raise_error: @raise_error)
     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
+      return log_error_and_raise("Some required API config for token hasn't been configured yet", raise_error)
     end
 
     drive_token_hash = {
@@ -201,12 +206,10 @@ class GoogleDrive
   end
 
   # Generates temp token file and return path to it
-  def generate_temp_token_file
+  def generate_temp_token_file(raise_error: @raise_error)
     tmpfile = Tempfile.new('drive_token')
-    token_yaml = generate_token_yaml
-    unless token_yaml
-      return false
-    end
+    token_yaml = generate_token_yaml(raise_error: raise_error)
+    return false unless token_yaml
     tmpfile.write(token_yaml)
     tmpfile.flush # flush file contents before continuing.
     return @drive_token_path = File.expand_path(tmpfile.path)
@@ -226,7 +229,6 @@ class GoogleDrive
   # 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}."
@@ -270,7 +272,6 @@ class GoogleDrive
   end
 
   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")
@@ -289,8 +290,7 @@ class GoogleDrive
     @logger.debug("Passed authorization mode: #{mode}")
 
     unless %w(environment loopback input manual).include?(mode)
-      log_error_and_raise("Unknown authorization mode")
-      return false
+      return log_error_and_raise("Unknown authorization mode")
     end
 
     # TODO: Figure out balance between always requiring env config and just reading from the token store if it already exists
@@ -301,7 +301,10 @@ class GoogleDrive
     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))
+      key_load_result = (
+        load_api_keys_from_env(require_refresh_token:!interactive_mode,  raise_error: false) ||
+          load_api_keys_from_file(require_refresh_token:!interactive_mode, raise_error: false)
+      )
     end
 
     if interactive_mode && !key_load_result
@@ -311,22 +314,19 @@ class GoogleDrive
     # 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
+      tmp_token_path = generate_temp_token_file(raise_error: false)
       unless tmp_token_path
-        log_error_and_raise("Failed to generate temporary token file")
-        return false
+        return log_error_and_raise("Failed to generate temporary token file")
       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
+        return log_error_and_raise("Unable to load api keys from environment")
       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
+        return log_error_and_raise("Client Secret or ID missing.")
       end
       token_store = Google::Auth::Stores::FileTokenStore.new(file: @drive_token_path)
     end
@@ -352,8 +352,7 @@ class GoogleDrive
 
     # Final cred check
     if @credentials.nil?
-      @logger.error('Unable to retrieve credentials')
-      return false
+      return log_error_and_raise(@logger.error('Unable to retrieve credentials') )
     end
 
     # Update internal credentials based on credentials loaded
@@ -380,11 +379,8 @@ class GoogleDrive
   # parentfolderid: "root" gets the root directory. Not all folders are under the root. Has to do with permissions
   # 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
+  def get_all_files(justfiles: false, justfolders: false, parentfolderid: nil, name: nil, raise_error: @raise_error)
+    return log_error_and_raise("Drive service not initialized.") unless @drive_service
 
     # Number of files/directories to be returned each call to /files.
     # multiple page sizes are handled with the pageToken return value.
@@ -401,16 +397,36 @@ class GoogleDrive
     # 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
+
+    if name
+      name.split("*").each_with_index do |part, idx|
+        if idx == 0 and name =~ /\*/ and part.size > 0
+          # If the above are true, this is the first piece, and it was followed by a *, so we should pass it in the
+          # format for prefix matching
+          query += " and (name contains '#{part}*')"
+        elsif idx == 0 and !(name =~ /\*/ )
+          # If the above is true, this is a literal equivalence search, no wildcards should be used.
+          query += " and (name = '#{part}')"
+        else
+          # If we're here, either we had a wildcard prefix, or we're on a later part of the search term. Do a contains.
+          query += " and (name contains '#{part}')" if part.size > 0
+        end
+      end
+    end
+    @logger.debug("Searching with query: #{query}")
 
     files = [ ]
     next_page_token = nil
-    loop do
-      # 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
+    begin
+      loop do
+        # 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
+    rescue => e
+      return log_error_and_raise("Error retrieving files: #{e}", raise_error)
     end
 
     # Process the returned files
@@ -420,7 +436,6 @@ class GoogleDrive
       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
@@ -437,45 +452,40 @@ class GoogleDrive
   end
 
   # returns all files by default in all folders
-  def find_files(name = "*", parentfolderid: nil)
-    return get_all_files(justfiles: true, parentfolderid: parentfolderid, name: name)
+  def find_files(name = "*", parentfolderid: nil, raise_error: @raise_error)
+    return get_all_files(justfiles: true, parentfolderid: parentfolderid, name: name, raise_error: raise_error)
   end
 
-  def get_file_info(file_id)
-    unless @drive_service
-      log_error_and_raise("Drive service not initialized.")
-      return false
+  def get_file_info(file_id, raise_error: @raise_error)
+    return log_error_and_raise("Drive service not initialized.") unless @drive_service
+    begin
+      # TODO: Maybe convert this to block format and handle errors like in other places
+      file = @drive_service.get_file(file_id, fields: "#{@file_fields}")
+      return process_file(file)
+    rescue => e
+      return log_error_and_raise("Error getting file info: #{e}.", raise_error)
     end
-
-    # TODO: Maybe convert this to block format and handle errors like in other places
-    file = @drive_service.get_file(file_id, fields: "#{@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)
+  def find_directory_id(directory_name, parentfolderid: nil, raise_error: @raise_error)
+    file_list = get_all_files(justfolders: true, name: directory_name, parentfolderid: parentfolderid, raise_error: raise_error)
 
     if !file_list || (file_list.count == 0)
-      log_error_and_raise("Directory not found.")
-      return false
+      return log_error_and_raise("Directory not found.", raise_error)
     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
+    return log_error_and_raise("Drive service not initialized.") unless @drive_service
 
     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
-      log_error_and_raise("ERROR: File '#{file_basename}' already exists.")
-      return false
+      return log_error_and_raise("ERROR: File '#{file_basename}' already exists.")
     end
 
     file_obj =  Google::Apis::DriveV3::File.new(name: file_basename)
@@ -486,24 +496,19 @@ class GoogleDrive
       fields: @file_fields
     ) do |resfile, err|
       if err
-        log_error_and_raise("Error: #{err}.")
-        return false
+        return log_error_and_raise("Error uploading file: #{err}.")
       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
+        return log_error_and_raise("no name key specified in response.")
       elsif !resfile.kind # kind key does not exist
-        log_error_and_raise("no kind key specified in response.")
-        return false
+        return log_error_and_raise("no kind key specified in response.")
       elsif resfile.kind != "drive#file" # Not of file type
-        log_error_and_raise("kind is of non-file type.")
-        return false
+        return log_error_and_raise("kind is of non-file type.")
       elsif resfile.name != file_basename # file name mismatch
-        log_error_and_raise("file name mismatch.")
-        return false
+        return log_error_and_raise("file name mismatch.")
       end
       # TODO: Add MD5 check, since we're now capable.
     end
@@ -512,15 +517,11 @@ class GoogleDrive
 
   # 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
+    return log_error_and_raise("Drive service not initialized.") unless @drive_service
 
     # if file path passed, check it is valid.
     if file_path && !Dir.exist?(file_path)
-      log_error_and_raise("File path '#{file_path}' does not exist.")
-      return false
+      return log_error_and_raise("File path '#{file_path}' does not exist.")
     elsif !file_path # no path passed, use current directory
       file_path = Dir.getwd
     end
@@ -533,13 +534,11 @@ class GoogleDrive
     if files && (files.count == 1)
       file_info = files.first
     elsif files && (files.count > 1)
-      log_error_and_raise("Multiple files with name '#{file_name_or_id}' exist. download_file() can only handle a single filename.")
-      return false
+      return log_error_and_raise("Multiple files with name '#{file_name_or_id}' exist. download_file() can only handle a single filename.")
     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
-        log_error_and_raise("No file with ID  '#{file_name_or_id}' exist.")
-        return false
+        return log_error_and_raise("No file with ID  '#{file_name_or_id}' exist.")
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: googledrive-easy
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Mike Bullock
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-26 00:00:00.000000000 Z
+date: 2022-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: googleauth