spree_core 0.30.0.beta1

data/lib/spree/config.rb

@@ -0,0 +1,31 @@
+module Spree
+  # Singleton class to access the configuration object (AppConfiguration.first by default) and its preferences.
+  #
+  # Usage:
+  #   Spree::Config[:foo]                  # Returns the +foo+ preference
+  #   Spree::Config[]                      # Returns a Hash with all the application preferences
+  #   Spree::Config.instance               # Returns the configuration object (AppConfiguration.first)
+  #   Spree::Config.set(preferences_hash)  # Set the application preferences as especified in +preference_hash+
+  #   Spree::Config.searcher/searcher=     # get/set the default product search implementation
+  class Config
+    include Singleton
+    include Spree::PreferenceAccess
+
+    class << self
+      def instance
+        return @configuration if @configuration
+        return nil unless ActiveRecord::Base.connection.tables.include?('configurations')
+        @configuration ||= AppConfiguration.find_or_create_by_name("Default configuration")
+        @configuration
+      end
+
+      def searcher
+        @searcher ||= Spree::Search::Base.new
+      end
+
+      def searcher=(searcher_obj)
+        @searcher = searcher_obj
+      end
+    end
+  end
+end

data/lib/spree/current_order.rb

@@ -0,0 +1,14 @@
+module Spree
+  module CurrentOrder
+    # The current incomplete order from the session for use in cart and during checkout
+    def current_order(create_order_if_necessary = false)
+      return @current_order if @current_order
+      @current_order ||= Order.find_by_id(session[:order_id], :include => :adjustments)
+      if create_order_if_necessary and (@current_order.nil? or @current_order.complete?)
+        @current_order = Order.create
+      end
+      session[:order_id] = @current_order ? @current_order.id : nil
+      @current_order
+    end
+  end
+end

data/lib/spree/file_utilz.rb

@@ -0,0 +1,73 @@
+require 'fileutils'
+
+module Spree
+  class FileUtilz
+    # A general purpose method to mirror a directory (+source+) into a destination
+    # directory, including all files and subdirectories. Files will not be mirrored
+    # if they are identical already (checked via FileUtils#identical?).
+    #
+    # Copyright (c) 2008 James Adam (The MIT License)
+
+    # added: do mirroring with backup saving turned on
+    def self.mirror_with_backup(source, destination)
+      self.mirror_files(source, destination, true)
+    end
+
+    def self.mirror_files(source, destination, create_backups = false)
+      # TODO: use Rake::FileList#pathmap?
+      if File.directory?(source)
+        source_files  = Dir[source + "/**/*"]
+        source_dirs   = source_files.select { |d| File.directory?(d) }
+        source_files -= source_dirs
+      elsif File.exist? source
+        source_dirs   = []
+        source_files  = [source]
+        source        = File.dirname source
+      else
+        puts "Could not mirror #{source} - entity does not exist"
+        return
+      end
+
+      unless source_files.empty?
+        base_target_dir = File.join(destination)
+        base_target_dir = File.dirname base_target_dir unless File.directory? base_target_dir
+        FileUtils.mkdir_p(base_target_dir)
+      end
+
+      base_target_dir ||= File.join(destination)
+
+      source_dirs.each do |dir|
+        # strip down these paths so we have simple, relative paths we can
+        # add to the destination
+        target_dir = File.join(base_target_dir, dir.gsub(source, ''))
+        begin
+          FileUtils.mkdir_p(target_dir)
+        rescue Exception => e
+          raise "Could not create directory #{target_dir}: \n" + e
+        end
+      end
+
+      source_files.each do |file|
+        begin
+          target = File.join(base_target_dir, file.gsub(source, ''))
+          unless File.exist?(target) && self.same_contents(file, target)
+            # WAS FileUtils.identical?(file, target), but we want to test contents too
+            if create_backups && File.exist?(target)
+              File.rename(target, target + '~')
+            end
+            FileUtils.cp(file, target)
+          end
+        rescue Exception => e
+          raise "Could not copy #{file} to #{target}: \n" + e
+        end
+      end
+    end
+
+    # for windows users...
+    def self.same_contents(source,destination)
+      File.read(source) == File.read(destination)
+    end
+
+  end
+end
+

