browse-everything 1.0.0.rc2 → 1.1.1

data/lib/browse_everything/driver/dropbox.rb

@@ -83,7 +83,8 @@ module BrowseEverything
       def contents(path = '')
         path = '/' + path unless path == ''
         response = client.list_folder(path)
-        @entries = response.entries.map { |entry| FileEntryFactory.build(metadata: entry, key: key) }
+        values = response.entries.map { |entry| FileEntryFactory.build(metadata: entry, key: key) }
+        @entries = values.compact
         @sorter.call(@entries)
       end
 
@@ -91,7 +92,7 @@ module BrowseEverything
         return @downloaded_files[path] if @downloaded_files.key?(path)
 
         # This ensures that the name of the file its extension are preserved for user downloads
-        temp_file_path = File.join(Dir.mktmpdir, File.basename(path))
+        temp_file_path = File.join(download_directory_path, File.basename(path))
         temp_file = File.open(temp_file_path, mode: 'w+', encoding: 'ascii-8bit')
         client.download(path) do |chunk|
           temp_file.write chunk
@@ -137,29 +138,44 @@ module BrowseEverything
 
       private
 
-        def session
-          AuthenticationFactory.new(
-            self.class.authentication_klass,
-            config[:client_id],
-            config[:client_secret]
-          )
-        end
+      def session
+        AuthenticationFactory.new(
+          self.class.authentication_klass,
+          config[:client_id],
+          config[:client_secret]
+        )
+      end
 
-        def authenticate
-          session.authenticate
-        end
+      def authenticate
+        session.authenticate
+      end
 
-        def authenticator
-          @authenticator ||= authenticate
-        end
+      def authenticator
+        @authenticator ||= authenticate
+      end
 
-        def client
-          DropboxApi::Client.new(token)
-        end
+      def client
+        DropboxApi::Client.new(token)
+      end
 
-        def redirect_uri(url_options)
-          connector_response_url(**url_options)
-        end
+      def redirect_uri(url_options)
+        connector_response_url(**url_options)
+      end
+
+      # Ensures that the "tmp" directory is used if there is no default download
+      # directory specified in the configuration
+      # @return [String]
+      def default_download_directory
+        Rails.root.join('tmp')
+      end
+
+      # Retrieves the directory path for downloads used when retrieving the
+      # resource from Dropbox
+      # @return [String]
+      def download_directory_path
+        dir_path = config[:download_directory] || default_download_directory
+        File.expand_path(dir_path)
+      end
     end
   end
 end

data/lib/browse_everything/driver/file_system.rb

@@ -11,13 +11,17 @@ module BrowseEverything
         raise BrowseEverything::InitializationError, 'FileSystem driver requires a :home argument' if config[:home].blank?
       end
 
+      # Retrieve the contents of a directory
+      # @param path [String] the path to a file system resource
+      # @return [Array<BrowseEverything::FileEntry>]
       def contents(path = '')
         real_path = File.join(config[:home], path)
-        @entries = if File.directory?(real_path)
-                     make_directory_entry real_path
-                   else
-                     [details(real_path)]
-                   end
+        values = if File.directory?(real_path)
+                   make_directory_entry real_path
+                 else
+                   [details(real_path)]
+                 end
+        @entries = values.compact
 
         @sorter.call(@entries)
       end
@@ -32,6 +36,10 @@ module BrowseEverything
         true
       end
 
+      # Construct a FileEntry objects for a file-system resource
+      # @param path [String] path to the file
+      # @param display [String] display label for the resource
+      # @return [BrowseEverything::FileEntry]
       def details(path, display = File.basename(path))
         return nil unless File.exist? path
         info = File::Stat.new(path)
@@ -47,21 +55,25 @@ module BrowseEverything
 
       private
 
-        def make_directory_entry(real_path)
-          entries = []
-          entries + Dir[File.join(real_path, '*')].collect { |f| details(f) }
-        end
+      # Construct an array of FileEntry objects for the contents of a
+      # directory
+      # @param real_path [String] path to the file system directory
+      # @return [Array<BrowseEverything::FileEntry>]
+      def make_directory_entry(real_path)
+        entries = []
+        entries + Dir[File.join(real_path, '*')].collect { |f| details(f) }
+      end
 
-        def make_pathname(path)
-          Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(config[:home]))
-        end
+      def make_pathname(path)
+        Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(config[:home]))
+      end
 
