yousty-activeadmin 1.0.0.pre

data/lib/active_admin/resource.rb

@@ -0,0 +1,153 @@
+require 'active_admin/resource/action_items'
+require 'active_admin/resource/controllers'
+require 'active_admin/resource/menu'
+require 'active_admin/resource/page_presenters'
+require 'active_admin/resource/pagination'
+require 'active_admin/resource/routes'
+require 'active_admin/resource/naming'
+require 'active_admin/resource/scopes'
+require 'active_admin/resource/scope_to'
+require 'active_admin/resource/sidebars'
+require 'active_admin/resource/belongs_to'
+
+module ActiveAdmin
+
+  # Resource is the primary data storage for resource configuration in Active Admin
+  #
+  # When you register a resource (ActiveAdmin.register Post) you are actually creating
+  # a new Resource instance within the given Namespace.
+  #
+  # The instance of the current resource is available in ResourceController and views
+  # by calling the #active_admin_config method.
+  #
+  class Resource
+
+    # Event dispatched when a new resource is registered
+    RegisterEvent = 'active_admin.resource.register'.freeze
+
+    # The namespace this config belongs to
+    attr_reader :namespace
+
+    # The name of the resource class
+    attr_reader :resource_class_name
+
+    # An array of member actions defined for this resource
+    attr_reader :member_actions
+
+    # An array of collection actions defined for this resource
+    attr_reader :collection_actions
+
+    # The default sort order to use in the controller
+    attr_writer :sort_order
+    def sort_order
+      @sort_order ||= (resource_class.respond_to?(:primary_key) ? resource_class.primary_key.to_s : 'id') + '_desc'
+    end
+
+    # Set the configuration for the CSV
+    attr_writer :csv_builder
+
+    # Set breadcrumb builder
+    attr_accessor :breadcrumb
+
+    # Store a reference to the DSL so that we can dereference it during garbage collection.
+    attr_accessor :dsl
+
+    # The string identifying a class to decorate our resource with for the view.
+    # nil to not decorate.
+    attr_accessor :decorator_class_name
+
+    module Base
+      def initialize(namespace, resource_class, options = {})
+        @namespace = namespace
+        @resource_class_name = "::#{resource_class.name}"
+        @options    = options
+        @sort_order = options[:sort_order]
+        @member_actions, @collection_actions = [], []
+      end
+    end
+
+    include MethodOrProcHelper
+
+    include Base
+    include ActionItems
+    include Authorization
+    include Controllers
+    include Menu
+    include Naming
+    include PagePresenters
+    include Pagination
+    include Scopes
+    include ScopeTo
+    include Sidebars
+    include Menu
+    include Routes
+
+    # The class this resource wraps. If you register the Post model, Resource#resource_class
+    # will point to the Post class
+    def resource_class
+      ActiveSupport::Dependencies.constantize(resource_class_name)
+    end
+
+    def decorator_class
+      ActiveSupport::Dependencies.constantize(decorator_class_name) if decorator_class_name
+    end
+
+    def resource_table_name
+      resource_class.quoted_table_name
+    end
+
+    def resource_column_names
+      resource_class.column_names
+    end
+
+    def resource_quoted_column_name(column)
+      resource_class.connection.quote_column_name(column)
+    end
+
+    # Clears all the member actions this resource knows about
+    def clear_member_actions!
+      @member_actions = []
+    end
+
+    def clear_collection_actions!
+      @collection_actions = []
+    end
+
+    # Return only defined resource actions
+    def defined_actions
+      controller.instance_methods.map(&:to_sym) & ResourceController::ACTIVE_ADMIN_ACTIONS
+    end
+
+    def belongs_to(target, options = {})
+      @belongs_to = Resource::BelongsTo.new(self, target, options)
+      self.navigation_menu_name = target unless @belongs_to.optional?
+      controller.send :belongs_to, target, options.dup
+    end
+
+    def belongs_to_config
+      @belongs_to
+    end
+
+    # Do we belong to another resource?
+    def belongs_to?
+      !!belongs_to_config
+    end
+
+    # The csv builder for this resource
+    def csv_builder
+      @csv_builder || default_csv_builder
+    end
+
+    def find_resource(id)
+      resource = resource_class.where(resource_class.primary_key => id).first
+      decorator_class ? decorator_class.new(resource) : resource
+    end
+
+    private
+
+    def default_csv_builder
+      @default_csv_builder ||= CSVBuilder.default_for_resource(resource_class)
+    end
+
+  end # class Resource
+end # module ActiveAdmin

