goca-spree-core 3.1.14.rails.5.0

data/lib/spree/core/importer/product.rb

@@ -0,0 +1,62 @@
+module Spree
+  module Core
+    module Importer
+      class Product
+        attr_reader :product, :product_attrs, :variants_attrs, :options_attrs
+
+        def initialize(product, product_params, options = {})
+          @product = product || Spree::Product.new(product_params)
+
+          @product_attrs = product_params
+          @variants_attrs = options[:variants_attrs] || []
+          @options_attrs = options[:options_attrs] || []
+        end
+
+        def create
+          if product.save
+            variants_attrs.each do |variant_attribute|
+              # make sure the product is assigned before the options=
+              product.variants.create({ product: product }.merge(variant_attribute))
+            end
+
+            set_up_options
+          end
+
+          product
+        end
+
+        def update
+          if product.update_attributes(product_attrs)
+            variants_attrs.each do |variant_attribute|
+              # update the variant if the id is present in the payload
+              if variant_attribute['id'].present?
+                product.variants.find(variant_attribute['id'].to_i).update_attributes(variant_attribute)
+              else
+                # make sure the product is assigned before the options=
+                product.variants.create({ product: product }.merge(variant_attribute))
+              end
+            end
+
+            set_up_options
+          end
+
+          product
+        end
+
+        private
+          def set_up_options
+            options_attrs.each do |name|
+              option_type = Spree::OptionType.where(name: name).first_or_initialize do |option_type|
+                option_type.presentation = name
+                option_type.save!
+              end
+
+              unless product.option_types.include?(option_type)
+                product.option_types << option_type
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/spree/core/importer.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Core
+    module Importer
+    end
+  end
+end
+
+require 'spree/core/importer/order'
+require 'spree/core/importer/product'

data/lib/spree/core/number_generator.rb

@@ -0,0 +1,52 @@
+module Spree
+  module Core
+    class NumberGenerator < Module
+      BASE           = 10
+      DEFAULT_LENGTH = 9
+      NUMBERS        = (0..9).to_a.freeze
+      LETTERS        = ('A'..'Z').to_a.freeze
+
+      attr_accessor :prefix, :length
+
+      def initialize(options)
+        @random     = Random.new
+        @prefix     = options.fetch(:prefix)
+        @length     = options.fetch(:length, DEFAULT_LENGTH)
+        @candidates = NUMBERS + (options[:letters] ? LETTERS : [])
+      end
+
+      def included(host)
+        generator_method   = method(:generate_permalink)
+        generator_instance = self
+
+        host.class_eval do
+          validates(:number, presence: true, uniqueness: { allow_blank: true })
+
+          before_validation do |instance|
+            instance.number ||= generator_method.call(host)
+          end
+
+          define_singleton_method(:number_generator) { generator_instance }
+        end
+      end
+
+      private
+
+      def generate_permalink(host)
+        length = @length
+
+        loop do
+          candidate = new_candidate(length)
+          return candidate unless host.exists?(number: candidate)
+
+          # If over half of all possible options are taken add another digit.
+          length += 1 if host.count > Rational(BASE**length, 2)
+        end
+      end
+
+      def new_candidate(length)
+        @prefix + length.times.map { @candidates.sample(random: @random) }.join
+      end
+    end # Permalink
+  end # Core
+end # Spree

data/lib/spree/core/product_duplicator.rb

