solidus_core 2.0.3 → 2.1.0.beta1

data/app/models/spree/item_adjustments.rb

@@ -1,89 +0,0 @@
-module Spree
-  # Manage (recalculate) item (LineItem or Shipment) adjustments
-  class ItemAdjustments
-    attr_reader :item
-
-    # @param item [Order, LineItem, Shipment] the item whose adjustments should be updated
-    def initialize(item)
-      @item = item
-    end
-
-    # Update the item's adjustments and totals
-    #
-    # If the item is an {Order}, this will update and select the best
-    # promotion adjustment.
-    #
-    # If it is a {LineItem} or {Shipment}, it will update and select the best
-    # promotion adjustment, update tax adjustments, update cancellation
-    # adjustments, and then update the total fields (promo_total,
-    # included_tax_total, additional_tax_total, and adjustment_total) on the
-    # item.
-    #
-    # This is a noop if the item is not persisted.
-    def update
-      return @item unless item.persisted?
-
-      # 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.
-
-      promotion_adjustments = adjustments.select(&:promotion?)
-      promotion_adjustments.each(&:update!)
-
-      promo_total = Spree::Config.promotion_chooser_class.new(promotion_adjustments).update
-
-      # Calculating the totals for the order here would be incorrect. Order's
-      # totals are the sum of the adjustments on all child models, as well as
-      # its own.
-      #
-      # We want to select the best promotion for the order, but the remainder
-      # of the calculations here are done in the OrderUpdater instead.
-      return if item.is_a?(Spree::Order)
-
-      @item.promo_total = promo_total
-
-      tax = adjustments.select(&:tax?)
-
-      @item.included_tax_total = tax.select(&:included?).map(&:update!).compact.sum
-      @item.additional_tax_total = tax.reject(&:included?).map(&:update!).compact.sum
-
-      item_cancellation_total = adjustments.select(&:cancellation?).map(&:update!).compact.sum
-
-      @item.adjustment_total = @item.promo_total + @item.additional_tax_total + item_cancellation_total
-
-      @item.update_columns(
-        promo_total: @item.promo_total,
-        included_tax_total: @item.included_tax_total,
-        additional_tax_total: @item.additional_tax_total,
-        adjustment_total: @item.adjustment_total,
-        updated_at: Time.current
-      ) if @item.changed?
-
-      # In rails 4.2 update_columns isn't reflected in the changed_attributes hash,
-      # which means that multiple updates on the same in-memory model will
-      # behave incorrectly.
-      # In rails 5.0 changed_attributes works with update_columns and this is
-      # unnecessary.
-      item.attributes_changed_by_setter.except!(:promo_total, :included_tax_total, :additional_tax_total, :adjustment_total)
-
-      @item
-    end
-
-    private
-
-    def adjustments
-      @adjustments ||= item.adjustments.to_a
-    end
-  end
-end

data/app/models/spree/option_type_prototype.rb

@@ -1,6 +0,0 @@
-module Spree
-  class OptionTypePrototype < Spree::Base
-    belongs_to :option_type
-    belongs_to :prototype
-  end
-end

data/app/models/spree/property_prototype.rb

@@ -1,6 +0,0 @@
-module Spree
-  class PropertyPrototype < Spree::Base
-    belongs_to :prototype
-    belongs_to :property
-  end
-end

data/app/models/spree/prototype.rb

@@ -1,14 +0,0 @@
-module Spree
-  class Prototype < Spree::Base
-    has_many :property_prototypes
-    has_many :properties, through: :property_prototypes
-
-    has_many :option_type_prototypes
-    has_many :option_types, through: :option_type_prototypes
-
-    has_many :prototype_taxons, dependent: :destroy
-    has_many :taxons, through: :prototype_taxons
-
-    validates :name, presence: true
-  end
-end

data/app/models/spree/prototype_taxon.rb

@@ -1,6 +0,0 @@
-module Spree
-  class PrototypeTaxon < Spree::Base
-    belongs_to :prototype
-    belongs_to :taxon
-  end
-end

data/app/models/spree/tracker.rb

@@ -1,8 +0,0 @@
-module Spree
-  class Tracker < Spree::Base
-    def self.current
-      tracker = where(active: true).first
-      tracker.analytics_id.present? ? tracker : nil if tracker
-    end
-  end
-end

