spree_core 0.60.6 → 0.70.0

data/app/helpers/spree/base_helper.rb

@@ -20,8 +20,7 @@ module Spree::BaseHelper
     # overwrite show_vat_text if show_price_inc_vat is false
     options[:show_vat_text] = Spree::Config[:show_price_inc_vat]
 
-    amount =  order.item_total
-    amount += Calculator::Vat.calculate_tax(order) if Spree::Config[:show_price_inc_vat]
+    amount =  order.total
 
     options.delete(:format_as_currency) ? number_to_currency(amount) : amount
   end
@@ -36,8 +35,19 @@ module Spree::BaseHelper
 
   # human readable list of variant options
   def variant_options(v, allow_back_orders = Spree::Config[:allow_backorders], include_style = true)
+    ActiveSupport::Deprecation.warn("variant_options method is deprecated, and will be removed in 0.80.0", caller)
     list = v.options_text
-    list = include_style ? "<span class =\"out-of-stock\">(" + t("out_of_stock") + ") #{list}</span>" : "#{t("out_of_stock")} #{list}" unless (allow_back_orders || v.in_stock?)
+
+    # We shouldn't show out of stock if the product is infact in stock
+    # or when we're not allowing backorders.
+    unless (allow_back_orders || v.in_stock?)
+      list = if include_style
+        content_tag(:span, "(#{t(:out_of_stock)}) #{list}", :class => "out-of-stock")
+      else
+        "#{t(:out_of_stock)} #{list}"
+      end
+    end
+
     list
   end
 
@@ -45,7 +55,7 @@ module Spree::BaseHelper
     define_method "#{style}_image" do |product, *options|
       options = options.first || {}
       if product.images.empty?
-        image_tag "noimage/#{style}.jpg", options
+        image_tag "noimage/#{style}.png", options
       else
         image = product.images.first
         options.reverse_merge! :alt => image.alt.blank? ? product.name : image.alt
@@ -56,15 +66,21 @@ module Spree::BaseHelper
 
   def meta_data_tags
     object = instance_variable_get('@'+controller_name.singularize)
-    return unless object
-    "".tap do |tags|
-      if object.respond_to?(:meta_keywords) and object.meta_keywords.present?
-        tags << tag('meta', :name => 'keywords', :content => object.meta_keywords) + "\n"
-      end
-      if object.respond_to?(:meta_description) and object.meta_description.present?
-        tags << tag('meta', :name => 'description', :content => object.meta_description) + "\n"
-      end
+    meta = { :keywords => Spree::Config[:default_meta_keywords], :description => Spree::Config[:default_meta_description] }
+
+    if object.kind_of?(ActiveRecord::Base)
+      meta[:keywords] = object.meta_keywords if object[:meta_keywords].present?
+      meta[:description] = object.meta_description if object[:meta_description].present?
     end
+
+    meta.map do |name, content|
+      tag('meta', :name => name, :content => content)
+    end.join("\n")
+  end
+
+  def body_class
+    @body_class ||= content_for?(:sidebar) ? 'two-col' : 'one-col'
+    @body_class
   end
 
   def stylesheet_tags(paths=stylesheet_paths)
@@ -84,22 +100,60 @@ module Spree::BaseHelper
     link_to image_tag(image_path), root_path
   end
 
