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

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

@@ -1,95 +0,0 @@
-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/vendor/deps/active_admin/lib/active_admin/application.rb

@@ -1,305 +0,0 @@
-require 'active_admin/router'
-require 'active_admin/helpers/settings'
-
-module ActiveAdmin
-  class Application
-    include Settings
-
-    # Adds settings to both the Application and the Namespace instance
-    # so that they can be configured independantly.
-    def self.inheritable_setting(name, default)
-      Namespace.setting name, nil
-      setting name, default
-    end
-
-    def self.deprecated_inheritable_setting(name, default)
-      Namespace.deprecated_setting name, nil
-      deprecated_setting name, default
-    end
-
-    # 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
-
-    # A hash of all the registered namespaces
-    setting :namespaces, {}
-
-    # 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 default number of resources to display on index pages
-    inheritable_setting :default_per_page, 30
-
-    # The title which gets displayed in the main layout
-    inheritable_setting :site_title, ""
-
-    # Set the site title link href (defaults to AA dashboard)
-    inheritable_setting :site_title_link, ""
-
-    # Set the site title image displayed in the main layout (has precendence over :site_title)
-    inheritable_setting :site_title_image, ""
-
-    # The view factory to use to generate all the view classes. Take
-    # a look at ActiveAdmin::ViewFactory
-    inheritable_setting :view_factory, ActiveAdmin::ViewFactory.new
-
-    # The method to call in controllers to get the current user
-    inheritable_setting :current_user_method, false
-
-    # The method to call in the controllers to ensure that there
-    # is a currently authenticated admin user
-    inheritable_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
-    inheritable_setting :logout_link_path, :destroy_admin_user_session_path
-
-    # The method to use when generating the link for user logout
-    inheritable_setting :logout_link_method, :get
-
-    # Whether the batch actions are enabled or not
-    inheritable_setting :batch_actions, false
-
-    # Whether filters are enabled
-    inheritable_setting :filters, true
-
-    # The namespace root.
-    inheritable_setting :root_to, 'dashboard#index'
-
-    # Default CSV options
-    inheritable_setting :csv_options, {}
-
-    # Default Download Links options
-    inheritable_setting :download_links, true
-
-    # The authorization adapter to use
-    inheritable_setting :authorization_adapter, ActiveAdmin::AuthorizationAdapter
-
-    # A proc to be used when a user is not authorized to view the current resource
-    inheritable_setting :on_unauthorized_access, :rescue_active_admin_access_denied
-
-    # 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 Default CSV separator will be removed in 0.6.0. Use `csv_options = { :col_sep => ',' }` instead.
-    deprecated_inheritable_setting :csv_column_separator, ','
-
-    # @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
-
-    # Event that gets triggered on load of Active Admin
-    BeforeLoadEvent = 'active_admin.application.before_load'.freeze
-    AfterLoadEvent = 'active_admin.application.after_load'.freeze
-
-    def setup!
-      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 = extract_namespace_name(options)
-      namespace = find_or_create_namespace(namespace_name)
-      namespace.register(resource, options, &block)
-    end
-
-    # Creates a namespace for the given name
-    #
-    # Yields the namespace if a block is given
-    #
-    # @returns [Namespace] the new or existing namespace
-    def find_or_create_namespace(name)
-      name ||= :root
-
-      if namespaces[name]
-        namespace = namespaces[name]
-      else
-        namespace = Namespace.new(self, name)
-        namespaces[name] = namespace
-        ActiveAdmin::Event.dispatch ActiveAdmin::Namespace::RegisterEvent, namespace
-      end
-
-      yield(namespace) if block_given?
-
-      namespace
-    end
-
-    alias_method :namespace, :find_or_create_namespace
-
-    # Register a page
-    #
-    # @param name [String] The page name
-    # @options [Hash] Accepts option :namespace.
-    # @&block The registration block.
-    #
-    def register_page(name, options = {}, &block)
-      namespace_name = extract_namespace_name(options)
-      namespace = find_or_create_namespace(namespace_name)
-      namespace.register_page(name, options, &block)
-    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! }
-      @@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?
-
-      ActiveAdmin::Event.dispatch BeforeLoadEvent, self
-
-      # 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?
-
-      # Dispatch an ActiveAdmin::Application::LoadEvent with the Application
-      ActiveAdmin::Event.dispatch AfterLoadEvent, self
-
-      @@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 and pages.
-    #
-    # eg:
-    #
-    #   ActiveAdmin.before_filter :authenticate_admin!
-    #
-    def before_filter(*args, &block)
-      BaseController.before_filter(*args, &block)
-    end
-
-    def skip_before_filter(*args, &block)
-      BaseController.skip_before_filter(*args, &block)
-    end
-
-    def after_filter(*args, &block)
-      BaseController.after_filter(*args, &block)
-    end
-
-    def around_filter(*args, &block)
-      BaseController.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', :media => 'screen'
-      register_stylesheet 'active_admin/print.css', :media => 'print'
-
-      unless ActiveAdmin.use_asset_pipeline?
-        register_javascript 'jquery.min.js'
-        register_javascript 'jquery-ui.min.js'
-        register_javascript 'jquery_ujs.js'
-      end
-
-      register_javascript 'active_admin.js'
-    end
-
-    def extract_namespace_name(options)
-      options.has_key?(:namespace) ? options[:namespace] : default_namespace
-    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.build(Rails.application, self, Rails.version).attach!
-    end
-
-    def generate_stylesheets
-      # 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/vendor/deps/active_admin/lib/active_admin/asset_registration.rb

