spree 0.8.5 → 0.9.0

data/lib/product_filters.rb

@@ -0,0 +1,174 @@
+# THIS FILE SHOULD BE OVER-RIDDEN IN YOUR SITE EXTENSION!
+#   the exact code probably won't be useful, though you're welcome to modify and reuse
+#   the current contents are mainly for testing and documentation
+
+# set up some basic filters for use with products
+#
+# Each filter has two parts
+#  * a parametrized named scope which expects a list of labels 
+#  * an object which describes/defines the filter
+#
+# The filter description has three components
+#  * a name, for displaying on pages
+#  * a named scope which will 'execute' the filter
+#  * 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 
+# scope which returns results which match any of the inputs. This is purely a convention,
+# 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 
+# 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. 
+#
+# 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. 
+#
+# 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.
+
+
+module ProductFilters
+
+  # Example: filtering by price
+  #   The named scope just maps incoming labels onto their conditions, and builds the conjunction
+  #   'price' is in the base scope's context (ie, "select foo from products where ...") so
+  #     we can access the field right away
+  #   The filter identifies which scope to use, then sets the conditions for each price range
+  #
+  Product.named_scope :price_range_any,
+    lambda {|opts| 
+      conds = opts.map {|o| ProductFilters.price_filter[:conds][o]}.reject {|c| c.nil?}
+      Product.scoped(:joins => :master).conditions_any(conds).scope :find
+    }
+
+  def ProductFilters.price_filter
+    conds = [ [ "Under $10",    "price             <= 10" ],
+              [ "$10 - $15",    "price between 10 and 15" ],
+              [ "$15 - $18",    "price between 15 and 18" ],
+              [ "$18 - $20",    "price between 18 and 20" ],
+              [ "$20 or over",  "price             >= 20" ] ]
+    { :name   => "Price Range",
+      :scope  => :price_range_any,
+      :conds  => Hash[*conds.flatten],
+      :labels => conds.map {|k,v| [k,k]}
+    }
+  end
+
+
+  # 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 
+  #   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 
+  #   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. 
+
+  if Property.table_exists? && @@brand_property = Property.find_by_name("brand")
+    Product.named_scope :brand_any,
+      lambda {|opts| 
+        conds = opts.map {|o| ProductFilters.brand_filter[:conds][o]}.reject {|c| c.nil?} 
+        Product.with_property(@@brand_property, "p_brand").conditions_any(conds).scope(:find)
+      } 
+
+    def ProductFilters.brand_filter
+      brands = ProductProperty.find_all_by_property_id(@@brand_property).map(&:value).uniq
+      conds  = Hash[*brands.map {|b| [b, "p_brand.value = '#{b}'"]}.flatten]
+      conds["No brand"] = "p_brand.value is NULL"
+      { :name   => "All Brands",
+        :scope  => :brand_any,
+        :conds  => conds,
+        :labels => (brands.sort + ["No brand"]).map {|k| [k,k]}
+      }
+    end
+  end
+
+  # 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 
+  #   its descendents.
+  #
+  #   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) 
+  #   parameter and value is its label array, and then get a modified named scope
+  #   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. 
+
+  if Property.table_exists? && @@brand_property 
+    Product.named_scope :selective_brand_any, lambda {|opts| Product.brand_any(opts).scope(:find) }
+
+    def ProductFilters.selective_brand_filter(taxon = nil)
+      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}, 
+                                     :conditions => ["taxons.id in (?)", [taxon] + taxon.descendents])
+      brands = scope.map {|p| p.value}
+
+      { :name   => "Applicable Brands",
+        :scope  => :selective_brand_any,
+        :conds  => Hash[*all_brands.map {|m| [m, "p_colour.value like '%#{m}%'"]}.flatten],
+        :labels => brands.sort.map {|k| [k,k]}
+      }
+    end
+  end
+
+
+  # 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. 
+  #
+  # 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,
+      :scope  => :taxons_id_in_tree_any,
+      :labels => taxon.children.sort_by(&:position).map {|t| [t.name, t.id]},
+      :conds  => nil
+    }
+  end
+
+  # Filtering by the list of all taxons
+  #
+  # Similar idea as above, but we don't want the descendents' products, hence
+  # it uses one of the auto-generated scopes from SearchLogic.
+  #
+  # idea: expand the format to allow nesting of labels?
+  def ProductFilters.all_taxons
+    taxons = Taxonomy.all.map {|t| [t.root] + t.root.descendents }.flatten
+    { :name   => "All taxons",
+      :scope  => :taxons_id_equals_any,
+      :labels => taxons.sort_by(&:name).map {|t| [t.name, t.id]},
+      :conds  => nil	# not needed
+    }
+  end
+end