@@ -0,0 +1,74 @@
+module Spree
+  class ProductDuplicator
+    attr_accessor :product
+
+    @@clone_images_default = true
+    mattr_accessor :clone_images_default
+
+    def initialize(product, include_images = @@clone_images_default)
+      @product = product
+      @include_images = include_images
+    end
+
+    def duplicate
+      new_product = duplicate_product
+
+      # don't dup the actual variants, just the characterising types
+      new_product.option_types = product.option_types if product.has_variants?
+
+      # allow site to do some customization
+      new_product.send(:duplicate_extra, product) if new_product.respond_to?(:duplicate_extra)
+      new_product.save!
+      new_product
+    end
+
+    protected
+
+    def duplicate_product
+      product.dup.tap do |new_product|
+        new_product.name = "COPY OF #{product.name}"
+        new_product.taxons = product.taxons
+        new_product.created_at = nil
+        new_product.deleted_at = nil
+        new_product.updated_at = nil
+        new_product.product_properties = reset_properties
+        new_product.master = duplicate_master
+        new_product.variants = product.variants.map { |variant| duplicate_variant variant }
+      end
+    end
+
+    def duplicate_master
+      master = product.master
+      master.dup.tap do |new_master|
+        new_master.sku = "COPY OF #{master.sku}"
+        new_master.deleted_at = nil
+        new_master.images = master.images.map { |image| duplicate_image image } if @include_images
+        new_master.price = master.price
+        new_master.currency = master.currency
+      end
+    end
+
+    def duplicate_variant(variant)
+      new_variant = variant.dup
+      new_variant.sku = "COPY OF #{new_variant.sku}"
+      new_variant.deleted_at = nil
+      new_variant.option_values = variant.option_values.map { |option_value| option_value}
+      new_variant
+    end
+
+    def duplicate_image(image)
+      new_image = image.dup
+      new_image.assign_attributes(:attachment => image.attachment.clone)
+      new_image
+    end
+
+    def reset_properties
+      product.product_properties.map do |prop|
+        prop.dup.tap do |new_prop|
+          new_prop.created_at = nil
+          new_prop.updated_at = nil
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/product_filters.rb

