activeadmin 0.1.1 → 0.2.0

data/lib/active_admin/arbre/tag.rb

@@ -0,0 +1,129 @@
+require 'erb'
+
+module Arbre
+  module HTML
+
+    class Tag < Element
+      attr_reader :attributes
+
+      def initialize(*)
+        super
+        @attributes = Attributes.new
+      end
+
+      def build(*args)
+        super
+        attributes = args.extract_options!
+        self.content = args.first if args.first
+
+        set_for_attribute(attributes.delete(:for))
+
+        attributes.each do |key, value|
+          set_attribute(key, value)
+        end
+      end
+
+      def set_attribute(name, value)
+        @attributes[name.to_sym] = value
+      end
+
+      def get_attribute(name)
+        @attributes[name.to_sym]
+      end
+      alias :attr :get_attribute
+
+      def has_attribute?(name)
+        @attributes.has_key?(name.to_sym)
+      end
+
+      def remove_attribute(name)
+        @attributes.delete(name.to_sym)
+      end
+
+      def id
+        get_attribute(:id)
+      end
+
+      # Generates and id for the object if it doesn't exist already
+      def id!
+        return id if id
+        self.id = object_id.to_s
+        id
+      end
+
+      def id=(id)
+        set_attribute(:id, id)
+      end
+
+      def add_class(class_names)
+        class_list.add class_names
+      end
+
+      def remove_class(class_names)
+        class_list.delete(class_names)
+      end
+
+      # Returns a string of classes
+      def class_names
+        class_list.to_html
+      end
+
+      def class_list
+        get_attribute(:class) || set_attribute(:class, ClassList.new)
+      end
+
+      def to_html
+        indent("<#{tag_name}#{attributes_html}>", content, "</#{tag_name}>").html_safe
+      end
+
+      private
+
+      INDENT_SIZE = 2
+      
+      def indent(open_tag, child_content, close_tag)
+        spaces = ' ' * indent_level * INDENT_SIZE
+
+        html = ""
+
+        if no_child? || child_is_text?
+          # one line
+          html << spaces << open_tag << child_content << close_tag
+        else
+          # multiple lines
+          html << spaces << open_tag << "\n"
+          html << child_content # the child takes care of its own spaces
+          html << spaces << close_tag
+        end
+
+        html << "\n"
+
+        html
+      end
+      
+      def no_child?
+        children.empty?
+      end
+
+      def child_is_text?
+        children.size == 1 && children.first.is_a?(TextNode)
+      end
+
+
+      def attributes_html
+        attributes.any? ? " " + attributes.to_html : nil
+      end
+
+      def set_for_attribute(record)
+        return unless record
+        set_attribute :id, ActionController::RecordIdentifier.dom_id(record, default_id_for_prefix)
+        add_class ActionController::RecordIdentifier.dom_class(record)
+      end
+
+      def default_id_for_prefix
+        nil
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/arbre/text_node.rb

@@ -0,0 +1,35 @@
+require 'erb'
+
+module Arbre
+  module HTML
+
+    class TextNode < Element
+
+      builder_method :text_node
+
+      # Builds a text node from a string
+      def self.from_string(string)
+        node = new
+        node.build(string)
+        node
+      end
+
+      def add_child(*args)
+        raise "TextNodes do not have children"
+      end
+
+      def build(string)
+        @content = string
+      end
+
+      def tag_name
+        nil
+      end
+
+      def to_html
+        ERB::Util.html_escape(@content.to_html)
+      end
+    end
+
+  end
+end

data/lib/active_admin/callbacks.rb

