goca-spree-core 3.1.14.rails.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aba6863b91a645fcee9334b81d398c7137988e17
+  data.tar.gz: b39ff84eb8f8b960d47fe18095344fc0c909273f
+SHA512:
+  metadata.gz: dac8ef26d94c18eaede8001b3dbb693a97134e661b86578d9bd3e258bb052e69949a9c39e38a8a95294e710048ce0ba85f2b411e7c10cd914346211c60bad60c
+  data.tar.gz: ef075cdcc94e6c1d9cebeec9b05d4277652d8b00087847bc9ec6081c1d8e8f53dd86dbe7946dcb698f66a008cc6c80101c1d7689743391d5f46afa2295268680

data/Gemfile

@@ -0,0 +1,3 @@
+eval(File.read(File.dirname(__FILE__) + '/../common_spree_dependencies.rb'))
+
+gemspec

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2007-2015, Spree Commerce, Inc. and other contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name Spree nor the names of its contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require 'spree/testing_support/common_rake'
+
+RSpec::Core::RakeTask.new
+
+task default: :spec
+
+desc "Generates a dummy app for testing"
+task :test_app do
+  ENV['LIB_NAME'] = 'spree/core'
+  Rake::Task['common:test_app'].invoke
+end

data/app/assets/javascripts/spree.js.coffee.erb

@@ -0,0 +1,59 @@
+#= require jsuri
+class window.Spree
+  @ready: (callback) ->
+    jQuery(document).ready(callback)
+
+    # fire ready callbacks also on turbolinks page change event
+    jQuery(document).on 'page:load', ->
+      callback(jQuery)
+
+  @mountedAt: ->
+    "<%= Rails.application.routes.url_helpers.spree_path(trailing_slash: true) %>"
+
+  @adminPath: ->
+    '<%= Spree.admin_path.gsub(/\A(\/)?(.*[^\/])(\/)?\z/, '\\2/') %>'
+
+  @pathFor: (path) ->
+    locationOrigin = "#{window.location.protocol}//#{window.location.hostname}" + (if window.location.port then ":#{window.location.port}" else "")
+    @url("#{locationOrigin}#{@mountedAt()}#{path}", @url_params).toString()
+
+  @adminPathFor: (path) ->
+    @pathFor("#{@adminPath()}#{path}")
+
+  # Helper function to take a URL and add query parameters to it
+  # Uses the JSUri library from here: https://github.com/derek-watson/jsUri
+  # Thanks to Jake Moffat for the suggestion: https://twitter.com/jakeonrails/statuses/321776992221544449
+  @url: (uri, query) ->
+    if uri.path == undefined
+      uri = new Uri(uri)
+    if query
+      $.each query, (key, value) ->
+        uri.addQueryParam(key, value)
+    return uri
+
+  # This function automatically appends the API token
+  # for the user to the end of any URL.
+  # Immediately after, this string is then passed to jQuery.ajax.
+  #
+  # ajax works in two ways in jQuery:
+  #
+  # $.ajax("url", {settings: 'go here'})
+  # or:
+  # $.ajax({url: "url", settings: 'go here'})
+  #
+  # This function will support both of these calls.
+  @ajax: (url_or_settings, settings) ->
+    if (typeof(url_or_settings) == "string")
+      $.ajax(Spree.url(url_or_settings).toString(), settings)
+    else
+      url = url_or_settings['url']
+      delete url_or_settings['url']
+      $.ajax(Spree.url(url).toString(), url_or_settings)
+
+  @routes:
+    states_search: @pathFor('api/v1/states')
+    apply_coupon_code: (order_id) ->
+      Spree.pathFor("api/v1/orders/#{order_id}/apply_coupon_code")
+
+  @url_params:
+    {}

data/app/controllers/spree/base_controller.rb

@@ -0,0 +1,15 @@
+require 'cancan'
+require_dependency 'spree/core/controller_helpers/strong_parameters'
+
+class Spree::BaseController < ApplicationController
+  include Spree::Core::ControllerHelpers::Auth
+  include Spree::Core::ControllerHelpers::RespondWith
+  include Spree::Core::ControllerHelpers::Common
+  include Spree::Core::ControllerHelpers::Search
+  include Spree::Core::ControllerHelpers::Store
+  include Spree::Core::ControllerHelpers::StrongParameters
+
+  respond_to :html
+end
+
+require 'spree/i18n/initializer'

