solidus_core_devise_token_auth 2.8.0.alpha.0

data/lib/spree/preferences/configuration.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'spree/preferences/preferable'
+
+module Spree::Preferences
+  # This takes the preferrable methods and adds some
+  # syntatic sugar to access the preferences
+  #
+  #   class App < Configuration
+  #     preference :color, :string
+  #   end
+  #
+  #   a = App.new
+  #
+  # Provides the following setters:
+  #
+  #   a.color = :blue
+  #   a[:color] = :blue
+  #   a.set color: :blue
+  #   a.preferred_color = :blue
+  #
+  # and the following getters:
+  #
+  #   a.color
+  #   a[:color]
+  #   a.get :color
+  #   a.preferred_color
+  #
+  class Configuration
+    include Spree::Preferences::Preferable
+
+    # @yield [config] Yields this configuration object to a block
+    def configure
+      yield(self)
+    end
+
+    # @!attribute preference_store
+    # Storage method for preferences.
+    attr_writer :preference_store
+    def preference_store
+      @preference_store ||= default_preferences
+    end
+
+    # Replace the default legacy preference store, which stores preferences in
+    # the spree_preferences table, with a plain in memory hash. This is faster
+    # and less error prone.
+    #
+    # This will set all preferences to their default values.
+    #
+    # These won't be loaded from or persisted to the database, so any desired
+    # changes must be made each time the application is started, such as in an
+    # initializer.
+    def use_static_preferences!
+      @preference_store = default_preferences
+    end
+
+    # Replace the new static preference store with the legacy store which
+    # fetches preferences from the DB.
+    def use_legacy_db_preferences!
+      @preference_store = ScopedStore.new(self.class.name.underscore)
+    end
+
+    alias_method :preferences, :preference_store
+
+    # Reset all preferences to their default values.
+    def reset
+      set(default_preferences)
+    end
+
+    alias :[] :get_preference
+    alias :[]= :set_preference
+
+    alias :get :get_preference
+
+    # @param preferences [Hash] a hash of preferences to set
+    def set(preferences)
+      preferences.each do |name, value|
+        set_preference name, value
+      end
+    end
+
+    def self.preference(name, type, options = {})
+      super
+      alias_method name.to_s, "preferred_#{name}"
+      alias_method "#{name}=", "preferred_#{name}="
+    end
+
+    def self.class_name_attribute(name, default:)
+      ivar = :"@#{name}"
+
+      define_method("#{name}=") do |class_name|
+        # If this is a named class constant, we should store it as a string to
+        # allow code reloading.
+        class_name = class_name.name if class_name.is_a?(Class) && class_name.name
+
+        instance_variable_set(ivar, class_name)
+      end
+
+      define_method(name) do
+        class_name = instance_variable_get(ivar)
+        class_name ||= default
+        class_name = class_name.constantize if class_name.is_a?(String)
+        class_name
+      end
+    end
+  end
+end

