saulolso-activeadmin 0.2.2

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,198 @@
+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)
+      resources.values.find{|config| config.resource == klass }
+    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("Dashboard", dashboard_path, 1) unless menu["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/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

data/lib/active_admin/resource/belongs_to.rb

@@ -0,0 +1,31 @@
+module ActiveAdmin
+  class Resource
+    class BelongsTo
+
+      class TargetNotFound < StandardError; end
+
+      # The resource which initiated this relationship
+      attr_reader :owner
+
+      def initialize(owner_resource, target_name, options = {})
+        @owner, @target_name = owner_resource, target_name
+        @options = options
+      end
+
+      # Returns the target resource class or raises an exception if it doesn't exist
+      def target
+        namespace.resources[@target_name.to_s.camelize] or 
+          raise TargetNotFound, "Could not find registered resource #{@target_name} in #{namespace.name} with #{namespace.resources.keys.inspect}"
+      end
+
+      def namespace
+        @owner.namespace
+      end
+
+      def optional?
+        @options[:optional]
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource.rb

@@ -0,0 +1,229 @@
+module ActiveAdmin
+
+  # Resource is the primary data storage for resource configuration in Active Admin
+  #
+  # When you register a resource (ActiveAdmin.register Post) you are actually creating
+  # a new Resource instance within the given Namespace.
+  #
+  # The instance of the current resource is available in ResourceController and views
+  # by calling the #active_admin_config method.
+  #
+  class Resource
+
+    # Event dispatched when a new resource is registered
+    RegisterEvent = 'active_admin.resource.register'.freeze
+
+    autoload :BelongsTo, 'active_admin/resource/belongs_to'
+
+    # The namespace this resource belongs to
+    attr_reader :namespace
+
+    # The class this resource wraps. If you register the Post model, Resource#resource
+    # will point to the Post class
+    attr_reader :resource
+
+    # A hash of page configurations for the controller indexed by action name
+    attr_reader :page_configs
+
+    # An array of member actions defined for this resource
+    attr_reader :member_actions
+
+    # An array of collection actions defined for this resource
+    attr_reader :collection_actions
+
+    # The titleized name to use for this resource
+    attr_accessor :resource_name
+
+    # The default sort order to use in the controller
+    attr_accessor :sort_order
+
+    # Scope this resource to an association in the controller
+    attr_accessor :scope_to
+
+    # If we're scoping resources, use this method on the parent to return the collection
+    attr_accessor :scope_to_association_method
+
+    # Set to false to turn off admin notes
+    attr_accessor :admin_notes
+
+    # Set the configuration for the CSV
+    attr_writer :csv_builder
+
+    def initialize(namespace, resource, options = {})
+      @namespace = namespace
+      @resource = resource
+      @options = default_options.merge(options)
+      @sort_order = @options[:sort_order]
+      @page_configs = {}
+      @menu_options = {}
+      @member_actions, @collection_actions = [], []
+      @scopes = []
+    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.
+    # By default will use resource.model_name.human
+    def resource_name
+      @resource_name ||= if @options[:as] || !resource.respond_to?(:model_name)
+        underscored_resource_name.titleize
+      else
+        resource.model_name.human.titleize
+      end
+    end
+
+    # Returns the plural version of this resource
+    def plural_resource_name
+      @plural_resource_name ||= resource_name.pluralize
+    end
+
+    def resource_table_name
+      resource.table_name
+    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
+      namespace.module_name.try(:underscore)
+    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
+
+    # Returns the named route for an instance of this resource
+    def route_instance_path
+      [route_prefix, controller.resources_configuration[:self][:route_instance_name], 'path'].compact.join('_').to_sym
+    end
+
+    # Set the menu options. To not add this resource to the menu, just
+    # call #menu(false)
+    def menu(options = {})
+      options = options == false ? { :display => false } : options
+      @menu_options = options
+    end
+
+    # Returns the name to put this resource under in the menu
+    def parent_menu_item_name
+      @menu_options[:parent]
+    end
+
+    # Returns the name to be displayed in the menu for this resource
+    def menu_item_name
+      @menu_options[:label] || plural_resource_name
+    end
+    
+    # Returns the items priority for altering the default sort order
+    def menu_item_priority
+      @menu_options[:priority] || 10
+    end
+    
+    # Returns a proc for deciding whether to display the menu item or not in the view
+    def menu_item_display_if
+      @menu_options[:if] || proc { true }
+    end
+
+    # Should this resource be added to the menu system?
+    def include_in_menu?
+      return false if @menu_options[:display] == false
+      !(belongs_to? && !belongs_to_config.optional?)
+    end
+
+
+    # Clears all the member actions this resource knows about
+    def clear_member_actions!
+      @member_actions = []
+    end
+
+    def clear_collection_actions!
+      @collection_actions = []
+    end
+
+    # Return an array of scopes for this resource
+    def scopes
+      @scopes
+    end
+
+    # Returns a scope for this object by its identifier
+    def get_scope_by_id(id)
+      id = id.to_s
+      @scopes.find{|s| s.id == id }
+    end
+
+    def default_scope
+      @default_scope
+    end
+
+    # Create a new scope object for this resource.
+    # If you want to internationalize the scope name, you can add
+    # to your i18n files a key like "active_admin.scopes.scope_method".
+    def scope(*args, &block)
+      options = args.extract_options!
+      @scopes << ActiveAdmin::Scope.new(*args, &block)
+      if options[:default]
+        @default_scope = @scopes.last
+      end
+    end
+
+    # Are admin notes turned on for this resource
+    def admin_notes?
+      admin_notes.nil? ? ActiveAdmin.admin_notes : admin_notes
+    end
+
+    def belongs_to(target, options = {})
+      @belongs_to = Resource::BelongsTo.new(self, target, options)
+      controller.belongs_to(target, options.dup)
+    end
+
+    def belongs_to_config
+      @belongs_to
+    end
+
+    # Do we belong to another resource
+    def belongs_to?
+      !belongs_to_config.nil?
+    end
+
+    # The csv builder for this resource
+    def csv_builder
+      @csv_builder || default_csv_builder
+    end
+
+    private
+
+    def default_options
+      {
+        :namespace  => ActiveAdmin.application.default_namespace,
+        :sort_order => ActiveAdmin.application.default_sort_order
+      }
+    end
+
+    def default_csv_builder
+      @default_csv_builder ||= CSVBuilder.default_for_resource(resource)
+    end
+  end # class Resource
+end # module ActiveAdmin

data/lib/active_admin/resource_controller/action_builder.rb

@@ -0,0 +1,21 @@
+module ActiveAdmin
+  class ResourceController < ::InheritedResources::Base
+
+    module ActionBuilder
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def clear_member_actions!
+          active_admin_config.clear_member_actions!
+        end
+
+        def clear_collection_actions!
+          active_admin_config.clear_collection_actions!
+        end
+      end
+
+    end
+
+  end
+end