@@ -0,0 +1,194 @@
+module Spree
+  module Core
+    # THIS FILE SHOULD BE OVER-RIDDEN IN YOUR SITE EXTENSION!
+    #   the exact code probably won't be useful, though you're welcome to modify and reuse
+    #   the current contents are mainly for testing and documentation
+
+    # To override this file...
+    #   1) Make a copy of it in your sites local /lib/spree folder
+    #   2) Add it to the config load path, or require it in an initializer, e.g...
+    #
+    #      # config/initializers/spree.rb
+    #      require 'spree/core/product_filters'
+    #
+
+    # set up some basic filters for use with products
+    #
+    # Each filter has two parts
+    #  * a parametrized named scope which expects a list of labels
+    #  * an object which describes/defines the filter
+    #
+    # The filter description has three components
+    #  * a name, for displaying on pages
+    #  * a named scope which will 'execute' the filter
+    #  * a mapping of presentation labels to the relevant condition (in the context of the named scope)
+    #  * an optional list of labels and values (for use with object selection - see taxons examples below)
+    #
+    # The named scopes here have a suffix '_any', following Ransack's convention for a
+    # scope which returns results which match any of the inputs. This is purely a convention,
+    # but might be a useful reminder.
+    #
+    # When creating a form, the name of the checkbox group for a filter F should be
+    # the name of F's scope with [] appended, eg "price_range_any[]", and for
+    # each label you should have a checkbox with the label as its value. On submission,
+    # Rails will send the action a hash containing (among other things) an array named
+    # after the scope whose values are the active labels.
+    #
+    # Ransack will then convert this array to a call to the named scope with the array
+    # contents, and the named scope will build a query with the disjunction of the conditions
+    # relating to the labels, all relative to the scope's context.
+    #
+    # The details of how/when filters are used is a detail for specific models (eg products
+    # or taxons), eg see the taxon model/controller.
+
+    # See specific filters below for concrete examples.
+    module ProductFilters
+      # Example: filtering by price
+      #   The named scope just maps incoming labels onto their conditions, and builds the conjunction
+      #   'price' is in the base scope's context (ie, "select foo from products where ...") so
+      #     we can access the field right away
+      #   The filter identifies which scope to use, then sets the conditions for each price range
+      #
+      # If user checks off three different price ranges then the argument passed to
+      # below scope would be something like ["$10 - $15", "$15 - $18", "$18 - $20"]
+      #
+      Spree::Product.add_search_scope :price_range_any do |*opts|
+        conds = opts.map {|o| Spree::Core::ProductFilters.price_filter[:conds][o]}.reject { |c| c.nil? }
+        scope = conds.shift
+        conds.each do |new_scope|
+          scope = scope.or(new_scope)
+        end
+        Spree::Product.joins(master: :default_price).where(scope)
+      end
+
+      def ProductFilters.format_price(amount)
+        Spree::Money.new(amount)
+      end
+
+      def ProductFilters.price_filter
+        v = Spree::Price.arel_table
+        conds = [ [ Spree.t(:under_price, price: format_price(10))     , v[:amount].lteq(10)],
+                  [ "#{format_price(10)} - #{format_price(15)}"        , v[:amount].in(10..15)],
+                  [ "#{format_price(15)} - #{format_price(18)}"        , v[:amount].in(15..18)],
+                  [ "#{format_price(18)} - #{format_price(20)}"        , v[:amount].in(18..20)],
+                  [ Spree.t(:or_over_price, price: format_price(20)) , v[:amount].gteq(20)]]
+        {
+          name:   Spree.t(:price_range),
+          scope:  :price_range_any,
+          conds:  Hash[*conds.flatten],
+          labels: conds.map { |k,v| [k, k] }
+        }
+      end
+
+
+      # Example: filtering by possible brands
+      #
+      # First, we define the scope. Two interesting points here: (a) we run our conditions
+      #   in the scope where the info for the 'brand' property has been loaded; and (b)
+      #   because we may want to filter by other properties too, we give this part of the
+      #   query a unique name (which must be used in the associated conditions too).
+      #
+      # Secondly, the filter. Instead of a static list of values, we pull out all existing
+      #   brands from the db, and then build conditions which test for string equality on
+      #   the (uniquely named) field "p_brand.value". There's also a test for brand info
+      #   being blank: note that this relies on with_property doing a left outer join
+      #   rather than an inner join.
+      Spree::Product.add_search_scope :brand_any do |*opts|
+        conds = opts.map {|o| ProductFilters.brand_filter[:conds][o]}.reject { |c| c.nil? }
+        scope = conds.shift
+        conds.each do |new_scope|
+          scope = scope.or(new_scope)
+        end
+        Spree::Product.with_property('brand').where(scope)
+      end
+
+      def ProductFilters.brand_filter
+        brand_property = Spree::Property.find_by(name: 'brand')
+        brands = brand_property ? Spree::ProductProperty.where(property_id: brand_property.id).pluck(:value).uniq.map(&:to_s) : []
+        pp = Spree::ProductProperty.arel_table
+        conds = Hash[*brands.map { |b| [b, pp[:value].eq(b)] }.flatten]
+        {
+          name:   'Brands',
+          scope:  :brand_any,
+          conds:  conds,
+          labels: (brands.sort).map { |k| [k, k] }
+        }
+      end
+
+      # Example: a parameterized filter
+      #   The filter above may show brands which aren't applicable to the current taxon,
+      #   so this one only shows the brands that are relevant to a particular taxon and
+      #   its descendants.
+      #
+      #   We don't have to give a new scope since the conditions here are a subset of the
+      #   more general filter, so decoding will still work - as long as the filters on a
+      #   page all have unique names (ie, you can't use the two brand filters together
+      #   if they use the same scope). To be safe, the code uses a copy of the scope.
+      #
+      #   HOWEVER: what happens if we want a more precise scope?  we can't pass
+      #   parametrized scope names to Ransack, only atomic names, so couldn't ask
+      #   for taxon T's customized filter to be used. BUT: we can arrange for the form
+      #   to pass back a hash instead of an array, where the key acts as the (taxon)
+      #   parameter and value is its label array, and then get a modified named scope
+      #   to get its conditions from a particular filter.
+      #
+      #   The brand-finding code can be simplified if a few more named scopes were added to
+      #   the product properties model.
+      Spree::Product.add_search_scope :selective_brand_any do |*opts|
+        Spree::Product.brand_any(*opts)
+      end
+
+      def ProductFilters.selective_brand_filter(taxon = nil)
+        taxon ||= Spree::Taxonomy.first.root
+        brand_property = Spree::Property.find_by(name: 'brand')
+        scope = Spree::ProductProperty.where(property: brand_property).
+          joins(product: :taxons).
+          where("#{Spree::Taxon.table_name}.id" => [taxon] + taxon.descendants)
+        brands = scope.pluck(:value).uniq
+        {
+          name:   'Applicable Brands',
+          scope:  :selective_brand_any,
+          labels: brands.sort.map { |k| [k, k] }
+        }
+      end
+
+      # Provide filtering on the immediate children of a taxon
+      #
+      # This doesn't fit the pattern of the examples above, so there's a few changes.
+      # Firstly, it uses an existing scope which was not built for filtering - and so
+      # has no need of a conditions mapping, and secondly, it has a mapping of name
+      # to the argument type expected by the other scope.
+      #
+      # This technique is useful for filtering on objects (by passing ids) or with a
+      # scope that can be used directly (eg. testing only ever on a single property).
+      #
+      # This scope selects products in any of the active taxons or their children.
+      #
+      def ProductFilters.taxons_below(taxon)
+        return Spree::Core::ProductFilters.all_taxons if taxon.nil?
+        {
+          name:   'Taxons under ' + taxon.name,
+          scope:  :taxons_id_in_tree_any,
+          labels: taxon.children.sort_by(&:position).map { |t| [t.name, t.id] },
+          conds:  nil
+        }
+      end
+
+      # Filtering by the list of all taxons
+      #
+      # Similar idea as above, but we don't want the descendants' products, hence
+      # it uses one of the auto-generated scopes from Ransack.
+      #
+      # idea: expand the format to allow nesting of labels?
+      def ProductFilters.all_taxons
+        taxons = Spree::Taxonomy.all.map { |t| [t.root] + t.root.descendants }.flatten
+        {
+          name:   'All taxons',
+          scope:  :taxons_id_equals_any,
+          labels: taxons.sort_by(&:name).map { |t| [t.name, t.id] },
+          conds:  nil # not needed
+        }
+      end
+    end
+  end
+end