data/app/helpers/spree/base_helper.rb

@@ -0,0 +1,123 @@
+module Spree
+  module BaseHelper
+
+    def available_countries
+      checkout_zone = Zone.find_by(name: Spree::Config[:checkout_zone])
+
+      if checkout_zone && checkout_zone.kind == 'country'
+        countries = checkout_zone.country_list
+      else
+        countries = Country.all
+      end
+
+      countries.collect do |country|
+        country.name = Spree.t(country.iso, scope: 'country_names', default: country.name)
+        country
+      end.sort_by { |c| c.name.parameterize }
+    end
+
+    def display_price(product_or_variant)
+      product_or_variant.
+        price_in(current_currency).
+        display_price_including_vat_for(current_price_options).
+        to_html
+    end
+
+    def link_to_tracking(shipment, options = {})
+      return unless shipment.tracking && shipment.shipping_method
+
+      if shipment.tracking_url
+        link_to(shipment.tracking, shipment.tracking_url, options)
+      else
+        content_tag(:span, shipment.tracking)
+      end
+    end
+
+    def logo(image_path=Spree::Config[:logo])
+      link_to image_tag(image_path), spree.root_path
+    end
+
+    def meta_data
+      object = instance_variable_get('@'+controller_name.singularize)
+      meta = {}
+
+      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
+
+      if meta[:description].blank? && object.kind_of?(Spree::Product)
+        meta[:description] = truncate(strip_tags(object.description), length: 160, separator: ' ')
+      end
+
+      meta.reverse_merge!({
+        keywords: current_store.meta_keywords,
+        description: current_store.meta_description,
+      }) if meta[:keywords].blank? or meta[:description].blank?
+      meta
+    end
+
+    def meta_data_tags
+      meta_data.map do |name, content|
+        tag('meta', name: name, content: content)
+      end.join("\n")
+    end
+
+    def method_missing(method_name, *args, &block)
+      if image_style = image_style_from_method_name(method_name)
+        define_image_method(image_style)
+        self.send(method_name, *args)
+      else
+        super
+      end
+    end
+
+    def pretty_time(time)
+      [I18n.l(time.to_date, format: :long), time.strftime("%l:%M %p")].join(" ")
+    end
+
+    def seo_url(taxon)
+      return spree.nested_taxons_path(taxon.permalink)
+    end
+
+    # human readable list of variant options
+    def variant_options(v, options={})
+      v.options_text
+    end
+
+    private
+
+    def create_product_image_tag(image, product, options, style)
+      options.reverse_merge! alt: image.alt.blank? ? product.name : image.alt
+      image_tag image.attachment.url(style), options
+    end
+
+    def define_image_method(style)
+      self.class.send :define_method, "#{style}_image" do |product, *options|
+        options = options.first || {}
+        options[:alt] ||= product.name
+        if product.images.empty?
+          if !product.is_a?(Spree::Variant) && !product.variant_images.empty?
+            create_product_image_tag(product.variant_images.first, product, options, style)
+          else
+            if product.is_a?(Variant) && !product.product.variant_images.empty?
+              create_product_image_tag(product.product.variant_images.first, product, options, style)
+            else
+              image_tag "noimage/#{style}.png", options
+            end
+          end
+        else
+          create_product_image_tag(product.images.first, product, options, style)
+        end
+      end
+    end
+
+    # Returns style of image or nil
+    def image_style_from_method_name(method_name)
+      if method_name.to_s.match(/_image$/) && style = method_name.to_s.sub(/_image$/, '')
+        possible_styles = Spree::Image.attachment_definitions[:attachment][:styles]
+        style if style.in? possible_styles.with_indifferent_access
+      end
+    end
+  end
+end

data/app/helpers/spree/products_helper.rb