data/lib/spree/gateway_error.rb

@@ -0,0 +1,3 @@
+module Spree
+  class GatewayError < RuntimeError; end
+end

data/lib/spree/preference_access.rb

@@ -0,0 +1,27 @@
+module Spree::PreferenceAccess
+
+  def self.included(base)
+    class << base
+      def get(key = nil)
+        key = key.to_s if key.is_a?(Symbol)
+        return nil unless config = self.instance
+        # preferences will be cached under the name of the class including this module (ex. Spree::Config)
+        prefs = Rails.cache.fetch(self.to_s) { config.preferences }
+        return prefs if key.nil?
+        prefs[key]
+      end
+
+      # Set the preferences as specified in a hash (like params[:preferences] from a post request)
+      def set(preferences={})
+        config = self.instance
+        preferences.each do |key, value|
+          config.set_preference(key, value)
+        end
+        config.save
+        Rails.cache.delete(self.to_s) { config.preferences }
+      end
+
+      alias_method :[], :get
+    end
+  end
+end

data/lib/spree/search/base.rb

@@ -0,0 +1,21 @@
+module Spree::Search
+  class Base
+    attr_accessor :properties
+
+    def initialize
+      @properties = {}
+    end
+
+    # method should return hash with conditions {:conditions=> "..."} for Product model
+    def get_products_conditions_for(query)
+      Product.like_any([:name, :description], query.split)
+    end
+
+    def prepare(params)
+    end
+
+    def method_missing(name)
+      @properties[name]
+    end
+  end
+end

data/lib/spree/search.rb

@@ -0,0 +1,47 @@
+module Spree::Search
+  def retrieve_products
+    # taxon might be already set if this method is called from TaxonsController#show
+    @taxon ||= Taxon.find_by_id(params[:taxon]) unless params[:taxon].blank?
+    # add taxon id to params for searcher
+    params[:taxon] = @taxon.id if @taxon
+    @keywords = params[:keywords]
+    
+    per_page = params[:per_page].to_i
+    per_page = per_page > 0 ? per_page : Spree::Config[:products_per_page]
+    params[:per_page] = per_page
+    params[:page] = 1 if (params[:page].to_i <= 0)
+    
+    # Prepare a search within the parameters
+    Spree::Config.searcher.prepare(params) unless @keywords.blank?
+
+    if !params[:order_by_price].blank?
+      @product_group = ProductGroup.new.from_route([params[:order_by_price]+"_by_master_price"])
+    elsif params[:product_group_name]
+      @cached_product_group = ProductGroup.find_by_permalink(params[:product_group_name])
+      @product_group = ProductGroup.new
+    elsif params[:product_group_query]
+      @product_group = ProductGroup.new.from_route(params[:product_group_query])
+    else
+      @product_group = ProductGroup.new
+    end
+
+    @product_group = @product_group.from_search(params[:search]) if params[:search]
+ 
+    base_scope = @cached_product_group ? @cached_product_group.products.active : Product.active
+    base_scope = base_scope.in_taxon(@taxon) unless @taxon.blank? 
+    base_scope = base_scope.keywords(@keywords) unless @keywords.blank?
+    
+    base_scope = base_scope.on_hand unless Spree::Config[:show_zero_stock_products]
+    @products_scope = @product_group.apply_on(base_scope)
+
+    curr_page = Spree::Config.searcher.manage_pagination ? 1 : params[:page]
+    @products = @products_scope.all.paginate({
+        :include  => [:images, :master],
+        :per_page => per_page,
+        :page     => curr_page
+      })
+    @products_count = @products_scope.count
+
+    return(@products)
+  end
+end

data/lib/spree_core/delegate_belongs_to.rb