data/lib/spree/core/routes.rb

@@ -0,0 +1,46 @@
+module Spree
+  module Core
+    class Engine < ::Rails::Engine
+      def self.add_routes(&block)
+        @spree_routes ||= []
+
+        # Anything that causes the application's routes to be reloaded,
+        # will cause this method to be called more than once
+        # i.e. https://github.com/plataformatec/devise/blob/31971e69e6a1bcf6c7f01eaaa44f227c4af5d4d2/lib/devise/rails.rb#L14
+        # In the case of Devise, this *only* happens in the production env
+        # This coupled with Rails 4's insistence that routes are not drawn twice,
+        # poses quite a serious problem.
+        #
+        # This is mainly why this whole file exists in the first place.
+        #
+        # Thus we need to make sure that the routes aren't drawn twice.
+        unless @spree_routes.include?(block)
+          @spree_routes << block
+        end
+      end
+
+      def self.append_routes(&block)
+        @append_routes ||= []
+        # See comment in add_routes.
+        unless @append_routes.include?(block)
+          @append_routes << block
+        end
+      end
+
+      def self.draw_routes(&block)
+        @spree_routes ||= []
+        @append_routes ||= []
+        eval_block(block) if block_given?
+        @spree_routes.each { |r| eval_block(&r) }
+        @append_routes.each { |r| eval_block(&r) }
+        # # Clear out routes so that they aren't drawn twice.
+        @spree_routes = []
+        @append_routes = []
+      end
+
+      def eval_block(&block)
+        Spree::Core::Engine.routes.send :eval_block, block
+      end
+    end
+  end
+end

data/lib/spree/core/search/base.rb

