solidus_core_devise_token_auth 2.8.0.alpha.0

data/lib/spree/core/role_configuration.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'spree/core/class_constantizer'
+
+module Spree
+  # A class responsible for associating {Spree::Role} with a list of permission sets.
+  #
+  # @see Spree::PermissionSets
+  #
+  # @example Adding order, product, and user display to customer service users.
+  #   Spree::RoleConfiguration.configure do |config|
+  #     config.assign_permissions :customer_service, [
+  #       Spree::PermissionSets::OrderDisplay,
+  #       Spree::PermissionSets::UserDisplay,
+  #       Spree::PermissionSets::ProductDisplay
+  #     ]
+  #   end
+  class RoleConfiguration
+    # An internal structure for the association between a role and a
+    # set of permissions.
+    class Role
+      attr_reader :name, :permission_sets
+
+      def initialize(name, permission_sets)
+        @name = name
+        @permission_sets = Spree::Core::ClassConstantizer::Set.new
+        @permission_sets.concat permission_sets
+      end
+    end
+
+    attr_accessor :roles
+
+    class << self
+      def instance
+        Spree::Deprecation.warn "Spree::RoleConfiguration.instance is DEPRECATED use Spree::Config.roles instead"
+        Spree::Config.roles
+      end
+
+      # Yields the instance of the singleton, used for configuration
+      # @yieldparam instance [Spree::RoleConfiguration]
+      def configure
+        Spree::Deprecation.warn "Spree::RoleConfiguration.configure is deprecated. Call Spree::Config.roles.assign_permissions instead"
+        yield(Spree::Config.roles)
+      end
+    end
+
+    # Given a CanCan::Ability, and a user, determine what permissions sets can
+    # be activated on the ability, then activate them.
+    #
+    # This performs can/cannot declarations on the ability, and can modify its
+    # internal permissions.
+    #
+    # @param ability [CanCan::Ability] the ability to invoke declarations on
+    # @param user [#spree_roles] the user that holds the spree_roles association.
+    def activate_permissions!(ability, user)
+      spree_roles = ['default'] | user.spree_roles.map(&:name)
+      applicable_permissions = Set.new
+
+      spree_roles.each do |role_name|
+        applicable_permissions |= roles[role_name].permission_sets
+      end
+
+      applicable_permissions.each do |permission_set|
+        permission_set.new(ability).activate!
+      end
+    end
+
+    # Not public due to the fact this class is a Singleton
+    # @!visibility private
+    def initialize
+      @roles = Hash.new do |h, name|
+        h[name] = Role.new(name, Set.new)
+      end
+    end
+
+    # Assign permission sets for a {Spree::Role} that has the name of role_name
+    # @param role_name [Symbol, String] The name of the role to associate permissions with
+    # @param permission_sets [Array<Spree::PermissionSets::Base>, Set<Spree::PermissionSets::Base>]
+    #   A list of permission sets to activate if the user has the role indicated by role_name
+    def assign_permissions(role_name, permission_sets)
+      name = role_name.to_s
+
+      roles[name].permission_sets.concat permission_sets
+      roles[name]
+    end
+  end
+end