data/lib/product_scopes.rb

@@ -0,0 +1,76 @@
+module ProductScopes
+
+  Product.named_scope :price_between, lambda {|low,high| 
+    { :joins => :master, :conditions => ["price BETWEEN ? AND ?", low, high] }
+  }
+
+  Product.named_scope :taxons_id_in_tree, lambda {|taxon| 
+    Product.taxons_id_in_tree_any(taxon).scope :find 
+  }
+
+  # TODO - speed test on nest vs join
+  Product.named_scope :taxons_id_in_tree_any, lambda {|*taxons| 
+    taxons = [taxons].flatten
+    { :conditions => [ "products.id in (select product_id from products_taxons where taxon_id in (?))", 
+                       taxons.map    {|i| i.is_a?(Taxon) ? i : Taxon.find(i)}.
+                              reject {|t| t.nil?}.
+                              map    {|t| [t] + t.descendents}.flatten ]}
+  }
+
+  # a simple test for product with a certain property-value pairing
+  # it can't test for NULLs and can't be cascaded - see :with_property 
+  Product.named_scope :with_property_value, lambda { |property, value| 
+    Product.product_properties_property_id_equals(property).
+            product_properties_value_equals(value).
+            scope :find
+  }   # coded this way to demonstrate composition
+
+
+  # a scope which sets up later testing on the values of a given property
+  # it takes * a property (object or id), and 
+  #          * an optional distinguishing name to support multiple property tests 
+  # this version includes results for which the property is not given (ie is NULL),
+  #   eg an unspecified colour would come out as a NULL.
+  # it probably won't be used without taxon or other filters having narrowed the set 
+  #   to a point where results aren't swamped by nulls, hence no inner join version
+  Product.named_scope :with_property,
+    lambda {|property,*args|
+      name = args.empty? ? "product_properties" : args.first
+      property_id = case property
+                      when Property then property.id 
+                      when Fixnum   then property
+                    end
+      return {} if property_id.nil?
+      { :joins => "left outer join product_properties #{name} on products.id = #{name}.product_id and #{name}.property_id = #{property_id}"}
+    }
+                     
+
+  # add in option_values_variants to the query
+  # this is the common info required for all options searches
+  Product.named_scope :with_variant_options,
+    Product.
+      scoped(:joins => :variants).
+      scoped(:joins => "join option_values_variants on variants.id = option_values_variants.variant_id").
+      scope(:find)
+
+  # select products which have an option of the given type
+  # this sets up testing on specific option values, eg colour = red
+  # the optional argument supports filtering by multi options, eg colour = red and 
+  #   size = small, which need separate joins if done a property at a time
+  # this version discards products which don't have the given option (the outer join
+  #   version is a bit more complex because we need to control the order of joins)
+  # TODO: speed test on nest vs join
+  Product.named_scope :with_option,
+    lambda {|opt_type,*args|
+      name   = args.empty? ? "option_types" : args.first
+      opt_id = case opt_type
+                 when OptionType then opt_type.id 
+                 when Fixnum     then opt_type
+               end
+      return {} if opt_id.nil?
+      Product.with_variant_options.
+              scoped(:joins => "join (select presentation, id from option_values where option_type_id = #{opt_id}) #{name} on #{name}.id = option_values_variants.option_value_id").
+              scope(:find)
+    }
+
+end

data/lib/spree.rb

@@ -8,8 +8,8 @@ unless defined? Spree::Version
   module Spree
     module Version
       Major = '0'
-      Minor = '8'
-      Tiny  = '5'
+      Minor = '9'
+      Tiny  = '0'
 
       class << self
         def to_s

data/lib/spree/config.rb

@@ -4,7 +4,7 @@ module Spree
   # Usage:
   #   Spree::Config[:foo]                  # Returns the +foo+ preference
   #   Spree::Config[]                      # Returns a Hash with all the application preferences
-  #   Spree::Config.intance                # Returns the configuration object (AppConfiguration.first)
+  #   Spree::Config.instance               # Returns the configuration object (AppConfiguration.first)
   #   Spree::Config.set(preferences_hash)  # Set the application preferences as especified in +preference_hash+
   class Config
     include Singleton