@@ -0,0 +1,95 @@
+##
+# Creates methods on object which delegate to an association proxy.
+# see delegate_belongs_to for two uses
+# 
+# Todo - integrate with ActiveRecord::Dirty to make sure changes to delegate object are noticed
+# Should do
+# class User < ActiveRecord::Base; delegate_belongs_to :contact, :firstname; end
+# class Contact < ActiveRecord::Base; end
+# u = User.first
+# u.changed? # => false
+# u.firstname = 'Bobby'
+# u.changed? # => true
+# 
+# Right now the second call to changed? would return false
+# 
+# Todo - add has_one support. fairly straightforward addition
+##
+module DelegateBelongsTo
+  
+  module ClassMethods
+    
+    @@default_rejected_delegate_columns = ['created_at','created_on','updated_at','updated_on','lock_version','type','id','position','parent_id','lft','rgt']
+    mattr_accessor :default_rejected_delegate_columns
+        
+    ##
+    # Creates methods for accessing and setting attributes on an association.  Uses same
+    # default list of attributes as delegates_to_association.  
+    # @todo Integrate this with ActiveRecord::Dirty, so if you set a property through one of these setters and then call save on this object, it will save the associated object automatically.
+    # delegate_belongs_to :contact
+    # delegate_belongs_to :contact, [:defaults]  ## same as above, and useless
+    # delegate_belongs_to :contact, [:defaults, :address, :fullname], :class_name => 'VCard'
+    ##
+    def delegate_belongs_to(association, *attrs)
+      opts = attrs.extract_options!
+      initialize_association :belongs_to, association, opts
+      attrs = get_association_column_names(association) if attrs.empty?      
+      attrs.concat get_association_column_names(association) if attrs.delete :defaults
+      attrs.each do |attr|
+        class_def attr do |*args|
+          if args.empty?
+            send(:delegator_for, association).send(attr)
+          else
+            send(:delegator_for, association).send(attr, *args)
+          end
+        end
+        class_def "#{attr}=" do |val|
+          send(:delegator_for, association).send("#{attr}=", val)
+        end
+      end
+    end
+    
+    protected
+
+    def get_association_column_names(association, without_default_rejected_delegate_columns=true)
+      begin
+        association_klass = reflect_on_association(association).klass    
+        methods = association_klass.column_names    
+        methods.reject!{|x|default_rejected_delegate_columns.include?(x.to_s)} if without_default_rejected_delegate_columns
+        return methods
+      rescue
+        return []
+      end
+    end
+    
+    ##
+    # initialize_association :belongs_to, :contact
+    def initialize_association(type, association, opts={})
+      raise 'Illegal or unimplemented association type.' unless [:belongs_to].include?(type.to_s.to_sym)
+      send type, association, opts if reflect_on_association(association).nil?
+    end
+    
+    private
+    
+    def class_def(name, method=nil, &blk)
+      class_eval { method.nil? ? define_method(name, &blk) : define_method(name, method) }
+    end
+    
+  end
+  
+  module InstanceMethods
+    protected  
+    def delegator_for(association)
+      send("#{association}=", self.class.reflect_on_association(association).klass.new) if send(association).nil?
+      send(association)
+    end
+  end
+  
+  def self.included(receiver)
+    receiver.extend ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+
+end
+
+ActiveRecord::Base.send :include, DelegateBelongsTo

data/lib/spree_core/enumerable_constants.rb

