Bring configuration and preferences code from spree_core

app/models/spree/app_configuration.rb

@@ -0,0 +1,120 @@
+# This is the primary location for defining spree preferences
+#
+# The expectation is that this is created once and stored in
+# the spree environment
+#
+# 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
+#
+require "spree/core/search/base"
+
+module Spree
+  class AppConfiguration < Preferences::Configuration
+
+    # Alphabetized to more easily lookup particular preferences
+    preference :address_requires_state, :boolean, default: true # should state/state_name be required
+    preference :admin_interface_logo, :string, default: 'logo/spree_50.png'
+    preference :admin_products_per_page, :integer, default: 10
+    preference :allow_backorder_shipping, :boolean, default: false # should only be true if you don't need to track inventory
+    preference :allow_checkout_on_gateway_error, :boolean, default: false
+    preference :allow_guest_checkout, :boolean, default: true
+    preference :allow_ssl_in_development_and_test, :boolean, default: false
+    preference :allow_ssl_in_production, :boolean, default: true
+    preference :allow_ssl_in_staging, :boolean, default: true
+    preference :alternative_billing_phone, :boolean, default: false # Request extra phone for bill addr
+    preference :alternative_shipping_phone, :boolean, default: false # Request extra phone for ship addr
+    preference :always_put_site_name_in_title, :boolean, default: true
+    preference :auto_capture, :boolean, default: false # automatically capture the credit card (as opposed to just authorize and capture later)
+    preference :check_for_spree_alerts, :boolean, default: true
+    preference :checkout_zone, :string, default: nil # replace with the name of a zone if you would like to limit the countries
+    preference :company, :boolean, default: false # Request company field for billing and shipping addr
+    preference :currency, :string, default: "USD"
+    preference :currency_decimal_mark, :string, default: "."
+    preference :currency_symbol_position, :string, default: "before"
+    preference :currency_thousands_separator, :string, default: ","
+    preference :display_currency, :boolean, default: false
+    preference :default_country_id, :integer
+    preference :default_meta_description, :string, default: 'Spree demo site'
+    preference :default_meta_keywords, :string, default: 'spree, demo'
+    preference :default_seo_title, :string, default: ''
+    preference :dismissed_spree_alerts, :string, default: ''
+    preference :hide_cents, :boolean, default: false
+    preference :last_check_for_spree_alerts, :string, default: nil
+    preference :layout, :string, default: 'spree/layouts/spree_application'
+    preference :logo, :string, default: 'logo/spree_50.png'
+    preference :max_level_in_taxons_menu, :integer, default: 1 # maximum nesting level in taxons menu
+    preference :orders_per_page, :integer, default: 15
+    preference :prices_inc_tax, :boolean, default: false
+    preference :products_per_page, :integer, default: 12
+    preference :redirect_https_to_http, :boolean, :default => false
+    preference :require_master_price, :boolean, default: true
+    preference :shipment_inc_vat, :boolean, default: false
+    preference :shipping_instructions, :boolean, default: false # Request instructions/info for shipping
+    preference :show_only_complete_orders_by_default, :boolean, default: true
+    preference :show_variant_full_price, :boolean, default: false #Displays variant full price or difference with product price. Default false to be compatible with older behavior
+    preference :show_products_without_price, :boolean, default: false
+    preference :show_raw_product_description, :boolean, :default => false
+    preference :site_name, :string, default: 'Spree Demo Site'
+    preference :site_url, :string, default: 'demo.spreecommerce.com'
+    preference :tax_using_ship_address, :boolean, default: true
+    preference :track_inventory_levels, :boolean, default: true # Determines whether to track on_hand values for variants / products.
+
+    # Preferences related to image settings
+    preference :attachment_default_url, :string, default: '/spree/products/:id/:style/:basename.:extension'
+    preference :attachment_path, :string, default: ':rails_root/public/spree/products/:id/:style/:basename.:extension'
+    preference :attachment_url, :string, default: '/spree/products/:id/:style/:basename.:extension'
+    preference :attachment_styles, :string, default: "{\"mini\":\"48x48>\",\"small\":\"100x100>\",\"product\":\"240x240>\",\"large\":\"600x600>\"}"
+    preference :attachment_default_style, :string, default: 'product'
+    preference :s3_access_key, :string
+    preference :s3_bucket, :string
+    preference :s3_secret, :string
+    preference :s3_headers, :string, default: "{\"Cache-Control\":\"max-age=31557600\"}"
+    preference :use_s3, :boolean, default: false # Use S3 for images rather than the file system
+    preference :s3_protocol, :string
+    preference :s3_host_alias, :string
+
+    # Default mail headers settings
+    preference :enable_mail_delivery, :boolean, :default => false
+    preference :mails_from, :string, :default => 'spree@example.com'
+    preference :mail_bcc, :string, :default => 'spree@example.com'
+    preference :intercept_email, :string, :default => nil
+
+    # Default smtp settings
+    preference :override_actionmailer_config, :boolean, :default => true
+    preference :mail_host, :string, :default => 'localhost'
+    preference :mail_domain, :string, :default => 'localhost'
+    preference :mail_port, :integer, :default => 25
+    preference :secure_connection_type, :string, :default => Core::MailSettings::SECURE_CONNECTION_TYPES[0]
+    preference :mail_auth_type, :string, :default => Core::MailSettings::MAIL_AUTH[0]
+    preference :smtp_username, :string
+    preference :smtp_password, :string
+
+    # searcher_class allows spree extension writers to provide their own Search class
+    def searcher_class
+      @searcher_class ||= Spree::Core::Search::Base
+    end
+
+    def searcher_class=(sclass)
+      @searcher_class = sclass
+    end
+
+    attr_writer :package_factory, :order_updater_decorator
+
+    def package_factory
+      @package_factory ||= Spree::Stock::Package
+    end
+
+    def order_updater_decorator
+      @order_updater_decorator ||= NullDecorator
+    end
+  end
+end

