activeadmin 0.1.0

data/lib/active_admin/form_builder.rb

@@ -0,0 +1,91 @@
+module ActiveAdmin
+  class FormBuilder < ::Formtastic::SemanticFormBuilder
+    
+    def initialize(*args)
+      @form_buffers = ["".html_safe]
+      @skip_form_buffer = false
+      super
+    end
+
+    # Sets up buffering for this form which allows
+    # the entire form to be built in a block outside
+    # of the context of the view. Ie: you don't need
+    # to use erb tags.
+    def self.buffer_output_for(*method_names)
+      method_names.each do |method_name|
+        module_eval <<-EOF
+          def #{method_name}(*args)
+            content = block_given? ? with_new_form_buffer{ super } : super
+            return content if @skip_form_buffer
+            @form_buffers.last << content.html_safe
+          end
+        EOF
+      end
+    end
+
+    buffer_output_for   :submit,
+                        :label,
+                        :inputs_for_nested_attributes,
+                        :semantic_fields_for,
+                        :text_field,
+                        :text_area,
+                        :datetime_select,
+                        :time_select,
+                        :date_select,
+                        :radio_button,
+                        :file_field,
+                        :hidden_field,
+                        :select,
+                        :grouped_collection_select,
+                        :collection_select
+
+    def inputs(*args, &block)
+      # Store that we are creating inputs without a block
+      @inputs_with_no_block = true unless block_given?
+      content = with_new_form_buffer { super }
+      @form_buffers.last << content.html_safe
+    end
+
+    # The input method returns a properly formatted string for
+    # its contents, so we want to skip the internal buffering
+    # while building up its contents
+    def input(*args)
+      @skip_form_buffer = true
+      content = with_new_form_buffer { super }
+      @skip_form_buffer = false
+      return content.html_safe if @inputs_with_no_block
+      @form_buffers.last << content.html_safe
+    end
+
+    # The buttons method always needs to be wrapped in a new buffer
+    def buttons(*args, &block)
+      content = with_new_form_buffer{ super }
+      @form_buffers.last << content.html_safe
+    end
+
+    def datepicker_input(method, options)
+      options = options.dup
+      options[:input_html] ||= {}
+      options[:input_html][:class] = [options[:input_html][:class], "datepicker"].compact.join(' ')
+      options[:input_html][:size] ||= "10"
+      string_input(method, options)
+    end
+
+    private
+
+    def with_new_form_buffer
+      @form_buffers << "".html_safe
+      return_value = yield
+      @form_buffers.pop
+      return_value
+    end
+
+    def skip_form_buffers
+      @skip_form_buffer = true
+      return_value = yield
+      @skip_form_buffer = false
+      return_value
+    end
+    
+  end
+end

data/lib/active_admin/helpers/optional_display.rb

@@ -0,0 +1,34 @@
+module ActiveAdmin
+  
+  # Shareable module to give a #display_on?(action) method
+  # which returns true or false depending on an options hash.
+  #
+  # The options hash accepts:
+  #
+  # :only => :index
+  # :only => [:index, :show]
+  # :except => :index
+  # :except => [:index, :show]
+  #
+  # call #normalize_display_options! after @options has been set
+  # to ensure that the display options are setup correctly
+
+  module OptionalDisplay
+    def display_on?(action)
+      return @options[:only].include?(action.to_sym) if @options[:only]
+      return !@options[:except].include?(action.to_sym) if @options[:except]
+      true
+    end
+
+    private
+
+    def normalize_display_options!
+      if @options[:only]
+        @options[:only] = @options[:only].is_a?(Array) ? @options[:only] : [@options[:only]]
+      end
+      if @options[:except]
+        @options[:except] = @options[:except].is_a?(Array) ? @options[:except] : [@options[:except]]
+      end
+    end
+  end
+end

data/lib/active_admin/menu.rb

