spree-line_item_discount 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f9f715a59787c41fa9aa861b9eeb2e7b85a491cd
+  data.tar.gz: 6e97f1872121803605274f50b26d6ce0b0e0c089
+SHA512:
+  metadata.gz: 8d1b8275cb2650d48a2a2f857f348f97e72afa1813efd080c74e2fe4110025028972b19f9f21eabc7fe23e7b4e862bda9d8639af03e89f1bdbac2407a19e859b
+  data.tar.gz: 9878ca2787faf412ced9626779bed972c1b90e9d88560789dadcadebcfd9367366821264247842630af2faba8996257d9d48d9aebafdb5b100c0c4ccb9010ca5

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/dummy

data/.travis.yml

@@ -0,0 +1,10 @@
+before_script:
+  - sh -e /etc/init.d/xvfb start
+  - export DISPLAY=:99.0
+  - bundle update
+  - bundle exec rake test_app
+
+script: bundle exec rspec spec
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem 'spree', '~> 2.0.4'
+
+group :test do
+  gem 'ffaker'
+  gem 'pry-rails'
+end
+
+# Specify your gem's dependencies in spree_line_item_discounts.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Washington Luiz
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# Spree Line Item Discounts
+
+* Apply promo adjustments at the LineItem level on a Spree ~> 2.0 install
+
+* Item Discount promos don't require `event_name` they should be set to nil
+
+* Item Discount promos should only have one single action
+
+* Adjustments should be inserted at the line item creation before the order
+  receive `update!`. Hopefully that will give room to make order changes way more
+  perfomant
+
+* The same promo may apply adjustments to multiple line items on the order
+
+* Multiple adjustments from different promos may be applied to the same line item
+
+* The same adjustment cannot apply twice on the same item
+
+## Installation
+
+Add to your Gemfile, bundle install and you should be ready to go.
+
+```ruby
+gem 'spree-line_item_discount', github: 'huoxito/spree-line_item_discount'
+```
+
+## Usage
+
+1. Create a Promotion but do not choose any event name for the promotion.
+2. Set up promotion rules as you please
+3. Add a _Create line item discount_ action to the promotion
+4. Set up the percent as you please (currently has only one Calculator)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rubygems/package_task'
+require 'rspec/core/rake_task'
+require 'spree/testing_support/common_rake'
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+
+spec = eval(File.read('spree_line_item_discount.gemspec'))
+
+Gem::PackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+desc "Generates a dummy app for testing"
+task :test_app do
+  ENV['LIB_NAME'] = 'spree_line_item_discount'
+  Rake::Task['common:test_app'].invoke
+end

data/app/controllers/spree/admin/promotions_controller_decorator.rb

@@ -0,0 +1,15 @@
+module Spree
+  module Admin
+    PromotionsController.class_eval do
+      protected
+        # Overriden from Spree core
+        #
+        # Give frontend users a chance to ignore event_name as promos by the
+        # extension should have event_name set to nil
+        def load_event_names
+          @event_names = Spree::Activator.event_names.map { |name| [Spree.t("events.#{name}"), name] }
+          @event_names.unshift []
+        end
+    end
+  end
+end

data/app/models/spree/adjustment_decorator.rb

@@ -0,0 +1,22 @@
+module Spree
+  Adjustment.class_eval do
+    scope :source_order, -> { where(source_type: "Spree::Order") }
+
+    # Overriden from Spree core
+    #
+    # Allow originator of the adjustment to perform an additional eligibility of the adjustment
+    # Should return _true_ if originator is absent or doesn't implement _eligible?_
+    #
+    # Pass the +adjustable+ object instead of the +source+ to +eligible?+ to allow
+    # the extension to check concurrent discounts for a line item. This shouldn't
+    # make any difference on the original mtehod for spree_core beacuse there
+    # both +adjustable+ and +source+ is the same Order object
+    #
+    # FIXME maybe we don't need to care about concurrent line item adjustments
+    # right now so passing just the order should be fine
+    def eligible_for_originator?
+      return true if originator.nil?
+      !originator.respond_to?(:eligible?) || originator.eligible?(adjustable)
+    end
+  end
+end