@@ -0,0 +1,91 @@
+module Spree
+  module ProductsHelper
+    # returns the formatted price for the specified variant as a full price or a difference depending on configuration
+    def variant_price(variant)
+      if Spree::Config[:show_variant_full_price]
+        variant_full_price(variant)
+      else
+        variant_price_diff(variant)
+      end
+    end
+
+    # returns the formatted price for the specified variant as a difference from product price
+    def variant_price_diff(variant)
+      variant_amount = variant.amount_in(current_currency)
+      product_amount = variant.product.amount_in(current_currency)
+      return if variant_amount == product_amount || product_amount.nil?
+      diff   = variant.amount_in(current_currency) - product_amount
+      amount = Spree::Money.new(diff.abs, currency: current_currency).to_html
+      label  = diff > 0 ? :add : :subtract
+      "(#{Spree.t(label)}: #{amount})".html_safe
+    end
+
+    # returns the formatted full price for the variant, if at least one variant price differs from product price
+    def variant_full_price(variant)
+      product = variant.product
+      unless product.variants.active(current_currency).all? { |v| v.price == product.price }
+        Spree::Money.new(variant.price, { currency: current_currency }).to_html
+      end
+    end
+
+    # converts line breaks in product description into <p> tags (for html display purposes)
+    def product_description(product)
+      description = if Spree::Config[:show_raw_product_description]
+                      product.description
+                    else
+                      product.description.to_s.gsub(/(.*?)\r?\n\r?\n/m, '<p>\1</p>')
+                    end
+      description.blank? ? Spree.t(:product_has_no_description) : raw(description)
+    end
+
+    def line_item_description(variant)
+      ActiveSupport::Deprecation.warn "line_item_description(variant) is deprecated and may be removed from future releases, use line_item_description_text(line_item.description) instead.", caller
+
+      line_item_description_text(variant.product.description)
+    end
+
+    def line_item_description_text description_text
+      if description_text.present?
+        truncate(strip_tags(description_text.gsub('&nbsp;', ' ').squish), length: 100)
+      else
+        Spree.t(:product_has_no_description)
+      end
+    end
+
+    def cache_key_for_products
+      count = @products.count
+      max_updated_at = (@products.maximum(:updated_at) || Date.today).to_s(:number)
+      products_cache_keys = "spree/products/all-#{params[:page]}-#{max_updated_at}-#{count}"
+      (common_product_cache_keys + [products_cache_keys]).compact.join("/")
+    end
+
+    def cache_key_for_product(product = @product)
+      (common_product_cache_keys + [product.cache_key, product.possible_promotions]).compact.join("/")
+    end
+
+    def available_status(product) # will return a human readable string
+      return Spree.t(:discontinued)  if product.discontinued?
+      return Spree.t(:deleted)  if product.deleted?
+
+      if product.available?
+        Spree.t(:available)
+      elsif product.available_on && product.available_on.future?
+        Spree.t(:pending_sale)
+      else
+        Spree.t(:no_available_date_set)
+      end
+    end
+
+    private
+
+    def common_product_cache_keys
+      [I18n.locale, current_currency] + price_options_cache_key
+    end
+
+    def price_options_cache_key
+      current_price_options.sort.map(&:last).map do |value|
+        value.try(:cache_key) || value
+      end
+    end
+  end
+end

data/app/mailers/spree/base_mailer.rb

@@ -0,0 +1,27 @@
+module Spree
+  class BaseMailer < ActionMailer::Base
+    def from_address
+      Spree::Store.current.mail_from_address
+    end
+
+    def money(amount, currency = Spree::Config[:currency])
+      Spree::Money.new(amount, currency: currency).to_s
+    end
+    helper_method :money
+
+    def mail(headers = {}, &block)
+      ensure_default_action_mailer_url_host
+      super if Spree::Config[:send_core_emails]
+    end
+
+    private
+
+    # this ensures that ActionMailer::Base.default_url_options[:host] is always set
+    # this is only a fail-safe solution if developer didn't set this in environment files
+    # http://guides.rubyonrails.org/action_mailer_basics.html#generating-urls-in-action-mailer-views
+    def ensure_default_action_mailer_url_host
+      ActionMailer::Base.default_url_options ||= {}
+      ActionMailer::Base.default_url_options[:host] ||= Spree::Store.current.url
+    end
+  end
+end

data/app/mailers/spree/order_mailer.rb

