browse-everything 0.15.1 → 0.16.0

data/lib/browse_everything/engine.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module BrowseEverything
   class Engine < ::Rails::Engine
     config.assets.paths << config.root.join('vendor', 'assets', 'javascripts')
     config.assets.paths << config.root.join('vendor', 'assets', 'stylesheets')
-    config.assets.precompile += %w(browse_everything.js)
-    config.assets.precompile += %w(browse_everything.css)
+    config.assets.precompile += %w[browse_everything.js browse_everything.css]
   end
 end

data/lib/browse_everything/file_entry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module BrowseEverything
   class FileEntry
     attr_reader :id, :location, :name, :size, :mtime, :type
@@ -13,7 +15,7 @@ module BrowseEverything
     end
 
     def relative_parent_path?
-      name =~ /^\.\.?$/ ? true : false
+      /^\.\.?$/.match(name) ? true : false
     end
 
     def container?

data/lib/browse_everything/retriever.rb

@@ -1,15 +1,49 @@
-require 'httparty'
-require 'tempfile'
+# frozen_string_literal: true
+
 require 'addressable'
+require 'tempfile'
+require 'typhoeus'
 
 module BrowseEverything
+  # Class for raising errors when a download is invalid
+  class DownloadError < StandardError
+    attr_reader :response
+
+    # Constructor
+    # @param msg [String]
+    # @param response [Typhoeus::Response] response from the server
+    def initialize(msg, response)
+      @response = response
+      super(msg)
+    end
+
+    # Generate the message for the exception
+    # @return [String]
+    def message
+      "#{super}: #{response.body}"
+    end
+  end
+
+  # Class for retrieving a file or resource from a storage provider
   class Retriever
+    CHUNK_SIZE = 16384
+
     attr_accessor :chunk_size
 
+    class << self
+      def can_retrieve?(uri)
+        Typhoeus.get(uri, headers: { Range: 'bytes=0-0' }).success?
+      end
+    end
+
+    # Constructor
     def initialize
-      @chunk_size = 16384
+      @chunk_size = CHUNK_SIZE
     end
 
+    # Download a file or resource
+    # @param options [Hash]
+    # @param target [String, nil] system path to the downloaded file (defaults to a temporary file)
     def download(spec, target = nil)
       if target.nil?
         ext = File.extname(spec['file_name'])
@@ -26,65 +60,103 @@ module BrowseEverything
       target
     end
 
-    def retrieve(spec, &block)
-      if spec.key?('expires') && Time.parse(spec['expires']) < Time.now
-        raise ArgumentError, "Download spec expired at #{spec['expires']}"
+    # Retrieve the resource from the storage service
+    # @param options [Hash]
+    def retrieve(options, &block)
+      expiry_time_value = options.fetch('expires', nil)
+      if expiry_time_value
+        expiry_time = Time.parse(expiry_time_value)
+        raise ArgumentError, "Download expired at #{expiry_time}" if expiry_time < Time.now
       end
 
-      parsed_spec = parse_spec(spec)
+      download_options = extract_download_options(options)
+      url = download_options.fetch(:url)
 
-      case parsed_spec[:url].scheme
+      case url.scheme
       when 'file'
-        retrieve_file(parsed_spec, &block)
+        retrieve_file(download_options, &block)
       when /https?/
-        retrieve_http(parsed_spec, &block)
+        retrieve_http(download_options, &block)
       else
-        raise URI::BadURIError, "Unknown URI scheme: #{parsed_spec[:url].scheme}"
+        raise URI::BadURIError, "Unknown URI scheme: #{url.scheme}"
       end
     end
 
     private
 
-      def parse_spec(spec)
-        result = {
-          url: ::Addressable::URI.parse(spec['url']),
-          headers: spec['auth_header'] || {},
-          file_size: spec.fetch('file_size', 0).to_i
+      # 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('auth_header', {}) || {}
+        headers.each_pair { |k, v| headers[k] = v.tr('+', ' ') }
+
+        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
         }
 
-        result[:headers].each_pair { |k, v| result[:headers][k] = v.tr('+', ' ') }
-        result[:file_size] = get_file_size(result) if result[:file_size] < 1
-        result
+        output[:file_size] = get_file_size(output) if output[:file_size] < 1
+        output
       end
 
-      def retrieve_file(parsed_spec)
+      # 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(parsed_spec[:url].path, 'rb') do |f|
+        File.open(file_uri.path, 'rb') do |f|
           until f.eof?
             chunk = f.read(chunk_size)
             retrieved += chunk.length
-            yield(chunk, retrieved, parsed_spec[:file_size])
+            yield(chunk, retrieved, file_size)
           end
         end
       end
 
-      def retrieve_http(parsed_spec)
+      # 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
-        stream_body = parsed_spec[:file_size] > 500.megabytes
 
-        HTTParty.get(parsed_spec[:url].to_s, stream_body: stream_body, headers: parsed_spec[:headers]) do |chunk|
-          retrieved += chunk.length
-          yield(chunk, retrieved, parsed_spec[:file_size])
+        request = Typhoeus::Request.new(url.to_s)
+        request.on_headers do |response|
+          raise DownloadError.new("#{self.class}: Failed to download #{url}", response) unless response.code == 200
         end
