spree-enriquez 0.9.4

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/profiler/add_to_cart_profiler.rb

@@ -0,0 +1,2 @@
+put '/orders', :id => 13164603
+say "PUT #{path}"

data/lib/profiler/product_details_profiler.rb

@@ -0,0 +1,2 @@
+get '/products/ruby-on-rails-stein'
+say "GET #{path}"

data/lib/role_requirement_system.rb

@@ -0,0 +1,145 @@
+# Main module for authentication.  
+# Include this in ApplicationController to activate RoleRequirement
+#
+# See RoleSecurityClassMethods for some methods it provides.
+module RoleRequirementSystem
+  def self.included(klass)
+    klass.send :class_inheritable_array, :role_requirements
+    klass.send :include, RoleSecurityInstanceMethods
+    klass.send :extend, RoleSecurityClassMethods
+    klass.send :helper_method, :url_options_authenticate? 
+    
+    klass.send :role_requirements=, []
+    
+  end
+  
+  module RoleSecurityClassMethods
+    
+    def reset_role_requirements!
+      self.role_requirements.clear
+    end
+    
+    # Add this to the top of your controller to require a role in order to access it.
+    # Example Usage:
+    # 
+    #    require_role "contractor"
+    #    require_role "admin", :only => :destroy # don't allow contractors to destroy
+    #    require_role "admin", :only => :update, :unless => "current_user.authorized_for_listing?(params[:id]) "
+    #
+    # Valid options
+    #
+    #  * :only - Only require the role for the given actions
+    #  * :except - Require the role for everything but 
+    #  * :if - a Proc or a string to evaluate.  If it evaluates to true, the role is required.
+    #  * :unless - The inverse of :if
+    #    
+    def require_role(roles, options = {})
+      options.assert_valid_keys(:if, :unless,
+        :for, :only, 
+        :for_all_except, :except
+      )
+      
+      # only declare that before filter once
+      unless (@before_filter_declared||=false)
+        @before_filter_declared=true
+        before_filter :check_roles
+      end
+      
+      # convert to an array if it isn't already
+      roles = [roles] unless Array===roles
+      
+      options[:only] ||= options[:for] if options[:for]
+      options[:except] ||= options[:for_all_except] if options[:for_all_except]      
+            
+      # convert any actions into symbols
+      for key in [:only, :except]
+        if options.has_key?(key)          
+          options[key] = [options[key]] unless Array === options[key]
+          options[key] = options[key].compact.collect{|v| v.to_sym}
+        end 
+      end
+      
+      self.role_requirements||=[]
+      self.role_requirements << {:roles => roles, :options => options }      
+    end
+    
+    # This is the core of RoleRequirement.  Here is where it discerns if a user can access a controller or not./
+    def user_authorized_for?(user, params = {}, binding = self.binding)
+      return true unless Array===self.role_requirements
+      self.role_requirements.each{| role_requirement|
+        
+        roles = role_requirement[:roles]
+        options = role_requirement[:options]
+        # do the options match the params?
+        
+        # check the action
+        if options.has_key?(:only)
+          next unless options[:only].include?( (params[:action]||"index").to_sym )
+        end
+                
+        if options.has_key?(:except)
+          next if options[:except].include?( (params[:action]||"index").to_sym)
+        end
+        
+        if options.has_key?(:if)
+          # execute the proc.  if the procedure returns false, we don't need to authenticate these roles
+          next unless ( String===options[:if] ? eval(options[:if], binding) : options[:if].call(params) )
+        end
+        
+        if options.has_key?(:unless)
+          # execute the proc.  if the procedure returns true, we don't need to authenticate these roles
+          next if ( String===options[:unless] ? eval(options[:unless], binding) : options[:unless].call(params) )
+        end
+        
+        # check to see if they have one of the required roles
+        passed = false
+        roles.each { |role|          
+          passed = true if user.has_role?(role)
+        } unless (user.nil? || user==false)
+        
+        return false unless passed
+      }
+      
+      return true
+    end
+  end
+  
+  module RoleSecurityInstanceMethods
+    def self.included(klass)
+      #raise "Because role_requirement extends acts_as_authenticated, You must include AuthenticatedSystem first before including RoleRequirementSystem!" unless klass.included_modules.include?(AuthenticatedSystem)
+    end
+    
+    # We want to render something when access is denied, how does this make sense?
+    #
+    # def access_denied
+    #   if logged_in?
+    #     render :nothing => true, :status => 401
+    #     return false
+    #   else
+    #     super
+    #   end
+    # end
+    
+    def check_roles       
+      return access_denied unless self.class.user_authorized_for?(current_user, params, binding)
+      
+      true
+    end
+    
+  protected
+    # receives a :controller, :action, and :params.  Finds the given controller and runs user_authorized_for? on it.
+    # This can be called in your views, and is for advanced users only.  If you are using :if / :unless eval expressions, 
+    #   then this may or may not work (eval strings use the current binding to execute, not the binding of the target 
+    #   controller)
+    def url_options_authenticate?(params = {})
+      params = params.symbolize_keys
+      if params[:controller]
+        # find the controller class
+        klass = eval("#{params[:controller]}_controller".classify)
+      else
+        klass = self.class
+      end
+      klass.user_authorized_for?(current_user, params, binding)
+    end
+  end
+end

