nsm-activeadmin 0.2.2

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,73 @@
+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
+    
+    # Returns the display if block. If the block was not explicitly defined
+    # a default block always returning true will be returned.
+    def display_if_block
+      @display_if_block || lambda { |_| true }
+    end
+
+  end  
+end

data/lib/active_admin/namespace.rb

@@ -0,0 +1,206 @@
+module ActiveAdmin
+
+  class ResourceMismatchError < StandardError; end
+
+  # 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, :menu
+
+    def initialize(application, name)
+      @application = application
+      @name = name.to_s.underscore.to_sym
+      @resources = {}
+      @menu = Menu.new
+      register_module unless root?
+      generate_dashboard_controller
+    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, options = {}, &block)
+      config = find_or_build_resource(resource, options)
+
+      # Register the resource
+      register_resource_controller(config)
+      parse_registration_block(config, &block) if block_given?
+      register_with_menu(config) if config.include_in_menu?
+
+      # Ensure that the dashboard is generated
+      generate_dashboard_controller
+
+      # Dispatch a registration event
+      ActiveAdmin::Event.dispatch ActiveAdmin::Resource::RegisterEvent, 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
+
+    # Returns the name of the dashboard controller for this namespace
+    def dashboard_controller_name
+      [module_name, "DashboardController"].compact.join("::")
+    end
+
+    # Unload all the registered resources for this namespace
+    def unload!
+      unload_resources!
+      unload_dashboard!
+      unload_menu!
+    end
+
+    # The menu gets built by Active Admin once all the resources have been
+    # loaded. This method gets called to register each resource with the menu system.
+    def load_menu!
+      register_dashboard
+      resources.values.each do |config|
+        register_with_menu(config) if config.include_in_menu?
+      end
+    end
+
+    # Returns the first registered ActiveAdmin::Resource instance for a given class
+    def resource_for(klass)
+      actual = resources.values.find{|config| config.resource == klass }
+      return actual if actual
+
+      if klass.respond_to?(:base_class)
+        base_class = klass.base_class
+        resources.values.find{|config| config.resource == base_class }
+      else
+        nil
+      end
+    end
+
+    protected
+
+    # Either returns an existing Resource instance or builds a new
+    # one for the resource and options
+    def find_or_build_resource(resource_class, options)
+      resource = Resource.new(self, resource_class, options)
+
+      # If we've already registered this resource, use the existing
+      if @resources.has_key? resource.camelized_resource_name
+        existing_resource = @resources[resource.camelized_resource_name]
+
+        if existing_resource.resource != resource_class
+          raise ActiveAdmin::ResourceMismatchError, 
+            "Tried to register #{resource_class} as #{resource.camelized_resource_name} but already registered to #{resource.resource}"
+        end
+
+        resource = existing_resource
+      else
+        @resources[resource.camelized_resource_name] = resource
+      end
+
+      resource
+    end
+
+    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
+      @resources = {}
+    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)
+      eval "class ::#{config.controller_name} < ActiveAdmin::ResourceController; end"
+      config.controller.active_admin_config = config
+    end
+
+    def dsl
+      @dsl ||= DSL.new
+    end
+
+    def parse_registration_block(config, &block)
+      dsl.run_registration_block(config, &block)
+    end
+
+    # Creates a dashboard controller for this config
+    def generate_dashboard_controller
+      eval "class ::#{dashboard_controller_name} < ActiveAdmin::Dashboards::DashboardController; end"
+    end
+
+    # Adds the dashboard to the menu
+    def register_dashboard
+      dashboard_path = root? ? :dashboard_path : "#{name}_dashboard_path".to_sym
+      menu.add(I18n.t("active_admin.dashboard"), dashboard_path, 1) unless menu[I18n.t("active_admin.dashboard")]
+    end
+
+    # Does all the work of registernig a config with the menu system
+    def register_with_menu(config)
+      # 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, config.menu_item_priority, { :if => config.menu_item_display_if })
+      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/reloader.rb

@@ -0,0 +1,30 @@
+module ActiveAdmin
+  # Deals with reloading Active Admin on each request in 
+  # development and once in production.
+  class Reloader
+
+    # @param [String] rails_version
+    #   The version of Rails we're using. We use this to switch between
+    #   the correcr Rails reloader class.
+    def initialize(rails_version)
+      @rails_version = rails_version.to_s
+    end
+
+    # Attach to Rails and perform the reload on each request.
+    def attach!
+      reloader_class.to_prepare do
+        ActiveAdmin.application.unload!
+        Rails.application.reload_routes!
+      end
+    end
+
+    def reloader_class
+      if @rails_version[0..2] == '3.1'
+        ActionDispatch::Reloader
+      else
+        ActionDispatch::Callbacks
+      end
+    end
+
+  end
+end

data/lib/active_admin/renderer.rb

@@ -0,0 +1,87 @@
+module ActiveAdmin
+  class Renderer
+
+    include ::ActiveAdmin::ViewHelpers::RendererHelper
+    include Arbre::HTML
+
+    attr_accessor :view, :assigns
+
+    # For use in html
+    alias_method :helpers, :view
+
+    def initialize(view_or_renderer)
+      @view = view_or_renderer.is_a?(Renderer) ? view_or_renderer.view : view_or_renderer
+
+      if view.respond_to?(:assigns)
+        @assigns = view.assigns.each { |key, value| instance_variable_set("@#{key}", value) }
+      else
+        @assigns = {}
+      end
+    end
+
+    def method_missing(name,*args, &block)
+      if view.respond_to?(name)
+        view.send(name, *args, &block)
+      else
+        super
+      end
+    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