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

data/vendor/deps/active_admin/lib/active_admin/resource/action_items.rb

@@ -1,93 +0,0 @@
-require 'active_admin/helpers/optional_display'
-
-module ActiveAdmin
-
-  class Resource
-    module ActionItems
-
-      # Add the default action items to a resource when it's
-      # initialized
-      def initialize(*args)
-        super
-        add_default_action_items
-      end
-
-      # @return [Array] The set of action items for this resource
-      def action_items
-        @action_items ||= []
-      end
-
-      # Add a new action item to a resource
-      #
-      # @param [Hash] options valid keys include:
-      #                 :only:  A single or array of controller actions to display
-      #                         this action item on.
-      #                 :except: A single or array of controller actions not to
-      #                          display this action item on.
-      def add_action_item(options = {}, &block)
-        self.action_items << ActiveAdmin::ActionItem.new(options, &block)
-      end
-
-      # Returns a set of action items to display for a specific controller action
-      #
-      # @param [String, Symbol] action the action to retrieve action items for
-      #
-      # @return [Array] Array of ActionItems for the controller actions
-      def action_items_for(action, render_context = nil)
-        action_items.select{|item| item.display_on?(action, render_context) }
-      end
-
-      # Clears all the existing action items for this resource
-      def clear_action_items!
-        @action_items = []
-      end
-
-      # Used by active_admin Base view
-      def action_items?
-        !!@action_items && @action_items.any?
-      end
-
-      private
-
-      # Adds the default action items to each resource
-      def add_default_action_items
-        # New Link on all actions except :new and :show
-        add_action_item :except => [:new, :show] do
-          if controller.action_methods.include?('new') && authorized?(ActiveAdmin::Auth::CREATE, active_admin_config.resource_class)
-            link_to(I18n.t('active_admin.new_model', :model => active_admin_config.resource_label), new_resource_path)
-          end
-        end
-
-        # Edit link on show
-        add_action_item :only => :show do
-          if controller.action_methods.include?('edit') && authorized?(ActiveAdmin::Auth::UPDATE, resource)
-            link_to(I18n.t('active_admin.edit_model', :model => active_admin_config.resource_label), edit_resource_path(resource))
-          end
-        end
-
-        # Destroy link on show
-        add_action_item :only => :show do
-          if controller.action_methods.include?("destroy") && authorized?(ActiveAdmin::Auth::DESTROY, resource)
-            link_to(I18n.t('active_admin.delete_model', :model => active_admin_config.resource_label),
-              resource_path(resource),
-              :method => :delete, :data => {:confirm => I18n.t('active_admin.delete_confirmation')})
-          end
-        end
-      end
-
-    end
-  end
-
-  # Model class to store the data for ActionItems
-  class ActionItem
-    include ActiveAdmin::OptionalDisplay
-
-    attr_accessor :block
-
-    def initialize(options = {}, &block)
-      @options, @block = options, block
-      normalize_display_options!
-    end
-  end
-
-end

data/vendor/deps/active_admin/lib/active_admin/resource/belongs_to.rb

@@ -1,33 +0,0 @@
-require 'active_admin/resource'
-
-module ActiveAdmin
-  class Resource
-    class BelongsTo
-
-      class TargetNotFound < StandardError; end
-
-      # The resource which initiated this relationship
-      attr_reader :owner
-
-      def initialize(owner_resource, target_name, options = {})
-        @owner, @target_name = owner_resource, target_name
-        @options = options
-      end
-
-      # Returns the target resource class or raises an exception if it doesn't exist
-      def target
-        namespace.resources.find_by_key(@target_name.to_s.camelize) or 
-          raise TargetNotFound, "Could not find registered resource #{@target_name} in #{namespace.name} with #{namespace.resources.inspect}"
-      end
-
-      def namespace
-        @owner.namespace
-      end
-
-      def optional?
-        @options[:optional]
-      end
-
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/resource/controllers.rb

@@ -1,18 +0,0 @@
-module ActiveAdmin
-  class Resource
-    module Controllers
-
-      # Returns a properly formatted controller name for this
-      # config within its namespace
-      def controller_name
-        [namespace.module_name, resource_name.plural.camelize + "Controller"].compact.join('::')
-      end
-
-      # Returns the controller for this config
-      def controller
-        @controller ||= controller_name.constantize
-      end
-
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/resource/menu.rb