+  def flash_messages
+    [:notice, :error].map do |msg_type|
+      if flash[msg_type]
+        content_tag :div, flash[msg_type], :class => "flash #{msg_type}"
+      else
+        ''
+      end
+    end.join("\n").html_safe
+  end
+
+  def breadcrumbs(taxon, separator="&nbsp;&raquo;&nbsp;")
+    return "" if current_page?("/") || taxon.nil?
+    separator = raw(separator)
+    crumbs = [content_tag(:li, link_to(t(:home) , root_path) + separator)]
+    if taxon
+      crumbs << content_tag(:li, link_to(t('products') , products_path) + separator)
+      crumbs << taxon.ancestors.collect { |ancestor| content_tag(:li, link_to(ancestor.name , seo_url(ancestor)) + separator) } unless taxon.ancestors.empty?
+      crumbs << content_tag(:li, content_tag(:span, taxon.name))
+    else
+      crumbs << content_tag(:li, content_tag(:span, t('products')))
+    end
+    crumb_list = content_tag(:ul, raw(crumbs.flatten.map{|li| li.mb_chars}.join))
+    content_tag(:div, crumb_list + tag(:br, {:class => 'clear'}, false, true), :id => 'breadcrumbs')
+  end
+
+  def taxons_tree(root_taxon, current_taxon, max_level = 1)
+    return '' if max_level < 1 || root_taxon.children.empty?
+    content_tag :ul, :class => 'taxons-list' do
+      root_taxon.children.map do |taxon|
+        css_class = (current_taxon && current_taxon.self_and_ancestors.include?(taxon)) ? 'current' : nil
+        content_tag :li, :class => css_class do
+         link_to(taxon.name, seo_url(taxon)) +
+         taxons_tree(taxon, current_taxon, max_level - 1)
+        end
+      end.join("\n").html_safe
+    end
+  end
+
   def available_countries
     return Country.all unless zone = Zone.find_by_name(Spree::Config[:checkout_zone])
     zone.country_list
   end
-  
+
   def format_price(price, options={})
     options.assert_valid_keys(:show_vat_text)
     options.reverse_merge! :show_vat_text => Spree::Config[:show_price_inc_vat]
-    formatted_price = number_to_currency(price)
+    formatted_price = number_to_currency price
     if options[:show_vat_text]
       I18n.t(:price_with_vat_included, :price => formatted_price)
     else
       formatted_price
     end
   end
-  
+
   # generates nested url to product based on supplied taxon
   def seo_url(taxon, product = nil)
     return '/t/' + taxon.permalink if product.nil?
@@ -107,7 +161,7 @@ module Spree::BaseHelper
       "not used anymore. Use product_url instead. (called from #{caller[0]})"
     return product_url(product)
   end
-  
+
   def current_orders_product_count
     if current_order.blank? || current_order.item_count < 1
       return 0

data/app/helpers/taxons_helper.rb

@@ -1,20 +1,4 @@
 module TaxonsHelper
-  def breadcrumbs(taxon, separator=" » ")
-    return "" if current_page?("/")
-    separator = raw(separator)
-    crumbs = [content_tag(:li, link_to(t(:home) , root_path) + separator)]
-    if taxon
-      crumbs << content_tag(:li, link_to(t('products') , products_path) + separator)
-      crumbs << taxon.ancestors.collect { |ancestor| content_tag(:li, link_to(ancestor.name , seo_url(ancestor)) + separator) } unless taxon.ancestors.empty?
-      crumbs << content_tag(:li, content_tag(:span, taxon.name))
-    else
-      crumbs << content_tag(:li, content_tag(:span, t('products')))
-    end
-    crumb_list = content_tag(:ul, raw(crumbs.flatten.map{|li| li.mb_chars}.join))
-    content_tag(:div, crumb_list + tag(:br, {:class => 'clear'}, false, true), :class => 'breadcrumbs')
-  end
-
-
   # Retrieves the collection of products to display when "previewing" a taxon.  This is abstracted into a helper so
   # that we can use configurations as well as make it easier for end users to override this determination.  One idea is
   # to show the most popular products for a particular taxon (that is an exercise left to the developer.)

data/app/mailers/order_mailer.rb

@@ -1,18 +1,18 @@
 class OrderMailer < ActionMailer::Base
-  helper "spree/base"
+  helper 'spree/base'
 
   def confirm_email(order, resend=false)
     @order = order
-    subject = (resend ? "[RESEND] " : "")
-    subject += "#{Spree::Config[:site_name]} #{t('subject', :scope =>'order_mailer.confirm_email')} ##{order.number}"
+    subject = (resend ? "[#{t(:resend).upcase}] " : "")
+    subject += "#{Spree::Config[:site_name]} #{t('order_mailer.confirm_email.subject')} ##{order.number}"
     mail(:to => order.email,
          :subject => subject)
   end
 
   def cancel_email(order, resend=false)
     @order = order
