spree_core 1.3.5 → 2.0.0.rc1

data/lib/spree/core/calculated_adjustments.rb

@@ -1,54 +1,62 @@
 module Spree
   module Core
     module CalculatedAdjustments
-      module ClassMethods
-        def calculated_adjustments
-          has_one   :calculator, :class_name => "Spree::Calculator", :as => :calculable, :dependent => :destroy
+      def self.included(klass)
+        klass.class_eval do
+          has_one   :calculator, :as => :calculable, :dependent => :destroy
           accepts_nested_attributes_for :calculator
           attr_accessible :calculator_type, :calculator_attributes
           validates :calculator, :presence => true
 
           def self.calculators
-            Rails.application.config.spree.calculators.send(self.to_s.tableize.gsub('/', '_').sub('spree_', ''))
+            spree_calculators.send model_name_without_spree_namespace
           end
-        end
-      end
 
-      def calculator_type
-        calculator.class.to_s if calculator
-      end
+          def calculator_type
+            calculator.class.to_s if calculator
+          end
 
-      def calculator_type=(calculator_type)
-        clazz = calculator_type.constantize if calculator_type
-        self.calculator = clazz.new if clazz and not self.calculator.is_a? clazz
-      end
+          def calculator_type=(calculator_type)
+            klass = calculator_type.constantize if calculator_type
+            self.calculator = klass.new if klass && !self.calculator.is_a?(klass)
+          end
 
-      # Creates a new adjustment for the target object (which is any class that has_many :adjustments) and
-      # sets amount based on the calculator as applied to the calculable argument (Order, LineItems[], Shipment, etc.)
-      # By default the adjustment will not be considered mandatory
-      def create_adjustment(label, target, calculable, mandatory=false)
-        amount = compute_amount(calculable)
-        return if amount == 0 && !mandatory
-        target.adjustments.create({ :amount => amount,
-                                    :source => calculable,
-                                    :originator => self,
-                                    :label => label,
-                                    :mandatory => mandatory}, :without_protection => true)
-      end
+          # Creates a new adjustment for the target object (which is any class that has_many :adjustments) and
+          # sets amount based on the calculator as applied to the calculable argument (Order, LineItems[], Shipment, etc.)
+          # By default the adjustment will not be considered mandatory
+          def create_adjustment(label, target, calculable, mandatory=false, state="closed")
+            amount = compute_amount(calculable)
+            return if amount == 0 && !mandatory
+            target.adjustments.create({ :amount => amount,
+                                        :source => calculable,
+                                        :originator => self,
+                                        :label => label,
+                                        :mandatory => mandatory,
+                                        :state => state }, :without_protection => true)
+          end
 
-      # Updates the amount of the adjustment using our Calculator and calling the +compute+ method with the +calculable+
-      # referenced passed to the method.
-      def update_adjustment(adjustment, calculable)
-        adjustment.update_attribute_without_callbacks(:amount, compute_amount(calculable))
-      end
+          # Updates the amount of the adjustment using our Calculator and calling the +compute+ method with the +calculable+
+          # referenced passed to the method.
+          def update_adjustment(adjustment, calculable)
+            adjustment.update_attribute_without_callbacks(:amount, compute_amount(calculable))
+          end
 
-      # Calculate the amount to be used when creating an adjustment
-      def compute_amount(calculable)
-        self.calculator.compute(calculable)
-      end
+          # Calculate the amount to be used when creating an adjustment
+          # NOTE: May be overriden by classes where this module is included into.
+          # Such as Spree::Promotion::Action::CreateAdjustment.
+          def compute_amount(calculable)
+            self.calculator.compute(calculable)
+          end
 
-      def self.included(receiver)
-        receiver.extend ClassMethods
+          private
+          def self.model_name_without_spree_namespace
+            self.to_s.tableize.gsub('/', '_').sub('spree_', '')
+          end
+
+          def self.spree_calculators
+            Rails.application.config.spree.calculators
+          end
+        end
       end
     end
   end

data/lib/spree/core/controller_helpers/auth.rb

@@ -2,15 +2,14 @@ module Spree
   module Core
     module ControllerHelpers
       module Auth
-        def self.included(base)
-          base.class_eval do
-            include SslRequirement
+        extend ActiveSupport::Concern
 
-            helper_method :try_spree_current_user
+        included do
+          before_filter :ensure_api_key
+          helper_method :try_spree_current_user
 
-            rescue_from CanCan::AccessDenied do |exception|
-              return unauthorized
-            end
+          rescue_from CanCan::AccessDenied do |exception|
+            return unauthorized
           end
         end
 
