activeadmin-orac 1.0.0.pre4

data/lib/active_admin/resource_controller/decorators.rb

@@ -0,0 +1,102 @@
+module ActiveAdmin
+  class ResourceController < BaseController
+    module Decorators
+
+    protected
+
+      def apply_decorator(resource)
+        decorate? ? decorator_class.new(resource) : resource
+      end
+
+      def apply_collection_decorator(collection)
+        if decorate?
+          collection_decorator.decorate collection, with: decorator_class
+        else
+          collection
+        end
+      end
+
+      def self.undecorate(resource)
+        if resource.respond_to?(:decorated?) && resource.decorated?
+          resource.model
+        else
+          resource
+        end
+      end
+
+    private
+
+      def decorate?
+        case action_name
+        when 'new', 'edit', 'create', 'update'
+          form = active_admin_config.get_page_presenter :form
+          form && form.options[:decorate] && decorator_class.present?
+        else
+          decorator_class.present?
+        end
+      end
+
+      def decorator_class
+        active_admin_config.decorator_class
+      end
+
+      # When using Draper, we wrap the collection draper in a new class that
+      # correctly delegates methods that Active Admin depends on.
+      def collection_decorator
+        if decorator_class
+          Wrapper.wrap decorator_class
+        end
+      end
+
+      class Wrapper
+        @cache = {}
+
+        def self.wrap(decorator)
+          collection_decorator = find_collection_decorator(decorator)
+
+          if draper_collection_decorator? collection_decorator
+            name = "#{collection_decorator.name} of #{decorator} + ActiveAdmin"
+            @cache[name] ||= wrap! collection_decorator, name
+          else
+            collection_decorator
+          end
+        end
+
+      private
+
+        def self.wrap!(parent, name)
+          ::Class.new parent do
+            delegate :reorder, :page, :current_page, :total_pages, :limit_value,
+                     :total_count, :total_pages, :to_key, :group_values, :except,
+                     :find_each, :ransack
+
+            define_singleton_method(:name) { name }
+          end
+        end
+
+        # Draper::CollectionDecorator was introduced in 1.0.0
+        # Draper::Decorator#collection_decorator_class was introduced in 1.3.0
+        def self.find_collection_decorator(decorator)
+          if Dependency.draper?    '>= 1.3.0'
+            decorator.collection_decorator_class
+          elsif Dependency.draper? '>= 1.0.0'
+            draper_collection_decorator
+          else
+            decorator
+          end
+        end
+
+        def self.draper_collection_decorator?(decorator)
+          decorator && decorator <= draper_collection_decorator
+        rescue NameError
+          false
+        end
+
+        def self.draper_collection_decorator
+          ::Draper::CollectionDecorator
+        end
+
+      end
+    end
+  end
+end

data/lib/active_admin/resource_controller/resource_class_methods.rb

@@ -0,0 +1,24 @@
+module ActiveAdmin
+  class ResourceController < BaseController
+    module ResourceClassMethods
+
+      # Override the default `resource_class` class and instance
+      # methods to only return the class defined in the instance
+      # of ActiveAdmin::Resource
+      def override_resource_class_methods!
+        class_exec do
+          def self.resource_class=(klass); end
+
+          def self.resource_class
+            @active_admin_config ? @active_admin_config.resource_class : nil
+          end
+
+          def resource_class
+            self.class.resource_class
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource_controller/scoping.rb

@@ -0,0 +1,31 @@
+module ActiveAdmin
+  class ResourceController < BaseController
+
+    # This module deals with scoping entire controllers to a relation
+    module Scoping
+      extend ActiveSupport::Concern
+
+      protected
+
+      # Override the default InheritedResource #begin_of_association_chain to allow
+      # the scope to be defined in the active admin configuration.
+      #
+      # If scope_to is a proc, we eval it, otherwise we call the method on the controller.
+      #
+      # Collection can be scoped conditionally with an :if or :unless proc.
+      def begin_of_association_chain
+        return nil unless active_admin_config.scope_to?(self)
+        render_in_context(self, active_admin_config.scope_to_method)
+      end
+
+      # Overriding from InheritedResources::BaseHelpers
+      #
+      # Returns the method for the association chain when using
+      # the scope_to option
+      def method_for_association_chain
+        active_admin_config.scope_to_association_method || super
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource_controller/sidebars.rb

@@ -0,0 +1,18 @@
+module ActiveAdmin
+  class ResourceController < BaseController
+
+    module Sidebars
+
+      protected
+
+      def skip_sidebar!
+        @skip_sidebar = true
+      end
+
+      def skip_sidebar?
+        @skip_sidebar == true
+      end
+    end
+
+  end
+end

