lalala 4.0.0.dev.141 → 4.0.0.dev.144

data/vendor/deps/active_admin/lib/active_admin/menu_item.rb

@@ -1,85 +0,0 @@
-module ActiveAdmin
-
-  class MenuItem
-    include Menu::MenuNode
-
-    attr_accessor :id, :label, :url, :priority, :display_if_block, :html_options
-    attr_reader :parent
-
-    # Build a new menu item
-    #
-    # @param [Hash] options The options for the menu
-    #
-    # @option options [String, Proc] :label
-    #         The label to display for this menu item. It can either be a String or a 
-    #         Proc. If the option is Proc, it is called each time the label is requested.
-    #
-    # @option options [String] :id
-    #         A custom id to reference this menu item with. If empty an id is automatically 
-    #         generated for you.
-    #
-    # @option options [String, Symbol] :url
-    #         A string or symbol representing the url for this item. If it's a symbol, the
-    #         view will automatically call the method for you.
-    #
-    # @option options [Integer] :priority
-    #         MenuItems are sorted by priority then by label. The lower the priority, the 
-    #         earlier in the menu the item will be displayed.
-    #         Default: 10
-    #
-    # @option options [Proc] :if
-    #         A block for the view to call to decide if this menu item should be displayed.
-    #         The block should return true of false
-    #
-    # @option options [Hash] :html_options
-    #         A hash of options to pass to `link_to` when rendering the item
-    #
-    # @param [ActiveAdmin::MenuItem] parent The parent menu item of this item
-    #
-    def initialize(options = {}, parent = nil)
-      @label        = options[:label]
-      @id           = normalize_id(options[:id] || label)
-      @url          = options[:url] || "#"
-      @priority     = options[:priority] || 10
-      @html_options = options[:html_options] || {}
-      @parent       = parent
-
-      @display_if_block = options[:if]
-
-      yield(self) if block_given? # Builder style syntax
-    end
-
-    def parent?
-      !parent.nil?
-    end
-
-    def dom_id
-      case id
-      when Proc
-        id
-      else
-        id.to_s.gsub( " ", '_' ).gsub( /[^a-z0-9_]/, '' )
-      end
-    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
-
-    def <=>(other)
-      result = priority <=> other.priority
-      result = label.to_s <=> other.label.to_s 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/vendor/deps/active_admin/lib/active_admin/namespace.rb