-    subject = (resend ? "[RESEND] " : "")
-    subject += "#{Spree::Config[:site_name]} #{t('subject', :scope => 'order_mailer.cancel_email')} ##{order.number}"
+    subject = (resend ? "[#{t(:resend).upcase}] " : "")
+    subject += "#{Spree::Config[:site_name]} #{t('order_mailer.cancel_email.subject')} ##{order.number}"
     mail(:to => order.email,
          :subject => subject)
   end

data/app/mailers/shipment_mailer.rb

@@ -1,10 +1,10 @@
 class ShipmentMailer < ActionMailer::Base
-  helper "spree/base"
+  helper 'spree/base'
 
   def shipped_email(shipment, resend=false)
     @shipment = shipment
-    subject = (resend ? "[RESEND] " : "")
-    subject += "#{Spree::Config[:site_name]} #{t('subject', :scope => 'shipment_mailer.shipped_email')} ##{shipment.order.number}"
+    subject = (resend ? "[#{t(:resend).upcase}] " : "")
+    subject += "#{Spree::Config[:site_name]} #{t('shipment_mailer.shipped_email.subject')} ##{shipment.order.number}"
     mail(:to => shipment.order.email,
          :subject => subject)
   end

data/app/mailers/test_mailer.rb

@@ -0,0 +1,10 @@
+class TestMailer < ActionMailer::Base
+
+  def test_email(mail_method, user)
+    @mail_method = mail_method
+    subject = "#{Spree::Config[:site_name]} #{t('test_mailer.test_email.subject')}"
+    mail(:to => user.email,
+         :subject => subject)
+  end
+
+end

data/app/models/activator.rb

@@ -0,0 +1,27 @@
+class Activator < ActiveRecord::Base
+
+  cattr_accessor :event_names
+
+  self.event_names = [
+    'spree.cart.add',
+    'spree.checkout.coupon_code_added',
+    'spree.order.contents_changed',
+    'spree.user.signup'
+  ]
+
+  def self.register_event_name(name)
+    self.event_names << name
+  end
+
+  scope :event_name_starts_with, lambda{|name| where('event_name like ?', "#{name}%") }
+  scope :active, where('( starts_at IS NULL OR starts_at < ? ) AND ( expires_at IS NULL OR expires_at > ?)', Time.now, Time.now)
+
+  def activate(payload)
+  end
+
+  def expired?
+    starts_at && Time.now < starts_at ||
+    expires_at && Time.now > expires_at
+  end
+
+end

data/app/models/adjustment.rb

@@ -1,4 +1,4 @@
-# Adjustments represent a change to the +item_total+ of an Order.  Each adjustment has an +amount+ that be either
+
 # positive or negative.  Adjustments have two useful boolean flags
 #
 # +mandatory+
@@ -13,6 +13,13 @@
 # The charge is never to be udpated.  Typically you would want to freeze certain adjustments after checkout.
 # One use case for this is if you want to lock a shipping adjustment so that its value does not change
 # in the future when making other trivial edits to the order (like an email change).
+#
+# +eligible?+
+#
+#  This boolean attributes stores whether this adjustment is currently eligible for its order. Only eligible
+#  adjustments count towards the order's adjustment total. This allows an adjustment to be preserved if it
+#  becomes ineligible so it might be reinstated.
+#
 class Adjustment < ActiveRecord::Base
   belongs_to :order
   belongs_to :source, :polymorphic => true
@@ -21,27 +28,40 @@ class Adjustment < ActiveRecord::Base
   validates :label, :presence => true
   validates :amount, :numericality => true
 
-  scope :tax, lambda { where(:label => I18n.t(:tax)) }
+  scope :tax, lambda { where(:originator_type => "TaxRate") }
   scope :shipping, lambda { where(:label => I18n.t(:shipping)) }
   scope :optional, where(:mandatory => false)
+  scope :eligible, where(:eligible => true)
 
   after_save { order.update! }
   after_destroy { order.update! }
 
