spree_core 2.4.10 → 3.0.0.rc1

data/app/helpers/spree/orders_helper.rb

@@ -1,17 +0,0 @@
-require 'truncate_html'
-require 'app/helpers/truncate_html_helper'
-
-module Spree
-  module OrdersHelper
-    include TruncateHtmlHelper
-
-    def truncated_product_description(product)
-      truncate_html(raw(product.description))
-    end
-
-    def order_just_completed?(order)
-      flash[:order_completed] && order.present?
-    end
-  end
-end
-

data/app/helpers/spree/store_helper.rb

@@ -1,16 +0,0 @@
-# Methods added to this helper will be available to all templates in the frontend.
-module Spree
-  module StoreHelper
-
-    # helper to determine if its appropriate to show the store menu
-    def store_menu?
-      %w{thank_you}.exclude? params[:action]
-    end
-
-    def cache_key_for_taxons
-      max_updated_at = @taxons.maximum(:updated_at).to_i
-      parts = [@taxon.try(:id), max_updated_at].compact.join("-")
-      "#{I18n.locale}/taxons/#{parts}"
-    end
-  end
-end

data/app/helpers/spree/taxons_helper.rb

@@ -1,19 +0,0 @@
-module Spree
-  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, max=4)
-      products = taxon.active_products.select("DISTINCT (spree_products.id), spree_products.*, spree_products_taxons.position").limit(max)
-      if (products.size < max)
-        products_arel = Spree::Product.arel_table
-        taxon.descendants.each do |taxon|
-          to_get = max - products.length
-          products += taxon.active_products.select("DISTINCT (spree_products.id), spree_products.*, spree_products_taxons.position").where(products_arel[:id].not_in(products.map(&:id))).limit(to_get)
-          break if products.size >= max
-        end
-      end
-      products
-    end
-  end
-end

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

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

data/app/models/friendly_id/slug_decorator.rb

@@ -1,3 +0,0 @@
-FriendlyId::Slug.class_eval do
-  acts_as_paranoid
-end

data/app/models/spree/billing_integration.rb

@@ -1,21 +0,0 @@
-module Spree
-  class BillingIntegration < PaymentMethod
-    validates :name, presence: true
-
-    preference :server, :string, default: 'test'
-    preference :test_mode, :boolean, default: true
-
-    def provider
-      integration_options = options
-      ActiveMerchant::Billing::Base.integration_mode = integration_options[:server].to_sym
-      integration_options[:test] = true if integration_options[:test_mode]
-      @provider ||= provider_class.new(integration_options)
-    end
-
-    def options
-      options_hash = {}
-      preferences.each { |key, value| options_hash[key.to_sym] = value }
-      options_hash
-    end
-  end
-end

data/app/models/spree/configuration.rb

@@ -1,5 +0,0 @@
-module Spree
-  class Configuration < Spree::Base
-
-  end
-end

data/app/models/spree/item_adjustments.rb