data/app/models/spree/line_item_decorator.rb

@@ -0,0 +1,20 @@
+module Spree
+  LineItem.class_eval do
+    # Trigger LineItemDiscount promos
+    #
+    # It makes more sense to run it here because the order did not receive
+    # +update!+ just yet. If it complied with the usual Spree AS::Notifications
+    # events promo triggers we would have to run +update!+ on the order for each
+    # promo which is not perfomant at all
+    after_create :activate_discounts
+
+    private
+      def activate_discounts
+        unless order.completed?
+          LineItemDiscount::Adjust.all.each do |adjust_discount|
+            adjust_discount.perform(self)
+          end
+        end
+      end
+  end
+end

data/app/models/spree/line_item_discount/adjust.rb

@@ -0,0 +1,102 @@
+module Spree
+  module LineItemDiscount
+    class Adjust < PromotionAction
+      include Core::CalculatedAdjustments
+
+      attr_reader :order, :line_items, :adjustable
+
+      has_many :adjustments, :as => :originator
+
+      before_validation :ensure_action_has_calculator
+
+      # decide whether adjustment should be deleted or not
+      before_destroy :deals_with_adjustments
+
+      # Create the adjustment
+      #
+      # It needs to create the adjustment here anyway because the action only
+      # performs when the line item is created.
+      #
+      # Doesn't need care about adjustment eligibility as that's done later on
+      # down the stack
+      def perform(line_item)
+        @order, @line_items = line_item.order, line_item
+
+        unless has_applied?(line_item)
+          amount = self.compute_amount(line_item)
+          adjustment = create_adjustment(amount: amount, adjustable: line_item, source: order)
+        end
+      end
+
+      # Receives an adjustable object (here a LineItem)
+      #
+      # FIXME Remove concurrent discount logic
+      def eligible?(adjustable)
+        @adjustable, @order = adjustable, adjustable.order
+        self.promotion.eligible?(order) && best_than_concurrent_discounts?
+      end
+
+      # Receives an adjustable object (here a LineItem)
+      #
+      # Returns total discount for the adjustable
+      def compute_amount(adjustable)
+        amount = self.calculator.compute(adjustable).to_f.abs
+        [adjustable.total, amount].min * -1
+      end
+
+      private
+        def has_applied?(item)
+          self.adjustments.map(&:adjustable).flatten.include? item
+        end
+
+        def create_adjustment(params)
+          self.adjustments.create(default_adjustment_params.merge(params), :without_protection => true)
+        end
+
+        def best_than_concurrent_discounts?
+          return false if current_discount == 0
+          if current_discount == best_concurrent_amount && best_concurrent_discount.eligible
+            return false
+          end
+
+          current_discount <= best_concurrent_amount || !best_concurrent_discount.eligible
+        end
+
+        def current_adjustment
+          @adjustment ||= self.adjustments.where("adjustable_id = ? AND adjustable_type = ?", adjustable.id, adjustable.class.name).first
+        end
+
+        def current_discount
+          current_adjustment.amount
+        end
+
+        def best_concurrent_amount
+          best_concurrent_discount ? best_concurrent_discount.amount : 0
+        end
+
+        def best_concurrent_discount
+          adjustable.adjustments.promotion.eligible
+            .where('id NOT IN (?)', [current_adjustment]).max { |a,b| a.amount.abs <=> b.amount.abs }
+        end
+
+        def default_adjustment_params
+          { :label => self.promotion.name, :mandatory => false }
+        end
+
+        def ensure_action_has_calculator
+          self.calculator = Percent.new unless self.calculator
+        end
+
+        def deals_with_adjustments
+          self.adjustments.each do |adjustment|
+            if adjustment.source.complete?
+              adjustment.originator = nil
+              adjustment.save
+            else
+              adjustment.destroy
+            end
+          end
+        end
+    end
+  end
+end