data/db/migrate/20150128032538_remove_environment_from_tracker.rb

@@ -1,6 +0,0 @@
-class RemoveEnvironmentFromTracker < ActiveRecord::Migration[4.2]
-  def up
-    Spree::Tracker.where('environment != ?', Rails.env).update_all(active: false)
-    remove_column :spree_trackers, :environment
-  end
-end

data/lib/generators/spree/dummy/templates/initializers/custom_user.rb

@@ -1 +0,0 @@
-# Spree.user_class = "User"

data/lib/spree/core/delegate_belongs_to.rb

@@ -1,94 +0,0 @@
-##
-# Creates methods on object which delegate to an association proxy.
-# see delegate_belongs_to for two uses
-#
-# Todo - integrate with ActiveRecord::Dirty to make sure changes to delegate object are noticed
-# Should do
-# class User < Spree::Base; delegate_belongs_to :contact, :firstname; end
-# class Contact < Spree::Base; end
-# u = User.first
-# u.changed? # => false
-# u.firstname = 'Bobby'
-# u.changed? # => true
-#
-# Right now the second call to changed? would return false
-#
-# Todo - add has_one support. fairly straightforward addition
-##
-module DelegateBelongsTo
-  extend ActiveSupport::Concern
-
-  module ClassMethods
-    @@default_rejected_delegate_columns = ['created_at', 'created_on', 'updated_at', 'updated_on', 'lock_version', 'type', 'id', 'position', 'parent_id', 'lft', 'rgt']
-    mattr_accessor :default_rejected_delegate_columns
-
-    ##
-    # Creates methods for accessing and setting attributes on an association.  Uses same
-    # default list of attributes as delegates_to_association.
-    # @todo Integrate this with ActiveRecord::Dirty, so if you set a property through one of these setters and then call save on this object, it will save the associated object automatically.
-    # delegate_belongs_to :contact
-    # delegate_belongs_to :contact, [:defaults]  ## same as above, and useless
-    # delegate_belongs_to :contact, [:defaults, :address, :fullname], :class_name => 'VCard'
-    ##
-    def delegate_belongs_to(association, *attrs)
-      Spree::Deprecation.warn "delegate_belongs_to is deprecated. Instead use rails built in delegates.", caller
-      opts = attrs.extract_options!
-      initialize_association :belongs_to, association, opts
-      attrs = get_association_column_names(association) if attrs.empty?
-      attrs.concat get_association_column_names(association) if attrs.delete :defaults
-      attrs.each do |attr|
-        class_def attr do |*args|
-          send(:delegator_for, association, attr, *args)
-        end
-
-        class_def "#{attr}=" do |val|
-          send(:delegator_for_setter, association, attr, val)
-        end
-      end
-    end
-
-    protected
-
-    def get_association_column_names(association, without_default_rejected_delegate_columns = true)
-        association_klass = reflect_on_association(association).klass
-        methods = association_klass.column_names
-        methods.reject!{ |x| default_rejected_delegate_columns.include?(x.to_s) } if without_default_rejected_delegate_columns
-        return methods
-    rescue
-        return []
-    end
-
-    ##
-    # initialize_association :belongs_to, :contact
-    def initialize_association(type, association, opts = {})
-      raise 'Illegal or unimplemented association type.' unless [:belongs_to].include?(type.to_s.to_sym)
-      send type, association, opts if reflect_on_association(association).nil?
-    end
-
-    private
-
-    def class_def(name, method = nil, &blk)
-      class_eval { method.nil? ? define_method(name, &blk) : define_method(name, method) }
-    end
-  end
-
-  def delegator_for(association, attr, *args)
-    return if self.class.column_names.include?(attr.to_s)
-    send("#{association}=", self.class.reflect_on_association(association).klass.new) if send(association).nil?
-    if args.empty?
-      send(association).send(attr)
-    else
-      send(association).send(attr, *args)
-    end
-  end
-
-  def delegator_for_setter(association, attr, val)
-    return if self.class.column_names.include?(attr.to_s)
-    send("#{association}=", self.class.reflect_on_association(association).klass.new) if send(association).nil?
-    send(association).send("#{attr}=", val)
-  end
-  protected :delegator_for
-  protected :delegator_for_setter
-end
-
-ActiveRecord::Base.send :include, DelegateBelongsTo

