yousty-activeadmin 1.0.0.pre

data/lib/active_admin/namespace.rb

@@ -0,0 +1,224 @@
+require 'active_admin/resource_collection'
+
+module ActiveAdmin
+
+  # Namespaces are the basic organizing principle for resources within Active Admin
+  #
+  # Each resource is registered into a namespace which defines:
+  #   * the namespaceing for routing
+  #   * the module to namespace controllers
+  #   * the menu which gets displayed (other resources in the same namespace)
+  #
+  # For example:
+  #
+  #   ActiveAdmin.register Post, :namespace => :admin
+  #
+  # Will register the Post model into the "admin" namespace. This will namespace the
+  # urls for the resource to "/admin/posts" and will set the controller to
+  # Admin::PostsController
+  #
+  # You can also register to the "root" namespace, which is to say no namespace at all.
+  #
+  #   ActiveAdmin.register Post, :namespace => false
+  #
+  # This will register the resource to an instantiated namespace called :root. The
+  # resource will be accessible from "/posts" and the controller will be PostsController.
+  #
+  class Namespace
+    RegisterEvent = 'active_admin.namespace.register'.freeze
+
+    attr_reader :application, :resources, :name, :menus
+
+    def initialize(application, name)
+      @application = application
+      @name = name.to_s.underscore.to_sym
+      @resources = ResourceCollection.new
+      register_module unless root?
+      build_menu_collection
+    end
+
+    # Register a resource into this namespace. The preffered method to access this is to
+    # use the global registration ActiveAdmin.register which delegates to the proper
+    # namespace instance.
+    def register(resource_class, options = {}, &block)
+      config = find_or_build_resource(resource_class, options)
+
+      # Register the resource
+      register_resource_controller(config)
+      parse_registration_block(config, &block) if block_given?
+      reset_menu!
+
+      # Dispatch a registration event
+      ActiveAdmin::Event.dispatch ActiveAdmin::Resource::RegisterEvent, config
+
+      # Return the config
+      config
+    end
+
+    def register_page(name, options = {}, &block)
+      config = build_page(name, options)
+
+      # Register the resource
+      register_page_controller(config)
+      parse_page_registration_block(config, &block) if block_given?
+      reset_menu!
+
+      config
+    end
+
+    def root?
+      name == :root
+    end
+
+    # Returns the name of the module if required. Will be nil if none
+    # is required.
+    #
+    # eg:
+    #   Namespace.new(:admin).module_name # => 'Admin'
+    #   Namespace.new(:root).module_name # => nil
+    #
+    def module_name
+      return nil if root?
+      @module_name ||= name.to_s.camelize
+    end
+
+    # Unload all the registered resources for this namespace
+    def unload!
+      unload_resources!
+      reset_menu!
+    end
+
+    # Returns the first registered ActiveAdmin::Resource instance for a given class
+    def resource_for(klass)
+      resources[klass]
+    end
+
+    # Override from ActiveAdmin::Settings to inherit default attributes
+    # from the application
+    def read_default_setting(name)
+      application.send(name)
+    end
+
+    def fetch_menu(name)
+      @menus.fetch(name)
+    end
+
+    def reset_menu!
+      @menus.clear!
+    end
+
+    # Add a callback to be ran when we build the menu
+    #
+    # @param [Symbol] name The name of the menu. Default: :default
+    # @param [Proc] block The block to be ran when the menu is built
+    #
+    # @returns [void]
+    def build_menu(name = DEFAULT_MENU, &block)
+      @menus.before_build do |menus|
+        menus.menu name do |menu|
+          block.call(menu)
+        end
+      end
+    end
+
+    # Add the default logout button to the menu, using the ActiveAdmin configuration settings
+    #
+    # @param [ActiveAdmin::MenuItem] menu The menu to add the logout link to
+    # @param [Fixnum] priority Override the default priority of 100 to position the logout button where you want
+    # @param [Hash] html_options An options hash to pass along to link_to
+    #
+    # @returns [void]
+    def add_logout_button_to_menu(menu, priority=100, html_options={})
+      if logout_link_path
+        logout_method = logout_link_method || :get
+        menu.add :id           => 'logout',
+                 :priority     => priority,
+                 :label        => proc{ I18n.t('active_admin.logout') },
+                 :html_options => html_options.reverse_merge(:method => logout_method),
+                 :url          => proc{ render_or_call_method_or_proc_on self, active_admin_namespace.logout_link_path },
+                 :if           => proc{ current_active_admin_user? }
+      end
+    end
+
+    def add_current_user_to_menu(menu)
+      menu.add label: proc{ display_name current_active_admin_user },
+               url:   proc{ url_for [active_admin_namespace.name, current_active_admin_user] rescue '#' },
+               id:    'current_user',
+               if:    proc{ current_active_admin_user? }
+    end
+
+    protected
+
+    def build_menu_collection
+      @menus = MenuCollection.new
+
+      @menus.on_build do |menus|
+        build_default_utility_nav
+
+        resources.each do |resource|
+          resource.add_to_menu(@menus)
+        end
+      end
+    end
+
+    # Builds the default utility navigation in top right header with current user & logout button
+    def build_default_utility_nav
+      return if @menus.exists? :utility_navigation
+      @menus.menu :utility_navigation do |menu|
+        add_current_user_to_menu menu
+        add_logout_button_to_menu menu
+      end
+    end
+
+    # Either returns an existing Resource instance or builds a new
+    # one for the resource and options
+    def find_or_build_resource(resource_class, options)
+      resources.add Resource.new(self, resource_class, options)
+    end
+
+    def build_page(name, options)
+      resources.add Page.new(self, name, options)
+    end
+
+    def register_page_controller(config)
+      eval "class ::#{config.controller_name} < ActiveAdmin::PageController; end"
+      config.controller.active_admin_config = config
+    end
+
+    def unload_resources!
+      resources.each do |resource|
+        parent = (module_name || 'Object').constantize
+        const_name = resource.controller_name.split('::').last
+        # Remove the const if its been defined
+        parent.send(:remove_const, const_name) if parent.const_defined?(const_name)
+
+        # Remove circular references
+        resource.controller.active_admin_config = nil
+        if resource.is_a?(Resource) && resource.dsl
+          resource.dsl.run_registration_block { @config = nil }
+        end
+      end
+      @resources = ResourceCollection.new
+    end
+
+    # Creates a ruby module to namespace all the classes in if required
+    def register_module
+      eval "module ::#{module_name}; end"
+    end
+
+    def register_resource_controller(config)
+      eval "class ::#{config.controller_name} < ActiveAdmin::ResourceController; end"
+      config.controller.active_admin_config = config
+    end
+
+    def parse_registration_block(config, &block)
+      config.dsl = ResourceDSL.new(config)
+      config.dsl.run_registration_block(&block)
+    end
+
+    def parse_page_registration_block(config, &block)
+      PageDSL.new(config).run_registration_block(&block)
+    end
+
+  end
+end

