spree_core 0.30.0.beta1

data/lib/spree_core/preferences/mail_settings.rb

@@ -0,0 +1,57 @@
+module Spree
+  module Preferences
+    # This class handle mail settings using preferences feature available in spree core.
+    class MailSettings
+
+      class << self
+
+        # When loading from config/initializers/spree.rb the logger
+        # variable is not available yet, so defining it here.
+        def logger
+          Rails.logger
+        end
+
+        def init
+          # Set mail server settings from preferences
+          begin
+            logger.info "INFO: Loading mail preferences"
+
+            if Spree::Config.instance.prefers_enable_mail_delivery?
+              mail_server_settings = {
+                :address => Spree::Config[:mail_host],
+                :domain => Spree::Config[:mail_domain],
+                :port => Spree::Config[:mail_port],
+              }
+
+              if Spree::Config[:mail_auth_type] != 'none'
+                mail_server_settings[:authentication] = Spree::Config[:mail_auth_type]
+                mail_server_settings[:user_name] = Spree::Config[:smtp_username]
+                mail_server_settings[:password] = Spree::Config[:smtp_password]
+              end
+
+              # Enable TLS
+              if Spree::Config[:secure_connection_type] == 'TLS'
+                mail_server_settings[:enable_starttls_auto] = true
+              end
+
+              logger.info "INFO: Setting mails settings to #{mail_server_settings.inspect}"
+              ActionMailer::Base.smtp_settings = mail_server_settings
+              logger.info "INFO: Enabling mail delivery"
+              ActionMailer::Base.perform_deliveries = true
+              return true
+            else
+              logger.warn "NOTICE: Mail not enabled"
+              ActionMailer::Base.perform_deliveries = false
+              return false
+            end
+          rescue
+            logger.error "========================================================================="
+            logger.error "ERROR: Something went wrong while loading mail preferences"
+            logger.error "       Verify you created a default configuration in admin/configurations"
+            logger.error "========================================================================="
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spree_core/preferences/model_hooks.rb

