solidus_core_devise_token_auth 2.8.0.alpha.0

data/lib/tasks/migrations/copy_order_bill_address_to_credit_card.rake

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+namespace 'spree:migrations:copy_order_bill_address_to_credit_card' do
+  # This copies the billing address from the order associated with a
+  # credit card's most recent payment to the credit card.
+
+  # Used in the migration CopyOrderBillAddressToCreditCard and made available as a
+  # rake task to allow running it a second time after deploying the new code, in
+  # case some order->credit card data was missed between the time that the
+  # migration was run and the application servers were restarted with the new
+  # code.
+
+  # This task should be safe to run multiple times.
+
+  task up: :environment do
+    if Spree::CreditCard.connection.adapter_name =~ /postgres/i
+      postgres_copy
+    else
+      ruby_copy
+    end
+  end
+
+  task down: :environment do
+    Spree::CreditCard.update_all(address_id: nil)
+  end
+
+  def ruby_copy
+    scope = Spree::CreditCard.where(address_id: nil).includes(payments: :order)
+
+    scope.find_each(batch_size: 500) do |cc|
+      # remove payments that lack a bill address
+      payments = cc.payments.select { |p| p.order.bill_address_id }
+
+      payment = payments.sort_by do |p|
+        [
+          %w(failed invalid).include?(p.state) ? 0 : 1, # prioritize valid payments
+          p.created_at, # prioritize more recent payments
+        ]
+      end.last
+
+      next if payment.nil?
+
+      cc.update_column(:address_id, payment.order.bill_address_id)
+      puts "Successfully associated billing address (#{payment.order.bill_address_id}) with credit card (#{cc.id})"
+    end
+  end
+
+  # This was 20x faster for us but the syntax is postgres-specific. I'm sure
+  # there are equivalent versions for other DBs if someone wants to write them.
+  # I took a quick stab at crafting a cross-db compatible version but it was
+  # slow.
+  def postgres_copy
+    batch_size = 10_000
+
+    current_start_id = 1
+
+    while current_start_id <= last_credit_card_id
+      current_end_id = current_start_id + batch_size
+      puts "updating #{current_start_id} to #{current_end_id}"
+
+      # first try to find a valid payment for each credit card
+      Spree::CreditCard.connection.execute(
+        postgres_sql(
+          start_id: current_start_id,
+          end_id: current_end_id,
+          payment_state: "not in ('failed', 'invalid')"
+        )
+      )
+
+      # fall back to using invalid payments for each credit card
+      Spree::CreditCard.connection.execute(
+        postgres_sql(
+          start_id: current_start_id,
+          end_id: current_end_id,
+          payment_state: "in ('failed', 'invalid')"
+        )
+      )
+
+      current_start_id += batch_size
+    end
+  end
+
+  def postgres_sql(start_id:, end_id:, payment_state:)
+    <<-SQL
+      update spree_credit_cards c
+      set address_id = o.bill_address_id
+      from spree_payments p
+      inner join spree_orders o
+        on  o.id = p.order_id
+        and o.bill_address_id is not null
+      left join (
+        select p2.*
+        from spree_payments p2
+        inner join spree_orders o2
+          on  o2.id = p2.order_id
+          and o2.bill_address_id is not null
+      ) more_recent_payment
+        on  more_recent_payment.source_id = p.source_id
+        and more_recent_payment.source_type = 'Spree::CreditCard'
+        and more_recent_payment.created_at > p.created_at
+        and more_recent_payment.state #{payment_state}
+      where c.address_id is null
+        and p.source_id = c.id
+        and p.source_type = 'Spree::CreditCard'
+        and p.state #{payment_state}
+        and more_recent_payment.id is null
+        and o.bill_address_id is not null
+        and c.id between #{start_id} and #{end_id}
+    SQL
+  end
+
+  def last_credit_card_id
+    Spree::CreditCard.last.try!(:id) || 0
+  end
+end

data/lib/tasks/migrations/migrate_shipping_rate_taxes.rake

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+namespace :solidus do
+  namespace :migrations do
+    namespace :migrate_shipping_rate_taxes do
+      task up: :environment do
+        print "Adding persisted tax notes to historic shipping rates ... "
+        Spree::ShippingRate.where.not(tax_rate_id: nil).find_each do |shipping_rate|
+          tax_rate = Spree::TaxRate.unscoped.find(shipping_rate.tax_rate_id)
+          shipping_rate.taxes.find_or_create_by!(
+            tax_rate: tax_rate,
+            amount: tax_rate.compute_amount(shipping_rate)
+          )
+        end
+        Spree::ShippingRate.where.not(tax_rate_id: nil).update_all(tax_rate_id: nil)
+        puts "Success."
+      end
+    end
+  end
+end

