spree_core 0.40.4 → 0.50.0

data/db/migrate/20110110130847_add_next_state_to_state_events.rb

@@ -0,0 +1,9 @@
+class AddNextStateToStateEvents < ActiveRecord::Migration
+  def self.up
+    add_column :state_events, :next_state, :string
+  end
+
+  def self.down
+    remove_column :state_events, :next_state
+  end
+end

data/db/migrate/20110111122537_add_position_to_option_types.rb

@@ -0,0 +1,9 @@
+class AddPositionToOptionTypes < ActiveRecord::Migration
+  def self.up
+    add_column :option_types, :position, :integer, :null => false, :default => 0
+  end
+
+  def self.down
+    remove_column :option_types, :position
+  end
+end

data/db/migrate/20110314192118_remove_trailing_slashes_in_taxon_permalinks.rb

@@ -0,0 +1,17 @@
+class RemoveTrailingSlashesInTaxonPermalinks < ActiveRecord::Migration
+  def self.up
+    Taxon.find_each(:conditions => {}) do |t|
+      if t.permalink && t.permalink[-1..-1] == '/'
+        t.update_attribute(:permalink, t.permalink[0...-1])
+      end
+    end
+  end
+
+  def self.down
+    Taxon.find_each(:conditions => {}) do |t|
+      if t.permalink && t.permalink[-1..-1] != '/'
+        t.update_attribute(:permalink, t.permalink + '/')
+      end
+    end
+  end
+end

data/lib/custom_fixtures.rb

@@ -4,4 +4,4 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
   def delete_existing_fixtures
     # do nothing - we're intentionally not emptying the database since it has some structural data in it
   end
-end    
+end

data/lib/{seo_assist.rb → middleware/seo_assist.rb}

@@ -8,23 +8,29 @@ class SeoAssist
     request = Rack::Request.new(env)
     params = request.params
     taxon_id = params['taxon']
-    if !taxon_id.blank? && !taxon_id.is_a?(Hash) && @taxon = Taxon.find(taxon_id)
+
+    #redirect requests using taxon id's to their permalinks
+    if !taxon_id.blank? && !taxon_id.is_a?(Hash) && taxon = Taxon.find(taxon_id)
       params.delete('taxon')
-      query = build_query(params)
-      permalink = @taxon.permalink[0...-1] #ensures no trailing / for taxon urls
-      return [301, { 'Location'=> "/t/#{permalink}?#{query}" }, []]
+
+      return build_response(params, "/t/#{taxon.permalink}" )
     elsif env["PATH_INFO"] =~ /^\/(t|products)(\/\S+)?\/$/
       #ensures no trailing / for taxon and product urls
-      query = build_query(params)
-      new_location = env["PATH_INFO"][0...-1]
-      new_location += '?' + query unless query.blank?
-      return [301, { 'Location'=> new_location }, []]
+
+      return build_response(params, env["PATH_INFO"][0...-1])
     end
+
     @app.call(env)
   end
 
   private
 