@@ -1,47 +0,0 @@
-module ActiveAdmin
-  module AssetRegistration
-
-    # Stylesheets
-
-    def register_stylesheet(*args)
-      stylesheets << ActiveAdmin::Stylesheet.new(*args)
-    end
-
-    def stylesheets
-      @stylesheets ||= []
-    end
-
-    def clear_stylesheets!
-      @stylesheets = []
-    end
-
-
-    # Javascripts
-
-    def register_javascript(name)
-      javascripts << name
-    end
-
-    def javascripts
-      @javascripts ||= []
-    end
-
-    def clear_javascripts!
-      @javascripts = []
-    end
-
-  end
-  
-  # Wrapper class for stylesheet registration
-  class Stylesheet
-    
-    attr_reader :options, :path
-    
-    def initialize(*args)
-      @options = args.extract_options!
-      @path = args.first if args.first
-    end
-    
-  end
-  
-end

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

@@ -1,128 +0,0 @@
-module ActiveAdmin
-
-  # Default Authorization permissions for Active Admin
-  module Authorization
-    READ    = :read
-    CREATE  = :create
-    UPDATE  = :update
-    DESTROY = :destroy
-  end
-
-  Auth = Authorization
-
-
-  # Active Admin's default authorization adapter. This adapter returns true
-  # for all requests to `#authorized?`. It should be the starting point for
-  # implementing your own authorization adapter.
-  #
-  # To view an example subclass, check out `ActiveAdmin::CanCanAdapter`
-  class AuthorizationAdapter
-    attr_reader :resource, :user
-
-
-    # Initialize a new authorization adapter. This happens on each and
-    # every request to a controller.
-    #
-    # @param [ActiveAdmin::Resource, ActiveAdmin::Page] resource The resource
-    #        that the user is currently on. Note, we may be authorizing access
-    #        to a different subject, so don't rely on this other than to
-    #        pull configuration information from.
-    #
-    # @param [any] user The current user. The user is set to whatever is returned
-    #        from `#current_active_admin_user` in the controller.
-    #
-    def initialize(resource, user)
-      @resource = resource
-      @user = user
-    end
-
-    # Returns true of false depending on if the user is authorized to perform
-    # the action on the subject.
-    #
-    # @param [Symbol] action The name of the action to perform. Usually this will be
-    #        one of the `ActiveAdmin::Auth::*` symbols.
-    #
-    # @param [any] subject The subject the action is being performed on usually this
-    #        is a model object. Note, that this is NOT always in instance, it can be 
-    #        the class of the subject also. For example, Active Admin uses the class
-    #        of the resource to decide if the resource should be displayed in the 
-    #        global navigation. To deal with this nicely in a case statement, take
-    #        a look at `#normalized(klasss)`
-    #
-    # @returns [Boolean]
-    def authorized?(action, subject = nil)
-      true
-    end
-
-
-    # A hook method for authorization libraries to scope the collection. By
-    # default, we just return the same collection. The returned scope is used
-    # as the starting point for all queries to the db in the controller.
-    #
-    # @param [ActiveRecord::Relation] collection The collection the user is
-    #        attempting to view.
-    #
-    # @returns [ActiveRecord::Relation] A new collection, scoped to the 
-    #          objects that the current user has access to.
-    def scope_collection(collection)
-      collection
-    end
-
-    private
-
-    # The `#authorized?` method's subject can be set to both instances as well
-    # as classes of objects. This can make it much difficult to create simple
-    # case statements for authorization since you have to handle both the 
-    # class level match and the instance level match.
-    #
-    # For example:
-    #
-    #     class MyAuthAdapter < ActiveAdmin::AuthorizationAdapter
-    #
-    #       def authorized?(action, subject = nil)
-    #         case subject
-    #         when Post
-    #           true
-    #         when Class
-    #           if subject == Post
-    #             true
-    #           end
-    #         end
-    #       end
-    #
-    #     end
-    #
-    # To handle this, the normalized method takes care of returning a object
-    # which implements `===` to be matched in a case statement.
-    #
-    # The above now becomes:
-    #
-    #     class MyAuthAdapter < ActiveAdmin::AuthorizationAdapter
-    #
-    #       def authorized?(action, subject = nil)
-    #         case subject
-    #         when normalized(Post)
-    #           true
-    #         end
-    #       end
-    #
-    #     end
-    def normalized(klass)
-      NormalizedMatcher.new(klass)
-    end
-
-    class NormalizedMatcher
-
-      def initialize(klass)
-        @klass = klass
-      end
-
-      def ===(other)
-        @klass == other || other.is_a?(@klass)
-      end
-
-    end
-
-  end
-
-end