@@ -0,0 +1,42 @@
+module ActiveAdmin
+  class Menu
+    
+    def initialize
+      @items = []
+      yield(self) if block_given?
+    end  
+    
+    def add(*args, &block)
+      @items << MenuItem.new(*args, &block)
+    end
+    
+    def [](name)
+      items.find{ |i| i.name == name }
+    end
+    
+    def items
+      @items.sort
+    end
+    
+    def find_by_url(url)
+      recursive_find_by_url(items, url)
+    end
+    
+    private
+    
+    def recursive_find_by_url(collection, url)
+      found = nil
+      collection.each do |item|
+        if item.url == url
+          found = item
+          break
+        else
+          found = recursive_find_by_url(item.children, url)
+          break if found
+        end
+      end
+      found
+    end
+    
+  end
+end

data/lib/active_admin/menu_item.rb

@@ -0,0 +1,67 @@
+module ActiveAdmin
+  class MenuItem
+    
+    # Use this to get to the routes
+    include Rails.application.routes.url_helpers
+    
+    attr_accessor :name, :url, :priority, :parent, :display_if_block
+    
+    def initialize(name, url, priority = 10, options = {})
+      @name, @url, @priority = name, url, priority
+      @children = []
+      @cached_url = {} # Stores the cached url in a hash to allow us to change it and still cache it
+
+      @display_if_block = options.delete(:if)
+      
+      yield(self) if block_given? # Builder style syntax
+    end
+
+    def add(name, url, priority=10, options = {}, &block)
+      item = MenuItem.new(name, url, priority, options, &block)
+      item.parent = self
+      @children << item
+    end  
+    
+    def children
+      @children.sort
+    end
+    
+    def parent?
+      !parent.nil?
+    end
+    
+    def dom_id
+      name.downcase.gsub( " ", '_' ).gsub( /[^a-z0-9_]/, '' )
+    end
+    
+    def url
+      case @url
+      when Symbol
+        generated = send(@url) # Call the named route
+      else
+        generated = @url
+      end
+      @cached_url[@url] ||= generated
+    end
+    
+    # Returns an array of the ancestory of this menu item
+    # The first item is the immediate parent fo the item
+    def ancestors
+      return [] unless parent?
+      [parent, parent.ancestors].flatten
+    end
+    
+    # Returns the child item with the name passed in
+    #    @blog_menu["Create New"] => <#MenuItem @name="Create New" >
+    def [](name)
+      @children.find{ |i| i.name == name }
+    end
+    
+    def <=>(other)
+      result = priority <=> other.priority
+      result = name <=> other.name if result == 0
+      result
+    end
+
+  end  
+end

data/lib/active_admin/namespace.rb

@@ -0,0 +1,111 @@
+module ActiveAdmin
+  class Namespace
+
+    attr_reader :resources, :name, :menu
+
+    def initialize(name)
+      @name = name.to_s.underscore.to_sym
+      @resources = {}
+      @menu = Menu.new
+    end
+
+    def register(resource, options = {}, &block)
+      # Init and store the resource
+      config = Resource.new(self, resource, options)
+      @resources[config.camelized_resource_name] = config
+
+      # Register the resource
+      register_module unless root?
+      register_resource_controller(config, &block)
+      register_dashboard_controller(config)
+      register_with_menu(config)
+      
+      # Return the config
+      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!
+      unload_dashboard!
+      unload_menu!
+    end
+
+    protected
+
+    def unload_resources!
+      resources.each do |name, config|
+        parent = (module_name || 'Object').constantize
+        const_name = config.controller_name.split('::').last
+        # Remove the const if its been defined
+        parent.send(:remove_const, const_name) if parent.const_defined?(const_name)
+      end
+    end
+
+    def unload_dashboard!
+      # TODO: Only clear out my sections
+      Dashboards.clear_all_sections!
+    end
+
+    def unload_menu!
+      @menu = Menu.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, &block)
+      eval "class ::#{config.controller_name} < ActiveAdmin::ResourceController; end"
+      config.controller.active_admin_config = config
+      config.controller.class_eval(&block) if block_given?
+    end
+
+    # Creates a dashboard controller for this config
+    def register_dashboard_controller(config)
+      eval "class ::#{config.dashboard_controller_name} < ActiveAdmin::Dashboards::DashboardController; end"
+    end
+
+    # Does all the work of registernig a config with the menu system
+    def register_with_menu(config)
+      menu.add("Dashboard", "#{name}_dashboard_path".to_sym, 1) unless menu["Dashboard"]
+
+      # The menu we're going to add this resource to
+      add_to = menu
+
+      # Adding as a child
+      if config.parent_menu_item_name
+        # Create the parent if it doesn't exist
+        menu.add(config.parent_menu_item_name, '#') unless menu[config.parent_menu_item_name]
+        add_to = menu[config.parent_menu_item_name]
+      end
+
+      # Check if this menu item has already been created
+      if add_to[config.menu_item_name]
+        # Update the url if it's already been created
+        add_to[config.menu_item_name].url = config.route_collection_path
+      else
+        add_to.add(config.menu_item_name, config.route_collection_path)
+      end
+    end
+
+
+  end
+end