data/lib/spree/core/search/base.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'spree/deprecation'
+
+module Spree
+  module Core
+    module Search
+      class Base
+        attr_accessor :properties
+        attr_accessor :current_user
+        attr_accessor :pricing_options
+
+        def initialize(params)
+          self.pricing_options = Spree::Config.default_pricing_options
+          @properties = {}
+          prepare(params)
+        end
+
+        def current_currency=(currency)
+          self.pricing_options = Spree::Config.pricing_options_class.new(
+            pricing_options.desired_attributes.merge(currency: currency)
+          )
+        end
+
+        def current_currency
+          pricing_options.currency
+        end
+        deprecate :current_currency, :current_currency=, deprecator: Spree::Deprecation
+
+        def retrieve_products
+          @products = get_base_scope
+          curr_page = @properties[:page] || 1
+
+          unless Spree::Config.show_products_without_price
+            @products = @products.joins(:prices).merge(Spree::Price.where(pricing_options.search_arguments)).distinct
+          end
+          @products = @products.page(curr_page).per(@properties[:per_page])
+        end
+
+        def method_missing(name)
+          if @properties.key?(name)
+            Spree::Deprecation.warn "Accessing Searcher's #{name} property using #{self.class.name}##{name} is deprecated without replacement"
+            @properties[name]
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(name)
+          @properties.key?(name) || super(name)
+        end
+
+        protected
+
+        def get_base_scope
+          base_scope = Spree::Product.display_includes.available
+          base_scope = base_scope.in_taxon(@properties[:taxon]) unless @properties[:taxon].blank?
+          base_scope = get_products_conditions_for(base_scope, @properties[:keywords])
+          base_scope = add_search_scopes(base_scope)
+          base_scope = add_eagerload_scopes(base_scope)
+          base_scope
+        end
+
+        def add_eagerload_scopes(scope)
+          # TL;DR Switch from `preload` to `includes` as soon as Rails starts honoring
+          # `order` clauses on `has_many` associations when a `where` constraint
+          # affecting a joined table is present (see
+          # https://github.com/rails/rails/issues/6769).
+          #
+          # Ideally this would use `includes` instead of `preload` calls, leaving it
+          # up to Rails whether associated objects should be fetched in one big join
+          # or multiple independent queries. However as of Rails 4.1.8 any `order`
+          # defined on `has_many` associations are ignored when Rails builds a join
+          # query.
+          #
+          # Would we use `includes` in this particular case, Rails would do
+          # separate queries most of the time but opt for a join as soon as any
+          # `where` constraints affecting joined tables are added to the search;
+          # which is the case as soon as a taxon is added to the base scope.
+          scope = scope.preload(master: :currently_valid_prices)
+          scope = scope.preload(master: :images) if @properties[:include_images]
+          scope
+        end
+
+        def add_search_scopes(base_scope)
+          if @properties[:search]
+            @properties[:search].each do |name, scope_attribute|
+              scope_name = name.to_sym
+              if base_scope.respond_to?(:search_scopes) && base_scope.search_scopes.include?(scope_name.to_sym)
+                base_scope = base_scope.send(scope_name, *scope_attribute)
+              else
+                base_scope = base_scope.merge(Spree::Product.ransack({ scope_name => scope_attribute }).result)
+              end
+            end
+          end
+          base_scope
+        end
+
+        # method should return new scope based on base_scope
+        def get_products_conditions_for(base_scope, query)
+          unless query.blank?
+            base_scope = base_scope.like_any([:name, :description], query.split)
+          end
+          base_scope
+        end
+
+        def prepare(params)
+          @properties[:taxon] = params[:taxon].blank? ? nil : Spree::Taxon.find(params[:taxon])
+          @properties[:keywords] = params[:keywords]
+          @properties[:search] = params[:search]
+          @properties[:include_images] = params[:include_images]
+
+          per_page = params[:per_page].to_i
+          @properties[:per_page] = per_page > 0 ? per_page : Spree::Config[:products_per_page]
+          @properties[:page] = (params[:page].to_i <= 0) ? 1 : params[:page].to_i
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/search/variant.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/class/attribute'
+
+module Spree
+  module Core
+    module Search
+      #
+      # NOTE: Use Spree::Config.variant_search_class rather than referencing this
+      # directly.
+      #
+
+      class Variant
+        class_attribute :search_terms
+        self.search_terms = [
+          :sku_cont,
+          :product_name_cont,
+          :product_slug_cont,
+          :option_values_presentation_cont,
+          :option_values_name_cont
+        ]
+
+        def initialize(query_string, scope: Spree::Variant.all)
+          @query_string = query_string
+          @scope = scope
+        end
+
+        # Searches the variants table using the ransack 'search_terms' defined on the class.
+        # Each word of the query string is searched individually, matching by a union of the ransack
+        # search terms, then we find the intersection of those queries, ensuring that each word matches
+        # one of the rules.
+        #
+        # == Returns:
+        # ActiveRecord::Relation of variants
+        def results
+          return @scope if @query_string.blank?
+
+          matches = @query_string.split.map do |word|
+            @scope.ransack(search_term_params(word)).result.pluck(:id)
+          end
+
+          Spree::Variant.where(id: matches.inject(:&))
+        end
+
+        private
+
+        # Returns an array of search term symbols that will be passed to Ransack
+        # to query the DB for the given word.
+        # Subclasses may override this to allow conditional filtering, etc.
+        #
+        # @api public
+        # @param _word [String] One of the search words provided by the user.
+        #   e.g. a SKU
+        # @return [Array<Symbol>] the list of search terms to use for this word
+        def search_terms(_word)
+          self.class.search_terms
+        end
+
+        def search_term_params(word)
+          terms = Hash[search_terms(word).map { |t| [t, word] }]
+          terms.merge(m: 'or')
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/stock_configuration.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StockConfiguration
+      attr_writer :coordinator_class
+      attr_writer :estimator_class
+      attr_writer :location_sorter_class
+
+      def coordinator_class
+        @coordinator_class ||= '::Spree::Stock::SimpleCoordinator'
+        @coordinator_class.constantize
+      end
+
+      def estimator_class
+        @estimator_class ||= '::Spree::Stock::Estimator'
+        @estimator_class.constantize
+      end
+
+      def location_sorter_class
+        @location_sorter_class ||= '::Spree::Stock::LocationSorter::Unsorted'
+        @location_sorter_class.constantize
+      end
+    end
+  end
+end