data/lib/spree/preferences/preferable.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'spree/preferences/preferable_class_methods'
+require 'active_support/concern'
+require 'active_support/core_ext/hash/keys'
+
+module Spree
+  module Preferences
+    # Preferable allows defining preference accessor methods.
+    #
+    # A class including Preferable must implement #preferences which should return
+    # an object responding to .fetch(key), []=(key, val), and .delete(key).
+    #
+    # The generated writer method performs typecasting before assignment into the
+    # preferences object.
+    #
+    # Examples:
+    #
+    #   # Spree::Base includes Preferable and defines preferences as a serialized
+    #   # column.
+    #   class Settings < Spree::Base
+    #     preference :color,       :string,  default: 'red'
+    #     preference :temperature, :integer, default: 21
+    #   end
+    #
+    #   s = Settings.new
+    #   s.preferred_color # => 'red'
+    #   s.preferred_temperature # => 21
+    #
+    #   s.preferred_color = 'blue'
+    #   s.preferred_color # => 'blue'
+    #
+    #   # Typecasting is performed on assignment
+    #   s.preferred_temperature = '24'
+    #   s.preferred_color # => 24
+    #
+    #   # Modifications have been made to the .preferences hash
+    #   s.preferences #=> {color: 'blue', temperature: 24}
+    #
+    #   # Save the changes. All handled by activerecord
+    #   s.save!
+    #
+    # Each preference gets rendered as a form field in Solidus backend.
+    #
+    # As not all supported preference types are representable as a form field, only
+    # some of them get rendered per default. Arrays and Hashes for instance are
+    # supported preference field types, but do not represent well as a form field.
+    #
+    # Overwrite +allowed_admin_form_preference_types+ in your class if you want to
+    # provide more fields. If you do so, you also need to provide a preference field
+    # partial that lives in:
+    #
+    # +app/views/spree/admin/shared/preference_fields/+
+    #
+    module Preferable
+      extend ActiveSupport::Concern
+
+      included do
+        extend Spree::Preferences::PreferableClassMethods
+      end
+
+      # Get a preference
+      # @param name [#to_sym] name of preference
+      # @return [Object] The value of preference +name+
+      def get_preference(name)
+        has_preference! name
+        send self.class.preference_getter_method(name)
+      end
+
+      # Set a preference
+      # @param name [#to_sym] name of preference
+      # @param value [Object] new value for preference +name+
+      def set_preference(name, value)
+        has_preference! name
+        send self.class.preference_setter_method(name), value
+      end
+
+      # @param name [#to_sym] name of preference
+      # @return [Symbol] The type of preference +name+
+      def preference_type(name)
+        has_preference! name
+        send self.class.preference_type_getter_method(name)
+      end
+
+      # @param name [#to_sym] name of preference
+      # @return [Object] The default for preference +name+
+      def preference_default(name)
+        has_preference! name
+        send self.class.preference_default_getter_method(name)
+      end
+
+      # Raises an exception if the +name+ preference is not defined on this class
+      # @param name [#to_sym] name of preference
+      def has_preference!(name)
+        raise NoMethodError.new "#{name} preference not defined" unless has_preference? name
+      end
+
+      # @param name [#to_sym] name of preference
+      # @return [Boolean] if preference exists on this class
+      def has_preference?(name)
+        defined_preferences.include?(name.to_sym)
+      end
+
+      # @return [Array<Symbol>] All preferences defined on this class
+      def defined_preferences
+        self.class.defined_preferences
+      end
+
+      # @return [Hash{Symbol => Object}] Default for all preferences defined on this class
+      def default_preferences
+        Hash[
+          defined_preferences.map do |preference|
+            [preference, preference_default(preference)]
+          end
+        ]
+      end
+
+      # Preference names representable as form fields in Solidus backend
+      #
+      # Not all preferences are representable as a form field.
+      #
+      # Arrays and Hashes for instance are supported preference field types,
+      # but do not represent well as a form field.
+      #
+      # As these kind of preferences are mostly developer facing
+      # and not admin facing we should not render them.
+      #
+      # Overwrite +allowed_admin_form_preference_types+ in your class that
+      # includes +Spree::Preferable+ if you want to provide more fields.
+      # If you do so, you also need to provide a preference field partial
+      # that lives in:
+      #
+      # +app/views/spree/admin/shared/preference_fields/+
+      #
+      # @return [Array]
+      def admin_form_preference_names
+        defined_preferences.keep_if do |type|
+          preference_type(type).in? self.class.allowed_admin_form_preference_types
+        end
+      end
+
+      private
+
+      def convert_preference_value(value, type)
+        return nil if value.nil?
+        case type
+        when :string, :text
+          value.to_s
+        when :password
+          value.to_s
+        when :decimal
+          begin
+            value.to_s.to_d
+          rescue ArgumentError
+            BigDecimal(0)
+          end
+        when :integer
+          value.to_i
+        when :boolean
+          if !value ||
+             value == 0 ||
+             value =~ /\A(f|false|0)\Z/i ||
+             (value.respond_to?(:empty?) && value.empty?)
+            false
+          else
+            true
+          end
+        when :array
+          raise TypeError, "Array expected got #{value.inspect}" unless value.is_a?(Array)
+          value
+        when :hash
+          raise TypeError, "Hash expected got #{value.inspect}" unless value.is_a?(Hash)
+          value
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/spree/preferences/preferable_class_methods.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Spree::Preferences
+  module PreferableClassMethods
+    DEFAULT_ADMIN_FORM_PREFERENCE_TYPES = %i(
+      boolean
+      decimal
+      integer
+      password
+      string
+      text
+    )
+
+    def defined_preferences
+      []
+    end
+
+    def preference(name, type, options = {})
+      options.assert_valid_keys(:default)
+      default = options[:default]
+      default = ->{ options[:default] } unless default.is_a?(Proc)
+
+      # The defined preferences on a class are all those defined directly on
+      # that class as well as those defined on ancestors.
+      # We store these as a class instance variable on each class which has a
+      # preference. super() collects preferences defined on ancestors.
+      singleton_preferences = (@defined_singleton_preferences ||= [])
+      singleton_preferences << name.to_sym
+
+      define_singleton_method :defined_preferences do
+        super() + singleton_preferences
+      end
+
+      # cache_key will be nil for new objects, then if we check if there
+      # is a pending preference before going to default
+      define_method preference_getter_method(name) do
+        preferences.fetch(name) do
+          default.call
+        end
+      end
+
+      define_method preference_setter_method(name) do |value|
+        value = convert_preference_value(value, type)
+        preferences[name] = value
+
+        # If this is an activerecord object, we need to inform
+        # ActiveRecord::Dirty that this value has changed, since this is an
+        # in-place update to the preferences hash.
+        preferences_will_change! if respond_to?(:preferences_will_change!)
+      end
+
+      define_method preference_default_getter_method(name), &default
+
+      define_method preference_type_getter_method(name) do
+        type
+      end
+    end
+
+    def preference_getter_method(name)
+      "preferred_#{name}".to_sym
+    end
+
+    def preference_setter_method(name)
+       "preferred_#{name}=".to_sym
+    end
+
+    def preference_default_getter_method(name)
+      "preferred_#{name}_default".to_sym
+    end
+
+    def preference_type_getter_method(name)
+      "preferred_#{name}_type".to_sym
+    end
+
+    # List of preference types allowed as form fields in the Solidus admin
+    #
+    # Overwrite this method in your class that includes +Spree::Preferable+
+    # if you want to provide more fields. If you do so, you also need to provide
+    # a preference field partial that lives in:
+    #
+    # +app/views/spree/admin/shared/preference_fields/+
+    #
+    # @return [Array]
+    def allowed_admin_form_preference_types
+      DEFAULT_ADMIN_FORM_PREFERENCE_TYPES
+    end
+  end
+end

