browse-everything 0.15.1 → 0.16.0

data/lib/browse_everything/browser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module BrowseEverything
   class Browser
     attr_reader :providers
@@ -11,15 +13,20 @@ module BrowseEverything
         opts = BrowseEverything.config
       end
 
-      @providers = {}
-      opts.each_pair do |driver, config|
+      @providers = ActiveSupport::HashWithIndifferentAccess.new
+      opts.each_pair do |driver_key, config|
         begin
-          driver_klass = BrowseEverything::Driver.const_get((config[:driver] || driver.to_s).camelize.to_sym)
-          @providers[driver] = driver_klass.new(config.merge(url_options: url_options))
+          driver = driver_key.to_s
+          driver_klass = BrowseEverything::Driver.const_get((config[:driver] || driver).camelize.to_sym)
+          @providers[driver_key] = driver_klass.new(config.merge(url_options: url_options))
         rescue NameError
           Rails.logger.warn "Unknown provider: #{driver}"
         end
       end
     end
+
+    def first_provider
+      @providers.to_hash.each_value.to_a.first
+    end
   end
 end

data/lib/browse_everything/driver/authentication_factory.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module BrowseEverything
+  module Driver
+    # Class for instantiating authentication API Objects
+    class AuthenticationFactory
+      # Constructor
+      # @param klass [Class] the authentication object class
+      # @param params [Array, Hash] the parameters for the authentication constructor
+      def initialize(klass, *params)
+        @klass = klass
+        @params = params
+      end
+
+      # Constructs an authentication Object
+      # @return [Object]
+      def authenticate
+        @klass.new(*@params)
+      end
+    end
+  end
+end

data/lib/browse_everything/driver/base.rb

@@ -1,66 +1,119 @@
+# frozen_string_literal: true
+
 module BrowseEverything
   module Driver
+    # Abstract class for provider classes
     class Base
       include BrowseEverything::Engine.routes.url_helpers
 
-      attr_reader :config, :name
-      attr_accessor :token
+      # Provide accessor and mutator methods for @token and @code
+      attr_accessor :token, :code
+
+      # Integrate sorting lambdas for configuration using initializers
+      class << self
+        attr_accessor :sorter
+
+        # Provide a default sorting lambda
+        # @return [Proc]
+        def default_sorter
+          lambda { |files|
+            files.sort do |a, b|
+              if b.container?
+                a.container? ? a.name.downcase <=> b.name.downcase : 1
+              else
+                a.container? ? -1 : a.name.downcase <=> b.name.downcase
+              end
+            end
+          }
+        end
+
+        # Set the sorter lambda (or proc) for all subclasses
+        # (see Class.inherited)
+        # @param subclass [Class] the class inheriting from BrowseEverything::Driver::Base
+        def inherited(subclass)
+          subclass.sorter = sorter
+        end
+      end
 
-      def initialize(config, _session_info = {})
-        @config = config
+      # Constructor
+      # @param config_values [Hash] configuration for the driver
+      def initialize(config_values)
+        @config = config_values
+        @sorter = self.class.sorter || self.class.default_sorter
         validate_config
       end
 
+      # Ensure that the configuration Hash has indifferent access
+      # @return [ActiveSupport::HashWithIndifferentAccess]
+      def config
+        @config = ActiveSupport::HashWithIndifferentAccess.new(@config) if @config.is_a? Hash
+        @config
+      end
+
+      # Abstract method
+      def validate_config; end
+
+      # Generate the key for the driver
+      # @return [String]
       def key
         self.class.name.split(/::/).last.underscore
       end
 
+      # Generate the icon markup for the driver
+      # @return [String]
       def icon
         'unchecked'
       end
 
+      # Generate the name for the driver
+      # @return [String]
       def name
         @name ||= (@config[:name] || self.class.name.split(/::/).last.titleize)
       end
 
-      def validate_config
-      end
-
-      def contents(_path)
+      # Abstract method
+      def contents(*_args)
         []
       end
 
-      def details(_path)
-        nil
-      end
-
+      # Generate the link for a resource at a given path
+      # @param path [String] the path to the resource
+      # @return [Array<String, Hash>]
       def link_for(path)
         [path, { file_name: File.basename(path) }]
       end
 
+      # Abstract method
       def authorized?
         false
       end
 