@@ -1,82 +0,0 @@
-module Spree
-  # Manage (recalculate) item (LineItem or Shipment) adjustments
-  class ItemAdjustments
-    include ActiveSupport::Callbacks
-    define_callbacks :promo_adjustments, :tax_adjustments
-    attr_reader :item
-
-    delegate :adjustments, :order, to: :item
-
-    def initialize(item)
-      @item = item
-
-      # Don't attempt to reload the item from the DB if it's not there
-      @item.reload if @item.instance_of?(Shipment) && @item.persisted?
-    end
-
-    def update
-      update_adjustments if item.persisted?
-      item
-    end
-
-    # TODO this should be probably the place to calculate proper item taxes
-    # values after promotions are applied
-    def update_adjustments
-      # Promotion adjustments must be applied first, then tax adjustments.
-      # This fits the criteria for VAT tax as outlined here:
-      # http://www.hmrc.gov.uk/vat/managing/charging/discounts-etc.htm#1
-      #
-      # It also fits the criteria for sales tax as outlined here:
-      # http://www.boe.ca.gov/formspubs/pub113/
-      #
-      # Tax adjustments come in not one but *two* exciting flavours:
-      # Included & additional
-
-      # Included tax adjustments are those which are included in the price.
-      # These ones should not affect the eventual total price.
-      #
-      # Additional tax adjustments are the opposite, affecting the final total.
-      promo_total = 0
-      run_callbacks :promo_adjustments do
-        promotion_total = adjustments.promotion.reload.map do |adjustment|
-          adjustment.update!(@item)
-        end.compact.sum
-
-        unless promotion_total == 0
-          choose_best_promotion_adjustment
-        end
-        promo_total = best_promotion_adjustment.try(:amount).to_f
-      end
-
-      included_tax_total = 0
-      additional_tax_total = 0
-      run_callbacks :tax_adjustments do
-        tax = (item.respond_to?(:all_adjustments) ? item.all_adjustments : item.adjustments).tax
-        included_tax_total = tax.is_included.reload.map(&:update!).compact.sum
-        additional_tax_total = tax.additional.reload.map(&:update!).compact.sum
-      end
-
-      item.update_columns(
-        :promo_total => promo_total,
-        :included_tax_total => included_tax_total,
-        :additional_tax_total => additional_tax_total,
-        :adjustment_total => promo_total + additional_tax_total,
-        :updated_at => Time.now,
-      )
-    end
-
-    # Picks one (and only one) promotion to be eligible for this order
-    # This promotion provides the most discount, and if two promotions
-    # have the same amount, then it will pick the latest one.
-    def choose_best_promotion_adjustment
-      if best_promotion_adjustment
-        other_promotions = self.adjustments.promotion.where.not(id: best_promotion_adjustment.id)
-        other_promotions.update_all(:eligible => false)
-      end
-    end
-
-    def best_promotion_adjustment
-      @best_promotion_adjustment ||= adjustments.promotion.eligible.reorder("amount ASC, created_at DESC, id DESC").first
-    end
-  end
-end

data/app/models/spree/order_merger.rb

@@ -1,65 +0,0 @@
-module Spree
-  class OrderMerger
-    attr_accessor :order
-    delegate :updater, to: :order
-
-    def initialize(order)
-      @order = order
-    end
-
-    def merge!(other_order, user = nil)
-      other_order.line_items.each do |other_order_line_item|
-        next unless other_order_line_item.currency == order.currency
-
-        current_line_item = find_matching_line_item(other_order_line_item)
-        handle_merge(current_line_item, other_order_line_item)
-      end
-
-      set_user(user)
-      persist_merge
-
-      # So that the destroy doesn't take out line items which may have been re-assigned
-      other_order.line_items.reload
-      other_order.destroy
-    end
-
-    # Compare the line item of the other order with mine.
-    # Make sure you allow any extensions to chime in on whether or
-    # not the extension-specific parts of the line item match
-    def find_matching_line_item(other_order_line_item)
-      order.line_items.detect do |my_li|
-        my_li.variant == other_order_line_item.variant &&
-          order.line_item_comparison_hooks.all? do |hook|
-            order.send(hook, my_li, other_order_line_item.serializable_hash)
-          end
-      end
-    end
-
-    def set_user(user = nil)
-      order.associate_user!(user) if !order.user && !user.blank?
-    end
-
-    # The idea is the end developer can choose to override the merge
-    # to their own choosing. Default is merge with errors.
-    def handle_merge(current_line_item, other_order_line_item)
-      if current_line_item
-        current_line_item.quantity += other_order_line_item.quantity
-        handle_error(current_line_item) unless current_line_item.save
-      else
-        other_order_line_item.order_id = order.id
-        handle_error(other_order_line_item) unless other_order_line_item.save
-      end
-    end
-
-    # Change the error messages as you choose.
-    def handle_error(line_item)
-      order.errors[:base] << line_item.errors.full_messages
-    end
-
-    def persist_merge
-      updater.update_item_count
-      updater.update_item_total
-      updater.persist_totals
-    end
-  end
-end