-  # Checks if adjustment is applicable for the order. Should return _true_ if adjustment should be preserved and
-  # _false_ if removed. Default behaviour is to preserve adjustment if amount is present and non 0.  Exceptions
-  # are made if the adjustment is considered +mandatory+.
-  def applicable?
-    mandatory || amount != 0
+  # Update the boolean _eligible_ attribute which deterimes which adjustments count towards the order's
+  # adjustment_total.
+  def set_eligibility
+    update_attribute_without_callbacks(:eligible,
+                                       mandatory ||
+                                       (amount != 0 && eligible_for_originator?))
   end
 
-  # Tells the adjustment that its time to update itself.  Adjustments will delegate this request to their Originator
+  # Allow originator of the adjustment to perform an additional eligibility of the adjustment
+  # Should return _true_ if originator is absent or doesn't implement _eligible?_
+  def eligible_for_originator?
+    return true if originator.nil?
+    !originator.respond_to?(:eligible?) || originator.eligible?(source)
+  end
+
+
+  # Update both the eligibility and amount of the adjustment. Adjustments delegate updating of amount to their Originator
   # when present, but only if +locked+ is false.  Adjustments that are +locked+ will never change their amount.
   # The new adjustment amount will be set by by the +originator+ and is not automatically saved.  This makes it save
-  # to use this method in an after_save hook for other models without causing an infinite recursion problem.  If there
-  # is no +originator+ then this method will have no effect.
+  # to use this method in an after_save hook for other models without causing an infinite recursion problem.
   def update!
-    return if locked? || originator.nil?
-    originator.update_adjustment(self, source)
+    return if locked?
+    set_eligibility
+    if originator.present?
+      originator.update_adjustment(self, source)
+    end
   end
+
 end

data/app/models/app_configuration.rb

@@ -2,6 +2,8 @@ class AppConfiguration < Configuration
 
   preference :site_name, :string, :default => 'Spree Demo Site'
   preference :default_seo_title, :string, :default => ''
+  preference :default_meta_description, :string, :default => 'Spree demo site'
+  preference :default_meta_keywords, :string, :default => 'spree, demo'
   preference :site_url, :string, :default => 'demo.spreecommerce.com'
   preference :default_locale, :string, :default => 'en'
   preference :allow_locale_switching, :boolean, :default => true
@@ -13,12 +15,12 @@ class AppConfiguration < Configuration
   preference :show_descendents, :boolean, :default => true
   preference :show_zero_stock_products, :boolean, :default => true
   preference :orders_per_page, :integer, :default => 15
-  preference :show_only_complete_orders_by_default, :boolean, :default => false
+  preference :show_only_complete_orders_by_default, :boolean, :default => true
   preference :admin_products_per_page, :integer, :default => 10
   preference :admin_pgroup_preview_size, :integer, :default => 10
   preference :products_per_page, :integer, :default => 10
-  preference :logo, :string, :default => '/images/admin/bg/spree_50.png'
-  preference :stylesheets, :string, :default => 'screen' # Comma separate multiple stylesheets, e.g. 'screen,mystyle'
+  preference :logo, :string, :default => 'admin/bg/spree_50.png'
+  preference :stylesheets, :string, :default => 'reset,screen' # Comma separate multiple stylesheets, e.g. 'screen,mystyle'
   preference :admin_interface_logo, :string, :default => "admin/bg/spree_50.png"
   preference :allow_ssl_in_production, :boolean, :default => true
   preference :allow_ssl_in_development_and_test, :boolean, :default => false
@@ -27,6 +29,7 @@ class AppConfiguration < Configuration
   preference :alternative_shipping_phone, :boolean, :default => false # Request extra phone for ship addr
   preference :shipping_instructions,      :boolean, :default => false # Request instructions/info for shipping
   preference :show_price_inc_vat, :boolean, :default => false
+  preference :shipment_inc_vat, :boolean, :default => false
   preference :auto_capture, :boolean, :default => false # automatically capture the creditcard (as opposed to just authorize and capture later)
   preference :address_requires_state, :boolean, :default => true # should state/state_name be required
   preference :checkout_zone, :string, :default => nil # replace with the name of a zone if you would like to limit the countries
