activeadmin 0.1.0

data/lib/active_admin/pages/edit.rb

@@ -0,0 +1,21 @@
+module ActiveAdmin
+  module Pages
+    class Edit < Base
+
+      def title
+        "Edit #{active_admin_config.resource_name}"
+      end
+
+      def main_content
+        config = self.form_config.dup
+        config.delete(:block)
+        config.reverse_merge!({
+          :url => resource_path(resource)
+        })
+
+        active_admin_form_for resource, config, &form_config[:block]
+      end
+
+    end
+  end
+end

data/lib/active_admin/pages/index.rb

@@ -0,0 +1,58 @@
+module ActiveAdmin
+  module Pages
+
+    class Index < Base
+
+      # Default Index config styles. Each of these are what 
+      # actually gets rendered in the main content and configured
+      # through the :as option when configuring your index
+      autoload :Table,      'active_admin/pages/index/table'
+      autoload :Blog,      'active_admin/pages/index/blog'
+      autoload :Thumbnails, 'active_admin/pages/index/thumbnails'
+
+      def title
+        active_admin_config.plural_resource_name
+      end
+
+      def config
+        index_config || default_index_config
+      end
+
+      # Render's the index configuration that was set in the
+      # controller. Defaults to rendering the ActiveAdmin::Pages::Index::Table
+      def main_content
+        renderer_class = find_index_renderer_class(config[:as])
+        renderer_class.new(self).to_html(config, collection)
+      end
+
+      private
+
+      # Creates a default configuration for the resource class. This is a table
+      # with each column displayed as well as all the default actions
+      def default_index_config
+        @default_index_config ||= ::ActiveAdmin::PageConfig.new(:as => :table) do |display|
+          display.id
+          resource_class.content_columns.each do |column|
+            display.column column.name.to_sym
+          end
+          display.default_actions
+        end
+      end
+
+      # Returns the actual class for renderering the main content on the index
+      # page. To set this, use the :as option in the page_config block.
+      def find_index_renderer_class(symbol_or_class)
+        case symbol_or_class
+        when Symbol
+          ::ActiveAdmin::Pages::Index.const_get(symbol_or_class.to_s.camelcase)
+        when Class
+          symbol_or_class
+        else
+          raise ArgumentError, "'as' requires a class or a symbol"
+        end
+      end
+
+    end
+  end
+end
+

data/lib/active_admin/pages/index/blog.rb

@@ -0,0 +1,65 @@
+module ActiveAdmin
+  module Pages
+    class Index
+
+      class Blog < Renderer
+
+        def to_html(page_config, collection)
+          @page_config = page_config
+          @config = Builder.new
+          @page_config.block.call(@config) if @page_config.block
+
+          wrap_with_pagination(collection, :entry_name => active_admin_config.resource_name) do
+            content_tag :div do
+              collection.collect{|item| render_post(item) }.join
+            end
+          end
+        end
+
+        private
+
+        def render_post(post)
+          content_tag_for :div, post do
+            title = content_tag :h3, link_to(post_title_content(post), resource_path(post))
+            main_content = content_tag(:div, post_content(post), :class => 'content')
+            title + main_content
+          end
+        end
+
+        def post_title_content(post)
+          call_method_or_proc_on(post, @config.title) || "#{active_admin_config.resource_name} #{post.id}"
+        end
+
+        def post_content(post)
+          call_method_or_proc_on(post, @config.content) || ""
+        end
+
+
+        # A small builder class which gets passed into the block when defining
+        # the options to display as posts.
+        #
+        # ActiveAdmin.register Post
+        #   index :as => :posts do |i|
+        #     # i is an instance of Builder
+        #   end
+        # end
+        class Builder
+          def title(method = nil, &block)
+            if block_given? || method
+              @title = block_given? ? block : method
+            end
+            @title
+          end
+
+          def content(method = nil, &block)
+            if block_given? || method
+              @content = block_given? ? block : method
+            end
+            @content
+          end
+        end
+
+      end # Posts
+    end
+  end
+end

data/lib/active_admin/pages/index/table.rb

