andrewroth_activeadmin 0.3.4

data/lib/active_admin/application.rb

@@ -0,0 +1,231 @@
+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, ""
+    
+    # Set the site title link href (defaults to AA dashboard)
+    setting :site_title_link, ""
+
+    # 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, :get
+
+    # 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.application, self, 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/builder"
+require "active_admin/arbre/core_extensions"
+require "active_admin/arbre/context"
+require "active_admin/arbre/html/element"
+require "active_admin/arbre/html/attributes"
+require "active_admin/arbre/html/collection"
+require "active_admin/arbre/html/class_list"
+require "active_admin/arbre/html/tag"
+require "active_admin/arbre/html/document"
+require "active_admin/arbre/html/html5_elements"
+require "active_admin/arbre/html/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::Builder; @_helpers = self; @__current_dom_element__ = Arbre::Context.new(assigns, self); begin; #{template.source}; end; current_dom_context"
+}

data/lib/active_admin/arbre/builder.rb

@@ -0,0 +1,111 @@
+module Arbre
+
+  # Include this module in any context to start building html.
+  #
+  #   assigns = {}
+  #   include Arbre::Builder
+  #   span("foo").to_s #=> "<span>foo</span>
+  #
+  # When you include the module, you are required to setup 2 variables:
+  #
+  # * assigns: This is a hash that includes local variables
+  # * helpers: This is an object that provides helper methods to all
+  #              objects within the context.
+  module Builder
+
+    # Retrieve the current DOM context.
+    #
+    # If no `@__current_dom_element__` has been set, this method will
+    # setup the initial context.
+    #
+    # @return [Arbre::Element] the current element that is in context
+    def current_dom_context
+      @__current_dom_element__ ||= Arbre::Context.new(assigns, helpers)
+      @__current_dom_element__.current_dom_context
+    end
+
+    def helpers
+      @_helpers
+    end
+
+    # Implements the method lookup chain. When you call a method that
+    # doesn't exist, we:
+    #
+    #  1. Try to call the method on the current DOM context
+    #  2. Return an assigned variable of the same name
+    #  3. Call the method on the helper object
+    #  4. Call super
+    #
+    def method_missing(name, *args, &block)
+      if current_dom_context.respond_to?(name)
+        current_dom_context.send name, *args, &block
+      elsif assigns && assigns.has_key?(name)
+        assigns[name]
+      elsif helpers.respond_to?(name)
+        helpers.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    module BuilderMethods
+      def build_tag(klass, *args, &block)
+        tag = klass.new(assigns, helpers)
+
+        # If you passed in a block and want the object
+        if block_given? && block.arity > 0
+          # Set out context to the tag, and pass responsibility to the tag
+          with_current_dom_context tag do
+            tag.build(*args, &block)
+          end
+        else
+          # Build the tag
+          tag.build(*args)
+
+          # Render the blocks contents
+          if block_given?
+            with_current_dom_context tag do
+              insert_text_node_if_string(yield)
+            end
+          end
+        end
+
+        tag
+      end
+
+      def insert_tag(klass, *args, &block)
+        tag = build_tag(klass, *args, &block)
+        current_dom_context.add_child(tag)
+        tag
+      end
+
+      def current_dom_context
+        @__current_dom_element_buffer__ ||= [self]
+        current_element = @__current_dom_element_buffer__.last
+        if current_element == self
+          self
+        else
+          current_element.current_dom_context
+        end
+      end
+
+      def with_current_dom_context(tag)
+        raise ArgumentError, "Can't be in the context of nil. #{@__current_dom_element_buffer__.inspect}" unless tag
+        current_dom_context # Ensure a context is setup
+        @__current_dom_element_buffer__.push tag
+        yield
+        @__current_dom_element_buffer__.pop
+      end
+      alias_method :within, :with_current_dom_context
+
+      # Inserts a text node if the tag is a string
+      def insert_text_node_if_string(tag)
+        if tag.is_a?(String)
+          current_dom_context << Arbre::HTML::TextNode.from_string(tag)
+        end
+      end
+    end
+
+  end
+end
+

data/lib/active_admin/arbre/context.rb

@@ -0,0 +1,45 @@
+require 'active_admin/arbre/html/element'
+
+module Arbre
+  class Context < Arbre::HTML::Element
+    def indent_level
+      # A context does not increment the indent_level
+      super - 1
+    end
+
+    def bytesize
+      cached_html.bytesize
+    end
+    alias :length :bytesize
+
+    def respond_to?(method)
+      super || cached_html.respond_to?(method)
+    end
+
+    # Webservers treat Arbre::Context as a string. We override
+    # method_missing to delegate to the string representation
+    # of the html.
+    def method_missing(method, *args, &block)
+      if cached_html.respond_to? method
+        cached_html.send method, *args, &block
+      else
+        super
+      end
+    end
+
+    private
+
+    # Caches the rendered HTML so that we don't re-render just to
+    # get the content lenght or to delegate a method to the HTML
+    def cached_html
+      if defined?(@cached_html)
+        @cached_html
+      else
+        html = to_html
+        @cached_html = html if html.length > 0
+        html
+      end
+    end
+
+  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/html/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/html/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