nsm-activeadmin 0.2.2

data/lib/active_admin/application.rb

@@ -0,0 +1,228 @@
+require 'active_admin/router'
+require 'active_admin/helpers/settings'
+
+module ActiveAdmin
+  class Application
+    include Settings
+
+    # The default namespace to put controllers and routes inside. Set this
+    # in config/initializers/active_admin.rb using:
+    #
+    #   config.default_namespace = :super_admin
+    #
+    setting :default_namespace, :admin
+
+    # The default number of resources to display on index pages
+    setting :default_per_page, 30
+
+    # A hash of all the registered namespaces
+    setting :namespaces, {}
+
+    # The title which gets displayed in the main layout
+    setting :site_title, ""
+
+    # Load paths for admin configurations. Add folders to this load path
+    # to load up other resources for administration. External gems can
+    # include their paths in this load path to provide active_admin UIs
+    setting :load_paths, [File.expand_path('app/admin', Rails.root)]
+
+    # The view factory to use to generate all the view classes. Take
+    # a look at ActiveAdmin::ViewFactory
+    setting :view_factory, ActiveAdmin::ViewFactory.new
+
+    # The method to call in controllers to get the current user
+    setting :current_user_method, false
+
+    # The method to call in the controllers to ensure that there
+    # is a currently authenticated admin user
+    setting :authentication_method, false
+
+    # The path to log user's out with. If set to a symbol, we assume
+    # that it's a method to call which returns the path
+    setting :logout_link_path, :destroy_admin_user_session_path
+
+    # The method to use when generating the link for user logout
+    setting :logout_link_method, :delete
+
+    # Active Admin makes educated guesses when displaying objects, this is
+    # the list of methods it tries calling in order
+    setting :display_name_methods, [ :display_name,
+                                      :full_name,
+                                      :name,
+                                      :username,
+                                      :login,
+                                      :title,
+                                      :email,
+                                      :to_s ]
+
+    # == Deprecated Settings
+
+    # @deprecated The default sort order for index pages
+    deprecated_setting :default_sort_order, 'id_desc'
+
+    # DEPRECATED: This option is deprecated and will be removed. Use
+    # the #allow_comments_in option instead
+    attr_accessor :admin_notes
+
+
+    include AssetRegistration
+
+    def initialize
+      register_default_assets
+    end
+
+    def prepare!
+      remove_active_admin_load_paths_from_rails_autoload_and_eager_load
+      attach_reloader
+      generate_stylesheets
+    end
+
+    # Registers a brand new configuration for the given resource.
+    def register(resource, options = {}, &block)
+      namespace_name = options.has_key?(:namespace) ? options[:namespace] : default_namespace
+      namespace = find_or_create_namespace(namespace_name)
+      namespace.register(resource, options, &block)
+    end
+
+    # Creates a namespace for the given name
+    def find_or_create_namespace(name)
+      name ||= :root
+      return namespaces[name] if namespaces[name]
+      namespace = Namespace.new(self, name)
+      ActiveAdmin::Event.dispatch ActiveAdmin::Namespace::RegisterEvent, namespace
+      namespaces[name] = namespace
+      namespace
+    end
+
+
+    # Stores if everything has been loaded or we need to reload
+    @@loaded = false
+
+    # Returns true if all the configuration files have been loaded.
+    def loaded?
+      @@loaded
+    end
+
+    # Removes all the controllers that were defined by registering
+    # resources for administration.
+    #
+    # We remove them, then load them on each request in development
+    # to allow for changes without having to restart the server.
+    def unload!
+      namespaces.values.each{|namespace| namespace.unload! }
+      self.namespaces = {}
+      @@loaded = false
+    end
+
+    # Loads all of the ruby files that are within the load path of
+    # ActiveAdmin.load_paths. This should load all of the administration
+    # UIs so that they are available for the router to proceed.
+    #
+    # The files are only loaded if we haven't already loaded all the files
+    # and they aren't marked for re-loading. To mark the files for re-loading
+    # you must first call ActiveAdmin.unload!
+    def load!
+      # No work to do if we've already loaded
+      return false if loaded?
+
+      # Load files
+      files_in_load_path.each{|file| load file }
+
+      # If no configurations, let's make sure you can still login
+      load_default_namespace if namespaces.values.empty?
+
+      # Load Menus
+      namespaces.values.each{|namespace| namespace.load_menu! }
+
+      @@loaded = true
+    end
+
+    # Returns ALL the files to load from all the load paths
+    def files_in_load_path
+      load_paths.flatten.compact.uniq.collect{|path| Dir["#{path}/**/*.rb"] }.flatten
+    end
+
+    def router
+      @router ||= Router.new(self)
+    end
+
+    def routes(rails_router)
+      # Ensure that all the configurations (which define the routes)
+      # are all loaded
+      load!
+
+      router.apply(rails_router)
+    end
+
+    def load_default_namespace
+      find_or_create_namespace(default_namespace)
+    end
+
+    #
+    # Add before, around and after filters to each registered resource.
+    #
+    # eg:
+    #
+    #   ActiveAdmin.before_filter :authenticate_admin!
+    #
+    def before_filter(*args, &block)
+      ResourceController.before_filter(*args, &block)
+    end
+
+    def skip_before_filter(*args, &block)
+      ResourceController.skip_before_filter(*args, &block)
+    end
+
+    def after_filter(*args, &block)
+      ResourceController.after_filter(*args, &block)
+    end
+
+    def around_filter(*args, &block)
+      ResourceController.around_filter(*args, &block)
+    end
+
+    # Helper method to add a dashboard section
+    def dashboard_section(name, options = {}, &block)
+      ActiveAdmin::Dashboards.add_section(name, options, &block)
+    end
+
+    private
+
+    def register_default_assets
+      register_stylesheet 'active_admin.css'
+      register_javascript 'active_admin.js'
+    end
+
+    # Since we're dealing with all our own file loading, we need
+    # to remove our paths from the ActiveSupport autoload paths.
+    # If not, file naming becomes very important and can cause clashes.
+    def remove_active_admin_load_paths_from_rails_autoload_and_eager_load
+      ActiveSupport::Dependencies.autoload_paths.reject!{|path| load_paths.include?(path) }
+      # Don't eagerload our configs, we'll deal with them ourselves
+      Rails.application.config.eager_load_paths = Rails.application.config.eager_load_paths.reject do |path|
+        load_paths.include?(path)
+      end
+    end
+
+    def attach_reloader
+      ActiveAdmin::Reloader.new(Rails.version).attach!
+    end
+
+
+    def generate_stylesheets
+      # This must be required after initialization
+      require 'sass/plugin'
+      require 'active_admin/sass/helpers'
+
+      # Create our own asset pipeline in Rails 3.0
+      if ActiveAdmin.use_asset_pipeline?
+        # Add our mixins to the load path for SASS
+        ::Sass::Engine::DEFAULT_OPTIONS[:load_paths] <<  File.expand_path("../../../app/assets/stylesheets", __FILE__)
+      else
+        require 'active_admin/sass/css_loader'
+        ::Sass::Plugin.add_template_location(File.expand_path("../../../app/assets/stylesheets", __FILE__))
+        ::Sass::Plugin.add_template_location(File.expand_path("../sass", __FILE__))
+      end
+    end
+  end
+end

