spree_core 3.7.14.1 → 4.0.0.beta

data/app/models/concerns/spree/acts_as_taggable.rb

@@ -1,11 +0,0 @@
-module Spree
-  module ActsAsTaggable
-    extend ActiveSupport::Concern
-
-    included do
-      acts_as_taggable
-      Spree::PermittedAttributes.send("#{model_name.param_key}_attributes") <<
-        [:tag_list]
-    end
-  end
-end

data/app/models/spree/image/configuration/paperclip.rb

@@ -1,64 +0,0 @@
-module Spree
-  class Image < Asset
-    module Configuration
-      module Paperclip
-        extend ActiveSupport::Concern
-
-        included do
-          validate :no_attachment_errors
-
-          def self.accepted_image_types
-            %w(image/jpeg image/jpg image/png image/gif)
-          end
-
-          def self.styles
-            attachment_definitions[:attachment][:styles]
-          end
-
-          has_attached_file :attachment,
-            styles: { mini: '48x48>', small: '100x100>', product: '240x240>', large: '600x600>' },
-            default_style: :product,
-            url: '/spree/products/:id/:style/:basename.:extension',
-            path: ':rails_root/public/spree/products/:id/:style/:basename.:extension',
-            convert_options: { all: '-strip -auto-orient -colorspace sRGB' }
-
-          validates_attachment :attachment,
-            presence: true,
-            content_type: { content_type: accepted_image_types }
-
-          # save the w,h of the original image (from which others can be calculated)
-          # we need to look at the write-queue for images which have not been saved yet
-          before_save :find_dimensions, if: :attachment_updated_at_changed?
-
-          delegate :url, to: :attachment
-
-          # used by admin products autocomplete
-          def mini_url
-            url(:mini, false)
-          end
-
-          def find_dimensions
-            temporary = attachment.queued_for_write[:original]
-            filename = temporary.path unless temporary.nil?
-            filename = attachment.path if filename.blank?
-            geometry = ::Paperclip::Geometry.from_file(filename)
-            self.attachment_width  = geometry.width
-            self.attachment_height = geometry.height
-          end
-
-          # if there are errors from the plugin, then add a more meaningful message
-          def no_attachment_errors
-            unless attachment.errors.empty?
-              # uncomment this to get rid of the less-than-useful interim messages
-              # errors.clear
-              errors.add :attachment,
-                "Paperclip returned errors for file '#{attachment_file_name}' - check ImageMagick installation or image source file."
-
-              false
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/app/models/spree/order_contents.rb

@@ -1,54 +0,0 @@
-module Spree
-  class OrderContents
-    attr_accessor :order, :currency
-
-    def initialize(order)
-      @order = order
-    end
-
-    def add(variant, quantity = 1, options = {})
-      ActiveSupport::Deprecation.warn(<<-EOS, caller)
-        OrderContents#add method is deprecated and will be removed in Spree 4.0.
-        Please use Spree::Dependencies.cart_add_item_service
-        to add items to cart.
-      EOS
-
-      Spree::Dependencies.cart_add_item_service.constantize.call(order: order,
-                                                                 variant: variant,
-                                                                 quantity: quantity,
-                                                                 options: options).value
-    end
-
-    def remove(variant, quantity = 1, options = {})
-      ActiveSupport::Deprecation.warn(<<-EOS, caller)
-        OrderContents#remove method is deprecated and will be removed in Spree 4.0.
-        Please use Spree::Dependencies.cart_remove_item_service
-        service to remove item from cart.
-      EOS
-
-      # change this dependencies to Spree::Cart::RemoveItem
-      Spree::Dependencies.cart_remove_item_service.constantize.call(order: order,
-                                                                    variant: variant,
-                                                                    quantity: quantity,
-                                                                    options: options).value
-    end
-
-    def remove_line_item(line_item, options = {})
-      ActiveSupport::Deprecation.warn(<<-EOS, caller)
-        OrderContents#remove_line_item method is deprecated and will be removed in Spree 4.0.
-      EOS
-
-      Spree::Cart::RemoveLineItem.call(order: @order, line_item: line_item, options: options).value
-    end
-
-    def update_cart(params)
-      ActiveSupport::Deprecation.warn(<<-EOS, caller)
-        OrderContents#update_cart method is deprecated and will be removed in Spree 4.0.
-        Spree::Dependencies.cart_update_service
-        service to update cart.
-      EOS
-
-      Spree::Dependencies.cart_update_service.constantize.call(order: order, params: params).value
-    end
-  end
-end

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