@@ -0,0 +1,293 @@
+# Most of this code is from the preferences plugin available at
+# http://github.com/pluginaweek/preferences/tree/master
+
+module Spree
+  module Preferences
+    # Adds support for defining preferences on ActiveRecord models.
+    #
+    # == Saving preferences
+    #
+    # Preferences are not automatically saved when they are set.  You must save
+    # the record that the preferences were set on.
+    #
+    # For example,
+    #
+    #   class User < ActiveRecord::Base
+    #     preference :notifications
+    #   end
+    #
+    #   u = User.new(:login => 'admin', :prefers_notifications => false)
+    #   u.save!
+    #
+    #   u = User.find_by_login('admin')
+    #   u.attributes = {:prefers_notifications => true}
+    #   u.save!
+    module ModelHooks
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          extend Spree::Preferences::ModelHooks::MacroMethods
+        end
+      end
+
+      module MacroMethods
+        # Defines a new preference for all records in the model.  By default, preferences
+        # are assumed to have a boolean data type, so all values will be typecasted
+        # to true/false based on ActiveRecord rules.
+        #
+        # Configuration options:
+        # * +default+ - The default value for the preference. Default is nil.
+        #
+        # == Examples
+        #
+        # The example below shows the various ways to define a preference for a
+        # particular model.
+        #
+        #   class User < ActiveRecord::Base
+        #     preference :notifications, :default => false
+        #     preference :color, :string, :default => 'red'
+        #     preference :favorite_number, :integer
+        #     preference :data, :any # Allows any data type to be stored
+        #   end
+        #
+        # All preferences are also inherited by subclasses.
+        #
+        # == Associations
+        #
+        # After the first preference is defined, the following associations are
+        # created for the model:
+        # * +stored_preferences+ - A collection of all the custom preferences specified for a record
+        #
+        # == Generated shortcut methods
+        #
+        # In addition to calling <tt>prefers?</tt> and +preferred+ on a record, you
+        # can also use the shortcut methods that are generated when a preference is
+        # defined.  For example,
+        #
+        #   class User < ActiveRecord::Base
+        #     preference :notifications
+        #   end
+        #
+        # ...generates the following methods:
+        # * <tt>prefers_notifications?</tt> - The same as calling <tt>record.prefers?(:notifications)</tt>
+        # * <tt>prefers_notifications=(value)</tt> - The same as calling <tt>record.set_preference(:notifications, value)</tt>
+        # * <tt>preferred_notifications</tt> - The same as called <tt>record.preferred(:notifications)</tt>
+        # * <tt>preferred_notifications=(value)</tt> - The same as calling <tt>record.set_preference(:notifications, value)</tt>
+        #
+        # Notice that there are two tenses used depending on the context of the
+        # preference.  Conventionally, <tt>prefers_notifications?</tt> is better
+        # for boolean preferences, while +preferred_color+ is better for non-boolean
+        # preferences.
+        #
+        # Example:
+        #
+        #   user = User.find(:first)
+        #   user.prefers_notifications?         # => false
+        #   user.prefers_color?                 # => true
+        #   user.preferred_color                # => 'red'
+        #   user.preferred_color = 'blue'       # => 'blue'
+        #
+        #   user.prefers_notifications = true
+        #
+        #   car = Car.find(:first)
+        #   user.preferred_color = 'red', car   # => 'red'
+        #   user.preferred_color(car)           # => 'red'
+        #   user.prefers_color?(car)            # => true
+        #
+        #   user.save!  # => true
+        def preference(name, *args)
+          unless included_modules.include?(InstanceMethods)
+            class_inheritable_hash :preference_definitions
+            self.preference_definitions = {}
+
+            class_inheritable_hash :default_preferences
+            self.default_preferences = {}
+
+            has_many  :stored_preferences, :as => :owner, :class_name => 'Preference'
+
+            after_save :update_preferences
+
+            include Spree::Preferences::ModelHooks::InstanceMethods
+          end
+
+          # Create the definition
+          name = name.to_s
+          definition = PreferenceDefinition.new(name, *args)
+          self.preference_definitions[name] = definition
+          self.default_preferences[name] = definition.default_value
+
+          # Create short-hand helper methods, making sure that the attribute
+          # is method-safe in terms of what characters are allowed
+          name = name.gsub(/[^A-Za-z0-9_-]/, '').underscore
+
+          # Query lookup
+          define_method("prefers_#{name}?") do |*group|
+            prefers?(name, group.first)
+          end
+
+          # Writer
+          define_method("prefers_#{name}=") do |*args|
+            set_preference(*([name] + [args].flatten))
+          end
+          alias_method "preferred_#{name}=", "prefers_#{name}="
+
+          # Reader
+          define_method("preferred_#{name}") do |*group|
+            preferred(name, group.first)
+          end
+
+          definition
+        end
+      end
+
+      module InstanceMethods
+        def self.included(base) #:nodoc:
+          base.class_eval do
+            alias_method :prefs, :preferences
+          end
+        end
+
+        # Finds all preferences, including defaults, for the current record.  If
+        # any custom group preferences have been stored, then this will include
+        # all default preferences within that particular group.
+        #
+        # == Examples
+        #
+        # A user with no stored values:
+        #   user = User.find(:first)
+        #   user.preferences
+        #   => {"language"=>"English", "color"=>nil}
+        #
+        # A user with stored values for a particular group:
+        #   user.preferred_color = 'red', 'cars'
+        #   user.preferences
+        #   => {"language"=>"English", "color"=>nil, "cars"=>{"language=>"English", "color"=>"red"}}
+        #
+        # Getting preference values for the owning record:
+        #   user.preferences(nil)
+        #   => {"language"=>"English", "color"=>nil}
+        #
+        # Getting preference values for a particular group:
+        #   user.preferences('cars')
+        #   => {"language"=>"English", "color"=>"red"}
+        def preferences(*args)
+          if args.empty?
+            group = nil
+            conditions = {}
+          else
+            group = args.first
+            group_id, group_type = Preference.split_group(group)
+            conditions = {:group_id => group_id, :group_type => group_type}
+          end
+
+          # Find all of the stored preferences
+          stored_preferences = self.stored_preferences.find(:all, :conditions => conditions)
+
+          # Hashify attribute -> value or group -> attribute -> value
+          stored_preferences.inject(self.class.default_preferences.dup) do |all_preferences, preference|
+            if !group && (preference_group = preference.group)
+              preferences = all_preferences[preference_group] ||= self.class.default_preferences.dup
+            else
+              preferences = all_preferences
+            end
+
+            preferences[preference.name] = preference.value
+            all_preferences
+          end
+        end
+
+        # Queries whether or not a value has been specified for the given attribute.
+        # This is dependent on how the value is type-casted.
+        #
+        # == Examples
+        #
+        #   user = User.find(:first)
+        #   user.prefers?(:notifications)             # => true
+        #
+        #   user.prefers(:notifications, 'error')     # => true
+        #
+        #   newsgroup = Newsgroup.find(:first)
+        #   user.prefers?(:notifications, newsgroup)  # => false
+        def prefers?(name, group = nil)
+          name = name.to_s
+
+          value = preferred(name, group)
+          preference_definitions[name].query(value)
+        end
+
+        # Gets the preferred value for the given attribute.
+        #
+        # == Examples
+        #
+        #   user = User.find(:first)
+        #   user.preferred(:color)          # => 'red'
+        #
+        #   user.preferred(:color, 'cars')  # => 'blue'
+        #
+        #   car = Car.find(:first)
+        #   user.preferred(:color, car)     # => 'black'
+        def preferred(name, group = nil)
+          name = name.to_s
+
+          if @preference_values && @preference_values[name] && @preference_values[name].include?(group)
+            value = @preference_values[name][group]
+          else
+            group_id, group_type = Preference.split_group(group)
+            preference = stored_preferences.find(:first, :conditions => {:name => name, :group_id => group_id, :group_type => group_type})
+            value = preference ? preference.value : preference_definitions[name].default_value
+          end
+
+          value
+        end
+
+        # Sets a new value for the given attribute.  The actual Preference record
+        # is *not* created until the actual record is saved.
+        #
+        # == Examples
+        #
+        #   user = User.find(:first)
+        #   user.set_preference(:notifications, false) # => false
+        #   user.save!
+        #
+        #   newsgroup = Newsgroup.find(:first)
+        #   user.set_preference(:notifications, true, newsgroup)  # => true
+        #   user.save!
+        def set_preference(name, value, group = nil)
+          name = name.to_s
+
+          @preference_values ||= {}
+          @preference_values[name] ||= {}
+          @preference_values[name][group] = value
+
+          value
+        end
+
+        private
+
+        # Updates any preferences that have been changed/added since the record
+        # was last saved
+        def update_preferences
+          if @preference_values
+            @preference_values.each do |name, grouped_records|
+              grouped_records.each do |group, value|
+                group_id, group_type = Preference.split_group(group)
+                attributes = {:name => name, :group_id => group_id, :group_type => group_type}
+
+                # Find an existing preference or build a new one
+                preference = stored_preferences.find(:first, :conditions => attributes)
+                if preference.nil?
+                  attribute = attributes.delete(:attribute)
+                  preference = stored_preferences.build(attributes)
+                  preference['attribute'] = attribute
+                end
+                preference.value = value
+                preference.save!
+              end
+            end
+
+            @preference_values = nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spree_core/preferences/preference_definition.rb