-        def file_size(path)
-          File.size(path).to_i
-        rescue StandardError => error
-          Rails.logger.error "Failed to find the file size for #{path}: #{error}"
-          0
-        end
+      def file_size(path)
+        File.size(path).to_i
+      rescue StandardError => error
+        Rails.logger.error "Failed to find the file size for #{path}: #{error}"
+        0
+      end
     end
   end
 end

data/lib/browse_everything/driver/google_drive.rb

@@ -79,9 +79,10 @@ module BrowseEverything
             raise error
           end
 
-          @entries += file_list.files.map do |gdrive_file|
+          values = file_list.files.map do |gdrive_file|
             details(gdrive_file, path)
           end
+          @entries += values.compact
 
           request_params.page_token = file_list.next_page_token
         end
@@ -190,50 +191,50 @@ module BrowseEverything
 
       private
 
-        def client_secrets
-          {
-            Google::Auth::ClientId::WEB_APP => {
-              Google::Auth::ClientId::CLIENT_ID => config[:client_id],
-              Google::Auth::ClientId::CLIENT_SECRET => config[:client_secret]
-            }
+      def client_secrets
+        {
+          Google::Auth::ClientId::WEB_APP => {
+            Google::Auth::ClientId::CLIENT_ID => config[:client_id],
+            Google::Auth::ClientId::CLIENT_SECRET => config[:client_secret]
           }
-        end
+        }
+      end
 
-        # This is required for using the googleauth Gem
-        # @see http://www.rubydoc.info/gems/googleauth/Google/Auth/Stores/FileTokenStore FileTokenStore for googleauth
-        # @return [Tempfile] temporary file within which to cache credentials
-        def file_token_store_path
-          Tempfile.new('gdrive.yaml')
-        end
+      # This is required for using the googleauth Gem
+      # @see http://www.rubydoc.info/gems/googleauth/Google/Auth/Stores/FileTokenStore FileTokenStore for googleauth
+      # @return [Tempfile] temporary file within which to cache credentials
+      def file_token_store_path
+        Tempfile.new('gdrive.yaml')
+      end
 
-        def scope
-          Google::Apis::DriveV3::AUTH_DRIVE
-        end
+      def scope
+        Google::Apis::DriveV3::AUTH_DRIVE
+      end
 
-        # Provides the user ID for caching access tokens
-        # (This is a hack which attempts to anonymize the access tokens)
-        # @return [String] the ID for the user
-        def user_id
-          'current_user'
-        end
+      # Provides the user ID for caching access tokens
+      # (This is a hack which attempts to anonymize the access tokens)
+      # @return [String] the ID for the user
+      def user_id
+        'current_user'
+      end
 
-        # Please see https://developers.google.com/drive/v3/web/manage-downloads
-        # @param id [String] the ID for the Google Drive File
-        # @return [String] the URL for the file download
-        def download_url(id)
-          "https://www.googleapis.com/drive/v3/files/#{id}?alt=media"
-        end
+      # Please see https://developers.google.com/drive/v3/web/manage-downloads
+      # @param id [String] the ID for the Google Drive File
+      # @return [String] the URL for the file download
+      def download_url(id)
+        "https://www.googleapis.com/drive/v3/files/#{id}?alt=media"
+      end
 
-        # Restore the credentials for the Google API
-        # @param access_token [String] the access token redeemed using an authorization code
-        # @return Credentials credentials restored from a cached access token
-        def restore_credentials(access_token)
-          client = Auth::Google::Credentials.new
-          client.client_id = client_id.id
-          client.client_secret = client_id.secret
-          client.update_token!('access_token' => access_token)
-          @credentials = client
-        end
+      # Restore the credentials for the Google API
+      # @param access_token [String] the access token redeemed using an authorization code
+      # @return Credentials credentials restored from a cached access token
+      def restore_credentials(access_token)
+        client = Auth::Google::Credentials.new
+        client.client_id = client_id.id
+        client.client_secret = client_id.secret
+        client.update_token!('access_token' => access_token)
+        @credentials = client
+      end
     end
   end
 end

data/lib/browse_everything/driver/s3.rb

@@ -79,63 +79,79 @@ module BrowseEverything
 
       private
 
-        def strip(path)
-          path.sub %r{^/?(.+?)/?$}, '\1'
-        end
+      def strip(path)
+        path.sub %r{^/?(.+?)/?$}, '\1'
+      end
 
-        def from_base(key)
-          Pathname.new(key).relative_path_from(Pathname.new(config[:base].to_s)).to_s
-        end
+      def from_base(key)
+        Pathname.new(key).relative_path_from(Pathname.new(config[:base].to_s)).to_s
+      end
 
-        def full_path(path)
-          config[:base].present? ? File.join(config[:base], path) : path
-        end
+      def full_path(path)
+        config[:base].present? ? File.join(config[:base], path) : path
+      end
 
-        def aws_config
-          result = {}
-          result[:credentials] = Aws::Credentials.new(config[:app_key], config[:app_secret]) if config[:app_key].present?
-          result[:region] = config[:region] if config.key?(:region)
-          result
-        end
+      def aws_config
+        result = {}
+        result[:credentials] = Aws::Credentials.new(config[:app_key], config[:app_secret]) if config[:app_key].present?
+        result[:region] = config[:region] if config.key?(:region)
+        result
+      end
 
-        def session
-          AuthenticationFactory.new(
-            self.class.authentication_klass,
-            aws_config
-          )
-        end
+      def session
+        AuthenticationFactory.new(
+          self.class.authentication_klass,
+          aws_config
+        )
+      end
 
-        def authenticate
-          session.authenticate
-        end
+      def authenticate
+        session.authenticate
+      end
 
-        def client
-          @client ||= authenticate
-        end
+      def client
+        @client ||= authenticate
+      end
 
-        def entry_for(name, size, date, dir)
-          BrowseEverything::FileEntry.new(name, [key, name].join(':'), File.basename(name), size, date, dir)
-        end
+      # Construct a BrowseEverything::FileEntry object
+      # @param name [String]
+      # @param size [String]
+      # @param date [DateTime]
+      # @param dir [String]
+      # @return [BrowseEverything::FileEntry]
+      def entry_for(name, size, date, dir)
+        BrowseEverything::FileEntry.new(name, [key, name].join(':'), File.basename(name), size, date, dir)
+      end
 
-        def add_directories(listing)
-          listing.common_prefixes.each do |prefix|
-            @entries << entry_for(from_base(prefix.prefix), 0, Time.current, true)
-          end
+      # Populate the entries with FileEntry objects from an S3 listing
+      # @param listing [Seahorse::Client::Response]
+      def add_directories(listing)
+        listing.common_prefixes.each do |prefix|
+          new_entry = entry_for(from_base(prefix.prefix), 0, Time.current, true)
+          @entries << new_entry unless new_entry.nil?
         end
+      end
 
-        def add_files(listing, path)
-          listing.contents.each do |entry|
-            key = from_base(entry.key)
-            @entries << entry_for(key, entry.size, entry.last_modified, false) unless strip(key) == strip(path)
-          end
+      # Given a listing and a S3 listing and path, populate the entries
+      # @param listing [Seahorse::Client::Response]
+      # @param path [String]
+      def add_files(listing, path)
+        listing.contents.each do |entry|
+          key = from_base(entry.key)
+          new_entry = entry_for(key, entry.size, entry.last_modified, false)
+          @entries << new_entry unless strip(key) == strip(path) || new_entry.nil?
         end
+      end
 
-        def generate_listing(path)
-          client
-          listing = client.list_objects(bucket: config[:bucket], delimiter: '/', prefix: full_path(path))
-          add_directories(listing)
-          add_files(listing, path)
-        end
+      # For a given path to a S3 resource, retrieve the listing object and
+      # construct the file entries
+      # @param path [String]
+      def generate_listing(path)
+        client
+        listing = client.list_objects(bucket: config[:bucket], delimiter: '/', prefix: full_path(path))
+        add_directories(listing)
+        add_files(listing, path)
+      end
     end
   end
 end

data/lib/browse_everything/file_entry.rb

@@ -15,7 +15,7 @@ module BrowseEverything
     end
 
     def relative_parent_path?
-      name =~ /^\.\.?$/ ? true : false
+      name.match?(/^\.\.?$/)
     end
 
     def container?

data/lib/browse_everything/retriever.rb

@@ -31,8 +31,13 @@ module BrowseEverything
     attr_accessor :chunk_size
 
     class << self
-      def can_retrieve?(uri)
-        Typhoeus.get(uri, headers: { Range: 'bytes=0-0' }).success?
+      # Determines whether or not a remote resource can be retrieved
+      # @param uri [String] URI for the remote resource (usually a URL)
+      # @param headers [Hash] any custom headers required to transit the request
+      def can_retrieve?(uri, headers = {})
+        request_headers = headers.merge(Range: 'bytes=0-0')
+        response = Typhoeus.get(uri, headers: request_headers)
+        response.success?
       end
     end
 
@@ -84,81 +89,81 @@ module BrowseEverything
 
     private
 
-      # Extract and parse options used to download a file or resource from an HTTP API
-      # @param options [Hash]
-      # @return [Hash]
-      def extract_download_options(options)
-        url = options.fetch('url')
+    # Extract and parse options used to download a file or resource from an HTTP API
+    # @param options [Hash]
+    # @return [Hash]
+    def extract_download_options(options)
+      url = options.fetch('url')
 
-        # This avoids the potential for a KeyError
-        headers = options.fetch('headers', {}) || {}
+      # This avoids the potential for a KeyError
+      headers = options.fetch('headers', {}) || {}
 
-        file_size_value = options.fetch('file_size', 0)
-        file_size = file_size_value.to_i
+      file_size_value = options.fetch('file_size', 0)
+      file_size = file_size_value.to_i
 
-        output = {
-          url: ::Addressable::URI.parse(url),
-          headers: headers,
-          file_size: file_size
-        }
+      output = {
+        url: ::Addressable::URI.parse(url),
+        headers: headers,
+        file_size: file_size
+      }
 
-        output[:file_size] = get_file_size(output) if output[:file_size] < 1
-        output
-      end
+      output[:file_size] = get_file_size(output) if output[:file_size] < 1
+      output
+    end
 
-      # Retrieve the file from the file system
-      # @param options [Hash]
-      def retrieve_file(options)
-        file_uri = options.fetch(:url)
-        file_size = options.fetch(:file_size)
-
-        retrieved = 0
-        File.open(file_uri.path, 'rb') do |f|
-          until f.eof?
-            chunk = f.read(chunk_size)
-            retrieved += chunk.length
-            yield(chunk, retrieved, file_size)
-          end
+    # Retrieve the file from the file system
+    # @param options [Hash]
+    def retrieve_file(options)
+      file_uri = options.fetch(:url)
+      file_size = options.fetch(:file_size)
+
+      retrieved = 0
+      File.open(file_uri.path, 'rb') do |f|
+        until f.eof?
+          chunk = f.read(chunk_size)
+          retrieved += chunk.length
+          yield(chunk, retrieved, file_size)
         end
       end
+    end
 
-      # Retrieve a resource over the HTTP
-      # @param options [Hash]
-      def retrieve_http(options)
-        file_size = options.fetch(:file_size)
-        headers = options.fetch(:headers)
-        url = options.fetch(:url)
-        retrieved = 0
-
-        request = Typhoeus::Request.new(url.to_s, method: :get, headers: headers)
-        request.on_headers do |response|
-          raise DownloadError.new("#{self.class}: Failed to download #{url}: Status Code: #{response.code}", response) unless response.code == 200
-        end
-        request.on_body do |chunk|
-          retrieved += chunk.bytesize
-          yield(chunk, retrieved, file_size)
-        end
-        request.run
+    # Retrieve a resource over the HTTP
+    # @param options [Hash]
+    def retrieve_http(options)
+      file_size = options.fetch(:file_size)
+      headers = options.fetch(:headers)
+      url = options.fetch(:url)
+      retrieved = 0
+
+      request = Typhoeus::Request.new(url.to_s, method: :get, headers: headers)
+      request.on_headers do |response|
+        raise DownloadError.new("#{self.class}: Failed to download #{url}: Status Code: #{response.code}", response) unless response.code == 200
+      end
+      request.on_body do |chunk|
+        retrieved += chunk.bytesize
+        yield(chunk, retrieved, file_size)
       end
+      request.run
+    end
 
-      # Retrieve the file size
-      # @param options [Hash]
-      # @return [Integer] the size of the requested file
-      def get_file_size(options)
-        url = options.fetch(:url)
-        headers = options.fetch(:headers)
-        file_size = options.fetch(:file_size)
-
-        case url.scheme
-        when 'file'
-          File.size(url.path)
-        when /https?/
-          response = Typhoeus.head(url.to_s, headers: headers)
-          length_value = response.headers['Content-Length'] || file_size
-          length_value.to_i
-        else
-          raise URI::BadURIError, "Unknown URI scheme: #{url.scheme}"
-        end
+    # Retrieve the file size
+    # @param options [Hash]
+    # @return [Integer] the size of the requested file
+    def get_file_size(options)
+      url = options.fetch(:url)
+      headers = options.fetch(:headers)
+      file_size = options.fetch(:file_size)
+
+      case url.scheme
+      when 'file'
+        File.size(url.path)
+      when /https?/
+        response = Typhoeus.head(url.to_s, headers: headers)
+        length_value = response.headers['Content-Length'] || file_size
+        length_value.to_i
+      else
+        raise URI::BadURIError, "Unknown URI scheme: #{url.scheme}"
       end
+    end
   end
 end