spree_core 0.30.0.beta1

data/lib/spree_core/theme_support/more_patches.rb

@@ -0,0 +1,118 @@
+# Patches for the 'more' plugin which adds LessCSS Support to Rails
+# We need more to be able to load stylesheets from app/stylesheets in
+# each extension then write them to the same destination. Where stylesheets
+# of the same name exist in different extensions, the file in the last
+# extension to be loaded takes precedence allowing them to be overriden
+# in the same manner as views
+
+#RAILS3 TODO - deal with extension load path and whether or not we even need the More stuff
+# class Less::More
+# 
+#   class << self
+# 
+#     def source_paths
+#       @source_paths || [source_path]
+#     end
+#     def source_paths=(paths_array)
+#       @source_paths = paths_array.map{|p| Pathname.new(p.to_s)}
+#     end
+# 
+#     # Override because this method would only generate if .css file didnt exist for path_as_array
+#     # and we want to force re-compilation of a less file, overwriting css
+#     def generate(path_as_array)
+#       source = pathname_from_array(path_as_array)
+#       if source.extname == ".css"
+#         css = File.read(source)
+#       else
+#         css = generate_css(source)
+#       end
+#       css
+#     end
+# 
+#     def generate_css(source)
+#       engine = File.open(source) {|f| Less::Engine.new(f) }
+#       css = engine.to_css
+#       css.delete!("\n") if self.compression?
+#       css = (HEADER % [source.to_s]) << css if self.header?
+#       css
+#     end
+# 
+# 
+#     # If .less file, compile CSS for same directory as a cache
+#     def compile(path_as_array)
+#       source = pathname_from_filename(path_as_array.to_s + '.less')
+#       return if source.nil?
+#       unless source.extname == ".css"
+#         destination = Pathname.new(source.to_s.gsub(/.less$/, '.css'))
+# 
+#         if !File.exists?(destination) || source.mtime > destination.mtime
+#           css = Less::More.generate_css(source)
+#           if page_cache?
+#             File.open(destination, "w") {|f|
+#               f.puts css
+#             }
+#           end
+#         end
+#       end
+#     end
+# 
+# 
+#     # Array of Pathname instances for all the less source files.
+#     def all_less_files
+#       #Dir[Less::More.source_path.join("**", "*.{css,less,lss}")].map! {|f| Pathname.new(f) }
+#       source_paths.map do |pathname|
+#         all_less_files_in_path(pathname)
+#       end.flatten
+#     end
+# 
+#     def all_less_files_in_path(pathname)
+#       Dir[pathname.join("**", "*.{css,less,lss}").to_s].map! {|f| Pathname.new(f) }
+#     end
+# 
+# 
+#     # Generates all the .css files.
+#     # Override to iterate through all source paths
+#     def parse
+#       source_paths.reverse.each do |source_path|
+#         Less::More.all_less_files_in_path(source_path).each do |path|
+#           # Get path
+#           relative_path = path.relative_path_from(source_path)
+#           path_as_array = relative_path.to_s.split(File::SEPARATOR)
+#           path_as_array[-1] = File.basename(path_as_array[-1], File.extname(path_as_array[-1]))
+# 
+#           # Generate CSS
+#           css = Less::More.generate(path_as_array)
+# 
+#           # Store CSS
+#           path_as_array[-1] = path_as_array[-1] + ".css"
+#           destination = Pathname.new(Rails.root.join("public", Less::More.destination_path)).join(*path_as_array)
+#           destination.dirname.mkpath
+# 
+#           File.open(destination, "w") {|f|
+#             f.puts css
+#           }
+#         end
+#       end
+#     end
+# 
+#     # Override to look in each of the source paths. Return pathname for first source path that contains this file
+#     def pathname_from_array(array)
+#       path_spec = array.dup
+#       path_spec[-1] = path_spec[-1] + ".{css,less,lss}"
+#       self.source_paths.map do |source_path|
+#         Pathname.glob(File.join(source_path.to_s, *path_spec))[0]
+#       end.compact.first
+#     end
+# 
+#     # Find pathname for specific filename in each of the source paths
+#     def pathname_from_filename(filename)
+#       self.source_paths.map do |source_path|
+#         Pathname.glob(File.join(source_path.to_s, filename))[0]
+#       end.compact.first
+#     end
+# 
+#   end
+# 
+# end
+# 
+# $LESS_LOAD_PATH = Less::More.source_paths = Spree::ExtensionLoader.stylesheet_source_paths.reverse

data/lib/spree_core/theme_support.rb

