spree_core 1.3.5 → 2.0.0.rc1

data/lib/spree/core/permalinks.rb

@@ -14,6 +14,8 @@ module Spree
           options[:field] ||= :permalink
           self.permalink_options = options
 
+          validates permalink_options[:field], :uniqueness => true
+
           if self.table_exists? && self.column_names.include?(permalink_options[:field].to_s)
             before_validation(:on => :create) { save_permalink }
           end
@@ -31,27 +33,33 @@ module Spree
           permalink_options[:field]
         end
 
+        def permalink_prefix
+          permalink_options[:prefix] || ""
+        end
+
         def permalink_order
           order = permalink_options[:order]
           "#{order} ASC," if order
         end
       end
 
+      def generate_permalink
+        "#{self.class.permalink_prefix}#{Array.new(9){rand(9)}.join}"
+      end
+
       def save_permalink(permalink_value=self.to_param)
-        self.with_lock do
-          permalink_value ||= generate_permalink
-
-          field = self.class.permalink_field
-            # Do other links exist with this permalink?
-            other = self.class.select(field).where("#{self.class.table_name}.#{field} LIKE ?", "#{permalink_value}%")
-            if other.any?
-              # Find the existing permalink with the highest number, and increment that number.
-              # (If none of the existing permalinks have a number, this will evaluate to 1.)
-              number = other.map { |o| o.send(field)[/-(\d+)$/, 1].to_i }.max + 1
-              permalink_value += "-#{number.to_s}"
-            end
-          write_attribute(field, permalink_value)
-        end
+        permalink_value ||= generate_permalink
+
+        field = self.class.permalink_field
+          # Do other links exist with this permalink?
+          other = self.class.where("#{self.class.table_name}.#{field} LIKE ?", "#{permalink_value}%")
+          if other.any?
+            # Find the existing permalink with the highest number, and increment that number.
+            # (If none of the existing permalinks have a number, this will evaluate to 1.)
+            number = other.map { |o| o.send(field)[/-(\d+)$/, 1].to_i }.max + 1
+            permalink_value += "-#{number.to_s}"
+          end
+        write_attribute(field, permalink_value)
       end
     end
   end

data/lib/spree/core/product_duplicator.rb

@@ -0,0 +1,61 @@
+module Spree
+  class ProductDuplicator
+    attr_accessor :product
+
+    def initialize(product)
+      @product = product
+    end
+
+    def duplicate
+      new_product = duplicate_product
+
+      # don't dup the actual variants, just the characterising types
+      new_product.option_types = product.option_types if product.has_variants?
+
+      # allow site to do some customization
+      new_product.send(:duplicate_extra, product) if new_product.respond_to?(:duplicate_extra)
+      new_product.save!
+      new_product
+    end
+
+    protected
+
+    def duplicate_product
+      product.dup.tap do |new_product|
+        new_product.name = "COPY OF #{product.name}"
+        new_product.taxons = product.taxons
+        new_product.created_at = nil
+        new_product.deleted_at = nil
+        new_product.updated_at = nil
+        new_product.product_properties = reset_properties
+        new_product.master = duplicate_master
+      end
+    end
+
+    def duplicate_master
+      master = product.master
+      master.dup.tap do |new_master|
+        new_master.sku = "COPY OF #{master.sku}"
+        new_master.deleted_at = nil
+        new_master.images = master.images.map { |image| duplicate_image image }
+        new_master.price = master.price
+        new_master.currency = master.currency
+      end
+    end
+
+    def duplicate_image(image)
+      new_image = image.dup
+      new_image.assign_attributes(:attachment => image.attachment.clone)
+      new_image
+    end
+
+    def reset_properties
+      product.product_properties.map do |prop|
+        prop.dup.tap do |new_prop|
+          new_prop.created_at = nil
+          new_prop.updated_at = nil
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/product_filters.rb

