goca-spree-core 3.1.14.rails.5.0

data/app/models/spree/preference.rb

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

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

@@ -0,0 +1,71 @@
+# This takes the preferrable methods and adds some
+# syntatic sugar to access the preferences
+#
+# class App < Configuration
+#   preference :color, :string
+# end
+#
+# a = App.new
+#
+# setters:
+# a.color = :blue
+# a[:color] = :blue
+# a.set :color = :blue
+# a.preferred_color = :blue
+#
+# getters:
+# a.color
+# a[:color]
+# a.get :color
+# a.preferred_color
+#
+#
+module Spree::Preferences
+  class Configuration
+    include Spree::Preferences::Preferable
+
+    def configure
+      yield(self) if block_given?
+    end
+
+    def preferences
+      ScopedStore.new(self.class.name.underscore)
+    end
+
+    def reset
+      preferences.each do |name, value|
+        set_preference name, preference_default(name)
+      end
+    end
+
+    alias :[] :get_preference
+    alias :[]= :set_preference
+
+    alias :get :get_preference
+
+    def set(*args)
+      options = args.extract_options!
+      options.each do |name, value|
+        set_preference name, value
+      end
+
+      if args.size == 2
+        set_preference args[0], args[1]
+      end
+    end
+
+    def method_missing(method, *args)
+      name = method.to_s.gsub('=', '')
+      if has_preference? name
+        if method.to_s =~ /=$/
+          set_preference(name, args.first)
+        else
+          get_preference name
+        end
+      else
+        super
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,133 @@
+# 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
+
+  def get_preference(name)
+    has_preference! name
+    send self.class.preference_getter_method(name)
+  end
+
+  def set_preference(name, value)
+    has_preference! name
+    send self.class.preference_setter_method(name), value
+  end
+
+  def preference_type(name)
+    has_preference! name
+    send self.class.preference_type_getter_method(name)
+  end
+
+  def preference_default(name)
+    has_preference! name
+    send self.class.preference_default_getter_method(name)
+  end
+
+  def has_preference!(name)
+    raise NoMethodError.new "#{name} preference not defined" unless has_preference? name
+  end
+
+  def has_preference?(name)
+    respond_to? self.class.preference_getter_method(name)
+  end
+
+  def defined_preferences
+    methods.grep(/\Apreferred_.*=\Z/).map do |pref_method|
+      pref_method.to_s.gsub(/\Apreferred_|=\Z/, '').to_sym
+    end
+  end
+
+  def default_preferences
+    Hash[
+      defined_preferences.map do |preference|
+        [preference, preference_default(preference)]
+      end
+    ]
+  end
+
+  def clear_preferences
+    preferences.keys.each {|pref| preferences.delete pref}
+  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.is_a?(FalseClass) ||
+         value.nil? ||
+         value == 0 ||
+         value =~ /^(f|false|0)$/i ||
+         (value.respond_to? :empty? and value.empty?)
+         false
+      else
+         true
+      end
+    when :array
+      value.is_a?(Array) ? value : Array.wrap(value)
+    when :hash
+      case value.class.to_s
+      when "Hash"
+        value
+      when "String"
+        # only works with hashes whose keys are strings
+        JSON.parse value.gsub('=>', ':')
+      when "Array"
+        begin
+          value.try(:to_h)
+        rescue TypeError
+          Hash[*value]
+        rescue ArgumentError
+          raise 'An even count is required when passing an array to be converted to a hash'
+        end
+      else
+        value.class.ancestors.include?(Hash) ? value : {}
+      end
+    else
+      value
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Spree::Preferences
+  module PreferableClassMethods
+
+    def preference(name, type, *args)
+      options = args.extract_options!
+      options.assert_valid_keys(:default)
+      default = options[:default]
+      default = ->{ options[:default] } unless default.is_a?(Proc)
+
+      # 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,98 @@
+# Use singleton class Spree::Preferences::Store.instance to access
+#
+# StoreInstance has a persistence flag that is on by default,
+# but we disable database persistence in testing to speed up tests
+#
+
+require 'singleton'
+
+module Spree::Preferences
+
+  class StoreInstance
+    attr_accessor :persistence
+
+    def initialize
+      @cache = Rails.cache
+      @persistence = true
+    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?
+      @persistence && ActiveRecord::Base.connected? && Spree::Preference.table_exists?
+    end
+
+  end
+
+  class Store < StoreInstance
+    include Singleton
+  end
+
+end

data/app/models/spree/price.rb

@@ -0,0 +1,53 @@
+module Spree
+  class Price < Spree::Base
+    include VatPriceCalculation
+
+    acts_as_paranoid
+
+    MAXIMUM_AMOUNT = BigDecimal('99_999_999.99')
+
+    belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :prices, touch: true
+
+    before_validation :ensure_currency
+
+    validates :amount, allow_nil: true, numericality: {
+      greater_than_or_equal_to: 0,
+      less_than_or_equal_to: MAXIMUM_AMOUNT
+    }
+
+    extend DisplayMoney
+    money_methods :amount, :price
+
+    self.whitelisted_ransackable_attributes = ['amount']
+
+    def money
+      Spree::Money.new(amount || 0, { currency: currency })
+    end
+
+    def amount=(amount)
+      self[:amount] = Spree::LocalizedNumber.parse(amount)
+    end
+
+    alias_attribute :price, :amount
+
+    def price_including_vat_for(price_options)
+      options = price_options.merge(tax_category: variant.tax_category)
+      gross_amount(price, options)
+    end
+
+    def display_price_including_vat_for(price_options)
+      Spree::Money.new(price_including_vat_for(price_options), currency: currency)
+    end
+
+    # Remove variant default_scope `deleted_at: nil`
+    def variant
+      Spree::Variant.unscoped { super }
+    end
+
+    private
+
+    def ensure_currency
+      self.currency ||= Spree::Config[:currency]
+    end
+  end
+end