@@ -0,0 +1,4 @@
+require 'spree_core/theme_support/hook'
+require 'spree_core/theme_support/hook_listener'
+require 'spree_core/theme_support/hook_modifier'
+#require 'spree/theme_support/more_patches'

data/lib/spree_core/validation_group.rb

@@ -0,0 +1,143 @@
+# This is a modified version of wizardly plugin (Jeff Patmon), which itself is based on the validationgroup
+# plugin (akira)
+module ValidationGroup
+  module ActiveRecord
+    module ActsMethods # extends ActiveRecord::Base
+      def self.extended(base)
+        # Add class accessor which is shared between all models and stores
+        # validation groups defined for each model
+        base.class_eval do
+          cattr_accessor :validation_group_classes
+          self.validation_group_classes = {}
+
+          def self.validation_group_order; @validation_group_order; end
+          def self.validation_groups(all_classes = false)
+            return (self.validation_group_classes[self] || {}) unless all_classes
+            klasses = ValidationGroup::Util.current_and_ancestors(self).reverse
+            hash = Hash.new
+            klasses.each do |klass|
+              hash.merge! self.validation_group_classes[klass]
+            end
+            hash
+          end
+        end
+      end
+
+      def validation_group(name, options={})
+        self_groups = (self.validation_group_classes[self] ||= {})
+        self_groups[name.to_sym] = case options[:fields]
+when Array then options[:fields]
+when Symbol, String then [options[:fields].to_sym]
+else []
+end
+        # jeffp: capture the declaration order for this class only (no
+        # superclasses)
+        (@validation_group_order ||= []) << name.to_sym
+
+        unless included_modules.include?(InstanceMethods)
+          # jeffp: added reader for current_validation_fields
+          attr_reader :current_validation_group, :current_validation_fields
+          include InstanceMethods
+        end
+      end
+    end
+
+    module InstanceMethods # included in every model which calls validation_group
+      #needs testing
+# def reset_fields_for_validation_group(group)
+# group_classes = self.class.validation_group_classes
+# found = ValidationGroup::Util.current_and_ancestors(self.class).find do |klass|
+# group_classes[klass] && group_classes[klass].include?(group)
+# end
+# if found
+# group_classes[found][group].each do |field|
+# self[field] = nil
+# end
+# end
+# end
+      def enable_validation_group(group)
+        # Check if given validation group is defined for current class or one of
+        # its ancestors
+        group_classes = self.class.validation_group_classes
+        found = ValidationGroup::Util.current_and_ancestors(self.class).
+          find do |klass|
+          group_classes[klass] && group_classes[klass].include?(group)
+        end
+        if found
+          @current_validation_group = group
+          # jeffp: capture current fields for performance optimization
+          @current_validation_fields = group_classes[found][group].clone
+        end
+      end
+
+      def disable_validation_group
+        @current_validation_group = nil
+        # jeffp: delete fields
+        @current_validation_fields = nil
+      end
+
+      def reject_non_validation_group_errors
+        return unless validation_group_enabled?
+        self.errors.remove_on(@current_validation_fields)
+      end
+
+      # jeffp: optimizer for someone writing custom :validate method -- no need
+      # to validate fields outside the current validation group note: could also
+      # use in validation modules to improve performance
+      def should_validate?(attribute)
+        !self.validation_group_enabled? || (@current_validation_fields && @current_validation_fields.include?(attribute.to_sym))
+      end
+
+      def validation_group_enabled?
+        respond_to?(:current_validation_group) && !current_validation_group.nil?
+      end
+
+      # eliminates need to use :enable_validation_group before :valid? call --
+      # nice
+      def valid_with_validation_group?(group=nil)
+        self.enable_validation_group(group) if group
+        valid_without_validation_group?
+      end
+    end
+
+    module Errors # included in ActiveRecord::Errors
+      def add_with_validation_group(attribute,
+          msg = @@default_error_messages[:invalid], *args,
+          &block)
+        # jeffp: setting @current_validation_fields and use of should_validate? optimizes code
+        add_error = @base.respond_to?(:should_validate?) ? @base.should_validate?(attribute.to_sym) : true
+        add_without_validation_group(attribute, msg, *args, &block) if add_error
+      end
+
+      def remove_on(attributes)
+        return unless attributes
+        attributes = [attributes] unless attributes.is_a?(Array)
+        @errors.reject!{|k,v| !attributes.include?(k.to_sym)}
+      end
+
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          alias_method_chain :add, :validation_group
+        end
+      end
+    end
+  end
+
+  module Util
+    # Return array consisting of current and its superclasses down to and
+    # including base_class.
+    def self.current_and_ancestors(current)
+      klasses = []
+      klasses << current
+      root = current.base_class
+      until current == root
+        current = current.superclass
+        klasses << current
+      end
+      klasses
+    end
+  end
+end
+
+# jeffp: moved from init.rb for gemification purposes --
+# require 'validation_group' loads everything now, init.rb requires 'validation_group' only

