goca-spree-core 3.1.14.rails.5.0

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/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/localized_number.rb

@@ -0,0 +1,22 @@
+module Spree
+  class LocalizedNumber
+
+    # Strips all non-price-like characters from the number, taking into account locale settings.
+    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}]/
+
+      # work on a copy, prevent original argument modification
+      number = number.dup
+      # strip everything else first, including thousands delimiter
+      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,77 @@
+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,61 @@
+# encoding: utf-8
+
+require 'money'
+
+module Spree
+  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, :currency, to: :money
+
+    def initialize(amount, options={})
+      @money = Monetize.parse([amount, (options[:currency] || Spree::Config[:currency])].join)
+      @options = Spree::Money.default_formatting_rules.merge(options)
+    end
+
+    def amount_in_cents
+      (cents / currency.subunit_to_unit.to_f * 100).round
+    end
+
+    def to_s
+      @money.format(@options)
+    end
+
+    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
+
+    def as_json(*)
+      to_s
+    end
+
+    def decimal_mark
+      return @money.decimal_mark if @options[:decimal_mark].nil?
+      @options[:decimal_mark]
+    end
+
+    def thousands_separator
+      return @money.thousands_separator if @options[:thousands_separator].nil?
+      @options[:thousands_separator]
+    end
+
+    def ==(obj)
+      @money == obj.money
+    end
+  end
+end

data/lib/spree/permitted_attributes.rb

@@ -0,0 +1,115 @@
+module Spree
+  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,
+      :store_credit_attributes,
+      :taxon_attributes,
+      :taxonomy_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, :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, :discontinue_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,
+      :cost_currency, :cost_price,
+      option_type_ids: [], taxon_ids: []
+    ]
+
+    @@property_attributes = [:name, :presentation]
+
+    @@return_authorization_attributes = [:amount, :memo, :stock_location_id, :inventory_units_attributes, :return_authorization_reason_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]
+
+    @@store_credit_attributes = [:amount, :category_id, :memo]
+
+    @@taxonomy_attributes = [:name]
+
+    @@taxon_attributes = [
+      :name, :parent_id, :position, :icon, :description, :permalink, :taxonomy_id,
+      :meta_description, :meta_keywords, :meta_title, :child_index]
+
+    # TODO Should probably use something like Spree.user_class.attributes
+    @@user_attributes = [:email, :password, :password_confirmation]
+
+    @@variant_attributes = [
+      :name, :presentation, :cost_price, :discontinue_on, :lock_version,
+      :position, :track_inventory,
+      :product_id, :product, :option_values_attributes, :price,
+      :weight, :height, :width, :depth, :sku, :cost_currency,
+      options: [:name, :value], option_value_ids: []
+    ]
+  end
+end

data/lib/spree/promo/environment.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Promo
+    class Environment
+      include Core::EnvironmentExtension
+
+      attr_accessor :rules, :actions
+    end
+  end
+end

data/lib/spree/responder.rb

@@ -0,0 +1,45 @@
+module Spree
+  class Responder < ::ActionController::Responder #:nodoc:
+
+    attr_accessor :on_success, :on_failure
+
+    def initialize(controller, resources, options={})
+      super
+
+      class_name = controller.class.name.to_sym
+      action_name = options.delete(:action_name)
+
+      if result = Spree::BaseController.spree_responders[class_name].try(:[], action_name).try(:[], self.format.to_sym)
+        self.on_success = handler(controller, result, :success)
+        self.on_failure = handler(controller, result, :failure)
+      end
+    end
+
+    def to_html
+      super and return if !(on_success || on_failure)
+      has_errors? ? controller.instance_exec(&on_failure) : controller.instance_exec(&on_success)
+    end
+
+    def to_format
+      super and return if !(on_success || on_failure)
+      has_errors? ? controller.instance_exec(&on_failure) : controller.instance_exec(&on_success)
+    end
+
+    private
+
+    def handler(controller, result, status)
+      return result if result.respond_to? :call
+
+      case result
+      when Hash
+        if result[status].is_a? Symbol
+          controller.method(result[status])
+        else
+          result[status]
+        end
+      when Symbol
+        controller.method(result)
+      end
+    end
+  end
+end

data/lib/spree/testing_support/ability_helpers.rb

