solidus_core 1.0.0.pre

data/app/models/spree/preference.rb

@@ -0,0 +1,5 @@
+class Spree::Preference < Spree::Base
+  serialize :value
+
+  validates :key, presence: true, uniqueness: true
+end

data/app/models/spree/preferences/configuration.rb

@@ -0,0 +1,78 @@
+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. Default is {ScopedStore}
+    attr_writer :preference_store
+    def preference_store
+      @preference_store ||= ScopedStore.new(self.class.name.underscore)
+    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
+
+    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}", "preferred_#{name}"
+      alias_method "#{name}=", "preferred_#{name}="
+    end
+  end
+end

data/app/models/spree/preferences/preferable.rb

@@ -0,0 +1,128 @@
+# 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!
+module Spree::Preferences::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
+
+  private
+
+  def convert_preference_value(value, type)
+    case type
+    when :string, :text
+      value.to_s
+    when :password
+      value.to_s
+    when :decimal
+      BigDecimal.new(value.to_s)
+    when :integer
+      value.to_i
+    when :boolean
+      if !value ||
+         value == 0 ||
+         value =~ /\A(f|false|0)\Z/i ||
+         (value.respond_to? :empty? and 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

data/app/models/spree/preferences/preferable_class_methods.rb

@@ -0,0 +1,64 @@
+module Spree::Preferences
+  module PreferableClassMethods
+    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
+  end
+end

data/app/models/spree/preferences/scoped_store.rb

@@ -0,0 +1,33 @@
+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/app/models/spree/preferences/store.rb

@@ -0,0 +1,93 @@
+# 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/app/models/spree/price.rb

@@ -0,0 +1,62 @@
+module Spree
+  class Price < Spree::Base
+    acts_as_paranoid
+    belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :prices, touch: true
+
+    validate :check_price
+    validates :amount, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
+    validate :validate_amount_maximum
+    after_save :set_default_price
+
+    extend DisplayMoney
+    money_methods :amount, :price
+
+    # @return [Spree::Money] this price as a Spree::Money object
+    def money
+      Spree::Money.new(amount || 0, { currency: currency })
+    end
+
+    # An alias for #amount
+    def price
+      amount
+    end
+
+    # Sets this price's amount to a new value, parsing it if the new value is
+    # a string.
+    #
+    # @param price [String, #to_d] a new amount
+    def price=(price)
+      self[:amount] = Spree::LocalizedNumber.parse(price)
+    end
+
+    # @note This returns the variant regardless of whether it was soft
+    #   deleted.
+    # @return [Spree::Variant] this price's variant.
+    def variant
+      Spree::Variant.unscoped { super }
+    end
+
+    private
+
+    def check_price
+      self.currency ||= Spree::Config[:currency]
+    end
+
+    def maximum_amount
+      BigDecimal '999999.99'
+    end
+
+    def validate_amount_maximum
+      if amount && amount > maximum_amount
+        errors.add :amount, I18n.t('errors.messages.less_than_or_equal_to', count: maximum_amount)
+      end
+    end
+
+    def set_default_price
+      if is_default?
+        other_default_prices = variant.prices.where(currency: self.currency, is_default: true).where.not(id: self.id)
+        other_default_prices.each { |p| p.update_attributes!(is_default: false) }
+      end
+    end
+  end
+end