data/lib/active_admin/resource_collection.rb

@@ -0,0 +1,42 @@
+module ActiveAdmin
+  # This is a container for resources, which acts much like a Hash.
+  # It's assumed that an added resource responds to `resource_name`.
+  class ResourceCollection
+    include Enumerable
+    extend Forwardable
+    def_delegators :@resources, :empty?, :has_key?, :keys, :values, :[]=
+
+    def initialize
+      @resources = {}
+    end
+
+    def add(resource)
+      @resources[resource.resource_name] ||= resource
+    end
+
+    # Changes `each` to pass in the value, instead of both the key and value.
+    def each(&block)
+      values.each &block
+    end
+
+    # Finds a resource based on the resource name, the resource class, or the base class.
+    def [](klass)
+      if match = @resources[klass]
+        match
+      elsif match = real_resources.detect{ |r| [r.resource_name.to_s, r.resource_class.to_s].include? klass.to_s }
+        match
+      elsif klass.respond_to? :base_class
+        real_resources.detect{ |r| r.resource_class.to_s == klass.base_class.to_s }
+      end
+    end
+
+    private
+
+    # REFACTOR: ResourceCollection currently stores Resource and Page objects. That doesn't
+    # make sense, because by definition a ResourceCollection is a collection of resources.
+    def real_resources
+      select{ |r| r.respond_to? :resource_class }
+    end
+
+  end
+end

data/lib/active_admin/resource_controller/action_builder.rb

@@ -0,0 +1,21 @@
+module ActiveAdmin
+  class ResourceController < BaseController
+
+    module ActionBuilder
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def clear_member_actions!
+          active_admin_config.clear_member_actions!
+        end
+
+        def clear_collection_actions!
+          active_admin_config.clear_collection_actions!
+        end
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/resource_controller/data_access.rb