data/lib/spree/extension_loader.rb

@@ -96,6 +96,15 @@ module Spree
     end
     alias :reactivate :activate_extensions
 
+    def run_initializers
+      load_extension_roots.each do |extension_path|
+        Dir["#{extension_path}/config/initializers/**/*.rb"].sort.each do |initializer|
+          RAILS_DEFAULT_LOGGER.info "INFO: Loading initializer #{initializer}"
+          load(initializer)
+        end
+      end
+    end 
+
     def load_extension_roots
       @load_extension_roots ||= unless configuration.extensions.empty?
         select_extension_roots
@@ -145,4 +154,4 @@ module Spree
         end.flatten
       end
   end
-end
+end

data/lib/spree/file_utilz.rb

@@ -0,0 +1,71 @@
+require 'fileutils'
+require 'spree/extension'
+
+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
+        raise "Could not mirror #{source} - entity does not exist"
+      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
+    
+      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/initializer.rb

@@ -6,6 +6,15 @@
 require 'initializer'
 require 'spree/extension_loader'
 
+# Small hack to make sure metal stuff inside Spree gem is also loaded
+Rails::Initializer.class_eval do
+  alias :initialize_metal_old :initialize_metal
+  def initialize_metal
+    Rails::Rack::Metal.metal_paths += ["#{SPREE_ROOT}/app/metal"]
+    initialize_metal_old
+  end
+end
+
 module Spree
 
   class Configuration < Rails::Configuration
@@ -52,9 +61,11 @@ module Spree
         # Followed by the standard includes.
         paths.concat %w(
           app
+          app/metal
           app/models
           app/controllers
           app/helpers
+          app/services
           config
           lib
           vendor
@@ -119,6 +130,7 @@ module Spree
 
     def after_initialize
       extension_loader.activate_extensions unless $rails_gem_installer
+      extension_loader.run_initializers #? conds?
       super
     end
 =begin
@@ -148,7 +160,7 @@ module Spree
     def initialize_i18n
       extension_loader.add_locale_paths
       spree_locale_paths = Dir[File.join(SPREE_ROOT, 'config', 'locales', '*.{rb,yml}')]
-      extension_loader.configuration.i18n.load_path.concat(spree_locale_paths)
+      extension_loader.configuration.i18n.load_path = spree_locale_paths + extension_loader.configuration.i18n.load_path
       super
     end
 

data/lib/spree/setup.rb

@@ -99,6 +99,12 @@ module Spree
           FileUtils.cp src_path, target_path
         end
       end
+      
+      # HACK - need to add all sample users to the 'user' role (can't do this in sample fixtures because user role is seed data)
+      user_role = Role.find_by_name "user"
+      if user_role
+        User.all.each { |u| u.roles << user_role unless u.has_role?("user") } 
+      end
 
       announce "Sample data has been loaded"
     end
@@ -118,7 +124,7 @@ module Spree
       
       def prompt_for_admin_email
         email = ask('Email [spree@example.com]: ', String) do |q|
-          q.echo = false
+          q.echo = true
           q.whitespace = :strip
         end
         email = "spree@example.com" if email.blank?

data/lib/tasks/consistency.rake

@@ -0,0 +1,30 @@
+require 'activerecord'              
+#require 'test/unit/testcase'
+
+def assert (bool,msg)
+  puts "#{bool ? "OK   =>" : "FAIL =>"} #{msg}"
+end
+
+namespace :db do
+  desc "check overall database consistency"
+  task :consistency => :environment do
+  end
+        
+  namespace :consistency do                       
+    desc "Check product and variant consistency" 
+    task :products => :environment do
+      assert(Product.all.all? {|p| p.master.present?},
+             "all products must have a master variant")
+      assert(Product.all.all? {|p| p.master.option_values.empty?}, 
+             "all master variants must have no option values")
+      assert(Product.all.all? {|p| p.variants.all? {|v| ! v.option_values.empty?}},
+             "all (non-master) variants must have some option values")
+      
+      o_types = Product.all(:include => {:variants => :option_values}).all? do |p| 
+                  v_types = p.variants.map {|v| v.option_values.map &:option_type}.flatten.uniq 
+                  v_types.map(&:id).sort == p.option_types.map(&:id).sort
+                end
+      assert(o_types, "a product's option types must match the types on its variants' options")
+    end
+  end
+end