spree 0.8.5 → 0.9.0

data/app/helpers/application_helper.rb

@@ -17,5 +17,4 @@ module ApplicationHelper
   def flag_image(code)
     "#{code.to_s.split("-").last.downcase}.png"
   end                      
-
-end
+end

data/app/helpers/checkouts_helper.rb

@@ -0,0 +1,7 @@
+module CheckoutsHelper
+  def checkout_steps                                                      
+    checkout_steps = %w{registration billing shipping shipping_method payment confirmation}
+    checkout_steps.delete "registration" if current_user
+    checkout_steps
+  end
+end

data/app/helpers/products_helper.rb

@@ -1,18 +1,8 @@
 module ProductsHelper
-  # returns the price of the product to show for display purposes
-  def product_price(product_or_variant, options={})
-    options.assert_valid_keys(:format_as_currency)
-    options.reverse_merge! :format_as_currency => true
-    
-    amount = product_or_variant.is_a?(Product) ? product_or_variant.master_price : product_or_variant.price
-
-    options[:format_as_currency] ? format_price(amount, options) : amount
-  end
-  
   # returns the formatted change in price (from the master price) for the specified variant (or simply return 
   # the variant price if no master price was supplied)
   def variant_price_diff(variant)
-    return product_price(variant) unless variant.product.master_price
+    return product_price(variant) unless variant.product.master.price
     diff = product_price(variant, :format_as_currency => false) - product_price(variant.product, :format_as_currency => false)
     return nil if diff == 0
     if diff > 0
@@ -22,12 +12,22 @@ module ProductsHelper
     end
   end
   
-  def format_price(price)      
-    # Don't be fooled - default implementation uses number_to_currency but other extensions may patch into this.  It is
-    # suggested that you leave your format_price calls alone.
-    number_to_currency(price)
+  # returns the price of the product to show for display purposes
+  def product_price(product_or_variant, options={})
+    options.assert_valid_keys(:format_as_currency, :show_vat_text)
+    options.reverse_merge! :format_as_currency => true, :show_vat_text => Spree::Config[:show_price_inc_vat]
+
+    amount = product_or_variant.price
+    amount += Calculator::Vat.calculate_tax_on(product_or_variant) if Spree::Config[:show_price_inc_vat]
+    options.delete(:format_as_currency) ? format_price(amount, options) : ("%0.2f" % amount).to_f
   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]
+    options[:show_vat_text]  ?  number_to_currency(price) + ' (inc. VAT)' : number_to_currency(price)
+  end
+    
   # converts line breaks in product description into <p> tags (for html display purposes)
   def product_description(product)
     product.description.gsub(/^(.*)$/, '<p>\1</p>')

data/app/helpers/spree/base_helper.rb

@@ -31,10 +31,10 @@ module Spree::BaseHelper
     options.reverse_merge! :format_as_currency => true, :show_vat_text => true
     
     # overwrite show_vat_text if show_price_inc_vat is false
-    options[:show_vat_text] = Spree::Tax::Config[:show_price_inc_vat]
+    options[:show_vat_text] = Spree::Config[:show_price_inc_vat]
 
-    amount =  order.item_total    
-    amount += Spree::VatCalculator.calculate_tax(order) if Spree::Tax::Config[:show_price_inc_vat]    
+    amount =  order.item_total   
+    amount += Calculator::Vat.calculate_tax(order) if Spree::Config[:show_price_inc_vat]
 
     options.delete(:format_as_currency) ? number_to_currency(amount) : amount
   end
@@ -68,8 +68,8 @@ module Spree::BaseHelper
 
   # human readable list of variant options
   def variant_options(v, allow_back_orders = Spree::Config[:allow_backorders], include_style = true)
-    list = v.option_values.map { |ov| "#{ov.option_type.presentation}: #{ov.presentation}" }.to_sentence({:words_connector => ", ", :two_words_connector => ", "})
-    list = include_style ? "<span class =\"out-of-stock\">(" + t("out_of_stock") + ") #{list}</span>" : "#{t("out_of_stock")} #{list}" unless (v.in_stock or allow_back_orders)
+    list = v.options_text
+    list = include_style ? "<span class =\"out-of-stock\">(" + t("out_of_stock") + ") #{list}</span>" : "#{t("out_of_stock")} #{list}" unless (v.in_stock? or allow_back_orders)
     list
   end  
   
