solidus_core 1.0.0.pre

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

@@ -0,0 +1,46 @@
+module Spree
+  module Core
+    module Search
+      class Variant
+
+        class_attribute :search_terms
+        self.search_terms = [
+          :sku_cont,
+          :product_name_cont,
+          :product_slug_cont,
+          :option_values_presentation_cont,
+          :option_values_name_cont,
+        ]
+
+        def initialize(query_string, scope: Spree::Variant.all)
+          @query_string = query_string
+          @scope = scope
+        end
+
+        # Searches the variants table using the ransack 'search_terms' defined on the class.
+        # Each word of the query string is searched individually, matching by a union of the ransack
+        # search terms, then we find the intersection of those queries, ensuring that each word matches
+        # one of the rules.
+        #
+        # == Returns:
+        # ActiveRecord::Relation of variants
+        def results
+          return @scope if @query_string.blank?
+
+          matches = @query_string.split.map do |word|
+            @scope.ransack(search_terms(word)).result.pluck(:id)
+          end
+
+          Spree::Variant.where(id: matches.inject(:&))
+        end
+
+        private
+
+        def search_terms(word)
+          terms = Hash[self.class.search_terms.map { |t| [t, word] }]
+          terms.merge(m: 'or')
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/unreturned_item_charger.rb

@@ -0,0 +1,102 @@
+module Spree
+  class UnreturnedItemCharger
+    class ChargeFailure < StandardError
+      attr_accessor :new_order
+      def initialize(message, new_order)
+        @new_order = new_order
+        super(message)
+      end
+    end
+
+    class_attribute :failure_handler
+
+    attr_reader :original_order
+
+    def initialize(shipment, return_items)
+      @shipment = shipment
+      @original_order = @shipment.order
+      @return_items = return_items
+    end
+
+    def charge_for_items
+      new_order.associate_user!(@original_order.user) if @original_order.user
+
+      add_exchange_variants_to_order
+
+      new_order.reload.update!
+      while new_order.state != new_order.checkout_steps[-2] && new_order.next; end
+
+      set_order_payment
+
+      # the order builds a shipment on its own on transition to delivery, but we want
+      # the original exchange shipment, not the built one
+      set_shipment_for_new_order
+
+      new_order.contents.approve(name: self.class.name)
+      new_order.reload.complete!
+      Spree::OrderCapturing.new(new_order).capture_payments if (Spree::Config[:auto_capture_exchanges] && !Spree::Config[:auto_capture])
+
+      @return_items.each(&:expired!)
+      create_new_rma if Spree::Config[:create_rma_for_unreturned_exchange]
+
+      if !new_order.completed?
+        raise ChargeFailure.new('order not complete', new_order)
+      elsif !new_order.valid?
+        raise ChargeFailure.new('order not valid', new_order)
+      end
+
+    end
+
+    private
+
+    def new_order
+      @new_order ||= Spree::Order.create!(exchange_order_attributes)
+    end
+
+    def add_exchange_variants_to_order
+      @return_items.group_by(&:exchange_variant).map do |variant, variant_return_items|
+        variant_inventory_units = variant_return_items.map(&:exchange_inventory_unit)
+        line_item = Spree::LineItem.create!(variant: variant, quantity: variant_return_items.count, order: new_order)
+        variant_inventory_units.each { |i| i.update_attributes!(line_item_id: line_item.id, order_id: new_order.id) }
+      end
+    end
+
+    def set_shipment_for_new_order
+      new_order.shipments.destroy_all
+      @shipment.update_attributes!(order_id: new_order.id)
+      new_order.update_attributes!(state: "confirm")
+    end
+
+    def set_order_payment
+      unless new_order.payments.present?
+        card_to_reuse = @original_order.valid_credit_cards.first
+        card_to_reuse = @original_order.user.credit_cards.default.first if !card_to_reuse && @original_order.user
+        Spree::Payment.create!(order: new_order,
+                               payment_method_id: card_to_reuse.try(:payment_method_id),
+                               source: card_to_reuse,
+                               amount: new_order.total)
+      end
+    end
+
+    def create_new_rma
+      @return_items.group_by(&:return_authorization).each do |rma, return_items|
+        new_return_items = return_items.map { |ri| Spree::ReturnItem.create!(inventory_unit: ri.inventory_unit) }
+        Spree::ReturnAuthorization.create!(order: rma.order,
+                                           reason: rma.reason,
+                                           stock_location: rma.stock_location,
+                                           return_items: new_return_items)
+      end
+    end
+
+    def exchange_order_attributes
+      order_attributes = {
+        bill_address: @original_order.bill_address,
+        ship_address: @original_order.ship_address,
+        email: @original_order.email,
+        frontend_viewable: false
+      }
+      order_attributes[:store_id] = @original_order.store_id if @original_order.respond_to?(:store_id)
+      order_attributes
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+class EmailValidator < ActiveModel::EachValidator
+  def validate_each(record,attribute,value)
+    unless value =~ /\A([^@\.]|[^@\.]([^@\s]*)[^@\.])@([^@\s]+\.)+[^@\s]+\z/
+      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
+    "2.4.6.beta"
+  end
+end

