spree_core 2.1.3 → 2.1.4

data/lib/spree/core/mail_method.rb

@@ -0,0 +1,27 @@
+module Spree
+  module Core
+    class MailMethod
+      def initialize(options={})
+      end
+
+      def deliver!(mail)
+        if Config.enable_mail_delivery
+          mailer.deliver!(mail)
+        end
+      end
+
+      def mailer
+        mailer_class.new(mail_server_settings)
+      end
+
+      private
+      def mailer_class
+        Rails.env.test?? Mail::TestMailer : Mail::SMTP
+      end
+
+      def mail_server_settings
+        MailSettings.new.mail_server_settings
+      end
+    end
+  end
+end

data/lib/spree/core/mail_settings.rb

@@ -8,53 +8,48 @@ module Spree
       # This makes it possible to configure the mail settings through an admin
       # interface instead of requiring changes to the Rails envrionment file
       def self.init
-        self.new.override! if override?
+        override! if override?
       end
 
       def self.override?
         Config.override_actionmailer_config
       end
 
-      def override!
-        if Config.enable_mail_delivery
-          ActionMailer::Base.default_url_options[:host] ||= Config.site_url
-          ActionMailer::Base.smtp_settings = mail_server_settings
-          ActionMailer::Base.perform_deliveries = true
-        else
-          ActionMailer::Base.perform_deliveries = false
-        end
+      def self.override!
+        ActionMailer::Base.delivery_method = :spree
+        ActionMailer::Base.default_url_options[:host] ||= Config.site_url
+      end
+
+      def mail_server_settings
+        settings = if need_authentication?
+                     basic_settings.merge(user_credentials)
+                   else
+                     basic_settings
+                   end
+
+        settings.merge :enable_starttls_auto => secure_connection?
       end
 
       private
-        def mail_server_settings
-          settings = if need_authentication?
-            basic_settings.merge(user_credentials)
-          else
-            basic_settings
-          end
-
-          settings.merge :enable_starttls_auto => secure_connection?
-        end
-
-        def user_credentials
-          { :user_name => Config.smtp_username,
-            :password => Config.smtp_password }
-        end
-
-        def basic_settings
-          { :address => Config.mail_host,
-            :domain => Config.mail_domain,
-            :port => Config.mail_port,
-            :authentication => Config.mail_auth_type }
-        end
-
-        def need_authentication?
-          Config.mail_auth_type != 'None'
-        end
-
-        def secure_connection?
-          Config.secure_connection_type == 'TLS'
-        end
+      def user_credentials
+        { :user_name => Config.smtp_username,
+          :password => Config.smtp_password }
+      end
+
+      def basic_settings
+        { :address => Config.mail_host,
+          :domain => Config.mail_domain,
+          :port => Config.mail_port,
+          :authentication => Config.mail_auth_type }
+      end
+
+      def need_authentication?
+        Config.mail_auth_type != 'None'
+      end
+
+      def secure_connection?
+        Config.secure_connection_type == 'TLS'
+      end
     end
   end
 end

data/lib/spree/core/permalinks.rb

@@ -33,6 +33,10 @@ 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
@@ -40,7 +44,7 @@ module Spree
       end
 
       def generate_permalink
-        "#{self.class.permalink_prefix}#{Array.new(9){rand(9)}.join}"
+        "#{self.class.permalink_prefix}#{Array.new(self.class.permalink_length){rand(9)}.join}"
       end
 
       def save_permalink(permalink_value=self.to_param)

data/lib/spree/core/s3_support.rb

@@ -15,7 +15,7 @@ module Spree
             self.attachment_definitions[field][:s3_credentials] = s3_creds
             self.attachment_definitions[field][:s3_headers] = ActiveSupport::JSON.decode(config[:s3_headers])
             self.attachment_definitions[field][:bucket] = config[:s3_bucket]
-            self.attachment_definitions[field][:s3_protocol] = config[:s3_protocol].downcase unless config[:s3_protocol].blank?
+            self.attachment_definitions[field][:s3_protocol] = config[:s3_protocol].blank? ? '' : config[:s3_protocol].downcase
             self.attachment_definitions[field][:s3_host_alias] = config[:s3_host_alias] unless config[:s3_host_alias].blank?
           end
         end