data/lib/active_admin/orm/active_record/comments/comment.rb

@@ -0,0 +1,39 @@
+module ActiveAdmin
+  class Comment < ActiveRecord::Base
+
+    belongs_to :resource, :polymorphic => true
+    belongs_to :author,   :polymorphic => true
+
+    unless Rails::VERSION::MAJOR > 3 && !defined? ProtectedAttributes
+      attr_accessible :resource, :resource_id, :resource_type, :body, :namespace
+    end
+
+    validates_presence_of :body, :namespace, :resource
+
+    # @returns [String] The name of the record to use for the polymorphic relationship
+    def self.resource_type(record)
+      record.class.base_class.name.to_s
+    end
+
+    # Postgres adapters won't compare strings to numbers (issue 34)
+    def self.resource_id_cast(record)
+      resource_id_type == :string ? record.id.to_s : record.id
+    end
+
+    def self.find_for_resource_in_namespace(resource, namespace)
+      where :resource_type => resource_type(resource),
+            :resource_id   => resource_id_cast(resource),
+            :namespace     => namespace.to_s
+    end
+
+    def self.resource_id_type
+      columns.detect{ |i| i.name == "resource_id" }.type
+    end
+
+    def self.table_name
+      @table_name ||= ActiveRecord::Migrator.proper_table_name("active_admin_comments")
+    end
+
+  end
+end
+