@@ -0,0 +1,298 @@
+module ActiveAdmin
+  class ResourceController < BaseController
+
+    # This module overrides most of the data access methods in Inherited
+    # Resources to provide Active Admin with it's data.
+    #
+    # The module also deals with authorization and resource callbacks.
+    #
+    module DataAccess
+      extend ActiveSupport::Concern
+
+      include ActiveAdmin::Callbacks
+      include ActiveAdmin::ScopeChain
+
+      included do
+        define_active_admin_callbacks :build, :create, :update, :save, :destroy
+      end
+
+      protected
+
+      # Retrieve, memoize and authorize the current collection from the db. This
+      # method delegates the finding of the collection to #find_collection.
+      #
+      # Once #collection has been called, the collection is available using
+      # either the @collection instance variable or an instance variable named
+      # after the resource that the collection is for. eg: Post => @post.
+      #
+      # @returns [ActiveRecord::Relation] The collection for the index
+      def collection
+        _collection = get_collection_ivar
+
+        return _collection if _collection
+
+        _collection = find_collection
+        authorize! ActiveAdmin::Authorization::READ, active_admin_config.resource_class
+
+        set_collection_ivar _collection
+      end
+
+
+      # Does the actual work of retrieving the current collection from the db.
+      # This is a great method to override if you would like to perform
+      # some additional db # work before your controller returns and
+      # authorizes the collection.
+      #
+      # @returns [ActiveRecord::Relation] The collectin for the index
+      def find_collection
+        collection = scoped_collection
+
+        collection = apply_authorization_scope(collection)
+        collection = apply_sorting(collection)
+        collection = apply_filtering(collection)
+        collection = apply_scoping(collection)
+        collection = apply_pagination(collection)
+        collection = apply_decorator(collection)
+
+        collection
+      end
+
+
+      # Override this method in your controllers to modify the start point
+      # of our searches and index.
+      #
+      # This method should return an ActiveRecord::Relation object so that
+      # the searching and filtering can be applied on top
+      #
+      # Note, unless you are doing something special, you should use the
+      # scope_to method from the Scoping module instead of overriding this
+      # method.
+      def scoped_collection
+        end_of_association_chain
+      end
+
+      # Retrieve, memoize and authorize a resource based on params[:id]. The
+      # actual work of finding the resource is done in #find_resource.
+      #
+      # This method is used on all the member actions:
+      #
+      #   * show
+      #   * edit
+      #   * update
+      #   * destroy
+      #
+      # @returns [ActiveRecord::Base] An active record object
+      def resource
+        _resource = get_resource_ivar
+
+        return _resource if _resource
+
+        _resource = find_resource
+        authorize_resource! _resource
+
+        if decorator?
+          _resource = decorator_class.new(_resource)
+        end
+
+        set_resource_ivar(_resource)
+      end
+
+      def decorator?
+        !!active_admin_config.decorator_class
+      end
+
+      def decorator_class
+        active_admin_config.decorator_class
+      end
+
+
+      # Does the actual work of finding a resource in the database. This
+      # method uses the finder method as defined in InheritedResources.
+      #
+      # @returns [ActiveRecord::Base] An active record object.
+      def find_resource
+        scoped_collection.send(method_for_find, params[:id])
+      end
+
+
+      # Builds, memoize and authorize a new instance of the resource. The
+      # actual work of building the new instance is delegated to the
+      # #build_new_resource method.
+      #
+      # This method is used to instantiate and authorize new resources in the
+      # new and create controller actions.
+      #
+      # @returns [ActiveRecord::Base] An un-saved active record base object
+      def build_resource
+        return resource if resource = get_resource_ivar
+
+        resource = build_new_resource
+
+        run_build_callbacks resource
+        authorize_resource! resource
+
+        set_resource_ivar(resource)
+      end
+
+      # Builds a new resource. This method uses the method_for_build provided
+      # by Inherited Resources.
+      #
+      # @returns [ActiveRecord::Base] An un-saved active record base object
+      def build_new_resource
+        scoped_collection.send(method_for_build, *resource_params)
+      end
+
+      # Calls all the appropriate callbacks and then creates the new resource.
+      #
+      # @param [ActiveRecord::Base] object The new resource to create
+      #
+      # @returns [void]
+      def create_resource(object)
+        run_create_callbacks object do
+          save_resource(object)
+        end
+      end
+
+      # Calls all the appropriate callbacks and then saves the new resource.
+      #
+      # @param [ActiveRecord::Base] object The new resource to save
+      #
+      # @returns [void]
+      def save_resource(object)
+        run_save_callbacks object do
+          object.save
+        end
+      end
+
+      # Update an object with the given attributes. Also calls the appropriate
+      # callbacks for update action.
+      #
+      # @param [ActiveRecord::Base] object The instance to update
+      #
+      # @param [Array] attributes An array with the attributes in the first position
+      #                           and the Active Record "role" in the second. The role
+      #                           may be set to nil.
+      #
+      # @returns [void]
+      def update_resource(object, attributes)
+        if object.respond_to?(:assign_attributes)
+          object.assign_attributes(*attributes)
+        else
+          object.attributes = attributes[0]
+        end
+
+        run_update_callbacks object do
+          save_resource(object)
+        end
+      end
+
+      # Destroys an object from the database and calls appropriate callbacks.
+      #
+      # @returns [void]
+      def destroy_resource(object)
+        run_destroy_callbacks object do
+          object.destroy
+        end
+      end
+
+
+      #
+      # Collection Helper Methods
+      #
+
+
+      # Gives the authorization library a change to pre-scope the collection.
+      #
+      # In the case of the CanCan adapter, it calls `#accessible_by` on
+      # the collection.
+      #
+      # @param [ActiveRecord::Relation] collection The collection to scope
+      #
+      # @retruns [ActiveRecord::Relation] a scoped collection of query
+      def apply_authorization_scope(collection)
+        action_name = action_to_permission(params[:action])
+        active_admin_authorization.scope_collection(collection, action_name)
+      end
+
+
+      def apply_sorting(chain)
+        params[:order] ||= active_admin_config.sort_order
+        if params[:order] && params[:order] =~ /^([\w\_\.]+)_(desc|asc)$/
+          column = $1
+          order  = $2
+          table  = active_admin_config.resource_column_names.include?(column) ? active_admin_config.resource_table_name : nil
+          table_column = (column =~ /\./) ? column :
+            [table, active_admin_config.resource_quoted_column_name(column)].compact.join(".")
+
+          chain.reorder("#{table_column} #{order}")
+        else
+          chain # just return the chain
+        end
+      end
+
+      # Applies any Ransack search methods to the currently scoped collection.
+      # Both `search` and `ransack` are provided, but we use `ransack` to prevent conflicts.
+      def apply_filtering(chain)
+        @search = chain.ransack clean_search_params params[:q]
+        @search.result
+      end
+
+      def clean_search_params(search_params)
+        return {} unless search_params.is_a?(Hash)
+        search_params = search_params.dup
+        search_params.delete_if do |key, value|
+          value == ""
+        end
+        search_params
+      end
+
+      def apply_scoping(chain)
+        @collection_before_scope = chain
+
+        if current_scope
+          scope_chain(current_scope, chain)
+        else
+          chain
+        end
+      end
+
+      def collection_before_scope
+        @collection_before_scope
+      end
+
+      def current_scope
+        @current_scope ||= if params[:scope]
+          active_admin_config.get_scope_by_id(params[:scope]) if params[:scope]
+        else
+          active_admin_config.default_scope(self)
+        end
+      end
+
+      def apply_pagination(chain)
+        page_method = Kaminari.config.page_method_name
+        page_param  = params[Kaminari.config.param_name]
+
+        chain.send(page_method, page_param).per(per_page)
+      end
+
+      def per_page
+        return max_per_page if active_admin_config.paginate == false
+
+        @per_page || active_admin_config.per_page
+      end
+
+      def max_per_page
+        10_000
+      end
+
+      def apply_decorator(chain)
+        if decorator?
+          decorator_class.decorate_collection(chain)
+        else
+          chain
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource_controller/decorators.rb