data/lib/active_admin/arbre.rb

@@ -0,0 +1,23 @@
+require "active_admin/arbre/html"
+require "active_admin/arbre/attributes"
+require "active_admin/arbre/core_extensions"
+require "active_admin/arbre/element"
+require "active_admin/arbre/context"
+require "active_admin/arbre/collection"
+require "active_admin/arbre/class_list"
+require "active_admin/arbre/tag"
+require "active_admin/arbre/document"
+require "active_admin/arbre/html5_elements"
+require "active_admin/arbre/text_node"
+
+# Arbre - The DOM Tree in Ruby
+#
+# Arbre is a ruby library for building HTML in pure Object Oriented Ruby
+module Arbre
+end
+
+require 'action_view'
+
+ActionView::Template.register_template_handler :arb, lambda { |template|
+  "self.class.send :include, Arbre::HTML; @_helpers = self; @__current_dom_element__ = Arbre::Context.new(assigns, self); begin; #{template.source}; end; current_dom_context"
+}

data/lib/active_admin/arbre/attributes.rb

@@ -0,0 +1,20 @@
+module Arbre
+  module HTML
+
+    class Attributes < Hash
+
+      def to_html
+        self.collect do |name, value|
+          "#{html_escape(name)}=\"#{html_escape(value)}\""
+        end.join(" ")
+      end
+
+      protected
+
+      def html_escape(s)
+        ERB::Util.html_escape(s)
+      end
+    end
+
+  end
+end

data/lib/active_admin/arbre/class_list.rb

@@ -0,0 +1,28 @@
+require 'set'
+
+module Arbre
+  module HTML
+
+    # Holds a set of classes
+    class ClassList < Set
+
+      def add(class_names)
+        class_names.to_s.split(" ").each do |class_name|
+          super(class_name)
+        end
+        self
+      end
+      alias :<< :add
+
+      def to_s
+        to_html
+      end
+
+      def to_html
+        to_a.join(" ")
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/arbre/collection.rb