@@ -24,11 +23,11 @@ module Spree
         # to access the requested action.  For example, a popup window might simply close itself.
         def unauthorized
           if try_spree_current_user
-            flash[:error] = t(:authorization_failure)
+            flash[:error] = Spree.t(:authorization_failure)
             redirect_to '/unauthorized'
           else
             store_location
-            url = respond_to?(:spree_login_path) ? spree_login_path : root_path
+            url = spree.respond_to?(:login_path) ? spree.login_path : spree.root_path
             redirect_to url
           end
         end
@@ -59,6 +58,16 @@ module Spree
           redirect_to(session["spree_user_return_to"] || default)
           session["spree_user_return_to"] = nil
         end
+
+        # Need to generate an API key for a user due to some actions potentially
+        # requiring authentication to the Spree API
+        def ensure_api_key
+          if user = try_spree_current_user
+            if user.respond_to?(:spree_api_key) && user.spree_api_key.blank?
+              user.generate_spree_api_key!
+            end
+          end
+        end
       end
     end
   end

data/lib/spree/core/controller_helpers/common.rb

@@ -2,82 +2,83 @@ module Spree
   module Core
     module ControllerHelpers
       module Common
-        def self.included(base)
-          base.class_eval do
-            helper_method :title
-            helper_method :title=
-            helper_method :accurate_title
+        extend ActiveSupport::Concern
+        included do
+          helper_method :title
+          helper_method :title=
+          helper_method :accurate_title
 
-            layout :get_layout
+          layout :get_layout
 
-            before_filter :set_user_language
-          end
-        end
+          before_filter :set_user_language
 
-        protected
+          protected
 
-        # Convenience method for firing instrumentation events with the default payload hash
-        def fire_event(name, extra_payload = {})
-          ActiveSupport::Notifications.instrument(name, default_notification_payload.merge(extra_payload))
-        end
+          # Convenience method for firing instrumentation events with the default payload hash
+          def fire_event(name, extra_payload = {})
+            ActiveSupport::Notifications.instrument(name, default_notification_payload.merge(extra_payload))
+          end
 
-        # Creates the hash that is sent as the payload for all notifications. Specific notifications will
-        # add additional keys as appropriate. Override this method if you need additional data when
-        # responding to a notification
-        def default_notification_payload
-          {:user => try_spree_current_user, :order => current_order}
-        end
+          # Creates the hash that is sent as the payload for all notifications. Specific notifications will
+          # add additional keys as appropriate. Override this method if you need additional data when
+          # responding to a notification
+          def default_notification_payload
+            {:user => try_spree_current_user, :order => current_order}
+          end
 
-        # can be used in views as well as controllers.
-        # e.g. <% self.title = 'This is a custom title for this view' %>
-        attr_writer :title
+          # can be used in views as well as controllers.
+          # e.g. <% self.title = 'This is a custom title for this view' %>
+          attr_writer :title
 
-        def title
-          title_string = @title.present? ? @title : accurate_title
-          if title_string.present?
-            if Spree::Config[:always_put_site_name_in_title]
-              [title_string, default_title].join(' - ')
+          def title
+            title_string = @title.present? ? @title : accurate_title
+            if title_string.present?
+              if Spree::Config[:always_put_site_name_in_title]
+                [title_string, default_title].join(' - ')
+              else
+                title_string
+              end
             else
-              title_string
+              default_title
             end
-          else
-            default_title
           end
-        end
 
-        def default_title
-          Spree::Config[:site_name]
-        end
+          def default_title
+            Spree::Config[:site_name]
+          end
 
-        # this is a hook for subclasses to provide title
-        def accurate_title
-          Spree::Config[:default_seo_title]
-        end
+          # this is a hook for subclasses to provide title
+          def accurate_title
+            Spree::Config[:default_seo_title]
+          end
 
-        def render_404(exception = nil)
-          respond_to do |type|
-            type.html { render :status => :not_found, :file    => "#{::Rails.root}/public/404", :formats => [:html], :layout => nil}
-            type.all  { render :status => :not_found, :nothing => true }
+          def render_404(exception = nil)
+            respond_to do |type|
+              type.html { render :status => :not_found, :file    => "#{::Rails.root}/public/404", :formats => [:html], :layout => nil}
+              type.all  { render :status => :not_found, :nothing => true }
+            end
           end
-        end
 
-        private
+          private
 