+        request.on_body do |chunk|
+          retrieved += chunk.bytesize
+          yield(chunk, retrieved, file_size)
+        end
+        request.run
       end
 
-      def get_file_size(parsed_spec)
-        case parsed_spec[:url].scheme
+      # 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 = HTTParty.head(parsed_spec[:url].to_s, headers: parsed_spec[:headers])
-          (response.content_length || parsed_spec[:file_size]).to_i
+          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

data/lib/browse_everything/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module BrowseEverything
-  VERSION = '0.15.1'.freeze
+  VERSION = '0.16.0'
 end

data/lib/generators/browse_everything/assets_generator.rb

@@ -1,10 +1,11 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
 require 'rails/generators'
 
 class BrowseEverything::AssetsGenerator < Rails::Generators::Base
   desc 'This generator installs the browse_everything CSS assets into your application'
 
-  source_root File.expand_path('../templates', __FILE__)
+  source_root File.expand_path('templates', __dir__)
 
   def inject_css
     copy_file 'browse_everything.scss', 'app/assets/stylesheets/browse_everything.scss'

data/lib/generators/browse_everything/config_generator.rb

@@ -1,13 +1,14 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
 require 'rails/generators'
 
 class BrowseEverything::ConfigGenerator < Rails::Generators::Base
-  desc <<-END_OF_DESC
-This generator makes the following changes to your application:
- 1. Creates config/browse_everything_providers.yml with a placeholder value
- 2. Modifies your app's routes.rb to mount BrowseEverything at /browse
-  END_OF_DESC
-  source_root File.expand_path('../templates', __FILE__)
+  desc <<-DESC
+  This generator makes the following changes to your application:
+   1. Creates config/browse_everything_providers.yml with a placeholder value
+   2. Modifies your app's routes.rb to mount BrowseEverything at /browse
+    DESC
+  source_root File.expand_path('templates', __dir__)
 
   def inject_routes
     insert_into_file 'config/routes.rb', after: '.draw do' do
@@ -17,12 +18,13 @@ This generator makes the following changes to your application:
   end
 
   def copy_example_config
-    copy_file 'browse_everything_providers.yml.example', 'config/browse_everything_providers.yml'
+    FileUtils.rm 'config/browse_everything_providers.yml', force: true if File.exists? 'config/browse_everything_providers.yml'
+    copy_file 'browse_everything_providers.yml.example', 'config/browse_everything_providers.yml', force: true
   end
 
   def insert_file_system_path
     insert_into_file 'config/browse_everything_providers.yml', before: '# dropbox:' do
-      YAML.dump('file_system' => { home: Rails.root.to_s })
+      "file_system:\n  home: #{Rails.root}\n"
     end
   end
 end

data/lib/generators/browse_everything/install_generator.rb

@@ -1,4 +1,5 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
 require 'rails/generators'
 
 class BrowseEverything::InstallGenerator < Rails::Generators::Base
@@ -6,7 +7,7 @@ class BrowseEverything::InstallGenerator < Rails::Generators::Base
 
   desc 'This generator installs the browse everything configuration and assets into your application'
 
-  source_root File.expand_path('../templates', __FILE__)
+  source_root File.expand_path('templates', __dir__)
 
   def inject_config
     generate 'browse_everything:config'

data/lib/generators/browse_everything/templates/browse_everything_providers.yml.example

@@ -3,18 +3,19 @@
 # The file_system provider can be a path to any directory on the server where your application is running.
 #
 # dropbox:
-#   :app_key: YOUR_DROPBOX_APP_KEY
-#   :app_secret: YOUR_DROPBOX_APP_SECRET
+#   app_key: YOUR_DROPBOX_APP_KEY
+#   app_secret: YOUR_DROPBOX_APP_SECRET
 # box:
-#   :client_id: YOUR_BOX_CLIENT_ID
-#   :client_secret: YOUR_BOX_CLIENT_SECRET
+#   client_id: YOUR_BOX_CLIENT_ID
+#   client_secret: YOUR_BOX_CLIENT_SECRET
 # google_drive:
-#   :client_id: YOUR_GOOGLE_API_CLIENT_ID
-#   :client_secret: YOUR_GOOGLE_API_CLIENT_SECRET
+#   client_id: YOUR_GOOGLE_API_CLIENT_ID
+#   client_secret: YOUR_GOOGLE_API_CLIENT_SECRET
 # s3:
-#   :bucket: YOUR_AWS_S3_BUCKET
-#   :response_type: :signed_url # set to :public_url for public urls or :s3_uri for an s3://BUCKET/KEY uri
-#   :app_key: YOUR_AWS_S3_KEY       # :app_key, :app_secret, and :region can be specified
-#   :app_secret: YOUR_AWS_S3_SECRET # explicitly here, or left out to use system-configured
-#   :region: YOUR_AWS_S3_REGION     # defaults.
+#   bucket: YOUR_AWS_S3_BUCKET
+#   response_type: signed_url # set to :public_url for public urls or :s3_uri for an s3://BUCKET/KEY uri
+#   expires_in: 14400 # for signed_url response_type, number of seconds url will be valid for.
+#   app_key: YOUR_AWS_S3_KEY       # :app_key, :app_secret, and :region can be specified
+#   app_secret: YOUR_AWS_S3_SECRET # explicitly here, or left out to use system-configured
+#   region: YOUR_AWS_S3_REGION     # defaults.
 #   See https://aws.amazon.com/blogs/security/a-new-and-standardized-way-to-manage-credentials-in-the-aws-sdks/

data/spec/controllers/browse_everything_controller_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'signet/errors'
+
+RSpec.describe BrowseEverythingController, type: :controller do
+  routes { Rails.application.class.routes }
+
+  let(:provider) { instance_double(BrowseEverything::Driver::Base) }
+
+  before do
+    allow(provider).to receive(:authorized?).and_return(true)
+    allow(controller).to receive(:provider).and_return(provider)
+  end
+
+  describe '#auth' do
+    let(:provider_session) { instance_double(BrowseEverythingSession::ProviderSession) }
+
+    before do
+      allow(controller).to receive(:params).and_return('code' => 'test-code')
+      allow(provider_session).to receive(:data).and_return(nil)
+      allow(provider).to receive(:connect)
+      controller.auth
+    end
+    it 'retrieves the authorization code from the parameters' do
+      expect(provider).to have_received(:connect).with({ 'code' => 'test-code' }, nil)
+    end
+  end
+
+  describe '#show' do
+    let(:file1) { instance_double(BrowseEverything::FileEntry) }
+    let(:file2) { instance_double(BrowseEverything::FileEntry) }
+
+    before do
+      allow(provider).to receive(:contents).and_return([file1, file2])
+      allow(controller).to receive(:render).with(partial: 'files', layout: true)
+    end
+
+    it 'renders the files retrieved by the provider' do
+      allow(provider).to receive(:contents).and_return([file1, file2])
+      controller.show
+      expect(controller).to have_received(:render).with(partial: 'files', layout: true)
+    end
+
+    context 'when an authentication error occurs while retrieving the files' do
+      let(:provider_session) { instance_double(BrowseEverythingSession::ProviderSession) }
+
+      before do
+        controller.instance_variable_set(:@provider_session, provider_session)
+        allow(controller).to receive(:render).with(partial: 'auth', layout: true)
+        allow(controller).to receive(:render).with(partial: 'files', layout: true).and_raise(Signet::AuthorizationError)
+        allow(provider_session).to receive(:token=)
+        allow(provider_session).to receive(:code=)
+        allow(provider_session).to receive(:data=)
+        controller.show
+      end
+
+      it 'clears the Rails session of auth. data' do
+        expect(provider_session).to have_received(:token=).with(nil)
+        expect(provider_session).to have_received(:code=).with(nil)
+        expect(provider_session).to have_received(:data=).with(nil)
+        expect(provider_session.instance_variable_get(:@provider_session)).to be_nil
+      end
+    end
+
+    context 'when a remote API error occurs while retrieving the files' do
+      before do
+        allow(controller).to receive(:render).with(partial: 'auth', layout: true)
+        allow(controller).to receive(:render).with(partial: 'files', layout: true).and_raise(StandardError)
+        allow(controller).to receive(:reset_provider_session!)
+        controller.show
+      end
+
+      it 'directs the user to reauthenticate after attempting to render the files' do
+        expect(controller).to have_received(:render).with(partial: 'auth', layout: true)
+        expect(controller).to have_received(:reset_provider_session!)
+      end
+    end
+  end
+end

data/spec/features/select_files_spec.rb

@@ -1,30 +1,30 @@
-require 'capybara/poltergeist'
+# frozen_string_literal: true
 
-describe 'Choosing files', type: :feature do
+describe 'Choosing files', type: :feature, js: true do
   before do
-    Capybara.register_driver :poltergeist do |app|
-      Capybara::Poltergeist::Driver.new(app, js_errors: true, timeout: 90)
-    end
-    Capybara.current_driver = :poltergeist
     visit '/'
   end
 
   shared_examples 'browseable files' do
     it 'selects files from the filesystem' do
       click_button('Browse')
-      sleep(5)
-      click_link('Gemfile.lock')
-      check('config-ru')
+      wait_for_ajax
+
+      expect(page).to have_selector '#browse-everything'
+      expect(page).to have_link 'config.ru'
+      find(:css, '#config-ru').set(true)
+
       within('.modal-footer') do
-        expect(page).to have_selector('span', text: '2 files selected')
         click_button('Submit')
       end
-      sleep(5)
-      expect(page).to have_selector('#status', text: '2 items selected')
+
+      wait_for_ajax
+
+      expect(page).to have_selector('#status', text: '1 items selected')
     end
   end
 
-  context 'when Turbolinks are enabled' do
+  context 'when Turbolinks are enabled', fail: true do
     before { click_link('Enter Test App (Turbolinks)') }
     it_behaves_like 'browseable files'
   end