spree_core 2.2.14 → 2.3.0

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

@@ -3,55 +3,33 @@ module Spree::Preferences
 
     def preference(name, type, *args)
       options = args.extract_options!
-      options.assert_valid_keys(:default, :description)
+      options.assert_valid_keys(:default)
       default = options[:default]
-      description = options[:description] || name
+      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
-
-        # 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
+        preferences.fetch(name) do
+          default.call
         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)
+        preferences[name] = value
 
-      define_method preference_default_getter_method(name) do
-        default
+        # 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
-
-      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)
@@ -62,14 +40,6 @@ module Spree::Preferences
        "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
@@ -77,10 +47,5 @@ module Spree::Preferences
     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

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

@@ -16,17 +16,18 @@ module Spree::Preferences
       @persistence = true
     end
 
-    def set(key, value, type)
+    def set(key, value)
       @cache.write(key, value)
-      persist(key, value, type)
+      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,fallback=nil)
+    def get(key)
       # return the retrieved value, if it's in the cache
       # use unless nil? incase the value is actually boolean false
       #
@@ -44,7 +45,7 @@ module Spree::Preferences
           val = preference.value
         else
           # use the fallback value
-          val = fallback
+          val = yield
         end
 
         # Cache either the value from the db or the fallback value.
@@ -53,9 +54,10 @@ module Spree::Preferences
 
         return val
       else
-        return fallback
+        yield
       end
     end
+    alias_method :fetch, :get
 
     def delete(key)
       @cache.delete(key)
@@ -68,12 +70,11 @@ module Spree::Preferences
 
     private
 
-    def persist(cache_key, value, type)
+    def persist(cache_key, value)
       return unless should_persist?
 
       preference = Spree::Preference.where(:key => cache_key).first_or_initialize
       preference.value = value
-      preference.value_type = type
       preference.save
     end
 

data/app/models/spree/price.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Price < ActiveRecord::Base
+  class Price < Spree::Base
     acts_as_paranoid
     belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :prices, touch: true
 
@@ -11,8 +11,6 @@ module Spree
     end
     alias :display_price :display_amount
 
-    self.whitelisted_ransackable_attributes = ['amount']
-
     def money
       Spree::Money.new(amount || 0, { currency: currency })
     end

data/app/models/spree/product.rb

@@ -19,11 +19,12 @@
 #
 
 module Spree
-  class Product < ActiveRecord::Base
+  class Product < Spree::Base
     extend FriendlyId
     friendly_id :slug_candidates, use: :slugged
 
     acts_as_paranoid
+
     has_many :product_option_types, dependent: :destroy, inverse_of: :product
     has_many :option_types, through: :product_option_types
     has_many :product_properties, dependent: :destroy, inverse_of: :product
@@ -39,7 +40,8 @@ module Spree
     has_one :master,
       -> { where is_master: true },
       inverse_of: :product,
-      class_name: 'Spree::Variant'
+      class_name: 'Spree::Variant',
+      dependent: :destroy
 
     has_many :variants,
       -> { where(is_master: false).order("#{::Spree::Variant.quoted_table_name}.position ASC") },
@@ -63,9 +65,9 @@ module Spree
     after_create :set_master_variant_defaults
     after_create :add_properties_and_option_types_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
+
     after_save :save_master
-    after_save :run_touch_callbacks, if: :anything_changed?
-    after_save :reset_nested_changes
+    after_save :touch
     after_touch :touch_taxons
 
     delegate :images, to: :master, prefix: true
@@ -91,13 +93,6 @@ module Spree
 
     after_initialize :ensure_master
 
-    self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
-    self.whitelisted_ransackable_attributes = %w[slug]
-
-    def to_param
-      slug
-    end
-
     # the master variant is not a member of the variants array
     def has_variants?
       variants.any?
@@ -204,10 +199,10 @@ module Spree
     end
 
     def total_on_hand
-      if any_variants_not_track_inventory?
+      if self.variants_including_master.any? { |v| !v.should_track_inventory? }
         Float::INFINITY
       else
-        stock_items.sum(:count_on_hand)
+        self.stock_items.to_a.sum(&:count_on_hand)
       end
     end
 
@@ -220,93 +215,70 @@ module Spree
 
     private
 
-    def add_properties_and_option_types_from_prototype
-      if prototype_id && prototype = Spree::Prototype.find_by(id: prototype_id)
-        prototype.properties.each do |property|
-          product_properties.create(property: property)
-        end
-        self.option_types = prototype.option_types
+      def normalize_slug
+        self.slug = normalize_friendly_id(slug)
       end
-    end
 
-    def any_variants_not_track_inventory?
-      if variants_including_master.loaded?
-        variants_including_master.any? { |v| !v.should_track_inventory? }
-      else
-        !Spree::Config.track_inventory_levels || variants_including_master.where(track_inventory: false).any?
+      # Builds variants from a hash of option types & values
+      def build_variants_from_option_values_hash
+        ensure_option_types_exist_for_values_hash
+        values = option_values_hash.values
+        values = values.inject(values.shift) { |memo, value| memo.product(value).map(&:flatten) }
+
+        values.each do |ids|
+          variant = variants.create(
+            option_value_ids: ids,
+            price: master.price
+          )
+        end
+        save
       end
-    end
 