@@ -0,0 +1,48 @@
+module ActiveAdmin
+  module Pages
+    class Index
+
+      class Table < Renderer
+
+        def to_html(page_config, collection)
+          wrap_with_pagination(collection, :entry_name => active_admin_config.resource_name) do
+            table_options = {
+              :id => active_admin_config.plural_resource_name.underscore, 
+              :sortable => true,
+              :class => "index_table"
+            }
+            TableBuilder.new(&page_config.block).to_html(self, collection, table_options)
+          end
+        end
+
+        # 
+        # Extend the default ActiveAdmin::TableBuilder with some
+        # methods for quickly displaying items on the index page
+        #
+        class TableBuilder < ::ActiveAdmin::TableBuilder
+
+          # Display a column for the id
+          def id
+            column 'ID', :id
+          end
+
+          # Adds links to View, Edit and Delete
+          def default_actions(options = {})
+            options = {
+              :name => ""
+            }.merge(options)
+            column options[:name] do |resource|
+              links = link_to "View", resource_path(resource)
+              links += " | "
+              links += link_to "Edit", edit_resource_path(resource)
+              links += " | "
+              links += link_to "Delete", resource_path(resource), :method => :delete, :confirm => "Are you sure you want to delete this?"
+              links
+            end
+          end
+        end # TableBuilder
+
+      end # Table
+    end
+  end
+end

data/lib/active_admin/pages/index/thumbnails.rb

@@ -0,0 +1,40 @@
+module ActiveAdmin
+  module Pages
+    class Index
+
+      class Thumbnails < Renderer
+
+        def to_html(page_config, collection)
+          @page_config = page_config
+          @config = Builder.new
+          @page_config.block.call(@config) if @page_config.block
+
+          wrap_with_pagination(collection, :entry_name => active_admin_config.resource_name) do
+            content_tag :div, :style => "clear:both;" do
+              collection.collect{|item| render_image(item) }.join
+            end
+          end
+        end
+
+        def render_image(item)
+          link_to tag("img", :src => thumbnail_url(item), :width => 200, :height => 200),
+                  resource_path(item)
+        end
+
+        def thumbnail_url(item)
+          call_method_or_proc_on(item, @config.image)
+        end          
+
+        class Builder
+          def image(method = nil, &block)
+            if block_given? || method
+              @image = block_given? ? block : method
+            end
+            @image
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_admin/pages/new.rb

@@ -0,0 +1,21 @@
+module ActiveAdmin
+  module Pages
+    class New < Base
+
+      def title
+        "New #{active_admin_config.resource_name}"
+      end
+
+      def main_content
+        config = self.form_config.dup
+        config.delete(:block)
+        config.reverse_merge!({
+          :url => collection_path
+        })
+
+        active_admin_form_for resource, config, &form_config[:block]
+      end
+    end    
+
+  end
+end

data/lib/active_admin/pages/show.rb

@@ -0,0 +1,54 @@
+module ActiveAdmin
+  module Pages
+    class Show < Base
+
+      def config
+        active_admin_config.page_configs[:show] || ::ActiveAdmin::PageConfig.new
+      end
+
+      def title
+        case config[:title]
+        when Symbol, Proc
+          call_method_or_proc_on(resource, config[:title])
+        when String
+          config[:title]
+        else
+          default_title
+        end
+      end
+
+      def main_content
+        if config.block
+          # Eval the show config from the controller
+          instance_eval &config.block
+        else
+          default_main_content
+        end
+      end
+
+      protected
+
+      def default_title
+        "#{active_admin_config.resource_name} ##{resource.id}"
+      end
+
+      def default_main_content
+        table_options = {
+          :border => 0, 
+          :cellpadding => 0, 
+          :cellspacing => 0,
+          :id => "#{resource_class.name.underscore}_attributes",
+          :class => "resource_attributes"
+        }        
+        content_tag :table, table_options do
+          show_view_columns.collect do |attr|
+            content_tag :tr do
+              content_tag(:th, attr.to_s.titlecase) + content_tag(:td, resource.send(attr))
+            end
+          end.join
+        end        
+      end
+
+    end
+  end
+end

data/lib/active_admin/renderer.rb