data/lib/spree/testing_support/factories/prototype_factory.rb

@@ -1,8 +0,0 @@
-require 'spree/testing_support/factories/property_factory'
-
-FactoryGirl.define do
-  factory :prototype, class: Spree::Prototype do
-    name 'Baseball Cap'
-    properties { [create(:property)] }
-  end
-end

data/lib/spree/testing_support/factories/tracker_factory.rb

@@ -1,6 +0,0 @@
-FactoryGirl.define do
-  factory :tracker, class: Spree::Tracker do
-    analytics_id 'A100'
-    active true
-  end
-end

data/spec/lib/spree/core/delegate_belongs_to_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-# This is a bit of a insane spec I have to admit
-# Chosed the spree_payment_methods table because it has a `name` column
-# already. Stubs wouldn't work here (the delegation runs before this spec is
-# loaded) and adding a column here might make the test even crazy so here we go
-module Spree
-  class DelegateBelongsToStubModel < Spree::Base
-    self.table_name = "spree_payment_methods"
-    belongs_to :product
-    Spree::Deprecation.silence do
-      delegate_belongs_to :product, :name
-    end
-  end
-
-  describe DelegateBelongsToStubModel do
-    context "model has column attr delegated to associated object" do
-      it "doesnt touch the associated object" do
-        expect(subject).not_to receive(:product)
-        subject.name
-      end
-    end
-  end
-end

data/spec/lib/spree/core/testing_support/factories/prototype_factory_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'spree/testing_support/factories/prototype_factory'
-
-RSpec.describe 'prototype factory' do
-  let(:factory_class) { Spree::Prototype }
-
-  describe 'plain prototype' do
-    let(:factory) { :prototype }
-
-    it_behaves_like 'a working factory'
-  end
-end

data/spec/lib/spree/core/testing_support/factories/tracker_factory_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'spree/testing_support/factories/tracker_factory'
-
-RSpec.describe 'tracker factory' do
-  let(:factory_class) { Spree::Tracker }
-
-  describe 'tracker' do
-    let(:factory) { :tracker }
-
-    it_behaves_like 'a working factory'
-  end
-end

data/spec/models/spree/item_adjustments_spec.rb

