rfcommerce_core 0.0.3

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/db/sample/users.rb

@@ -0,0 +1,61 @@
+# # 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
+#
+# # see last line where we create an admin if there is none, asking for email and password
+#
+# def prompt_for_admin_password
+#   password = ask('Password [spree]: ', String) do |q|
+#     q.echo = false
+#     q.validate = /^(|.{5,40})$/
+#     q.responses[:not_valid] = "Invalid password. Must be at least 5 characters long."
+#     q.whitespace = :strip
+#   end
+#   password = "spree" if password.blank?
+#   password
+# end
+#
+# def prompt_for_admin_email
+#   email = ask('Email [spree@example.com]: ', String) do |q|
+#     q.echo = true
+#     q.whitespace = :strip
+#   end
+#   email = "spree@example.com" if email.blank?
+#   email
+# end
+#
+# def create_admin_user
+#   if ENV['AUTO_ACCEPT']
+#     password =  "spree"
+#     email =  "spree@example.com"
+#   else
+#     require 'highline/import'
+#     puts "Create the admin user (press enter for defaults)."
+#     #name = prompt_for_admin_name unless name
+#     email = prompt_for_admin_email
+#     password = prompt_for_admin_password
+#   end
+#   attributes = {
+#     :password => password,
+#     :password_confirmation => password,
+#     :email => email,
+#     :login => email
+#   }
+#
+#   load 'user.rb'
+#
+#   if User.find_by_login(email)
+#     say "\nWARNING: There is already a user with the email: #{email}, so no account changes were made.  If you wish to create an additional admin user, please run rake db:admin:create again with a different email.\n\n"
+#   else
+#     admin = User.create(attributes)
+#     # create an admin role and and assign the admin user to that role
+#     role = Role.find_or_create_by_name "admin"
+#     admin.roles << role
+#     admin.save
+#   end
+# end
+#
+# create_admin_user unless User.first(:include => :roles, :conditions => ["roles.name = 'admin'"])
+#

data/db/seeds.rb

@@ -0,0 +1,3 @@
+# Loads seed data out of default dir
+Rake::Task["db:load_dir"].invoke( "default" )
+puts "Default data has been loaded"

data/lib/custom_fixtures.rb

@@ -0,0 +1,7 @@
+require 'active_record/fixtures'
+
+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

data/lib/generators/spree_core/upgrade_generator.rb

@@ -0,0 +1,23 @@
+module SpreeCore
+  module Generators
+    class UpgradeGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+
+      desc "Upgrade an existing Rails application to use with a new version of Spree."
+
+      def copy_migrations
+        directory "db"
+        create_file ".rspec", "--colour"
+      end
+
+      def copy_public
+        directory "public"
+      end
+
+      def config_middleware
+        application 'config.middleware.use "SeoAssist"'
+        application 'config.middleware.use "RedirectLegacyProductUrl"'
+      end
+    end
+  end
+end

data/lib/generators/templates/config/initializers/%file_name%.rb.tt

@@ -0,0 +1 @@
+# Initializer code goes here

data/lib/generators/templates/config/locales/%current_locale%.yml.tt

@@ -0,0 +1,2 @@
+---
+<%= I18n.locale.to_s %>:

data/lib/generators/templates/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do |map|
+  # add your extension routes here
+end

data/lib/middleware/seo_assist.rb

@@ -0,0 +1,44 @@
+# Make redirects for SEO needs
+class SeoAssist
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    request = Rack::Request.new(env)
+    params = request.params
+    taxon_id = params['taxon']
+
+    #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')
+
+      return build_response(params, "/t/#{taxon.permalink}" )
+    elsif env["PATH_INFO"] =~ /^\/(t|products)(\/\S+)?\/$/
+      #ensures no trailing / for taxon and product urls
+
+      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
+        build_query(v.map { |x| ["#{k}[]", x] })
+      else
+        k + "=" + Rack::Utils.escape(v)
+      end
+    }.join("&")
+  end
+
+end

data/lib/product_filters.rb

@@ -0,0 +1,179 @@
+# 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.
+
+# 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
+  #   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
+  #
+  # 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|
+      conds = opts.map {|o| ProductFilters.price_filter[:conds][o]}.reject {|c| c.nil?}
+      Product.scoped(:joins => :master).conditions_any(conds)
+    }
+
+  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.scope :brand_any,
+      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.where(:property_id => @@brand_property).map(&:value).compact.uniq
+      conds  = Hash[*brands.map {|b| [b, "product_properties.value = '#{b}'"]}.flatten]
+      { :name   => "Brands",
+        :scope  => :brand_any,
+        :conds  => conds,
+        :labels => (brands.sort).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 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
+  #   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.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
+      all_brands = ProductProperty.where(: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.descendants])
+      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 descendants' 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.descendants }.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/redirect_legacy_product_url.rb

@@ -0,0 +1,13 @@
+class RedirectLegacyProductUrl
+  def initialize(app)
+    @app = app
+  end
+
+  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

@@ -0,0 +1,69 @@
+# This module contains all custom scopes created for selecting products.
+#
+# All usable scopes *should* be included in SCOPES constant, it represents
+# all scopes that are selectable from user interface, extensions can extend
+# and modify it, but should provide corresponding translations.
+#
+# Format of constant is following:
+#
+#   {
+#     :namespace/grouping => {
+#       :name_of_the_scope => [:list, :of, :arguments]
+#     }
+#   }
+#
+#   This values are used in translation file, to describe them in the interface.
+#   So for each scope you define here you have to provide following entry in translation file
+#   product_scopes:
+#     name_of_the_group:
+#       name: Translated name of the group
+#       description: Longer description of what this scope group does, inluding
+#         any possible help user may need
+#       scopes:
+#         name_of_the_scope:
+#           name: Short name of the scope
+#           description: What does this scope does exactly
+#           arguments:
+#             arg1: Description of argument
+#             arg2: Description of second Argument
+#
+module Scopes
+  module_function
+
+  def generate_translation(all_scopes)
+    result = {"groups" => {}, "scopes" => {}}
+    all_scopes.dup.each_pair do |group_name, scopes|
+      result["groups"][group_name.to_s] = {
+        'name' => group_name.to_s.humanize,
+        'description' => "Scopes for selecting products based on #{group_name.to_s}",
+      }
+
+      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' => "",
+          'args' => hashed_args.dup
+        }
+      end
+    end
+
+    result
+  end
+
+  def generate_translations
+    require 'ya2yaml'
+    {
+      'product_scopes' => generate_translation(Scopes::Product::SCOPES)
+    }.ya2yaml
+  end
+end
+
+# Rails 3 TODO
+# ActiveRecord::NamedScope::Scope.class_eval do
+#   def to_sql
+#     construct_finder_sql({})
+#   end
+# end