data/lib/spree/i18n.rb

@@ -0,0 +1,37 @@
+require 'i18n'
+require 'active_support/core_ext/array/extract_options'
+require 'spree/i18n/base'
+
+module Spree
+  extend ActionView::Helpers::TranslationHelper
+  extend ActionView::Helpers::TagHelper
+
+  class << self
+    # Add spree namespace and delegate to Rails TranslationHelper for some nice
+    # extra functionality. e.g return reasonable strings for missing translations
+    def translate(*args)
+      @virtual_path = virtual_path
+
+      options = args.extract_options!
+      options[:scope] = [*options[:scope]].unshift(:spree)
+      args << options
+      super(*args)
+    end
+
+    alias_method :t, :translate
+
+    def context
+      Spree::ViewContext.context
+    end
+
+    def virtual_path
+      if context
+        path = context.instance_variable_get("@virtual_path")
+
+        if path
+          path.gsub(/spree/, '')
+        end
+      end
+    end
+  end
+end

data/lib/spree/i18n/base.rb

@@ -0,0 +1,17 @@
+module Spree
+  module ViewContext
+    def self.context=(context)
+      @context = context
+    end
+
+    def self.context
+      @context
+    end
+
+    def view_context
+      super.tap do |context|
+        Spree::ViewContext.context = context
+      end
+    end
+  end
+end

data/lib/spree/i18n/initializer.rb

@@ -0,0 +1 @@
+Spree::BaseController.send(:include, Spree::ViewContext)

data/lib/spree/localized_number.rb