data/lib/active_admin/page_config.rb

@@ -0,0 +1,15 @@
+module ActiveAdmin
+  class PageConfig
+
+    attr_reader :block
+
+    def initialize(options = {}, &block)
+      @options, @block = options, block
+    end
+
+    def [](key)
+      @options[key]
+    end
+      
+  end
+end

data/lib/active_admin/pages.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module Pages
+
+    autoload :Base,       'active_admin/pages/base'
+    autoload :Index,      'active_admin/pages/index'
+    autoload :New,        'active_admin/pages/new'
+    autoload :Show,       'active_admin/pages/show'
+    autoload :Edit,       'active_admin/pages/edit'
+
+  end
+end

data/lib/active_admin/pages/base.rb

@@ -0,0 +1,92 @@
+module ActiveAdmin
+  module Pages
+    class Base < ::ActiveAdmin::Renderer
+
+      def breadcrumb(separator = "/")
+        content_tag :span, :class => "breadcrumb" do
+          @breadcrumbs.map { |txt, path| link_to_unless((path.blank? || current_page?(path)), h(txt), path) }.join(" #{content_tag(:span, separator, :class => "breadcrumb_sep")} ")
+        end
+      end
+
+      def main_content
+        "Please implement #{self.class.name}#main_content to display content.".html_safe
+      end
+
+      def title_bar
+        content_for :title_bar do
+          [breadcrumb, title_tag, action_items].join.html_safe
+        end
+      end
+
+      def title_tag
+        content_tag :h2, title, :id => 'page_title'
+      end
+
+      def title
+        self.class.name
+      end
+
+      # Set's the page title for the layout to render
+      def set_page_title
+        set_ivar_on_view "@page_title", title
+      end
+
+      def action_items_renderer
+        ActiveAdmin::ActionItems::Renderer
+      end
+
+      def action_items
+        items = controller.class.action_items_for(params[:action])
+        action_items_renderer.new(self).to_html(items)
+      end
+
+      # Returns the renderer class to use to render the sidebar
+      #
+      # You could override this method and return your own custom
+      # sidebar renderer
+      def sidebar_renderer
+        ActiveAdmin::Sidebar::Renderer
+      end
+
+      # Returns the sidebar sections to render for the current action
+      def sidebar_sections
+        controller.class.sidebar_sections_for(params[:action])
+      end
+
+      # Renders the sidebar
+      def sidebar
+        content_for :sidebar do
+          sidebar_renderer.new(self).to_html(sidebar_sections)
+        end
+      end
+
+      # Renders the content for the footer
+      def footer
+        content_for :footer do
+          content_tag :p, "Powered by #{link_to("Active Admin", "http://www.activeadmin.info")} #{ActiveAdmin::VERSION}".html_safe
+        end
+      end
+
+      def flash_messages
+        content_for :flash_messages do
+          if flash.keys.any?
+            content_tag :div, :class => 'flashes' do
+              flash.collect do |type, message|
+                content_tag :div, message, :class => "flash flash_#{type}"
+              end.join
+            end
+          end
+        end
+      end
+
+      def to_html
+        set_page_title
+        title_bar
+        flash_messages
+        footer
+        sidebar
+        main_content
+      end
+    end
+  end
+end