data/lib/role_requirement_test_helper.rb

@@ -0,0 +1,86 @@
+# Include this is test_helper.rb to enable test-case helper support for RoleRequirement via:
+#   include RoleRequirementTestHelper
+#
+# RoleRequirementTestHelper uses the power of ruby to temporarily "hijack" your target action.  (don't worry, it puts things back the way it was after it runs)
+# This means that the only thing that will be tested is whether or not the action can be accessed with a given circumstances.
+# Any authentication you implement inside of your action will be ignored.
+#
+module RoleRequirementTestHelper
+
+  # Makes sure a user can access the given action
+  #
+  # Example:
+  #
+  #   assert_user_can_access(:quentin, "index")
+  # 
+  def assert_user_can_access(user, actions, params = {})
+    assert_user_access_check(true, user, actions, params)
+  end
+  
+  # Makes sure a user cant access the given action
+  #
+  # Example:
+  #
+  #   assert_user_cant_access(:quentin, "destroy", :listing_id => 1)
+  # 
+  def assert_user_cant_access(user, actions, params = {})
+    assert_user_access_check(false, user, actions, params)
+  end
+  
+  # Check a list of users against a set of actions with parameters.
+  # 
+  # Parameters:
+  #   users_access_list - a hash where the key is the label for a fixture, and the value is a boolean.
+  #   actions - a list of actions to test against
+  #   params - a hash containing the parameters to pass to each test call to the controller.
+  # 
+  # Example:
+  #   assert_user_access(
+  #     {:admin => true, :quentin => false }, 
+  #     [:show, :edit], 
+  #     {:listing_id => 1})
+  def assert_users_access(users_access_list, actions, params = {})
+    users_access_list.each_pair {|user, access| 
+      assert_user_access_check(access, user, actions, params)
+    }
+  end
+  
+  alias :assert_user_cannot_access :assert_user_cant_access
+
+private
+  def assert_user_access_check(should_access, user, actions, params = {})
+    params = HashWithIndifferentAccess.new(params)
+    
+    (Array===actions ? actions : [actions]).each { |action|
+      # reset the controller, request, and response
+      @controller = @controller.class.new
+      @request = @request.class.new
+      @response = @response.class.new
+      login_as user
+      if should_access
+        assert request_passes_role_security_system?(action, params), "request to #{@controller.class}##{action} with user #{user} and params #{params.inspect} should have passed "
+      else
+        assert ! request_passes_role_security_system?(action, params), "request to #{@controller.class}##{action} with user #{user} and params #{params.inspect} should have been denied"
+      end
+    }
+  end
+  
+  # This is the core of the test system.
+  def request_passes_role_security_system?(action, params)
+    did_it_pass = false
+    
+    action = action.to_s
+    hijacker = Hijacker.new(@controller.class)
+    
+    begin
+      assert hijacker.hijack_instance_method(action, "@last_action_passed='#{action}'; render :text => 'passed'"), "unable to hijack method '#{action}'.  Are you sure the action exists?"
+      get action, params
+    rescue
+      assert false, "error occurred while trying to access action '#{action}' -- #{$!.to_s}.\nCheck to make sure that you are passing needed parameters.\n#{$!.backtrace * "\n"} "
+    ensure
+      hijacker.restore
+    end
+    
+    did_it_pass = (action.to_s == assigns(:last_action_passed)) # make sure it actually made it through
+  end
+end