data/lib/spree/core/user_address.rb

@@ -0,0 +1,30 @@
+module Spree
+  module Core
+    module UserAddress
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to :bill_address, foreign_key: :bill_address_id, class_name: 'Spree::Address'
+        alias_attribute :billing_address, :bill_address
+
+        belongs_to :ship_address, foreign_key: :ship_address_id, class_name: 'Spree::Address'
+        alias_attribute :shipping_address, :ship_address
+
+        def persist_order_address(order)
+          b_address = self.bill_address || self.build_bill_address
+          b_address.attributes = order.bill_address.attributes.except('id', 'updated_at', 'created_at')
+          b_address.save
+          self.update_attributes(bill_address_id: b_address.id)
+
+          # May not be present if delivery step has been removed
+          if order.ship_address
+            s_address = self.ship_address || self.build_ship_address
+            s_address.attributes = order.ship_address.attributes.except('id', 'updated_at', 'created_at')
+            s_address.save
+            self.update_attributes(ship_address_id: s_address.id)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,10 +3,16 @@
 require 'mail'
 class EmailValidator < ActiveModel::EachValidator
   def validate_each(record,attribute,value)
+    unless valid?(value)
+      record.errors.add(attribute, :invalid, {:value => value}.merge!(options))
+    end
+  end
+
+  def valid?(email)
     begin
-      m = Mail::Address.new(value)
+      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 == value
+      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
@@ -18,6 +24,6 @@ class EmailValidator < ActiveModel::EachValidator
     rescue Exception => e
       r = false
     end
-    record.errors.add(attribute, :invalid, {:value => value}.merge!(options)) unless r
+    r
   end
 end

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
   def self.version
-    "2.1.3"
+    "2.1.4"
   end
 end

data/lib/spree/i18n.rb

@@ -4,6 +4,7 @@ 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/migrations.rb

@@ -0,0 +1,55 @@
+module Spree
+  class Migrations
+    attr_reader :config, :engine_name
+
+    # Takes the engine config block and engine name
+    def initialize(config, engine_name)
+      @config, @engine_name = config, engine_name
+    end
+
+    # Puts warning when any engine migration is not present on the Rails app
+    # db/migrate dir
+    #
+    # First split:
+    #
+    #   ["20131128203548", "update_name_fields_on_spree_credit_cards.spree.rb"]
+    #
+    # Second split should give the engine_name of the migration
+    #
+    #   ["update_name_fields_on_spree_credit_cards", "spree.rb"]
+    #
+    # Shouldn't run on test mode because migrations inside engine don't have
+    # engine name on the file name
+    def check
+      if File.exists?("config/spree.yml") && File.directory?("db/migrate")
+        engine_in_app = app_migrations.map do |file_name|
+          name, engine = file_name.split(".", 2)
+          next unless engine == "#{engine_name}.rb"
+          name
+        end.compact! || []
+
+        unless (engine_migrations.sort - engine_in_app.sort).empty?
+          puts "[#{engine_name.capitalize} WARNING] Missing migrations." \
+               "Run `bundle exec rake railties:install:migrations` to get them.\n\n"
+          true
+        end
+      end
+    end
+
+    private
+      def engine_migrations
+        Dir.entries("#{config.root}/db/migrate").map do |file_name|
+          name = file_name.split("_", 2).last.split(".", 2).first
+          name.empty? ? next : name
+        end.compact! || []
+      end
+
+      def app_migrations
+        Dir.entries("db/migrate").map do |file_name|
+          next if [".", ".."].include? file_name
+          name = file_name.split("_", 2).last
+          name.empty? ? next : name
+        end.compact! || []
+      end
+  end
+end

data/lib/spree/money.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'money'
 
 module Spree
@@ -7,7 +9,7 @@ module Spree
     delegate :cents, :to => :money
 
     def initialize(amount, options={})
-      @money = ::Money.parse([amount, (options[:currency] || Spree::Config[:currency])].join)
+      @money = self.class.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
@@ -20,6 +22,174 @@ 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 ::Money.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