saulolso-activeadmin 0.2.2

data/lib/active_admin/abstract_view_factory.rb

@@ -0,0 +1,95 @@
+module ActiveAdmin
+  class AbstractViewFactory
+    @@default_views = {}
+
+    def self.register(view_hash)
+      view_hash.each do |view_key, view_class|
+        @@default_views[view_key] = view_class
+      end
+    end
+
+    def initialize
+      @views = {}
+    end
+
+    # Register a new view key with the view factory
+    #
+    # eg:
+    #   
+    #   factory = AbstractViewFactory.new
+    #   factory.register :my_view => SomeViewClass
+    #
+    # You can setup many at the same time:
+    #
+    #   factory.register  :my_view => SomeClass,
+    #                     :another_view => OtherViewClass
+    #
+    def register(view_hash)
+      view_hash.each do |view_key, view_class|
+        @views[view_key] = view_class
+      end
+    end
+
+    def default_for(key)
+      @@default_views[key.to_sym]
+    end
+
+    def has_key?(key)
+      @views.has_key?(key.to_sym) || @@default_views.has_key?(key.to_sym)
+    end
+
+    def [](key)
+      get_view_for_key(key)
+    end
+
+    def []=(key, value)
+      set_view_for_key(key, value)
+    end
+
+    # Override respond to to include keys
+    def respond_to?(method)
+      key = key_from_method_name(method)
+      if has_key?(key)
+        true
+      else
+        super
+      end
+    end
+
+    private
+
+    def method_missing(method, *args)
+      key = key_from_method_name(method)
+      if has_key?(key)
+        if method.to_s.include?('=')
+          self.class_eval <<-EOS
+            def #{key}=(value)
+              set_view_for_key(:#{key}, value)
+            end
+          EOS
+        else
+          self.class_eval <<-EOS
+            def #{key}
+              get_view_for_key(:#{key})
+            end
+          EOS
+        end
+        self.send(method, *args)
+      else
+        super
+      end
+    end
+
+    def key_from_method_name(method)
+      method.to_s.gsub('=', '').to_sym
+    end
+
+    def get_view_for_key(key)
+      @views[key.to_sym] || @@default_views[key.to_sym]
+    end
+
+    def set_view_for_key(key, view)
+      @views[key.to_sym] = view
+    end
+  end
+end

data/lib/active_admin/action_items.rb

@@ -0,0 +1,37 @@
+require 'active_admin/helpers/optional_display'
+
+module ActiveAdmin
+  module ActionItems
+    extend ActiveSupport::Concern
+
+    included do
+      self.class_inheritable_accessor :action_items
+      self.action_items = []
+    end
+
+    module ClassMethods
+      def action_item(options = {}, &block)
+        self.action_items << ActiveAdmin::ActionItems::ActionItem.new(options, &block)
+      end
+
+      def clear_action_items!
+        self.action_items = []
+      end
+
+      def action_items_for(action)
+        action_items.select{|item| item.display_on?(action) }
+      end
+    end
+
+    class ActionItem
+      include ActiveAdmin::OptionalDisplay
+
+      attr_accessor :block
+
+      def initialize(options = {}, &block)
+        @options, @block = options, block
+        normalize_display_options!
+      end
+    end
+  end
+end

data/lib/active_admin/application.rb

@@ -0,0 +1,204 @@
+require 'active_admin/router'
+
+module ActiveAdmin
+  class Application
+
+    # The default namespace to put controllers and routes inside. Set this
+    # in config/initializers/active_admin.rb using:
+    #
+    #   config.default_namespace = :super_admin
+    #
+    attr_accessor_with_default :default_namespace, :admin
+
+    # The default number of resources to display on index pages
+    attr_accessor_with_default :default_per_page, 30
+
+    # The default sort order for index pages
+    attr_accessor_with_default :default_sort_order, 'id_desc'
+
+    # A hash of all the registered namespaces
+    attr_accessor_with_default :namespaces, {}
+
+    # The title which gets displayed in the main layout
+    attr_accessor_with_default :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
+    attr_accessor_with_default :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
+    attr_accessor_with_default :view_factory, ActiveAdmin::ViewFactory.new
+
+    # DEPRECATED: This option is deprecated and will be removed. Use
+    # the #allow_comments_in option instead
+    attr_accessor :admin_notes
+
+    # The method to call in controllers to get the current user
+    attr_accessor_with_default :current_user_method, false
+
+    # The method to call in the controllers to ensure that there
+    # is a currently authenticated admin user
+    attr_accessor_with_default :authentication_method, false
+
+    # Active Admin makes educated guesses when displaying objects, this is
+    # the list of methods it tries calling in order
+    attr_accessor_with_default :display_name_methods, [ :display_name,
+                                                        :full_name,
+                                                        :name,
+                                                        :username,
+                                                        :login,
+                                                        :title,
+                                                        :email,
+                                                        :to_s ]
+
+    attr_accessor_with_default :views_path, File.expand_path('../views/templates', __FILE__)
+
+    include AssetRegistration
+
+    def initialize
+      register_default_assets
+    end
+
+    def prepare!
+      remove_active_admin_load_paths_from_rails_autoload_and_eager_load
+      append_active_admin_views_path
+      generate_stylesheets
+    end
+
+    # Registers a brand new configuration for the given resource.
+    def register(resource, options = {}, &block)
+      namespace_name = options[:namespace] == false ? :root : (options[:namespace] || default_namespace || :root)
+      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)
+      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 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 'admin/active_admin.css'
+      register_javascript 'active_admin_vendor.js'
+      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
+
+    # Add the Active Admin view path to the rails view path
+    def append_active_admin_views_path
+      ActionController::Base.append_view_path views_path
+    end
+
+    def generate_stylesheets
+      # Setup SASS
+      require 'sass/plugin' # This must be required after initialization
+      Sass::Plugin.add_template_location(File.expand_path("../active_admin/stylesheets/", __FILE__), File.join(Sass::Plugin.options[:css_location], 'admin'))
+    end
+  end
+end

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,8 @@
+module Arbre
+  class Context < Arbre::HTML::Element
+    def indent_level
+      # A context does not increment the indent_level
+      super - 1
+    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/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

data/lib/active_admin/arbre/html.rb

@@ -0,0 +1,84 @@
+module Arbre
+  module HTML
+    def current_dom_context
+      @__current_dom_element__ ||= Arbre::Context.new(assigns, helpers)
+      @__current_dom_element__.current_dom_context
+    end
+
+    def helpers
+      @_helpers
+    end
+
+    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 << TextNode.from_string(tag)
+        end
+      end
+    end
+
+  end
+end
+