spree_core 1.0.7 → 1.1.0.rc1

data/app/models/spree/order.rb

@@ -1,3 +1,5 @@
+require 'spree/core/validators/email'
+
 module Spree
   class Order < ActiveRecord::Base
     attr_accessible :line_items, :bill_address_attributes, :ship_address_attributes, :payments_attributes,
@@ -5,11 +7,18 @@ module Spree
                     :shipping_method_id, :email, :use_billing, :special_instructions
 
     belongs_to :user
+
     belongs_to :bill_address, :foreign_key => 'bill_address_id', :class_name => 'Spree::Address'
+    alias_method :billing_address, :bill_address
+    alias_method :billing_address=, :bill_address=
+
     belongs_to :ship_address, :foreign_key => 'ship_address_id', :class_name => 'Spree::Address'
+    alias_method :shipping_address, :ship_address
+    alias_method :shipping_address=, :ship_address=
+
     belongs_to :shipping_method
 
-    has_many :state_events, :as => :stateful
+    has_many :state_changes, :as => :stateful
     has_many :line_items, :dependent => :destroy
     has_many :inventory_units
     has_many :payments, :dependent => :destroy
@@ -30,7 +39,7 @@ module Spree
     after_create :create_tax_charge!
 
     # TODO: validate the format of the email as well (but we can't rely on authlogic anymore to help with validation)
-    validates :email, :presence => true, :format => /^([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})$/i, :if => :require_email
+    validates :email, :presence => true, :email => true, :if => :require_email
     validate :has_available_shipment
     validate :has_available_payment
 
@@ -51,41 +60,6 @@ module Spree
     class_attribute :update_hooks
     self.update_hooks = Set.new
 
-    # Use this method in other gems that wish to register their own custom logic that should be called after Order#updat
-    def self.register_update_hook(hook)
-      self.update_hooks.add(hook)
-    end
-
-    # For compatiblity with Calculator::PriceSack
-    def amount
-      line_items.map(&:amount).sum
-    end
-
-    def to_param
-      number.to_s.to_url.upcase
-    end
-
-    def completed?
-      !! completed_at
-    end
-
-    # Indicates whether or not the user is allowed to proceed to checkout.  Currently this is implemented as a
-    # check for whether or not there is at least one LineItem in the Order.  Feel free to override this logic
-    # in your own application if you require additional steps before allowing a checkout.
-    def checkout_allowed?
-      line_items.count > 0
-    end
-
-    # Is this a free order in which case the payment step should be skipped
-    def payment_required?
-      total.to_f > 0.0
-    end
-
-    # Indicates the number of items in the order
-    def item_count
-      line_items.map(&:quantity).sum
-    end
-
     # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
     state_machine :initial => 'cart', :use_transactions => false do
 
@@ -120,11 +94,7 @@ module Spree
         begin
           order.process_payments!
         rescue Core::GatewayError
-          if Spree::Config[:allow_checkout_on_gateway_error]
-            true
-          else
-            false
-          end
+          !!Spree::Config[:allow_checkout_on_gateway_error]
         end
       end
 
@@ -140,6 +110,41 @@ module Spree
 
     end
 
+    # Use this method in other gems that wish to register their own custom logic that should be called after Order#updat
+    def self.register_update_hook(hook)
+      self.update_hooks.add(hook)
+    end
+
+    # For compatiblity with Calculator::PriceSack
+    def amount
+      line_items.map(&:amount).sum
+    end
+
+    def to_param
+      number.to_s.to_url.upcase
+    end
+
+    def completed?
+      !! completed_at
+    end
+
+    # Indicates whether or not the user is allowed to proceed to checkout.  Currently this is implemented as a
+    # check for whether or not there is at least one LineItem in the Order.  Feel free to override this logic
+    # in your own application if you require additional steps before allowing a checkout.
+    def checkout_allowed?
+      line_items.count > 0
+    end
+
+    # Is this a free order in which case the payment step should be skipped
+    def payment_required?
+      total.to_f > 0.0
+    end
+
+    # Indicates the number of items in the order
+    def item_count
+      line_items.map(&:quantity).sum
+    end
+
     # Indicates whether there are any backordered InventoryUnits associated with the Order.
     def backordered?
       return false unless Spree::Config[:track_inventory_levels]