@@ -1,250 +0,0 @@
-module Spree
-  class Product < Spree::Base
-    cattr_accessor :search_scopes do
-      []
-    end
-
-    def self.add_search_scope(name, &block)
-      singleton_class.send(:define_method, name.to_sym, &block)
-      search_scopes << name.to_sym
-    end
-
-    def self.simple_scopes
-      [
-        :ascend_by_updated_at,
-        :descend_by_updated_at,
-        :ascend_by_name,
-        :descend_by_name
-      ]
-    end
-
-    def self.add_simple_scopes(scopes)
-      scopes.each do |name|
-        # We should not define price scopes here, as they require something slightly different
-        next if name.to_s.include?('master_price')
-
-        parts = name.to_s.match(/(.*)_by_(.*)/)
-        scope(name.to_s, -> { order(Arel.sql("#{Product.quoted_table_name}.#{parts[2]} #{parts[1] == 'ascend' ? 'ASC' : 'DESC'}")) })
-      end
-    end
-
-    def self.property_conditions(property)
-      properties = Property.table_name
-      case property
-      when String   then { "#{properties}.name" => property }
-      when Property then { "#{properties}.id" => property.id }
-      else { "#{properties}.id" => property.to_i }
-      end
-    end
-
-    add_simple_scopes simple_scopes
-
-    add_search_scope :ascend_by_master_price do
-      joins(master: :default_price).order("#{price_table_name}.amount ASC")
-    end
-
-    add_search_scope :descend_by_master_price do
-      joins(master: :default_price).order("#{price_table_name}.amount DESC")
-    end
-
-    add_search_scope :price_between do |low, high|
-      joins(master: :default_price).where(Price.table_name => { amount: low..high })
-    end
-
-    add_search_scope :master_price_lte do |price|
-      joins(master: :default_price).where("#{price_table_name}.amount <= ?", price)
-    end
-
-    add_search_scope :master_price_gte do |price|
-      joins(master: :default_price).where("#{price_table_name}.amount >= ?", price)
-    end
-
-    # This scope selects products in taxon AND all its descendants
-    # If you need products only within one taxon use
-    #
-    #   Spree::Product.joins(:taxons).where(Taxon.table_name => { id: taxon.id })
-    #
-    # If you're using count on the result of this scope, you must use the
-    # `:distinct` option as well:
-    #
-    #   Spree::Product.in_taxon(taxon).count(distinct: true)
-    #
-    # This is so that the count query is distinct'd:
-    #
-    #   SELECT COUNT(DISTINCT "spree_products"."id") ...
-    #
-    #   vs.
-    #
-    #   SELECT COUNT(*) ...
-    add_search_scope :in_taxon do |taxon|
-      includes(:classifications).
-        where('spree_products_taxons.taxon_id' => taxon.self_and_descendants.pluck(:id)).
-        order('spree_products_taxons.position ASC')
-    end
-
-    # This scope selects products in all taxons AND all its descendants
-    # If you need products only within one taxon use
-    #
-    #   Spree::Product.taxons_id_eq([x,y])
-    add_search_scope :in_taxons do |*taxons|
-      taxons = get_taxons(taxons)
-      taxons.first ? prepare_taxon_conditions(taxons) : where(nil)
-    end
-
-    # a scope that finds all products having property specified by name, object or id
-    add_search_scope :with_property do |property|
-      joins(:properties).where(property_conditions(property))
-    end
-
-    # a simple test for product with a certain property-value pairing
-    # note that it can test for properties with NULL values, but not for absent values
-    add_search_scope :with_property_value do |property, value|
-      joins(:properties).
-        where("#{ProductProperty.table_name}.value = ?", value).
-        where(property_conditions(property))
-    end
-
-    add_search_scope :with_option do |option|
-      option_types = OptionType.table_name
-      conditions = case option
-                   when String     then { "#{option_types}.name" => option }
-                   when OptionType then { "#{option_types}.id" => option.id }
-                   else { "#{option_types}.id" => option.to_i }
-                   end
-
-      joins(:option_types).where(conditions)
-    end
-
-    add_search_scope :with_option_value do |option, value|
-      option_values = OptionValue.table_name
-      option_type_id = case option
-                       when String then OptionType.find_by(name: option) || option.to_i
-                       when OptionType then option.id
-                       else option.to_i
-                       end
-
-      conditions = "#{option_values}.name = ? AND #{option_values}.option_type_id = ?", value, option_type_id
-      group('spree_products.id').joins(variants_including_master: :option_values).where(conditions)
-    end
-
-    # Finds all products which have either:
-    # 1) have an option value with the name matching the one given
-    # 2) have a product property with a value matching the one given
-    add_search_scope :with do |value|
-      includes(variants_including_master: :option_values).
-        includes(:product_properties).
-        where("#{OptionValue.table_name}.name = ? OR #{ProductProperty.table_name}.value = ?", value, value)
-    end
-
-    # Finds all products that have a name containing the given words.
-    add_search_scope :in_name do |words|
-      like_any([:name], prepare_words(words))
-    end
-
-    # Finds all products that have a name or meta_keywords containing the given words.
-    add_search_scope :in_name_or_keywords do |words|
-      like_any([:name, :meta_keywords], prepare_words(words))
-    end
-
-    # Finds all products that have a name, description, meta_description or meta_keywords containing the given keywords.
-    add_search_scope :in_name_or_description do |words|
-      like_any([:name, :description, :meta_description, :meta_keywords], prepare_words(words))
-    end
-
-    # Finds all products that have the ids matching the given collection of ids.
-    # Alternatively, you could use find(collection_of_ids), but that would raise an exception if one product couldn't be found
-    add_search_scope :with_ids do |*ids|
-      where(id: ids)
-    end
-
-    # Sorts products from most popular (popularity is extracted from how many
-    # times use has put product in cart, not completed orders)
-    #
-    # there is alternative faster and more elegant solution, it has small drawback though,
-    # it doesn stack with other scopes :/
-    #
-    # joins: "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
-    # order: 'COALESCE(cnt, 0) DESC'
-    add_search_scope :descend_by_popularity do
-      joins(:master).
-        order(%Q{
-           COALESCE((
-             SELECT
-               COUNT(#{LineItem.quoted_table_name}.id)
-             FROM
-               #{LineItem.quoted_table_name}
-             JOIN
-               #{Variant.quoted_table_name} AS popular_variants
-             ON
-               popular_variants.id = #{LineItem.quoted_table_name}.variant_id
-             WHERE
-               popular_variants.product_id = #{Product.quoted_table_name}.id
-           ), 0) DESC
-        })
-    end
-
-    add_search_scope :not_deleted do
-      where("#{Product.quoted_table_name}.deleted_at IS NULL or #{Product.quoted_table_name}.deleted_at >= ?", Time.zone.now)
-    end
-
-    def self.not_discontinued(only_not_discontinued = true)
-      if only_not_discontinued != '0' && only_not_discontinued
-        where("#{Product.quoted_table_name}.discontinue_on IS NULL or #{Product.quoted_table_name}.discontinue_on >= ?", Time.zone.now)
-      else
-        all
-      end
-    end
-    search_scopes << :not_discontinued
-    # Can't use add_search_scope for this as it needs a default argument
-    def self.available(available_on = nil, _currency = nil)
-      available_on ||= Time.current
-      not_discontinued.joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on)
-    end
-    search_scopes << :available
-
-    def self.active(currency = nil)
-      available(nil, currency)
-    end
-    search_scopes << :active
-
-    add_search_scope :taxons_name_eq do |name|
-      group('spree_products.id').joins(:taxons).where(Taxon.arel_table[:name].eq(name))
-    end
-
-    def self.price_table_name
-      Price.quoted_table_name
-    end
-    private_class_method :price_table_name
-
-    # specifically avoid having an order for taxon search (conflicts with main order)
-    def self.prepare_taxon_conditions(taxons)
-      ids = taxons.map { |taxon| taxon.self_and_descendants.pluck(:id) }.flatten.uniq
-      joins(:classifications).where(Classification.table_name => { taxon_id: ids })
-    end
-    private_class_method :prepare_taxon_conditions
-
-    # Produce an array of keywords for use in scopes.
-    # Always return array with at least an empty string to avoid SQL errors
-    def self.prepare_words(words)
-      return [''] if words.blank?
-
-      a = words.split(/[,\s]/).map(&:strip)
-      a.any? ? a : ['']
-    end
-    private_class_method :prepare_words
-
-    def self.get_taxons(*ids_or_records_or_names)
-      taxons = Taxon.table_name
-      ids_or_records_or_names.flatten.map do |t|
-        case t
-        when Integer then Taxon.find_by(id: t)
-        when ApplicationRecord then t
-        when String
-          Taxon.find_by(name: t) ||
-            Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first
-        end
-      end.compact.flatten.uniq
-    end
-    private_class_method :get_taxons
-  end
-end