data/lib/simpleton.rb

@@ -0,0 +1,24 @@
+#######################################################################################################
+# Substantial portions of this code were adapted from the Radiant CMS project (http://radiantcms.org) #
+#######################################################################################################
+module Simpleton
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    
+    def instance(&block)
+      @instance ||= new
+      block.call(@instance) if block_given?
+      @instance
+    end
+    
+    def method_missing(method, *args, &block)
+      instance.respond_to?(method) ? instance.send(method, *args, &block) : super
+    end
+    
+  end
+  
+end

data/lib/spree.rb

@@ -0,0 +1,22 @@
+#######################################################################################################
+# Substantial portions of this code were adapted from the Radiant CMS project (http://radiantcms.org) #
+#######################################################################################################
+
+SPREE_ROOT = File.expand_path(File.join(File.dirname(__FILE__), "..")) unless defined? SPREE_ROOT
+
+unless defined? Spree::Version
+  module Spree
+    module Version
+      Major = '0'
+      Minor = '9'
+      Tiny  = '4'
+
+      class << self
+        def to_s
+          [Major, Minor, Tiny].join('.')
+        end
+        alias :to_str :to_s
+      end
+    end
+  end
+end

data/lib/spree/config.rb

@@ -0,0 +1,20 @@
+module Spree
+  # Singleton class to access the configuration object (AppConfiguration.first by default) and it's 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+
+  class Config
+    include Singleton
+    include PreferenceAccess
+    
+    class << self
+      def instance
+        return nil unless ActiveRecord::Base.connection.tables.include?('configurations')
+        AppConfiguration.find_or_create_by_name("Default configuration")
+      end
+    end
+  end
+end

data/lib/spree/extension.rb

@@ -0,0 +1,58 @@
+require 'annotatable'
+require 'simpleton'
+#require 'radiant/admin_ui'
+
+module Spree
+  class Extension
+    include Simpleton
+    include Annotatable
+
+    annotate :version, :description, :url, :root, :extension_name
+
+    attr_writer :active
+
+    def active?
+      @active
+    end
+    
+    def migrator
+      ExtensionMigrator.new(self)
+    end
+=begin
+    def admin
+      AdminUI.instance
+    end
+=end
+    def meta
+      self.class.meta
+    end
+
+    class << self
+
+      def activate_extension
+        return if instance.active?
+        instance.activate if instance.respond_to? :activate
+        #ActionController::Routing::Routes.reload
+        instance.active = true
+      end
+      alias :activate :activate_extension
+
+      def define_routes(&block)
+        route_definitions << block
+      end
+
+      def inherited(subclass)
+        subclass.extension_name = subclass.name.to_name('Extension')
+      end
+
+      def meta
+        Spree::ExtensionMeta.find_or_create_by_name(extension_name)
+      end
+
+      def route_definitions        
+        @route_definitions ||= []
+      end
+
+    end
+  end
+end

data/lib/spree/extension_loader.rb