@@ -0,0 +1,53 @@
+# Most of this code is from the preferences plugin available at
+# http://github.com/pluginaweek/preferences/tree/master
+#
+module Spree
+  # Adds support for defining preferences on ActiveRecord models.
+  module Preferences
+    # Represents the definition of a preference for a particular model
+    class PreferenceDefinition
+      def initialize(name, *args) #:nodoc:
+        options = args.extract_options!
+        options.assert_valid_keys(:default)
+        
+        @type = args.first ? args.first.to_s : 'boolean'
+        
+        # Create a column that will be responsible for typecasting
+        @column = ActiveRecord::ConnectionAdapters::Column.new(name.to_s, options[:default], @type == 'any' ? nil : @type)
+      end
+      
+      # The attribute which is being preferenced
+      def name
+        @column.name
+      end
+      
+      # The default value to use for the preference in case none have been
+      # previously defined      
+      def default_value
+        @column.default
+      end
+      
+      # Typecasts the value based on the type of preference that was defined
+      def type_cast(value)
+        if @type == 'any'
+          value
+        else
+          @column.type_cast(value)
+        end
+      end
+      
+      # Typecasts the value to true/false depending on the type of preference
+      def query(value)
+        unless value = type_cast(value)
+          false
+        else
+          if @column.number?
+            !value.zero?
+          else
+            !value.blank?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spree_core/ssl_requirement.rb