data/lib/spree_core.rb

@@ -0,0 +1,144 @@
+#++
+# 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.
+#--
+require "rails/all"
+
+require 'state_machine'
+require 'paperclip'
+require 'stringex'
+require 'will_paginate'
+#require 'less' #TODO RAILS3: consider making this optional
+require 'awesome_nested_set'
+require 'acts_as_list'
+require 'resource_controller'
+require 'searchlogic'
+require 'active_merchant'
+
+require 'spree_core/ext/active_record'
+require 'spree_core/delegate_belongs_to'
+require 'spree_core/theme_support'
+require 'spree_core/validation_group'
+require 'spree_core/enumerable_constants'
+require 'spree_core/find_by_param'
+require 'spree_core/ssl_requirement'
+require 'spree_core/preferences/mail_settings'
+require 'spree_core/preferences/model_hooks'
+require 'spree_core/preferences/preference_definition'
+require 'store_helpers'
+require 'spree/file_utilz'
+require 'spree/calculated_adjustments'
+require 'spree/current_order'
+require 'spree/preference_access'
+require 'spree/config'
+require 'redirect_legacy_product_url'
+require 'seo_assist'
+
+module Spree
+  def self.version
+    "0.30.0.beta1"
+  end
+end
+
+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,
+          PaymentMethod::Check,
+
+          Calculator::FlatPercentItemTotal,
+          Calculator::FlexiRate,
+          Calculator::PerItem,
+          Calculator::PriceBucket
+        ].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,
+        ].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
+
+  end
+end
+
+ActiveRecord::Base.class_eval { include Spree::CalculatedAdjustments }
+
+ActiveRecord::Base.class_eval do
+  include CollectiveIdea::Acts::NestedSet
+end
+
+if defined?(ActionView)
+  require 'awesome_nested_set/helper'
+  ActionView::Base.class_eval do
+    include CollectiveIdea::Acts::NestedSet::Helper
+  end
+end
+
+ActiveSupport.on_load(:action_view) do
+  include StoreHelpers
+end

data/lib/store_helpers.rb

@@ -0,0 +1,10 @@
+# Methods added to this helper will be available to all templates in the application.
+module StoreHelpers
+
+  # helper to determine if its appropriate to show the store menu
+  def store_menu?
+    return true unless %w{thank_you}.include? @current_action
+    false
+  end
+
+end

data/lib/tasks/core.rake

