spree_core 2.0.13 → 2.1.0

data/lib/spree/core/delegate_belongs_to.rb

@@ -37,8 +37,6 @@ module DelegateBelongsTo
       attrs = get_association_column_names(association) if attrs.empty?
       attrs.concat get_association_column_names(association) if attrs.delete :defaults
       attrs.each do |attr|
-        next if attribute_method?(attr)
-
         class_def attr do |*args|
           if args.empty?
             send(:delegator_for, association).send(attr)

data/lib/spree/core/engine.rb

@@ -86,11 +86,7 @@ module Spree
         ]
       end
 
-      # Promotion rules need to be evaluated on after initialize otherwise
-      # Spree.user_class would be nil and users might experience errors related
-      # to malformed model associations (Spree.user_class is only defined on
-      # the app initializer)
-      config.after_initialize do
+      initializer 'spree.promo.register.promotion.calculators' do
         Rails.application.config.spree.promotions.rules.concat [
           Spree::Promotion::Rules::ItemTotal,
           Spree::Promotion::Rules::Product,

data/lib/spree/core/ext/active_record.rb

@@ -2,14 +2,7 @@ module ActiveRecord::Persistence
 
   # Update attributes of a record in the database without callbacks, validations etc.
   def update_attributes_without_callbacks(attributes)
-    self.assign_attributes(attributes, :without_protection => true)
-    self.class.update_all(attributes, { :id => id })
+    self.assign_attributes(attributes)
+    self.class.where(:id => id).update_all(attributes)
   end
-
-  # Update a single attribute in the database
-  def update_attribute_without_callbacks(name, value)
-    send("#{name}=", value)
-    update_attributes_without_callbacks(name => value)
-  end
-
 end

data/lib/spree/core/permalinks.rb

@@ -37,10 +37,6 @@ module Spree
           permalink_options[:prefix] || ""
         end
 
-        def permalink_length
-          permalink_options[:length] || 9
-        end
-
         def permalink_order
           order = permalink_options[:order]
           "#{order} ASC," if order
@@ -48,7 +44,7 @@ module Spree
       end
 
       def generate_permalink
-        "#{self.class.permalink_prefix}#{Array.new(self.class.permalink_length){rand(9)}.join}"
+        "#{self.class.permalink_prefix}#{Array.new(9){rand(9)}.join}"
       end
 
       def save_permalink(permalink_value=self.to_param)

data/lib/spree/core/product_duplicator.rb

@@ -2,12 +2,8 @@ module Spree
   class ProductDuplicator
     attr_accessor :product
 
-    @@clone_images_default = true
-    mattr_accessor :clone_images_default
-
-    def initialize(product, include_images = @@clone_images_default)
+    def initialize(product)
       @product = product
-      @include_images = include_images
     end
 
     def duplicate
@@ -27,14 +23,12 @@ module Spree
     def duplicate_product
       product.dup.tap do |new_product|
         new_product.name = "COPY OF #{product.name}"
-        new_product.permalink = "copy-of-#{product.permalink}"
         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
-        new_product.variants = product.variants.map { |variant| duplicate_variant variant }
       end
     end
 
@@ -43,20 +37,12 @@ module Spree
       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 } if @include_images
+        new_master.images = master.images.map { |image| duplicate_image image }
         new_master.price = master.price
         new_master.currency = master.currency
       end
     end
 
-    def duplicate_variant(variant)
-      new_variant = variant.dup
-      new_variant.sku = "COPY OF #{new_variant.sku}"
-      new_variant.deleted_at = nil
-      new_variant.option_values = variant.option_values.map { |option_value| option_value}
-      new_variant
-    end
-
     def duplicate_image(image)
       new_image = image.dup
       new_image.assign_attributes(:attachment => image.attachment.clone)

data/lib/spree/core/product_filters.rb

@@ -57,12 +57,12 @@ module Spree
       # 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?}
+        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)
+        Spree::Product.joins(master: :default_price).where(scope)
       end
 
       def ProductFilters.format_price(amount)