@@ -0,0 +1,109 @@
+# ++
+# Copyright (c) 2007-2010, Rails Dog LLC and other contributors
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Rails Dog LLC nor the names of its
+#       contributors may be used to endorse or promote products derived from this
+#       software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# --
+
+# ++
+# Copyright (c) 2005 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# --
+
+# Modified version of the ssl_requirement plugin by DHH
+module SslRequirement
+  def self.included(controller)
+    controller.extend(ClassMethods)
+    controller.before_filter(:ensure_proper_protocol)
+  end
+
+  module ClassMethods
+    # Specifies that the named actions requires an SSL connection to be performed (which is enforced by ensure_proper_protocol).
+    def ssl_required(*actions)
+      write_inheritable_array(:ssl_required_actions, actions)
+    end
+
+    def ssl_allowed(*actions)
+      write_inheritable_array(:ssl_allowed_actions, actions)
+    end
+  end
+
+  protected
+    # Returns true if the current action is supposed to run as SSL
+    def ssl_required?
+      (self.class.read_inheritable_attribute(:ssl_required_actions) || []).include?(action_name.to_sym)
+    end
+
+    def ssl_allowed?
+      (self.class.read_inheritable_attribute(:ssl_allowed_actions) || []).include?(action_name.to_sym)
+    end
+
+  private
+    def dvp_mode?
+      ENV['RAILS_ENV'] == 'development'
+    end
+
+    def test_mode?
+      ENV['RAILS_ENV'] == 'test' || ENV['RAILS_ENV'] == 'cucumber'
+    end
+
+    # don't require ssl in development or test mode
+    def ssl_supported?
+      ((dvp_mode? || test_mode?) && Spree::Config[:allow_ssl_in_development_and_test]) ||
+      (!dvp_mode? && !test_mode? && Spree::Config[:allow_ssl_in_production]) ? true : false
+    end
+
+    def ensure_proper_protocol
+      return true if ssl_allowed?
+
+      if ssl_required? && !request.ssl? && ssl_supported?
+        redirect_to "https://" + request.host + request.fullpath
+        flash.keep
+        return false
+      elsif request.ssl? && !ssl_required?
+        redirect_to "http://" + request.host + request.fullpath
+        flash.keep
+        return false
+      end
+    end
+end

data/lib/spree_core/theme_support/hook.rb