data/lib/active_admin/orm/active_record/comments/namespace_helper.rb

@@ -0,0 +1,14 @@
+module ActiveAdmin
+  module Comments
+
+    module NamespaceHelper
+
+      # Returns true if the namespace allows comments
+      def comments?
+        allow_comments == true
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/orm/active_record/comments/resource_helper.rb

@@ -0,0 +1,17 @@
+module ActiveAdmin
+  module Comments
+
+    module ResourceHelper
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :comments
+      end
+
+      def comments?
+        namespace.comments? && comments != false
+      end
+    end
+
+  end
+end

data/lib/active_admin/orm/active_record/comments/show_page_helper.rb

@@ -0,0 +1,23 @@
+module ActiveAdmin
+  module Comments
+
+    # Adds #active_admin_comments to the show page for use
+    # and sets it up on the default main content
+    module ShowPageHelper
+
+      # Add admin comments to the main content if they are
+      # turned on for the current resource
+      def default_main_content
+        super
+        active_admin_comments if active_admin_config.comments?
+      end
+
+      # Display the comments for the resource. Same as calling
+      # #active_admin_comments_for with the current resource
+      def active_admin_comments(*args, &block)
+        active_admin_comments_for(resource, *args, &block)
+      end
+    end
+
+  end
+end

data/lib/active_admin/orm/active_record/comments/views/active_admin_comments.rb

@@ -0,0 +1,75 @@
+require 'active_admin/views'
+require 'active_admin/views/components/panel'
+
+module ActiveAdmin
+  module Comments
+    module Views
+
+      class Comments < ActiveAdmin::Views::Panel
+        builder_method :active_admin_comments_for
+
+        def build(resource)
+          @resource = resource
+          @comments = ActiveAdmin::Comment.find_for_resource_in_namespace @resource, active_admin_namespace.name
+          super(title, :for => resource)
+          build_comments
+        end
+
+        protected
+
+        def title
+          I18n.t 'active_admin.comments.title_content', :count => @comments.count
+        end
+
+        def build_comments
+          @comments.any? ? @comments.each(&method(:build_comment)) : build_empty_message
+          build_comment_form
+        end
+
+        def build_comment(comment)
+          div :for => comment do
+            div :class => 'active_admin_comment_meta' do
+              h4 :class => 'active_admin_comment_author' do
+                comment.author ? auto_link(comment.author) : I18n.t('active_admin.comments.author_missing')
+              end
+              span pretty_format comment.created_at
+            end
+            div :class => 'active_admin_comment_body' do
+              simple_format comment.body
+            end
+          end
+        end
+
+        def build_empty_message
+          span I18n.t('active_admin.comments.no_comments_yet'), :class => 'empty'
+        end
+
+        def comment_form_url
+          parts = []
+          parts << active_admin_namespace.name unless active_admin_namespace.root?
+          parts << active_admin_namespace.comments_registration_name.underscore.pluralize
+          parts << 'path'
+          send parts.join '_'
+        end
+
+        def build_comment_form
+          self << active_admin_form_for(ActiveAdmin::Comment.new, :url => comment_form_url) do |f|
+            f.inputs do
+              f.input :resource_type, :as => :hidden,  :input_html => { :value => ActiveAdmin::Comment.resource_type(@resource) }
+              f.input :resource_id,   :as => :hidden,  :input_html => { :value => @resource.id }
+              f.input :body,          :label => false, :input_html => { :size => '80x8' }
+            end
+            f.actions do
+              f.action :submit, :label => I18n.t('active_admin.comments.add')
+            end
+          end
+        end
+
+        def default_id_for_prefix
+          'active_admin_comments_for'
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/orm/active_record/comments/views.rb