data/app/models/spree/tag.rb

@@ -1,4 +0,0 @@
-module Spree
-  class Tag < ActsAsTaggableOn::Tag
-  end
-end

data/app/models/spree/taxon_image/configuration/paperclip.rb

@@ -1,27 +0,0 @@
-module Spree
-  class TaxonImage < Asset
-    module Configuration
-      module Paperclip
-        extend ActiveSupport::Concern
-
-        included do
-          def self.styles
-            attachment_definitions[:attachment][:styles]
-          end
-
-          delegate :url, to: :attachment
-
-          has_attached_file :attachment,
-            styles: { mini: '32x32>', normal: '128x128>' },
-            default_style: :mini,
-            url: '/spree/taxons/:viewable_id/:style/:basename.:extension',
-            path: ':rails_root/public/spree/taxons/:viewable_id/:style/:basename.:extension',
-            default_url: '/assets/default_taxon.png'
-
-          validates_attachment :attachment,
-            content_type: { content_type: ['image/jpg', 'image/jpeg', 'image/png', 'image/gif'] }
-        end
-      end
-    end
-  end
-end

data/config/initializers/acts_as_taggable_on.rb

@@ -1,9 +0,0 @@
-require 'acts-as-taggable-on'
-
-ActsAsTaggableOn::Tag.class_eval do
-  self.table_name_prefix = 'spree_'
-end
-
-ActsAsTaggableOn::Tagging.class_eval do
-  self.table_name_prefix = 'spree_'
-end