-        def set_user_language
-          locale = session[:locale]
-          locale ||= Rails.application.config.i18n.default_locale
-          locale ||= I18n.default_locale unless I18n.available_locales.map(&:to_s).include?(locale)
-          I18n.locale = locale
-        end
+          def set_user_language
+            locale = session[:locale]
+            locale ||= config_locale if respond_to?(:config_locale, true)
+            locale ||= Rails.application.config.i18n.default_locale
+            locale ||= I18n.default_locale unless I18n.available_locales.map(&:to_s).include?(locale)
+            I18n.locale = locale
+          end
+
+          # Returns which layout to render.
+          # 
+          # You can set the layout you want to render inside your Spree configuration with the +:layout+ option.
+          # 
+          # Default layout is: +app/views/spree/layouts/spree_application+
+          # 
+          def get_layout
+            layout ||= Spree::Config[:layout]
+          end
 
-        # Returns which layout to render.
-        # 
-        # You can set the layout you want to render inside your Spree configuration with the +:layout+ option.
-        # 
-        # Default layout is: +app/views/spree/layouts/spree_application+
-        # 
-        def get_layout
-          layout ||= Spree::Config[:layout]
         end
       end
     end

data/lib/spree/core/controller_helpers/ssl.rb

@@ -0,0 +1,69 @@
+module Spree
+  module Core
+    module ControllerHelpers
+      module SSL
+        extend ActiveSupport::Concern
+
+        included do
+          before_filter :force_non_ssl_redirect, :if => Proc.new { Spree::Config[:redirect_https_to_http] }
+          before_filter :force_ssl_redirect, :if => Proc.new { Rails.application.config.force_ssl }
+
+          def self.ssl_allowed(*actions)
+            class_attribute :ssl_allowed_actions
+            self.ssl_allowed_actions = actions
+          end
+
+          def self.ssl_required(*actions)
+            class_attribute :ssl_required_actions
+            self.ssl_required_actions = actions
+            if ssl_supported?
+              if ssl_required_actions.empty? or Rails.application.config.force_ssl
+                force_ssl
+              else
+                force_ssl :only => ssl_required_actions
+              end
+            end
+          end
+
+          def self.ssl_supported?
+            return Spree::Config[:allow_ssl_in_production] if Rails.env.production?
+            return Spree::Config[:allow_ssl_in_staging] if Rails.env.staging?
+            return Spree::Config[:allow_ssl_in_development_and_test] if (Rails.env.development? or Rails.env.test?)
+          end
+
+          private
+
+            # Redirect the existing request to use the HTTP protocol.
+            #
+            # ==== Parameters
+            # * <tt>host</tt> - Redirect to a different host name
+            def force_non_ssl_redirect(host = nil)
+              return true if defined?(ssl_allowed_actions) and ssl_allowed_actions.include?(action_name.to_sym)
+              if request.ssl? and (!defined?(ssl_required_actions) or !ssl_required_actions.include?(action_name.to_sym))
+                redirect_options = {:protocol => 'http://', :status => :moved_permanently}
+                redirect_options.merge!(:host => host) if host
+                redirect_options.merge!(:params => request.query_parameters)
+                flash.keep if respond_to?(:flash)
+                redirect_to redirect_options
+              end
+            end
+
+            # Redirect the existing request to use the HTTPS protocol.
+            #
+            # ==== Parameters
+            # * <tt>host</tt> - Redirect to a different host name
+            def force_ssl_redirect(host = nil)
+              unless request.ssl?
+                redirect_options = {:protocol => 'https://', :status => :moved_permanently}
+                redirect_options.merge!(:host => host) if host
+                redirect_options.merge!(:params => request.query_parameters)
+                flash.keep if respond_to?(:flash)
+                redirect_to redirect_options
+              end
+            end
+
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/controller_helpers.rb

@@ -1,10 +1,11 @@
 module Spree
   module Core
     module ControllerHelpers
-      def self.included(base)
-        base.class_eval do
+      def self.included(klass)
+        klass.class_eval do
           include Spree::Core::ControllerHelpers::Common
           include Spree::Core::ControllerHelpers::Auth
+          include Spree::Core::ControllerHelpers::RespondWith
           include Spree::Core::ControllerHelpers::Order
         end
       end

data/lib/spree/core/delegate_belongs_to.rb

@@ -86,4 +86,4 @@ module DelegateBelongsTo
 
 end
 
-ActiveRecord::Base.send :include, DelegateBelongsTo
+ActiveRecord::Base.send :include, DelegateBelongsTo

data/lib/spree/core/engine.rb

@@ -1,28 +1,12 @@
-require 'rabl'
-
 module Spree
   module Core
     class Engine < ::Rails::Engine
       isolate_namespace Spree
       engine_name 'spree'
 