data/lib/spree/preferences/scoped_store.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Spree::Preferences
+  class ScopedStore
+    def initialize(prefix, suffix = nil)
+      @prefix = prefix
+      @suffix = suffix
+    end
+
+    def store
+      Spree::Preferences::Store.instance
+    end
+
+    def fetch(key, &block)
+      store.fetch(key_for(key), &block)
+    end
+
+    def []=(key, value)
+      store[key_for(key)] = value
+    end
+
+    def delete(key)
+      store.delete(key_for(key))
+    end
+
+    private
+
+    def key_for(key)
+      [rails_cache_id, @prefix, key, @suffix].compact.join('/')
+    end
+
+    def rails_cache_id
+      ENV['RAILS_CACHE_ID']
+    end
+  end
+end

data/lib/spree/preferences/static_model_preferences.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Spree
+  module Preferences
+    class StaticModelPreferences
+      class Definition
+        attr_reader :preferences
+
+        def initialize(klass, hash)
+          hash = hash.symbolize_keys
+          hash.keys.each do |key|
+            if !klass.defined_preferences.include?(key)
+              raise "Preference #{key.inspect} is not defined on #{klass}"
+            end
+          end
+          @preferences = hash
+        end
+
+        def fetch(key, &block)
+          @preferences.fetch(key, &block)
+        end
+
+        def []=(key, value)
+          # ignores assignment
+        end
+
+        def to_hash
+          @preferences.deep_dup
+        end
+      end
+
+      def initialize
+        @store = Hash.new do |h, klass|
+          h[klass] = {}
+        end
+      end
+
+      def add(klass, name, preferences)
+        # We use class name instead of class to allow reloading in dev
+        raise "Static model preference '#{name}' on #{klass} is already defined" if @store[klass.to_s][name]
+        @store[klass.to_s][name] = Definition.new(klass, preferences)
+      end
+
+      def for_class(klass)
+        @store[klass.to_s]
+      end
+    end
+  end
+end