@@ -0,0 +1,87 @@
+module ActiveAdmin
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+      protected
+
+      # Simple callback system. Implements before and after callbacks for
+      # use within the controllers.
+      #
+      # We didn't use the ActiveSupport callbacks becuase they do not support
+      # passing in any arbitrary object into the callback method (which we
+      # need to do)
+      
+      def call_callback_with(method, *args)
+        case method
+        when Symbol
+          send(method, *args)
+        when Proc
+          instance_exec(*args, &method)
+        else
+          raise "Please register with callbacks using a symbol or a block/proc."
+        end
+      end
+    end
+
+    module ClassMethods
+
+      # Define a new callback.
+      #
+      # Example:
+      #
+      #   class MyClassWithCallbacks
+      #     include ActiveAdmin::Callbacks
+      #
+      #     define_active_admin_callbacks :save
+      #
+      #     before_save do |arg1, arg2|
+      #       # runs before save
+      #     end
+      #
+      #     after_save :call_after_save
+      #
+      #     def save
+      #       # Will run before, yield, then after
+      #       run_save_callbacks :arg1, :arg2 do
+      #         save!
+      #       end
+      #     end
+      #
+      #     protected
+      #
+      #     def call_after_save(arg1, arg2)
+      #       # runs after save
+      #     end
+      #   end
+      #     
+      def define_active_admin_callbacks(*names)
+        names.each do |name|
+          [:before, :after].each do |type|
+            # Create an inheritable accessor array for the callbacks
+            class_inheritable_array "#{type}_#{name}_callbacks".to_sym
+            send("#{type}_#{name}_callbacks=".to_sym, [])
+
+            # Define a method to set the callback
+            class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+              # def self.before_create
+              def self.#{type}_#{name}(method = nil, &block)
+                #{type}_#{name}_callbacks << (method || block)
+              end
+            EOS
+          end
+
+          # Define a method to run the callbacks
+          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+            def run_#{name}_callbacks(*args)
+              self.class.before_#{name}_callbacks.each{|callback| call_callback_with(callback, *args)}
+              value = yield if block_given?
+              self.class.after_#{name}_callbacks.each{|callback| call_callback_with(callback, *args)}
+              return value
+            end
+            EOS
+         end
+       end
+    end
+  end
+end

data/lib/active_admin/comments.rb

@@ -0,0 +1,73 @@
+require 'active_admin/comments/configuration'
+require 'active_admin/comments/comment'
+require 'active_admin/comments/views'
+require 'active_admin/comments/show_page_helper'
+require 'active_admin/comments/namespace_helper'
+require 'active_admin/comments/resource_helper'
+
+# Add the comments configuration
+ActiveAdmin.extend ActiveAdmin::Comments::Configuration
+
+# Add the comments module to ActiveAdmin::Namespace
+ActiveAdmin::Namespace.send :include, ActiveAdmin::Comments::NamespaceHelper
+
+# Add the comments module to ActiveAdmin::Resource
+ActiveAdmin::Resource.send :include, ActiveAdmin::Comments::ResourceHelper
+
+# Add the module to the show page
+ActiveAdmin.view_factory.show_page.send :include, ActiveAdmin::Comments::ShowPageHelper
+
+# Generate a Comment resource when namespaces are registered
+ActiveAdmin::Event.subscribe ActiveAdmin::Namespace::RegisterEvent do |namespace|
+  if namespace.comments?
+    namespace.register ActiveAdmin::Comment, :as => 'Comment' do
+      actions :index, :show, :create
+
+      # Don't display in the menu
+      menu false
+
+      # Don't allow comments on comments
+      config.comments = false
+
+      # Filter Comments by date
+      filter :resource_type
+      filter :body
+      filter :created_at
+
+      # Only view comments in this namespace
+      scope :all, :default => true do |comments|
+        comments.where(:namespace => active_admin_config.namespace.name)
+      end
+
+      # Always redirect to the resource on show
+      before_filter :only => :show do
+        flash[:notice] = flash[:notice].dup if flash[:notice]
+        comment = ActiveAdmin::Comment.find(params[:id])
+        resource_config = active_admin_config.namespace.resource_for(comment.resource.class)
+        redirect_to send(resource_config.route_instance_path, comment.resource)
+      end
+
+      # Store the author and namespace
+      before_save do |comment|
+        comment.namespace = active_admin_config.namespace.name
+        comment.author = current_active_admin_user
+      end
+
+      # Display as a table
+      index do
+        column("Resource"){|comment| auto_link(comment.resource) }
+        column("Author"){|comment| auto_link(comment.author) }
+        column :body
+      end
+    end
+  end
+end
+
+# Register for comments when new resources are registered
+ActiveAdmin::Event.subscribe ActiveAdmin::Resource::RegisterEvent do |resource|
+  if resource.comments?
+    resource.resource.has_many :active_admin_comments, :class_name => "ActiveAdmin::Comment",
+                                                       :as         => :resource, 
+                                                       :dependent  => :destroy
+  end
+end