@@ -35,9 +38,7 @@ class AppConfiguration < Configuration
   preference :use_content_controller, :boolean, :default => true
   preference :allow_checkout_on_gateway_error, :boolean, :default => false
   preference :select_taxons_from_tree, :boolean, :default => false # provide opportunity to select taxons from tree instead of search with autocomplete
-  preference :check_for_spree_alerts, :boolean, :default => true
-  preference :dismissed_spree_alerts, :string, :default => ''
-  preference :last_check_for_spree_alerts, :string, :default => nil
+  preference :max_level_in_taxons_menu, :integer, :default => 1 # maximum nesting level in taxons menu
 
   validates :name, :presence => true, :uniqueness => true
 

data/app/models/calculator/flat_percent_item_total.rb

@@ -5,11 +5,6 @@ class Calculator::FlatPercentItemTotal < Calculator
     I18n.t("flat_percent")
   end
 
-  def self.register
-    super
-    ShippingMethod.register_calculator(self)
-  end
-
   def compute(object)
     return unless object.present? and object.line_items.present?
     item_total = object.line_items.map(&:amount).sum

data/app/models/calculator/flat_rate.rb

@@ -5,11 +5,6 @@ class Calculator::FlatRate < Calculator
     I18n.t("flat_rate_per_order")
   end
 
-  def self.register
-    super
-    ShippingMethod.register_calculator(self)
-  end
-
   def compute(object=nil)
     self.preferred_amount
   end

data/app/models/calculator/flexi_rate.rb

@@ -11,11 +11,6 @@ class Calculator::FlexiRate < Calculator
     true
   end
 
-  def self.register
-    super
-    ShippingMethod.register_calculator(self)
-  end
-
   def compute(object)
     sum = 0
     max = self.preferred_max_items

data/app/models/calculator/per_item.rb

@@ -5,11 +5,6 @@ class Calculator::PerItem < Calculator
     I18n.t("flat_rate_per_item")
   end
 
-  def self.register
-    super
-    ShippingMethod.register_calculator(self)
-  end
-
   def compute(object=nil)
     self.preferred_amount * object.line_items.length
   end

data/app/models/calculator/price_bucket.rb

@@ -7,12 +7,6 @@ class Calculator::PriceBucket < Calculator
     I18n.t("price_bucket")
   end
 
-  def self.register
-    super
-    #Promotion.register_calculator(self)
-    ShippingMethod.register_calculator(self)
-  end
-
   # as object we always get line items, as calculable we have Coupon, ShippingMethod
   def compute(object)
     if object.is_a?(Array)

data/app/models/calculator/sales_tax.rb

@@ -4,11 +4,6 @@ class Calculator::SalesTax < Calculator
     I18n.t("sales_tax")
   end
 
-  def self.register
-    super
-    TaxRate.register_calculator(self)
-  end
-
   def self.calculate_tax(order, rates)
     ActiveSupport::Deprecation.warn("please use Calculator::SalesTax#compute instead", caller)
 
@@ -45,4 +40,4 @@ class Calculator::SalesTax < Calculator
       sum += line_item.total * rate.amount
     }
   end
-end
+end

data/app/models/calculator/vat.rb

@@ -4,60 +4,39 @@ class Calculator::Vat < Calculator
     I18n.t("vat")
   end
 
-  def self.register
-    super
-    TaxRate.register_calculator(self)
+  def self.calculate_tax_on(taxable)
+    # taxable may be product or variant
+    taxable = taxable.product if taxable.respond_to?(:product)
+    (taxable.price * taxable.effective_tax_rate).round(2, BigDecimal::ROUND_HALF_UP)
   end
 