data/lib/spree/preferences/statically_configurable.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Spree
+  module Preferences
+    module StaticallyConfigurable
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def preference_sources
+          Spree::Config.static_model_preferences.for_class(self)
+        end
+
+        def available_preference_sources
+          preference_sources.keys
+        end
+      end
+
+      # override assignment to cast empty string to nil
+      def preference_source=(val)
+        super(val.presence)
+      end
+
+      def preferences
+        if respond_to?(:preference_source) && preference_source
+          self.class.preference_sources[preference_source] || {}
+        else
+          self[:preferences]
+        end
+      end
+
+      def preferences=(val)
+        if respond_to?(:preference_source) && preference_source
+        else
+          self[:preferences] = val
+        end
+      end
+    end
+  end
+end

data/lib/spree/preferences/store.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Use singleton class Spree::Preferences::Store.instance to access
+#
+
+require 'singleton'
+
+module Spree::Preferences
+  class StoreInstance
+    def initialize
+      @cache = Rails.cache
+    end
+
+    def set(key, value)
+      @cache.write(key, value)
+      persist(key, value)
+    end
+    alias_method :[]=, :set
+
+    def exist?(key)
+      @cache.exist?(key) ||
+        should_persist? && Spree::Preference.where(key: key).exists?
+    end
+
+    def get(key)
+      # return the retrieved value, if it's in the cache
+      # use unless nil? incase the value is actually boolean false
+      #
+      unless (val = @cache.read(key)).nil?
+        return val
+      end
+
+      if should_persist?
+        # If it's not in the cache, maybe it's in the database, but
+        # has been cleared from the cache
+
+        # does it exist in the database?
+        if preference = Spree::Preference.find_by(key: key)
+          # it does exist
+          val = preference.value
+        else
+          # use the fallback value
+          val = yield
+        end
+
+        # Cache either the value from the db or the fallback value.
+        # This avoids hitting the db with subsequent queries.
+        @cache.write(key, val)
+
+        return val
+      else
+        yield
+      end
+    end
+    alias_method :fetch, :get
+
+    def delete(key)
+      @cache.delete(key)
+      destroy(key)
+    end
+
+    def clear_cache
+      @cache.clear
+    end
+
+    private
+
+    def persist(cache_key, value)
+      return unless should_persist?
+
+      preference = Spree::Preference.where(key: cache_key).first_or_initialize
+      preference.value = value
+      preference.save
+    end
+
+    def destroy(cache_key)
+      return unless should_persist?
+
+      preference = Spree::Preference.find_by(key: cache_key)
+      preference.destroy if preference
+    end
+
+    def should_persist?
+      Spree::Preference.table_exists?
+    end
+  end
+
+  class Store < StoreInstance
+    include Singleton
+  end
+end

data/lib/spree/promo/environment.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spree
+  module Promo
+    class Environment
+      include Core::EnvironmentExtension
+
+      add_class_set :rules
+      add_class_set :actions
+      add_class_set :shipping_actions
+    end
+  end
+end