data/lib/active_admin/resource_controller/streaming.rb

@@ -0,0 +1,43 @@
+require 'csv'
+
+module ActiveAdmin
+  class ResourceController < BaseController
+
+    # This module overrides CSV responses to allow large data downloads.
+    # Could be expanded to JSON and XML in the future.
+    #
+    module Streaming
+
+      def index
+        super do |format|
+          format.csv { stream_csv }
+          yield(format) if block_given?
+        end
+      end
+
+      protected
+
+      def stream_resource(&block)
+        headers['X-Accel-Buffering'] = 'no'
+        headers['Cache-Control'] = 'no-cache'
+
+        if ActiveAdmin.application.disable_streaming_in.include? Rails.env
+          self.response_body = block['']
+        else
+          self.response_body = Enumerator.new &block
+        end
+      end
+
+      def csv_filename
+        "#{resource_collection_name.to_s.gsub('_', '-')}-#{Time.zone.now.to_date.to_s(:default)}.csv"
+      end
+
+      def stream_csv
+        headers['Content-Type'] = 'text/csv; charset=utf-8' # In Rails 5 it's set to HTML??
+        headers['Content-Disposition'] = %{attachment; filename="#{csv_filename}"}
+        stream_resource &active_admin_config.csv_builder.method(:build).to_proc.curry[self]
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource_dsl.rb

@@ -0,0 +1,190 @@
+module ActiveAdmin
+  # This is the class where all the register blocks are evaluated.
+  class ResourceDSL < DSL
+    def initialize(config, resource_class)
+      @resource = resource_class
+      super(config)
+    end
+
+    private
+
+    def belongs_to(target, options = {})
+      config.belongs_to(target, options)
+    end
+
+    # Scope collection to a relation
+    def scope_to(*args, &block)
+      config.scope_to(*args, &block)
+    end
+
+    # Create a scope
+    def scope(*args, &block)
+      config.scope(*args, &block)
+    end
+
+    # Store relations that should be included
+    def includes(*args)
+      config.includes.push *args
+    end
+
+    #
+    # Rails 4 Strong Parameters Support
+    #
+    # Either
+    #
+    #   permit_params :title, :author, :body, tags: []
+    #
+    # Or
+    #
+    #   permit_params do
+    #     defaults = [:title, :body]
+    #     if current_user.admin?
+    #       defaults + [:author]
+    #     else
+    #       defaults
+    #     end
+    #   end
+    #
+    # Keys included in the `permitted_params` setting are automatically whitelisted.
+    #
+    def permit_params(*args, &block)
+      param_key = config.param_key.to_sym
+
+      controller do
+        define_method :permitted_params do
+          params.permit *active_admin_namespace.permitted_params,
+            param_key => block ? instance_exec(&block) : args
+        end
+      end
+    end
+
+    # Configure the index page for the resource
+    def index(options = {}, &block)
+      options[:as] ||= :table
+      config.set_page_presenter :index, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+
+    # Configure the show page for the resource
+    def show(options = {}, &block)
+      config.set_page_presenter :show, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+
+    def form(options = {}, &block)
+      config.set_page_presenter :form, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+
+    # Configure the CSV format
+    #
+    # For example:
+    #
+    #   csv do
+    #     column :name
+    #     column("Author") { |post| post.author.full_name }
+    #   end
+    #
+    #   csv col_sep: ";", force_quotes: true do
+    #     column :name
+    #   end
+    #
+    def csv(options={}, &block)
+      options[:resource] = @resource
+
+      config.csv_builder = CSVBuilder.new(options, &block)
+    end
+
+    # Member Actions give you the functionality of defining both the
+    # action and the route directly from your ActiveAdmin registration
+    # block.
+    #
+    # For example:
+    #
+    #   ActiveAdmin.register Post do
+    #     member_action :comments do
+    #       @post = Post.find(params[:id]
+    #       @comments = @post.comments
+    #     end
+    #   end
+    #
+    # Will create a new controller action comments and will hook it up to
+    # the named route (comments_admin_post_path) /admin/posts/:id/comments
+    #
+    # You can treat everything within the block as a standard Rails controller
+    # action.
+    #
+    def action(set, name, options = {}, &block)
+      set << ControllerAction.new(name, options)
+      title = options.delete(:title)
+
+      controller do
+        callback = ActiveAdmin::Dependency.rails >= 4 ? :before_action : :before_filter
+        send(callback, only: [name]) { @page_title = title } if title
+        define_method(name, &block || Proc.new{})
+      end
+    end
+
+    def member_action(name, options = {}, &block)
+      action config.member_actions, name, options, &block
+    end
+
+    def collection_action(name, options = {}, &block)
+      action config.collection_actions, name, options, &block
+    end
+
+    # Defined Callbacks
+    #
+    # == After Build
+    # Called after the resource is built in the new and create actions.
+    #
+    # ActiveAdmin.register Post do
+    #   after_build do |post|
+    #     post.author = current_user
+    #   end
+    # end
+    #
+    # == Before / After Create
+    # Called before and after a resource is saved to the db on the create action.
+    #
+    # == Before / After Update
+    # Called before and after a resource is saved to the db on the update action.
+    #
+    # == Before / After Save
+    # Called before and after the object is saved in the create and update action.
+    # Note: Gets called after the create and update callbacks
+    #
+    # == Before / After Destroy
+    # Called before and after the object is destroyed from the database.
+    #
+    delegate :before_build,   :after_build,   to: :controller
+    delegate :before_create,  :after_create,  to: :controller
+    delegate :before_update,  :after_update,  to: :controller
+    delegate :before_save,    :after_save,    to: :controller
+    delegate :before_destroy, :after_destroy, to: :controller
+
+    # This code defines both *_filter and *_action for Rails 3.2 to Rails 5.
+    actions = [
+      :before, :skip_before,
+      :after,  :skip_after,
+      :around, :skip
+    ]
+    destination = ActiveAdmin::Dependency.rails >= 4 ? :action : :filter
+    [:action, :filter].each do |name|
+      actions.each do |action|
+        define_method "#{action}_#{name}" do |*args, &block|
+          controller.public_send "#{action}_#{destination}", *args, &block
+        end
+      end
+    end
+
+    # Specify which actions to create in the controller
+    #
+    # Eg:
+    #
+    #   ActiveAdmin.register Post do
+    #     actions :index, :show
+    #   end
+    #
+    # Will only create the index and show actions (no create, update or delete)
+    delegate :actions, to: :controller
+
+  end
+end

