My-Commerce_core 1.0.0

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.where(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/railtie.rb

@@ -0,0 +1,63 @@
+module SpreeCore
+  class Engine < Rails::Engine
+
+    config.autoload_paths += %W(#{config.root}/lib)
+    # TODO - register state monitor observer?
+
+    def self.activate
+
+      Spree::ThemeSupport::HookListener.subclasses.each do |hook_class|
+        Spree::ThemeSupport::Hook.add_listener(hook_class)
+      end
+
+      #register all payment methods (unless we're in middle of rake task since migrations cannot be run for this first time without this check)
+      if File.basename( $0 ) != "rake"
+        [
+          Gateway::Bogus,
+          Gateway::AuthorizeNet,
+          Gateway::AuthorizeNetCim,
+          Gateway::Eway,
+          Gateway::Linkpoint,
+          Gateway::PayPal,
+          Gateway::SagePay,
+          Gateway::Beanstream,
+          Gateway::Braintree,
+          PaymentMethod::Check
+        ].each{|gw|
+          begin
+            gw.register
+          rescue Exception => e
+            $stderr.puts "Error registering gateway #{gw}: #{e}"
+          end
+        }
+
+        #register all calculators
+        [
+          Calculator::FlatPercentItemTotal,
+          Calculator::FlatRate,
+          Calculator::FlexiRate,
+          Calculator::PerItem,
+          Calculator::SalesTax,
+          Calculator::Vat,
+          Calculator::PriceBucket
+        ].each{|c_model|
+          begin
+            c_model.register if c_model.table_exists?
+          rescue Exception => e
+            $stderr.puts "Error registering calculator #{c_model}"
+          end
+        }
+
+      end
+
+    end
+
+    config.to_prepare &method(:activate).to_proc
+
+    # filter sensitive information during logging
+    initializer "spree.params.filter" do |app|
+      app.config.filter_parameters += [:password, :password_confirmation, :number]
+    end
+
+  end
+end

data/lib/spree_core/spree_custom_responder.rb

@@ -0,0 +1,29 @@
+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 = (result.respond_to?(:call) ? result : result[:success])
+        self.on_failure = (result.respond_to?(:call) ? result : 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
+
+  end
+end

data/lib/spree_core/spree_respond_with.rb

@@ -0,0 +1,57 @@
+module ActionController
+  class Base
+    def respond_with(*resources, &block)
+      raise "In order to use respond_with, first you need to declare the formats your " <<
+            "controller responds to in the class level" if self.class.mimes_for_respond_to.empty?
+
+      if response = retrieve_response_from_mimes(&block)
+        options = resources.size == 1 ? {} : resources.extract_options!
+        options.merge!(:default_response => response)
+
+        # following statement is not present in rails code. The action name is needed for processing
+        options.merge!(:action_name => action_name.to_sym)
+
+        # if responder is not specified then pass in Spree::Responder
+        (options.delete(:responder) || Spree::Responder).call(self, resources, options)
+      end
+    end
+  end
+end
+
+
+module SpreeRespondWith
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :spree_responders
+    self.spree_responders = {}
+  end
+
+  module ClassMethods
+    def respond_override(options={})
+
+      unless options.blank?
+        action_name = options.keys.first
+        action_value = options.values.first
+
+        if action_name.blank? || action_value.blank?
+          raise ArgumentError, "invalid values supplied #{options.inspect}"
+        end
+
+        format_name = action_value.keys.first
+        format_value = action_value.values.first
+
+        if format_name.blank? || format_value.blank?
+          raise ArgumentError, "invalid values supplied #{options.inspect}"
+        end
+
+        if format_value.is_a?(Proc)
+          options = {action_name.to_sym => {format_name.to_sym => {:success => format_value}}}
+        end
+
+        self.spree_responders.rmerge!(self.name.intern => options)
+      end
+    end
+  end
+
+end

data/lib/spree_core/ssl_requirement.rb

@@ -0,0 +1,104 @@
+# ++
+# 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
+  extend ActiveSupport::Concern
+
+  included do
+    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?
+      actions = self.class.read_inheritable_attribute(:ssl_required_actions)
+      return false if actions.nil?
+      actions.empty? || actions.include?(action_name.to_sym)
+    end
+
+    def ssl_allowed?
+      actions = self.class.read_inheritable_attribute(:ssl_allowed_actions)
+      return false if actions.nil?
+      actions.empty? || actions.include?(action_name.to_sym)
+    end
+
+  private
+
+    def ssl_supported?
+      return true if (Rails.env.development? or Rails.env.test?) and Spree::Config[:allow_ssl_in_development_and_test]
+      (Rails.env.staging? or Rails.env.production?) and Spree::Config[:allow_ssl_in_production]
+    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
+      elsif request.ssl? && !ssl_required?
+        redirect_to "http://" + request.host + request.fullpath
+        flash.keep
+      end
+
+    end
+end

data/lib/spree_core/testing_support/factories/address_factory.rb

@@ -0,0 +1,20 @@
+Factory.define :address do |f|
+  f.firstname 'John'
+  f.lastname 'Doe'
+  f.address1 '10 Lovely Street'
+  f.address2 'Northwest'
+  f.city   "Herndon"
+  f.zipcode '20170'
+  f.phone '123-456-7890'
+  f.alternative_phone "123-456-7899"
+
+  f.state  { |address| address.association(:state) }
+  f.country do |address|
+    if address.state
+      address.state.country
+    else
+      address.association(:country)
+    end
+  end
+end
+

data/lib/spree_core/testing_support/factories/adjustment_factory.rb

@@ -0,0 +1,6 @@
+Factory.define :adjustment do  |f|
+  f.order { Factory(:order) }
+  f.amount "100.0"
+  f.label 'Shipping'
+  f.source { Factory(:shipment) }
+end

data/lib/spree_core/testing_support/factories/calculator_factory.rb

@@ -0,0 +1,5 @@
+Factory.define :calculator, :class => Calculator::FlatRate do |f|
+  f.after_create do |c|
+    c.set_preference(:amount, 10.0)
+  end
+end

data/lib/spree_core/testing_support/factories/configuraion_factory.rb

@@ -0,0 +1,4 @@
+Factory.define :configuration do |f|
+  f.name "Default Configuration"
+  f.type "app_configuration"
+end

data/lib/spree_core/testing_support/factories/country_factory.rb

@@ -0,0 +1,7 @@
+Factory.define :country do |f|
+  f.iso_name 'UNITED STATES'
+  f.name 'UNITED STATES'
+  f.iso 'US'
+  f.iso3 'USA'
+  f.numcode 840
+end

data/lib/spree_core/testing_support/factories/creditcard_factory.rb

@@ -0,0 +1,11 @@
+# allows creditcard info to be saved to the datbase which is needed for factories to work properly
+class TestCard < Creditcard
+  def remove_readonly_attributes(attributes) attributes; end
+end
+
+Factory.define(:creditcard, :class => TestCard) do |f|
+  f.verification_value 123
+  f.month 12
+  f.year 2013
+  f.number "4111111111111111"
+end

data/lib/spree_core/testing_support/factories/inventory_unit_factory.rb

@@ -0,0 +1,7 @@
+Factory.define(:inventory_unit) do |record|
+  record.variant { Factory(:variant) }
+  record.order { Factory(:order) }
+  record.state "sold"
+  record.shipment { Factory(:shipment, :state => 'pending') }
+  #record.return_authorization { Factory(:return_authorization) }
+end

data/lib/spree_core/testing_support/factories/line_item_factory.rb

@@ -0,0 +1,8 @@
+Factory.define(:line_item) do |record|
+  record.quantity 1
+  record.price { BigDecimal.new("10.00") }
+
+  # associations:
+  record.association(:order, :factory => :order)
+  record.association(:variant, :factory => :variant)
+end

data/lib/spree_core/testing_support/factories/mail_method_factory.rb

@@ -0,0 +1,4 @@
+Factory.define :mail_method do |f|
+  f.environment { Rails.env }
+  f.active true
+end