@@ -0,0 +1,2 @@
+require 'active_admin/views'
+require 'active_admin/orm/active_record/comments/views/active_admin_comments'

data/lib/active_admin/orm/active_record/comments.rb

@@ -0,0 +1,84 @@
+require 'active_admin/orm/active_record/comments/views'
+require 'active_admin/orm/active_record/comments/show_page_helper'
+require 'active_admin/orm/active_record/comments/namespace_helper'
+require 'active_admin/orm/active_record/comments/resource_helper'
+
+# Add the comments configuration
+ActiveAdmin::Application.inheritable_setting :allow_comments,             true
+ActiveAdmin::Application.inheritable_setting :show_comments_in_menu,      true
+ActiveAdmin::Application.inheritable_setting :comments_registration_name, 'Comment'
+
+# Insert helper modules
+ActiveAdmin::Namespace.send :include, ActiveAdmin::Comments::NamespaceHelper
+ActiveAdmin::Resource.send  :include, ActiveAdmin::Comments::ResourceHelper
+
+# Add the module to the show page
+ActiveAdmin.application.view_factory.show_page.send :include, ActiveAdmin::Comments::ShowPageHelper
+
+# Load the model as soon as it's referenced. By that point, Rails & Kaminari will be ready
+module ActiveAdmin
+  autoload :Comment, 'active_admin/orm/active_record/comments/comment'
+end
+
+# Walk through all the loaded namespaces after they're loaded
+ActiveAdmin.after_load do |app|
+  app.namespaces.values.each do |namespace|
+    if namespace.comments?
+      namespace.register ActiveAdmin::Comment, :as => namespace.comments_registration_name do
+        actions :index, :show, :create
+
+        menu false unless namespace.show_comments_in_menu
+
+        config.comments      = false # Don't allow comments on comments
+        config.batch_actions = false # The default destroy batch action isn't showing up anyway...
+
+        scope :all, :show_count => false
+        # Register a scope for every namespace that exists.
+        # The current namespace will be the default scope.
+        app.namespaces.values.map(&:name).each do |name|
+          scope name, :default => namespace.name == name do |scope|
+            scope.where :namespace => name.to_s
+          end
+        end
+
+        # Store the author and namespace
+        before_save do |comment|
+          comment.namespace = active_admin_config.namespace.name
+          comment.author    = current_active_admin_user
+        end
+
+        controller do
+          # Prevent N+1 queries
+          def scoped_collection
+            resource_class.includes :author, :resource
+          end
+
+          # Redirect to the resource show page after comment creation
+          def create
+            create! do |success, failure|
+              success.html{ redirect_to :back }
+              failure.html do
+                flash[:error] = I18n.t 'active_admin.comments.errors.empty_text'
+                redirect_to :back
+              end
+            end
+          end
+
+          # Define the permitted params in case the app is using Strong Parameters
+          def permitted_params
+            params.permit active_admin_comment: [:body, :namespace, :resource_id, :resource_type]
+          end unless Rails::VERSION::MAJOR == 3 && !defined? StrongParameters
+        end
+
+        index do
+          column I18n.t('active_admin.comments.resource_type'), :resource_type
+          column I18n.t('active_admin.comments.author_type'),   :author_type
+          column I18n.t('active_admin.comments.resource'),      :resource
+          column I18n.t('active_admin.comments.author'),        :author
+          column I18n.t('active_admin.comments.body'),          :body
+          actions
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/orm/active_record.rb

@@ -0,0 +1,3 @@
+# ActiveRecord-specific plugins should be required here
+
+require 'active_admin/orm/active_record/comments'

data/lib/active_admin/orm/mongoid.rb

@@ -0,0 +1 @@
+# Mongoid-specific plugins should be required here

data/lib/active_admin/page.rb