@@ -1,77 +0,0 @@
-module ActiveAdmin
-  class Resource
-
-    module Menu
-
-      # Set the menu options. To not add this resource to the menu, just
-      # call #menu(false)
-      def menu_item_options=(options)
-        if options == false
-          @navigation_menu = false
-          @menu_item_options = {}
-        else
-          self.menu_item_menu_name = options[:menu_name]
-          @menu_item_options = default_menu_options.merge(options)
-        end
-      end
-
-      def menu_item_options
-        @menu_item_options ||= default_menu_options
-      end
-
-      # The default menu options to pass through to MenuItem.new
-      def default_menu_options
-        menu_resource_class = respond_to?(:resource_class) ? resource_class : self
-        the_resource = self # Make it available in the proc
-        {
-          :id     => resource_name.plural,
-          :label  => proc{ plural_resource_label },
-          :url    => proc{ the_resource.route_collection_path(params) },
-          :if     => proc { authorized?(:read, menu_resource_class)  }
-        }
-      end
-
-      def navigation_menu_name=(menu_name)
-        @navigation_menu_name = menu_name
-      end
-
-      def navigation_menu_name
-        @navigation_menu_name ||= DEFAULT_MENU
-        case @navigation_menu_name
-        when Proc
-          controller.instance_eval(&@navigation_menu_name).to_sym
-        else
-          @navigation_menu_name
-        end
-      end
-
-      def navigation_menu
-        namespace.fetch_menu(navigation_menu_name)
-      end
-
-      def menu_item_menu_name=(menu_name)
-        @menu_item_menu_name = menu_name
-      end
-
-      def menu_item_menu_name
-        @menu_item_menu_name ||= DEFAULT_MENU
-      end
-
-      def add_to_menu(menu_collection)
-        if include_in_menu?
-          @menu_item = menu_collection.add(menu_item_menu_name, menu_item_options)
-        end
-      end
-
-      def menu_item
-        @menu_item
-      end
-
-      # Should this resource be added to the menu system?
-      def include_in_menu?
-        @navigation_menu != false
-      end
-
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/resource/naming.rb

@@ -1,82 +0,0 @@
-module ActiveAdmin
-  class Resource
-
-    module Naming
-
-      # Returns a name used to uniquely identify this resource
-      # this should be an instance of ActiveAdmin:Resource::Name, which responds to
-      # #singular, #plural, #route_key, #human etc.
-      def resource_name
-        custom_name = @options[:as] && @options[:as].gsub(/\s/,'')
-        @resource_name ||= if custom_name || !resource_class.respond_to?(:model_name)
-            Resource::Name.new(resource_class, custom_name)
-          else
-            Resource::Name.new(resource_class)
-          end
-      end
-
-      # Returns the name to call this resource such as "Bank Account"
-      def resource_label
-        if @options[:as]
-          @options[:as]
-        else
-           resource_name.human(:default => resource_name.gsub('::', ' ').titleize)
-         end
-      end
-
-      # Returns the plural version of this resource such as "Bank Accounts"
-      def plural_resource_label
-        if @options[:as]
-          @options[:as].pluralize
-        else
-          resource_name.human(:count => 1.1, :default => resource_label.pluralize.titleize)
-        end
-      end
-    end
-
-    # A subclass of ActiveModel::Name which supports the different APIs presented
-    # in Rails < 3.1 and > 3.1.
-    class Name < ActiveModel::Name
-
-      def initialize(klass, name = nil)
-        if ActiveModel::Name.instance_method(:initialize).arity == 1
-          super(proxy_for_initializer(klass, name))
-        else
-          super(klass, nil, name)
-        end
-      end
-
-      def proxy_for_initializer(klass, name)
-        return klass unless name
-        return StringClassProxy.new(klass, name) if klass
-
-        StringProxy.new(name)
-      end
-
-      def route_key
-        plural
-      end
-
-      class StringProxy
-        def initialize(name)
-          @name = name
-        end
-
-        def name
-          @name
-        end
-      end
-
-      class StringClassProxy < StringProxy
-        delegate :lookup_ancestors, :i18n_scope, :to => :"@klass"
-
-        def initialize(klass, name)
-          @klass = klass || name
-          super(name)
-        end
-      end
-
-    end
-
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/resource/page_presenters.rb