@@ -0,0 +1,17 @@
+module Spree
+  class OrderMailer < BaseMailer
+    def confirm_email(order, resend = false)
+      @order = order.respond_to?(:id) ? order : Spree::Order.find(order)
+      subject = (resend ? "[#{Spree.t(:resend).upcase}] " : '')
+      subject += "#{Spree::Store.current.name} #{Spree.t('order_mailer.confirm_email.subject')} ##{@order.number}"
+      mail(to: @order.email, from: from_address, subject: subject)
+    end
+
+    def cancel_email(order, resend = false)
+      @order = order.respond_to?(:id) ? order : Spree::Order.find(order)
+      subject = (resend ? "[#{Spree.t(:resend).upcase}] " : '')
+      subject += "#{Spree::Store.current.name} #{Spree.t('order_mailer.cancel_email.subject')} ##{@order.number}"
+      mail(to: @order.email, from: from_address, subject: subject)
+    end
+  end
+end

data/app/mailers/spree/reimbursement_mailer.rb

@@ -0,0 +1,10 @@
+module Spree
+  class ReimbursementMailer < BaseMailer
+      def reimbursement_email(reimbursement, resend = false)
+        @reimbursement = reimbursement.respond_to?(:id) ? reimbursement : Spree::Reimbursement.find(reimbursement)
+        subject = (resend ? "[#{Spree.t(:resend).upcase}] " : '')
+        subject += "#{Spree::Store.current.name} #{Spree.t('reimbursement_mailer.reimbursement_email.subject')} ##{@reimbursement.order.number}"
+        mail(to: @reimbursement.order.email, from: from_address, subject: subject)
+      end
+  end
+end

data/app/mailers/spree/shipment_mailer.rb

@@ -0,0 +1,10 @@
+module Spree
+  class ShipmentMailer < BaseMailer
+    def shipped_email(shipment, resend = false)
+      @shipment = shipment.respond_to?(:id) ? shipment : Spree::Shipment.find(shipment)
+      subject = (resend ? "[#{Spree.t(:resend).upcase}] " : '')
+      subject += "#{Spree::Store.current.name} #{Spree.t('shipment_mailer.shipped_email.subject')} ##{@shipment.order.number}"
+      mail(to: @shipment.order.email, from: from_address, subject: subject)
+    end
+  end
+end

data/app/mailers/spree/test_mailer.rb

@@ -0,0 +1,8 @@
+module Spree
+  class TestMailer < BaseMailer
+    def test_email(email)
+      subject = "#{Spree::Store.current.name} #{Spree.t('test_mailer.test_email.subject')}"
+      mail(to: email, from: from_address, subject: subject)
+    end
+  end
+end

data/app/models/concerns/spree/adjustment_source.rb

@@ -0,0 +1,53 @@
+module Spree
+  module AdjustmentSource
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :adjustments, as: :source
+      before_destroy :deals_with_adjustments_for_deleted_source
+    end
+
+    protected
+
+    def create_adjustment(order, adjustable, included = false)
+      amount = compute_amount(adjustable)
+      return if amount == 0
+      adjustments.new(order: order,
+                      adjustable: adjustable,
+                      label: label,
+                      amount: amount,
+                      included: included).save
+    end
+
+    def create_unique_adjustment(order, adjustable)
+      return if already_adjusted?(adjustable)
+      create_adjustment(order, adjustable)
+    end
+
+    def create_unique_adjustments(order, adjustables)
+      adjustables.where.not(id: already_adjusted_ids(order)).map do |adjustable|
+        create_adjustment(order, adjustable) if !block_given? || yield(adjustable)
+      end.any?
+    end
+
+    private
+
+    def already_adjusted_ids(order)
+      adjustments.where(order: order).pluck(:adjustable_id)
+    end
+
+    def already_adjusted?(adjustable)
+      adjustments.where(adjustable: adjustable).exists?
+    end
+
+    def deals_with_adjustments_for_deleted_source
+      # For incomplete orders, remove the adjustment completely.
+      adjustments.for_incomplete_order.destroy_all
+
+      # For complete orders, the source will be invalid.
+      # Therefore we nullify the source_id, leaving the adjustment in place.
+      # This would mean that the order's total is not altered at all.
+      adjustments.for_complete_order.update_all(source_id: nil, updated_at: Time.current)
+    end
+  end
+end

data/app/models/concerns/spree/calculated_adjustments.rb