-      config.middleware.use "Spree::Core::Middleware::SeoAssist"
-      config.middleware.use "Spree::Core::Middleware::RedirectLegacyProductUrl"
-
       config.autoload_paths += %W(#{config.root}/lib)
 
-      def self.activate
-      end
-
-      config.to_prepare &method(:activate).to_proc
-
-
       config.after_initialize do
-        Rabl.configure do |config|
-          config.include_json_root = false
-          config.include_child_root = false
-        end
-
         ActiveSupport::Notifications.subscribe(/^spree\./) do |*args|
           event_name, start_time, end_time, id, payload = args
           Activator.active.event_name_starts_with(event_name).each do |activator|
@@ -33,8 +17,8 @@ module Spree
       end
 
       # We need to reload the routes here due to how Spree sets them up.
-      # The different facets of Spree (auth, promo, etc.) append/prepend routes to Core
-      # *after* Core has been loaded.
+      # The different facets of Spree (backend, frontend, etc.) append/prepend
+      # routes to Core *after* Core has been loaded.
       #
       # So we wait until after initialization is complete to do one final reload.
       # This then makes the appended/prepended routes available to the application.
@@ -42,7 +26,6 @@ module Spree
         Rails.application.routes_reloader.reload!
       end
 
-
       initializer "spree.environment", :before => :load_config_initializers do |app|
         app.config.spree = Spree::Core::Environment.new
         Spree::Config = app.config.spree.preferences #legacy access
@@ -54,16 +37,23 @@ module Spree
 
       initializer "spree.register.calculators" do |app|
         app.config.spree.calculators.shipping_methods = [
-            Spree::Calculator::FlatPercentItemTotal,
-            Spree::Calculator::FlatRate,
-            Spree::Calculator::FlexiRate,
-            Spree::Calculator::PerItem,
-            Spree::Calculator::PriceSack]
+            Spree::Calculator::Shipping::FlatPercentItemTotal,
+            Spree::Calculator::Shipping::FlatRate,
+            Spree::Calculator::Shipping::FlexiRate,
+            Spree::Calculator::Shipping::PerItem,
+            Spree::Calculator::Shipping::PriceSack]
 
          app.config.spree.calculators.tax_rates = [
             Spree::Calculator::DefaultTax]
       end
 
+      initializer "spree.register.stock_splitters" do |app|
+        app.config.spree.stock_splitters = [
+          Spree::Stock::Splitter::ShippingCategory,
+          Spree::Stock::Splitter::Backordered
+        ]
+      end
+
       initializer "spree.register.payment_methods" do |app|
         app.config.spree.payment_methods = [
             Spree::Gateway::Bogus,
@@ -71,6 +61,42 @@ module Spree
             Spree::PaymentMethod::Check ]
       end
 
+      initializer "spree.mail.settings" do |app|
+        Spree::Core::MailSettings.init
+        Mail.register_interceptor(Spree::Core::MailInterceptor)
+      end
+
+      initializer 'spree.promo.environment', :after => 'spree.environment' do |app|
+        app.config.spree.add_class('promotions')
+        app.config.spree.promotions = Spree::Promo::Environment.new
+      end
+
+      initializer 'spree.promo.register.promotion.calculators' do |app|
+        app.config.spree.calculators.add_class('promotion_actions_create_adjustments')
+        app.config.spree.calculators.promotion_actions_create_adjustments = [
+          Spree::Calculator::FlatPercentItemTotal,
+          Spree::Calculator::FlatRate,
+          Spree::Calculator::FlexiRate,
+          Spree::Calculator::PerItem,
+          Spree::Calculator::PercentPerItem,
+          Spree::Calculator::FreeShipping
+        ]
+      end
+
+      initializer 'spree.promo.register.promotions.rules' do |app|
+        app.config.spree.promotions.rules = [
+          Spree::Promotion::Rules::ItemTotal,
+          Spree::Promotion::Rules::Product,
+          Spree::Promotion::Rules::User,
+          Spree::Promotion::Rules::FirstOrder,
+          Spree::Promotion::Rules::UserLoggedIn]
+      end
+
+      initializer 'spree.promo.register.promotions.actions' do |app|
+        app.config.spree.promotions.actions = [Spree::Promotion::Actions::CreateAdjustment,
+          Spree::Promotion::Actions::CreateLineItems]
+      end
+
       # filter sensitive information during logging
       initializer "spree.params.filter" do |app|
         app.config.filter_parameters += [
@@ -79,27 +105,6 @@ module Spree
           :number,
           :verification_value]
       end