@@ -1,28 +0,0 @@
-module ActiveAdmin
-  class Resource
-    module PagePresenters
-
-      # A hash of page configurations for the controller indexed by action name
-      def page_presenters
-        @page_presenters ||= {}
-      end
-
-      # Sets a page config for a given action
-      #
-      # @param [String, Symbol] action The action to store this configuration for
-      # @param [PagePresenter] page_presenter The instance of PagePresenter to store
-      def set_page_presenter(action, page_presenter)
-        page_presenters[action.to_sym] = page_presenter
-      end
-
-      # Returns a stored page config
-      #
-      # @param [Symbol, String] action The action to get the config for
-      # @returns [PagePresenter, nil]
-      def get_page_presenter(action)
-        page_presenters[action.to_sym]
-      end
-
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/resource/pagination.rb

@@ -1,19 +0,0 @@
-module ActiveAdmin
-
-  class Resource
-    module Pagination
-
-      # The default number of records to display per page
-      attr_accessor :per_page
-
-      # Enable / disable pagination (defaults to true)
-      attr_accessor :paginate
-
-      def initialize(*args)
-        super
-        @paginate = true
-        @per_page = namespace.default_per_page
-      end
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/resource/routes.rb

@@ -1,46 +0,0 @@
-module ActiveAdmin
-  class Resource
-    module Routes
-
-      # Returns the routes prefix for this config
-      def route_prefix
-        namespace.module_name.try(:underscore)
-      end
-
-      def route_uncountable?
-        controller.resources_configuration[:self][:route_collection_name] ==
-              controller.resources_configuration[:self][:route_instance_name]
-      end
-
-      # Returns a symbol for the route to use to get to the
-      # collection of this resource
-      def route_collection_path(params = {})
-        route, required_params = [], []
-
-        route << route_prefix
-
-        if belongs_to? && !belongs_to_config.optional?
-          name = belongs_to_config.target.resource_name.singular
-          route << name
-          required_params << :"#{name}_id"
-        end
-
-        route << controller.resources_configuration[:self][:route_collection_name]
-
-        route << (route_uncountable? ? 'index_path' : 'path')
-
-        route_name = route.compact.join("_").to_sym
-
-        route_params = params.values_at(*required_params)
-        routes.send(route_name, *route_params)
-      end
-
-      private
-
-      def routes
-        Rails.application.routes.url_helpers
-      end
-
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/resource/scopes.rb

@@ -1,46 +0,0 @@
-module ActiveAdmin
-  class Resource
-    module Scopes
-
-      # Return an array of scopes for this resource
-      def scopes
-        @scopes ||= []
-      end
-
-      # Returns a scope for this object by its identifier
-      def get_scope_by_id(id)
-        id = id.to_s
-        scopes.find{|s| s.id == id }
-      end
-
-      def default_scope
-        @default_scope
-      end
-
-      # Create a new scope object for this resource.
-      # If you want to internationalize the scope name, you can add
-      # to your i18n files a key like "active_admin.scopes.scope_method".
-      def scope(*args, &block)
-        options = args.extract_options!
-        title = args[0] rescue nil
-        method = args[1] rescue nil
-
-        scope = ActiveAdmin::Scope.new(title, method, options, &block)
-
-        # Finds and replaces a scope by the same name if it already exists
-        existing_scope_index = scopes.index{|existing_scope| existing_scope.id == scope.id }
-        if existing_scope_index
-          scopes.delete_at(existing_scope_index)
-          scopes.insert(existing_scope_index, scope)
-        else
-          self.scopes << scope
-        end
-
-        @default_scope = scope if options[:default]
-
-        scope
-      end
-
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/resource/sidebars.rb

@@ -1,27 +0,0 @@
-require 'active_admin/helpers/optional_display'
-
-module ActiveAdmin
-
-  class Resource
-    module Sidebars
-
-      def sidebar_sections
-        @sidebar_sections ||= []
-      end
-
-      def clear_sidebar_sections!
-        @sidebar_sections = []
-      end
-
-      def sidebar_sections_for(action, render_context = nil)
-        sidebar_sections.select{|section| section.display_on?(action, render_context) }
-      end
-
-      def sidebar_sections?
-        !!@sidebar_sections && @sidebar_sections.any?
-      end
-
-    end
-  end
-
-end

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