@@ -0,0 +1,34 @@
+module Spree
+  module CalculatedAdjustments
+    extend ActiveSupport::Concern
+
+    included do
+      has_one   :calculator, class_name: "Spree::Calculator", as: :calculable, inverse_of: :calculable, dependent: :destroy, autosave: true
+      accepts_nested_attributes_for :calculator
+      validates :calculator, presence: true
+      delegate :compute, to: :calculator
+
+      def self.calculators
+        spree_calculators.send model_name_without_spree_namespace
+      end
+
+      def calculator_type
+        calculator.class.to_s if calculator
+      end
+
+      def calculator_type=(calculator_type)
+        klass = calculator_type.constantize if calculator_type
+        self.calculator = klass.new if klass && !self.calculator.is_a?(klass)
+      end
+
+      private
+      def self.model_name_without_spree_namespace
+        self.to_s.tableize.gsub('/', '_').sub('spree_', '')
+      end
+
+      def self.spree_calculators
+        Rails.application.config.spree.calculators
+      end
+    end
+  end
+end

data/app/models/concerns/spree/default_price.rb

@@ -0,0 +1,40 @@
+module Spree
+  module DefaultPrice
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :default_price,
+        -> { where currency: Spree::Config[:currency] },
+        class_name: 'Spree::Price',
+        dependent: :destroy
+
+      delegate_belongs_to :default_price,
+                          :display_price,
+                          :display_amount,
+                          :price,
+                          :price=,
+                          :price_including_vat_for,
+                          :currency
+
+      after_save :save_default_price
+
+      def default_price
+        Spree::Price.unscoped { super }
+      end
+
+      def has_default_price?
+        !self.default_price.nil?
+      end
+
+      private
+
+      def default_price_changed?
+        default_price && (default_price.changed? || default_price.new_record?)
+      end
+
+      def save_default_price
+        default_price.save if default_price_changed?
+      end
+    end
+  end
+end

data/app/models/concerns/spree/display_money.rb

@@ -0,0 +1,32 @@
+module Spree
+  module DisplayMoney
+    ##
+    # Takes a list of methods that the base object wants to be able to use
+    # to display with Spree::Money, and turns them into display_* methods.
+    # Intended to help clean up some of the presentational logic that exists
+    # at the model layer.
+    #
+    #
+    # ==== Examples
+    # Decorate a method, with the default option of using the base object's 
+    # currency
+    #
+    #     extend Spree::DisplayMoney
+    #     money_methods :tax_amount, :price
+    #
+    # Decorate a method, but with some additional options
+    #     extend Spree::DisplayMoney
+    #     money_methods tax_amount: { currency: "CAD", no_cents: true }, :price
+    def money_methods(*args)
+      args.each do |money_method|
+        money_method = { money_method => {} } unless money_method.is_a? Hash
+        money_method.each do |method_name, opts|
+          define_method("display_#{method_name}") do
+            default_opts = respond_to?(:currency) ? { currency: currency } : {}
+            Spree::Money.new(send(method_name), default_opts.merge(opts))
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/spree/named_type.rb

@@ -0,0 +1,12 @@
+module Spree
+  module NamedType
+    extend ActiveSupport::Concern
+
+    included do
+      scope :active, -> { where(active: true) }
+      default_scope { order("LOWER(#{self.table_name}.name)") }
+
+      validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+    end
+  end
+end

data/app/models/concerns/spree/ransackable_attributes.rb

@@ -0,0 +1,24 @@
+module Spree::RansackableAttributes
+  extend ActiveSupport::Concern
+  included do
+    class_attribute :whitelisted_ransackable_associations
+    class_attribute :whitelisted_ransackable_attributes
+    class_attribute :whitelisted_ransackable_scopes
+
+    class_attribute :default_ransackable_attributes
+    self.default_ransackable_attributes = %w[id name updated_at created_at]
+
+    def self.ransackable_associations(*args)
+      self.whitelisted_ransackable_associations || []
+    end
+
+    def self.ransackable_attributes(*args)
+      self.default_ransackable_attributes | (self.whitelisted_ransackable_attributes || [])
+    end
+
+    def self.ransackable_scopes(*args)
+      whitelisted_ransackable_scopes || []
+    end
+  end
+
+end

data/app/models/concerns/spree/user_address.rb

@@ -0,0 +1,30 @@
+module Spree
+  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
+
+      accepts_nested_attributes_for :ship_address, :bill_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