@@ -0,0 +1,199 @@
+module Spree
+  module Core
+    # THIS FILE SHOULD BE OVER-RIDDEN IN YOUR SITE EXTENSION!
+    #   the exact code probably won't be useful, though you're welcome to modify and reuse
+    #   the current contents are mainly for testing and documentation
+
+    # To override this file...
+    #   1) Make a copy of it in your sites local /lib/spree folder
+    #   2) Add it to the config load path, or require it in an initializer, e.g...
+    #
+    #      # config/initializers/spree.rb
+    #      require 'spree/product_filters'
+    #
+
+    # set up some basic filters for use with products
+    #
+    # Each filter has two parts
+    #  * a parametrized named scope which expects a list of labels
+    #  * an object which describes/defines the filter
+    #
+    # The filter description has three components
+    #  * a name, for displaying on pages
+    #  * a named scope which will 'execute' the filter
+    #  * a mapping of presentation labels to the relevant condition (in the context of the named scope)
+    #  * an optional list of labels and values (for use with object selection - see taxons examples below)
+    #
+    # The named scopes here have a suffix '_any', following Ransack's convention for a
+    # scope which returns results which match any of the inputs. This is purely a convention,
+    # but might be a useful reminder.
+    #
+    # When creating a form, the name of the checkbox group for a filter F should be
+    # the name of F's scope with [] appended, eg "price_range_any[]", and for
+    # each label you should have a checkbox with the label as its value. On submission,
+    # Rails will send the action a hash containing (among other things) an array named
+    # after the scope whose values are the active labels.
+    #
+    # Ransack will then convert this array to a call to the named scope with the array
+    # contents, and the named scope will build a query with the disjunction of the conditions
+    # relating to the labels, all relative to the scope's context.
+    #
+    # The details of how/when filters are used is a detail for specific models (eg products
+    # or taxons), eg see the taxon model/controller.
+
+    # See specific filters below for concrete examples.
+
+    # This module is included by Taxon. In development mode that inclusion does not
+    # happen until Taxon class is loaded. Ensure that Taxon class is loaded before
+    # you try something like Product.price_range_any
+    module ProductFilters
+      # Example: filtering by price
+      #   The named scope just maps incoming labels onto their conditions, and builds the conjunction
+      #   'price' is in the base scope's context (ie, "select foo from products where ...") so
+      #     we can access the field right away
+      #   The filter identifies which scope to use, then sets the conditions for each price range
+      #
+      # If user checks off three different price ranges then the argument passed to
+      # below scope would be something like ["$10 - $15", "$15 - $18", "$18 - $20"]
+      #
+      Spree::Product.add_search_scope :price_range_any do |*opts|
+        conds = opts.map {|o| Spree::Core::ProductFilters.price_filter[:conds][o]}.reject {|c| c.nil?}
+        scope = conds.shift
+        conds.each do |new_scope|
+          scope = scope.or(new_scope)
+        end
+        Spree::Product.joins(:master => :default_price).where(scope)
+      end
+
+      def ProductFilters.format_price(amount)
+        Spree::Money.new(amount)
+      end
+
+      def ProductFilters.price_filter
+        v = Spree::Price.arel_table
+        conds = [ [ Spree.t(:under_price, :price => format_price(10))   , v[:amount].lteq(10)],
+                  [ "#{format_price(10)} - #{format_price(15)}"        , v[:amount].in(10..15)],
+                  [ "#{format_price(15)} - #{format_price(18)}"        , v[:amount].in(15..18)],
+                  [ "#{format_price(18)} - #{format_price(20)}"        , v[:amount].in(18..20)],
+                  [ Spree.t(:or_over_price, :price => format_price(20)) , v[:amount].gteq(20)]]
+        { :name   => Spree.t(:price_range),
+          :scope  => :price_range_any,
+          :conds  => Hash[*conds.flatten],
+          :labels => conds.map {|k,v| [k,k]}
+        }
+      end
+
+
+      # Example: filtering by possible brands
+      #
+      # First, we define the scope. Two interesting points here: (a) we run our conditions
+      #   in the scope where the info for the 'brand' property has been loaded; and (b)
+      #   because we may want to filter by other properties too, we give this part of the
+      #   query a unique name (which must be used in the associated conditions too).
+      #
+      # Secondly, the filter. Instead of a static list of values, we pull out all existing
+      #   brands from the db, and then build conditions which test for string equality on
+      #   the (uniquely named) field "p_brand.value". There's also a test for brand info
+      #   being blank: note that this relies on with_property doing a left outer join
+      #   rather than an inner join.
+      if Spree::Property.table_exists?
+        Spree::Product.add_search_scope :brand_any do |*opts|
+          conds = opts.map {|o| ProductFilters.brand_filter[:conds][o]}.reject {|c| c.nil?}
+          scope = conds.shift
+          conds.each do |new_scope|
+            scope = scope.or(new_scope)
+          end
+          Spree::Product.with_property("brand").where(scope)
+        end
+
+        def ProductFilters.brand_filter
+          brand_property = Spree::Property.find_by_name("brand")
+          brands = Spree::ProductProperty.where(:property_id => brand_property).pluck(:value).uniq.map(&:to_s)
+          pp = Spree::ProductProperty.arel_table
+          conds = Hash[*brands.map { |b| [b, pp[:value].eq(b)] }.flatten]
+          { :name   => "Brands",
+            :scope  => :brand_any,
+            :conds  => conds,
+            :labels => (brands.sort).map { |k| [k, k] }
+          }
+        end
+      end
+
+      # Example: a parameterized filter
+      #   The filter above may show brands which aren't applicable to the current taxon,
+      #   so this one only shows the brands that are relevant to a particular taxon and
+      #   its descendants.
+      #
+      #   We don't have to give a new scope since the conditions here are a subset of the
+      #   more general filter, so decoding will still work - as long as the filters on a
+      #   page all have unique names (ie, you can't use the two brand filters together
+      #   if they use the same scope). To be safe, the code uses a copy of the scope.
+      #
+      #   HOWEVER: what happens if we want a more precise scope?  we can't pass
+      #   parametrized scope names to Ransack, only atomic names, so couldn't ask
+      #   for taxon T's customized filter to be used. BUT: we can arrange for the form
+      #   to pass back a hash instead of an array, where the key acts as the (taxon)
+      #   parameter and value is its label array, and then get a modified named scope
+      #   to get its conditions from a particular filter.
+      #
+      #   The brand-finding code can be simplified if a few more named scopes were added to
+      #   the product properties model.
+      if Spree::Property.table_exists?
+        Spree::Product.add_search_scope :selective_brand_any do |*opts|
+          Spree::Product.brand_any(*opts)
+        end
+
+        def ProductFilters.selective_brand_filter(taxon = nil)
+          taxon ||= Spree::Taxonomy.first.root
+          brand_property = Spree::Property.find_by_name("brand")
+          scope = Spree::ProductProperty.where(:property_id => brand_property).
+                                         joins(:product => :taxons).
+                                         where("#{Spree::Taxon.table_name}.id" => [taxon] + taxon.descendants).
+                                         scoped
+          brands = scope.pluck(:value).uniq
+          {
+            :name   => "Applicable Brands",
+            :scope  => :selective_brand_any,
+            :labels => brands.sort.map { |k| [k,k] }
+          }
+        end
+      end
+
+      # Provide filtering on the immediate children of a taxon
+      #
+      # This doesn't fit the pattern of the examples above, so there's a few changes.
+      # Firstly, it uses an existing scope which was not built for filtering - and so
+      # has no need of a conditions mapping, and secondly, it has a mapping of name
+      # to the argument type expected by the other scope.
+      #
+      # This technique is useful for filtering on objects (by passing ids) or with a
+      # scope that can be used directly (eg. testing only ever on a single property).
+      #
+      # This scope selects products in any of the active taxons or their children.
+      #
+      def ProductFilters.taxons_below(taxon)
+        return Spree::Core::ProductFilters.all_taxons if taxon.nil?
+        { :name   => "Taxons under " + taxon.name,
+          :scope  => :taxons_id_in_tree_any,
+          :labels => taxon.children.sort_by(&:position).map {|t| [t.name, t.id]},
+          :conds  => nil
+        }
+      end
+
+      # Filtering by the list of all taxons
+      #
+      # Similar idea as above, but we don't want the descendants' products, hence
+      # it uses one of the auto-generated scopes from Ransack.
+      #
+      # idea: expand the format to allow nesting of labels?
+      def ProductFilters.all_taxons
+        taxons = Spree::Taxonomy.all.map {|t| [t.root] + t.root.descendants }.flatten
+        { :name   => "All taxons",
+          :scope  => :taxons_id_equals_any,
+          :labels => taxons.sort_by(&:name).map {|t| [t.name, t.id]},
+          :conds  => nil # not needed
+        }
+      end
+    end
+  end
+end