-
-      # sets the manifests / assets to be precompiled, even when initialize_on_precompile is false
-      initializer "spree.assets.precompile", :group => :all do |app|
-        app.config.assets.precompile += %w[
-          store/all.*
-          admin/all.*
-          admin/orders/edit_form.js
-          admin/address_states.js
-          admin/states.js
-          jqPlot/excanvas.min.js
-          admin/images/new.js
-          jquery.jstree/themes/apple/*
-        ]
-      end
-
-      initializer "spree.mail.settings" do |app|
-        if Spree::MailMethod.table_exists?
-          Spree::Core::MailSettings.init
-          Mail.register_interceptor(Spree::Core::MailInterceptor)
-        end
-      end
     end
   end
 end

data/lib/spree/core/environment.rb

@@ -3,7 +3,8 @@ module Spree
     class Environment
       include EnvironmentExtension
 
-      attr_accessor :calculators, :payment_methods, :preferences
+      attr_accessor :calculators, :payment_methods, :preferences,
+                    :stock_splitters
 
       def initialize
         @calculators = Calculators.new

data/lib/spree/core/mail_interceptor.rb

@@ -1,21 +1,20 @@
 # Allows us to intercept any outbound mail message and make last minute changes
-# (such as specifying a "from" address or # sending to a test email account.)
+# (such as specifying a "from" address or sending to a test email account)
 #
 # See http://railscasts.com/episodes/206-action-mailer-in-rails-3 for more details.
 module Spree
   module Core
     class MailInterceptor
       def self.delivering_email(message)
-        return unless Spree::Config.override_actionmailer_config
-        return unless mail_method = Spree::MailMethod.current
+        return unless MailSettings.override?
 
-        if mail_method.preferred_intercept_email.present?
+        if Config[:intercept_email].present?
           message.subject = "#{message.to} #{message.subject}"
-          message.to = mail_method.preferred_intercept_email
+          message.to = Config[:intercept_email]
         end
 
-        if mail_method.preferred_mail_bcc.present?
-          message.bcc ||= mail_method.preferred_mail_bcc
+        if Config[:mail_bcc].present?
+          message.bcc ||= Config[:mail_bcc]
         end
       end
     end

data/lib/spree/core/mail_settings.rb

@@ -1,17 +1,23 @@
 module Spree
   module Core
     class MailSettings
+      MAIL_AUTH = ['None', 'plain', 'login', 'cram_md5']
+      SECURE_CONNECTION_TYPES = ['None','SSL','TLS']
+
       # Override the Rails application mail settings based on preferences
       # This makes it possible to configure the mail settings through an admin
       # interface instead of requiring changes to the Rails envrionment file
       def self.init
-        instance = new
-        instance.override! if instance.override?
+        self.new.override! if override?
+      end
+
+      def self.override?
+        Config.override_actionmailer_config
       end
 
       def override!
-        if mail_method.prefers_enable_mail_delivery?
-          ActionMailer::Base.default_url_options[:host] ||= Spree::Config[:site_url]
+        if Config.enable_mail_delivery
+          ActionMailer::Base.default_url_options[:host] ||= Config.site_url
           ActionMailer::Base.smtp_settings = mail_server_settings
           ActionMailer::Base.perform_deliveries = true
         else
@@ -19,10 +25,6 @@ module Spree
         end
       end
 
-      def override?
-        override_actionmailer_config? && mail_method
-      end
-
       private
         def mail_server_settings
           settings = if need_authentication?
@@ -35,31 +37,23 @@ module Spree
         end
 
         def user_credentials
-          { :user_name => mail_method.preferred_smtp_username,
-            :password => mail_method.preferred_smtp_password }
+          { :user_name => Config.smtp_username,
+            :password => Config.smtp_password }
         end
 
         def basic_settings
-          { :address => mail_method.preferred_mail_host,
-            :domain => mail_method.preferred_mail_domain,
-            :port => mail_method.preferred_mail_port,
-            :authentication => mail_method.preferred_mail_auth_type }
+          { :address => Config.mail_host,
+            :domain => Config.mail_domain,
+            :port => Config.mail_port,
+            :authentication => Config.mail_auth_type }
         end
 
         def need_authentication?
-          mail_method.preferred_mail_auth_type != 'none'
+          Config.mail_auth_type != 'None'
         end
 
         def secure_connection?
-          mail_method.preferred_secure_connection_type == 'TLS'
-        end
-
-        def mail_method
-          Spree::MailMethod.current
-        end
-
-        def override_actionmailer_config?
-          Spree::Config.override_actionmailer_config
+          Config.secure_connection_type == 'TLS'
         end
     end
   end