@@ -220,8 +225,8 @@ module Spree
 
     def restore_state
       # pop the resume event so we can see what the event before that was
-      state_events.pop if state_events.last.name == 'resume'
-      update_attribute('state', state_events.last.previous_state)
+      state_changes.pop if state_changes.last.name == 'resume'
+      update_attribute('state', state_changes.last.previous_state)
 
       if paid?
         raise 'do something with inventory'
@@ -250,7 +255,7 @@ module Spree
 
     def allow_resume?
       # we shouldn't allow resume for legacy orders b/c we lack the information necessary to restore to a previous state
-      return false if state_events.empty? || state_events.last.previous_state.nil?
+      return false if state_changes.empty? || state_changes.last.previous_state.nil?
       true
     end
 
@@ -319,8 +324,8 @@ module Spree
     # include taxes then price adjustments are created instead.
     def create_tax_charge!
       # destroy any previous adjustments (eveything is recalculated from scratch)
-      adjustments.tax.each { |e| e.destroy }
-      price_adjustments.each { |p| p.destroy }
+      adjustments.tax.each(&:destroy)
+      price_adjustments.each(&:destroy)
 
       TaxRate.match(self).each { |rate| rate.adjust(self) }
     end
@@ -331,10 +336,10 @@ module Spree
       if shipment.present?
         shipment.update_attributes!(:shipping_method => shipping_method)
       else
-        self.shipments << Shipment.create!(:order => self,
+        self.shipments << Shipment.create!({ :order => self,
                                           :shipping_method => shipping_method,
                                           :address => self.ship_address,
-                                          :inventory_units => self.inventory_units)
+                                          :inventory_units => self.inventory_units}, :without_protection => true)
       end
 
     end
@@ -371,12 +376,12 @@ module Spree
       adjustments.optional.each { |adjustment| adjustment.update_attribute('locked', true) }
       OrderMailer.confirm_email(self).deliver
 
-      self.state_events.create({
+      self.state_changes.create({
         :previous_state => 'cart',
         :next_state     => 'complete',
         :name           => 'order' ,
         :user_id        => (User.respond_to?(:current) && User.current.try(:id)) || self.user_id
-      })
+      }, :without_protection => true)
     end
 
     # Helper methods for checkout steps
@@ -393,12 +398,11 @@ module Spree
     def rate_hash
       @rate_hash ||= available_shipping_methods(:front_end).collect do |ship_method|
         next unless cost = ship_method.calculator.compute(self)
-        { :id => ship_method.id,
-          :shipping_method => ship_method,
-          :name => ship_method.name,
-          :cost => cost
-        }
-      end.compact.sort_by { |r| r[:cost] }
+        ShippingRate.new( :id => ship_method.id,
+                          :shipping_method => ship_method,
+                          :name => ship_method.name,
+                          :cost => cost)
+      end.compact.sort_by { |r| r.cost }
     end
 
     def payment
@@ -466,12 +470,12 @@ module Spree
         self.shipment_state = 'backorder' if backordered?
 
         if old_shipment_state = self.changed_attributes['shipment_state']
-          self.state_events.create({
+          self.state_changes.create({
             :previous_state => old_shipment_state,
             :next_state     => self.shipment_state,
             :name           => 'shipment',
             :user_id        => (User.respond_to?(:current) && User.current && User.current.id) || self.user_id
-          })
+          }, :without_protection => true)
         end
       end
 
@@ -484,7 +488,9 @@ module Spree
       #
       # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
       def update_payment_state
-        if round_money(payment_total) < round_money(total)
+        
+        #line_item are empty when user empties cart
+        if self.line_items.empty? || round_money(payment_total) < round_money(total)
           self.payment_state = 'balance_due'
           self.payment_state = 'failed' if payments.present? and payments.last.state == 'failed'
         elsif round_money(payment_total) > round_money(total)
@@ -494,12 +500,12 @@ module Spree
         end
 
         if old_payment_state = self.changed_attributes['payment_state']
-          self.state_events.create({
+          self.state_changes.create({
             :previous_state => old_payment_state,
             :next_state     => self.payment_state,
             :name           => 'payment',
             :user_id        => (User.respond_to?(:current) && User.current && User.current.id) || self.user_id
-          })
+          }, :without_protection => true)
         end
       end
 

