spree_core 2.2.14 → 2.3.0

data/lib/spree/core/controller_helpers/store.rb

@@ -0,0 +1,19 @@
+module Spree
+  module Core
+    module ControllerHelpers
+      module Store
+        extend ActiveSupport::Concern
+
+        included do
+
+          def current_store
+            @current_store ||= Spree::Store.current(request.env['SERVER_NAME'])
+          end
+          helper_method :current_store
+
+        end
+
+      end
+    end
+  end
+end

data/lib/spree/core/delegate_belongs_to.rb

@@ -4,8 +4,8 @@
 #
 # Todo - integrate with ActiveRecord::Dirty to make sure changes to delegate object are noticed
 # Should do
-# class User < ActiveRecord::Base; delegate_belongs_to :contact, :firstname; end
-# class Contact < ActiveRecord::Base; end
+# class User < Spree::Base; delegate_belongs_to :contact, :firstname; end
+# class Contact < Spree::Base; end
 # u = User.first
 # u.changed? # => false
 # u.firstname = 'Bobby'

data/lib/spree/core/engine.rb

@@ -9,10 +9,6 @@ module Spree
         Spree::Config = app.config.spree.preferences #legacy access
       end
 
-      initializer "spree.load_preferences", :before => "spree.environment" do
-        ::ActiveRecord::Base.send :include, Spree::Preferences::Preferable
-      end
-
       initializer "spree.register.calculators" do |app|
         app.config.spree.calculators.shipping_methods = [
             Spree::Calculator::Shipping::FlatPercentItemTotal,
@@ -39,12 +35,6 @@ module Spree
             Spree::PaymentMethod::Check ]
       end
 
-      initializer "spree.mail.settings" do |app|
-        ActionMailer::Base.add_delivery_method :spree, Spree::Core::MailMethod
-        Spree::Core::MailSettings.init
-        Mail.register_interceptor(Spree::Core::MailInterceptor)
-      end
-
       # We need to define promotions rules here so extensions and existing apps
       # can add their custom classes on their initializer files
       initializer 'spree.promo.environment' do |app|

data/lib/spree/core/importer.rb

@@ -6,3 +6,4 @@ module Spree
 end
 
 require 'spree/core/importer/order'
+require 'spree/core/importer/product'

data/lib/spree/core/importer/order.rb

@@ -13,34 +13,20 @@ module Spree
             order = Spree::Order.create!
             order.associate_user!(user)
 
-            shipments_attrs = params.delete(:shipments_attributes)
-
-            create_shipments_from_params(shipments_attrs, order)
+            create_shipments_from_params(params.delete(:shipments_attributes), order)
             create_line_items_from_params(params.delete(:line_items_attributes),order)
             create_adjustments_from_params(params.delete(:adjustments_attributes), order)
             create_payments_from_params(params.delete(:payments_attributes), order)
 
-            if completed_at = params.delete(:completed_at)
+            if(completed_at = params.delete(:completed_at))
               order.completed_at = completed_at
               order.state = 'complete'
             end
 
-            user_id = params.delete(:user_id)
-            if user.has_spree_role? "admin"
-              order.user_id = user_id
-            end
-
             order.update_attributes!(params)
-
-            order.create_proposed_shipments unless shipments_attrs.present?
-
-            # Really ensure that the order totals & states are correct
-            order.updater.update
-            if shipments_attrs.present?
-              order.shipments.each_with_index do |shipment, index|
-                shipment.update_columns(cost: shipments_attrs[index][:cost].to_f) if shipments_attrs[index][:cost].present?
-              end
-            end
+            # Really ensure that the order totals are correct
+            order.update_totals
+            order.persist_totals
             order.reload
           rescue Exception => e
             order.destroy if order && order.persisted?
@@ -53,13 +39,8 @@ module Spree
           shipments_hash.each do |s|
             begin
               shipment = order.shipments.build
-              shipment.tracking       = s[:tracking]
-              shipment.stock_location = Spree::StockLocation.find_by_admin_name(s[:stock_location]) || Spree::StockLocation.find_by_name!(s[:stock_location])
-
-              if s[:shipped_at].present?
-                shipment.shipped_at = s[:shipped_at]
-                shipment.state      = 'shipped'
-              end
+              shipment.tracking = s[:tracking]
+              shipment.stock_location = Spree::StockLocation.find_by_name!(s[:stock_location])
 
               inventory_units = s[:inventory_units] || []
               inventory_units.each do |iu|
@@ -76,7 +57,6 @@ module Spree
               rate = shipment.shipping_rates.create!(:shipping_method => shipping_method,
                                                      :cost => s[:cost])
               shipment.selected_shipping_rate_id = rate.id
-              shipment.update_amounts
 
             rescue Exception => e
               raise "Order import shipments: #{e.message} #{s}"
@@ -88,15 +68,12 @@ module Spree
           return {} unless line_items_hash
           line_items_hash.each_key do |k|
             begin
-              extra_params = line_items_hash[k].except(:variant_id, :quantity, :sku)
-              line_item = ensure_variant_id_from_params(line_items_hash[k])
+              line_item = line_items_hash[k]
+              ensure_variant_id_from_params(line_item)
+
+              extra_params = line_item.except(:variant_id, :quantity)
               line_item = order.contents.add(Spree::Variant.find(line_item[:variant_id]), line_item[:quantity])
-              # Raise any errors with saving to prevent import succeeding with line items failing silently.
-              if extra_params.present?
-                line_item.update_attributes!(extra_params)
-              else
-                line_item.save!
-              end
+              line_item.update_attributes(extra_params) unless extra_params.empty?
             rescue Exception => e
               raise "Order import line items: #{e.message} #{line_item}"
             end