@@ -0,0 +1,157 @@
+#######################################################################################################
+# Substantial portions of this code were adapted from the Radiant CMS project (http://radiantcms.org) #
+#######################################################################################################
+require 'spree/extension'
+require 'method_observer'
+
+module Spree
+  class ExtensionLoader
+    
+    class DependenciesObserver < MethodObserver
+      attr_accessor :config
+      
+      def initialize(rails_config)
+        @config = rails_config
+      end
+      
+      def after_clear(*args)
+        ExtensionLoader.load_extensions
+        ExtensionLoader.activate_extensions
+      end
+    end
+
+    include Simpleton
+    
+    attr_accessor :initializer, :extensions
+    
+    def initialize
+      self.extensions = []
+    end
+    
+    def configuration
+      initializer.configuration
+    end
+    
+    def extension_load_paths
+      load_extension_roots.map { |extension| load_paths_for(extension) }.flatten
+    end
+
+    def plugin_paths
+      load_extension_roots.map {|extension| "#{extension}/vendor/plugins" }.select {|d| File.directory?(d) }
+    end
+    
+    def add_extension_paths
+      extension_load_paths.reverse_each do |path|
+        configuration.load_paths.unshift path
+        $LOAD_PATH.unshift path
+      end
+    end
+    
+    def add_plugin_paths
+      configuration.plugin_paths.concat plugin_paths
+    end
+
+    def controller_paths
+      extensions.map { |extension| "#{extension.root}/app/controllers" }.select { |d| File.directory?(d) }
+    end
+    
+    def add_controller_paths
+      configuration.controller_paths.concat(controller_paths)
+    end
+    
+    def locale_paths
+      load_extension_roots.map { |extension|  Dir[File.join("#{extension}/config/locales" , '*.{rb,yml}')]  }.flatten
+    end
+    
+    def add_locale_paths
+      configuration.i18n.load_path.concat(locale_paths)
+    end
+ 
+    def view_paths
+      extensions.map { |extension| "#{extension.root}/app/views" }.select { |d| File.directory?(d) }
+    end
+    
+    # Load the extensions
+    def load_extensions
+      @observer ||= DependenciesObserver.new(configuration).observe(ActiveSupport::Dependencies)
+      self.extensions = load_extension_roots.map do |root|
+        begin
+          extension_file = "#{File.basename(root).sub(/^\d+_/,'')}_extension"       
+          extension = extension_file.camelize.constantize
+          extension.unloadable
+          extension.root = root
+          extension
+        rescue LoadError, NameError => e
+          $stderr.puts "Could not load extension from file: #{extension_file}.\n#{e.inspect}"
+          nil
+        end
+      end.compact
+    end
+    
+    def activate_extensions
+#      initializer.initialize_default_admin_tabs
+      # Reset the view paths after 
+      initializer.initialize_framework_views
+      extensions.each &:activate
+    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
+      else
+        []
+      end
+    end
+
+    private
+
+      def load_paths_for(dir)
+        if File.directory?(dir)
+          %w(lib app/models app/controllers app/helpers test/helpers).collect do |p|
+            path = "#{dir}/#{p}"
+            path if File.directory?(path)
+          end.compact << dir
+        else
+          []
+        end
+      end
+      
+      def select_extension_roots
+        all_roots = all_extension_roots.dup
+        
+        roots = configuration.extensions.map do |ext_name|
+          if :all === ext_name
+            :all
+          else
+            ext_path = all_roots.detect do |maybe_path|
+              File.basename(maybe_path).sub(/^\d+_/, '') == ext_name.to_s
+            end
+            raise LoadError, "Cannot find the extension '#{ext_name}'!" if ext_path.nil?
+            all_roots.delete(ext_path)
+          end
+        end
+
+        if placeholder = roots.index(:all)
+          # replace the :all symbol with any remaining paths
+          roots[placeholder, 1] = all_roots
+        end
+        roots
+      end
+      
+      def all_extension_roots
+        @all_extension_roots ||= configuration.extension_paths.map do |path|
+          Dir["#{path}/*"].map {|f| File.expand_path(f) if File.directory?(f) }.compact.sort
+        end.flatten
+      end
+  end
+end