+  def build_response(params, location)
+    query = build_query(params)
+    location += '?' + query unless query.blank?
+    [301, { 'Location'=> location }, []]
+  end
+
   def build_query(params)
     params.map { |k, v|
       if v.class == Array

data/lib/product_filters.rb

@@ -5,7 +5,7 @@
 # set up some basic filters for use with products
 #
 # Each filter has two parts
-#  * a parametrized named scope which expects a list of labels 
+#  * a parametrized named scope which expects a list of labels
 #  * an object which describes/defines the filter
 #
 # The filter description has three components
@@ -14,26 +14,28 @@
 #  * a mapping of presentation labels to the relevant condition (in the context of the named scope)
 #  * an optional list of labels and values (for use with object selection - see taxons examples below)
 #
-# The named scopes here have a suffix '_any', following SearchLogic's convention for a 
+# The named scopes here have a suffix '_any', following SearchLogic's convention for a
 # scope which returns results which match any of the inputs. This is purely a convention,
-# but might be a useful reminder. 
+# but might be a useful reminder.
 #
-# When creating a form, the name of the checkbox group for a filter F should be 
-# the name of F's scope with [] appended, eg "price_range_any[]", and for 
+# When creating a form, the name of the checkbox group for a filter F should be
+# the name of F's scope with [] appended, eg "price_range_any[]", and for
 # each label you should have a checkbox with the label as its value. On submission,
 # Rails will send the action a hash containing (among other things) an array named
-# after the scope whose values are the active labels. 
+# after the scope whose values are the active labels.
 #
 # SearchLogic will then convert this array to a call to the named scope with the array
 # contents, and the named scope will build a query with the disjunction of the conditions
-# relating to the labels, all relative to the scope's context. 
+# relating to the labels, all relative to the scope's context.
 #
-# The details of how/when filters are used is a detail for specific models (eg products 
+# The details of how/when filters are used is a detail for specific models (eg products
 # or taxons), eg see the taxon model/controller.
 
 # See specific filters below for concrete examples.
 
-
+# This module is included by Taxon. In development mode that inclusion does not
+# happen until Taxon class is loaded. Ensure that Taxon class is loaded before
+# you try something like Product.price_range_any
 module ProductFilters
 
   # Example: filtering by price
@@ -42,8 +44,11 @@ module ProductFilters
   #     we can access the field right away
   #   The filter identifies which scope to use, then sets the conditions for each price range
   #
+  # If user checks off three different price ranges then the argument passed to
+  # below scope would be something like ["$10 - $15", "$15 - $18", "$18 - $20"]
+  #
   Product.scope :price_range_any,
-    lambda {|opts| 
+    lambda {|*opts|
       conds = opts.map {|o| ProductFilters.price_filter[:conds][o]}.reject {|c| c.nil?}
       Product.scoped(:joins => :master).conditions_any(conds)
     }
@@ -63,27 +68,27 @@ module ProductFilters
 
 
   # Example: filtering by possible brands
-  # 
+  #
   # First, we define the scope. Two interesting points here: (a) we run our conditions
-  #   in the scope where the info for the 'brand' property has been loaded; and (b) 
-  #   because we may want to filter by other properties too, we give this part of the 
+  #   in the scope where the info for the 'brand' property has been loaded; and (b)
+  #   because we may want to filter by other properties too, we give this part of the
   #   query a unique name (which must be used in the associated conditions too).
   #
-  # Secondly, the filter. Instead of a static list of values, we pull out all existing 
+  # Secondly, the filter. Instead of a static list of values, we pull out all existing
   #   brands from the db, and then build conditions which test for string equality on
   #   the (uniquely named) field "p_brand.value". There's also a test for brand info
-  #   being blank: note that this relies on with_property doing a left outer join 
-  #   rather than an inner join. 
+  #   being blank: note that this relies on with_property doing a left outer join
+  #   rather than an inner join.
 
   if Property.table_exists? && @@brand_property = Property.find_by_name("brand")
     Product.scope :brand_any,
-      lambda {|opts| 
-        conds = opts.map {|o| ProductFilters.brand_filter[:conds][o]}.reject {|c| c.nil?} 
+      lambda {|*opts|
+        conds = opts.map {|o| ProductFilters.brand_filter[:conds][o]}.reject {|c| c.nil?}
         Product.with_property("brand").conditions_any(conds)
-      } 
+      }
 
     def ProductFilters.brand_filter
-      brands = ProductProperty.find_all_by_property_id(@@brand_property).map(&:value).uniq
+      brands = ProductProperty.find_all_by_property_id(@@brand_property).map(&:value).compact.uniq
       conds  = Hash[*brands.map {|b| [b, "product_properties.value = '#{b}'"]}.flatten]
       { :name   => "Brands",
         :scope  => :brand_any,
@@ -95,34 +100,34 @@ module ProductFilters
 
   # Example: a parametrized filter
   #   The filter above may show brands which aren't applicable to the current taxon,
-  #   so this one only shows the brands that are relevant to a particular taxon and 
+  #   so this one only shows the brands that are relevant to a particular taxon and
   #   its descendants.
   #
-  #   We don't have to give a new scope since the conditions here are a subset of the 
-  #   more general filter, so decoding will still work - as long as the filters on a 
-  #   page all have unique names (ie, you can't use the two brand filters together 
+  #   We don't have to give a new scope since the conditions here are a subset of the
+  #   more general filter, so decoding will still work - as long as the filters on a
+  #   page all have unique names (ie, you can't use the two brand filters together
   #   if they use the same scope). To be safe, the code uses a copy of the scope.
   #
-  #   HOWEVER: what happens if we want a more precise scope?  we can't pass 
-  #   parametrized scope names to SearchLogic, only atomic names, so couldn't ask 
-  #   for taxon T's customized filter to be used. BUT: we can arrange for the form 
-  #   to pass back a hash instead of an array, where the key acts as the (taxon) 
+  #   HOWEVER: what happens if we want a more precise scope?  we can't pass
+  #   parametrized scope names to SearchLogic, only atomic names, so couldn't ask
+  #   for taxon T's customized filter to be used. BUT: we can arrange for the form
+  #   to pass back a hash instead of an array, where the key acts as the (taxon)
   #   parameter and value is its label array, and then get a modified named scope
-  #   to get its conditions from a particular filter. 
+  #   to get its conditions from a particular filter.
   #
-  #   The brand-finding code can be simplified if a few more named scopes were added to 
-  #   the product properties model. 
+  #   The brand-finding code can be simplified if a few more named scopes were added to
+  #   the product properties model.
 
-  if Property.table_exists? && @@brand_property 
+  if Property.table_exists? && @@brand_property
     Product.scope :selective_brand_any, lambda {|opts| Product.brand_any(opts) }
 
     def ProductFilters.selective_brand_filter(taxon = nil)
-      if taxon.nil? 
-        taxon = Taxonomy.first.root 
-      end 
+      if taxon.nil?
+        taxon = Taxonomy.first.root
+      end
       all_brands = ProductProperty.find_all_by_property_id(@@brand_property).map(&:value).uniq
       scope = ProductProperty.scoped(:conditions => ["property_id = ?", @@brand_property]).
-                              scoped(:joins      => {:product => :taxons}, 
+                              scoped(:joins      => {:product => :taxons},
                                      :conditions => ["taxons.id in (?)", [taxon] + taxon.descendants])
       brands = scope.map {|p| p.value}
 
@@ -136,17 +141,17 @@ module ProductFilters
 
 
   # Provide filtering on the immediate children of a taxon
-  # 
+  #
   # This doesn't fit the pattern of the examples above, so there's a few changes.
-  # Firstly, it uses an existing scope which was not built for filtering - and so 
-  # has no need of a conditions mapping, and secondly, it has a mapping of name 
-  # to the argument type expected by the other scope. 
+  # Firstly, it uses an existing scope which was not built for filtering - and so
+  # has no need of a conditions mapping, and secondly, it has a mapping of name
+  # to the argument type expected by the other scope.
   #
-  # This technique is useful for filtering on objects (by passing ids) or with a 
+  # This technique is useful for filtering on objects (by passing ids) or with a
   # scope that can be used directly (eg. testing only ever on a single property).
-  # 
+  #
   # This scope selects products in any of the active taxons or their children.
-  # 
+  #
   def ProductFilters.taxons_below(taxon)
     return ProductFilters.all_taxons if taxon.nil?
     { :name   => "Taxons under " + taxon.name,
@@ -170,4 +175,5 @@ module ProductFilters
       :conds  => nil	# not needed
     }
   end
+
 end

data/lib/redirect_legacy_product_url.rb

@@ -2,12 +2,12 @@ class RedirectLegacyProductUrl
   def initialize(app)
     @app = app
   end
-  
-  def call(env)                
-    if env["PATH_INFO"] =~ %r{/t/.+/p/(.+)}      
-      return [301, {'Location'=> "/products/#{$1}" }, []]  
+
+  def call(env)
+    if env["PATH_INFO"] =~ %r{/t/.+/p/(.+)}
+      return [301, {'Location'=> "/products/#{$1}" }, []]
     end
     @app.call(env)
   end
-  
+
 end

data/lib/scopes.rb

@@ -41,7 +41,7 @@ module Scopes
       scopes.each_pair do |scope_name, targs|
         hashed_args = {}
         targs.each{|v| hashed_args[v.to_s] = v.to_s.humanize}
-        
+
         result['scopes'][scope_name.to_s] = {
           'name' => scope_name.to_s.humanize,
           'description' => "",
@@ -66,4 +66,4 @@ end
 #   def to_sql
 #     construct_finder_sql({})
 #   end
-# end     
+# end

data/lib/scopes/dynamic.rb

@@ -1,3 +1,4 @@
+# This module is extended by ProductScope
 module Scopes::Dynamic
   module_function
 
@@ -9,30 +10,22 @@ module Scopes::Dynamic
 
     # Price based scopes
     all_prices = products.map(&:price).sort
+
     ranges = [Math.log(products.length).floor, scope_limit].max
+
     if ranges >= 2
       l = all_prices.length / ranges
-      scopes << ProductScope.new({
-          :name => "master_price_lte",
-          :arguments => [all_prices[l]]
-        })
+      scopes << ProductScope.new({:name => "master_price_lte", :arguments => [all_prices[l]] })
+
       (ranges - 2).times do |x|
-        scopes << ProductScope.new({
-            :name => "price_between",
-            :arguments => [
-              all_prices[l*(x+1)+1],
-              all_prices[l*(x+2)]
-            ]
-          })
+        scopes << ProductScope.new({:name => "price_between",
+                                    :arguments => [ all_prices[l*(x+1)+1], all_prices[l*(x+2)] ] })
       end
-      scopes << ProductScope.new({
-          :name => "master_price_gte",
-          :arguments => [all_prices[l*(ranges-1)+1]]
-        })
+
+      scopes << ProductScope.new({:name => "master_price_gte", :arguments => [all_prices[l*(ranges-1)+1]] })
     end
 
     scopes
   end
 
-  
 end

data/lib/scopes/product.rb

@@ -40,6 +40,22 @@ module Scopes::Product
     :descend_by_popularity,
   ]
 
+  ORDERING.each do |name|
+    next if %w(asecend_by_master_price descend_by_master_price).include?(name.to_s)
+    r = name.to_s.match(/(.*)_by_(.*)/)
+
+    order_text = "products.#{r[2]} "
+    order_text << ((r[1] == 'ascend') ?  "asc" : "desc")
+
+    Product.send(:scope, name.to_s, Product.send(:relation).order(order_text) )
+  end
+
+  ::Product.scope :ascend_by_master_price, lambda {
+    Product.joins(:variants_with_only_master).order('variants.price asc') }
+
+  ::Product.scope :descend_by_master_price, lambda {
+    Product.joins(:variants_with_only_master).order('variants.price desc') }
+
   ATTRIBUTE_HELPER_METHODS = {
     :with_ids => :product_picker_field
   }
@@ -47,9 +63,10 @@ module Scopes::Product
   # Ryan Bates - http://railscasts.com/episodes/112
   # general merging of conditions, names following the searchlogic pattern
   ::Product.scope :conditions, lambda { |*args| {:conditions => args}}
+
   # conditions_all is a more descriptively named enhancement of the above
-  ::Product.scope :conditions_all, lambda { |*args| {:conditions => [args].flatten}}  
-  
+  ::Product.scope :conditions_all, lambda { |*args| {:conditions => [args].flatten}}
+
   # forming the disjunction of a list of conditions (as strings)
   ::Product.scope :conditions_any, lambda { |*args|
     args = [args].flatten
@@ -58,21 +75,19 @@ module Scopes::Product
   }
 
 
+  ::Product.scope :price_between, lambda { |low, high|
+    { :joins => :master, :conditions => ["variants.price BETWEEN ? AND ?", low, high] }
+  }
 
-  #RAILS3 TODO - scopes are duplicated here and in model/product.rb - can we DRY it up?
-  # default product scope only lists available and non-deleted products
-  # ::Product.scope :not_deleted, lambda { where("products.deleted_at is null") }
-  # ::Product.scope :available,   lambda { |*args|
-  #    where("products.available_on <= ?", args.first || Time.zone.now)
-  # }
-  # ::Product.scope :active,      lambda { |*args|
-  #   Product.not_deleted.available(args.first).scope(:find)
-  # }
+  ::Product.scope :master_price_lte, lambda { |price|
+    { :joins => :master, :conditions => ["variants.price <= ?", price] }
+  }
 
-  ::Product.scope :price_between, lambda {|low,high|
-    { :joins => :master, :conditions => ["variants.price BETWEEN ? AND ?", low, high] }
+  ::Product.scope :master_price_gte, lambda { |price|
+    { :joins => :master, :conditions => ["variants.price >= ?", price] }
   }
 
+
   # This scope selects products in taxon AND all its descendants
   # If you need products only within one taxon use
   #
@@ -176,11 +191,11 @@ module Scopes::Product
   Product.scope :in_name, lambda{|words|
     Product.like_any([:name], prepare_words(words))
   }
-  
+
   Product.scope :in_name_or_keywords, lambda{|words|
     Product.like_any([:name, :meta_keywords], prepare_words(words))
   }
-  
+
   Product.scope :in_name_or_description, lambda{|words|
     Product.like_any([:name, :description, :meta_description, :meta_keywords], prepare_words(words))
   }
@@ -218,8 +233,10 @@ SQL
     }
   }
 
-  # Produce an array of keywords for use in scopes. Always return array with at least an empty string to avoid SQL errors
+  # Produce an array of keywords for use in scopes.
+  # Always return array with at least an empty string to avoid SQL errors
   def self.prepare_words(words)
+    return [''] if words.blank?
     a = words.split(/[,\s]/).map(&:strip)
     a.any? ? a : ['']
   end

data/lib/scopes/variant.rb

@@ -1,10 +1,11 @@
 module Scopes::Variant
-  # WARNING tested only under sqlite and postgresql
+
+  #FIXME WARNING tested only under sqlite and postgresql
   Variant.scope :descend_by_popularity, lambda{
       order('COALESCE((SELECT COUNT(*) FROM  line_items GROUP BY line_items.variant_id HAVING line_items.variant_id = variants.id), 0) DESC')
   }
 
-  # for selecting variants with an option value 
+  # for selecting variants with an option value
   # no option type given since the value implies an option type
   # this scope can be chained repeatedly, since the join name is unique
   Variant.scope :has_option, lambda {|opt|
@@ -13,5 +14,5 @@ module Scopes::Variant
       :conditions => ["#{tbl}.option_value_id = (?)", opt]
     }
   }
-  
+
 end