boar 1.0.1

data/app/models/boar/handlers/downloads/remote.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+#
+# This file is part of the boar gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Boar
+  module Handlers
+    module Downloads
+      class Remote < Base
+        def call(path, entry, _, _, _)
+          # Get the url
+          url = entry[:url]
+
+          # We can't download a directory
+          raise Boar::Exceptions::NotFound.new(path) if url.blank?
+
+          # Redirect to the remote URL
+          @service.controller.redirect_to(self.interpolate(url, {path: path, entry: entry, options: @provider_options}))
+        end
+      end
+    end
+  end
+end

data/app/models/boar/handlers/downloads/s3.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+#
+# This file is part of the boar gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Boar
+  module Handlers
+    module Downloads
+      #noinspection RubyClassModuleNamingConvention
+      class S3 < Base
+        URL_AGE = 604800
+
+        def initialize(service, options)
+          super(service, options)
+
+          configuration = self.load_credentials
+          @s3_configuration = {access_key_id: configuration[:access_key], secret_access_key: configuration[:access_secret], region: configuration[:region]}
+        end
+
+        def call(path, entry, skip_cache, _, _)
+          # Read the URL from Redis
+          key = @configuration.backend_key("downloads:s3[#{path}]", self, @service.controller.request)
+          url = @configuration.backend.get(key)
+
+          if skip_cache || url.blank? then
+            begin
+              # Update the region
+              @s3_configuration[:region] = entry[:region] if entry[:region].present?
+
+              # Get the object
+              object = AWS::S3.new(@s3_configuration).buckets[entry[:bucket]].objects[entry[:key]]
+              raise ArgumentError if !object.exists?
+
+              # Get the public URL
+              url = object.url_for(:read, response_content_disposition: entry[:disposition], expire: Boar::Handlers::Downloads::S3::URL_AGE).to_s
+
+              # Save the URL
+              if url.present? then
+                @configuration.backend.set(key, url)
+                @configuration.backend.expire(key, Boar::Handlers::Downloads::S3::URL_AGE)
+              end
+            rescue => e
+              raise Boar::Exceptions::ServerError.new("[#{e.class}] #{e.message}")
+            end
+          end
+
+          # Redirect to the final URL
+          @service.controller.redirect_to(url)
+        end
+      end
+    end
+  end
+end

data/app/models/boar/handlers/downloads/sky_drive.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+#
+# This file is part of the boar gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Boar
+  module Handlers
+    module Downloads
+      class SkyDrive < Base
+        def initialize(service, options)
+          super(service, options)
+
+          @client = Boar::Providers::SkyDrive.authorized_client(self.load_credentials, self.credentials_params)
+        end
+
+        def call(path, entry, skip_cache, _, _)
+          # Read the URL from Redis
+          key = @configuration.backend_key("downloads:sky_drive[#{path}]", self, @service.controller.request)
+          url = @configuration.backend.get(key)
+
+          if skip_cache || url.blank? then
+            begin
+              # Get the file
+              file = @client.get("/" + entry[:id]) rescue nil
+              raise Boar::Exceptions::NotFound if file.blank?
+
+              url = entry["disposition"] == "inline" ? file.link : file.download_link
+              raise Boar::Exceptions::NotFound if url.blank?
+
+              # Save the URL
+              @configuration.backend.set(key, url) if url.present?
+            rescue => e
+              raise e
+              raise Boar::Exceptions::ServerError.new("[#{e.class}] #{e.message}")
+            end
+          end
+
+          # Redirect to the final URL
+          @service.controller.redirect_to(url)
+        end
+      end
+    end
+  end
+end

data/app/models/boar/handlers/generic.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+#
+# This file is part of the boar gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Boar
+  module Handlers
+    class Generic
+      include Boar::Utils::Basic
+
+      attr_accessor :service
+      attr_accessor :configuration
+
+      def initialize(service, _ = nil)
+        @service = service
+        @configuration = Rails.application.config.boar
+      end
+
+      def call(*_)
+        raise Boar::Exceptions::UnImplemented.new
+      end
+    end
+  end
+end