data/app/models/spree/payment.rb

@@ -1,7 +1,7 @@
 module Spree
   class Payment < ActiveRecord::Base
     belongs_to :order
-    belongs_to :source, :polymorphic => true
+    belongs_to :source, :polymorphic => true, :validate => true
     belongs_to :payment_method
 
     has_many :offsets, :class_name => 'Spree::Payment', :foreign_key => 'source_id', :conditions => "source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'"

data/app/models/spree/payment_method.rb

@@ -30,12 +30,6 @@ module Spree
       self.count(:conditions => { :type => self.to_s, :environment => Rails.env, :active => true }) > 0
     end
 
-    # TODO: Remove this method by 1.0
-    def self.current
-      ActiveSupport::Deprecation.warn "Gateway.current is deprecated and will be removed in Spree > 1.0. Use current_order.payment_method instead."
-      first(:conditions => { :active => true, :environment => Rails.env })
-    end
-
     def method_type
       type.demodulize.downcase
     end

data/app/models/spree/product/scopes.rb

@@ -1,25 +1,11 @@
 module Spree
   class Product < ActiveRecord::Base
-    cattr_accessor :search_scopes do
-      []
-    end
-
-    def self.add_search_scope(name, &block)
-      self.singleton_class.send(:define_method, name.to_sym, &block)
-      search_scopes << name.to_sym
-    end
-
     def self.simple_scopes
       [
         :ascend_by_updated_at,
         :descend_by_updated_at,
         :ascend_by_name,
-        :descend_by_name,
-        # Need to have master price scopes here
-        # This makes them appear in admin/product_groups/edit
-        :ascend_by_master_price,
-        :descend_by_master_price,
-        :descend_by_popularity
+        :descend_by_name
       ]
     end
 
@@ -31,23 +17,37 @@ module Spree
       self.scope(name.to_s, relation.order(order_text))
     end
 
-    add_search_scope :ascend_by_master_price do
+    def self.ascend_by_master_price
       joins(:variants_with_only_master).order("#{variant_table_name}.price ASC")
     end
 
-    add_search_scope :descend_by_master_price do
+    def self.descend_by_master_price
       joins(:variants_with_only_master).order("#{variant_table_name}.price DESC")
     end
 
-    add_search_scope :price_between do |low, high|
+    # Ryan Bates - http://railscasts.com/episodes/112
+    # general merging of conditions, names following the searchlogic pattern
+    scope :conditions, lambda { |*args| { :conditions => args } }
+
+    # conditions_all is a more descriptively named enhancement of the above
+    scope :conditions_all, lambda { |*args| { :conditions => [args].flatten } }
+
+    # forming the disjunction of a list of conditions (as strings)
+    scope :conditions_any, lambda { |*args|
+      args = [args].flatten
+      raise "non-strings in conditions_any" unless args.all? { |s| s.is_a? String }
+      { :conditions => args.map { |c| "(#{c})"}.join(" OR ") }
+    }
+
+    def self.price_between(low, high)
       joins(:master).where(Variant.table_name => { :price => low..high })
     end
 
-    add_search_scope :master_price_lte do |price|
+    def self.master_price_lte(price)
       joins(:master).where("#{variant_table_name}.price <= ?", price)
     end
 
-    add_search_scope :master_price_gte do |price|
+    def self.master_price_gte(price)
       joins(:master).where("#{variant_table_name}.price >= ?", price)
     end
 
@@ -55,7 +55,7 @@ module Spree
     # If you need products only within one taxon use
     #
     #   Spree::Product.taxons_id_eq(x)
-    add_search_scope :in_taxon do |taxon|
+    def self.in_taxon(taxon)
       joins(:taxons).where(Taxon.table_name => { :id => taxon.self_and_descendants.map(&:id) })
     end
 
@@ -63,17 +63,18 @@ module Spree
     # If you need products only within one taxon use
     #
     #   Spree::Product.taxons_id_eq([x,y])
-    add_search_scope :in_taxons do |*taxons|
+    #
+    def self.in_taxons(*taxons)
       taxons = get_taxons(taxons)
       taxons.first ? prepare_taxon_conditions(taxons) : scoped
     end
 
