activeadmin 0.6.0 → 0.6.1

data/lib/active_admin/resource/belongs_to.rb

@@ -9,15 +9,15 @@ module ActiveAdmin
       # 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
+      def initialize(owner, target_name, options = {})
+        @owner, @target_name, @options = owner, target_name, 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}"
+        key = @target_name.to_s.camelize
+        namespace.resources[key] or raise TargetNotFound, "Could not find #{key} in" +
+          " #{namespace.name} with #{namespace.resources.map(&:resource_name)}"
       end
 
       def namespace
@@ -28,6 +28,9 @@ module ActiveAdmin
         @options[:optional]
       end
 
+      def required?
+        !optional?
+      end
     end
   end
 end

data/lib/active_admin/resource/menu.rb

@@ -3,15 +3,15 @@ module ActiveAdmin
 
     module Menu
 
-      # Set the menu options. To not add this resource to the menu, just
-      # call #menu(false)
+      # Set the menu options.
+      # To disable this menu item, call `menu(false)` from the DSL
       def menu_item_options=(options)
         if options == false
-          @navigation_menu = false
+          @include_in_menu   = false
           @menu_item_options = {}
         else
-          self.menu_item_menu_name = options[:menu_name]
-          @menu_item_options = default_menu_options.merge(options)
+          @navigation_menu_name = options[:menu_name]
+          @menu_item_options    = default_menu_options.merge options
         end
       end
 
@@ -31,13 +31,10 @@ module ActiveAdmin
         }
       end
 
-      def navigation_menu_name=(menu_name)
-        @navigation_menu_name = menu_name
-      end
+      attr_writer :navigation_menu_name
 
       def navigation_menu_name
-        @navigation_menu_name ||= DEFAULT_MENU
-        case @navigation_menu_name
+        case @navigation_menu_name ||= DEFAULT_MENU
         when Proc
           controller.instance_eval(&@navigation_menu_name).to_sym
         else
@@ -49,27 +46,17 @@ module ActiveAdmin
         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)
+          @menu_item = menu_collection.add navigation_menu_name, menu_item_options
         end
       end
 
-      def menu_item
-        @menu_item
-      end
+      attr_reader :menu_item
 
       # Should this resource be added to the menu system?
       def include_in_menu?
-        @navigation_menu != false
+        @include_in_menu != false
       end
 
     end

data/lib/active_admin/resource/naming.rb

@@ -17,12 +17,12 @@ module ActiveAdmin
 
       # Returns the name to call this resource such as "Bank Account"
       def resource_label
-        resource_name.translate :count => 1,  :default => resource_name.gsub('::', ' ').titleize
+        resource_name.translate :count => 1, :default => resource_name.gsub('::', ' ').titleize
       end
 
       # Returns the plural version of this resource such as "Bank Accounts"
-      def plural_resource_label
-        resource_name.translate :count => 1.1, :default => resource_label.pluralize.titleize
+      def plural_resource_label(options = {})
+        resource_name.translate ({:count => 1.1, :default => resource_label.pluralize.titleize}).merge(options)
       end
     end
 

data/lib/active_admin/resource/page_presenters.rb

@@ -34,9 +34,9 @@ module ActiveAdmin
       # @param [String] type The string specified in the presenters index_name method
       # @returns [PagePresenter, nil]
       def get_page_presenter(action, type=nil)
-        
+
         if action.to_s == "index" && type && page_presenters[:index].kind_of?(Hash)
-          page_presenters[:index][type.to_sym] 
+          page_presenters[:index][type.to_sym]
         elsif action.to_s == "index" && page_presenters[:index].kind_of?(Hash)
           page_presenters[:index].default
         else

data/lib/active_admin/resource/routes.rb

@@ -1,6 +1,19 @@
 module ActiveAdmin
   class Resource
     module Routes
+      # @params params [Hash] of params: {study_id: 3}
+      # @return [String] the path to this resource collection page
+      # @example "/admin/posts"
+      def route_collection_path(params = {})
+        RouteBuilder.new(self).collection_path(params)
+      end
+      
+      # @param resource [ActiveRecord::Base] the instance we want the path of
+      # @return [String] the path to this resource collection page
+      # @example "/admin/posts/1"
+      def route_instance_path(resource)
+        RouteBuilder.new(self).instance_path(resource)
+      end
 
       # Returns the routes prefix for this config
       def route_prefix
@@ -8,39 +21,79 @@ module ActiveAdmin
       end
 
       def route_uncountable?