data/app/models/spree/order_populator.rb

@@ -1,43 +0,0 @@
-module Spree
-  class OrderPopulator
-    attr_accessor :order, :currency
-    attr_reader :errors
-
-    def initialize(order, currency)
-      @order = order
-      @currency = currency
-      @errors = ActiveModel::Errors.new(self)
-    end
-
-    def populate(variant_id, quantity, options = {})
-      ActiveSupport::Deprecation.warn "OrderPopulator is deprecated and will be removed from Spree 3, use OrderContents with order.contents.add instead.", caller
-      # protect against passing a nil hash being passed in
-      # due to an empty params[:options]
-      attempt_cart_add(variant_id, quantity, options || {})
-      valid?
-    end
-
-    def valid?
-      errors.empty?
-    end
-
-    private
-
-    def attempt_cart_add(variant_id, quantity, options = {})
-      quantity = quantity.to_i
-      # 2,147,483,647 is crazy.
-      # See issue #2695.
-      if quantity > 2_147_483_647
-        errors.add(:base, Spree.t(:please_enter_reasonable_quantity, scope: :order_populator))
-        return false
-      end
-
-      variant = Spree::Variant.find(variant_id)
-      begin
-        @order.contents.add(variant, quantity, options.merge(currency: currency))
-      rescue ActiveRecord::RecordInvalid => e
-        errors.add(:base, e.record.errors.messages.values.join(" "))
-      end
-    end
-  end
-end

data/app/models/spree/product_scope/scopes.rb

@@ -1,47 +0,0 @@
-module Spree
-  class ProductScope < Spree::Base
-    before_validation(:on => :create) do
-      # Add default empty arguments so scope validates and errors aren't caused when previewing it
-      if name && args = self.class.arguments_for_scope_name(name)
-        self.arguments ||= ['']*args.length
-      end
-    end
-
-    def self.all_scopes
-      {
-        # Scopes for selecting products based on taxon
-        :taxon => {
-          :taxons_name_eq => [:taxon_name],
-          :in_taxons => [:taxon_names],
-        },
-        # product selection based on name, or search
-        :search => {
-          :in_name => [:words],
-          :in_name_or_keywords => [:words],
-          :in_name_or_description => [:words],
-          :with_ids => [:ids]
-        },
-        # Scopes for selecting products based on option types and properties
-        :values => {
-          :with => [:value],
-          :with_property => [:property],
-          :with_property_value => [:property, :value],
-          :with_option => [:option],
-          :with_option_value => [:option, :value],
-        },
-        # product selection based upon master price
-        :price => {
-          :price_between => [:low, :high],
-          :master_price_lte => [:amount],
-          :master_price_gte => [:amount],
-        },
-      }
-    end
-
-    def self.arguments_for_scope_name(name)
-      if group = all_scopes.detect { |k,v| v[name.to_sym] }
-        group[1][name.to_sym]
-      end
-    end
-  end
-end

data/app/models/spree/variant/scopes.rb