-    def self.in_cached_group(product_group)
-      joins(:product_groups).where('spree_product_groups_products.product_group_id' => product_group)
-    end
+    # def self.in_cached_group(product_group)
+    #   joins(:product_groups).where('spree_product_groups_products.product_group_id' => product_group)
+    # end
 
     # a scope that finds all products having property specified by name, object or id
-    add_search_scope :with_property do |property|
+    def self.with_property(property)
       properties = Property.table_name
       conditions = case property
       when String   then { "#{properties}.name" => property }
@@ -86,7 +87,7 @@ module Spree
 
     # a simple test for product with a certain property-value pairing
     # note that it can test for properties with NULL values, but not for absent values
-    add_search_scope :with_property_value do |property, value|
+    def self.with_property_value(property, value)
       properties = Spree::Property.table_name
       conditions = case property
       when String   then ["#{properties}.name = ?", property]
@@ -98,7 +99,8 @@ module Spree
       joins(:properties).where(conditions)
     end
 
-    add_search_scope :with_option do |option|
+    # a scope that finds all products having an option_type specified by name, object or id
+    def self.with_option(option)
       option_types = OptionType.table_name
       conditions = case option
       when String     then { "#{option_types}.name" => option }
@@ -109,7 +111,8 @@ module Spree
       joins(:option_types).where(conditions)
     end
 
-    add_search_scope :with_option_value do |option, value|
+    # a scope that finds all products having an option value specified by name, object or id
+    def self.with_option_value(option, value)
       option_values = OptionValue.table_name
       option_type_id = case option
         when String then OptionType.find_by_name(option) || option.to_i
@@ -124,30 +127,30 @@ module Spree
     # Finds all products which have either:
     # 1) have an option value with the name matching the one given
     # 2) have a product property with a value matching the one given
-    add_search_scope :with do |value|
+    def self.with(value)
       includes(:variants_including_master => :option_values).
       includes(:product_properties).
       where("#{OptionValue.table_name}.name = ? OR #{ProductProperty.table_name}.value = ?", value, value)
     end
 
     # Finds all products that have a name containing the given words.
-    add_search_scope :in_name do |words|
+    def self.in_name(words)
       like_any([:name], prepare_words(words))
     end
 
     # Finds all products that have a name or meta_keywords containing the given words.
-    add_search_scope :in_name_or_keywords do |words|
+    def self.in_name_or_keywords(words)
       like_any([:name, :meta_keywords], prepare_words(words))
     end
 
     # Finds all products that have a name, description, meta_description or meta_keywords containing the given keywords.
-    add_search_scope :in_name_or_description do |words|
+    def self.in_name_or_description(words)
       like_any([:name, :description, :meta_description, :meta_keywords], prepare_words(words))
     end
 
     # Finds all products that have the ids matching the given collection of ids.
     # Alternatively, you could use find(collection_of_ids), but that would raise an exception if one product couldn't be found
-    add_search_scope :with_ids do |*ids|
+    def self.with_ids(*ids)
       where(:id => ids)
     end
 
@@ -159,7 +162,7 @@ module Spree
     #
     # :joins => "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
     # :order => 'COALESCE(cnt, 0) DESC'