@@ -1,170 +0,0 @@
-require 'active_admin/resource/action_items'
-require 'active_admin/resource/controllers'
-require 'active_admin/resource/menu'
-require 'active_admin/resource/page_presenters'
-require 'active_admin/resource/pagination'
-require 'active_admin/resource/routes'
-require 'active_admin/resource/naming'
-require 'active_admin/resource/scopes'
-require 'active_admin/resource/sidebars'
-require 'active_admin/resource/belongs_to'
-
-module ActiveAdmin
-
-  # Resource is the primary data storage for resource configuration in Active Admin
-  #
-  # When you register a resource (ActiveAdmin.register Post) you are actually creating
-  # a new Resource instance within the given Namespace.
-  #
-  # The instance of the current resource is available in ResourceController and views
-  # by calling the #active_admin_config method.
-  #
-  class Resource
-
-    # Event dispatched when a new resource is registered
-    RegisterEvent = 'active_admin.resource.register'.freeze
-
-    # The namespace this config belongs to
-    attr_reader :namespace
-
-    # The name of the resource class
-    attr_reader :resource_class_name
-
-    # An array of member actions defined for this resource
-    attr_reader :member_actions
-
-    # An array of collection actions defined for this resource
-    attr_reader :collection_actions
-
-    # The default sort order to use in the controller
-    attr_accessor :sort_order
-
-    # Scope this resource to an association in the controller
-    attr_accessor :scope_to
-
-    # If we're scoping resources, use this method on the parent to return the collection
-    attr_accessor :scope_to_association_method
-
-    # Set the configuration for the CSV
-    attr_writer :csv_builder
-    
-    # Set breadcrumb builder
-    attr_accessor :breadcrumb
-
-    # Store a reference to the DSL so that we can dereference it during garbage collection.
-    attr_accessor :dsl
-
-    # The string identifying a class to decorate our resource with for the view.
-    # nil to not decorate.
-    attr_accessor :decorator_class_name
-
-    module Base
-      def initialize(namespace, resource_class, options = {})
-        @namespace = namespace
-        @resource_class_name = "::#{resource_class.name}"
-        @options = default_options.merge(options)
-        @sort_order = @options[:sort_order]
-        @member_actions, @collection_actions = [], []
-      end
-    end
-
-    include Base
-    include ActionItems
-    include Authorization
-    include Controllers
-    include Menu
-    include Naming
-    include PagePresenters
-    include Pagination
-    include Scopes
-    include Sidebars
-    include Menu
-    include Routes
-
-    # The class this resource wraps. If you register the Post model, Resource#resource_class
-    # will point to the Post class
-    def resource_class
-      ActiveSupport::Dependencies.constantize(resource_class_name)
-    end
-
-    def decorator_class
-      ActiveSupport::Dependencies.constantize(decorator_class_name) if decorator_class_name
-    end
-
-    def resource_table_name
-      resource_class.quoted_table_name
-    end
-
-    def resource_column_names
-      resource_class.column_names
-    end
-
-    def resource_quoted_column_name(column)
-      resource_class.connection.quote_column_name(column)
-    end
-
-    # Returns the named route for an instance of this resource
-    def route_instance_path
-      [route_prefix, controller.resources_configuration[:self][:route_instance_name], 'path'].compact.join('_').to_sym
-    end
-
-    # Clears all the member actions this resource knows about
-    def clear_member_actions!
-      @member_actions = []
-    end
-
-    def clear_collection_actions!
-      @collection_actions = []
-    end
-
-    # Return only defined resource actions
-    def defined_actions
-      controller.instance_methods.map { |m| m.to_sym } & ResourceController::ACTIVE_ADMIN_ACTIONS
-    end
-
-    # Are admin notes turned on for this resource
-    def admin_notes?
-      admin_notes.nil? ? ActiveAdmin.admin_notes : admin_notes
-    end
-
-    def belongs_to(target, options = {})
-      @belongs_to = Resource::BelongsTo.new(self, target, options)
-      self.menu_item_menu_name = target unless @belongs_to.optional?
-      controller.belongs_to(target, options.dup)
-    end
-
-    def belongs_to_config
-      @belongs_to
-    end
-
-    # Do we belong to another resource
-    def belongs_to?
-      !belongs_to_config.nil?
-    end
-
-    # The csv builder for this resource
-    def csv_builder
-      @csv_builder || default_csv_builder
-    end
-
-    # @deprecated
-    def resource
-      resource_class
-    end
-    ActiveAdmin::Deprecation.deprecate self, :resource,
-      "ActiveAdmin::Resource#resource is deprecated. Please use #resource_class instead."
-
-    private
-
-    def default_options
-      {
-        :sort_order => "#{resource_class.respond_to?(:primary_key) ? resource_class.primary_key : 'id'}_desc"
-      }
-    end
-
-    def default_csv_builder
-      @default_csv_builder ||= CSVBuilder.default_for_resource(resource_class)
-    end
-
-  end # class Resource
-end # module ActiveAdmin