andrewroth_activeadmin 0.3.4

data/lib/active_admin/locales/zh_cn.yml

@@ -0,0 +1,40 @@
+zh_cn:
+  active_admin:
+    dashboard: "控制面板"
+    dashboard_welcome:
+      welcome: "欢迎使用Active Admin. 这是默认的控制面板页."
+      call_to_action: "若要添加新的面板内容, 请修改 'app/admin/dashboards.rb'"
+    view: "查看"
+    edit: "编辑"
+    delete: "删除"
+    delete_confirmation: "确定删除?"
+    new_model: "新建%{model}"
+    edit_model: "编辑%{model}"
+    delete_model: "删除%{model}"
+    details: "%{model}详情"
+    cancel: "取消"
+    empty: "清空"
+    previous: "上一个"
+    next: "下一个"
+    download: "下载:"
+    has_many_new: "新建一个%{model}"
+    has_many_delete: "删除"
+    filter: "过滤"
+    clear_filters: "清除条件"
+    search_field: "查找%{field}"
+    equal_to: "等于"
+    greater_than: "大于"
+    less_than: "小于"
+    main_content: "请执行 %{model}#main_content 来显示内容."
+    logout: "退出"
+    sidebars:
+      filters: "所有条件"
+    pagination:
+      empty: "暂时没有%{model}"
+      one: "显示 <b>1</b> %{model}"
+      one_page: "显示 <b>所有 %{n}</b> %{model}"
+      multiple: "显示所有 <b>%{total}</b> %{model}中的<b>%{from}&nbsp;-&nbsp;%{to}</b> 条"
+    any: "任何"
+    blank_slate:
+      content: "暂时还没有%{resource_name}."
+      link: "新建一个"

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,64 @@
+module ActiveAdmin
+
+  class FileUpdateChecker < ::ActiveSupport::FileUpdateChecker
+
+    # Over-ride the default #updated_at to support the deletion of files
+    def updated_at
+      paths.map { |path| File.mtime(path) rescue Time.now }.max
+    end
+
+  end
+
+  # Deals with reloading Active Admin on each request in 
+  # development and once in production.
+  class Reloader
+
+    attr_reader :active_admin_app, 
+                :rails_app,
+                :file_update_checker
+
+    # @param [ActiveAdmin::Application] app
+    # @param [String] rails_version The version of Rails we're using. 
+    #                 We use this to switch between the correcrt Rails reloader class.
+    def initialize(rails_app, active_admin_app, rails_version)
+      @rails_app = rails_app
+      @active_admin_app = active_admin_app
+      @rails_version = rails_version.to_s
+      @file_update_checker = FileUpdateChecker.new(watched_paths) do
+        reload!
+      end
+    end
+
+    def reload!
+      active_admin_app.unload!
+      rails_app.reload_routes!
+      file_update_checker.paths.clear
+      watched_paths.each{|path| file_update_checker.paths << path }
+    end
+
+    # Attach to Rails and perform the reload on each request.
+    def attach!
+      # Bring the checker into local scope for the ruby block
+      checker = file_update_checker
+
+      reloader_class.to_prepare do
+        checker.execute_if_updated
+      end
+    end
+
+    def watched_paths
+      paths = active_admin_app.load_paths
+      active_admin_app.load_paths.each{|path| paths += Dir[File.join(path, "**", "*.rb")]}
+      paths
+    end
+
+    def reloader_class
+      if @rails_version[0..2] == '3.1'
+        ActionDispatch::Reloader
+      else
+        ActionDispatch::Callbacks
+      end
+    end
+
+  end
+end