data/lib/tasks/migrations/migrate_user_addresses.rake

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+namespace 'spree:migrations:migrate_user_addresses' do
+  # This creates an entry in the user_addresses table for a user's currently
+  # associated shipping and billing addresses.
+
+  # This task should not need to be run more than once. But the de-dup behavior in
+  # UserAddressBook should make it safe.
+  # When the code (in the same PR) is deployed, each new order's addresses will be added
+  # to the user's address book. This will catch up all the historical data.
+
+  task up: :environment do
+    Spree.user_class.find_each(batch_size: 500) do |user|
+      ship_address = Spree::Address.find_by(id: user.ship_address_id)
+      bill_address = Spree::Address.find_by(id: user.bill_address_id)
+
+      current_addresses = [bill_address, ship_address].compact.uniq
+
+      current_addresses.each do |address|
+        # since ship_address is last, it will override bill_address as default when both are present
+        user.save_in_address_book(address.attributes, true)
+      end
+
+      puts "Migrated addresses for user ##{user.id}"
+    end
+  end
+
+  task down: :environment do
+    Spree::UserAddress.delete_all
+  end
+end

data/lib/tasks/migrations/rename_gateways.rake

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'solidus/migrations/rename_gateways'
+
+namespace 'solidus:migrations:rename_gateways' do
+  task up: :environment do
+    count = Solidus::Migrations::RenameGateways.new.up
+
+    unless ENV['VERBOSE'] == 'false' || !verbose
+      puts "Renamed #{count} gateways into payment methods."
+    end
+  end
+
+  task down: :environment do
+    count = Solidus::Migrations::RenameGateways.new.down
+
+    unless ENV['VERBOSE'] == 'false' || !verbose
+      puts "Renamed #{count} payment methods into gateways."
+    end
+  end
+end

data/lib/tasks/order_capturing.rake

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+namespace :order_capturing do
+  desc "Looks for orders with inventory that is fully shipped/short-shipped, and captures money for it"
+  task capture_payments: :environment do
+    failures = []
+    orders = Spree::Order.complete.where(payment_state: 'balance_due').where('completed_at > ?', Spree::Config[:order_capturing_time_window].days.ago)
+
+    orders.find_each do |order|
+      if order.inventory_units.all? { |iu| iu.canceled? || iu.shipped? }
+        if Spree::OrderCapturing.failure_handler
+          begin
+            Spree::OrderCapturing.new(order).capture_payments
+          rescue StandardError => e
+            failures << { message: "Order #{order.number} unable to capture. #{e.class}: #{e.message}" }
+          end
+        else
+          Spree::OrderCapturing.new(order).capture_payments
+        end
+      end
+    end
+
+    Spree::OrderCapturing.failure_handler.call(failures) if failures.any?
+  end
+end

data/script/rails

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/spree/core/engine', __dir__)
+
+require 'rails/all'
+require 'rails/engine/commands'

data/solidus_core.gemspec

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../core/lib/spree/core/version.rb'
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = 'solidus_core_devise_token_auth'
+  s.version     = Spree.solidus_version
+  s.summary     = 'Essential models, mailers, and classes for the Solidus e-commerce project (devise_token_auth revised version)'
+  s.description = s.summary
+
+  s.author    = 'Michał Siwek (skycocker)'
+  s.email     = 'mike21@aol.pl'
+  s.homepage  = 'https://github.com/skycocker/solidus/tree/master/core'
+  s.license   = 'BSD-3-Clause'
+
+  s.files        = `git ls-files`.split("\n")
+  s.require_path = 'lib'
+
+  s.required_ruby_version     = '>= 2.2.2'
+  s.required_rubygems_version = '>= 1.8.23'
+
+  %w[
+    actionmailer actionpack actionview activejob activemodel activerecord
+    activesupport railties
+  ].each do |rails_dep|
+    s.add_dependency rails_dep, ['>= 5.1', '< 5.3.x']
+  end
+
+  s.add_dependency 'activemerchant', '~> 1.66'
+  s.add_dependency 'acts_as_list', '~> 0.3'
+  s.add_dependency 'awesome_nested_set', '~> 3.0', '>= 3.0.1'
+  s.add_dependency 'cancancan', '~> 2.2'
+  s.add_dependency 'carmen', '~> 1.1.0'
+  s.add_dependency 'discard', '~> 1.0'
+  s.add_dependency 'friendly_id', '~> 5.0'
+  s.add_dependency 'kaminari-activerecord', '~> 1.1'
+  s.add_dependency 'monetize', '~> 1.8'
+  s.add_dependency 'paperclip', ['>= 4.2', '< 6']
+  s.add_dependency 'paranoia', '~> 2.4'
+  s.add_dependency 'ransack', '~> 2.0'
+  s.add_dependency 'state_machines-activerecord', '~> 0.4'
+
+  # it's simply the latest rubygems published version
+  # at the time of writing it,
+  # feel free to update
+  s.add_dependency 'devise_token_auth', '~> 1.0.0rc2'
+end