@@ -0,0 +1,20 @@
+module ActiveAdmin
+  class ResourceController < BaseController
+    module Decorators
+      protected
+
+      def resource
+        decorator = active_admin_config.decorator_class
+        resource = super
+        decorator ? decorator.new(resource) : resource
+      end
+
+      def active_admin_collection
+        decorator = active_admin_config.decorator_class
+        collection = super
+        decorator ? decorator.decorate_collection(collection) : collection
+      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.rb

@@ -0,0 +1,50 @@
+require 'inherited_resources'
+require 'active_admin/resource_controller/action_builder'
+require 'active_admin/resource_controller/data_access'
+require 'active_admin/resource_controller/decorators'
+require 'active_admin/resource_controller/scoping'
+require 'active_admin/resource_controller/sidebars'
+require 'active_admin/resource_controller/resource_class_methods'
+
+module ActiveAdmin
+  # All Resources Controller inherits from this controller.
+  # It implements actions and helpers for resources.
+  class ResourceController < BaseController
+    layout :determine_active_admin_layout
+
+    respond_to :html, :xml, :json
+    respond_to :csv, :only => :index
+
+    include ActionBuilder
+    include Decorators
+    include DataAccess
+    include Scoping
+    include Sidebars
+    extend  ResourceClassMethods
+
+    def self.active_admin_config=(config)
+      if @active_admin_config = config
+        defaults :resource_class => config.resource_class,
+                 :route_prefix   => config.route_prefix,
+                 :instance_name  => config.resource_name.singular
+      end
+    end
+
+    # Inherited Resources uses the `self.inherited(base)` hook to add
+    # in `self.resource_class`. To override it, we need to install
+    # our resource_class method each time we're inherited from.
+    def self.inherited(base)
+      super(base)
+      base.override_resource_class_methods!
+    end
+
+    private
+
+    # Returns the renderer class to use for the given action.
+    def renderer_for(action)
+      active_admin_namespace.view_factory["#{action}_page"]
+    end
+    helper_method :renderer_for
+
+  end
+end