@@ -108,5 +108,27 @@ module Spree::BaseHelper
       end
     end
   end
+
+  def stylesheet_tags(paths=stylesheet_paths)
+    output = ''
+    if !paths.blank?
+      paths.each do |path|
+        output << stylesheet_link_tag(path)
+      end
+    end
+    return output
+  end
   
+  def stylesheet_paths
+    paths = Spree::Config[:stylesheets]
+    if (paths.blank?)
+      []
+    else
+      paths.split(',')
+    end
+  end
+
+  def logo(image_path=Spree::Config[:logo])
+    link_to image_tag(image_path), root_path
+  end
 end

data/app/helpers/taxons_helper.rb

@@ -1,7 +1,7 @@
 module TaxonsHelper
   def breadcrumbs(taxon, separator=" » ")
     return "" if current_page?("/")
-    crumbs = [content_tag(:li, link_to("Home" , root_path) + 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.reverse.collect { |ancestor| content_tag(:li, link_to(ancestor.name , seo_url(ancestor)) + separator) } unless taxon.ancestors.empty?
@@ -17,15 +17,15 @@ module TaxonsHelper
   # 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.) 
-  def taxon_preview(taxon)
-    products = taxon.products.active[0..4]
-    return products unless products.size < 5
-    if Spree::Config[:show_descendents]
+  def taxon_preview(taxon, max=5)
+    products = taxon.products.active.find(:all, :limit => max)
+    if (products.size < max) && Spree::Config[:show_descendents]
       taxon.descendents.each do |taxon|
-        products += taxon.products.active[0..4]
-        break if products.size >= 5
+        to_get = max - products.length
+        products += taxon.products.active.find(:all, :limit => to_get)
+        break if products.size >= max
       end
     end
-    products[0..4]
+    products
   end
-end
+end

data/app/metal/create_admin_user.rb

@@ -0,0 +1,21 @@
+# Allow the metal piece to run in isolation
+require(File.dirname(__FILE__) + "/../../config/environment") unless defined?(Rails)
+
+# note: we're not returning 404 in the usuaul sense - it actually just tells rails to continue metal chain
+class CreateAdminUser  
+  
+  def self.call(env)                
+    if env["PATH_INFO"] =~ /^\/users/ or @admin_defined or not User.table_exists?
+      @status = [404, {"Content-Type" => "text/html"}, "Not Found"]
+    else
+      @admin_defined = User.first(:include => :roles, :conditions => ["roles.name = 'admin'"])
+      @status = [404, {"Content-Type" => "text/html"}, "Not Found"] if @admin_defined
+    end
+    # redirect to user creation screen
+    return @status || [302, {'Location'=> '/users/new' }, []]
+  ensure
+    # Release the connections back to the pool.
+    ActiveRecord::Base.clear_active_connections!
+  end
+  
+end

data/app/models/address.rb

@@ -2,16 +2,38 @@ class Address < ActiveRecord::Base
   belongs_to :country
   belongs_to :state
   
+  has_many :checkouts, :foreign_key => "bill_address_id"
+  has_many :shipments
+
   validates_presence_of :firstname
   validates_presence_of :lastname
   validates_presence_of :address1
   validates_presence_of :city
-  validates_presence_of :state, :unless => Proc.new { |address| address.country && address.country.states.length==0 }
-  validates_presence_of :state_name, :if => Proc.new { |address| address.country &&  address.country.states.length==0 }
+  validates_presence_of :state, :if => Proc.new { |address| address.state_name.blank? && Spree::Config[:address_requires_state] }
+  validates_presence_of :state_name, :if => Proc.new { |address| address.state.blank? && Spree::Config[:address_requires_state] }
   validates_presence_of :zipcode
   validates_presence_of :country
   validates_presence_of :phone
 
+  # disconnected since there's no code to display error messages yet OR matching client-side validation
+  def phone_validate
+    return if phone.blank?
+    n_digits = phone.scan(/[0-9]/).size
+    valid_chars = (phone =~ /^[-+()\/\s\d]+$/)
+    if !(n_digits > 5 && valid_chars)
+      errors.add(:phone, "is invalid")
+    end
+  end
+
+  def self.default
+    new :country => Country.find(Spree::Config[:default_country_id])
+  end
+
+  # can modify an address if it's not been used in an order (but checkouts controller has finer control)
+  def editable?
+    new_record? || (shipments.empty? && checkouts.empty?)
+  end
+
   def full_name
     self.firstname + " " + self.lastname
   end
@@ -19,4 +41,22 @@ class Address < ActiveRecord::Base
   def state_text
     state.nil? ? state_name : (state.abbr.blank? ? state.name : state.abbr)
   end
+
+  def zone
+    (state && state.zone) ||
+    (country && country.zone)
+  end
+
+  def zones
+    Zone.match(self)
+  end
+
+  def same_as?(other)
+    attributes.except("id", "updated_at", "created_at") ==  other.attributes.except("id", "updated_at", "created_at")
+  end
+  alias same_as same_as?
+
+  def to_s
+    "#{full_name}: #{address1}"
+  end
 end

data/app/models/adjustment.rb

@@ -0,0 +1,37 @@
+class Adjustment < ActiveRecord::Base
+  acts_as_list :scope => :order
+  
+  belongs_to :order
+  belongs_to :adjustment_source, :polymorphic => true
+
+  validates_presence_of :amount
+  validates_presence_of :description
+  validates_numericality_of :amount
+
+  before_save do |record|
+    new_amount = record.calculate_adjustment
+    record.amount = new_amount if new_amount
+    record.secondary_type ||= record.type
+  end
+
+  def calculate_adjustment
+    if adjustment_source
+      calc = adjustment_source.calculator || adjustment_source.default_calculator
+      raise(RuntimeError, "#{self.class.name}##{id} doesn't have a calculator") unless calc
+      calc.compute(adjustment_source)
+    elsif read_attribute(:amount)
+      read_attribute(:amount)
+    else
+      nil
+    end
+  end
+
+  def amount
+    read_attribute(:amount) || self.calculate_adjustment
+  end
+  
+  def update_amount
+    new_amount = calculate_adjustment
+    update_attribute(:amount, new_amount) if new_amount
+  end
+end

data/app/models/app_configuration.rb

@@ -30,12 +30,21 @@ class AppConfiguration < Configuration
   preference :admin_products_per_page, :integer, :default => 10 
   preference :products_per_page, :integer, :default => 10
   preference :default_tax_category, :string, :default => nil # Use the name (exact case) of the tax category if you wish to specify
+  preference :logo, :string, :default => '/images/admin/bg/spree_50.png'
+  preference :stylesheets, :string, :default => 'compiled/screen' # Comma separate multiple stylesheets, e.g. 'compiled/screen,compiled/site'
   preference :admin_interface_logo, :string, :default => "spree/spree.jpg"
   preference :allow_ssl_in_production, :boolean, :default => true
   preference :allow_ssl_in_development_and_test, :boolean, :default => false
   preference :google_analytics_id, :string, :default => '12312312' # Replace with real Google Analytics Id 
   preference :allow_guest_checkout, :boolean, :default => true 
-
+  preference :alternative_billing_phone,  :boolean, :default => false # Request extra phone for bill addr
+  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 :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 :use_mail_queue, :boolean, :default => false #send mail immediately or use a mail queue. 
   validates_presence_of :name
   validates_uniqueness_of :name
+  
 end

data/app/models/calculator.rb

@@ -0,0 +1,41 @@
+class Calculator < ActiveRecord::Base  
+  belongs_to :calculable, :polymorphic => true
+
+  # This method must be overriden in concrete calculator.
+  #
+  # It should return amount computed based on #calculable and/or optional parameter
+  def compute(something=nil)
+    raise(NotImplementedError, "please use concrete calculator")
+  end
+
+  # overwrite to provide description for your calculators
+  def self.description
+    "Base Caclulator"
+  end
+
+  ###################################################################
+
+  @@calculators = Set.new
+  # Registers calculator to be used with selected kinds of operations
+  def self.register
+    @@calculators.add(self)
+  end
+
+  # Returns all calculators applicable for kind of work
+  # If passed nil, will return only general calculators
+  def self.calculators
+    @@calculators.to_a
+  end
+
+  def to_s
+    self.class.name.titleize.gsub("Calculator\/", "")
+  end
+
+  def description
+    self.class.description
+  end
+
+  def available?(object)
+    self.class.available?(object)
+  end
+end

data/app/models/calculator/flat_percent_item_total.rb

@@ -0,0 +1,19 @@
+class Calculator::FlatPercentItemTotal < Calculator
+  preference :flat_percent, :decimal, :default => 0
+
+  def self.description
+    I18n.t("flat_percent")
+  end
+
+  def self.register
+    super                                
+    Coupon.register_calculator(self)
+    ShippingMethod.register_calculator(self)
+    ShippingRate.register_calculator(self)
+  end
+  
+  def compute(order)
+    return if order.nil?
+    order.item_total * self.preferred_flat_percent / 100.0
+  end  
+end

data/app/models/calculator/flat_rate.rb

@@ -0,0 +1,18 @@
+class Calculator::FlatRate < Calculator
+  preference :amount, :decimal, :default => 0
+
+  def self.description
+    I18n.t("flat_rate_per_order")
+  end
+
+  def self.register
+    super                                
+    Coupon.register_calculator(self)
+    ShippingMethod.register_calculator(self)
+    ShippingRate.register_calculator(self)
+  end  
+  
+  def compute(object=nil)
+    self.preferred_amount
+  end  
+end

data/app/models/calculator/flexi_rate.rb

@@ -0,0 +1,33 @@
+class Calculator::FlexiRate < Calculator
+  preference :first_item,      :decimal, :default => 0
+  preference :additional_item, :decimal, :default => 0
+  preference :max_items,       :decimal, :default => 0
+
+  def self.description
+    I18n.t("flexible_rate")
+  end
+
+  def self.available?(object)
+    true
+  end
+
+  def self.register
+    super
+    Coupon.register_calculator(self)
+    ShippingMethod.register_calculator(self)
+    ShippingRate.register_calculator(self)
+  end
+
+  def compute(object)
+    sum = 0
+    max = self.preferred_max_items
+    object.length.times do |i|
+      if (i % max == 0) && (max > 0)
+        sum += self.preferred_first_item
+      else
+        sum += self.preferred_additional_item
+      end
+    end
+    return(sum)
+  end  
+end

data/app/models/calculator/per_item.rb

@@ -0,0 +1,18 @@
+class Calculator::PerItem < Calculator
+  preference :amount, :decimal, :default => 0
+
+  def self.description
+    I18n.t("flat_rate_per_item")
+  end
+
+  def self.register
+    super                                
+    Coupon.register_calculator(self)
+    ShippingMethod.register_calculator(self)
+    ShippingRate.register_calculator(self)
+  end
+
+  def compute(object=nil)
+    self.preferred_amount * object.length
+  end  
+end

data/app/models/calculator/price_bucket.rb

@@ -0,0 +1,31 @@
+class Calculator::PriceBucket < Calculator
+  preference :minimal_amount, :decimal, :default => 0
+  preference :normal_amount, :decimal, :default => 0
+  preference :discount_amount, :decimal, :default => 0
+
+  def self.description
+    I18n.t("price_bucket")
+  end
+
+  def self.register
+    super                                
+    Coupon.register_calculator(self)
+    ShippingMethod.register_calculator(self)
+    ShippingRate.register_calculator(self)
+  end
+
+  # as object we always get line items, as calculable we have Coupon, ShippingMethod or ShippingRate
+  def compute(object)
+    if object.is_a?(Array)
+      base = object.map{ |o| o.respond_to?(:amount) ? o.amount : o.to_d }.sum
+    else
+      base = object.respond_to?(:amount) ? object.amount : object.to_d
+    end
+
+    if base >= self.preferred_minimal_amount
+      self.preferred_normal_amount
+    else
+      self.preferred_discount_amount
+    end
+  end  
+end