data/lib/spree/core/validators/email.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Spree
+  # == An ActiveModel Email Validator
+  #
+  # === Usage
+  #
+  #     require 'spree/core/validators/email'
+  #
+  #     class Person < ApplicationRecord
+  #       validates :email_address, 'spree/email' => true
+  #     end
+  #
+  class EmailValidator < ActiveModel::EachValidator
+    EMAIL_REGEXP = /\A([^@\.]|[^@\.]([^@\s]*)[^@\.])@([^@\s]+\.)+[^@\s]+\z/
+
+    def validate_each(record, attribute, value)
+      unless value =~ EMAIL_REGEXP
+        record.errors.add(attribute, :invalid, { value: value }.merge!(options))
+      end
+    end
+  end
+end
+
+# @private
+EmailValidator = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
+  'EmailValidator',
+  'Spree::EmailValidator',
+  message: "EmailValidator is deprecated! Use Spree::EmailValidator instead.\nChange `validates :email, email: true` to `validates :email, 'spree/email' => true`\n"
+)

data/lib/spree/core/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Spree
+  def self.solidus_version
+    "2.8.0.alpha.0"
+  end
+
+  def self.solidus_gem_version
+    Gem::Version.new(solidus_version)
+  end
+end

data/lib/spree/core.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'rails/all'
+require 'acts_as_list'
+require 'awesome_nested_set'
+require 'cancan'
+require 'friendly_id'
+require 'kaminari/activerecord'
+require 'mail'
+require 'monetize'
+require 'paperclip'
+require 'paranoia'
+require 'ransack'
+require 'state_machines-activerecord'
+
+require 'spree/deprecation'
+require 'spree/paranoia_deprecations'
+
+# This is required because ActiveModel::Validations#invalid? conflicts with the
+# invalid state of a Payment. In the future this should be removed.
+StateMachines::Machine.ignore_method_conflicts = true
+
+module Spree
+  mattr_accessor :user_class
+
+  def self.user_class
+    if @@user_class.is_a?(Class)
+      raise "Spree.user_class MUST be a String or Symbol object, not a Class object."
+    elsif @@user_class.is_a?(String) || @@user_class.is_a?(Symbol)
+      @@user_class.to_s.constantize
+    end
+  end
+
+  # Used to configure Spree.
+  #
+  # Example:
+  #
+  #   Spree.config do |config|
+  #     config.track_inventory_levels = false
+  #   end
+  #
+  # This method is defined within the core gem on purpose.
+  # Some people may only wish to use the Core part of Spree.
+  def self.config(&_block)
+    yield(Spree::Config)
+  end
+
+  module Core
+    class GatewayError < RuntimeError; end
+
+    include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+    deprecate_constant 'DestroyWithOrdersError', ActiveRecord::DeleteRestrictionError, deprecator: Spree::Deprecation
+  end
+end
+
+require 'spree/core/version'
+
+require 'spree/core/active_merchant_dependencies'
+require 'spree/core/class_constantizer'
+require 'spree/core/environment_extension'
+require 'spree/core/environment/calculators'
+require 'spree/core/environment'
+require 'spree/promo/environment'
+require 'spree/migrations'
+require 'spree/migration_helpers'
+require 'spree/core/engine'
+
+require 'spree/i18n'
+require 'spree/localized_number'
+require 'spree/money'
+require 'spree/permitted_attributes'
+
+require 'spree/core/importer'
+require 'spree/core/permalinks'
+require 'spree/core/product_duplicator'
+require 'spree/core/current_store'
+require 'spree/core/controller_helpers/auth'
+require 'spree/core/controller_helpers/common'
+require 'spree/core/controller_helpers/order'
+require 'spree/core/controller_helpers/payment_parameters'
+require 'spree/core/controller_helpers/pricing'
+require 'spree/core/controller_helpers/search'
+require 'spree/core/controller_helpers/store'
+require 'spree/core/controller_helpers/strong_parameters'
+require 'spree/core/role_configuration'
+require 'spree/core/stock_configuration'
+require 'spree/core/validators/email'
+require 'spree/permission_sets'
+
+require 'spree/preferences/store'
+require 'spree/preferences/static_model_preferences'
+require 'spree/preferences/scoped_store'