@@ -0,0 +1,102 @@
+module Spree
+  module Core
+    module Search
+      class Base
+        attr_accessor :properties
+        attr_accessor :current_user
+        attr_accessor :current_currency
+
+        def initialize(params)
+          self.current_currency = Spree::Config[:currency]
+          @properties = {}
+          prepare(params)
+        end
+
+        def retrieve_products
+          @products = get_base_scope
+          curr_page = page || 1
+
+          unless Spree::Config.show_products_without_price
+            @products = @products.where("spree_prices.amount IS NOT NULL").
+                                  where("spree_prices.currency" => current_currency)
+          end
+          @products = @products.page(curr_page).per(per_page)
+        end
+
+        def method_missing(name)
+          if @properties.has_key? name
+            @properties[name]
+          else
+            super
+          end
+        end
+
+        protected
+          def get_base_scope
+            base_scope = Spree::Product.spree_base_scopes.active
+            base_scope = base_scope.in_taxon(taxon) unless taxon.blank?
+            base_scope = get_products_conditions_for(base_scope, keywords)
+            base_scope = add_search_scopes(base_scope)
+            base_scope = add_eagerload_scopes(base_scope)
+            base_scope
+          end
+
+          def add_eagerload_scopes scope
+            # TL;DR Switch from `preload` to `includes` as soon as Rails starts honoring
+            # `order` clauses on `has_many` associations when a `where` constraint
+            # affecting a joined table is present (see
+            # https://github.com/rails/rails/issues/6769).
+            #
+            # Ideally this would use `includes` instead of `preload` calls, leaving it
+            # up to Rails whether associated objects should be fetched in one big join
+            # or multiple independent queries. However as of Rails 4.1.8 any `order`
+            # defined on `has_many` associations are ignored when Rails builds a join
+            # query.
+            #
+            # Would we use `includes` in this particular case, Rails would do
+            # separate queries most of the time but opt for a join as soon as any
+            # `where` constraints affecting joined tables are added to the search;
+            # which is the case as soon as a taxon is added to the base scope.
+            scope = scope.preload(master: :prices)
+            scope = scope.preload(master: :images) if include_images
+            scope
+          end
+
+          def add_search_scopes(base_scope)
+            search.each do |name, scope_attribute|
+              scope_name = name.to_sym
+              if base_scope.respond_to?(:search_scopes) && base_scope.search_scopes.include?(scope_name.to_sym)
+                base_scope = base_scope.send(scope_name, *scope_attribute)
+              else
+                base_scope = base_scope.merge(Spree::Product.ransack({scope_name => scope_attribute}).result)
+              end
+            end if search.is_a?(Hash)
+            base_scope
+          end
+
+          # method should return new scope based on base_scope
+          def get_products_conditions_for(base_scope, query)
+            unless query.blank?
+              base_scope = base_scope.like_any([:name, :description], query.split)
+            end
+            base_scope
+          end
+
+          def prepare(params)
+            @properties[:taxon] = params[:taxon].blank? ? nil : Spree::Taxon.find(params[:taxon])
+            @properties[:keywords] = params[:keywords]
+            @properties[:search] = params[:search]
+            @properties[:include_images] = params[:include_images]
+
+            per_page = params[:per_page].to_i
+            @properties[:per_page] = per_page > 0 ? per_page : Spree::Config[:products_per_page]
+            if params[:page].respond_to?(:to_i)
+              @properties[:page] = (params[:page].to_i <= 0) ? 1 : params[:page].to_i
+            else
+              @properties[:page] = 1
+            end
+          end
+      end
+    end
+  end
+end

data/lib/spree/core/token_generator.rb

@@ -0,0 +1,22 @@
+module Spree
+  module Core
+    module TokenGenerator
+      def generate_guest_token(model_class = Spree::Order)
+        loop do
+          token = "#{random_token}#{unique_ending}"
+          break token unless model_class.exists?(guest_token: token)
+        end
+      end
+
+      private
+
+      def random_token
+        SecureRandom.urlsafe_base64(nil, false)
+      end
+
+      def unique_ending
+        (Time.now.to_f * 1000).to_i
+      end
+    end
+  end
+end