data/lib/active_admin/router.rb

@@ -0,0 +1,106 @@
+module ActiveAdmin
+  class Router
+    def initialize(application)
+      @application = application
+    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
+    #
+    def apply(router)
+      define_root_routes router
+      define_resource_routes router
+    end
+
+    def define_root_routes(router)
+      router.instance_exec @application.namespaces do |namespaces|
+        namespaces.each do |namespace|
+          if namespace.root?
+            root namespace.root_to_options.merge(to: namespace.root_to)
+          else
+            namespace namespace.name do
+              root namespace.root_to_options.merge(to: namespace.root_to, as: :root)
+            end
+          end
+        end
+      end
+    end
+
+    # Defines the routes for each resource
+    def define_resource_routes(router)
+      router.instance_exec @application.namespaces, self do |namespaces, aa_router|
+        resources = namespaces.flat_map{ |n| n.resources.values }
+        resources.each do |config|
+          routes = aa_router.resource_routes(config)
+
+          # Add in the parent if it exists
+          if config.belongs_to?
+            belongs_to = routes
+            routes     = Proc.new do
+              # If it's optional, make the normal resource routes
+              instance_exec &belongs_to if config.belongs_to_config.optional?
+
+              # Make the nested belongs_to routes
+              # :only is set to nothing so that we don't clobber any existing routes on the resource
+              resources config.belongs_to_config.target.resource_name.plural, only: [] do
+                instance_exec &belongs_to
+              end
+            end
+          end
+
+          # Add on the namespace if required
+          unless config.namespace.root?
+            nested = routes
+            routes = Proc.new do
+              namespace config.namespace.name do
+                instance_exec &nested
+              end
+            end
+          end
+
+          instance_exec &routes
+        end
+      end
+    end
+
+    def resource_routes(config)
+      Proc.new do
+        # Builds one route for each HTTP verb passed in
+        build_route  = proc{ |verbs, *args|
+          [*verbs].each{ |verb| send verb, *args }
+        }
+        # Deals with +ControllerAction+ instances
+        build_action = proc{ |action|
+          build_route.call(action.http_verb, action.name)
+        }
+        case config
+        when ::ActiveAdmin::Resource
+          resources config.resource_name.route_key, only: config.defined_actions do
+            member do
+              config.member_actions.each &build_action
+            end
+
+            collection do
+              config.collection_actions.each &build_action
+              post :batch_action if config.batch_actions_enabled?
+            end
+          end
+        when ::ActiveAdmin::Page
+          page = config.underscored_resource_name
+          get "/#{page}" => "#{page}#index"
+          config.page_actions.each do |action|
+            build_route.call action.http_verb, "/#{page}/#{action.name}" => "#{page}##{action.name}"
+          end
+        else
+          raise "Unsupported config class: #{config.class}"
+        end
+      end
+
+    end
+  end
+end