-  # list the vat rates for the default country
-  def self.default_rates
-    origin = Country.find(Spree::Config[:default_country_id])
-    calcs = Calculator::Vat.includes(:calculable => :zone).select {
-      |vat| vat.calculable.zone.country_list.include?(origin)
-    }
-    calcs.collect { |calc| calc.calculable }
-  end
+  # computes vat for line_items associated with order, and tax rate and
+  # now coupon discounts are taken into account in tax calcs
+  # and tax is added to shipment if :shipment_inc_vat is set
+  # coupons and shipment are applied if this object is the rate for the default category
+  #           (also items with no category get this rate applied)
+  def compute(order)
+    rate = self.calculable
+    tax = 0
 
-  def self.calculate_tax(order, rates=default_rates)
-    return 0 if rates.empty?
-    # note: there is a bug with associations in rails 2.1 model caching so we're using this hack
-    # (see http://rails.lighthouseapp.com/projects/8994/tickets/785-caching-models-fails-in-development)
-    cache_hack = rates.first.respond_to?(:tax_category_id)
+    if rate.tax_category.is_default
+      order.adjustments.each do | adjust |
+        next if adjust.originator_type == "TaxRate"
+        next if adjust.originator_type == "ShippingMethod" and not Spree::Config[:shipment_inc_vat]
 
-    taxable_totals = {}
-    order.line_items.each do |line_item|
-      next unless tax_category = line_item.variant.product.tax_category
-      next unless rate = rates.find { | vat_rate | vat_rate.tax_category_id == tax_category.id } if cache_hack
-      next unless rate = rates.find { | vat_rate | vat_rate.tax_category == tax_category } unless cache_hack
-      taxable_totals[tax_category] ||= 0
-      taxable_totals[tax_category] += line_item.price * rate.amount * line_item.quantity
+        tax += (adjust.amount * rate.amount).round(2, BigDecimal::ROUND_HALF_UP)
+      end
     end
 
-    return 0 if taxable_totals.empty?
-    tax = 0
-    taxable_totals.values.each do |total|
-      tax += total
+    order.line_items.each do  | line_item|
+      if line_item.product.tax_category  #only apply this calculator to products assigned this rates category
+        next unless line_item.product.tax_category == rate.tax_category
+      else
+        next unless rate.tax_category.is_default # and apply to products with no category, if this is the default rate
+      end
+      tax += (line_item.price * rate.amount).round(2, BigDecimal::ROUND_HALF_UP) * line_item.quantity
     end
-    tax
-  end
 
-  # TODO: Refactor this method after integrating #54 to use default address
-  def self.calculate_tax_on(product_or_variant)
-    vat_rates = default_rates
-
-    return 0 if vat_rates.nil?
-    return 0 unless tax_category = product_or_variant.is_a?(Product) ? product_or_variant.tax_category : product_or_variant.product.tax_category
-    return 0 unless rate = vat_rates.find { | vat_rate | vat_rate.tax_category_id == tax_category.id }
-
-    (product_or_variant.is_a?(Product) ? product_or_variant.price : product_or_variant.price) * rate.amount
-  end
-
-  # computes vat for line_items associated with order, and tax rate
-  def compute(order)
-    rate = self.calculable
-    line_items = order.line_items.select { |i| i.product.tax_category == rate.tax_category }
-    line_items.inject(0) {|sum, line_item|
-      sum += (line_item.price * rate.amount * line_item.quantity)
-    }
+    tax
   end
 end

data/app/models/calculator.rb

@@ -15,21 +15,19 @@ class Calculator < ActiveRecord::Base
 
   ###################################################################
 
-  @@calculators = Set.new
-  # Registers calculator to be used with selected kinds of operations
   def self.register(*klasses)
-    @@calculators.add(self)
-    klasses.each do |klass|
-      klass = klass.constantize if klass.is_a?(String)
-      klass.register_calculator(self)
-    end
-    self
+    # @@calculators.add(self)
+    # klasses.each do |klass|
+    #   klass = klass.constantize if klass.is_a?(String)
+    #   klass.register_calculator(self)
+    # end
+    # self
   end
 
   # Returns all calculators applicable for kind of work
   # If passed nil, will return only general calculators
   def self.calculators
-    @@calculators.to_a
+    Rails.application.config.spree.calculators.all
   end
 
   def to_s