app/models/spree/preference.rb

@@ -0,0 +1,35 @@
+class Spree::Preference < ActiveRecord::Base
+  serialize :value
+
+  validates :key, presence: true
+  validates :value_type, presence: true
+
+  scope :valid, -> { where(Spree::Preference.arel_table[:key].not_eq(nil)).where(Spree::Preference.arel_table[:value_type].not_eq(nil)) }
+
+  # The type conversions here should match
+  # the ones in spree::preferences::preferrable#convert_preference_value
+  def value
+    if self[:value_type].present?
+      case self[:value_type].to_sym
+      when :string, :text
+        self[:value].to_s
+      when :password
+        self[:value].to_s
+      when :decimal
+        BigDecimal.new(self[:value].to_s).round(2, BigDecimal::ROUND_HALF_UP)
+      when :integer
+        self[:value].to_i
+      when :boolean
+        (self[:value].to_s =~ /^[t|1]/i) != nil
+      else
+        self[:value].is_a?(String) ? YAML.load(self[:value]) : self[:value]
+      end
+    else
+      self[:value]
+    end
+  end
+
+  def raw_value
+    self[:value]
+  end
+end

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 preference_cache_key(name)
+      [ENV['RAILS_CACHE_ID'], self.class.name, name].flatten.join('::').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

app/models/spree/preferences/preferable.rb

@@ -0,0 +1,137 @@
+# The preference_cache_key is used to determine if the preference
+# can be set. The default behavior is to return nil if there is no
+# id value. On ActiveRecords, new objects will have their preferences
+# saved to a pending hash until it is persisted.
+#
+# class_attributes are inheritied unless you reassign them in
+# the subclass, so when you inherit a Preferable class, the
+# inherited hook will assign a new hash for the subclass definitions
+# and copy all the definitions allowing the subclass to add
+# additional defintions without affecting the base
+module Spree::Preferences::Preferable
+
+  def self.included(base)
+    base.class_eval do
+      extend Spree::Preferences::PreferableClassMethods
+
+      if respond_to?(:after_create)
+        after_create do |obj|
+          obj.save_pending_preferences
+        end
+      end
+
+      if respond_to?(:after_destroy)
+        after_destroy do |obj|
+          obj.clear_preferences
+        end
+      end
+
+    end
+  end
+
+  def get_preference(name)
+    has_preference! name
+    send self.class.preference_getter_method(name)
+  end
+  alias :preferred :get_preference
+  alias :prefers? :get_preference
+
+  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 preference_description(name)
+    has_preference! name
+    send self.class.preference_description_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 preferences
+    prefs = {}
+    methods.grep(/^prefers_.*\?$/).each do |pref_method|
+      prefs[pref_method.to_s.gsub(/prefers_|\?/, '').to_sym] = send(pref_method)
+    end
+    prefs
+  end
+
+  def prefers?(name)
+    get_preference(name)
+  end
+
+  def preference_cache_key(name)
+    return unless id
+    [ENV["RAILS_CACHE_ID"], self.class.name, name, id].join('::').underscore
+  end
+
+  def save_pending_preferences
+    return unless @pending_preferences
+    @pending_preferences.each do |name, value|
+      set_preference(name, value)
+    end
+  end
+
+  def clear_preferences
+    preferences.keys.each {|pref| preference_store.delete preference_cache_key(pref)}
+  end
+
+  private
+
+  def add_pending_preference(name, value)
+    @pending_preferences ||= {}
+    @pending_preferences[name] = value
+  end
+
+  def get_pending_preference(name)
+    return unless @pending_preferences
+    @pending_preferences[name]
+  end
+
+  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).round(2, BigDecimal::ROUND_HALF_UP)
+    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
+    else
+      value
+    end
+  end
+
+  def preference_store
+    Spree::Preferences::Store.instance
+  end
+
+end
+

