browse-everything 0.10.5 → 0.11.0

data/lib/browse_everything/driver/file_system.rb

@@ -1,30 +1,29 @@
 module BrowseEverything
   module Driver
     class FileSystem < Base
-
       def icon
         'file'
       end
-      
+
       def validate_config
         unless config[:home]
-          raise BrowseEverything::InitializationError, "FileSystem driver requires a :home argument"
+          raise BrowseEverything::InitializationError, 'FileSystem driver requires a :home argument'
         end
       end
 
-      def contents(path='')
-        relative_path = path.sub(%r{^[\/.]+},'')
+      def contents(path = '')
+        relative_path = path.sub(%r{^[\/.]+}, '')
         real_path = File.join(config[:home], relative_path)
         result = []
         if File.directory?(real_path)
           if relative_path.present?
-            result << details(File.expand_path('..',real_path),'..')
+            result << details(File.expand_path('..', real_path), '..')
           end
-          result += Dir[File.join(real_path,'*')].collect { |f| details(f) }
-        elsif File.exists?(real_path)
+          result += Dir[File.join(real_path, '*')].collect { |f| details(f) }
+        elsif File.exist?(real_path)
           result += [details(real_path)]
         end
-        result.sort do |a,b|
+        result.sort do |a, b|
           if b.container?
             a.container? ? a.name.downcase <=> b.name.downcase : 1
           else
@@ -33,20 +32,17 @@ module BrowseEverything
         end
       end
 
-      def details(path,display=nil)
-        if File.exists?(path)
-          info = File::Stat.new(path)
-          BrowseEverything::FileEntry.new(
-            Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(config[:home])),
-            [self.key,path].join(':'),
-            display || File.basename(path),
-            info.size,
-            info.mtime,
-            info.directory?
-          )
-        else
-          nil
-        end
+      def details(path, display = nil)
+        return nil unless File.exist?(path)
+        info = File::Stat.new(path)
+        BrowseEverything::FileEntry.new(
+          Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(config[:home])),
+          [key, path].join(':'),
+          display || File.basename(path),
+          info.size,
+          info.mtime,
+          info.directory?
+        )
       end
 
       def link_for(path)
@@ -59,6 +55,5 @@ module BrowseEverything
         true
       end
     end
-
   end
 end

data/lib/browse_everything/driver/google_drive.rb

@@ -1,8 +1,8 @@
 module BrowseEverything
   module Driver
     class GoogleDrive < Base
-
-      require 'google/api_client'
+      require 'google/apis/drive_v3'
+      require 'signet'
 
       def icon
         'google-plus-sign'
@@ -10,121 +10,97 @@ module BrowseEverything
 
       def validate_config
         unless config[:client_id]
-          raise BrowseEverything::InitializationError, "GoogleDrive driver requires a :client_id argument"
+          raise BrowseEverything::InitializationError, 'GoogleDrive driver requires a :client_id argument'
         end
         unless config[:client_secret]
-          raise BrowseEverything::InitializationError, "GoogleDrive driver requires a :client_secret argument"
+          raise BrowseEverything::InitializationError, 'GoogleDrive driver requires a :client_secret argument'
         end
       end
 
-      def contents(path='')
-        default_params = { }
+      def contents(path = '')
+        return to_enum(:contents, path) unless block_given?
+        default_params = {
+          order_by: 'folder,modifiedTime desc,name',
+          fields: 'nextPageToken,files(name,id,mimeType,size,modifiedTime,parents,web_content_link)'
+          # page_size: 100
+        }
         page_token = nil
-        files = []
         begin
-          unless path.blank?
-            default_params[:q] = "'#{path}' in parents"
-          end
-          unless page_token.blank?
-            default_params[:pageToken] = page_token
-          end
-          api_result = oauth_client.execute( api_method: drive.files.list, parameters: default_params )
-          response = JSON.parse(api_result.response.body)
-          page_token = response["nextPageToken"]
-          response["items"].select do |file|
-            path.blank? ? (file["parents"].blank? or file["parents"].any?{|p| p["isRoot"] }) : true
+          default_params[:q] = "'#{path}' in parents" unless path.blank?
+          default_params[:page_token] = page_token unless page_token.blank?
+          response = drive.list_files(default_params)
+          page_token = response.next_page_token
+          response.files.select do |file|
+            path.blank? ? (file.parents.blank? || file.parents.any? { |p| p == 'root' }) : true
           end.each do |file|