data/config/initializers/use_paperclip.rb

@@ -1,3 +0,0 @@
-Rails.application.configure do
-  config.use_paperclip = ActiveModel::Type::Boolean.new.cast ENV['SPREE_USE_PAPERCLIP']
-end

data/db/migrate/20160511071954_acts_as_taggable_on_spree_migration.rb

@@ -1,40 +0,0 @@
-class ActsAsTaggableOnSpreeMigration < ActiveRecord::Migration[4.2]
-  def self.up
-    create_table :spree_tags do |t|
-      t.string :name
-      t.integer :taggings_count, default: 0
-    end
-
-    create_table :spree_taggings do |t|
-      t.references :tag
-
-      # You should make sure that the column created is
-      # long enough to store the required class names.
-      t.references :taggable, polymorphic: true
-      t.references :tagger, polymorphic: true
-
-      # Limit is created to prevent MySQL error on index
-      # length for MyISAM table type: http://bit.ly/vgW2Ql
-      t.string :context, limit: 128
-
-      t.datetime :created_at
-    end
-
-    add_index :spree_tags, :name, unique: true
-    add_index :spree_taggings,
-              [
-                :tag_id,
-                :taggable_id,
-                :taggable_type,
-                :context,
-                :tagger_id,
-                :tagger_type
-              ],
-              unique: true, name: "spree_taggings_idx"
-  end
-
-  def self.down
-    drop_table :spree_taggings
-    drop_table :spree_tags
-  end
-end