-    add_search_scope :descend_by_popularity do
+    def self.descend_by_popularity
       joins(:master).
       order(%Q{
            COALESCE((
@@ -177,26 +180,25 @@ module Spree
         })
     end
 
-    add_search_scope :not_deleted do
+    def self.not_deleted
       where(:deleted_at => nil)
     end
 
-    # Can't use add_search_scope for this as it needs a default argument
     def self.available(available_on = nil)
       where('available_on <= ?', available_on || Time.now)
     end
-    search_scopes << :available
 
-    add_search_scope :active do
+    #RAILS 3 TODO - this scope doesn't match the original 2.3.x version, needs attention (but it works)
+    def self.active
       not_deleted.available
     end
 
-    add_search_scope :on_hand do
+    def self.on_hand
       variants_table = Variant.table_name
-      where("#{table_name}.id in (select product_id from #{variants_table} where product_id = #{table_name}.id and #{variants_table}.deleted_at IS NULL group by product_id having sum(count_on_hand) > 0)")
+      where("#{table_name}.id in (select product_id from #{variants_table} where product_id = #{table_name}.id group by product_id having sum(count_on_hand) > 0)")
     end
 
-    add_search_scope :taxons_name_eq do |name|
+    def self.taxons_name_eq(name)
       joins(:taxons).where(Taxon.arel_table[:name].eq(name))
     end
 
@@ -207,8 +209,6 @@ module Spree
     else
       scope :group_by_products_id, { :group => "#{self.quoted_table_name}.id" }
     end
-    search_methods :group_by_products_id
-    search_scopes << :group_by_products_id
 
     private
       def self.variant_table_name

data/app/models/spree/product.rb

@@ -23,26 +23,24 @@ module Spree
     has_many :option_types, :through => :product_option_types
     has_many :product_properties, :dependent => :destroy
     has_many :properties, :through => :product_properties
-    has_many :images, :as => :viewable, :order => :position, :dependent => :destroy
-    has_and_belongs_to_many :product_groups, :join_table => 'spree_product_groups_products'
     belongs_to :tax_category
     has_and_belongs_to_many :taxons, :join_table => 'spree_products_taxons'
     belongs_to :shipping_category
 
     has_one :master,
-      :class_name => "Spree::Variant",
-      :conditions => { :is_master => true }
+      :class_name => 'Spree::Variant',
+      :conditions => ["#{Variant.quoted_table_name}.is_master = ? AND #{Variant.quoted_table_name}.deleted_at IS NULL", true]
 
     delegate_belongs_to :master, :sku, :price, :weight, :height, :width, :depth, :is_master
     delegate_belongs_to :master, :cost_price if Variant.table_exists? && Variant.column_names.include?('cost_price')
 
     after_create :set_master_variant_defaults
     after_create :add_properties_and_option_types_from_prototype
+    after_create :build_variants_from_option_values_hash, :if => :option_values_hash
     before_save :recalculate_count_on_hand
-    after_save :update_memberships if ProductGroup.table_exists?
     after_save :save_master
     after_save :set_master_on_hand_to_zero_when_product_has_variants
-    
+
     has_many :variants,
       :class_name => 'Spree::Variant',
       :conditions => ["#{::Spree::Variant.quoted_table_name}.is_master = ? AND #{::Spree::Variant.quoted_table_name}.deleted_at IS NULL", false],
@@ -58,23 +56,29 @@ module Spree
       :conditions => ["#{::Spree::Variant.quoted_table_name}.deleted_at IS NULL AND #{::Spree::Variant.quoted_table_name}.is_master = ?", true],
       :dependent => :destroy
 
+    accepts_nested_attributes_for :variants, :allow_destroy => true
+
     def variant_images
       Image.find_by_sql("SELECT #{Asset.quoted_table_name}.* FROM #{Asset.quoted_table_name} LEFT JOIN #{Variant.quoted_table_name} ON (#{Variant.quoted_table_name}.id = #{Asset.quoted_table_name}.viewable_id) WHERE (#{Variant.quoted_table_name}.product_id = #{self.id})")
     end
 
+    alias_method :images, :variant_images
+
     validates :name, :price, :permalink, :presence => true
 
+    attr_accessor :option_values_hash
+
     attr_accessible :name, :description, :available_on, :permalink, :meta_description,
                     :meta_keywords, :price, :sku, :deleted_at, :prototype_id,
                     :option_values_hash, :on_hand, :weight, :height, :width, :depth,
-                    :shipping_category_id, :tax_category_id, :product_properties_attributes,
-                    :variants_attributes, :taxon_ids
+                    :shipping_category_id, :tax_category_id
 
     attr_accessible :cost_price if Variant.table_exists? && Variant.column_names.include?('cost_price')
 
+
     accepts_nested_attributes_for :product_properties, :allow_destroy => true, :reject_if => lambda { |pp| pp[:property_name].blank? }
 
-    make_permalink
+    make_permalink :order => :name
 
     alias :options :product_option_types
 
@@ -124,12 +128,12 @@ module Spree
       @prototype_id = value.to_i
     end
 
-    def add_properties_and_option_types_from_prototype
-      if prototype_id && prototype = Spree::Prototype.find_by_id(prototype_id)
-        prototype.properties.each do |property|
-          product_properties.create({:property => property}, :without_protection => true)
-        end
-        self.option_types = prototype.option_types
+    # Ensures option_types and product_option_types exist for keys in option_values_hash
+    def ensure_option_types_exist_for_values_hash
+      return if option_values_hash.nil?
+      option_values_hash.keys.map(&:to_i).each do |id|
+        self.option_type_ids << id unless self.option_type_ids.include?(id)
+        self.product_option_types.create({:option_type_id => id}, :without_protection => true) unless product_option_types.map(&:option_type_id).include?(id)
       end
     end
 
@@ -145,20 +149,16 @@ module Spree
       p.product_properties = self.product_properties.map { |q| r = q.dup; r.created_at = r.updated_at = nil; r }
 
       image_dup = lambda { |i| j = i.dup; j.attachment = i.attachment.clone; j }
-      p.images = self.images.map { |i| image_dup.call i }
 
-      master = Spree::Variant.find_by_product_id_and_is_master(self.id, true)
       variant = master.dup
       variant.sku = 'COPY OF ' + master.sku
       variant.deleted_at = nil
       variant.images = master.images.map { |i| image_dup.call i }
       p.master = variant
 
-      if self.has_variants?
-        # don't dup the actual variants, just the characterising types
-        p.option_types = self.option_types
-      else
-      end
+      # don't dup the actual variants, just the characterising types
+      p.option_types = self.option_types if self.has_variants?
+        
       # allow site to do some customization
       p.send(:duplicate_extra, self) if p.respond_to?(:duplicate_extra)
       p.save!
@@ -199,6 +199,28 @@ module Spree
     end
 
     private
+
+      # Builds variants from a hash of option types & values
+      def build_variants_from_option_values_hash
+        ensure_option_types_exist_for_values_hash
+        values = option_values_hash.values
+        values = values.inject(values.shift) { |memo, value| memo.product(value).map(&:flatten) }
+
+        values.each do |ids|
+          variant = self.variants.create({:option_value_ids => ids, :price => self.master.price}, :without_protection => true)
+        end
+        save
+      end
+
+      def add_properties_and_option_types_from_prototype
+        if prototype_id && prototype = Spree::Prototype.find_by_id(prototype_id)
+          prototype.properties.each do |property|
+            product_properties.create({:property => property}, :without_protection => true)
+          end
+          self.option_types = prototype.option_types
+        end
+      end
+
       def recalculate_count_on_hand
         product_count_on_hand = has_variants? ?
           variants.sum(:count_on_hand) : (master ? master.count_on_hand : 0)
@@ -221,10 +243,6 @@ module Spree
       def save_master
         master.save if master && (master.changed? || master.new_record?)
       end
-
-      def update_memberships
-        self.product_groups = ProductGroup.all.select { |pg| pg.include?(self) }
-      end
   end
 end
 

data/app/models/spree/product_property.rb

@@ -6,8 +6,6 @@ module Spree
     validates :property, :presence => true
     validates_length_of :value, :maximum => 255
 
-    attr_accessible :property_name, :value
-
     # virtual attributes for use with AJAX completion stuff
     def property_name
       property.name if property

data/app/models/spree/property.rb

@@ -5,8 +5,6 @@ module Spree
     has_many :product_properties, :dependent => :destroy
     has_many :products, :through => :product_properties
 
-    after_destroy :recalculate_product_group_products
-
     attr_accessible :name, :presentation
 
     validates :name, :presentation, :presence => true
@@ -20,19 +18,5 @@ module Spree
       end
       joins("LEFT JOIN properties_prototypes ON property_id = #{self.table_name}.id").where(:prototype_id => id)
     end
-
-    private
-
-    # A fix for #774
-    # What was happening was that when a property was deleted, any product group
-    # that used the property to calculate included properties was not recalculated
-    #
-    # Recalculates product group products after the property has been deleted
-    def recalculate_product_group_products
-      ProductScope.where(:name => "with_property", :arguments => [self.name].to_yaml).each do |scope|
-        # Triggers ProductGroup#update_memberships callback to recalculate products
-        scope.product_group.save!
-      end
-    end
   end
 end

data/app/models/spree/prototype.rb

@@ -6,6 +6,5 @@ module Spree
     attr_accessible :name
 
     validates :name, :presence => true
-
   end
 end