@@ -0,0 +1,72 @@
+module ActiveAdmin
+  class Renderer
+
+    attr_accessor :view, :assigns
+
+    def initialize(view_or_renderer)
+      @view = view_or_renderer.is_a?(Renderer) ? view_or_renderer.view : view_or_renderer
+      @assigns = view.assigns.each { |key, value| instance_variable_set("@#{key}", value) }
+    end
+
+    def method_missing(*args, &block)
+      view.send(*args, &block)
+    end    
+
+    def to_html(*args)
+    end
+
+    def to_s(*args)
+      to_html(*args)
+    end
+
+    def haml(template)
+      begin
+        require 'haml' unless defined?(Haml)
+      rescue LoadError
+        raise LoadError, "Please install the HAML gem to use the HAML method with ActiveAdmin"
+      end
+
+      # Find the first non whitespace character in the template
+      indent = template.index(/\S/)
+
+      # Remove the indent if its greater than 0
+      if indent > 0
+        template = template.split("\n").collect do |line|
+          line[indent..-1]
+        end.join("\n")
+      end
+
+      # Render it baby
+      Haml::Engine.new(template).render(self)
+    end
+
+    protected
+
+    # Although we make a copy of all the instance variables on the way in, it
+    # doesn't mean that we can set new instance variables that are stored in
+    # the context of the view. This method allows you to do that. It can be useful
+    # when trying to share variables with a layout.
+    def set_ivar_on_view(name, value)
+      view.instance_variable_set(name, value)
+    end
+
+    # Many times throughout the views we want to either call a method on an object
+    # or instance_exec a proc passing in the object as the first parameter. This
+    # method takes care of this functionality.
+    #
+    #   call_method_or_proc_on(@my_obj, :size) same as @my_obj.size
+    # OR
+    #   proc = Proc.new{|s| s.size }
+    #   call_method_or_proc_on(@my_obj, proc)
+    #
+    def call_method_or_proc_on(obj, symbol_or_proc)
+      case symbol_or_proc
+      when Symbol, String
+        obj.send(symbol_or_proc.to_sym)
+      when Proc
+        instance_exec(obj, &symbol_or_proc)
+      end
+    end
+    
+  end
+end

data/lib/active_admin/resource.rb

@@ -0,0 +1,96 @@
+module ActiveAdmin
+  class Resource
+
+    attr_reader :namespace, :resource, :page_configs, :member_actions, :collection_actions,
+                :parent_menu_item_name
+    attr_accessor :resource_name, :sort_order, :scope_to, :scope_to_association_method
+
+    def initialize(namespace, resource, options = {})
+      @namespace = namespace
+      @resource = resource
+      @options = default_options.merge(options)
+      @sort_order = @options[:sort_order]
+      @page_configs = {}
+      @member_actions, @collection_actions = [], []
+    end
+
+    # An underscored safe representation internally for this resource
+    def underscored_resource_name
+      @underscored_resource_name ||= if @options[:as]
+        @options[:as].gsub(' ', '').underscore.singularize
+      else
+        resource.name.gsub('::','').underscore
+      end
+    end
+
+    # A camelized safe representation for this resource
+    def camelized_resource_name
+      underscored_resource_name.camelize
+    end
+
+    # Returns the name to call this resource
+    def resource_name
+      @resource_name ||= underscored_resource_name.titleize
+    end
+
+    # Returns the plural version of this resource
+    def plural_resource_name
+      @plural_resource_name ||= resource_name.pluralize
+    end
+
+    # Returns a properly formatted controller name for this
+    # resource within its namespace
+    def controller_name
+      [namespace.module_name, camelized_resource_name.pluralize + "Controller"].compact.join('::')
+    end
+
+    # Returns the controller for this resource
+    def controller
+      @controller ||= controller_name.constantize
+    end
+
+    # Returns the routes prefix for this resource
+    def route_prefix
+      controller.resources_configuration[:self][:route_prefix]
+    end
+
+    # Returns a symbol for the route to use to get to the
+    # collection of this resource
+    def route_collection_path
+      [route_prefix, controller.resources_configuration[:self][:route_collection_name], 'path'].compact.join('_').to_sym
+    end
+
+    # Set the menu options
+    def menu(options = {})
+      @parent_menu_item_name = options[:parent]
+    end
+
+    # Returns the name to be displayed in the menu for this resource
+    def menu_item_name
+      @menu_item_name ||= plural_resource_name
+    end
+
+    def clear_member_actions!
+      @member_actions = []
+    end
+
+    def clear_collection_actions!
+      @collection_actions = []
+    end
+
+    # Returns the name of the controller class for this resource
+    def dashboard_controller_name
+      [namespace.module_name, "DashboardController"].compact.join("::")
+    end
+
+    private
+
+    def default_options
+      {
+        :namespace  => ActiveAdmin.default_namespace,
+        :sort_order => ActiveAdmin.default_sort_order,
+      }
+    end
+
+  end
+end