-        controller.resources_configuration[:self][:route_collection_name] ==
-              controller.resources_configuration[:self][:route_instance_name]
+        config = controller.resources_configuration[:self]
+
+        config[:route_collection_name] == config[: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 = [], []
+      private
 
-        route << route_prefix
+      class RouteBuilder
+        def initialize(resource)
+          @resource = resource
+        end
 
-        if belongs_to? && !belongs_to_config.optional?
-          name = belongs_to_config.target.resource_name.singular
-          route << name
-          required_params << :"#{name}_id"
+        def collection_path(params)
+          route_name = route_name(
+            resource.controller.resources_configuration[:self][:route_collection_name],
+            (resource.route_uncountable? ? 'index_path' : 'path')
+          )
+
+          routes.send(route_name, *route_collection_params(params))
         end
 
-        route << controller.resources_configuration[:self][:route_collection_name]
+        # @return [String] the path to this resource collection page
+        # @param instance [ActiveRecord::Base] the instance we want the path of
+        # @example "/admin/posts/1"
+        def instance_path(instance)
+          route_name = route_name(resource.controller.resources_configuration[:self][:route_instance_name])
 
-        route << (route_uncountable? ? 'index_path' : 'path')
+          routes.send(route_name, *route_instance_params(instance))
+        end
 
-        route_name = route.compact.join("_").to_sym
+        private
 
-        route_params = params.values_at(*required_params)
-        routes.send(route_name, *route_params)
-      end
+        attr_reader :resource
 
-      private
+        def route_name(resource_path_name, suffix = 'path')
+          route = []
 
-      def routes
-        Rails.application.routes.url_helpers
-      end
+          route << resource.route_prefix      # "admin"
+          route << belongs_to_name if nested? # "category"
+          route << resource_path_name         # "posts" or "post"
+          route << suffix                     # "path" or "index path"
 
+          route.compact.join('_').to_sym      # :admin_category_posts_path
+        end
+
+
+        # @return params to pass to instance path
+        def route_instance_params(instance)
+          if nested?
+            [instance.send(belongs_to_name).to_param, instance.to_param]
+          else
+            instance.to_param
+          end
+        end
+
+        def route_collection_params(params)
+          if nested?
+            params[:"#{belongs_to_name}_id"]
+          end
+        end
+
+        def nested?
+          resource.belongs_to? && resource.belongs_to_config.required?
+        end
+
+        def belongs_to_name
+          resource.belongs_to_config.target.resource_name.singular if nested?
+        end
+
+        def routes
+          Rails.application.routes.url_helpers
+        end
+      end
     end
   end
 end

data/lib/active_admin/resource/scope_to.rb

@@ -0,0 +1,74 @@
+module ActiveAdmin
+  class Resource
+    module ScopeTo
+
+      # Scope this controller to some object which has a relation
+      # to the resource. Can either accept a block or a symbol
+      # of a method to call.
+      #
+      # Eg:
+      #
+      #   ActiveAdmin.register Post do
+      #     scope_to :current_user
+      #   end
+      #
+      # Then every time we instantiate and object, it would call
+      #
+      #   current_user.posts.build
+      #
+      # By default Active Admin will use the resource name to build a
+      # method to call as the association. If its different, you can
+      # pass in the association_method as an option.
+      #
+      #   scope_to :current_user, :association_method => :blog_posts
+      #
+      # will result in the following
+      #
+      #   current_user.blog_posts.build
+      #
+      # To conditionally use this scope, you can use conditional procs
+      #
+      #   scope_to :current_user, :if => proc{ admin_user_signed_in? }
+      #
+      # or
+      #
+      #   scope_to :current_user, :unless => proc{ current_user.admin? }
+      #
+      def scope_to(*args, &block)
+        options = args.extract_options!
+        method = args.first
+
+        scope_to_config[:method]              = block || method
+        scope_to_config[:association_method]  = options[:association_method]
+        scope_to_config[:if]                  = options[:if]
+        scope_to_config[:unless]              = options[:unless]
+
+      end
+
+      def scope_to_association_method
+        scope_to_config[:association_method]
+      end
+
+      def scope_to_method
+        scope_to_config[:method]
+      end
+
+      def scope_to_config
+        @scope_to_config ||= {
+          :method               => nil,
+          :association_method   => nil,
+          :if                   => nil,
+          :unless               => nil
+        }
+      end
+
+      def scope_to?(context = nil)
+        return false if scope_to_method.nil?
+        return render_in_context(context, scope_to_config[:if]) unless scope_to_config[:if].nil?
+        return !render_in_context(context, scope_to_config[:unless]) unless scope_to_config[:unless].nil?
+        true
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource/scopes.rb

@@ -13,8 +13,14 @@ module ActiveAdmin
         scopes.find{|s| s.id == id }
       end
 
-      def default_scope
-        @default_scope
+      def default_scope(context = nil)
+        scopes.detect do |scope|
+          if scope.default_block.is_a?(Proc)
+            render_in_context(context, scope.default_block)
+          else
+            scope.default_block
+          end
+        end
       end
 
       # Create a new scope object for this resource.
@@ -36,8 +42,6 @@ module ActiveAdmin
           self.scopes << scope
         end
 
-        @default_scope = scope if options[:default]
-
         scope
       end
 

data/lib/active_admin/resource_collection.rb

@@ -1,87 +1,41 @@
 module ActiveAdmin
-
-  class ResourceMismatchError < StandardError; end
-
-  # Holds on to a collection of Resources. Is an Enumerable object
-  # so it has some Array like qualities.
-  #
-  # Adding a resource assumes that the object responds to #resource_name
+  # This is a container for resources, which acts much like a Hash.
+  # It's assumed that an added resource responds to `resource_name`.
   class ResourceCollection
     include Enumerable
+    extend Forwardable
+    def_delegators :@resources, :empty?, :has_key?, :keys, :values, :[]=
 
     def initialize
-      @resource_hash = {}
+      @resources = {}
     end
 
-    # Add a new resource to the collection. If the resource_name already
-    # exists, the exiting resource is returned.
-    #
-    # @param [Resource, Page] resource The resource to add to the collection
-    #
-    # @returns [Resource, Page] Either the existing resource or the new one
     def add(resource)
-      if has_key?(resource.resource_name)
-        existing_resource = find_by_key(resource.resource_name)
-        ensure_resource_classes_match!(existing_resource, resource)
-        existing_resource
-      else
-        @resource_hash[resource.resource_name] = resource
-      end
-    end
-
-    # @returns [Array] An array of all the resources
-    def resources
-      @resource_hash.values
+      @resources[resource.resource_name] ||= resource
     end
 
-    # For enumerable
+    # Changes `each` to pass in the value, instead of both the key and value.
     def each(&block)
-      @resource_hash.values.each(&block)
-    end
-
-    # @returns [Array] An array of all the keys registered in the collection
-    def keys
-      @resource_hash.keys
-    end
-
-    # @returns [Boolean] If the key has been registered in the collection
-    def has_key?(resource_name)
-      @resource_hash.has_key?(resource_name)
-    end
-
-    # Finds a resource by a given key
-    def find_by_key(resource_name)
-      @resource_hash[resource_name]
+      values.each &block
     end
 
-    # Finds a resource based on it's class. Looks up the class Heirarchy if its
-    # a subclass of an Active Record class (ie: implementes base_class)
-    def find_by_resource_class(resource_class)
-      resource_class_name = resource_class.to_s
-      match = resources_with_a_resource_class.find{|r| r.resource_class.to_s == resource_class_name }
-      return match if match
-
-      if resource_class.respond_to?(:base_class)
-        base_class_name = resource_class.base_class.to_s
-        resources_with_a_resource_class.find{|r| r.resource_class.to_s == base_class_name }
-      else
-        nil
+    # Finds a resource based on the resource name, the resource class, or the base class.
+    def [](klass)
+      if match = @resources[klass]
+        match
+      elsif match = real_resources.detect{ |r| [r.resource_name.to_s, r.resource_class.to_s].include? klass.to_s }
+        match
+      elsif klass.respond_to? :base_class
+        real_resources.detect{ |r| r.resource_class.to_s == klass.base_class.to_s }
       end
     end
 
     private
 
-    def resources_with_a_resource_class
-      select{|resource| resource.respond_to?(:resource_class) }
-    end
-
-    def ensure_resource_classes_match!(existing_resource, resource)
-      return unless existing_resource.respond_to?(:resource_class) && resource.respond_to?(:resource_class)
-
-      if existing_resource.resource_class != resource.resource_class
-        raise ActiveAdmin::ResourceMismatchError, 
-          "Tried to register #{resource.resource_class} as #{resource.resource_name} but already registered to #{existing_resource.resource_class}"
-      end
+    # REFACTOR: ResourceCollection currently stores Resource and Page objects. That doesn't
+    # make sense, because by definition a ResourceCollection is a collection of resources.
+    def real_resources
+      select{ |r| r.respond_to? :resource_class }
     end
 
   end