@@ -0,0 +1,209 @@
+
+module EnumerableConstant
+  
+  # default (overridable) value for any
+  def self.any_value
+    -1
+  end
+  
+  def self.any
+    [any_value, '[any]']
+  end
+  
+  class Tupple
+    
+    include Comparable
+    
+    attr_accessor :name, :value, :display_name
+    
+    def initialize(name, value=nil, display_name=nil)
+      @name = name
+      @value = value
+      @display_name = display_name
+    end
+    
+    def <=> other
+      self.display_name <=> other.display_name
+    end
+    
+    def title_translated
+      t("order_status_#{self.name.downcase}")
+    end
+    
+    def title
+      if @display_name
+        self.display_name
+      else
+        self.name.titleize.strip
+      end
+    end
+    
+    def id
+      self.value
+    end
+    
+  end
+  
+  class Base
+    
+    include Comparable
+
+    def <=>
+      
+    end
+    
+    def self.class_var_prefix
+      self.name.gsub!('::', '_').underscore
+    end
+
+    def self.base=(value)
+      class_eval("@@#{self.class_var_prefix}_base = value")
+    end
+
+    def self.base(value)
+      class_eval("@@#{self.class_var_prefix}_base = value")
+    end
+
+    def self.constant(name, value=nil, display_name=nil)
+      # puts "name: #{name}"
+      # puts "value: #{value}"
+      # puts "display_name: #{display_name}"
+      class_eval("@@#{self.class_var_prefix}_constants ||= []")
+      class_eval("@@#{self.class_var_prefix}_base ||= 0 ")
+      if value == nil and class_eval("@@#{self.class_var_prefix}_constants.size == 0")
+        value = class_eval("@@#{self.class_var_prefix}_base")
+      end
+      if value == nil and class_eval("@@#{self.class_var_prefix}_constants.size > 0")
+        begin
+          value = class_eval("@@#{self.class_var_prefix}_constants.last.value.succ")
+        rescue
+          value = nil
+        end
+      end
+      # puts "eval : " + "#{name.to_s.underscore.upcase} = #{value}"
+      class_eval "#{name.to_s.underscore.upcase} = #{value}"
+      # class_eval "A_STUFF = 25"
+      # puts "display_name: #{display_name}" if display_name
+      class_eval("@@#{self.class_var_prefix}_constants << EnumerableConstant::Tupple.new(name, value, display_name)")
+    end
+    
+    # TODO: add method_missing for class methods so you can do stuff like:
+    # :my_constant = 2
+    # :my_constant 2
+    # MY_CONSTANT = 2
+    # MY_CONSTANT 2
+    # def self.method_missing(symbol, *params)
+    #  
+    # end
+    def self.from_value value
+      self.constants.each do |constant|
+        return constant.title if constant.value == value
+      end
+      nil
+    end
+    
+    def self.constants
+      class_eval("@@#{self.class_var_prefix}_constants")
+    end
+    
+    def self.constant_names
+      result = []
+      class_eval("@@#{self.class_var_prefix}_constants").map do |tupple|
+        result << tupple.name
+      end
+      result
+    end
+    
+    def self.names
+      result = []
+      class_eval("@@#{self.class_var_prefix}_constants").map do |tupple|
+        result << tupple.title
+      end
+      result
+    end
+    
+    def self.values
+      result = []
+      class_eval("@@#{self.class_var_prefix}_constants").map do |tupple|
+        result << tupple.value
+      end
+      result
+    end
+    
+  end
+  
+  module VERSION
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+  
+end
+
+class ActiveRecord::Base
+  
+  def self.enumerable_constant(attribute_name, options={})
+    raise ArgumentError, "you must specify a list of constants" unless options[:constants]
+    set_name = attribute_name.to_s.camelize
+    set_class = "#{self.name}::#{set_name}"
+    
+    constant_definitions = ""
+    options[:constants].each do |constant|
+      if constant.is_a? Hash
+        # puts "hash"
+        constant_name = constant.to_a[0][0]
+        display_name = constant.to_a[0][1]
+        # puts "constant name: #{constant_name}"
+        # puts "display name: #{display_name}"
+        # puts "c name: #{constant_name.to_s.underscore.upcase}"
+        constant_definitions << "constant '#{constant_name.to_s.underscore.upcase}', nil, '#{display_name}'\n" 
+      else
+        # puts "constant '#{constant.to_s.underscore.upcase}'\n" 
+        constant_definitions << "constant '#{constant.to_s.underscore.upcase}'\n" 
+      end
+    end
+    
+    # allow for :connector and :skip_last_comma as used in Array#to_sentence
+    if options[:connector]
+      connector = options[:connector] 
+    else
+      connector = 'or'
+    end
+    unless options[:skip_last_comma].kind_of? NilClass
+      skip_last_comma = options[:skip_last_comma] 
+    else
+      skip_last_comma = true
+    end
+    
+    if options[:base]
+      use_base = options[:base]
+    else
+      use_base = 1
+    end
+
+    # keep glue_text for back compat
+    if options[:glue_text]
+      connector = options[:glue_text].strip
+    end    
+
+    class_eval <<-EOF
+      class #{set_name} < EnumerableConstant::Base
+        base #{use_base}
+        #{constant_definitions}
+      end
+    EOF
+
+    should_be_in_text = set_class.constantize.names.to_sentence :words_connector => connector, :last_word_connector => skip_last_comma
+  
+    unless options[:no_validation]
+      class_eval <<-EOF  
+        validates :#{attribute_name.to_s}, :presence => {
+          :in => #{set_name}::values, 
+          :message => "should be #{should_be_in_text}"
+          }
+      EOF
+    end
+  end
+  
+end