data/lib/spree/deprecation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'active_support/deprecation'
+
+module Spree
+  Deprecation = ActiveSupport::Deprecation.new('3.0', 'Solidus')
+end

data/lib/spree/i18n.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'i18n'
+require 'active_support/core_ext/array/extract_options'
+require 'action_view'
+
+module Spree
+  def self.i18n_available_locales
+    I18n.available_locales.select do |locale|
+      I18n.t('spree.i18n.this_file_language', locale: locale, fallback: false, default: nil)
+    end
+  end
+
+  class TranslationHelperWrapper # :nodoc:
+    include ActionView::Helpers::TranslationHelper
+  end
+
+  # This value is used as a count for the pluralization helpers related to I18n
+  # ex: Spree::Order.model_name.human(count: Spree::I18N_GENERIC_PLURAL)
+  # Related to Solidus issue #1164, this is needed to avoid problems with
+  # some pluralization calculators
+  I18N_GENERIC_PLURAL = 2.1
+
+  class << self
+    # Add spree namespace and delegate to Rails TranslationHelper for some nice
+    # extra functionality. e.g return reasonable strings for missing translations
+
+    def translate(key, options = {})
+      options[:scope] = [:spree, *options[:scope]]
+      TranslationHelperWrapper.new.translate(key, options)
+    end
+
+    alias_method :t, :translate
+  end
+end