app/models/spree/preferences/preferable_class_methods.rb

@@ -0,0 +1,86 @@
+module Spree::Preferences
+  module PreferableClassMethods
+
+    def preference(name, type, *args)
+      options = args.extract_options!
+      options.assert_valid_keys(:default, :description)
+      default = options[:default]
+      description = options[:description] || name
+
+      # 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
+
+        # perference_cache_key will only be nil/false for new records
+        #
+        if preference_cache_key(name)
+          preference_store.get(preference_cache_key(name), default)
+        else
+          get_pending_preference(name) || default
+        end
+      end
+      alias_method prefers_getter_method(name), preference_getter_method(name)
+
+      define_method preference_setter_method(name) do |value|
+        value = convert_preference_value(value, type)
+        if preference_cache_key(name)
+          preference_store.set preference_cache_key(name), value, type
+        else
+          add_pending_preference(name, value)
+        end
+      end
+      alias_method prefers_setter_method(name), preference_setter_method(name)
+
+      define_method preference_default_getter_method(name) do
+        default
+      end
+
+      define_method preference_type_getter_method(name) do
+        type
+      end
+
+      define_method preference_description_getter_method(name) do
+        description
+      end
+    end
+
+    def remove_preference(name)
+      remove_method preference_getter_method(name) if method_defined? preference_getter_method(name)
+      remove_method preference_setter_method(name) if method_defined? preference_setter_method(name)
+      remove_method prefers_getter_method(name) if method_defined? prefers_getter_method(name)
+      remove_method prefers_setter_method(name) if method_defined? prefers_setter_method(name)
+      remove_method preference_default_getter_method(name) if method_defined? preference_default_getter_method(name)
+      remove_method preference_type_getter_method(name) if method_defined? preference_type_getter_method(name)
+      remove_method preference_description_getter_method(name) if method_defined? preference_description_getter_method(name)
+    end
+
+    def preference_getter_method(name)
+      "preferred_#{name}".to_sym
+    end
+
+    def preference_setter_method(name)
+       "preferred_#{name}=".to_sym
+    end
+
+    def prefers_getter_method(name)
+      "prefers_#{name}?".to_sym
+    end
+
+    def prefers_setter_method(name)
+       "prefers_#{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
+
+    def preference_description_getter_method(name)
+      "preferred_#{name}_description".to_sym
+    end
+
+  end
+end

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, type)
+      @cache.write(key, value)
+      persist(key, value, type)
+    end
+
+    def exist?(key)
+      @cache.exist?(key) ||
+      should_persist? && Spree::Preference.where(:key => key).exists?
+    end
+
+    def get(key,fallback=nil)
+      # 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 Spree::Preference.table_exists? && preference = Spree::Preference.find_by_key(key)
+          # it does exist, so let's put it back into the cache
+          @cache.write(preference.key, preference.value)
+
+          # and return the value
+          return preference.value
+        end
+      end
+
+      unless fallback.nil?
+        # cache fallback so we won't hit the db above on
+        # subsequent queries for the same key
+        #
+        @cache.write(key, fallback)
+      end
+
+      return fallback
+    end
+
+    def delete(key)
+      @cache.delete(key)
+      destroy(key)
+    end
+
+    def clear_cache
+      @cache.clear
+    end
+
+    private
+
+    def persist(cache_key, value, type)
+      return unless should_persist?
+
+      preference = Spree::Preference.where(:key => cache_key).first_or_initialize
+      preference.value = value
+      preference.value_type = type
+      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 && Spree::Preference.connected? && Spree::Preference.table_exists?
+    end
+
+  end
+
+  class Store < StoreInstance
+    include Singleton
+  end
+
+end