ultra-quick-hub 0.0.1

data/activeadmin-3.5.1/lib/active_admin/application.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+require "active_admin/router"
+require "active_admin/application_settings"
+require "active_admin/namespace_settings"
+
+module ActiveAdmin
+  class Application
+
+    class << self
+      def setting(name, default)
+        ApplicationSettings.register name, default
+      end
+
+      def inheritable_setting(name, default)
+        NamespaceSettings.register name, default
+      end
+    end
+
+    def settings
+      @settings ||= SettingsNode.build(ApplicationSettings)
+    end
+
+    def namespace_settings
+      @namespace_settings ||= SettingsNode.build(NamespaceSettings)
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      [settings, namespace_settings].any? { |sets| sets.respond_to?(method) } || super
+    end
+
+    def method_missing(method, *args)
+      if settings.respond_to?(method)
+        settings.send(method, *args)
+      elsif namespace_settings.respond_to?(method)
+        namespace_settings.send(method, *args)
+      else
+        super
+      end
+    end
+
+    attr_reader :namespaces
+    def initialize
+      @namespaces = Namespace::Store.new
+    end
+
+    include AssetRegistration
+
+    # Event that gets triggered on load of Active Admin
+    BeforeLoadEvent = "active_admin.application.before_load".freeze
+    AfterLoadEvent = "active_admin.application.after_load".freeze
+
+    # Runs before the app's AA initializer
+    def setup!
+      register_default_assets
+    end
+
+    # Runs after the app's AA initializer
+    def prepare!
+      remove_active_admin_load_paths_from_rails_autoload_and_eager_load
+      attach_reloader
+    end
+
+    # Registers a brand new configuration for the given resource.
+    def register(resource, options = {}, &block)
+      ns = options.fetch(:namespace) { default_namespace }
+      namespace(ns).register resource, options, &block
+    end
+
+    # Creates a namespace for the given name
+    #
+    # Yields the namespace if a block is given
+    #
+    # @return [Namespace] the new or existing namespace
+    def namespace(name)
+      name ||= :root
+
+      namespace = namespaces[name.to_sym] ||= begin
+        namespace = Namespace.new(self, name)
+        ActiveSupport::Notifications.instrument ActiveAdmin::Namespace::RegisterEvent, { active_admin_namespace: namespace }
+        namespace
+      end
+
+      yield(namespace) if block_given?
+
+      namespace
+    end
+
+    # Register a page
+    #
+    # @param name [String] The page name
+    # @option [Hash] Accepts option :namespace.
+    # @&block The registration block.
+    #
+    def register_page(name, options = {}, &block)
+      ns = options.fetch(:namespace) { default_namespace }
+      namespace(ns).register_page name, options, &block
+    end
+
+    # Whether all configuration files have been loaded
+    def loaded?
+      @@loaded ||= false
+    end
+
+    # Removes all defined controllers from memory. Useful in
+    # development, where they are reloaded on each request.
+    def unload!
+      namespaces.each &:unload!
+      @@loaded = false
+    end
+
+    # Loads all ruby files that are within the load_paths setting.
+    # To reload everything simply call `ActiveAdmin.unload!`
+    def load!
+      unless loaded?
+        ActiveSupport::Notifications.instrument BeforeLoadEvent, { active_admin_application: self } # before_load hook
+        files.each { |file| load file } # load files
+        namespace(default_namespace) # init AA resources
+        ActiveSupport::Notifications.instrument AfterLoadEvent, { active_admin_application: self } # after_load hook
+        @@loaded = true
+      end
+    end
+
+    def load(file)
+      DatabaseHitDuringLoad.capture { super }
+    end
+
+    # Returns ALL the files to be loaded
+    def files
+      load_paths.flatten.compact.uniq.flat_map { |path| Dir["#{path}/**/*.rb"].sort }
+    end
+
+    # Creates all the necessary routes for the ActiveAdmin configurations
+    #
+    # Use this within the routes.rb file:
+    #
+    #   Application.routes.draw do |map|
+    #     ActiveAdmin.routes(self)
+    #   end
+    #
+    # @param rails_router [ActionDispatch::Routing::Mapper]
+    def routes(rails_router)
+      load!
+      Router.new(router: rails_router, namespaces: namespaces).apply
+    end
+
+    # Adds before, around and after filters to all controllers.
+    # Example usage:
+    #   ActiveAdmin.before_action :authenticate_admin!
+    #
+    AbstractController::Callbacks::ClassMethods.public_instance_methods.
+      select { |m| m.match(/_action\z/) }.each do |name|
+      define_method name do |*args, &block|
+        ActiveSupport.on_load(:active_admin_controller) do
+          public_send name, *args, &block
+        end
+      end
+    end
+
+    def controllers_for_filters
+      controllers = [BaseController]
+      controllers.push *Devise.controllers_for_filters if Dependency.devise?
+      controllers
+    end
+
+    private
+
+    def register_default_assets
+      register_stylesheet "active_admin.css", media: "all"
+      register_javascript "active_admin.js"
+    end
+
+    # Since app/admin is alphabetically before app/models, we have to remove it
+    # from the host app's +autoload_paths+ to prevent missing constant errors.
+    #
+    # As well, we have to remove it from +eager_load_paths+ to prevent the
+    # files from being loaded twice in production.
+    def remove_active_admin_load_paths_from_rails_autoload_and_eager_load
+      ActiveSupport::Dependencies.autoload_paths -= load_paths
+      Rails.application.config.eager_load_paths -= load_paths
+    end
+
+    # Hook into the Rails code reloading mechanism so that things are reloaded
+    # properly in development mode.
+    #
+    # If any of the app files (e.g. models) has changed, we need to reload all
+    # the admin files. If the admin files themselves has changed, we need to
+    # regenerate the routes as well.
+    def attach_reloader
+      Rails.application.config.after_initialize do |app|
+        unload_active_admin = -> { ActiveAdmin.application.unload! }
+
+        if app.config.reload_classes_only_on_change
+          # Rails is about to unload all the app files (e.g. models), so we
+          # should first unload the classes generated by Active Admin, otherwise
+          # they will contain references to the stale (unloaded) classes.
+          ActiveSupport::Reloader.to_prepare(prepend: true, &unload_active_admin)
+        else
+          # If the user has configured the app to always reload app files after
+          # each request, so we should unload the generated classes too.
+          ActiveSupport::Reloader.to_complete(&unload_active_admin)
+        end
+
+        admin_dirs = {}
+
+        load_paths.each do |path|
+          admin_dirs[path] = [:rb]
+        end
+
+        routes_reloader = app.config.file_watcher.new([], admin_dirs) do
+          app.reload_routes!
+        end
+
+        app.reloaders << routes_reloader
+
+        ActiveSupport::Reloader.to_prepare do
+          # Rails might have reloaded the routes for other reasons (e.g.
+          # routes.rb has changed), in which case Active Admin would have been
+          # loaded via the `ActiveAdmin.routes` call in `routes.rb`.
+          #
+          # Otherwise, we should check if any of the admin files are changed
+          # and force the routes to reload if necessary. This would again causes
+          # Active Admin to load via `ActiveAdmin.routes`.
+          #
+          # Finally, if Active Admin is still not loaded at this point, then we
+          # would need to load it manually.
+          unless ActiveAdmin.application.loaded?
+            routes_reloader.execute_if_updated
+            ActiveAdmin.application.load!
+          end
+        end
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/application_settings.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require "active_admin/settings_node"
+
+module ActiveAdmin
+  class ApplicationSettings < SettingsNode
+
+    # The default namespace to put controllers and routes inside. Set this
+    # in config/initializers/active_admin.rb using:
+    #
+    #   config.default_namespace = :super_admin
+    #
+    register :default_namespace, :admin
+
+    register :app_path, Rails.root
+
+    # Load paths for admin configurations. Add folders to this load path
+    # to load up other resources for administration. External gems can
+    # include their paths in this load path to provide active_admin UIs
+    register :load_paths, [File.expand_path("app/admin", Rails.root)]
+
+    # Set default localize format for Date/Time values
+    register :localize_format, :long
+
+    # Active Admin makes educated guesses when displaying objects, this is
+    # the list of methods it tries calling in order
+    # Note that Formtastic also has 'collection_label_methods' similar to this
+    # used by auto generated dropdowns in filter or belongs_to field of Active Admin
+    register :display_name_methods, [ :display_name,
+                                      :full_name,
+                                      :name,
+                                      :username,
+                                      :login,
+                                      :title,
+                                      :email,
+                                      :to_s ]
+
+    # To make debugging easier, by default don't stream in development
+    register :disable_streaming_in, ["development"]
+
+    # Remove sensitive attributes from being displayed, made editable, or exported by default
+    register :filter_attributes, [:encrypted_password, :password, :password_confirmation]
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/asset_registration.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module AssetRegistration
+
+    def register_stylesheet(path, options = {})
+      stylesheets[path] = options
+    end
+
+    def stylesheets
+      @stylesheets ||= {}
+    end
+
+    def clear_stylesheets!
+      stylesheets.clear
+    end
+
+    def register_javascript(path, options = {})
+      javascripts[path] = options
+    end
+
+    def javascripts
+      @javascripts ||= {}
+    end
+
+    def clear_javascripts!
+      javascripts.clear
+    end
+
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/authorization_adapter.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+module ActiveAdmin
+
+  # Default Authorization permissions for Active Admin
+  module Authorization
+    READ = :read
+    NEW = :new
+    CREATE = :create
+    EDIT = :edit
+    UPDATE = :update
+    DESTROY = :destroy
+  end
+
+  Auth = Authorization
+
+  # Active Admin's default authorization adapter. This adapter returns true
+  # for all requests to `#authorized?`. It should be the starting point for
+  # implementing your own authorization adapter.
+  #
+  # To view an example subclass, check out `ActiveAdmin::CanCanAdapter`
+  class AuthorizationAdapter
+    attr_reader :resource, :user
+
+    # Initialize a new authorization adapter. This happens on each and
+    # every request to a controller.
+    #
+    # @param [ActiveAdmin::Resource, ActiveAdmin::Page] resource The resource
+    #        that the user is currently on. Note, we may be authorizing access
+    #        to a different subject, so don't rely on this other than to
+    #        pull configuration information from.
+    #
+    # @param [any] user The current user. The user is set to whatever is returned
+    #        from `#current_active_admin_user` in the controller.
+    #
+    def initialize(resource, user)
+      @resource = resource
+      @user = user
+    end
+
+    # Returns true of false depending on if the user is authorized to perform
+    # the action on the subject.
+    #
+    # @param [Symbol] action The name of the action to perform. Usually this will be
+    #        one of the `ActiveAdmin::Auth::*` symbols.
+    #
+    # @param [any] subject The subject the action is being performed on usually this
+    #        is a model object. Note, that this is NOT always in instance, it can be
+    #        the class of the subject also. For example, Active Admin uses the class
+    #        of the resource to decide if the resource should be displayed in the
+    #        global navigation. To deal with this nicely in a case statement, take
+    #        a look at `#normalized(klass)`
+    #
+    # @return [Boolean]
+    def authorized?(action, subject = nil)
+      true
+    end
+
+    # A hook method for authorization libraries to scope the collection. By
+    # default, we just return the same collection. The returned scope is used
+    # as the starting point for all queries to the db in the controller.
+    #
+    # @param [ActiveRecord::Relation] collection The collection the user is
+    #        attempting to view.
+    #
+    # @param [Symbol] action The name of the action to perform. Usually this will be
+    #        one of the `ActiveAdmin::Auth::*` symbols. Defaults to `Auth::READ` if
+    #        no action passed in.
+    #
+    # @return [ActiveRecord::Relation] A new collection, scoped to the
+    #          objects that the current user has access to.
+    def scope_collection(collection, action = Auth::READ)
+      collection
+    end
+
+    private
+
+    # The `#authorized?` method's subject can be set to both instances as well
+    # as classes of objects. This can make it much difficult to create simple
+    # case statements for authorization since you have to handle both the
+    # class level match and the instance level match.
+    #
+    # For example:
+    #
+    #     class MyAuthAdapter < ActiveAdmin::AuthorizationAdapter
+    #
+    #       def authorized?(action, subject = nil)
+    #         case subject
+    #         when Post
+    #           true
+    #         when Class
+    #           if subject == Post
+    #             true
+    #           end
+    #         end
+    #       end
+    #
+    #     end
+    #
+    # To handle this, the normalized method takes care of returning a object
+    # which implements `===` to be matched in a case statement.
+    #
+    # The above now becomes:
+    #
+    #     class MyAuthAdapter < ActiveAdmin::AuthorizationAdapter
+    #
+    #       def authorized?(action, subject = nil)
+    #         case subject
+    #         when normalized(Post)
+    #           true
+    #         end
+    #       end
+    #
+    #     end
+    def normalized(klass)
+      NormalizedMatcher.new(klass)
+    end
+
+    class NormalizedMatcher
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def ===(other)
+        @klass == other || other.is_a?(@klass)
+      end
+
+    end
+
+  end
+
+end