data/spec/helpers/base_helper_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::BaseHelper, type: :helper do
+  include Spree::BaseHelper
+
+  let(:current_store){ create :store }
+
+  context "available_countries" do
+    let(:country) { create(:country) }
+
+    before do
+      3.times { create(:country) }
+    end
+
+    context "with no checkout zone defined" do
+      before do
+        Spree::Config[:checkout_zone] = nil
+      end
+
+      it "return complete list of countries" do
+        expect(available_countries.count).to eq(Spree::Country.count)
+      end
+
+      it "uses locales for country names" do
+        expect(available_countries).to include(having_attributes(name: "United States of America"))
+      end
+    end
+
+    context "with a checkout zone defined" do
+      context "checkout zone is of type country" do
+        before do
+          @country_zone = create(:zone, name: "CountryZone")
+          @country_zone.members.create(zoneable: country)
+          Spree::Config[:checkout_zone] = @country_zone.name
+        end
+
+        it "return only the countries defined by the checkout zone" do
+          expect(available_countries).to eq([country])
+        end
+
+        it "returns only the countries defined by the checkout zone passed as parameter" do
+          expect(available_countries(restrict_to_zone: @country_zone.name)).to eq([country])
+        end
+      end
+
+      context "checkout zone is of type state" do
+        before do
+          state_zone = create(:zone, name: "StateZone")
+          state = create(:state, country: country)
+          state_zone.members.create(zoneable: state)
+          Spree::Config[:checkout_zone] = state_zone.name
+        end
+
+        it "return complete list of countries" do
+          expect(available_countries.count).to eq(Spree::Country.count)
+        end
+      end
+    end
+  end
+
+  # Regression test for https://github.com/spree/spree/issues/2034
+  context "flash_message" do
+    let(:flash) { { "notice" => "ok", "foo" => "foo", "bar" => "bar" } }
+
+    it "should output all flash content" do
+      flash_messages
+      html = Nokogiri::HTML(helper.output_buffer)
+      expect(html.css(".notice").text).to eq("ok")
+      expect(html.css(".foo").text).to eq("foo")
+      expect(html.css(".bar").text).to eq("bar")
+    end
+
+    it "should output flash content except one key" do
+      flash_messages(ignore_types: :bar)
+      html = Nokogiri::HTML(helper.output_buffer)
+      expect(html.css(".notice").text).to eq("ok")
+      expect(html.css(".foo").text).to eq("foo")
+      expect(html.css(".bar").text).to be_empty
+    end
+
+    it "should output flash content except some keys" do
+      flash_messages(ignore_types: [:foo, :bar])
+      html = Nokogiri::HTML(helper.output_buffer)
+      expect(html.css(".notice").text).to eq("ok")
+      expect(html.css(".foo").text).to be_empty
+      expect(html.css(".bar").text).to be_empty
+      expect(helper.output_buffer).to eq("<div class=\"flash notice\">ok</div>")
+    end
+  end
+
+  context "link_to_tracking" do
+    it "returns tracking link if available" do
+      a = link_to_tracking_html(shipping_method: true, tracking: '123', tracking_url: 'http://g.c/?t=123').css('a')
+
+      expect(a.text).to eq '123'
+      expect(a.attr('href').value).to eq 'http://g.c/?t=123'
+    end
+
+    it "returns tracking without link if link unavailable" do
+      html = link_to_tracking_html(shipping_method: true, tracking: '123', tracking_url: nil)
+      expect(html.css('span').text).to eq '123'
+    end
+
+    it "returns nothing when no shipping method" do
+      html = link_to_tracking_html(shipping_method: nil, tracking: '123')
+      expect(html.css('span').text).to eq ''
+    end
+
+    it "returns nothing when no tracking" do
+      html = link_to_tracking_html(tracking: nil)
+      expect(html.css('span').text).to eq ''
+    end
+
+    def link_to_tracking_html(options = {})
+      node = link_to_tracking(double(:shipment, options))
+      Nokogiri::HTML(node.to_s)
+    end
+  end
+
+  # Regression test for https://github.com/spree/spree/issues/2396
+  context "meta_data_tags" do
+    it "truncates a product description to 160 characters" do
+      # Because the controller_name method returns "test"
+      # controller_name is used by this method to infer what it is supposed
+      # to be generating meta_data_tags for
+      @test = Spree::Product.new(description: "a" * 200)
+      tags = Nokogiri::HTML.parse(meta_data_tags)
+      content = tags.css("meta[name=description]").first["content"]
+      expect(content.length).to be <= 160
+    end
+  end
+
+  describe "#pretty_time" do
+    subject { pretty_time(date) }
+
+    let(:date) { Time.new(2012, 11, 6, 13, 33) }
+
+    it "pretty prints time in long format" do
+      is_expected.to eq "November 06, 2012 1:33 PM"
+    end
+
+    context 'with format set to short' do
+      subject { pretty_time(date, :short) }
+
+      it "pretty prints time in short format" do
+        is_expected.to eq "Nov 6 '12 1:33pm"
+      end
+    end
+  end
+
+  context "plural_resource_name" do
+    let(:plural_config) { Spree::I18N_GENERIC_PLURAL }
+    let(:base_class) { Spree::Product }
+
+    subject { plural_resource_name(base_class) }
+
+    it "should use ActiveModel::Naming module to pluralize model names" do
+      expect(subject).to eq base_class.model_name.human(count: plural_config)
+    end
+
+    it "should use the Spree::I18N_GENERIC_PLURAL constant" do
+      expect(base_class.model_name).to receive(:human).with(hash_including(count: plural_config))
+      subject
+    end
+  end
+end