data/app/models/spree/line_item_discount/percent.rb

@@ -0,0 +1,16 @@
+module Spree
+  module LineItemDiscount
+    class Percent < Calculator
+      preference :percent, :decimal, :default => 0
+      attr_accessible :preferred_percent
+
+      def self.description
+        Spree.t(:percent_per_item)
+      end
+
+      def compute(item)
+        ((item.price * item.quantity) * preferred_percent) / 100
+      end
+    end
+  end
+end

data/app/models/spree/line_item_discount/promotion_pool.rb

@@ -0,0 +1,67 @@
+module Spree
+  module LineItemDiscount
+    # Compute adjustment amount and set their eligibility for all eligible promos
+    #
+    # The reason for doing it in a different class is that we only check the
+    # promotion eligibility once. It also should make it pretty easy to manage
+    # which adjustments should actually be computed. It doesn't make sense
+    # to compute values for adjustments that are not eligible. As the extension
+    # allows multiple adjustments for the same line item.
+    #
+    # e.g.
+    # Say we have 10 LineItemDiscount promos. An order with 5 items may have
+    # 50 adjustments. That would make order changes really slow as it will run
+    # +eligible?+ on 50 adjustments. Instead we group the data so that it
+    # only runs eligible? once on each promotion on each order change
+    #
+    # ps. watch out for scenarios where the promo eligibilty changes as adjustments
+    # are applied to the order total. Hopefully such cases don't exist and if
+    # they do we might just consider that adjustments or any probably other
+    # promotion action should not change the order eligibility among existing
+    # promotions
+    class PromotionPool
+      attr_reader :actions, :order
+
+      def initialize(order)
+        @order = order
+        @actions = Adjust.includes(:promotion).all
+      end
+
+      # Returns array of all eligible actions for the current order
+      def eligible
+        actions.select { |action| action.promotion.eligible? order }
+      end
+
+      # Returns array of all line item adjustments eligible for current order
+      def valid_discounts
+        adjustments(eligible.map(&:id))
+      end
+
+      def invalid_discounts
+        adjustments(not_eligible.map(&:id))
+      end
+
+      def not_eligible
+        actions.select { |action| !action.promotion.eligible? order }
+      end
+
+      # Update adjustment amounts for eligible actions
+      #
+      # Use +update_adjustment+ as it will not run any callbacks making
+      def adjust!
+        valid_discounts.each do |adjustment|
+          adjustment.originator.update_adjustment(adjustment, adjustment.adjustable)
+        end
+
+        valid_discounts.update_all(eligible: true)
+        invalid_discounts.update_all(eligible: false)
+      end
+
+      private
+        def adjustments(originator_ids)
+          Adjustment.promotion.source_order.includes(:originator)
+            .where(originator_id: originator_ids, source_id: order.id)
+        end
+    end
+  end
+end

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,44 @@
+module Spree
+  Order.class_eval do
+    has_many :line_item_adjustments, through: :line_items, source: :adjustments
+
+    # Overriden from spree core
+    # So that we can also lock line_item adjustments
+    #
+    # TODO Refactoring spree core by adding an Order `finalize_hooks` method
+    # similar to what we currently have in OrderUpdater. That gives room
+    # to implement custom logic without having to override the +finalize!+ method
+    #
+    # Finalizes an in progress order after checkout is complete.
+    # Called after transition to complete state when payments will have been processed
+    def finalize!
+      touch :completed_at
+
+      # lock all adjustments (coupon promotions, etc.)
+      adjustments.update_all "state = 'closed'"
+
+      # As of Spree::LineItemDiscount
+      line_item_adjustments.update_all "state = 'closed'"
+
+      # update payment and shipment(s) states, and save
+      updater.update_payment_state
+      shipments.each do |shipment|
+        shipment.update!(self)
+        shipment.finalize!
+      end
+
+      updater.update_shipment_state
+      save
+      updater.run_hooks
+
+      deliver_order_confirmation_email
+
+      self.state_changes.create({
+        previous_state: 'cart',
+        next_state:     'complete',
+        name:           'order' ,
+        user_id:        self.user_id
+      }, without_protection: true)
+    end
+  end
+end