-    # Builds variants from a hash of option types & values
-    def build_variants_from_option_values_hash
-      ensure_option_types_exist_for_values_hash
-      values = option_values_hash.values
-      values = values.inject(values.shift) { |memo, value| memo.product(value).map(&:flatten) }
-
-      values.each do |ids|
-        variant = variants.create(
-          option_value_ids: ids,
-          price: master.price
-        )
+      def add_properties_and_option_types_from_prototype
+        if prototype_id && prototype = Spree::Prototype.find_by(id: prototype_id)
+          prototype.properties.each do |property|
+            product_properties.create(property: property)
+          end
+          self.option_types = prototype.option_types
+        end
       end
-      save
-    end
-
-    def ensure_master
-      return unless new_record?
-      self.master ||= Variant.new
-    end
 
-    def normalize_slug
-      self.slug = normalize_friendly_id(slug)
-    end
-
-    def punch_slug
-      update_column :slug, "#{Time.now.to_i}_#{slug}" # punch slug with date prefix to allow reuse of original
-    end
-
-    def anything_changed?
-      changed? || @nested_changes
-    end
-
-    def reset_nested_changes
-      @nested_changes = false
-    end
+      # ensures the master variant is flagged as such
+      def set_master_variant_defaults
+        master.is_master = true
+      end
 
-    # there's a weird quirk with the delegate stuff that does not automatically save the delegate object
-    # when saving so we force a save using a hook.
-    def save_master
-      if master && (master.changed? || master.new_record? || (master.default_price && (master.default_price.changed? || master.default_price.new_record?)))
-        master.save
-        @nested_changes = true
+      # there's a weird quirk with the delegate stuff that does not automatically save the delegate object
+      # when saving so we force a save using a hook.
+      def save_master
+        master.save if master && (master.changed? || master.new_record? || (master.default_price && (master.default_price.changed? || master.default_price.new_record?)))
       end
-    end
 
-    # ensures the master variant is flagged as such
-    def set_master_variant_defaults
-      master.is_master = true
-    end
+      def ensure_master
+        return unless new_record?
+        self.master ||= Variant.new
+      end
 
-    # Try building a slug based on the following fields in increasing order of specificity.
-    def slug_candidates
-      [
-          :name,
-          [:name, :sku]
-      ]
-    end
+      # Iterate through this products taxons and taxonomies and touch their timestamps in a batch
+      def touch_taxons
+        taxons_to_touch = taxons.map(&:self_and_ancestors).flatten.uniq
+        Spree::Taxon.where(id: taxons_to_touch.map(&:id)).update_all(updated_at: Time.current)
 
-    def run_touch_callbacks
-      run_callbacks(:touch)
-    end
+        taxonomy_ids_to_touch = taxons_to_touch.map(&:taxonomy_id).flatten.uniq
+        Spree::Taxonomy.where(id: taxonomy_ids_to_touch).update_all(updated_at: Time.current)
+      end
 
-    # Iterate through this products taxons and taxonomies and touch their timestamps in a batch
-    def touch_taxons
-      taxons_to_touch = taxons.map(&:self_and_ancestors).flatten.uniq
-      Spree::Taxon.where(id: taxons_to_touch.map(&:id)).update_all(updated_at: Time.current)
+      # Try building a slug based on the following fields in increasing order of specificity.
+      def slug_candidates
+        [
+            :name,
+            [:name, :sku]
+        ]
+      end
 
-      taxonomy_ids_to_touch = taxons_to_touch.map(&:taxonomy_id).flatten.uniq
-      Spree::Taxonomy.where(id: taxonomy_ids_to_touch).update_all(updated_at: Time.current)
-    end
+      def punch_slug
+        update(slug: "#{Time.now.to_i}_#{slug}") # punch slug with date prefix to allow reuse of original
+      end
 
   end
 end

data/app/models/spree/product/scopes.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Product < ActiveRecord::Base
+  class Product < Spree::Base
     cattr_accessor :search_scopes do
       []
     end
@@ -201,19 +201,28 @@ module Spree
       group("spree_products.id").joins(:taxons).where(Taxon.arel_table[:name].eq(name))
     end
 
-    def self.distinct_by_product_ids(sort_order=nil)
-      if (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL')
-        sort_column = sort_order.split(" ").first
-        # Don't allow sort_column, a variable coming from params,
-        # to be anything but a column in the database
-        if column_names.include?(sort_column)
-          distinct_fields = ["id", sort_column].compact.join(",")
-          select("DISTINCT ON(#{distinct_fields}) spree_products.*")
-        else
-          all
-        end
+    def self.distinct_by_product_ids(sort_order = nil)
+      sort_column = sort_order.split(" ").first
+
+      # Postgres will complain when using ordering by expressions not present in
+      # SELECT DISTINCT. e.g.
+      #
+      #   PG::InvalidColumnReference: ERROR:  for SELECT DISTINCT, ORDER BY
+      #   expressions must appear in select list. e.g.
+      #
+      #   SELECT  DISTINCT "spree_products".* FROM "spree_products" LEFT OUTER JOIN
+      #   "spree_variants" ON "spree_variants"."product_id" = "spree_products"."id" AND "spree_variants"."is_master" = 't'
+      #   AND "spree_variants"."deleted_at" IS NULL LEFT OUTER JOIN "spree_prices" ON
+      #   "spree_prices"."variant_id" = "spree_variants"."id" AND "spree_prices"."currency" = 'USD'
+      #   AND "spree_prices"."deleted_at" IS NULL WHERE "spree_products"."deleted_at" IS NULL AND ('t'='t') 
+      #   ORDER BY "spree_prices"."amount" ASC LIMIT 10 OFFSET 0
+      #
+      # Don't allow sort_column, a variable coming from params,
+      # to be anything but a column in the database
+      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' && !column_names.include?(sort_column)
+        all
       else
-        select("DISTINCT spree_products.*")
+        distinct
       end
     end