@@ -0,0 +1,24 @@
+module Spree
+  class LocalizedNumber
+    # Given a string, strips all non-price-like characters from it,
+    # taking into account locale settings. Returns the input given anything
+    # else.
+    #
+    # @param number [String, anything] the number to be parsed or anything else
+    # @return [BigDecimal, anything] the number parsed from the string passed
+    #   in, or whatever you passed in
+    def self.parse(number)
+      return number unless number.is_a?(String)
+
+      separator, delimiter = I18n.t([:'number.currency.format.separator', :'number.currency.format.delimiter'])
+      non_number_characters = /[^0-9\-#{separator}]/
+
+      # strip everything else first
+      number.gsub!(non_number_characters, '')
+      # then replace the locale-specific decimal separator with the standard separator if necessary
+      number.gsub!(separator, '.') unless separator == '.'
+
+      number.to_d
+    end
+  end
+end

data/lib/spree/migrations.rb

@@ -0,0 +1,76 @@
+module Spree
+  class Migrations
+    attr_reader :config, :engine_name
+
+    # Takes the engine config block and engine name
+    def initialize(config, engine_name)
+      @config, @engine_name = config, engine_name
+    end
+
+    # Puts warning when any engine migration is not present on the Rails app
+    # db/migrate dir
+    #
+    # First split:
+    #
+    #   ["20131128203548", "update_name_fields_on_spree_credit_cards.spree.rb"]
+    #
+    # Second split should give the engine_name of the migration
+    #
+    #   ["update_name_fields_on_spree_credit_cards", "spree.rb"]
+    #
+    # Shouldn't run on test mode because migrations inside engine don't have
+    # engine name on the file name
+    def check
+      if File.directory?(app_dir)
+        engine_in_app = app_migrations.map do |file_name|
+          name, engine = file_name.split(".", 2)
+          next unless match_engine?(engine)
+          name
+        end.compact
+
+        missing_migrations = engine_migrations.sort - engine_in_app.sort
+        unless missing_migrations.empty?
+          puts "[#{engine_name.capitalize} WARNING] Missing migrations."
+          missing_migrations.each do |migration|
+            puts "[#{engine_name.capitalize} WARNING] #{migration} from #{engine_name} is missing."
+          end
+          puts "[#{engine_name.capitalize} WARNING] Run `bundle exec rake railties:install:migrations` to get them.\n\n"
+          true
+        end
+      end
+    end
+
+    private
+      def engine_migrations
+        Dir.entries(engine_dir).map do |file_name|
+          name = file_name.split("_", 2).last.split(".", 2).first
+          name.empty? ? next : name
+        end.compact! || []
+      end
+
+      def app_migrations
+        Dir.entries(app_dir).map do |file_name|
+          next if [".", ".."].include? file_name
+          name = file_name.split("_", 2).last
+          name.empty? ? next : name
+        end.compact! || []
+      end
+
+      def app_dir
+        "#{Rails.root}/db/migrate"
+      end
+
+      def engine_dir
+        "#{config.root}/db/migrate"
+      end
+
+      def match_engine?(engine)
+        if engine_name == "spree"
+          # Avoid stores upgrading from 1.3 getting wrong warnings
+          ["spree.rb", "spree_promo.rb"].include? engine
+        else
+          engine == "#{engine_name}.rb"
+        end
+      end
+  end
+end

data/lib/spree/money.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+require 'money'
+
+module Spree
+  # Spree::Money is a relatively thin wrapper around Monetize which handles
+  # formatting via Spree::Config.
+  class Money
+    class <<self
+      attr_accessor :default_formatting_rules
+    end
+    self.default_formatting_rules = {
+      # Ruby money currently has this as false, which is wrong for the vast
+      # majority of locales.
+      sign_before_symbol: true
+    }
+
+    attr_reader :money
+
+    delegate :cents, to: :money
+
+    # @param amount [#to_s] the value of the money object
+    # @param options [Hash] the options for creating the money object
+    # @option options [String] currency the currency for the money object
+    # @option options [Boolean] with_currency when true, show the currency
+    # @option options [Boolean] no_cents when true, round to the closest dollar
+    # @option options [String] decimal_mark the mark for delimiting the
+    #   decimals
+    # @option options [String, false, nil] thousands_separator the character to
+    #   delimit powers of 1000, if one is desired, otherwise false or nil
+    # @option options [Boolean] sign_before_symbol when true the sign of the
+    #   value comes before the currency symbol
+    # @option options [:before, :after] symbol_position the position of the
+    #   currency symbol
+    def initialize(amount, options={})
+      @money = Monetize.parse([amount, (options[:currency] || Spree::Config[:currency])].join)
+      @options = Spree::Money.default_formatting_rules.merge(options)
+    end
+
+    # @return [String] the value of this money object formatted according to
+    #   its options
+    def to_s
+      @money.format(@options)
+    end
+
+    # @note If you pass in options, ensure you pass in the html: true as well.
+    # @param options [Hash] additional formatting options
+    # @return [String] the value of this money object formatted according to
+    #   its options and any additional options, by default as html.
+    def to_html(options = { html: true })
+      output = @money.format(@options.merge(options))
+      if options[:html]
+        # 1) prevent blank, breaking spaces
+        # 2) prevent escaping of HTML character entities
+        output = output.sub(" ", "&nbsp;").html_safe
+      end
+      output
+    end
+
+    # (see #to_s)
+    def as_json(*)
+      to_s
+    end
+
+    # Delegates comparison to the internal ruby money instance.
+    #
+    # @see http://www.rubydoc.info/gems/money/Money/Arithmetic#%3D%3D-instance_method
+    def ==(obj)
+      @money == obj.money
+    end
+  end
+end

data/lib/spree/permitted_attributes.rb

@@ -0,0 +1,114 @@
+module Spree
+  # Spree::PermittedAttributes contains the attributes permitted through strong
+  # params in various controllers in the frontend. Extensions and stores that
+  # need additional params to be accepted can mutate these arrays to add them.
+  module PermittedAttributes
+    ATTRIBUTES = [
+      :address_attributes,
+      :checkout_attributes,
+      :customer_return_attributes,
+      :image_attributes,
+      :inventory_unit_attributes,
+      :line_item_attributes,
+      :option_type_attributes,
+      :option_value_attributes,
+      :payment_attributes,
+      :product_attributes,
+      :product_properties_attributes,
+      :property_attributes,
+      :return_authorization_attributes,
+      :shipment_attributes,
+      :source_attributes,
+      :stock_item_attributes,
+      :stock_location_attributes,
+      :stock_movement_attributes,
+      :store_attributes,
+      :taxon_attributes,
+      :taxonomy_attributes,
+      :transfer_item_attributes,
+      :user_attributes,
+      :variant_attributes
+    ]
+
+    mattr_reader *ATTRIBUTES
+
+    @@address_attributes = [
+      :id, :firstname, :lastname, :first_name, :last_name,
+      :address1, :address2, :city, :country_id, :state_id,
+      :zipcode, :phone, :state_name, :alternative_phone, :company,
+      country: [:iso, :name, :iso3, :iso_name],
+      state: [:name, :abbr]
+    ]
+
+    @@checkout_attributes = [
+      :coupon_code, :email, :shipping_method_id, :special_instructions, :use_billing
+    ]
+
+    @@customer_return_attributes = [:stock_location_id, return_items_attributes: [:id, :inventory_unit_id, :return_authorization_id, :returned, :pre_tax_amount, :reception_status_event, :acceptance_status, :exchange_variant_id, :resellable]]
+
+    @@image_attributes = [:alt, :attachment, :position, :viewable_type, :viewable_id]
+
+    @@inventory_unit_attributes = [:shipment, :variant_id]
+
+    @@line_item_attributes = [:id, :variant_id, :quantity]
+
+    @@option_type_attributes = [:name, :presentation, :option_values_attributes]
+
+    @@option_value_attributes = [:name, :presentation]
+
+    @@payment_attributes = [:amount, :payment_method_id, :payment_method]
+
+    @@product_properties_attributes = [:property_name, :value, :position]
+
+    @@product_attributes = [
+      :name, :description, :available_on, :permalink, :meta_description,
+      :meta_keywords, :price, :sku, :deleted_at, :prototype_id,
+      :option_values_hash, :weight, :height, :width, :depth,
+      :shipping_category_id, :tax_category_id,
+      :taxon_ids, :option_type_ids, :cost_currency, :cost_price]
+
+    @@property_attributes = [:name, :presentation]
+
+    @@return_authorization_attributes = [:memo, :stock_location_id, :return_authorization_reason_id, return_items_attributes: [:inventory_unit_id, :exchange_variant_id]]
+
+    @@shipment_attributes = [
+      :order, :special_instructions, :stock_location_id, :id,
+      :tracking, :address, :inventory_units, :selected_shipping_rate_id]
+
+    # month / year may be provided by some sources, or others may elect to use one field
+    @@source_attributes = [
+      :number, :month, :year, :expiry, :verification_value,
+      :first_name, :last_name, :cc_type, :gateway_customer_profile_id,
+      :gateway_payment_profile_id, :last_digits, :name, :encrypted_data]
+
+    @@stock_item_attributes = [:variant, :stock_location, :backorderable, :variant_id]
+
+    @@stock_location_attributes = [
+      :name, :active, :address1, :address2, :city, :zipcode,
+      :backorderable_default, :state_name, :state_id, :country_id, :phone,
+      :propagate_all_variants]
+
+    @@stock_movement_attributes = [
+      :quantity, :stock_item, :stock_item_id, :originator, :action]
+
+    @@store_attributes = [:name, :url, :seo_title, :meta_keywords,
+                         :meta_description, :default_currency, :mail_from_address]
+
+    @@taxonomy_attributes = [:name]
+
+    @@taxon_attributes = [
+      :name, :parent_id, :position, :icon, :description, :permalink, :taxonomy_id,
+      :meta_description, :meta_keywords, :meta_title, :child_index]
+
+    @@transfer_item_attributes = [:variant_id, :expected_quantity, :received_quantity]
+
+    # TODO Should probably use something like Spree.user_class.attributes
+    @@user_attributes = [:email, :password, :password_confirmation]
+
+    @@variant_attributes = [
+      :name, :presentation, :cost_price, :lock_version,
+      :position, :option_value_ids, :track_inventory,
+      :product_id, :product, :option_values_attributes, :price,
+      :weight, :height, :width, :depth, :sku, :cost_currency, options: [ :name, :value ]]
+  end
+end