data/app/models/boar/handlers/hosts.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+#
+# This file is part of the boar gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Boar
+  module Handlers
+    class Hosts < Boar::Handlers::Generic
+      def initialize(*args)
+      end
+
+      def call(request, domain = nil, port = nil)
+        domain ||= request.domain
+        port ||= request.port
+        rv = [domain, port].join(":")
+
+        if rv == "localhost:3000" then
+          rv = "localhost"
+        elsif ["http/80", "https/443"].include?([request.protocol, request.port].join("/")) then
+          rv = request.domain
+        end
+
+        rv
+      end
+    end
+  end
+end

data/app/models/boar/handlers/locale.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+#
+# This file is part of the boar gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Boar
+  module Handlers
+    class Locale < Boar::Handlers::Generic
+      attr_reader :locale_param
+
+      def initialize(service, options)
+        super(service)
+
+        # Get the parameter
+        @locale_param = self.get_option(options, :locale_param, @configuration.locale_param)
+      end
+
+      def call(*_)
+        # Retrieve locale from the controller's params.
+        @service.controller.params[@locale_param].ensure_string
+      end
+    end
+  end
+end

data/app/models/boar/handlers/path_mapper.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+#
+# This file is part of the boar gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Boar
+  module Handlers
+    class PathMapper < Boar::Handlers::Generic
+      def call(_, path)
+        path
+      end
+    end
+  end
+end

data/app/models/boar/handlers/root.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+#
+# This file is part of the boar gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Boar
+  module Handlers
+    class Root < Boar::Handlers::Generic
+      attr_reader :template
+
+      def initialize(service, options)
+        super(service)
+
+        # Get the template for building the root
+        @template = self.get_option(options, :directory, @configuration.directory)
+      end
+
+      def call(*_)
+        # Interpolate to a directory
+        Pathname.new(self.interpolate(@template, {root: Rails.root, request: @service.controller.request, controller: @service.controller}))
+      end
+    end
+  end
+end

data/app/models/boar/handlers/views.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+#
+# This file is part of the boar gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Boar
+  module Handlers
+    class Views < Boar::Handlers::Generic
+      attr_reader :views
+
+      def initialize(service, options)
+        super(service)
+
+        # Get the views
+        @views = self.get_option(options, :views, @configuration.views)
+      end
+
+      def call(*args)
+        # Interpolate the template
+        self.interpolate(@views.fetch(args[0]), ensure_hash(args[1]))
+      end
+    end
+  end
+end