data/lib/spree/core/s3_support.rb

@@ -15,7 +15,7 @@ module Spree
             self.attachment_definitions[field][:s3_credentials] = s3_creds
             self.attachment_definitions[field][:s3_headers] = ActiveSupport::JSON.decode(config[:s3_headers])
             self.attachment_definitions[field][:bucket] = config[:s3_bucket]
-            self.attachment_definitions[field][:s3_protocol] = config[:s3_protocol].downcase unless config[:s3_protocol].blank?
+            self.attachment_definitions[field][:s3_protocol] = config[:s3_protocol] unless config[:s3_protocol].blank?
             self.attachment_definitions[field][:s3_host_alias] = config[:s3_host_alias] unless config[:s3_host_alias].blank?
           end
         end

data/lib/spree/core/search/base.rb

@@ -36,7 +36,6 @@ module Spree
             base_scope = Spree::Product.active
             base_scope = base_scope.in_taxon(taxon) unless taxon.blank?
             base_scope = get_products_conditions_for(base_scope, keywords)
-            base_scope = base_scope.on_hand unless Spree::Config[:show_zero_stock_products]
             base_scope = add_search_scopes(base_scope)
             base_scope
           end

data/lib/spree/core/user_banners.rb

@@ -22,4 +22,4 @@ module Spree
       end
     end
   end