data/app/models/spree/order_updater_decorator.rb

@@ -0,0 +1,40 @@
+module Spree
+  OrderUpdater.class_eval do
+    # Overriden from Spree core
+    # So that it sums line_items_adjustments total to order.adjustment_total
+    #
+    # Updates the following Order total values:
+    #
+    # +payment_total+      The total value of all finalized Payments (NOTE: non-finalized Payments are excluded)
+    # +item_total+         The total value of all LineItems
+    # +adjustment_total+   The total value of all adjustments (promotions, credits, etc.)
+    # +total+              The so-called "order total."  This is equivalent to +item_total+ plus +adjustment_total+.
+    def update_totals
+      order.payment_total = payments.completed.map(&:amount).sum
+      order.item_total = line_items.map(&:amount).sum
+      order.adjustment_total = adjustments.eligible.map(&:amount).sum + items_adjustments_total
+      order.total = order.item_total + order.adjustment_total
+    end
+
+    # Overriden from Spree core
+    # As of LineItemDiscount it updates adjustments value and eligibility
+    #
+    # Updates each of the Order adjustments.
+    #
+    # This is intended to be called from an Observer so that the Order can
+    # respond to external changes to LineItem, Shipment, other Adjustments, etc.
+    #
+    # Adjustments will check if they are still eligible. Ineligible adjustments
+    # are preserved but not counted towards adjustment_total.
+    def update_adjustments
+      order.adjustments.reload.each { |adjustment| adjustment.update! }
+      choose_best_promotion_adjustment
+      LineItemDiscount::PromotionPool.new(order).adjust!
+    end
+
+    private
+      def items_adjustments_total
+        order.line_item_adjustments.eligible.sum(&:amount)
+      end
+  end
+end

data/app/models/spree/tax_rate_decorator.rb

@@ -0,0 +1,12 @@
+module Spree
+  TaxRate.class_eval do
+    def self.adjust(order)
+      order.adjustments.tax.destroy_all
+      order.line_item_adjustments.where(originator_type: 'Spree::TaxRate').destroy_all
+
+      self.match(order).each do |rate|
+        rate.adjust(order)
+      end
+    end
+  end
+end

data/app/views/spree/admin/promotions/actions/_adjust.html.erb

@@ -0,0 +1,22 @@
+<div class="calculator-fields row">
+  <div class="field alpha four columns">
+    <% field_name = "#{param_prefix}[calculator_type]" %>
+    <%= label_tag field_name, t(:calculator) %>
+    <%= select_tag field_name, options_from_collection_for_select([Spree::LineItemDiscount::Percent], :to_s, :description, promotion_action.calculator.type),
+                   :class => 'type-select select2 fullwidth' %>
+    <% if promotion_action.calculator.respond_to?(:preferences) %>
+      <span class="warning info"><%= t(:calculator_settings_warning) %></span>
+    <% end %>
+  </div>
+
+  <div class="settings field omega four columns">
+    <% promotion_action.calculator.preferences.keys.map do |key| %>
+      <% field_name = "#{param_prefix}[calculator_attributes][preferred_#{key}]" %>
+      <%= label_tag field_name, t(key.to_s) %>
+      <%= preference_field_tag(field_name,
+                               promotion_action.calculator.get_preference(key),
+                               :type => promotion_action.calculator.preference_type(key)) %>
+    <% end %>
+    <%= hidden_field_tag "#{param_prefix}[calculator_attributes][id]", promotion_action.calculator.id %>
+  </div>
+</div>

data/config/locales/en.yml

@@ -0,0 +1,6 @@
+en:
+  spree:
+    promotion_action_types:
+      adjust:
+        name: "Create line item discount"
+        description: "Creates an adjustment as per item on the order"