@@ -0,0 +1,51 @@
+module Spree
+  module ThemeSupport
+    module Hook
+
+      @@listener_classes = []
+      @@listeners = nil
+      @@hook_modifiers = {}
+
+      class << self
+        # Adds a listener class.
+        # Automatically called when a class inherits from Spree::ThemeSupport::HookListener.
+        def add_listener(klass)
+          raise "Hooks must include Singleton module." unless klass.included_modules.include?(Singleton)
+          @@listener_classes << klass
+          clear_listeners_instances
+        end
+
+        # Returns all the listerners instances.
+        def listeners
+          @@listeners ||= @@listener_classes.uniq.collect {|listener| listener.instance}
+        end
+
+        # Clears all the listeners.
+        def clear_listeners
+          @@listener_classes = []
+          clear_listeners_instances
+        end
+
+        # Clears all the listeners instances.
+        def clear_listeners_instances
+          @@listeners = nil
+          @@hook_modifiers = {}
+        end
+
+        # Take the content captured with a hook helper and modify with each HookModifier
+        def render_hook(hook_name, content, context, locals = {})
+          modifiers_for_hook(hook_name).inject(content) { |result, modifier| modifier.apply_to(result, context, locals) }
+        end
+        
+        # All the HookModifier instances that are associated with this hook_name in extension load order and order they were defined
+        def modifiers_for_hook(hook_name)
+          @@hook_modifiers[hook_name] ||= listeners.map {|l| l.modifiers_for_hook(hook_name)}.flatten
+        end
+
+      end
+
+    end
+  end
+end
+
+

data/lib/spree_core/theme_support/hook_listener.rb

@@ -0,0 +1,68 @@
+module Spree
+  module ThemeSupport
+
+    # Listener class used for views hooks.
+    class HookListener
+      include Singleton
+
+      attr_accessor :hook_modifiers
+
+      def initialize
+        @hook_modifiers = []
+      end
+
+      def modifiers_for_hook(hook_name)
+        hook_modifiers.select{|hm| hm.hook_name == hook_name}
+      end
+
+
+      # Replace contents of hook_name using supplied render args or string returned from block
+      def self.replace(hook_name, options = {}, &block)
+        add_hook_modifier(hook_name, :replace, options, &block)
+      end
+
+      # Insert before existing contents of hook_name using supplied render args or string returned from block
+      def self.insert_before(hook_name, options = {}, &block)
+        add_hook_modifier(hook_name, :insert_before, options, &block)
+      end
+
+      # Insert after existing contents of hook_name using supplied render args or string returned from block
+      def self.insert_after(hook_name, options = {}, &block)
+        add_hook_modifier(hook_name, :insert_after, options, &block)
+      end
+
+      # Clear contents of hook_name
+      def self.remove(hook_name)
+        add_hook_modifier(hook_name, :replace)
+      end
+
+
+      private
+
+        def self.add_hook_modifier(hook_name, action, options = {}, &block)
+          if block
+            renderer = lambda do |template, locals|
+              template.controller.render_to_string(:inline => yield, :locals => locals)
+            end
+          else
+            if options.empty?
+              renderer = nil
+            else
+              renderer = lambda do |template, locals|
+                render_args = [options]
+                if options.is_a?(Hash)
+                  options[:locals] = locals
+                else
+                  render_args << locals
+                end
+                template.render(*render_args)
+              end
+            end
+          end
+          instance.hook_modifiers << HookModifier.new(hook_name, action, renderer)
+        end
+
+    end
+
+  end
+end

data/lib/spree_core/theme_support/hook_modifier.rb

@@ -0,0 +1,35 @@
+module Spree
+  module ThemeSupport
+
+    # A hook modifier is created for each usage of 'insert_before','replace' etc.
+    # This stores how the original contents of the hook should be modified
+    # and does the work of altering the hooks content appropriately
+    class HookModifier
+      attr_accessor :hook_name
+      attr_accessor :action
+      attr_accessor :renderer
+
+      def initialize(hook_name, action, renderer = nil)
+        @hook_name = hook_name
+        @action = action
+        @renderer = renderer
+      end
+
+      def apply_to(content, context, locals = {})
+        return '' if renderer.nil?
+        case action
+        when :insert_before
+          "#{renderer.call(context, locals)}#{content}".html_safe
+        when :insert_after
+          "#{content}#{renderer.call(context, locals)}".html_safe
+        when :replace
+          renderer.call(context, locals).to_s.html_safe
+        else
+          ''
+        end
+      end
+
+    end
+
+  end
+end