-end
+end

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
   def self.version
-    "1.3.5"
+    "2.0.0.rc1"
   end
 end

data/lib/spree/core.rb

@@ -1,33 +1,5 @@
-#++
-# Copyright (c) 2007-2013, Spree Commerce, Inc. and other contributors
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without modification,
-# are permitted provided that the following conditions are met:
-#
-#     * Redistributions of source code must retain the above copyright notice,
-#       this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright notice,
-#       this list of conditions and the following disclaimer in the documentation
-#       and/or other materials provided with the distribution.
-#     * Neither the name of the Spree Commerce, Inc. nor the names of its
-#       contributors may be used to endorse or promote products derived from this
-#       software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#--
 require 'rails/all'
-require 'rails/generators'
+require 'cancan'
 require 'state_machine'
 require 'paperclip'
 require 'kaminari'
@@ -35,12 +7,6 @@ require 'awesome_nested_set'
 require 'acts_as_list'
 require 'active_merchant'
 require 'ransack'
-require 'jquery-rails'
-require 'deface'
-require 'cancan'
-require 'select2-rails'
-require 'spree/money'
-require 'rabl'
 
 module Spree
 
@@ -54,9 +20,6 @@ module Spree
     end
   end
 
-  module Core
-  end
-
   # Used to configure Spree.
   #
   # Example:
@@ -72,66 +35,19 @@ module Spree
   end
 end
 
-require 'spree/core/ext/active_record'
+require 'spree/core/version'
+require 'spree/core/engine'
 
-require 'spree/core/delegate_belongs_to'
+require 'spree/i18n'
+require 'spree/money'
 