@@ -0,0 +1,105 @@
+shared_examples_for 'access granted' do
+  it 'should allow read' do
+    expect(ability).to be_able_to(:read, resource, token) if token
+    expect(ability).to be_able_to(:read, resource) unless token
+  end
+
+  it 'should allow create' do
+    expect(ability).to be_able_to(:create, resource, token) if token
+    expect(ability).to be_able_to(:create, resource) unless token
+  end
+
+  it 'should allow update' do
+    expect(ability).to be_able_to(:update, resource, token) if token
+    expect(ability).to be_able_to(:update, resource) unless token
+  end
+end
+
+shared_examples_for 'access denied' do
+  it 'should not allow read' do
+    expect(ability).to_not be_able_to(:read, resource)
+  end
+
+  it 'should not allow create' do
+    expect(ability).to_not be_able_to(:create, resource)
+  end
+
+  it 'should not allow update' do
+    expect(ability).to_not be_able_to(:update, resource)
+  end
+end
+
+shared_examples_for 'admin granted' do
+  it 'should allow admin' do
+    expect(ability).to be_able_to(:admin, resource, token) if token
+    expect(ability).to be_able_to(:admin, resource) unless token
+  end
+end
+
+shared_examples_for 'admin denied' do
+  it 'should not allow admin' do
+    expect(ability).to_not be_able_to(:admin, resource)
+  end
+end
+
+shared_examples_for 'index allowed' do
+  it 'should allow index' do
+    expect(ability).to be_able_to(:index, resource)
+  end
+end
+
+shared_examples_for 'no index allowed' do
+  it 'should not allow index' do
+    expect(ability).to_not be_able_to(:index, resource)
+  end
+end
+
+shared_examples_for 'create only' do
+  it 'should allow create' do
+    expect(ability).to be_able_to(:create, resource)
+  end
+
+  it 'should not allow read' do
+    expect(ability).to_not be_able_to(:read, resource)
+  end
+
+  it 'should not allow update' do
+    expect(ability).to_not be_able_to(:update, resource)
+  end
+
+  it 'should not allow index' do
+    expect(ability).to_not be_able_to(:index, resource)
+  end
+end
+
+shared_examples_for 'read only' do
+  it 'should not allow create' do
+    expect(ability).to_not be_able_to(:create, resource)
+  end
+
+  it 'should not allow update' do
+    expect(ability).to_not be_able_to(:update, resource)
+  end
+
+  it 'should allow index' do
+    expect(ability).to be_able_to(:index, resource)
+  end
+end
+
+shared_examples_for 'update only' do
+  it 'should not allow create' do
+    expect(ability).to_not be_able_to(:create, resource)
+  end
+
+  it 'should not allow read' do
+    expect(ability).to_not be_able_to(:read, resource)
+  end
+
+  it 'should allow update' do
+    expect(ability).to be_able_to(:update, resource)
+  end
+
+  it 'should not allow index' do
+    expect(ability).to_not be_able_to(:index, resource)
+  end
+end

data/lib/spree/testing_support/authorization_helpers.rb

@@ -0,0 +1,63 @@
+module Spree
+  module TestingSupport
+    module AuthorizationHelpers
+      module CustomAbility
+        def build_ability(&block)
+          block ||= proc{ |u| can :manage, :all }
+          Class.new do
+            include CanCan::Ability
+            define_method(:initialize, block)
+          end
+        end
+      end
+
+      module Controller
+        include CustomAbility
+
+        def stub_authorization!(&block)
+          ability_class = build_ability(&block)
+          before do
+            allow(controller).to receive(:current_ability).and_return(ability_class.new(nil))
+          end
+        end
+      end
+
+      module Request
+        include CustomAbility
+
+        def stub_authorization!
+          ability = build_ability
+
+          after(:all) do
+            Spree::Ability.remove_ability(ability)
+          end
+
+          before(:all) do
+            Spree::Ability.register_ability(ability)
+          end
+
+          before do
+            allow(Spree.user_class).to receive(:find_by).
+                                         with(hash_including(:spree_api_key)).
+                                         and_return(Spree.user_class.new)
+          end
+        end
+
+        def custom_authorization!(&block)
+          ability = build_ability(&block)
+          after(:all) do
+            Spree::Ability.remove_ability(ability)
+          end
+          before(:all) do
+            Spree::Ability.register_ability(ability)
+          end
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.extend Spree::TestingSupport::AuthorizationHelpers::Controller, type: :controller
+  config.extend Spree::TestingSupport::AuthorizationHelpers::Request, type: :feature
+end

data/lib/spree/testing_support/bar_ability.rb

@@ -0,0 +1,14 @@
+# Fake ability for testing administration
+class BarAbility
+  include CanCan::Ability
+
+  def initialize(user)
+    user ||= Spree::User.new
+    if user.has_spree_role? 'bar'
+      # allow dispatch to :admin, :index, and :show on Spree::Order
+      can [:admin, :index, :show], Spree::Order
+      # allow dispatch to :index, :show, :create and :update shipments on the admin
+      can [:admin, :manage], Spree::Shipment
+    end
+  end
+end

data/lib/spree/testing_support/caching.rb

@@ -0,0 +1,47 @@
+module Spree
+  module TestingSupport
+    module Caching
+      def cache_writes
+        @cache_write_events
+      end
+
+      def assert_written_to_cache(key)
+        unless @cache_write_events.detect { |event| event[:key].starts_with?(key) }
+          fail %Q{Expected to find #{key} in the cache, but didn't.
+
+  Cache writes:
+  #{@cache_write_events.join("\n")}
+          }
+        end
+      end
+
+      def clear_cache_events
+        @cache_read_events = []
+        @cache_write_events = []
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Spree::TestingSupport::Caching, :caching => true
+
+  config.before(:each, :caching => true) do
+    ActionController::Base.perform_caching = true
+
+    ActiveSupport::Notifications.subscribe("read_fragment.action_controller") do |event, start_time, finish_time, _, details|
+      @cache_read_events ||= []
+      @cache_read_events << details 
+    end
+
+    ActiveSupport::Notifications.subscribe("write_fragment.action_controller") do |event, start_time, finish_time, _, details|
+      @cache_write_events ||= []
+      @cache_write_events << details
+    end
+  end
+
+  config.after(:each, :caching => true) do
+    ActionController::Base.perform_caching = false
+    Rails.cache.clear
+  end
+end