data/activeadmin-3.5.1/lib/active_admin/base_controller/authorization.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  class BaseController < ::InheritedResources::Base
+    module Authorization
+      extend ActiveSupport::Concern
+
+      ACTIONS_DICTIONARY = {
+        index: ActiveAdmin::Authorization::READ,
+        show: ActiveAdmin::Authorization::READ,
+        new: ActiveAdmin::Authorization::NEW,
+        create: ActiveAdmin::Authorization::CREATE,
+        edit: ActiveAdmin::Authorization::EDIT,
+        update: ActiveAdmin::Authorization::UPDATE,
+        destroy: ActiveAdmin::Authorization::DESTROY
+      }
+
+      included do
+        rescue_from ActiveAdmin::AccessDenied, with: :dispatch_active_admin_access_denied
+
+        helper_method :authorized?
+        helper_method :authorize!
+        helper_method :active_admin_authorization
+      end
+
+      protected
+
+      # Authorize the action and subject. Available in the controller
+      # as well as all the views.
+      #
+      # @param [Symbol] action The action to check if the user has permission
+      #                 to perform on the subject.
+      #
+      # @param [any] subject The subject that the user is trying to perform
+      #                 the action on.
+      #
+      # @return [Boolean]
+      #
+      def authorized?(action, subject = nil)
+        active_admin_authorization.authorized?(action, subject)
+      end
+
+      # Authorize the action and subject. Available in the controller
+      # as well as all the views. If the action is not allowd, it raises
+      # an ActiveAdmin::AccessDenied exception.
+      #
+      # @param [Symbol] action The action to check if the user has permission
+      #                 to perform on the subject.
+      #
+      # @param [any] subject The subject that the user is trying to perform
+      #                 the action on.
+      #
+      # @return [Boolean] True if authorized, otherwise raises
+      #                 an ActiveAdmin::AccessDenied.
+      def authorize!(action, subject = nil)
+        unless authorized? action, subject
+          raise ActiveAdmin::AccessDenied.new(
+            current_active_admin_user,
+            action,
+            subject)
+        end
+      end
+
+      # Performs authorization on the resource using the current controller
+      # action as the permission action.
+      #
+      def authorize_resource!(resource)
+        permission = action_to_permission(params[:action])
+        authorize! permission, resource
+      end
+
+      # Retrieve or instantiate the authorization instance for this resource
+      #
+      # @return [ActiveAdmin::AuthorizationAdapter]
+      def active_admin_authorization
+        @active_admin_authorization ||=
+         active_admin_authorization_adapter.new active_admin_config, current_active_admin_user
+      end
+
+      # Returns the class to be used as the authorization adapter
+      #
+      # @return [Class]
+      def active_admin_authorization_adapter
+        adapter = active_admin_namespace.authorization_adapter
+        if adapter.is_a? String
+          adapter.constantize
+        else
+          adapter
+        end
+      end
+
+      # Converts a controller action into one of the correct Active Admin
+      # authorization names. Uses the ACTIONS_DICTIONARY to convert the
+      # action name to permission.
+      #
+      # @param [String, Symbol] action The controller action name.
+      #
+      # @return [Symbol] The permission name to use.
+      def action_to_permission(action)
+        if action && action = action.to_sym
+          Authorization::ACTIONS_DICTIONARY[action] || action
+        end
+      end
+
+      def dispatch_active_admin_access_denied(exception)
+        instance_exec(self, exception, &active_admin_namespace.on_unauthorized_access.to_proc)
+      end
+
+      def rescue_active_admin_access_denied(exception)
+        error = exception.message
+
+        respond_to do |format|
+          format.html do
+            flash[:error] = error
+            redirect_backwards_or_to_root
+          end
+
+          format.csv { render body: error, status: :unauthorized }
+          format.json { render json: { error: error }, status: :unauthorized }
+          format.xml { render xml: "<error>#{error}</error>", status: :unauthorized }
+        end
+      end
+
+      def redirect_backwards_or_to_root
+        redirect_back fallback_location: active_admin_root
+      end
+
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/base_controller/menu.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  class BaseController < ::InheritedResources::Base
+    module Menu
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :set_current_tab
+        helper_method :current_menu
+      end
+
+      protected
+
+      def current_menu
+        active_admin_config.navigation_menu
+      end
+
+      # Set's @current_tab to be name of the tab to mark as current
+      # Get's called through a before filter
+      def set_current_tab
+        @current_tab = if current_menu && active_admin_config.belongs_to? && parent?
+                         parent_item = active_admin_config.belongs_to_config.target.menu_item
+                         if current_menu.include? parent_item
+                           parent_item
+                         else
+                           active_admin_config.menu_item
+                         end
+                       else
+                         active_admin_config.menu_item
+                       end
+      end
+
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/base_controller.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+require "active_admin/base_controller/authorization"
+require "active_admin/base_controller/menu"
+
+module ActiveAdmin
+  # BaseController for ActiveAdmin.
+  # It implements ActiveAdmin controllers core features.
+  class BaseController < ::InheritedResources::Base
+    helper ::ActiveAdmin::ViewHelpers
+
+    layout :determine_active_admin_layout
+
+    before_action :only_render_implemented_actions
+    before_action :authenticate_active_admin_user
+
+    class << self
+      # Ensure that this method is available for the DSL
+      public :actions
+
+      # Reference to the Resource object which initialized
+      # this controller
+      attr_accessor :active_admin_config
+    end
+
+    include Authorization
+    include Menu
+
+    private
+
+    # By default Rails will render un-implemented actions when the view exists. Because Active
+    # Admin allows you to not render any of the actions by using the #actions method, we need
+    # to check if they are implemented.
+    def only_render_implemented_actions
+      raise AbstractController::ActionNotFound unless action_methods.include?(params[:action])
+    end
+
+    # Calls the authentication method as defined in ActiveAdmin.authentication_method
+    def authenticate_active_admin_user
+      send(active_admin_namespace.authentication_method) if active_admin_namespace.authentication_method
+    end
+
+    def current_active_admin_user
+      send(active_admin_namespace.current_user_method) if active_admin_namespace.current_user_method
+    end
+    helper_method :current_active_admin_user
+
+    def current_active_admin_user?
+      !!current_active_admin_user
+    end
+    helper_method :current_active_admin_user?
+
+    def active_admin_config
+      self.class.active_admin_config
+    end
+    helper_method :active_admin_config
+
+    def active_admin_namespace
+      active_admin_config.namespace
+    end
+    helper_method :active_admin_namespace
+
+    ACTIVE_ADMIN_ACTIONS = [:index, :show, :new, :create, :edit, :update, :destroy]
+
+    # Determine which layout to use.
+    #
+    #   1.  If we're rendering a standard Active Admin action, we want layout(false)
+    #       because these actions are subclasses of the Base page (which implements
+    #       all the required layout code)
+    #   2.  If we're rendering a custom action, we'll use the active_admin layout so
+    #       that users can render any template inside Active Admin.
+    def determine_active_admin_layout
+      ACTIVE_ADMIN_ACTIONS.include?(params[:action].to_sym) ? false : "active_admin"
+    end
+
+    def active_admin_root
+      controller, action = active_admin_namespace.root_to.split "#"
+      { controller: controller, action: action }
+    end
+
+    ActiveSupport.run_load_hooks(:active_admin_controller, self)
+  end
+end