-      # @return [Array{URI,Object}] 2 elements: the URI, and session data to store under "#{provider_name}_data"
+      # Abstract method
       def auth_link
         []
       end
 
-      def connect(_params, _data)
+      # Abstract method
+      def connect(*_args)
         nil
       end
 
       private
 
-        def callback
-          connector_response_url(callback_options)
-        end
-
+        # Generate the options for the Rails URL generation for API callbacks
         # remove the script_name parameter from the url_options since that is causing issues
         #   with the route not containing the engine path in rails 4.2.0
+        # @return [Hash]
         def callback_options
-          config[:url_options].reject { |k, _v| k == :script_name }
+          options = config.to_hash
+          options.deep_symbolize_keys!
+          options[:url_options].reject { |k, _v| k == :script_name }
+        end
+
+        # Generate the URL for the API callback
+        # @return [String]
+        def callback
+          connector_response_url(callback_options)
         end
     end
   end

data/lib/browse_everything/driver/box.rb

@@ -1,18 +1,36 @@
+# frozen_string_literal: true
+
+require 'ruby-box'
+require_relative 'authentication_factory'
+
 module BrowseEverything
   module Driver
     # Driver for accessing the Box API (https://www.box.com/home)
     class Box < Base
-      require 'ruby-box'
-
       ITEM_LIMIT = 99999
 
+      class << self
+        attr_accessor :authentication_klass
+
+        def default_authentication_klass
+          RubyBox::Session
+        end
+      end
+
+      # Constructor
+      # @param config_values [Hash] configuration for the driver
+      def initialize(config_values)
+        self.class.authentication_klass ||= self.class.default_authentication_klass
+        super(config_values)
+      end
+
       def icon
         'cloud'
       end
 
       def validate_config
         return if config[:client_id] && config[:client_secret]
-        raise BrowseEverything::InitializationError, 'Box driver requires both :client_id and :client_secret argument'
+        raise InitializationError, 'Box driver requires both :client_id and :client_secret argument'
       end
 
       # @param [String] id of the file or folder in Box
@@ -20,16 +38,16 @@ module BrowseEverything
       def contents(id = '')
         if id.empty?
           folder = box_client.root_folder
-          results = []
+          @entries = []
         else
           folder = box_client.folder_by_id(id)
-          results = [parent_directory(folder)]
+          @entries = [parent_directory(folder)]
         end
 
-        folder.items(ITEM_LIMIT, 0, %w(name size created_at)).collect do |f|
-          results << directory_entry(f)
+        folder.items(ITEM_LIMIT, 0, %w[name size created_at]).collect do |f|
+          @entries << directory_entry(f)
         end
-        results
+        @sorter.call(@entries)
       end
 
       # @param [String] id of the file in Box
@@ -68,17 +86,28 @@ module BrowseEverything
 
         def box_client
           if token_expired?
-            session = box_session(box_token)
+            session = box_session
             register_access_token(session.refresh_token(box_refresh_token))
           end
-          RubyBox::Client.new(box_session(box_token, box_refresh_token))
+          RubyBox::Client.new(box_session)
+        end
+
+        def session
+          AuthenticationFactory.new(
+            self.class.authentication_klass,
+            client_id: config[:client_id],
+            client_secret: config[:client_secret],
+            access_token: box_token,
+            refresh_token: box_refresh_token
+          )
+        end
+
+        def authenticate
+          session.authenticate
         end
 
-        def box_session(token = nil, refresh_token = nil)
-          RubyBox::Session.new(client_id: config[:client_id],
-                               client_secret: config[:client_secret],
-                               access_token: token,
-                               refresh_token: refresh_token)
+        def box_session
+          authenticate
         end
 
         # If there is an active session, {@token} will be set by {BrowseEverythingController} using data stored in the
@@ -114,8 +143,8 @@ module BrowseEverything
           BrowseEverything::FileEntry.new(Pathname(folder.name).join('..'), '', '..', 0, Time.current, true)
         end
 
-        def directory_entry(f)
-          BrowseEverything::FileEntry.new(f.id, "#{key}:#{f.id}", f.name, f.size, f.created_at, f.type == 'folder')
+        def directory_entry(file)
+          BrowseEverything::FileEntry.new(file.id, "#{key}:#{file.id}", file.name, file.size, file.created_at, file.type == 'folder')
         end
     end
   end