@@ -121,11 +98,9 @@ module Spree
           return [] unless payments_hash
           payments_hash.each do |p|
             begin
-              payment = order.payments.build order: order
+              payment = order.payments.build
               payment.amount = p[:amount].to_f
-              # Order API should be using state as that's the normal payment field.
-              # spree_wombat serializes payment state as status so imported orders should fall back to status field.
-              payment.state = p[:state] || p[:status] || 'completed'
+              payment.state = p.fetch(:state, 'completed')
               payment.payment_method = Spree::PaymentMethod.find_by_name!(p[:payment_method])
               payment.save!
             rescue Exception => e
@@ -136,13 +111,10 @@ module Spree
 
         def self.ensure_variant_id_from_params(hash)
           begin
-            sku = hash.delete(:sku)
             unless hash[:variant_id].present?
-              hash[:variant_id] = Spree::Variant.active.find_by_sku!(sku).id
+              hash[:variant_id] = Spree::Variant.active.find_by_sku!(hash[:sku]).id
+              hash.delete(:sku)
             end
-            hash
-          rescue ActiveRecord::RecordNotFound => e
-            raise "Ensure order import variant: Variant w/SKU #{sku} not found."
           rescue Exception => e
             raise "Ensure order import variant: #{e.message} #{hash}"
           end

data/lib/spree/core/importer/product.rb

@@ -0,0 +1,62 @@
+module Spree
+  module Core
+    module Importer
+      class Product
+        attr_reader :product, :product_attrs, :variants_attrs, :options_attrs
+
+        def initialize(product, product_params, options = {})
+          @product = product || Spree::Product.new(product_params)
+
+          @product_attrs = product_params
+          @variants_attrs = options[:variants_attrs] || []
+          @options_attrs = options[:options_attrs] || []
+        end
+
+        def create
+          if product.save
+            variants_attrs.each do |variant_attribute|
+              # make sure the product is assigned before the options=
+              product.variants.create({ product: product }.merge(variant_attribute))
+            end
+
+            set_up_options
+          end
+
+          product
+        end
+
+        def update
+          if product.update_attributes(product_attrs)
+            variants_attrs.each do |variant_attribute|
+              # update the variant if the id is present in the payload
+              if variant_attribute['id'].present?
+                product.variants.find(variant_attribute['id'].to_i).update_attributes(variant_attribute)
+              else
+                # make sure the product is assigned before the options=
+                product.variants.create({ product: product }.merge(variant_attribute))
+              end
+            end
+
+            set_up_options
+          end
+
+          product
+        end
+
+        private
+          def set_up_options
+            options_attrs.each do |name|
+              option_type = Spree::OptionType.where(name: name).first_or_initialize do |option_type|
+                option_type.presentation = name
+                option_type.save!
+              end
+
+              unless product.option_types.include?(option_type)
+                product.option_types << option_type
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/spree/core/product_filters.rb

@@ -42,10 +42,6 @@ module Spree
     # or taxons), eg see the taxon model/controller.
 
     # See specific filters below for concrete examples.
-
-    # This module is included by Taxon. In development mode that inclusion does not
-    # happen until Taxon class is loaded. Ensure that Taxon class is loaded before
-    # you try something like Product.price_range_any
     module ProductFilters
       # Example: filtering by price
       #   The named scope just maps incoming labels onto their conditions, and builds the conjunction

data/lib/spree/core/routes.rb

@@ -38,11 +38,9 @@ module Spree
         @append_routes = []
       end
 
-      private
-
-        def eval_block(&block)
-          Spree::Core::Engine.routes.eval_block(block)
-        end
+      def eval_block(&block)
+        Spree::Core::Engine.routes.eval_block(block)
+      end
     end
   end
-end
+end

data/lib/spree/core/validators/email.rb

@@ -1,7 +1,29 @@
+# Borrowed from http://my.rails-royce.org/2010/07/21/email-validation-in-ruby-on-rails-without-regexp/
+# Mentioned in tweet here: https://twitter.com/_sohara/status/177120126083141633
+require 'mail'
 class EmailValidator < ActiveModel::EachValidator
   def validate_each(record,attribute,value)
-    unless value =~ /\A([^@\.]|[^@\.]([^@\s]*)[^@\.])@([^@\s]+\.)+[^@\s]+\z/
+    unless valid?(value)
       record.errors.add(attribute, :invalid, {:value => value}.merge!(options))
     end
   end
+
+  def valid?(email)
+    begin
+      m = Mail::Address.new(email)
+      # We must check that value contains a domain and that value is an email address
+      r = m.domain && m.address == email
+      t = m.__send__(:tree)
+      # We need to dig into treetop
+      # A valid domain must have dot_atom_text elements size > 1
+      # user@localhost is excluded
+      # treetop must respond to domain
+      # We exclude valid email values like <user@localhost.com>
+      # Hence we use m.__send__(tree).domain
+      r &&= (t.domain.dot_atom_text.elements.size > 1)
+    rescue Exception => e
+      r = false
+    end
+    r
+  end
 end

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
   def self.version
-    '2.2.14'
+    "2.3.0"
   end
 end

data/lib/spree/money.rb

@@ -9,7 +9,7 @@ module Spree
     delegate :cents, :to => :money
 
     def initialize(amount, options={})
-      @money = self.class.parse([amount, (options[:currency] || Spree::Config[:currency])].join)
+      @money = Monetize.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
@@ -22,174 +22,6 @@ module Spree
       @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