@@ -71,15 +71,16 @@ module Spree
 
       def ProductFilters.price_filter
         v = Spree::Price.arel_table
-        conds = [ [ Spree.t(:under_price, :price => format_price(10))   , v[:amount].lteq(10)],
+        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]}
+                  [ 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
 
@@ -98,23 +99,24 @@ module Spree
       #   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?}
+          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)
+          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)
+          brand_property = Spree::Property.find_by(name: 'brand')
+          brands = brand_property ? Spree::ProductProperty.where(property_id: brand_property.id).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] }
+          {
+            name:   'Brands',
+            scope:  :brand_any,
+            conds:  conds,
+            labels: (brands.sort).map { |k| [k, k] }
           }
         end
       end
@@ -145,16 +147,16 @@ module Spree
 
         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
+          brand_property = Spree::Property.find_by(name: 'brand')
+          scope = Spree::ProductProperty.where(property: 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] }
+            name:   'Applicable Brands',
+            scope:  :selective_brand_any,
+            labels: brands.sort.map { |k| [k, k] }
           }
         end
       end
@@ -173,10 +175,11 @@ module Spree
       #
       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
+        {
+          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
 
@@ -187,11 +190,12 @@ module Spree
       #
       # 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
+        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

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

@@ -46,7 +46,7 @@ module Spree
               if base_scope.respond_to?(:search_scopes) && base_scope.search_scopes.include?(scope_name.to_sym)
                 base_scope = base_scope.send(scope_name, *scope_attribute)
               else
-                base_scope = base_scope.merge(Spree::Product.search({scope_name => scope_attribute}).result)
+                base_scope = base_scope.merge(Spree::Product.ransack({scope_name => scope_attribute}).result)
               end
             end if search
             base_scope

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
   def self.version
-    '2.0.13'
+    "2.1.0"
   end
 end

data/lib/spree/core.rb

@@ -5,7 +5,6 @@ require 'awesome_nested_set'
 require 'cancan'
 require 'kaminari'
 require 'mail'
-require 'monetize'
 require 'paperclip'
 require 'paranoia'
 require 'ransack'
@@ -17,9 +16,9 @@ module Spree
 
   def self.user_class
     if @@user_class.is_a?(Class)
-      raise "Spree.user_class MUST be a String or Symbol object, not a Class object."
-    elsif @@user_class.is_a?(String) || @@user_class.is_a?(Symbol)
-      @@user_class.to_s.constantize
+      raise "Spree.user_class MUST be a String object, not a Class object."
+    elsif @@user_class.is_a?(String)
+      @@user_class.constantize
     end
   end
 
@@ -55,30 +54,3 @@ require 'spree/core/product_duplicator'
 ActiveRecord::Base.class_eval do
   include CollectiveIdea::Acts::NestedSet
 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

@@ -4,7 +4,6 @@ require 'spree/i18n/base'
 
 module Spree
   extend ActionView::Helpers::TranslationHelper
-  extend ActionView::Helpers::TagHelper
 
   class << self
     # Add spree namespace and delegate to Rails TranslationHelper for some nice

data/lib/spree/money.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'money'
 
 module Spree
@@ -9,187 +7,18 @@ module Spree
     delegate :cents, :to => :money
 
     def initialize(amount, options={})
-      @money = self.class.parse([amount, (options[:currency] || Spree::Config[:currency])].join)
+      @money = ::Money.parse([amount, (options[:currency] || Spree::Config[:currency])].join)
       @options = {}
       @options[:with_currency] = Spree::Config[:display_currency]
       @options[:symbol_position] = Spree::Config[:currency_symbol_position].to_sym
       @options[:no_cents] = Spree::Config[:hide_cents]
       @options[:decimal_mark] = Spree::Config[:currency_decimal_mark]
       @options[:thousands_separator] = Spree::Config[:currency_thousands_separator]
-      @options[:sign_before_symbol] = Spree::Config[:currency_sign_before_symbol]
       @options.merge!(options)
       # Must be a symbol because the Money gem doesn't do the conversion
       @options[:symbol_position] = @options[:symbol_position].to_sym
     end
 
-    # This method is being deprecated in Money 6.1.0, so now lives here.
-    def self.parse(input, currency = nil)
-      i = input.to_s.strip
-
-      # raise Money::Currency.table.collect{|c| c[1][:symbol]}.inspect
-
-      # Check the first character for a currency symbol, alternatively get it
-      # from the stated currency string
-      c = if ::Monetize.assume_from_symbol && i =~ /^(\$|€|£)/
-        case i
-        when /^\$/ then "USD"
-        when /^€/ then "EUR"
-        when /^£/ then "GBP"
-        end
-      else
-        i[/[A-Z]{2,3}/]
-      end
-
-      # check that currency passed and embedded currency are the same,
-      # and negotiate the final currency
-      if currency.nil? and c.nil?
-        currency = ::Money.default_currency
-      elsif currency.nil?
-        currency = c
-      elsif c.nil?
-        currency = currency
-      elsif currency != c
-        # TODO: ParseError
-        raise ArgumentError, "Mismatching Currencies"
-      end
-      currency = ::Money::Currency.wrap(currency)
-
-      fractional = extract_cents(i, currency)
-      ::Money.new(fractional, currency)
-    end
-
-    # This method is being deprecated in Money 6.1.0, so now lives here.
-    def self.extract_cents(input, currency = Money.default_currency)
-      # remove anything that's not a number, potential thousands_separator, or minus sign
-      num = input.gsub(/[^\d.,'-]/, '')
-
-      # set a boolean flag for if the number is negative or not
-      negative = num =~ /^-|-$/ ? true : false
-
-      # decimal mark character
-      decimal_char = currency.decimal_mark
-
-      # if negative, remove the minus sign from the number
-      # if it's not negative, the hyphen makes the value invalid
-      if negative
-        num = num.sub(/^-|-$/, '')
-      end
-
-      raise ArgumentError, "Invalid currency amount (hyphen)" if num.include?('-')
-
-      #if the number ends with punctuation, just throw it out.  If it means decimal,
-      #it won't hurt anything.  If it means a literal period or comma, this will
-      #save it from being mis-interpreted as a decimal.
-      num.chop! if num.match(/[\.|,]$/)
-
-      # gather all decimal_marks within the result number
-      used_delimiters = num.scan(/[^\d]/)
-
-      # determine the number of unique decimal_marks within the number
-      #
-      # e.g.
-      # $1,234,567.89 would return 2 (, and .)
-      # $125,00 would return 1
-      # $199 would return 0
-      # $1 234,567.89 would raise an error (decimal_marks are space, comma, and period)
-      case used_delimiters.uniq.length
-        # no decimal_mark or thousands_separator; major (dollars) is the number, and minor (cents) is 0
-      when 0 then major, minor = num, 0
-
-        # two decimal_marks, so we know the last item in this array is the
-        # major/minor thousands_separator and the rest are decimal_marks
-      when 2
-        thousands_separator, decimal_mark = used_delimiters.uniq
-
-        # remove all thousands_separator, split on the decimal_mark
-        major, minor = num.gsub(thousands_separator, '').split(decimal_mark)
-        min = 0 unless min
-      when 1
-        # we can't determine if the comma or period is supposed to be a decimal_mark or a thousands_separator
-        # e.g.
-        # 1,00 - comma is a thousands_separator
-        # 1.000 - period is a thousands_separator
-        # 1,000 - comma is a decimal_mark
-        # 1,000,000 - comma is a decimal_mark
-        # 10000,00 - comma is a thousands_separator
-        # 1000,000 - comma is a thousands_separator
-
-        # assign first decimal_mark for reusability
-        decimal_mark = used_delimiters.first
-
-        # When we have identified the decimal mark character
-        if decimal_char == decimal_mark
-          major, minor = num.split(decimal_char)
-
-        else
-          # decimal_mark is used as a decimal_mark when there are multiple instances, always
-          if num.scan(decimal_mark).length > 1 # multiple matches; treat as decimal_mark
-            major, minor = num.gsub(decimal_mark, ''), 0
-          else
-            # ex: 1,000 - 1.0000 - 10001.000
-            # split number into possible major (dollars) and minor (cents) values
-            possible_major, possible_minor = num.split(decimal_mark)
-            possible_major ||= "0"
-            possible_minor ||= "00"
-
-            # if the minor (cents) length isn't 3, assign major/minor from the possibles
-            # e.g.
-            #   1,00 => 1.00
-            #   1.0000 => 1.00
-            #   1.2 => 1.20
-            if possible_minor.length != 3 # thousands_separator
-              major, minor = possible_major, possible_minor
-            else
-              # minor length is three
-              # let's try to figure out intent of the thousands_separator
-
-              # the major length is greater than three, which means
-              # the comma or period is used as a thousands_separator
-              # e.g.
-              #   1000,000
-              #   100000,000
-              if possible_major.length > 3
-                major, minor = possible_major, possible_minor
-              else
-                # number is in format ###{sep}### or ##{sep}### or #{sep}###
-                # handle as , is sep, . is thousands_separator
-                if decimal_mark == '.'
-                  major, minor = possible_major, possible_minor
-                else
-                  major, minor = "#{possible_major}#{possible_minor}", 0
-                end
-              end
-            end
-          end
-        end
-      else
-        # TODO: ParseError
-        raise ArgumentError, "Invalid currency amount"
-      end
-
-      # build the string based on major/minor since decimal_mark/thousands_separator have been removed
-      # avoiding floating point arithmetic here to ensure accuracy
-      cents = (major.to_i * currency.subunit_to_unit)
-      # Because of an bug in JRuby, we can't just call #floor
-      minor = minor.to_s
-      minor = if minor.size < currency.decimal_places
-                (minor + ("0" * currency.decimal_places))[0,currency.decimal_places].to_i
-              elsif minor.size > currency.decimal_places
-                if minor[currency.decimal_places,1].to_i >= 5
-                  minor[0,currency.decimal_places].to_i+1
-                else
-                  minor[0,currency.decimal_places].to_i
-                end
-              else
-                minor.to_i
-              end
-
-      cents += minor
-
-      # if negative, multiply by -1; otherwise, return positive cents
-      negative ? cents * -1 : cents
-    end
-
     def to_s
       @money.format(@options)
     end
@@ -199,15 +28,11 @@ module Spree
       if options[:html]
         # 1) prevent blank, breaking spaces
         # 2) prevent escaping of HTML character entities
-        output = output.sub(" ", "&nbsp;").html_safe
+        output = output.gsub(" ", "&nbsp;").html_safe
       end
       output
     end
 
-    def as_json(*)
-      to_s
-    end
-
     def ==(obj)
       @money == obj.money
     end

data/lib/spree/permitted_attributes.rb

@@ -0,0 +1,95 @@
+module Spree
+  module PermittedAttributes
+    ATTRIBUTES = [
+      :address_attributes,
+      :checkout_attributes,
+      :image_attributes,
+      :inventory_unit_attributes,
+      :line_item_attributes,
+      :option_type_attributes,
+      :option_value_attributes,
+      :payment_attributes,
+      :product_attributes,
+      :product_properties_attributes,
+      :property_attributes,
+      :return_authorization_attributes,
+      :shipment_attributes,
+      :source_attributes,
+      :stock_item_attributes,
+      :stock_location_attributes,
+      :stock_movement_attributes,
+      :taxon_attributes,
+      :taxonomy_attributes,
+      :user_attributes,
+      :variant_attributes
+    ]
+
+    mattr_reader *ATTRIBUTES
+
+    @@address_attributes = [
+      :firstname, :lastname, :address1, :address2,
+      :city, :country_id, :state_id, :zipcode, :phone,
+      :state_name, :alternative_phone, :company]
+
+    @@checkout_attributes = [:email, :use_billing, :shipping_method_id, :coupon_code]
+
+    @@image_attributes = [:alt, :attachment, :position, :viewable_type, :viewable_id]
+
+    @@inventory_unit_attributes = [:shipment, :variant_id]
+
+    @@line_item_attributes = [:id, :variant_id, :quantity]
+
+    @@option_type_attributes = [:name, :presentation, :option_values_attributes]
+
+    @@option_value_attributes = [:name, :presentation]
+
+    @@payment_attributes = [:amount, :payment_method_id]
+
+    @@product_properties_attributes = [:property_name, :value, :position]
+
+    @@product_attributes = [
+      :name, :description, :available_on, :permalink, :meta_description,
+      :meta_keywords, :price, :sku, :deleted_at, :prototype_id,
+      :option_values_hash, :weight, :height, :width, :depth,
+      :shipping_category_id, :tax_category_id, :product_properties_attributes,
+      :variants_attributes, :taxon_ids, :option_type_ids, :cost_currency, :cost_price]
+
+    @@property_attributes = [:name, :presentation]
+
+    @@return_authorization_attributes = [:amount, :reason, :stock_location_id]
+
+    @@shipment_attributes = [
+      :order, :special_instructions, :stock_location_id, :id,
+      :tracking, :address, :inventory_units, :selected_shipping_rate_id]
+
+    # month / year may be provided by some sources, or others may elect to use one field
+    @@source_attributes = [
+      :number, :month, :year, :expiry, :verification_value,
+      :first_name, :last_name, :cc_type]
+
+    @@stock_item_attributes = [:variant, :stock_location, :backorderable, :variant_id]
+
+    @@stock_location_attributes = [
+      :name, :active, :address1, :address2, :city, :zipcode,
+      :backorderable_default, :state_name, :state_id, :country_id, :phone,
+      :propagate_all_variants]
+
+    @@stock_movement_attributes = [
+      :quantity, :stock_item, :stock_item_id, :originator, :action]
+
+    @@taxonomy_attributes = [:name]
+
+    @@taxon_attributes = [
+      :name, :parent_id, :position, :icon, :description, :permalink, :taxonomy_id,
+      :meta_description, :meta_keywords, :meta_title]
+
+    # TODO Should probably use something like Spree.user_class.attributes
+    @@user_attributes = [:email, :password, :password_confirmation]
+
+    @@variant_attributes = [
+      :name, :presentation, :cost_price, :lock_version,
+      :position, :option_value_ids,
+      :product_id, :option_values_attributes, :price,
+      :weight, :height, :width, :depth, :sku, :cost_currency]
+  end
+end

data/lib/spree/promo/coupon_applicator.rb

@@ -13,7 +13,7 @@ module Spree
           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)
+            promotion = Spree::Promotion.find_by(code: @order.coupon_code)
             if promotion.present?
               handle_present_promotion(promotion)
             else
@@ -32,17 +32,9 @@ module Spree
         return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded?
 
         event_name = "spree.checkout.coupon_code_added"
-        if promotion.activate(:coupon_code => @order.coupon_code, :order => @order)
-          promo = @order.adjustments.includes(:originator).promotion.detect { |p| p.originator.promotion.code == @order.coupon_code }
-          if promo.present?
-            determine_promotion_application_result(promo)
-          else
-            # if action is create line items
-            return { :coupon_applied? => true, :success =>  Spree.t(:coupon_code_applied) }
-          end
-        else
-          return { :coupon_applied? => false, :error =>  Spree.t(:coupon_code_not_eligible) }
-        end
+        promotion.activate(:coupon_code => @order.coupon_code, :order => @order)
+        promo = @order.adjustments.includes(:originator).promotion.detect { |p| p.originator.promotion.code == @order.coupon_code }
+        determine_promotion_application_result(promo)
       end
 
       def promotion_expired