-require 'spree/core/responder'
-require 'spree/core/ssl_requirement'
-require 'spree/core/store_helpers'
-require 'spree/core/calculated_adjustments'
-require 'spree/core/mail_settings'
-require 'spree/core/mail_interceptor'
-require 'spree/core/middleware/redirect_legacy_product_url'
-require 'spree/core/middleware/seo_assist'
+require 'spree/core/delegate_belongs_to'
+require 'spree/core/ext/active_record'
 require 'spree/core/permalinks'
 require 'spree/core/token_resource'
-require 'spree/core/s3_support'
-
-require 'spree/core/version'
-
-require 'spree/core/engine'
-require 'generators/spree/dummy/dummy_generator'
+require 'spree/core/calculated_adjustments'
+require 'spree/core/product_duplicator'
 
 ActiveRecord::Base.class_eval do
-  include Spree::Core::CalculatedAdjustments
   include CollectiveIdea::Acts::NestedSet
 end
-
-if defined?(ActionView)
-  require 'awesome_nested_set/helper'
-  ActionView::Base.class_eval do
-    include CollectiveIdea::Acts::NestedSet::Helper
-  end
-end
-
-ActiveSupport.on_load(:action_view) do
-  include Spree::Core::StoreHelpers
-end
-
-# Monkey patch to give us miliseconds precision in timestamps
-module ActiveSupport
-  class TimeWithZone
-    # Coerces time to a string for JSON encoding. The default format is ISO 8601. You can get
-    # %Y/%m/%d %H:%M:%S +offset style by setting <tt>ActiveSupport::JSON::Encoding.use_standard_json_time_format</tt>
-    # to false.
-    #
-    # ==== Examples
-    #
-    #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = true
-    #   Time.utc(2005,2,1,15,15,10).in_time_zone.to_json
-    #   # => "2005-02-01T15:15:10.001Z"
-    #
-    #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
-    #   Time.utc(2005,2,1,15,15,10).in_time_zone.to_json
-    #   # => "2005/02/01 15:15:10 +0000"
-    #
-    def as_json(options = nil)
-      if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-        xmlschema(3)
-      else
-        %(#{time.strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
-      end
-    end
-  end
-end

data/lib/spree/i18n.rb

@@ -0,0 +1,15 @@
+require 'i18n'
+require 'active_support/core_ext/array/extract_options'
+
+module Spree
+  extend ActionView::Helpers::TranslationHelper
+
+  # Add spree namespace and delegate to Rails TranslationHelper for some nice
+  # extra functionality. e.g return reasonable strings for missing translations
+  def self.t(*args)
+    options = args.extract_options!
+    options[:scope] = [*options[:scope]].unshift(:spree)
+    args << options
+    super(*args)
+  end
+end

data/lib/spree/promo/coupon_applicator.rb

@@ -0,0 +1,63 @@
+module Spree
+  module Promo
+    class CouponApplicator
+      attr_reader :order
+
+      def initialize(order)
+        @order = order
+      end
+
+      def apply
+        if @order.coupon_code.present?
+          # check if coupon code is already applied
+          if @order.adjustments.promotion.eligible.detect { |p| p.originator.promotion.code == @order.coupon_code }.present?
+            return { :coupon_applied? => true, :notice => Spree.t(:coupon_code_already_applied) }
+          else
+            promotion = Spree::Promotion.find_by_code(@order.coupon_code)
+            if promotion.present?
+              handle_present_promotion(promotion)
+            else
+              return { :coupon_applied? => false, :error => Spree.t(:coupon_code_not_found) }
+            end
+          end
+        else
+          return { :coupon_applied? => true }
+        end
+      end
+
+      private
+
+      def handle_present_promotion(promotion)
+        return promotion_expired if promotion.expired?
+        return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded?
+
+        event_name = "spree.checkout.coupon_code_added"
+        ActiveSupport::Notifications.instrument(event_name, :coupon_code => @order.coupon_code, :order => @order)
+        promo = @order.adjustments.promotion.detect { |p| p.originator.promotion.code == @order.coupon_code }
+        determine_promotion_application_result(promo)
+      end
+
+      def promotion_expired
+        { :coupon_applied? => false, :error =>  Spree.t(:coupon_code_expired) }
+      end
+
+      def promotion_usage_limit_exceeded
+        { :coupon_applied? => false, :error =>  Spree.t(:coupon_code_max_usage) }
+      end
+
+      def determine_promotion_application_result(promo)
+        previous_promo = @order.adjustments.promotion.eligible.first
+        if promo.present? and promo.eligible
+          return { :coupon_applied? => true, :success =>  Spree.t(:coupon_code_applied) }
+        elsif previous_promo.present? and promo.present?
+          return { :coupon_applied? => false, :error =>  Spree.t(:coupon_code_better_exists) }
+        elsif promo.present?
+          return { :coupon_applied? => false, :error =>  Spree.t(:coupon_code_not_eligible) }
+        else
+          # if the promotion was created after the order
+          return { :coupon_applied? => false, :error =>  Spree.t(:coupon_code_not_found) }
+        end
+      end
+    end
+  end
+end

data/lib/spree/promo/environment.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Promo
+    class Environment
+      include Core::EnvironmentExtension
+
+      attr_accessor :rules, :actions
+    end
+  end
+end

data/lib/spree/testing_support/ability_helpers.rb

@@ -0,0 +1,105 @@
+shared_examples_for 'access granted' do
+  it 'should allow read' do
+    ability.should be_able_to(:read, resource, token) if token
+    ability.should be_able_to(:read, resource) unless token
+  end
+
+  it 'should allow create' do
+    ability.should be_able_to(:create, resource, token) if token
+    ability.should be_able_to(:create, resource) unless token
+  end
+
+  it 'should allow update' do
+    ability.should be_able_to(:update, resource, token) if token
+    ability.should be_able_to(:update, resource) unless token
+  end
+end
+
+shared_examples_for 'access denied' do
+  it 'should not allow read' do
+    ability.should_not be_able_to(:read, resource)
+  end
+
+  it 'should not allow create' do
+    ability.should_not be_able_to(:create, resource)
+  end
+
+  it 'should not allow update' do
+    ability.should_not be_able_to(:update, resource)
+  end
+end
+
+shared_examples_for 'admin granted' do
+  it 'should allow admin' do
+    ability.should be_able_to(:admin, resource, token) if token
+    ability.should be_able_to(:admin, resource) unless token
+  end
+end
+
+shared_examples_for 'admin denied' do
+  it 'should not allow admin' do
+    ability.should_not be_able_to(:admin, resource)
+  end
+end
+
+shared_examples_for 'index allowed' do
+  it 'should allow index' do
+    ability.should be_able_to(:index, resource)
+  end
+end
+
+shared_examples_for 'no index allowed' do
+  it 'should not allow index' do
+    ability.should_not be_able_to(:index, resource)
+  end
+end
+
+shared_examples_for 'create only' do
+  it 'should allow create' do
+    ability.should be_able_to(:create, resource)
+  end
+
+  it 'should not allow read' do
+    ability.should_not be_able_to(:read, resource)
+  end
+
+  it 'should not allow update' do
+    ability.should_not be_able_to(:update, resource)
+  end
+
+  it 'should not allow index' do
+    ability.should_not be_able_to(:index, resource)
+  end
+end
+
+shared_examples_for 'read only' do
+  it 'should not allow create' do
+    ability.should_not be_able_to(:create, resource)
+  end
+
+  it 'should not allow update' do
+    ability.should_not be_able_to(:update, resource)
+  end
+
+  it 'should allow index' do
+    ability.should be_able_to(:index, resource)
+  end
+end
+
+shared_examples_for 'update only' do
+  it 'should not allow create' do
+    ability.should_not be_able_to(:create, resource)
+  end
+
+  it 'should not allow read' do
+    ability.should_not be_able_to(:read, resource)
+  end
+
+  it 'should allow update' do
+    ability.should be_able_to(:update, resource)
+  end
+
+  it 'should not allow index' do
+    ability.should_not be_able_to(:index, resource)
+  end
+end