data/spec/helpers/products_helper_spec.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  RSpec.describe ProductsHelper, type: :helper do
+    include ProductsHelper
+
+    let(:product) { create(:product, price: product_price) }
+    let(:product_price) { 10 }
+    let(:variant) { create(:variant, product: product, price: variant_price) }
+    let(:currency) { 'USD' }
+    let(:pricing_options) do
+      Spree::Config.pricing_options_class.new(currency: currency)
+    end
+
+    before do
+      allow(helper).to receive(:current_pricing_options) { pricing_options }
+    end
+
+    context "#variant_price_diff" do
+      let(:variant_price) { 10 }
+
+      subject { helper.variant_price(variant) }
+
+      context "when variant is same as master" do
+        it { is_expected.to be_nil }
+      end
+
+      context "when currency is default" do
+        context "when variant is more than master" do
+          let(:variant_price) { 15 }
+
+          it { is_expected.to eq("(Add: $5.00)") }
+          # Regression test for https://github.com/spree/spree/issues/2737
+          it { is_expected.to be_html_safe }
+        end
+
+        context "when variant is less than master" do
+          let(:product_price) { 15 }
+
+          it { is_expected.to eq("(Subtract: $5.00)") }
+        end
+      end
+
+      context "when currency is JPY" do
+        let(:variant_price) { 100 }
+        let(:product_price) { 100 }
+        let(:currency) { 'JPY' }
+
+        before do
+          variant
+          product.prices.update_all(currency: currency)
+        end
+
+        context "when variant is more than master" do
+          let(:variant_price) { 150 }
+
+          it { is_expected.to eq("(Add: ¥50)") }
+        end
+
+        context "when variant is less than master" do
+          let(:product_price) { 150 }
+
+          it { is_expected.to eq("(Subtract: ¥50)") }
+        end
+      end
+    end
+
+    context "#variant_price_full" do
+      let!(:variant_2) { create(:variant, product: product, price: variant_2_price) }
+      let(:variant_2_price) { 20 }
+      let(:variant_price) { 15 }
+
+      before do
+        Spree::Config[:show_variant_full_price] = true
+        variant
+      end
+
+      context "when currency is default" do
+        it "should return the variant price if the price is different than master" do
+          expect(helper.variant_price(variant)).to eq("$15.00")
+          expect(helper.variant_price(variant_2)).to eq("$20.00")
+        end
+      end
+
+      context "when currency is JPY" do
+        let(:currency) { 'JPY' }
+        let(:product_price) { 100 }
+        let(:variant_price) { 150 }
+
+        before do
+          variant
+          product.prices.update_all(currency: currency)
+        end
+
+        it "should return the variant price if the price is different than master" do
+          expect(helper.variant_price(variant)).to eq("¥150")
+        end
+      end
+
+      context "when all variant prices are equal" do
+        let(:product_price) { 10 }
+        let(:variant_price) { 10 }
+        let(:variant_2_price) { 10 }
+
+        it "should be nil" do
+          expect(helper.variant_price(variant)).to be_nil
+          expect(helper.variant_price(variant_2)).to be_nil
+        end
+      end
+    end
+
+    context "#product_description" do
+      # Regression test for https://github.com/spree/spree/issues/1607
+      it "renders a product description without excessive paragraph breaks" do
+        product.description = %{
+<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus a ligula leo. Proin eu arcu at ipsum dapibus ullamcorper. Pellentesque egestas orci nec magna condimentum luctus. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut ac ante et mauris bibendum ultricies non sed massa. Fusce facilisis dui eget lacus scelerisque eget aliquam urna ultricies. Duis et rhoncus quam. Praesent tellus nisi, ultrices sed iaculis quis, euismod interdum ipsum.</p>
+<ul>
+<li>Lorem ipsum dolor sit amet</li>
+<li>Lorem ipsum dolor sit amet</li>
+</ul>
+        }
+        description = product_description(product)
+        expect(description.strip).to eq(product.description.strip)
+      end
+
+      it "renders a product description with automatic paragraph breaks" do
+        product.description = %{
+THIS IS THE BEST PRODUCT EVER!
+
+"IT CHANGED MY LIFE" - Sue, MD}
+
+        description = product_description(product)
+        expect(description.strip).to eq(%{<p>\nTHIS IS THE BEST PRODUCT EVER!</p>"IT CHANGED MY LIFE" - Sue, MD})
+      end
+
+      it "renders a product description without any formatting based on configuration" do
+        description = %{
+            <p>hello world</p>
+
+            <p>tihs is completely awesome and it works</p>
+
+            <p>why so many spaces in the code. and why some more formatting afterwards?</p>
+        }
+
+        product.description = description
+
+        Spree::Config[:show_raw_product_description] = true
+        description = product_description(product)
+        expect(description).to eq(description)
+      end
+    end
+
+    context '#line_item_description_text' do
+      subject { line_item_description_text description }
+      context 'variant has a blank description' do
+        let(:description) { nil }
+        it { is_expected.to eq(I18n.t('spree.product_has_no_description')) }
+      end
+      context 'variant has a description' do
+        let(:description) { 'test_desc' }
+        it { is_expected.to eq(description) }
+      end
+      context 'description has nonbreaking spaces' do
+        let(:description) { 'test&nbsp;desc' }
+        it { is_expected.to eq('test desc') }
+      end
+    end
+
+    context '#cache_key_for_products' do
+      subject { helper.cache_key_for_products }
+      before(:each) do
+        @products = double('products collection')
+        allow(helper).to receive(:params) { { page: 10 } }
+      end
+
+      context 'when there is a maximum updated date' do
+        let(:updated_at) { Date.new(2011, 12, 13) }
+        before :each do
+          allow(@products).to receive(:count) { 5 }
+          allow(@products).to receive(:maximum).with(:updated_at) { updated_at }
+        end
+
+        it { is_expected.to eq('en/USD/spree/products/all-10-20111213-5') }
+      end
+
+      context 'when there is no considered maximum updated date' do
+        let(:today) { Date.new(2013, 12, 11) }
+        before :each do
+          allow(@products).to receive(:count) { 1_234_567 }
+          allow(@products).to receive(:maximum).with(:updated_at) { nil }
+          allow(Date).to receive(:today) { today }
+        end
+
+        it { is_expected.to eq('en/USD/spree/products/all-10-20131211-1234567') }
+      end
+    end
+  end
+end

data/spec/helpers/taxons_helper_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::TaxonsHelper, type: :helper do
+  let(:currency) { 'USD' }
+  let(:pricing_options) do
+    Spree::Config.pricing_options_class.new(currency: currency)
+  end
+  before do
+    allow(helper).to receive(:current_pricing_options) { pricing_options }
+  end
+
+  describe "#taxon_preview" do
+    let!(:taxon) { create(:taxon) }
+    let!(:child_taxon) { create(:taxon, parent: taxon) }
+    let!(:product_1) { create(:product) }
+    let!(:product_2) { create(:product) }
+    let!(:product_3) { create(:product) }
+
+    before do
+      taxon.products << product_1
+      taxon.products << product_2
+      child_taxon.products << product_3
+      taxon.reload
+    end
+
+    # Regression test for https://github.com/spree/spree/issues/4382
+    it "returns products" do
+      expect(helper.taxon_preview(taxon)).to eql([product_1, product_2, product_3])
+    end
+
+    context "with different currency" do
+      let(:currency) { 'CAD' }
+
+      it "returns no products" do
+        expect(helper.taxon_preview(taxon)).to be_empty
+      end
+    end
+  end
+end