@@ -1,253 +0,0 @@
-require 'active_admin/helpers/settings'
-require 'active_admin/resource_collection'
-
-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
-    include Settings
-
-    RegisterEvent = 'active_admin.namespace.register'.freeze
-
-    attr_reader :application, :resources, :name, :menus
-
-    def initialize(application, name)
-      @application = application
-      @name = name.to_s.underscore.to_sym
-      @resources = ResourceCollection.new
-      register_module unless root?
-      generate_dashboard_controller
-      build_menu_collection
-    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_class, options = {}, &block)
-      config = find_or_build_resource(resource_class, options)
-
-      # Register the resource
-      register_resource_controller(config)
-      parse_registration_block(config, &block) if block_given?
-      reset_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 register_page(name, options = {}, &block)
-      config = build_page(name, options)
-
-      # Register the resource
-      register_page_controller(config)
-      parse_page_registration_block(config, &block) if block_given?
-      reset_menu!
-
-      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!
-      reset_menu!
-    end
-
-    # Returns the first registered ActiveAdmin::Resource instance for a given class
-    def resource_for(klass)
-      resources.find_by_resource_class(klass)
-    end
-
-    # Override from ActiveAdmin::Settings to inherit default attributes
-    # from the application
-    def read_default_setting(name)
-      application.send(name)
-    end
-
-    def fetch_menu(name)
-      @menus.fetch(name)
-    end
-
-    def reset_menu!
-      @menus.clear!
-    end
-
-    # Add a callback to be ran when we build the menu
-    #
-    # @param [Symbol] name The name of the menu. Default: :default
-    # @param [Proc] block The block to be ran when the menu is built
-    #
-    # @returns [void]
-    def build_menu(name = DEFAULT_MENU, &block)
-      @menus.before_build do |menus|
-        menus.menu name do |menu|
-          block.call(menu)
-        end
-      end
-    end
-
-    # Add the default logout button to the menu, using the ActiveAdmin configuration settings
-    #
-    # @param [ActiveAdmin::MenuItem] menu The menu to add the logout link to
-    # @param [Fixnum] priority Override the default priority of 100 to position the logout button where you want
-    # @param [Hash] html_options An options hash to pass along to link_to
-    #
-    # @returns [void]
-    def add_logout_button_to_menu(menu, priority=100, html_options={})
-      if logout_link_path
-        logout_method = logout_link_method || :get
-        menu.add :id           => 'logout',
-                 :priority     => priority,
-                 :label        => proc{ I18n.t('active_admin.logout') },
-                 :html_options => html_options.reverse_merge(:method => logout_method),
-                 :url          => proc{ render_or_call_method_or_proc_on self, active_admin_namespace.logout_link_path },
-                 :if           => proc{ current_active_admin_user? }
-      end
-    end
-
-    protected
-
-    def build_menu_collection
-      @menus = MenuCollection.new
-
-      @menus.on_build do |menus|
-        # Support for deprecated dashboards...
-        Dashboards.add_to_menu(self, menus.menu(DEFAULT_MENU))
-
-        # Build the default utility navigation
-        build_default_utility_nav
-
-        resources.each do |resource|
-          resource.add_to_menu(@menus)
-        end
-      end
-    end
-
-    # Builds the default utility navigation in top right header with current user & logout button
-    def build_default_utility_nav
-      return if @menus.exists? :utility_navigation
-      @menus.menu :utility_navigation do |menu|
-        menu.add  :label  => proc{ display_name current_active_admin_user },
-                  :url    => '#',
-                  :id     => 'current_user',
-                  :if     => proc{ current_active_admin_user? }
-                  
-        add_logout_button_to_menu menu
-      end
-    end
-
-    # Either returns an existing Resource instance or builds a new
-    # one for the resource and options
-    def find_or_build_resource(resource_class, options)
-      resources.add Resource.new(self, resource_class, options)
-    end
-
-    def build_page(name, options)
-      resources.add Page.new(self, name, options)
-    end
-
-    def register_page_controller(config)
-      eval "class ::#{config.controller_name} < ActiveAdmin::PageController; end"
-      config.controller.active_admin_config = config
-    end
-
-    def unload_resources!
-      resources.each do |resource|
-        parent = (module_name || 'Object').constantize
-        const_name = resource.controller_name.split('::').last
-        # Remove the const if its been defined
-        parent.send(:remove_const, const_name) if parent.const_defined?(const_name)
-
-        # Remove circular references
-        resource.controller.active_admin_config = nil
-        if resource.is_a?(Resource) && resource.dsl
-          resource.dsl.run_registration_block { @config = nil }
-        end
-      end
-      @resources = ResourceCollection.new
-    end
-
-    def unload_dashboard!
-      # TODO: Only clear out my sections
-      Dashboards.clear_all_sections!
-    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 parse_registration_block(config, &block)
-      config.dsl = ResourceDSL.new(config)
-      config.dsl.run_registration_block(&block)
-    end
-
-    def parse_page_registration_block(config, &block)
-      PageDSL.new(config).run_registration_block(&block)
-    end
-
-    # Creates a dashboard controller for this config
-    def generate_dashboard_controller
-      return unless ActiveAdmin::Dashboards.built?
-
-      eval "class ::#{dashboard_controller_name} < ActiveAdmin::PageController
-              include ActiveAdmin::Dashboards::DashboardController
-            end"
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/page.rb

@@ -1,88 +0,0 @@
-module ActiveAdmin
-  # Page is the primary data storage for page configuration in Active Admin
-  #
-  # When you register a page (ActiveAdmin.page "Status") you are actually creating
-  # a new Page instance within the given Namespace.
-  #
-  # The instance of the current page is available in PageController and views
-  # by calling the #active_admin_config method.
-  #
-  class Page
-
-    # The namespace this config belongs to
-    attr_reader :namespace
-
-    # The name of the page
-    attr_reader :name
-
-    # An array of custom actions defined for this page
-    attr_reader :page_actions
-    
-    # Set breadcrumb builder
-    attr_accessor :breadcrumb
-
-    module Base
-      def initialize(namespace, name, options)
-        @namespace = namespace
-        @name = name
-        @options = options
-        @page_actions = []
-      end
-    end
-
-    include Base
-    include Resource::Controllers
-    include Resource::PagePresenters
-    include Resource::Sidebars
-    include Resource::ActionItems
-    include Resource::Menu
-    include Resource::Naming
-    include Resource::Routes
-
-    # label is singular
-    def plural_resource_label
-      name
-    end
-
-    def resource_name
-      @resource_name ||= Resource::Name.new(nil, name)
-    end
-
-    def underscored_resource_name
-      resource_name.parameterize.underscore
-    end
-
-    def camelized_resource_name
-      underscored_resource_name.camelize
-    end
-
-    def default_menu_options
-      super.merge(:id => resource_name)
-    end
-
-    def controller_name
-      [namespace.module_name, camelized_resource_name + "Controller"].compact.join('::')
-    end
-
-    # Override from `ActiveAdmin::Resource::Controllers`
-    def route_uncountable?
-      false
-    end
-
-    def belongs_to?
-      false
-    end
-
-    def add_default_action_items
-    end
-
-    def add_default_sidebar_sections
-    end
-    
-    # Clears all the custom actions this page knows about
-    def clear_page_actions!
-      @page_actions = []
-    end
-
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/page_controller.rb