@@ -0,0 +1,112 @@
+require 'active_record'
+require 'custom_fixtures'
+
+namespace :db do
+  desc "Loads a specified fixture using rake db:load_file[filename.rb]"
+  task :load_file , [:file] => :environment do |t , args|
+    file = args.file
+    ext = File.extname file
+    if ext == ".csv" or ext == ".yml"
+      puts "loading fixture " + file
+      Fixtures.create_fixtures(File.dirname(file) , File.basename(file, '.*') )
+    else
+      if File.exists? file
+        puts "loading ruby    " + file
+        require file
+      end
+    end
+  end
+
+  desc "Loads fixtures from the the dir you specify using rake db:load_dir[loadfrom]"
+  task :load_dir , [:dir] => :environment do |t , args|
+    dir = args.dir
+    fixtures = ActiveSupport::OrderedHash.new
+    ruby_files = ActiveSupport::OrderedHash.new
+    Dir.glob(File.join(Rails.root, "db", dir , '*.{yml,csv,rb}')).each do |fixture_file|
+      ext = File.extname fixture_file
+      if ext == ".rb"
+        ruby_files[File.basename(fixture_file, '.*')]  = fixture_file
+      else
+        fixtures[File.basename(fixture_file, '.*')]  = fixture_file
+      end
+    end
+    fixtures.sort.each do |fixture , fixture_file|
+      # an invoke will only execute the task once
+      Rake::Task["db:load_file"].execute( Rake::TaskArguments.new([:file], [fixture_file]) )
+    end
+    ruby_files.sort.each do |fixture , ruby_file|
+      # an invoke will only execute the task once
+      Rake::Task["db:load_file"].execute( Rake::TaskArguments.new([:file], [ruby_file]) )
+    end
+  end
+
+  desc "Migrate schema to version 0 and back up again. WARNING: Destroys all data in tables!!"
+  task :remigrate => :environment do
+    require 'highline/import'
+
+    if ENV['SKIP_NAG'] or ENV['OVERWRITE'].to_s.downcase == 'true' or agree("This task will destroy any data in the database. Are you sure you want to \ncontinue? [y/n] ")
+
+      # Drop all tables
+      ActiveRecord::Base.connection.tables.each { |t| ActiveRecord::Base.connection.drop_table t }
+
+      # Migrate upward
+      Rake::Task["db:migrate"].invoke
+
+      # Dump the schema
+      Rake::Task["db:schema:dump"].invoke
+    else
+      say "Task cancelled."
+      exit
+    end
+  end
+
+  desc "Bootstrap is: migrating, loading defaults, sample data and seeding (for all extensions) invoking create_admin and load_products tasks"
+  task :bootstrap  do
+    require 'highline/import'
+
+    # remigrate unless production mode (as saftey check)
+    if %w[demo development test].include? Rails.env
+      if ENV['AUTO_ACCEPT'] or agree("This task will destroy any data in the database. Are you sure you want to \ncontinue? [y/n] ")
+        ENV['SKIP_NAG'] = 'yes'
+        Rake::Task["db:remigrate"].invoke
+      else
+        say "Task cancelled, exiting."
+        exit
+      end
+    else
+      say "NOTE: Bootstrap in production mode will not drop database before migration"
+      Rake::Task["db:migrate"].invoke
+    end
+
+    load_defaults  = Country.count == 0
+    unless load_defaults    # ask if there are already Countries => default data hass been loaded
+      load_defaults = agree('Countries present, load sample data anyways? [y/n]: ')
+    end
+    Rake::Task["db:seed"].invoke if load_defaults
+
+    if Rails.env == 'production' and Product.count > 0
+      load_sample = agree("WARNING: In Production and products exist in database, load sample data anyways? [y/n]:" )
+    else
+      load_sample = true if ENV['AUTO_ACCEPT']
+      load_sample = agree('Load Sample Data? [y/n]: ') unless load_sample
+    end
+    Rake::Task["db:sample"].invoke if load_sample
+
+    puts "Bootstrap Complete.\n\n"
+  end
+
+  namespace :admin do
+    desc "Create admin username and password"
+    task :create => :environment do
+      require File.join(File.dirname(__FILE__), '..', '..', 'db', 'sample', 'users.rb')
+    end
+  end
+
+  desc "Loads sample data into the store"
+  task :sample do   # an invoke will not execute the task after defaults has already executed it
+    Rake::Task['db:load_dir'].reenable
+    Rake::Task["db:load_dir"].invoke( "sample" )
+    puts "Sample data has been loaded"
+  end
+
+end

data/lib/tasks/themes.rake

@@ -0,0 +1,34 @@
+namespace :spree do
+  namespace :dev do
+    desc "Compile non-partial less stylesheets into public/stylesheets for the last loaded theme extension."
+    task :less => :environment do
+      require 'less'
+
+      #RAILS 3 TODO - figure out final resting place for less
+      #$LESS_LOAD_PATH = Spree::ExtensionLoader.stylesheet_source_paths.reverse
+      $LESS_LOAD_PATH = [Rails.root.join("core", "app", "stylesheets")]
+
+      # css files are written to the last loaded theme extension's public/stylesheets directory
+      output_path = $LESS_LOAD_PATH.first.to_s.gsub("app/stylesheets", "public/stylesheets")
+      FileUtils.mkpath(output_path)
+
+      # Build a list of all unique non-partial .less files to compile
+      stylesheets = $LESS_LOAD_PATH.map do |path|
+        Dir[  File.join(path,"[^_]*.less").to_s].map! {|f| File.basename(f) }
+      end.flatten.uniq
+
+      stylesheets.each do |less_filename|
+        css_filename = less_filename.gsub(/.less/, '.css')
+        paths = $LESS_LOAD_PATH.map { |p| File.join(p, less_filename) }
+        if path = paths.detect {|p| File.exists?(p)}
+          puts "Compiling #{less_filename} from path: #{path}"
+          destination = File.join(output_path, css_filename)
+          f = File.new(destination, File::CREAT|File::TRUNC|File::RDWR, 0644)
+          f.write Less::Engine.new(File.new(path)).to_css
+          puts "  written to #{destination}"
+        end
+      end
+
+    end
+  end
+end