data/lib/active_admin/comments/comment.rb

@@ -0,0 +1,15 @@
+module ActiveAdmin
+
+  class Comment < ActiveRecord::Base
+    self.table_name = "active_admin_comments"
+
+    belongs_to :resource, :polymorphic => true
+    belongs_to :author, :polymorphic => true
+
+    validates_presence_of :resource_id
+    validates_presence_of :resource_type
+    validates_presence_of :body
+    validates_presence_of :namespace
+  end
+
+end

data/lib/active_admin/comments/configuration.rb

@@ -0,0 +1,16 @@
+module ActiveAdmin
+  module Comments
+
+    module Configuration
+
+      # Set the namespaces that can create and view comments
+      #
+      #   config.allow_comments_in = [:admin, :root]
+      #
+      @@allow_comments_in = [ActiveAdmin.default_namespace]
+      mattr_accessor :allow_comments_in
+
+    end
+
+  end
+end

data/lib/active_admin/comments/namespace_helper.rb

@@ -0,0 +1,14 @@
+module ActiveAdmin
+  module Comments
+
+    module NamespaceHelper
+
+      # Returns true of the namespace allows comments
+      def comments?
+        ActiveAdmin.allow_comments_in && ActiveAdmin.allow_comments_in.include?(name)
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/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/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/comments/views.rb

@@ -0,0 +1,3 @@
+require 'active_admin/views'
+require 'active_admin/comments/views/active_admin_comments'
+require 'active_admin/comments/views/active_admin_comment'

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

@@ -0,0 +1,82 @@
+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(record)
+          @record = record
+          super(title_content, :for => record)
+          build_comments
+        end
+
+        protected
+
+        def title_content
+          "Comments (#{record_comments.count})"
+        end
+
+        def record_comments
+          @record_comments ||= @record.active_admin_comments.where(:namespace => active_admin_namespace.name)
+        end
+
+        def build_comments
+          if record_comments.count > 0
+            record_comments.each do |comment|
+              build_comment(comment)
+            end
+          else
+            build_empty_message
+          end
+          build_comment_form
+        end
+
+        def build_comment(comment)
+          div :for => comment do
+            div :class => "active_admin_comment_meta" do
+              user_name = comment.author ? auto_link(comment.author) : "Anonymous"
+              h4(user_name, :class => "active_admin_comment_author")
+              span(pretty_format(comment.created_at))
+            end
+            div :class => "active_admin_comment_body" do
+              simple_format(comment.body)
+            end
+            div :style => "clear:both;"
+          end
+        end
+
+        def build_empty_message
+          span :class => "empty" do
+            "No comments yet."
+          end
+        end
+
+        def comment_form_url
+          send(:"#{active_admin_namespace.name}_comments_path")
+        end
+
+        def build_comment_form
+          self << active_admin_form_for(ActiveAdmin::Comment.new, :url => comment_form_url, :html => {:class => "inline_form"}) do |form|
+            form.inputs do
+              form.input :resource_type, :value => @record.class.base_class.name.to_s, :as => :hidden
+              form.input :resource_id, :value => @record.id, :as => :hidden
+              form.input :body, :input_html => {:size => "80x8"}, :label => false
+            end
+            form.buttons do
+              form.commit_button 'Add Comment'
+            end
+          end
+        end
+
+        def default_id_for_prefix
+          'active_admin_comments_for'
+        end
+      end
+
+    end
+  end
+end