data/lib/spree/line_item_discount.rb

@@ -0,0 +1,2 @@
+require 'spree_core'
+require "spree/line_item_discount/engine"

data/lib/spree/line_item_discount/engine.rb

@@ -0,0 +1,25 @@
+module Spree
+  module LineItemDiscount
+    class Engine < Rails::Engine
+      engine_name 'spree/line_item_discount'
+
+      config.autoload_paths += %W(#{config.root}/lib)
+
+      config.generators do |g|
+        g.test_framework :rspec
+      end
+
+      initializer 'spree.promo.register.promotions.actions' do |app|
+        app.config.spree.promotions.actions << Adjust
+      end
+
+      def self.activate
+        Dir.glob(File.join(File.dirname(__FILE__), "../../../app/**/*_decorator*.rb")) do |c|
+          Rails.configuration.cache_classes ? require(c) : load(c)
+        end
+      end
+
+      config.to_prepare &method(:activate).to_proc
+    end
+  end
+end

data/lib/spree/line_item_discount/version.rb

@@ -0,0 +1,5 @@
+module Spree
+  module LineItemDiscount
+    VERSION = "0.0.1"
+  end
+end

data/lib/spree_line_item_discount.rb

@@ -0,0 +1 @@
+require 'spree/line_item_discount'

data/spec/models/spree/line_item_discount/adjust_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+module Spree
+  module LineItemDiscount
+    describe Adjust do
+      let(:order) { create(:order) }
+      let(:promotion) { create(:promotion) }
+      let(:action) { Adjust.new }
+      let!(:line_item) { create(:line_item, :order => order) }
+
+      before { action.stub(:promotion => promotion) }
+
+      context "#perform" do
+        before { promotion.promotion_actions = [action] }
+
+        it "computes amount before creating adjustment" do
+          action.should_receive(:compute_amount).with(line_item).ordered
+          action.should_receive(:create_adjustment).ordered
+          action.perform(line_item)
+        end
+
+        it "creates adjustment with item as adjustable" do
+          action.perform(line_item)
+          line_item.adjustments.should == action.adjustments
+        end
+
+        it "creates adjustment with order as source" do
+          action.perform(line_item)
+          expect(line_item.adjustments.first.source).to eq order
+        end
+
+        it "does not perform twice on the same item" do
+          2.times { action.perform(line_item) }
+          action.adjustments.count.should == 1
+        end
+      end
+
+      context "#eligible" do
+        context "promotion is not eligible" do
+          before { promotion.stub(eligible?: false) }
+          it { action.should_not be_eligible(line_item) }
+        end
+
+        context "has a concurrent discount" do
+          let(:adjustment) { mock_model(Spree::Adjustment, :amount => -100, :adjustable => line_item) }
+          let(:concurrent) { mock_model(Spree::Adjustment, :amount => -100, :adjustable => line_item) }
+
+          before(:each) do
+            action.should_receive(:current_adjustment).at_least(:once).and_return(adjustment)
+            action.should_receive(:best_concurrent_discount).at_least(:once).and_return(concurrent)
+          end
+
+          context "with same amount" do
+            context "but not eligible" do
+              before { concurrent.stub(:eligible => false) }
+              specify { action.should be_eligible(line_item) }
+            end
+
+            context "and eligible" do
+              before { concurrent.stub(:eligible => true) }
+              specify { action.should_not be_eligible(line_item) }
+            end
+          end
+
+          context "which is better" do
+            before { concurrent.stub(:amount => -200) }
+
+            context "but not eligible" do
+              before { concurrent.stub(:eligible => false) }
+              it { expect(action).to be_eligible(line_item) }
+            end
+
+            context "and eligible" do
+              before { concurrent.stub(:eligible => true) }
+              it { expect(action).to_not be_eligible(line_item) }
+            end
+          end
+
+          context "which is worse" do
+            before { concurrent.stub(:amount => -20) }
+            it { expect(action).to be_eligible(line_item) }
+          end
+        end
+      end
+
+      context "#compute_amount" do
+        before { promotion.promotion_actions = [action] }
+
+        it "calls compute on the calculator" do
+          action.calculator.should_receive(:compute).with(line_item)
+          action.compute_amount(line_item)
+        end
+
+        context "calculator returns amount greater than item total" do
+          before do
+            action.calculator.should_receive(:compute).with(line_item).and_return(300)
+            line_item.stub(total: 100)
+          end
+
+          it "does not exceed it" do
+            action.compute_amount(line_item).should eql(-100)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/line_item_discount/promotion_pool_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module Spree
+  module LineItemDiscount
+    describe PromotionPool do
+      let(:order) { create(:order) }
+      let(:variant) { create(:variant) }
+
+      let(:rule) { Promotion::Rules::ItemTotal.create(preferred_amount: 30, preferred_operator: "gt") }
+      let(:calculator) { LineItemDiscount::Percent.create(preferred_percent: 10) }
+      let(:action) { LineItemDiscount::Adjust.new }
+      let(:promotion) { create(:promotion) }
+
+      before do
+        promotion.actions << action
+        action.calculator = calculator
+        action.save!
+
+        promotion.rules << rule
+      end
+
+      subject { PromotionPool.new(order) }
+
+      context "existing promo is not eligible" do
+        before { order.contents.add(variant, 1) }
+
+        it { expect(subject.eligible).to be_empty }
+
+        it "doesn't return adjustments from that promo" do
+          expect(subject.valid_discounts.map(&:originator)).to eq []
+        end
+
+        context "promo becomes eligible" do
+          let!(:previous_adjustment) { order.line_items.first.adjustments.first }
+
+          before { order.contents.add(variant, 8) }
+
+          it "adjust existing adjustments values" do
+            subject.adjust!
+            expect(subject.valid_discounts.map(&:amount)).to_not eq [previous_adjustment.amount]
+          end
+        end
+      end
+
+      context "existing promo is eligible" do
+        before { order.contents.add(variant, 8) }
+
+        it "returns array of eligible actions" do
+          expect(subject.eligible).to eq [action]
+        end
+
+        it "returns adjustments from that promo" do
+          expect(subject.valid_discounts.map(&:originator)).to eq [action]
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/line_item_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module Spree
+  describe LineItem do
+    let(:variant) { create(:variant) }
+    let(:order) { Order.create }
+
+    context "completed order" do
+      before { Order.any_instance.stub completed?: true }
+
+      it "doesnt activate discounts" do
+        pending "implement something like LineItemDiscount::Adjust.activate"
+        expect(LineItemDiscount::Adjust).not_to receive(:all)
+        order.contents.add(variant, 1)
+      end
+    end
+  end
+end

data/spec/models/spree/order_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Spree
+  describe Order do
+    let(:line_item) { create(:line_item) }
+    let(:order) { line_item.order }
+
+    let(:promotion) { create(:promotion) }
+    let(:calculator) { LineItemDiscount::Percent.create(preferred_percent: 10) }
+    let(:action) { LineItemDiscount::Adjust.create({promotion: promotion, calculator: calculator}, without_protection: true) }
+
+    context "finalize" do
+      before { action.perform(line_item) }
+
+      it "locks line item adjustments" do
+        order.finalize!
+        expect(order.line_item_adjustments.first).to be_closed
+      end
+    end
+  end
+end

data/spec/models/spree/order_updater_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module Spree
+  describe OrderUpdater do
+    let(:order) { create(:order) }
+    let(:variant) { create(:variant) }
+
+    let(:calculator) { LineItemDiscount::Percent.create(preferred_percent: 10) }
+    let(:action) { LineItemDiscount::Adjust.new }
+    let(:promotion) { create(:promotion) }
+
+    before do
+      promotion.actions << action
+      action.calculator = calculator
+      action.save!
+    end
+
+    context "eligible promo" do
+      before { order.contents.add(variant, 1) }
+
+      it "applies existing line item discounts" do
+        expect(order.total.to_f).to_not eql variant.price.to_f
+      end
+
+      context "not eligible anymore" do
+        let(:rule) { Promotion::Rules::ItemTotal.create(preferred_amount: 3000, preferred_operator: "gt") }
+
+        before do
+          promotion.rules << rule
+          order.contents.add(variant, 1)
+        end
+
+        it "no longer apply line item adjustment" do
+          expect(order.total.to_f).to eql (variant.price * 2).to_f
+        end
+      end
+    end
+
+    context "promo not eligible when item is first created" do
+      # Order total needs to be greater than 30
+      let(:rule) { Promotion::Rules::ItemTotal.create(preferred_amount: 30, preferred_operator: "gt") }
+
+      before do
+        promotion.rules << rule
+        expect(variant.price).to be < rule.preferred_amount
+        order.contents.add(variant, 1)
+      end
+
+      it "doesn't apply existing discount to order total" do
+        expect(order.total.to_f).to eql variant.price.to_f
+      end
+
+      context "but becomes eligible later on" do
+        before do
+          order.contents.add(variant, 8)
+        end
+
+        it "applies existing discount to order total" do
+          expect(order.total.to_f).to_not eql (variant.price * 9).to_f
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+ENV["RAILS_ENV"] = "test"
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+
+require 'rspec/rails'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each {|f| require f }
+
+require 'spree/testing_support/factories'
+
+Dir["#{File.dirname(__FILE__)}/factories/**"].each do |f|
+  fp =  File.expand_path(f)
+  require fp
+end
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  # config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  config.include FactoryGirl::Syntax::Methods
+end

data/spree_line_item_discount.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'spree/line_item_discount/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "spree-line_item_discount"
+  gem.version       = Spree::LineItemDiscount::VERSION
+  gem.authors       = ["Washington Luiz"]
+  gem.email         = ["huoxito@gmail.com"]
+  gem.description   = "Apply promotion adjustments per items"
+  gem.summary       = "Apply promotion adjustments per items"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'spree_core', '~> 2.0.0'
+
+  gem.add_development_dependency 'factory_girl', '~> 4.2'
+  gem.add_development_dependency 'rspec-rails',  '~> 2.14'
+  gem.add_development_dependency 'sqlite3'
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: spree-line_item_discount
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Washington Luiz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: spree_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Apply promotion adjustments per items
+email:
+- huoxito@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/controllers/spree/admin/promotions_controller_decorator.rb
+- app/models/spree/adjustment_decorator.rb
+- app/models/spree/line_item_decorator.rb
+- app/models/spree/line_item_discount/adjust.rb
+- app/models/spree/line_item_discount/percent.rb
+- app/models/spree/line_item_discount/promotion_pool.rb
+- app/models/spree/order_decorator.rb
+- app/models/spree/order_updater_decorator.rb
+- app/models/spree/tax_rate_decorator.rb
+- app/views/spree/admin/promotions/actions/_adjust.html.erb
+- config/locales/en.yml
+- lib/spree/line_item_discount.rb
+- lib/spree/line_item_discount/engine.rb
+- lib/spree/line_item_discount/version.rb
+- lib/spree_line_item_discount.rb
+- spec/models/spree/line_item_discount/adjust_spec.rb
+- spec/models/spree/line_item_discount/promotion_pool_spec.rb
+- spec/models/spree/line_item_spec.rb
+- spec/models/spree/order_spec.rb
+- spec/models/spree/order_updater_spec.rb
+- spec/spec_helper.rb
+- spree_line_item_discount.gemspec
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Apply promotion adjustments per items
+test_files:
+- spec/models/spree/line_item_discount/adjust_spec.rb
+- spec/models/spree/line_item_discount/promotion_pool_spec.rb
+- spec/models/spree/line_item_spec.rb
+- spec/models/spree/order_spec.rb
+- spec/models/spree/order_updater_spec.rb
+- spec/spec_helper.rb