data/lib/spree/core/validators/email.rb

@@ -0,0 +1,11 @@
+class EmailValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    unless value =~ %r{\A(([A-Za-z0-9]+_+)|
+                          ([A-Za-z0-9]+\-+)|
+                          ([A-Za-z0-9]+\.+)|
+                          ([A-Za-z0-9]+\++))*[A-Za-z0-9_]+@((\w+\-+)|
+                          (\w+\.))*\w{1,63}\.[a-zA-Z]{2,6}\z}xi
+      record.errors.add(attribute, :invalid, { value: value }.merge!(options))
+    end
+  end
+end

data/lib/spree/core/version.rb

@@ -0,0 +1,5 @@
+module Spree
+  def self.version
+    "3.1.14.rails.5.0"
+  end
+end

data/lib/spree/core.rb

@@ -0,0 +1,96 @@
+require 'rails/all'
+require 'active_merchant'
+require 'acts_as_list'
+require 'awesome_nested_set'
+require 'cancan'
+require 'friendly_id'
+require 'font-awesome-rails'
+require 'kaminari'
+require 'mail'
+require 'monetize'
+require 'paperclip'
+require 'paranoia'
+require 'premailer/rails'
+require 'ransack'
+require 'responders'
+require 'state_machines-activerecord'
+
+# This is required because ActiveModel::Validations#invalid? conflicts with the
+# invalid state of a Payment. In the future this should be removed.
+StateMachines::Machine.ignore_method_conflicts = true
+
+module Spree
+
+  mattr_accessor :user_class
+
+  def self.user_class
+    if @@user_class.is_a?(Class)
+      raise "Spree.user_class MUST be a String or Symbol object, not a Class object."
+    elsif @@user_class.is_a?(String) || @@user_class.is_a?(Symbol)
+      @@user_class.to_s.constantize
+    end
+  end
+
+  def self.admin_path
+    Spree::Config[:admin_path]
+  end
+
+  # Used to configure admin_path for Spree
+  #
+  # Example:
+  #
+  # write the following line in `config/initializers/spree.rb`
+  #   Spree.admin_path = '/custom-path'
+
+  def self.admin_path=(path)
+    Spree::Config[:admin_path] = path
+  end
+
+  # Used to configure Spree.
+  #
+  # Example:
+  #
+  #   Spree.config do |config|
+  #     config.track_inventory_levels = false
+  #   end
+  #
+  # This method is defined within the core gem on purpose.
+  # Some people may only wish to use the Core part of Spree.
+  def self.config(&block)
+    yield(Spree::Config)
+  end
+
+  module Core
+    autoload :ProductFilters, "spree/core/product_filters"
+    autoload :TokenGenerator, "spree/core/token_generator"
+
+    class GatewayError < RuntimeError; end
+    class DestroyWithOrdersError < StandardError; end
+  end
+end
+
+require 'spree/core/version'
+
+require 'spree/core/environment_extension'
+require 'spree/core/environment/calculators'
+require 'spree/core/environment'
+require 'spree/core/number_generator'
+require 'spree/promo/environment'
+require 'spree/migrations'
+require 'spree/core/engine'
+
+require 'spree/i18n'
+require 'spree/localized_number'
+require 'spree/money'
+require 'spree/permitted_attributes'
+
+require 'spree/core/delegate_belongs_to'
+require 'spree/core/importer'
+require 'spree/core/product_duplicator'
+require 'spree/core/controller_helpers/auth'
+require 'spree/core/controller_helpers/common'
+require 'spree/core/controller_helpers/order'
+require 'spree/core/controller_helpers/respond_with'
+require 'spree/core/controller_helpers/search'
+require 'spree/core/controller_helpers/store'
+require 'spree/core/controller_helpers/strong_parameters'