-            files << details(file, path)
+            d = details(file, path)
+            yield d if d
           end
         end while !page_token.blank?
-        files.compact
       end
 
-      def details(file, path='')
-        if file["downloadUrl"] or file["mimeType"] == "application/vnd.google-apps.folder"
-          BrowseEverything::FileEntry.new(
-            file["id"],
-            "#{self.key}:#{file["id"]}",
-            file["title"],
-            (file["fileSize"] || 0),
-            Time.parse(file["modifiedDate"]),
-            file["mimeType"] == "application/vnd.google-apps.folder",
-            file["mimeType"] == "application/vnd.google-apps.folder" ?
-                                  "directory" :
-                                  file["mimeType"]
-          )
-        end
+      def details(file, _path = '')
+        mime_folder = file.mime_type == 'application/vnd.google-apps.folder'
+        BrowseEverything::FileEntry.new(
+          file.id,
+          "#{key}:#{file.id}",
+          file.name,
+          file.size.to_i,
+          file.modified_time || DateTime.new,
+          mime_folder,
+          mime_folder ? 'directory' : file.mime_type
+        )
       end
 
       def link_for(id)
-        api_method = drive.files.get
-        api_result = oauth_client.execute(api_method: api_method, parameters: {fileId: id})
-        download_url = JSON.parse(api_result.response.body)["downloadUrl"]
-        auth_header = {'Authorization' => "Bearer #{oauth_client.authorization.access_token.to_s}"}
-        extras = { 
+        file = drive.get_file(id)
+        auth_header = { 'Authorization' => "Bearer #{auth_client.access_token}" }
+        extras = {
           auth_header: auth_header,
-          expires: 1.hour.from_now, 
-          file_name: api_result.data.title,
-          file_size: api_result.data.fileSize.to_i
+          expires: 1.hour.from_now,
+          file_name: file.name,
+          file_size: file.size.to_i
         }
-        [download_url, extras]
+        [file.web_content_link, extras]
       end
 
       def auth_link
-        oauth_client.authorization.authorization_uri.to_s
+        auth_client.authorization_uri
       end
 
       def authorized?
-        @token.present?
+        token.present?
       end
 
-      def connect(params, data)
-        oauth_client.authorization.code = params[:code]
-        @token = oauth_client.authorization.fetch_access_token!
+      def connect(params, _data)
+        auth_client.code = params[:code]
+        self.token = auth_client.fetch_access_token!
       end
 
       def drive
-        oauth_client.discovered_api('drive', 'v2')
+        @drive ||= Google::Apis::DriveV3::DriveService.new.tap do |s|
+          s.authorization = authorization
+        end
       end
 
       private
 
-      #As per issue http://stackoverflow.com/questions/12572723/rails-google-client-api-unable-to-exchange-a-refresh-token-for-access-token
-
-      #patch start
-      def token_expired?(token)
-        client=@client
-        result = client.execute( api_method: drive.files.list, parameters: {} )
-        (result.status != 200)
-      end
-
-      def exchange_refresh_token( refresh_token )
-        client=oauth_client
-        client.authorization.grant_type = 'refresh_token'
-        client.authorization.refresh_token = refresh_token
-        client.authorization.fetch_access_token!
-        client.authorization
-        client
+      def authorization
+        return @auth_client unless @auth_client.nil?
+        return nil unless token.present?
+        auth_client.update_token!(token)
+        self.token = auth_client.fetch_access_token! if auth_client.expired?
+        auth_client
       end
-      #patch end
 
-      def oauth_client
-        if @client.nil?
-          @client = Google::APIClient.new
-          @client.authorization.client_id = config[:client_id]
-          @client.authorization.client_secret = config[:client_secret]
-          @client.authorization.scope = "https://www.googleapis.com/auth/drive"
-          @client.authorization.redirect_uri = callback
-          @client.authorization.update_token!(@token) if @token.present?
-           #Patch start
-          @client = exchange_refresh_token(@token["refresh_token"]) if @token.present? && token_expired?(@token)
-          #Patch end
-        end
-        #todo error checking here
-        @client
+      def auth_client
+        @auth_client ||= Signet::OAuth2::Client.new token_credential_uri: 'https://www.googleapis.com/oauth2/v3/token',
+                                                    authorization_uri: 'https://accounts.google.com/o/oauth2/auth',
+                                                    scope: 'https://www.googleapis.com/auth/drive',
+                                                    client_id: config[:client_id],
+                                                    client_secret: config[:client_secret],
+                                                    redirect_uri: callback
       end
-
     end
-
   end
 end

data/lib/browse_everything/driver/s3.rb

@@ -0,0 +1,87 @@
+require 'aws-sdk'
+
+module BrowseEverything
+  module Driver
+    class S3 < Base
+      DEFAULTS = { signed_url: true, region: 'us-east-1' }
+      
+      def initialize config, *args
+        config = DEFAULTS.merge(config)
+        super
+      end
+      
+      def icon
+        'amazon'
+      end
+      
+      def validate_config
+        unless [:app_key, :app_secret, :bucket].all? { |key| config[key].present? }
+          raise BrowseEverything::InitializationError, 'Amazon S3 driver requires :bucket, :app_key and :app_secret'
+        end
+      end
+      
+      def contents(path = '')
+        path = File.join(path,'') unless path.empty?
+        result = []
+        listing = client.list_objects(bucket: config[:bucket], delimiter: '/', prefix: path)
+        unless path.empty?
+          result << BrowseEverything::FileEntry.new(
+            Pathname(path).join('..'),
+            '', '..', 0, Time.now, true
+          )
+        end
+        listing.common_prefixes.each do |prefix|
+          result << entry_for(prefix.prefix, 0, Time.now, true)
+        end
+        listing.contents.reject { |entry| entry.key == path }.each do |entry|
+          result << entry_for(entry.key, entry.size, entry.last_modified, false)
+        end
+        result.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 entry_for(name, size, date, dir)
+        BrowseEverything::FileEntry.new(name, [key,name].join(':'), File.basename(name), size, date, dir)
+      end
+      
+      def details(path)
+        entry = client.head_object(path)
+        BrowseEverything::FileEntry.new(
+          entry.key,
+          [key,entry.key].join(':'),
+          File.basename(entry.key),
+          entry.size,
+          entry.last_modified,
+          false
+        )
+      end
+      
+      def link_for(path)
+        obj = bucket.object(path)
+        if config[:signed_url]
+          obj.presigned_url(:get, expires_in: 14400)
+        else
+          obj.public_url
+        end
+      end
+      
+      def authorized?
+        true
+      end
+      
+      def bucket
+        @bucket ||= Aws::S3::Bucket.new(config[:bucket], client: client)
+      end
+      
+      def client
+        @client ||= Aws::S3::Client.new(credentials: Aws::Credentials.new(config[:app_key], config[:app_secret]), region: config[:region])
+      end
+
+    end
+  end
+end

data/lib/browse_everything/driver/sky_drive.rb

@@ -1,7 +1,6 @@
 module BrowseEverything
   module Driver
     class SkyDrive < Base
-
       require 'skydrive'
 
       def icon
@@ -9,27 +8,27 @@ module BrowseEverything
       end
 
       def container_items
-        ["folder","album"]
+        %w(folder album)
       end
 
       def validate_config
         unless config[:client_id]
-          raise BrowseEverything::InitializationError, "SkyDrive driver requires a :client_id argument"
+          raise BrowseEverything::InitializationError, 'SkyDrive driver requires a :client_id argument'
         end
         unless config[:client_secret]
-          raise BrowseEverything::InitializationError, "SkyDrive driver requires a :client_secret argument"
+          raise BrowseEverything::InitializationError, 'SkyDrive driver requires a :client_secret argument'
         end
       end
 
-      def contents(path='')
+      def contents(path = '')
         result = []
         token_obj = rehydrate_token
         client = Skydrive::Client.new(token_obj)
-        if (path == '')
+        if path == ''
           folder = client.my_skydrive
-        #todo do some loop to get down to my path
+        # TODO: do some loop to get down to my path
         else
-          folder = client.get("/#{path.gsub("-",".")}/")
+          folder = client.get("/#{path.tr('-', '.')}/")
           result += [parent_folder_details(folder)] if folder.parent_id
         end
 
@@ -47,68 +46,63 @@ module BrowseEverything
 
       def link_for(path)
         response = Skydrive::Client.new(rehydrate_token).get("/#{real_id(path)}/")
-        [response.download_link, {expires: 1.hour.from_now, file_name: File.basename(path), file_size: response.size.to_i}]
+        [response.download_link, { expires: 1.hour.from_now, file_name: File.basename(path), file_size: response.size.to_i }]
       end
 
-
-
       def file_details(file)
-          BrowseEverything::FileEntry.new(
-            safe_id(file.id),
-            "#{key}:#{safe_id(file.id)}",
-            file.name,
-            file.size,
-            file.updated_time,
-            false
-          )
+        BrowseEverything::FileEntry.new(
+          safe_id(file.id),
+          "#{key}:#{safe_id(file.id)}",
+          file.name,
+          file.size,
+          file.updated_time,
+          false
+        )
       end
 
-     def parent_folder_details(file)
-          BrowseEverything::FileEntry.new(
-            safe_id(file.parent_id),
-            "#{key}:#{safe_id(file.parent_id)}",
-            "..",
-            0,
-            Time.now,
-            true
-          )
+      def parent_folder_details(file)
+        BrowseEverything::FileEntry.new(
+          safe_id(file.parent_id),
+          "#{key}:#{safe_id(file.parent_id)}",
+          '..',
+          0,
+          Time.now,
+          true
+        )
       end
 
-
-
-
       def folder_details(folder)
         BrowseEverything::FileEntry.new(
-            safe_id(folder.id),
-            "#{key}:#{safe_id(folder.id)}",
-            folder.name,
-            0,
-            folder.updated_time,
-            true,
-            'directory'#todo how are we getting mime type
+          safe_id(folder.id),
+          "#{key}:#{safe_id(folder.id)}",
+          folder.name,
+          0,
+          folder.updated_time,
+          true,
+          'directory' # TODO: how are we getting mime type
         )
       end
 
-
       def auth_link
         oauth_client.authorize_url
       end
 
       def authorized?
         return false unless @token.present?
-        return !rehydrate_token.expired?
+        !rehydrate_token.expired?
       end
 
-      def connect(params,data)
+      def connect(params, _data)
         Rails.logger.warn "params #{params.inspect}"
         token = oauth_client.get_access_token(params[:code])
-        @token = {token:token.token, expires_at:token.expires_at}
+        @token = { token: token.token, expires_at: token.expires_at }
       end
 
       private
+
       def oauth_client
-        Skydrive::Oauth::Client.new(config[:client_id], config[:client_secret], callback.to_s,"wl.skydrive")
-        #todo error checking here
+        Skydrive::Oauth::Client.new(config[:client_id], config[:client_secret], callback.to_s, 'wl.skydrive')
+        # TODO: error checking here
       end
 
       def rehydrate_token
@@ -116,15 +110,15 @@ module BrowseEverything
         token_str = @token[:token]
         token_expires = @token[:expires_at]
         Rails.logger.warn "\n\n Rehydrating: #{@token} #{token_str} #{token_expires}"
-        @rehydrate_token = oauth_client.get_access_token_from_hash(token_str,{expires_at:token_expires})
+        @rehydrate_token = oauth_client.get_access_token_from_hash(token_str, expires_at: token_expires)
       end
 
       def safe_id(id)
-        id.gsub(".","-")
+        id.tr('.', '-')
       end
 
       def real_id(id)
-        id.gsub("-",".")
+        id.tr('-', '.')
       end
     end
   end