data/lib/spree_core/ext/active_record.rb

@@ -0,0 +1,13 @@
+module ActiveRecord::Persistence
+
+  # Update attributes of a record in the database without callbacks, validations etc.
+  def update_attributes_without_callbacks(attributes)
+    self.class.update_all(attributes, { :id => id })
+  end
+
+  # Update a single attribute in the database
+  def update_attribute_without_callbacks(name, value)
+    update_attributes_without_callbacks(name => value)
+  end
+
+end

data/lib/spree_core/ext/array.rb

@@ -0,0 +1,14 @@
+# RAILS3 TODO (likely not needed - it was commented out before rails3 branch)
+# module SpreeCore::Ext::Array
+#   def to_hash_keys(&block)
+#     Hash[*self.collect { |v|
+#       [v, block.call(v)]
+#     }.flatten]
+#   end
+#
+#   def to_hash_values(&block)
+#     Hash[*self.collect { |v|
+#       [block.call(v), v]
+#     }.flatten]
+#   end
+# end

data/lib/spree_core/ext/string.rb

@@ -0,0 +1,10 @@
+module SpreeCore::Ext::String
+  def is_integer?
+    begin
+      Integer(self.to_s)
+      return true
+    rescue ArgumentError
+      return false
+    end
+  end
+end

data/lib/spree_core/find_by_param.rb

@@ -0,0 +1,117 @@
+# This is a modified version of the original find_by_param plugin by Michael Bumann.  Simplified to use Rails 2.2
+# functionality and tossed out some features not worth supporting.
+
+# ++
+# Copyright (c) 2007 [Michael Bumann - Railslove.com]
+#
+# 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.
+# --
+
+begin
+  require "active_support/multibyte"
+rescue LoadError
+  require "rubygems"
+  require "active_support/multibyte"
+end
+module Railslove
+  module Plugins
+    module FindByParam
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def make_permalink(options={})
+          options[:field] ||= "permalink"
+
+          if self.column_names.include?(options[:field].to_s)
+            options[:param] = options[:field]
+            before_validation(:on => :create){ save_permalink }
+          end
+
+          self.permalink_options = options
+          extend Railslove::Plugins::FindByParam::SingletonMethods
+          include Railslove::Plugins::FindByParam::InstanceMethods
+        rescue
+          # Database is not available (not a problem if we're running rake db:create or rake db:bootstrap)
+        end
+      end
+
+      module SingletonMethods
+
+        def find_by_param(value,args={})
+          if permalink_options[:prepend_id]
+            param = "id"
+            value = value.to_i
+          else
+            param = permalink_options[:field]
+          end
+          self.send("find_by_#{param}".to_sym, value, args)
+        end
+
+        def find_by_param!(value, args={})
+          param = permalink_options[:field]
+          obj = find_by_param(value, args)
+          raise ::ActiveRecord::RecordNotFound unless obj
+          obj
+        end
+      end
+
+      module InstanceMethods
+
+        protected
+        def save_permalink
+          return unless self.class.column_names.include?(permalink_options[:field].to_s)
+          return if !changed?
+
+          base_value = to_param
+          permalink_value = base_value
+          query = self.class.send("where", "#{permalink_options[:field]} = ?", permalink_value)
+          counter = 0
+          unless query.limit(1).empty?
+            permalink_value = "#{base_value}-#{counter += 1}"
+            query = self.class.send("where", "#{permalink_options[:field]} = ?", permalink_value)
+          end
+          write_attribute(permalink_options[:field], permalink_value)
+          true
+
+        end
+      end
+
+    end
+  end
+end
+
+class ActiveRecord::Base
+  class_inheritable_accessor :permalink_options
+  self.permalink_options = {:param => :id}
+
+  #default finders these are overwritten if you use make_permalink in your model
+  def self.find_by_param(value,args={})
+    find_by_id(value,args)
+  end
+  def self.find_by_param!(value,args={})
+    find(value,args)
+  end
+
+end
+ActiveRecord::Base.send(:include, Railslove::Plugins::FindByParam)