@@ -1,42 +0,0 @@
-module Spree
-  class Variant < Spree::Base
-    #FIXME WARNING tested only under sqlite and postgresql
-    scope :descend_by_popularity, -> {
-      ActiveSupport::Deprecation.warn "Variant.descend_by_popularity is deprecated and will be removed from Spree 3.", caller
-      order("COALESCE((SELECT COUNT(*) FROM  #{LineItem.quoted_table_name} GROUP BY #{LineItem.quoted_table_name}.variant_id HAVING #{LineItem.quoted_table_name}.variant_id = #{Variant.quoted_table_name}.id), 0) DESC")
-    }
-
-    class << self
-      # Returns variants that match a given option value
-      #
-      # Example:
-      #
-      # product.variants_including_master.has_option(OptionType.find_by(name: 'shoe-size'), OptionValue.find_by(name: '8'))
-      def has_option(option_type, *option_values)
-        ActiveSupport::Deprecation.warn "Variant.descend_by_popularity is deprecated and will be removed from Spree 3.", caller
-        option_types = OptionType.table_name
-
-        option_type_conditions = case option_type
-        when OptionType then { "#{option_types}.name" => option_type.name }
-        when String     then { "#{option_types}.name" => option_type }
-        else                 { "#{option_types}.id"   => option_type }
-        end
-
-        relation = joins(:option_values => :option_type).where(option_type_conditions)
-
-        option_values_conditions = option_values.each do |option_value|
-          option_value_conditions = case option_value
-          when OptionValue then { "#{OptionValue.table_name}.name" => option_value.name }
-          when String      then { "#{OptionValue.table_name}.name" => option_value }
-          else                  { "#{OptionValue.table_name}.id"   => option_value }
-          end
-          relation = relation.where(option_value_conditions)
-        end
-
-        relation
-      end
-
-      alias_method :has_options, :has_option
-    end
-  end
-end

data/db/migrate/20150515211137_fix_adjustment_order_id.rb

@@ -1,70 +0,0 @@
-class FixAdjustmentOrderId < ActiveRecord::Migration
-  def change
-    say 'Populate order_id from adjustable_id where appropriate'
-    execute(<<-SQL.squish)
-      UPDATE
-        spree_adjustments
-      SET
-        order_id = adjustable_id
-      WHERE
-        adjustable_type = 'Spree::Order'
-      ;
-    SQL
-
-    # Submitter of change does not care about MySQL, as it is not officially supported.
-    # Still spree officials decided to provide a working code path for MySQL users, hence
-    # submitter made a AR code path he could validate on PostgreSQL.
-    #
-    # Whoever runs a big enough MySQL installation where the AR solution hurts:
-    # Will have to write a better MySQL specific equivalent.
-    if Spree::Order.connection.adapter_name.eql?('MySQL')
-      Spree::Adjustment.where(adjustable_type: 'Spree::LineItem').find_each do |adjustment|
-        adjustment.update_columns(order_id: Spree::LineItem.find(adjustment.adjustable_id).order_id)
-      end
-    else
-      execute(<<-SQL.squish)
-        UPDATE
-          spree_adjustments
-        SET
-          order_id =
-            (SELECT order_id FROM spree_line_items WHERE spree_line_items.id = spree_adjustments.adjustable_id)
-        WHERE
-          adjustable_type = 'Spree::LineItem'
-      SQL
-    end
-
-    say 'Fix schema for spree_adjustments order_id column'
-    change_table :spree_adjustments do |t|
-      t.change :order_id, :integer, null: false
-    end
-
-    # Improved schema for postgresql, uncomment if you like it:
-    #
-    # # Negated Logical implication.
-    # #
-    # # When adjustable_type is 'Spree::Order' (p) the adjustable_id must be order_id (q).
-    # #
-    # # When adjustable_type is NOT 'Spree::Order' the adjustable id allowed to be any value (including of order_id in
-    # # case foreign keys match). XOR does not work here.
-    # #
-    # # Postgresql does not have an operator for logical implication. So we need to build the following truth table
-    # # via AND with OR:
-    # #
-    # #  p q | CHECK = !(p -> q)
-    # #  -----------
-    # #  t t | t
-    # #  t f | f
-    # #  f t | t
-    # #  f f | t
-    # #
-    # # According to de-morgans law the logical implication q -> p is equivalent to !p || q
-    # #
-    # execute(<<-SQL.squish)
-    #   ALTER TABLE ONLY spree_adjustments
-    #    ADD CONSTRAINT fk_spree_adjustments FOREIGN KEY (order_id)
-    #      REFERENCES spree_orders(id) ON UPDATE RESTRICT ON DELETE RESTRICT,
-    #    ADD CONSTRAINT check_spree_adjustments_order_id CHECK
-    #      (adjustable_type <> 'Spree::Order' OR order_id = adjustable_id);
-    # SQL
-  end
-end