@@ -0,0 +1,88 @@
+module ActiveAdmin
+  # Page is the primary data storage for page configuration in Active Admin
+  #
+  # When you register a page (ActiveAdmin.page "Status") you are actually creating
+  # a new Page instance within the given Namespace.
+  #
+  # The instance of the current page is available in PageController and views
+  # by calling the #active_admin_config method.
+  #
+  class Page
+
+    # The namespace this config belongs to
+    attr_reader :namespace
+
+    # The name of the page
+    attr_reader :name
+
+    # An array of custom actions defined for this page
+    attr_reader :page_actions
+
+    # Set breadcrumb builder
+    attr_accessor :breadcrumb
+
+    module Base
+      def initialize(namespace, name, options)
+        @namespace = namespace
+        @name = name
+        @options = options
+        @page_actions = []
+      end
+    end
+
+    include Base
+    include Resource::Controllers
+    include Resource::PagePresenters
+    include Resource::Sidebars
+    include Resource::ActionItems
+    include Resource::Menu
+    include Resource::Naming
+    include Resource::Routes
+
+    # label is singular
+    def plural_resource_label
+      name
+    end
+
+    def resource_name
+      @resource_name ||= Resource::Name.new(nil, name)
+    end
+
+    def underscored_resource_name
+      resource_name.to_s.parameterize.underscore
+    end
+
+    def camelized_resource_name
+      underscored_resource_name.camelize
+    end
+
+    def default_menu_options
+      super.merge(:id => resource_name)
+    end
+
+    def controller_name
+      [namespace.module_name, camelized_resource_name + "Controller"].compact.join('::')
+    end
+
+    # Override from `ActiveAdmin::Resource::Controllers`
+    def route_uncountable?
+      false
+    end
+
+    def belongs_to?
+      false
+    end
+
+    def add_default_action_items
+    end
+
+    def add_default_sidebar_sections
+    end
+
+    # Clears all the custom actions this page knows about
+    def clear_page_actions!
+      @page_actions = []
+    end
+
+  end
+end

data/lib/active_admin/page_controller.rb

@@ -0,0 +1,29 @@
+module ActiveAdmin
+
+  # All Pages controllers inherit from this controller.
+  class PageController < BaseController
+
+    # Active admin actions don't require layout.  All custom actions do.
+    ACTIVE_ADMIN_ACTIONS = [:index]
+
+    actions :index
+
+    before_filter :authorize_access!
+
+    def index(options={}, &block)
+      render "active_admin/page/index"
+    end
+
+    def clear_page_actions!
+      active_admin_config.clear_page_actions!
+    end
+
+    private
+
+    def authorize_access!
+      permission = action_to_permission(params[:action])
+      authorize! permission, active_admin_config
+    end
+
+  end
+end

data/lib/active_admin/page_dsl.rb

@@ -0,0 +1,28 @@
+module ActiveAdmin
+  # This is the class where all the register_page blocks are instance eval'd
+  class PageDSL < DSL
+
+    # Page content.
+    #
+    # The block should define the view using Arbre.
+    #
+    # Example:
+    #
+    #   ActiveAdmin.register "My Page" do
+    #     content do
+    #       para "Sweet!"
+    #     end
+    #   end
+    #
+    def content(options = {}, &block)
+      config.set_page_presenter :index, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+
+    def page_action(name, options = {}, &block)
+      config.page_actions << ControllerAction.new(name, options)
+      controller do
+        define_method(name, &block || Proc.new{})
+      end
+    end
+  end
+end

data/lib/active_admin/page_presenter.rb

@@ -0,0 +1,32 @@
+module ActiveAdmin
+
+  # A simple object that gets used to present different aspects of views
+  #
+  # Initialize with a set of options and a block. The options become
+  # available using hash style syntax.
+  #
+  # Usage:
+  #
+  #     presenter = PagePresenter.new :as => :table do
+  #       # some awesome stuff
+  #     end
+  #
+  #     presenter[:as]    #=> :table
+  #     presenter.block   #=> The block passed in to new
+  #
+  class PagePresenter
+
+    attr_reader :block, :options
+
+    delegate :has_key?, :to => :options
+
+    def initialize(options = {}, &block)
+      @options, @block = options, block
+    end
+
+    def [](key)
+      @options[key]
+    end
+
+  end
+end