saulolso-activeadmin 0.2.2

data/lib/active_admin/arbre/html5_elements.rb

@@ -0,0 +1,47 @@
+module Arbre
+  module HTML
+
+    AUTO_BUILD_ELEMENTS = [ :a, :abbr, :address, :area, :article, :aside, :audio, :b, :base,
+                       :bdo, :blockquote, :body, :br, :button, :canvas, :caption, :cite,
+                       :code, :col, :colgroup, :command, :datalist, :dd, :del, :details,
+                       :dfn, :div, :dl, :dt, :em, :embed, :fieldset, :figcaption, :figure,
+                       :footer, :form, :h1, :h2, :h3, :h4, :h5, :h6, :head, :header, :hgroup, 
+                       :hr, :html, :i, :iframe, :img, :input, :ins, :keygen, :kbd, :label, 
+                       :legend, :li, :link, :map, :mark, :menu, :meta, :meter, :nav, :noscript, 
+                       :object, :ol, :optgroup, :option, :output, :pre, :progress, :q,
+                       :s, :samp, :script, :section, :select, :small, :source, :span,
+                       :strong, :style, :sub, :summary, :sup, :table, :tbody, :td,
+                       :textarea, :tfoot, :th, :thead, :time, :title, :tr, :ul, :var, :video ]
+
+    HTML5_ELEMENTS = [ :p ] + AUTO_BUILD_ELEMENTS
+
+    AUTO_BUILD_ELEMENTS.each do |name|
+      class_eval <<-EOF
+        class #{name.to_s.capitalize} < Tag
+          builder_method :#{name}
+        end
+      EOF
+    end
+
+    class P < Tag
+      builder_method :para
+    end
+
+    class Table < Tag
+      def initialize(*)
+        super
+        set_table_tag_defaults
+      end
+
+      protected
+
+      # Set some good defaults for tables
+      def set_table_tag_defaults
+        set_attribute :border,      0
+        set_attribute :cellspacing, 0
+        set_attribute :cellpadding, 0
+      end
+    end
+
+  end
+end

data/lib/active_admin/arbre/tag.rb

@@ -0,0 +1,137 @@
+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?
+          if self_closing_tag?
+            html << spaces << open_tag.sub( />$/, '/>' )
+          else
+            # one line
+            html << spaces << open_tag << child_content << close_tag
+          end
+        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 self_closing_tag?
+        %w|meta link|.include?(tag_name)
+      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/arbre.rb

@@ -0,0 +1,23 @@
+require "active_admin/arbre/html"
+require "active_admin/arbre/attributes"
+require "active_admin/arbre/core_extensions"
+require "active_admin/arbre/element"
+require "active_admin/arbre/context"
+require "active_admin/arbre/collection"
+require "active_admin/arbre/class_list"
+require "active_admin/arbre/tag"
+require "active_admin/arbre/document"
+require "active_admin/arbre/html5_elements"
+require "active_admin/arbre/text_node"
+
+# Arbre - The DOM Tree in Ruby
+#
+# Arbre is a ruby library for building HTML in pure Object Oriented Ruby
+module Arbre
+end
+
+require 'action_view'
+
+ActionView::Template.register_template_handler :arb, lambda { |template|
+  "self.class.send :include, Arbre::HTML; @_helpers = self; begin; #{template.source}; end; current_dom_context"
+}

data/lib/active_admin/asset_registration.rb

@@ -0,0 +1,34 @@
+module ActiveAdmin
+  module AssetRegistration
+
+    # Stylesheets
+
+    def register_stylesheet(name)
+      stylesheets << name
+    end
+
+    def stylesheets
+      @stylesheets ||= []
+    end
+
+    def clear_stylesheets!
+      @stylesheets = []
+    end
+
+
+    # Javascripts
+
+    def register_javascript(name)
+      javascripts << name
+    end
+
+    def javascripts
+      @javascripts ||= []
+    end
+
+    def clear_javascripts!
+      @javascripts = []
+    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/comment.rb

@@ -0,0 +1,21 @@
+require 'kaminari/models/active_record_extension'
+
+module ActiveAdmin
+
+  # manually initialize kaminari for this model
+  ::ActiveRecord::Base.send :include, Kaminari::ActiveRecordExtension
+
+  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,18 @@
+module ActiveAdmin
+  module Comments
+
+    module Configuration
+      extend ActiveSupport::Concern
+
+      included do
+        # Set the namespaces that can create and view comments
+        #
+        #   config.allow_comments_in = [:admin, :root]
+        #
+        attr_accessor_with_default :allow_comments_in, [:admin]
+      end
+
+    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?
+        application.allow_comments_in && application.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/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

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.rb

@@ -0,0 +1,88 @@
+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::Application.send :include, 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.application.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
+
+      # Redirect to the resource show page when failing to add a comment
+      # TODO: Provide helpers to make such kind of customization much simpler
+      controller do
+        def create
+          create! do |success, failure|
+            failure.html do 
+              resource_config = active_admin_config.namespace.resource_for(@comment.resource.class)
+              flash[:error] = "Comment wasn't saved, text was empty."
+              redirect_to send(resource_config.route_instance_path, @comment.resource)
+            end
+          end
+        end
+      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/component.rb

@@ -0,0 +1,22 @@
+module ActiveAdmin
+  class Component < Arbre::HTML::Div
+
+    # By default components render a div
+    def tag_name
+      'div'
+    end
+
+    def initialize(*)
+      super
+      add_class default_class_name
+    end
+
+    protected
+
+    # By default, add a css class named after the ruby class
+    def default_class_name
+      self.class.name.demodulize.underscore
+    end
+
+  end
+end

data/lib/active_admin/controller_action.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  class ControllerAction
+    attr_reader :name
+    def initialize(name, options = {})
+      @name, @options = name, options
+    end
+
+    def http_verb
+      @options[:method] ||= :get
+    end
+  end
+end