@@ -0,0 +1,27 @@
+module Arbre
+  module HTML
+
+    # Stores a collection of Element objects
+    class Collection < Array
+
+      def +(other)
+        self.class.new(super)
+      end
+
+      def -(other)
+        self.class.new(super)
+      end
+
+      def &(other)
+        self.class.new(super)
+      end
+
+      def to_html
+        self.collect do |element|
+          element.to_html
+        end.join.html_safe
+      end
+    end
+
+  end
+end

data/lib/active_admin/arbre/context.rb

@@ -0,0 +1,14 @@
+module Arbre
+  class Context < Arbre::HTML::Element
+    def indent_level
+      # A context does not increment the indent_level
+      super - 1
+    end
+
+    def length
+      to_html.length
+    end
+    alias :bytesize :length
+
+  end
+end

data/lib/active_admin/arbre/core_extensions.rb

@@ -0,0 +1,5 @@
+class Object
+  def to_html
+    to_s
+  end
+end

data/lib/active_admin/arbre/document.rb

@@ -0,0 +1,42 @@
+module Arbre
+  module HTML
+
+    class Document < Tag
+
+      def build(*args)
+        super
+        build_head
+        build_body
+      end
+
+      def document
+        self
+      end
+
+      def tag_name
+        'html'
+      end
+
+      def doctype
+        '<!DOCTYPE html>'.html_safe
+      end
+
+      def to_html
+        doctype + super
+      end
+
+      protected
+
+      def build_head
+        @head = head do
+          meta :"http-equiv" => "Content-type", :content => "text/html; charset=utf-8"
+        end
+      end
+
+      def build_body
+        @body = body
+      end
+    end
+
+  end
+end

data/lib/active_admin/arbre/element.rb

@@ -0,0 +1,151 @@
+module Arbre
+  module HTML
+
+    class Element
+      include ::Arbre::HTML
+      include ::Arbre::HTML::BuilderMethods
+
+      attr_accessor :parent
+      attr_reader :children
+
+      def self.builder_method(method_name)
+        ::Arbre::HTML::BuilderMethods.class_eval <<-EOF, __FILE__, __LINE__
+          def #{method_name}(*args, &block)
+            insert_tag #{self.name}, *args, &block
+          end
+        EOF
+      end
+
+      def initialize(assigns = {}, helpers = nil)
+        @_assigns, @_helpers = assigns, helpers
+        @children = Collection.new
+      end
+
+      def assigns
+        @_assigns
+      end
+
+      def helpers
+        @_helpers
+      end
+
+      def tag_name
+        @tag_name ||= self.class.name.demodulize.downcase
+      end
+
+      def build(*args, &block)
+        # Render the block passing ourselves in
+        insert_text_node_if_string(block.call(self)) if block
+      end
+
+      def add_child(child)
+        return unless child
+
+        if child.is_a?(Array)
+          child.each{|item| add_child(item) }
+          return @children
+        end
+
+        # If its not an element, wrap it in a TextNode
+        unless child.is_a?(Element)
+          child = TextNode.from_string(child)
+        end
+
+        if child.respond_to?(:parent)
+          # Remove the child
+          child.parent.remove_child(child) if child.parent
+          # Set ourselves as the parent
+          child.parent = self
+        end
+
+        @children << child
+      end
+
+      def remove_child(child)
+        child.parent = nil if child.respond_to?(:parent=)
+        @children.delete(child)
+      end
+
+      def <<(child)
+        add_child(child)
+      end
+
+      def parent=(parent)
+        @parent = parent
+      end
+
+      def parent?
+        !@parent.nil?
+      end
+
+      def document
+        parent.document if parent?
+      end
+
+      def content=(contents)
+        clear_children!
+        add_child(contents)
+      end
+
+      def get_elements_by_tag_name(tag_name)
+        elements = Collection.new
+        children.each do |child|
+          elements << child if child.tag_name == tag_name
+          elements.concat(child.get_elements_by_tag_name(tag_name))
+        end
+        elements
+      end
+      alias_method :find_by_tag, :get_elements_by_tag_name
+
+      def content
+        children.to_html
+      end
+
+      def html_safe
+        to_html
+      end
+
+      def indent_level
+        parent? ? parent.indent_level + 1 : 0
+      end
+
+      def each(&block)
+        [to_html].each(&block)
+      end
+
+      def to_s
+        to_html
+      end
+
+      def to_str
+        to_s
+      end
+
+      def to_html
+        content
+      end
+
+      def +(element)
+        case element
+        when Element, Collection
+        else
+          element = TextNode.from_string(element)
+        end
+        Collection.new([self]) + element
+      end
+
+      def to_ary
+        Collection.new [self]
+      end
+      alias_method :to_a, :to_ary
+
+      private
+
+      # Resets the Elements children
+      def clear_children!
+        @children.clear
+      end
+    end
+
+  end
+end