data/app/models/boar/services/downloads.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+#
+# This file is part of the boar gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Boar
+  module Services
+    class Downloads < Boar::Services::Generic
+      attr_accessor :downloads_configuration
+
+      def downloads
+        # Get the full path
+        path = @params[:path]
+
+        # Handle ACL for the path
+        self.handle_authentication(path, @options)
+
+        if !controller.performed? then
+          load_configuration(@skip_cache) # Instantiate the configuration
+
+          # Try to match the path against the list of files
+          match_data = nil
+          found = @downloads_configuration[:files].find{ |k, _| match_data = Regexp.new("^#{k}$").match(path) }
+          raise Boar::Exceptions::NotFound.new(path) if !found
+
+          # Get entry
+          regexp, entry = split_entry(found)
+
+          # Map the path
+          path = self.handler_for(:downloads_mapper, options).call(self, path)
+
+          # Now execute the provider. This will take care of acting on the controller
+          begin
+            provider_for_entry(entry).call(path, entry, @skip_cache, regexp, match_data)
+          rescue ::Mbrao::Exceptions::Unimplemented => e
+            raise Mbrao::Exceptions::Unimplemented.new(e)
+          end
+        end
+      end
+
+      def update
+        args = {nothing: true, status: :ok}
+
+        begin
+          load_configuration(true)
+        rescue => e
+          args = {text: e.message, status: 500}
+        end
+
+        @controller.render(args)
+      end
+
+      def download_file(*args)
+        @controller.send_file(*args)
+      end
+
+      private
+        def split_entry(found)
+          rv = found.last
+          rv = HashWithIndifferentAccess.new(rv.is_a?(Hash) ? rv : {provider: rv.ensure_string.to_sym}) # Make sure there is a provider key
+
+          # Get default provider is nothing is there
+          rv[:provider] ||= get_option(@options, :default_provider, @configuration.default_provider).to_s
+
+          [found.first, rv]
+        end
+
+        def provider_for_entry(entry)
+          # Instantiate the provider
+          @providers ||= {}
+          @providers[entry[:provider]] ||= ::Lazier.find_class(entry[:provider], "::Boar::Handlers::Downloads::%CLASS%", true).new(self, @downloads_configuration[:options])
+        end
+
+        def load_configuration(force = false)
+          # Setup stuff
+          config = Rails.application.config.boar
+          template = get_option(@options, :config, @configuration.config_file)
+          key = @configuration.backend_key("downloads", self, @controller.request)
+
+          # Delete from configuration
+          config.backend.del(key) if force
+
+          # Read the key
+          raw_downloads = config.backend.get(key)
+          raw_downloads = (ActiveSupport::JSON.decode(raw_downloads) rescue nil) if raw_downloads
+
+          @downloads_configuration = if raw_downloads then
+            HashWithIndifferentAccess.new(raw_downloads) # Just parse the read data
+          else
+            # Read the config file
+            downloads = YAML.load_file(self.interpolate(template, {root: Rails.root, request: @controller.request, controller: self}))
+
+            # Normalize
+            downloads = normalize_configuration(downloads)
+
+            # Save
+            config.backend.set(key, downloads.to_json)
+
+            downloads
+          end
+        end
+
+        def normalize_configuration(configuration)
+          configuration = ensure_hash(configuration)
+
+          # Scope by host
+          configuration = ensure_hash(configuration[self.handler_for(:hosts).call(@controller.request)])
+
+          # Adjust some defaults
+          configuration[:files] = ensure_hash(configuration[:files])
+          configuration[:options] = ensure_hash(configuration[:options])
+
+          configuration
+        end
+    end
+  end
+end

data/app/models/boar/services/generic.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+#
+# This file is part of the boar gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Boar
+  module Services
+    class Generic
+      attr_accessor :controller
+      attr_accessor :configuration
+      attr_accessor :options
+      attr_accessor :params
+
+      include Boar::Utils::Basic
+
+      def initialize(controller)
+        @controller = controller
+        @configuration = Rails.application.config.boar
+        @options = @controller.boar_options
+        @params = @controller.params
+
+        skip_cache_param = get_option(@options, :skip_cache_param, @configuration.skip_cache_param)
+        @skip_cache = skip_cache_param ? @controller.request.params[skip_cache_param].to_boolean : false
+      end
+
+      def run(method)
+        begin
+          self.send(method)
+        rescue => e
+          e = Boar::Exceptions::UnImplemented.new if !self.respond_to?(method)
+          self.handle_error(e)
+        end
+      end
+
+      def handle_error(exception)
+        if exception.is_a?(Lazier::Exceptions::Dump) then
+          raise exception
+        else
+          handler = self.handler_for(:views, @options)
+
+          # Get HTTP code
+          code = exception.is_a?(Boar::Exceptions::Error) ? exception.code : 500
+
+          # Basing on the code
+          view = case code
+            when 403 then handler.call(:error, code: 403)
+            when 404 then handler.call(:error, code: 404)
+            else
+              raise exception if !Boar::Exceptions::Error.must_raise?(exception)
+              handler.call(:error, code: 500, exception: exception)
+          end
+
+          @controller.render(file: view, status: code, formats: [:html]) if !@controller.performed?
+        end
+      end
+
+      def handle_authentication(path, options = nil)
+        self.handler_for(:authentication, options).call(path)
+      end
+
+      def handler_for(scope, options = nil)
+        options = ensure_hash(options)
+        scope = scope.to_sym
+
+        # Get the handler specified by user
+        handlers_options = get_option(@options.merge(options), :handlers, {})
+
+        # Use either the user handler or the system one
+        handlers = @configuration.handlers.merge(handlers_options)
+
+        # Instantiate the handler
+        @boar_handlers ||= {}
+        @boar_handlers[scope] ||= ::Lazier.find_class(handlers[scope]).new(self, options)
+      end
+    end
+  end
+end