data/lib/spree/localized_number.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Spree
+  class LocalizedNumber
+    # Given a string, strips all non-price-like characters from it,
+    # taking into account locale settings. Returns the input given anything
+    # else.
+    #
+    # @param number [String, anything] the number to be parsed or anything else
+    # @return [BigDecimal, anything] the number parsed from the string passed
+    #   in, or whatever you passed in
+    def self.parse(number)
+      return number unless number.is_a?(String)
+
+      # I18n.t('number.currency.format.delimiter') could be useful here, but is
+      # unnecessary as it is stripped by the non_number_characters gsub.
+      separator = I18n.t(:'number.currency.format.separator')
+      non_number_characters = /[^0-9\-#{separator}]/
+
+      # strip everything else first
+      number = number.gsub(non_number_characters, '')
+
+      # then replace the locale-specific decimal separator with the standard separator if necessary
+      number = number.gsub(separator, '.') unless separator == '.'
+
+      # Handle empty string for ruby 2.4 compatibility
+      BigDecimal(number.presence || 0)
+    end
+  end
+end

data/lib/spree/mailer_previews/carton_preview.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spree
+  class MailerPreviews
+    class CartonPreview < ActionMailer::Preview
+      def shipped
+        carton = Carton.joins(:orders).last
+        raise "Your database needs at one shipped order with a carton to render this preview" unless carton
+        Spree::Config.carton_shipped_email_class.shipped_email(order: carton.orders.first, carton: carton)
+      end
+    end
+  end
+end

data/lib/spree/mailer_previews/order_preview.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Spree
+  class MailerPreviews
+    class OrderPreview < ActionMailer::Preview
+      def confirm
+        order = Order.complete.last
+        raise "Your database needs at least one completed order to render this preview" unless order
+        Spree::Config.order_mailer_class.confirm_email(order)
+      end
+
+      def cancel
+        order = Order.with_state(:canceled).last
+        raise "Your database needs at least one cancelled order to render this preview" unless order
+        Spree::Config.order_mailer_class.cancel_email(order)
+      end
+
+      def inventory_cancellation
+        order = Spree::Order.joins(:inventory_units).merge(Spree::InventoryUnit.canceled).last
+        raise "Your database needs at least one order with a canceled inventory unit to render this preview" unless order
+        Spree::Config.order_mailer_class.inventory_cancellation_email(order, [order.inventory_units.first])
+      end
+    end
+  end
+end

data/lib/spree/mailer_previews/reimbursement_preview.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spree
+  class MailerPreviews
+    class ReimbursementPreview < ActionMailer::Preview
+      def reimbursement
+        reimbursement = Reimbursement.last
+        raise "Your database needs at least one Reimbursement to render this preview" unless reimbursement
+        Spree::Config.reimbursement_mailer_class.reimbursement_email(reimbursement)
+      end
+    end
+  end
+end

data/lib/spree/migration_helpers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Spree
+  module MigrationHelpers
+    def safe_remove_index(table, column)
+      remove_index(table, column) if index_exists?(table, column)
+    end
+
+    def safe_add_index(table, column, options = {})
+      if columns_exist?(table, column) && !index_exists?(table, column, options)
+        add_index(table, column, options)
+      end
+    end
+
+    private
+
+    def columns_exist?(table, columns)
+      Array.wrap(columns).all? { |column| column_exists?(table, column) }
+    end
+  end
+end

data/lib/spree/migrations.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Spree
+  class Migrations
+    attr_reader :config, :engine_name
+
+    # Takes the engine config block and engine name
+    def initialize(config, engine_name)
+      @config, @engine_name = config, engine_name
+    end
+
+    # Puts warning when any engine migration is not present on the Rails app
+    # db/migrate dir
+    #
+    # First split:
+    #
+    #   ["20131128203548", "update_name_fields_on_spree_credit_cards.spree.rb"]
+    #
+    # Second split should give the engine_name of the migration
+    #
+    #   ["update_name_fields_on_spree_credit_cards", "spree.rb"]
+    #
+    # Shouldn't run on test mode because migrations inside engine don't have
+    # engine name on the file name
+    def check
+      if File.directory?(app_dir)
+        unless missing_migrations.empty?
+          puts "[#{engine_name.capitalize} WARNING] Missing migrations."
+          missing_migrations.each do |migration|
+            puts "[#{engine_name.capitalize} WARNING] #{migration} from #{engine_name} is missing."
+          end
+          puts "[#{engine_name.capitalize} WARNING] Run `bundle exec rake railties:install:migrations` to get them.\n\n"
+          true
+        end
+      end
+    end
+
+    def missing_migrations
+      @missing_migrations ||=
+        begin
+          engine_in_app = app_migrations.map do |file_name|
+            name, engine = file_name.split(".", 2)
+            next unless match_engine?(engine)
+            name
+          end.compact
+
+          engine_migrations.sort - engine_in_app.sort
+        end
+    end
+
+    private
+
+    def engine_migrations
+      Dir.entries(engine_dir).map do |file_name|
+        name = file_name.split("_", 2).last.split(".", 2).first
+        name.empty? ? next : name
+      end.compact! || []
+    end
+
+    def app_migrations
+      Dir.entries(app_dir).map do |file_name|
+        next if [".", ".."].include? file_name
+        name = file_name.split("_", 2).last
+        name.empty? ? next : name
+      end.compact! || []
+    end
+
+    def app_dir
+      "#{Rails.root}/db/migrate"
+    end
+
+    def engine_dir
+      "#{config.root}/db/migrate"
+    end
+
+    def match_engine?(engine)
+      if engine_name == "spree"
+        # Avoid stores upgrading from 1.3 getting wrong warnings
+        ["spree.rb", "spree_promo.rb"].include? engine
+      else
+        engine == "#{engine_name}.rb"
+      end
+    end
+  end
+end