@@ -1,29 +0,0 @@
-module ActiveAdmin
-
-  # All Pages controllers inherit from this controller.
-  class PageController < BaseController
-
-    # Active admin actions don't require layout.  All custom actions do.
-    ACTIVE_ADMIN_ACTIONS = [:index]
-
-    actions :index
-
-    before_filter :authorize_access!
-
-    def index(options={}, &block)
-      render "active_admin/page/index"
-    end
-
-    def clear_page_actions!
-      active_admin_config.clear_page_actions!
-    end
-
-    private
-
-    def authorize_access!
-      permission = action_to_permission(params[:action])
-      authorize! permission, active_admin_config
-    end
-
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/page_dsl.rb

@@ -1,28 +0,0 @@
-module ActiveAdmin
-  # This is the class where all the register_page blocks are instance eval'd
-  class PageDSL < DSL
-
-    # Page content.
-    #
-    # The block should define the view using Arbre.
-    #
-    # Example:
-    #
-    #   ActiveAdmin.register "My Page" do
-    #     content do
-    #       para "Sweet!"
-    #     end
-    #   end
-    #
-    def content(options = {}, &block)
-      config.set_page_presenter :index, ActiveAdmin::PagePresenter.new(options, &block)
-    end
-    
-    def page_action(name, options = {}, &block)
-      config.page_actions << ControllerAction.new(name, options)
-      controller do
-        define_method(name, &block || Proc.new{})
-      end
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/page_presenter.rb

@@ -1,32 +0,0 @@
-module ActiveAdmin
-
-  # A simple object that gets used to present different aspects of views
-  #
-  # Initialize with a set of options and a block. The options become
-  # available using hash style syntax.
-  #
-  # Usage:
-  #
-  #     presenter = PagePresenter.new :as => :table do
-  #       # some awesome stuff
-  #     end
-  #
-  #     presenter[:as]    #=> :table
-  #     presenter.block   #=> The block passed in to new
-  #
-  class PagePresenter
-
-    attr_reader :block, :options
-
-    delegate :has_key?, :to => :options
-
-    def initialize(options = {}, &block)
-      @options, @block = options, block
-    end
-
-    def [](key)
-      @options[key]
-    end
-
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/reloader.rb

@@ -1,130 +0,0 @@
-module ActiveAdmin
-
-  module Reloader
-
-    # Builds the proper Reloader implementation class given the
-    # current version of Rails.
-    #
-    # @param [Rails::Application] rails_app The current rails application
-    # @param [ActiveAdmin::Application] active_admin_app The current Active Admin app
-    # @param [String] rails_version The version of Rails we're using. 
-    #
-    # @returns A concrete subclass of AbstractReloader
-    def self.build(rails_app, active_admin_app, rails_version)
-      reloader_class = rails_version[0..2] == "3.2" ? Rails32Reloader : RailsLessThan31Reloader
-      reloader_class.new(rails_app, active_admin_app, rails_version)
-    end
-
-    class AbstractReloader
-
-      attr_reader :active_admin_app, :rails_app, :rails_version
-
-      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
-      end
-
-      def attach!
-        raise "Please implement #{self.class}#attach!"
-      end
-
-      def reload!
-        active_admin_app.unload!
-        rails_app.reload_routes!
-      end
-
-      def major_rails_version
-        @rails_version[0..2]
-      end
-
-    end
-
-    # Reloads the application when using Rails 3.2
-    #
-    # 3.2 introduced a to_prepare block that only gets called when
-    # files have actually changed. ActiveAdmin had built this functionality
-    # in to speed up applications. So in Rails >= 3.2, we can now piggy
-    # back off the existing reloader. This simplifies our duties... which is
-    # nice.
-    class Rails32Reloader < AbstractReloader
-
-      # Attach to Rails and perform the reload on each request.
-      def attach!
-        active_admin_app.load_paths.each do |path|
-          rails_app.config.watchable_dirs[path] = [:rb]
-        end
-
-        reloader = self
-
-        ActionDispatch::Reloader.to_prepare do
-          reloader.reload!
-        end
-      end
-
-    end
-
-    # Deals with reloading Active Admin on each request in 
-    # development and once in production in Rails < 3.2.
-    class RailsLessThan31Reloader < AbstractReloader
-
-      class FileUpdateChecker < ::ActiveSupport::FileUpdateChecker
-        def paths
-          # hack to support both Rails 3.1 and 3.2
-          @files || @paths
-        end
-
-        # 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
-
-        def execute_if_updated
-          super
-        end
-      end
-
-      attr_reader :file_update_checker
-
-      def initialize(rails_app, active_admin_app, rails_version)
-        super
-        @file_update_checker = FileUpdateChecker.new(watched_paths) do
-          reload!
-        end
-      end
-
-      def reload!
-        super
-        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 major_rails_version == "3.1"
-          ActionDispatch::Reloader
-        else
-          ActionDispatch::Callbacks
-        end
-      end
-
-    end
-
-  end
-end