@@ -1,306 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  describe ItemAdjustments, type: :model do
-    let(:order) { create :order_with_line_items, line_items_count: 1 }
-    let(:line_item) { order.line_items.first }
-
-    let(:subject) { ItemAdjustments.new(line_item) }
-
-    context '#update' do
-      it "updates a linked adjustment" do
-        tax_rate = create(:tax_rate, amount: 0.05)
-        create(:adjustment, order: order, source: tax_rate, adjustable: line_item)
-        line_item.price = 10
-        line_item.tax_category = tax_rate.tax_category
-
-        subject.update
-        expect(line_item.adjustment_total).to eq(0.5)
-        expect(line_item.additional_tax_total).to eq(0.5)
-      end
-    end
-
-    context "taxes and promotions" do
-      let!(:tax_rate) do
-        create(:tax_rate, amount: 0.05)
-      end
-
-      let!(:promotion) do
-        Spree::Promotion.create(name: "$10 off")
-      end
-
-      let!(:promotion_action) do
-        calculator = Calculator::FlatRate.new(preferred_amount: 10)
-        Promotion::Actions::CreateItemAdjustments.create calculator: calculator, promotion: promotion
-      end
-
-      before do
-        line_item.price = 20
-        line_item.tax_category = tax_rate.tax_category
-        line_item.save
-        create(:adjustment, order: order, source: promotion_action, adjustable: line_item)
-      end
-
-      context "tax included in price" do
-        before do
-          create(:adjustment,
-            source: tax_rate,
-            adjustable: line_item,
-            order: order,
-            included: true
-          )
-        end
-
-        it "tax has no bearing on final price" do
-          subject.update
-          line_item.reload
-          expect(line_item.included_tax_total).to eq(0.5)
-          expect(line_item.additional_tax_total).to eq(0)
-          expect(line_item.promo_total).to eq(-10)
-          expect(line_item.adjustment_total).to eq(-10)
-        end
-
-        it "tax linked to order" do
-          order.update!
-          order.reload
-          expect(order.included_tax_total).to eq(0.5)
-          expect(order.additional_tax_total).to eq(00)
-        end
-      end
-
-      context "tax excluded from price" do
-        before do
-          create(:adjustment,
-            source: tax_rate,
-            adjustable: line_item,
-            order: order,
-            included: false
-          )
-        end
-
-        it "tax applies to line item" do
-          subject.update
-          line_item.reload
-          # Taxable amount is: $20 (base) - $10 (promotion) = $10
-          # Tax rate is 5% (of $10).
-          expect(line_item.included_tax_total).to eq(0)
-          expect(line_item.additional_tax_total).to eq(0.5)
-          expect(line_item.promo_total).to eq(-10)
-          expect(line_item.adjustment_total).to eq(-9.5)
-        end
-
-        it "tax linked to order" do
-          order.update!
-          expect(order.included_tax_total).to eq(0)
-          expect(order.additional_tax_total).to eq(0.5)
-        end
-      end
-    end
-
-    context "promotion chooser customization" do
-      before do
-        class Spree::TestPromotionChooser
-          def initialize(_adjustments)
-            raise "Custom promotion chooser"
-          end
-        end
-
-        Spree::Config.promotion_chooser_class = Spree::TestPromotionChooser
-      end
-
-      it "uses the defined promotion chooser" do
-        expect { subject.update }.to raise_error("Custom promotion chooser")
-      end
-    end
-
-    context "default promotion chooser (best promotion is always applied)" do
-      let(:calculator) { Calculator::FlatRate.new(preferred_amount: 10) }
-
-      let(:source) do
-        Promotion::Actions::CreateItemAdjustments.create!(
-          calculator: calculator,
-          promotion: promotion
-        )
-      end
-      let(:promotion) { create(:promotion) }
-
-      def create_adjustment(label, amount)
-        create(:adjustment, order: order,
-                            adjustable: line_item,
-                            source: source,
-                            amount: amount,
-                            finalized: true,
-                            label: label)
-      end
-
-      it "should make all but the most valuable promotion adjustment ineligible, leaving non promotion adjustments alone" do
-        create_adjustment("Promotion A", -100)
-        create_adjustment("Promotion B", -200)
-        create_adjustment("Promotion C", -300)
-        create(:adjustment, order: order,
-                            adjustable: line_item,
-                            source: nil,
-                            amount: -500,
-                            finalized: true,
-                            label: "Some other credit")
-        line_item.adjustments.each { |a| a.update_column(:eligible, true) }
-
-        subject.update
-
-        expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-        expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion C')
-      end
-
-      it "should choose the most recent promotion adjustment when amounts are equal" do
-        # Using Timecop is a regression test
-        Timecop.freeze do
-          create_adjustment("Promotion A", -200)
-          create_adjustment("Promotion B", -200)
-        end
-        line_item.adjustments.each { |a| a.update_column(:eligible, true) }
-
-        subject.update
-
-        expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-        expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion B')
-      end
-
-      it "should choose the most recent promotion adjustment when amounts are equal" do
-        # Using Timecop is a regression test
-        Timecop.freeze do
-          create_adjustment("Promotion A", -200)
-          create_adjustment("Promotion B", -200)
-        end
-        line_item.adjustments.each { |a| a.update_column(:eligible, true) }
-
-        subject.update
-
-        expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-        expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion B')
-      end
-
-      context "when previously ineligible promotions become available" do
-        let(:order_promo1) { create(:promotion, :with_order_adjustment, :with_item_total_rule, weighted_order_adjustment_amount: 5, item_total_threshold_amount: 10) }
-        let(:order_promo2) { create(:promotion, :with_order_adjustment, :with_item_total_rule, weighted_order_adjustment_amount: 10, item_total_threshold_amount: 20) }
-        let(:order_promos) { [order_promo1, order_promo2] }
-        let(:line_item_promo1) { create(:promotion, :with_line_item_adjustment, :with_item_total_rule, adjustment_rate: 2.5, item_total_threshold_amount: 10, apply_automatically: true) }
-        let(:line_item_promo2) { create(:promotion, :with_line_item_adjustment, :with_item_total_rule, adjustment_rate: 5, item_total_threshold_amount: 20, apply_automatically: true) }
-        let(:line_item_promos) { [line_item_promo1, line_item_promo2] }
-        let(:order) { create(:order_with_line_items, line_items_count: 1) }
-
-        # Apply promotions in different sequences. Results should be the same.
-        promo_sequences = [
-          [0, 1],
-          [1, 0]
-        ]
-
-        promo_sequences.each do |promo_sequence|
-          it "should pick the best order-level promo according to current eligibility" do
-            # apply both promos to the order, even though only promo1 is eligible
-            order_promos[promo_sequence[0]].activate order: order
-            order_promos[promo_sequence[1]].activate order: order
-
-            order.update!
-            order.reload
-            expect(order.all_adjustments.count).to eq(2), "Expected two adjustments (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.count).to eq(1), "Expected one elegible adjustment (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo1), "Expected promo1 to be used (using sequence #{promo_sequence})"
-
-            order.contents.add create(:variant, price: 10), 1
-            order.save
-
-            order.reload
-            expect(order.all_adjustments.count).to eq(2), "Expected two adjustments (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.count).to eq(1), "Expected one elegible adjustment (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo2), "Expected promo2 to be used (using sequence #{promo_sequence})"
-          end
-        end
-
-        promo_sequences.each do |promo_sequence|
-          it "should pick the best line-item-level promo according to current eligibility" do
-            # apply both promos to the order, even though only promo1 is eligible
-            line_item_promos[promo_sequence[0]].activate order: order
-            line_item_promos[promo_sequence[1]].activate order: order
-
-            order.reload
-            expect(order.all_adjustments.count).to eq(1), "Expected one adjustment (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.count).to eq(1), "Expected one elegible adjustment (using sequence #{promo_sequence})"
-            # line_item_promo1 is the only one that has thus far met the order total threshold, it is the only promo which should be applied.
-            expect(order.all_adjustments.first.source.promotion).to eq(line_item_promo1), "Expected line_item_promo1 to be used (using sequence #{promo_sequence})"
-
-            order.contents.add create(:variant, price: 10), 1
-            order.save
-
-            order.reload
-            expect(order.all_adjustments.count).to eq(4), "Expected four adjustments (using sequence #{promo_sequence})"
-            expect(order.all_adjustments.eligible.count).to eq(2), "Expected two elegible adjustments (using sequence #{promo_sequence})"
-            order.all_adjustments.eligible.each do |adjustment|
-              expect(adjustment.source.promotion).to eq(line_item_promo2), "Expected line_item_promo2 to be used (using sequence #{promo_sequence})"
-            end
-          end
-        end
-      end
-
-      context "multiple adjustments and the best one is not eligible" do
-        let!(:promo_a) { create_adjustment("Promotion A", -100) }
-        let!(:promo_c) { create_adjustment("Promotion C", -300) }
-
-        before do
-          promo_a.update_column(:eligible, true)
-          promo_c.update_column(:eligible, false)
-        end
-
-        # regression for https://github.com/spree/spree/issues/3274
-        it "still makes the previous best eligible adjustment valid" do
-          subject.update
-          expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion A')
-        end
-      end
-
-      it "should only leave one adjustment even if 2 have the same amount" do
-        create_adjustment("Promotion A", -100)
-        create_adjustment("Promotion B", -200)
-        create_adjustment("Promotion C", -200)
-
-        subject.update
-
-        expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-        expect(line_item.adjustments.promotion.eligible.first.amount.to_i).to eq(-200)
-      end
-    end
-
-    context "multiple updates" do
-      let(:adjustment) { create(:tax_adjustment, amount: -10) }
-      let(:item) { adjustment.adjustable }
-      # we need to get this from the line item so that we're modifying the same
-      # tax rate that is cached by line_item.adjustments
-      let(:source) { item.adjustments.to_a.first.source }
-
-      def update
-        described_class.new(item).update
-      end
-
-      # "fresh" record from the DB
-      def db_record
-        Spree::LineItem.find(item.id)
-      end
-
-      it "persists each change" do
-        source.update_attributes!(amount: 0.1)
-        update
-        expect(item).not_to be_changed
-        expect(db_record).to have_attributes(adjustment_total: 1)
-
-        source.update_attributes!(amount: 0.20)
-        update
-        expect(item).not_to be_changed
-        expect(db_record).to have_attributes(adjustment_total: 2)
-
-        source.update_attributes!(amount: 0.10)
-        update
-        expect(item).not_to be_changed
-        expect(db_record).to have_attributes(adjustment_total: 1)
-      end
-    end
-  end
-end