data/lib/browse_everything/driver/dropbox.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'dropbox_api'
+require_relative 'authentication_factory'
 
 module BrowseEverything
   module Driver
@@ -49,23 +52,34 @@ module BrowseEverything
         end
       end
 
+      class << self
+        attr_accessor :authentication_klass
+
+        def default_authentication_klass
+          DropboxApi::Authenticator
+        end
+      end
+
+      # Constructor
+      # @param config_values [Hash] configuration for the driver
+      def initialize(config_values)
+        self.class.authentication_klass ||= self.class.default_authentication_klass
+        super(config_values)
+      end
+
       def icon
         'dropbox'
       end
 
       def validate_config
-        raise BrowseEverything::InitializationError, 'Dropbox driver requires a :client_id argument' unless config[:client_id]
-        raise BrowseEverything::InitializationError, 'Dropbox driver requires a :client_secret argument' unless config[:client_secret]
+        raise InitializationError, 'Dropbox driver requires a :client_id argument' unless config[:client_id]
+        raise InitializationError, 'Dropbox driver requires a :client_secret argument' unless config[:client_secret]
       end
 
       def contents(path = '')
-        result = client.list_folder(path)
-        result.entries.map { |entry| FileEntryFactory.build(metadata: entry, key: key) }
-      end
-
-      def details(path)
-        metadata = client.get_metadata(path)
-        FileEntryFactory.build(metadata: metadata, key: key)
+        response = client.list_folder(path)
+        @entries = response.entries.map { |entry| FileEntryFactory.build(metadata: entry, key: key) }
+        @sorter.call(@entries)
       end
 
       def download(path)
@@ -102,8 +116,20 @@ module BrowseEverything
 
       private
 
+        def session
+          AuthenticationFactory.new(
+            self.class.authentication_klass,
+            config[:client_id],
+            config[:client_secret]
+          )
+        end
+
+        def authenticate
+          session.authenticate
+        end
+
         def authenticator
-          @authenticator ||= DropboxApi::Authenticator.new(config[:client_id], config[:client_secret])
+          @authenticator ||= authenticate
         end
 
         def client

data/lib/browse_everything/driver/file_system.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module BrowseEverything
   module Driver
     class FileSystem < Base
@@ -6,20 +8,18 @@ module BrowseEverything
       end
 
       def validate_config
-        return if config[:home].present?
-        raise BrowseEverything::InitializationError, 'FileSystem driver requires a :home argument'
+        raise BrowseEverything::InitializationError, 'FileSystem driver requires a :home argument' if config[:home].blank?
       end
 
       def contents(path = '')
-        relative_path = path.sub(%r{^[\/.]+}, '')
-        real_path = File.join(config[:home], relative_path)
-        entries = if File.directory?(real_path)
-                    make_directory_entry(relative_path, real_path)
-                  else
-                    [details(real_path)]
-                  end
+        real_path = File.join(config[:home], path)
+        @entries = if File.directory?(real_path)
+                     make_directory_entry real_path
+                   else
+                     [details(real_path)]
+                   end
 
-        sort_entries(entries)
+        @sorter.call(@entries)
       end
 
       def link_for(path)
@@ -33,7 +33,7 @@ module BrowseEverything
       end
 
       def details(path, display = File.basename(path))
-        return nil unless File.exist?(path)
+        return nil unless File.exist? path
         info = File::Stat.new(path)
         BrowseEverything::FileEntry.new(
           make_pathname(path),
@@ -47,31 +47,19 @@ module BrowseEverything
 
       private
 
-        def make_directory_entry(relative_path, real_path)
+        def make_directory_entry(real_path)
           entries = []
-          if relative_path.present?
-            entries << details(File.expand_path('..', real_path), '..')
-          end
           entries + Dir[File.join(real_path, '*')].collect { |f| details(f) }
         end
 
-        def sort_entries(entries)
-          entries.sort do |a, b|
-            if b.container?
-              a.container? ? a.name.downcase <=> b.name.downcase : 1
-            else
-              a.container? ? -1 : a.name.downcase <=> b.name.downcase
-            end
-          end
-        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
+        rescue StandardError => error
+          Rails.logger.error "Failed to find the file size for #{path}: #{error}"
           0
         end
     end