spree 0.0.9 → 0.2.0

data/foozah/public/stylesheets/store/_controller.css

@@ -0,0 +1,23 @@
+li.product {
+	list-style: none;
+}
+
+li.preview {
+	float: left;
+	width: 102px; height: 14em;
+	margin-right: 50px;
+	font-size: .9em;
+	line-height: 1.2em;
+}
+/**
+* html dl.preview { margin-right: 38px; }
+#section-index dl.preview {
+	margin-right: 18px;
+}*/
+li.preview a {
+	text-decoration: none;
+}
+
+#variants li {
+  list-style-type: none;
+}

data/foozah/script/about

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/about'

data/foozah/script/breakpointer

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/breakpointer'

data/foozah/script/console

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/console'

data/foozah/script/generate

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require "#{RAILS_ROOT}/config/environment"
+require 'rails_generator'
+require 'rails_generator/scripts/generate'
+
+class Rails::Generator::Base
+  def self.use_application_sources!
+    reset_sources
+    sources << Rails::Generator::PathSource.new(:builtin, "#{SPREE_ROOT}/lib/generators")
+  end
+end
+
+Rails::Generator::Base.use_application_sources!
+
+require 'commands/generate'

data/foozah/script/performance/benchmarker

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../config/boot'
+require 'commands/performance/benchmarker'

data/foozah/script/performance/profiler

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../config/boot'
+require 'commands/performance/profiler'

data/foozah/script/process/inspector

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../config/boot'
+require 'commands/process/inspector'

data/foozah/script/process/reaper

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../config/boot'
+require 'commands/process/reaper'

data/foozah/script/process/spawner

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../config/boot'
+require 'commands/process/spawner'

data/foozah/script/runner

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/runner'

data/foozah/script/server

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/server'

data/foozah/script/spec

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/rspec/lib"))
+require 'spec'
+exit ::Spec::Runner::CommandLine.run(::Spec::Runner::OptionParser.parse(ARGV, STDERR, STDOUT))

data/foozah/script/spec_server

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../rspec/lib' # For svn
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../vendor/plugins/rspec/lib' # For rspec installed as plugin
+require 'rubygems'
+require 'drb/drb'
+require 'rbconfig'
+require 'spec'
+require 'optparse'
+
+# This is based on Florian Weber's TDDMate
+module Spec
+  module Runner
+    class RailsSpecServer
+      def run(argv, stderr, stdout)
+        $stdout = stdout
+        $stderr = stderr
+
+        base = ActiveRecord::Base
+        def base.clear_reloadable_connections!
+          active_connections.each do |name, conn|
+            if conn.requires_reloading?
+              conn.disconnect!
+              active_connections.delete(name)
+            end
+          end
+        end        
+
+        if ActionController.const_defined?(:Dispatcher)
+          dispatcher = ::ActionController::Dispatcher.new($stdout)
+          dispatcher.cleanup_application(true)
+        elsif ::Dispatcher.respond_to?(:reset_application!)
+          ::Dispatcher.reset_application!
+        else
+          raise "Application reloading failed"
+        end
+        ::Dependencies.mechanism = :load
+        require_dependency('application.rb') unless Object.const_defined?(:ApplicationController)
+        load File.dirname(__FILE__) + '/../spec/spec_helper.rb'
+
+        ::Spec::Runner::CommandLine.run(
+          ::Spec::Runner::OptionParser.parse(
+            argv,
+            $stderr,
+            $stdout
+          )
+        )
+      end
+    end
+  end
+end
+puts "Loading Rails environment"
+
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'dispatcher'
+
+def restart_test_server
+  puts "restarting"
+  config       = ::Config::CONFIG
+  ruby         = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
+  command_line = [ruby, $0, ARGV].flatten.join(' ')
+  exec(command_line)
+end
+
+def daemonize(pid_file = nil)
+  return yield if $DEBUG
+  pid = Process.fork{
+    Process.setsid
+    Dir.chdir(RAILS_ROOT)
+    trap("SIGINT"){ exit! 0 }
+    trap("SIGTERM"){ exit! 0 }
+    trap("SIGHUP"){ restart_test_server }
+    File.open("/dev/null"){|f|
+      STDERR.reopen f
+      STDIN.reopen  f
+      STDOUT.reopen f
+    }
+    yield
+  }
+  puts "spec_server launched. (PID: %d)" % pid
+  File.open(pid_file,"w"){|f| f.puts pid } if pid_file
+  exit! 0
+end
+
+options = Hash.new
+opts = OptionParser.new
+opts.on("-d", "--daemon"){|v| options[:daemon] = true }
+opts.on("-p", "--pid PIDFILE"){|v| options[:pid] = v }
+opts.parse!(ARGV)
+
+puts "Ready"
+exec_server = lambda {
+  trap("USR2") { restart_test_server } if Signal.list.has_key?("USR2")
+  DRb.start_service("druby://localhost:8989", Spec::Runner::RailsSpecServer.new)
+  DRb.thread.join
+}
+
+if options[:daemon]
+  daemonize(options[:pid], &exec_server)
+else
+  exec_server.call
+end

data/lib/RFC822.rb

@@ -0,0 +1,30 @@
+#
+# RFC822 Email Address Regex
+# --------------------------
+# 
+# Originally written by Cal Henderson
+# c.f. http://iamcal.com/publish/articles/php/parsing_email/
+#
+# Translated to Ruby by Tim Fletcher, with changes suggested by Dan Kubb.
+#
+# Licensed under a Creative Commons Attribution-ShareAlike 2.5 License
+# http://creativecommons.org/licenses/by-sa/2.5/
+# 
+module RFC822
+  EmailAddress = begin
+    qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
+    dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]'
+    atom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-' +
+      '\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+'
+    quoted_pair = '\\x5c[\\x00-\\x7f]'
+    domain_literal = "\\x5b(?:#{dtext}|#{quoted_pair})*\\x5d"
+    quoted_string = "\\x22(?:#{qtext}|#{quoted_pair})*\\x22"
+    domain_ref = atom
+    sub_domain = "(?:#{domain_ref}|#{domain_literal})"
+    word = "(?:#{atom}|#{quoted_string})"
+    domain = "#{sub_domain}(?:\\x2e#{sub_domain})*"
+    local_part = "#{word}(?:\\x2e#{word})*"
+    addr_spec = "#{local_part}\\x40#{domain}"
+    pattern = /\A#{addr_spec}\z/
+  end
+end

data/lib/annotatable.rb

@@ -0,0 +1,71 @@
+#######################################################################################################
+# Substantial portions of this code were adapted from the Radiant CMS project (http://radiantcms.org) #
+#######################################################################################################
+module Annotatable
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def self.extended(base)
+      base.instance_eval do
+        alias :inherited_without_annotatable :inherited
+        alias :inherited :inherited_with_annotatable
+      end
+    end
+    
+    def annotate(*attrs)
+      options = {}
+      options = attrs.pop if attrs.last.kind_of?(Hash)
+      options.symbolize_keys!
+      inherit = options[:inherit]
+      if inherit
+        @inherited_annotations ||= []
+        @inherited_annotations += attrs
+      end
+      attrs.each do |attr|
+        class_eval %{
+          def self.#{attr}(string = nil)
+            @#{attr} = string || @#{attr}
+          end
+          def #{attr}(string = nil)
+            self.class.#{attr}(string)
+          end
+          def self.#{attr}=(string = nil)
+            #{attr}(string)
+          end
+          def #{attr}=(string = nil)
+            self.class.#{attr}=(string)
+          end
+        }
+      end
+      attrs
+    end
+
+    def inherited_with_annotatable(subclass)
+      inherited_without_annotatable(subclass)
+      (["inherited_annotations"] + (@inherited_annotations || [])).each do |t|
+        ivar = "@#{t}" 
+        subclass.instance_variable_set(ivar, instance_variable_get(ivar))
+      end
+    end
+  end
+
+end
+
+# We don't necessarily have ActiveSupport loaded yet!
+class Hash
+  # Return a new hash with all keys converted to symbols.
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[key.to_sym || key] = value
+      options
+    end
+  end
+
+  # Destructively convert all keys to symbols.
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+end

data/lib/easy_role_permissions.yml

@@ -0,0 +1,76 @@
+# Add to this this file to define the role(s) needed to process an action.
+##Format
+# FirstControllerName:                             # name of Controller
+#  permission_N:                                   # must =~ /permission\d+/
+#    roles : [role_name1, role_name2, role_name3]  # all roles for the controller must be listed here
+#    options :
+#      option_name : options_value                 # these options apply to all allowed roles
+#      option_name : options_value
+#  permission_N+1:
+#    role : [role_name1]                           # a roll_name from permission_N
+#    options :                                     
+#      option_name : options_value                 # options specific to that roll_name
+#      option_name : options_value                   
+#      option_name : options_value
+#      option_name : options_value
+# SecondControllerName:
+#  ...
+##Example Usage:
+# UserController:
+#  permission1:
+#    roles : [admin, user]
+#'Admin::BaseController':       # require admin role for all actions on this controller
+#  permission1:                 # and all controllers that inherit from it that are not
+#    role : admin               # given explicit permissions
+#'Admin::UsersController':
+#  permission1:
+#    role : [admin, shipper]    # require either of these roles for all actions
+#  permission2:
+#    role : admin
+#    options :
+#      except : [index, show]   # now shipper can only use #index and #show
+#      unless : "current_user.authorized_for_listing?(params[:id])"
+#
+##Valid options
+#
+#  * :only - Only require the role for the given action(s)
+#  * :for  - same as :only
+#  * :except - Require the role for everything but the given action(s)
+#  * :for_all_except  - same as :except
+#  * :if - takes a string to eval in the context of the controller.  
+#          If it evaluates to true, the role is required.
+#  * :unless - The inverse of :if
+#
+'UsersController':
+  permission1:
+    roles : [admin]
+    options :
+      only : index      
+'Admin::BaseController':
+  permission1:
+    roles : [admin]
+'Admin::UsersController':
+  permission1:
+    roles : [admin, shipper]    
+  permission2:
+    role : [shipper]
+    options :
+      except : [index, show]
+'Admin::OrdersController':
+  permission1:
+    role : [admin]
+    options :
+      except : [index, ship, show]
+'Admin::ProductsController':
+  permission1:
+    role : [admin]
+    options :
+      except : [index, show]
+'CheckoutController':
+  permission1:
+    role : [admin]
+    options :
+      only : comp      
+'Admin::TaxRatesController':
+  permission1:
+    role : [admin]

data/lib/easy_role_requirement_system.rb

@@ -0,0 +1,234 @@
+# Copyright (c) 2007-2008, Paul Saieg
+# 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 Paul Saieg nor 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.
+
+module EasyRoleRequirementSystem
+  def self.included(klass)
+    super
+    klass.extend ClassMethods
+    klass.enforce_permissions
+       
+    def klass.inherited(sub_klass)
+      super
+      sub_klass.reset_role_requirements!
+      sub_klass.enforce_permissions            
+    end
+  end
+  
+  
+  module InstanceMethods    
+    def included(klass)
+      raise "Include RoleRequirementSystem first BEFORE including EasyRoleRequirementSystem." unless klass.included_modules.include?(RoleRequirementSystem)
+    end
+  end
+  
+  include InstanceMethods
+  
+  module ClassMethods        
+    def role_permissions_file_path
+      @role_permissions_file_path ||= "#{SPREE_ROOT}/lib/easy_role_permissions.yml"
+    end
+    
+    def has_role_requirements?
+      self.role_requirements && self.role_requirements != [] ? true : false
+    end
+    
+    # calls RoleRequirementSystem::require_role for every permission set in the 
+    # config file for the current controller   
+    def enforce_permissions
+       controller_permissions.each do |permission|         
+         all_parameters = []                  
+         permission.each do |p|
+           check_format(p)
+           parameter = {}           
+           parameter[:roles]   = add_roles(p)
+           parameter[:options] = (reformat_options(p[:options]) if p[:options]) || {}        
+           all_parameters << parameter
+         end
+         all_parameters.each{|param| self.require_role(param[:roles], param[:options]) \
+           if param[:roles]}
+       end
+    end
+    
+  private
+    # walks up the class ancestry to find the nearest defined role_requirements.
+    # returns those requirements or {}
+    def inherited_permissions(klass = self)
+      super_class = klass.superclass
+      if super_class.respond_to?(:has_role_requirements?) &&
+         super_class.has_role_requirements?
+           {'permission00' => super_class.role_requirements.last}
+      elsif super_class.respond_to?(:has_role_requirements?)
+          inherited_permissions(super_class)
+      else
+          {}
+      end
+    end
+  
+    def check_format(permission)      
+      legal_keys = [:role, :roles, :options]
+      illegal_keys = permission.reject {|key, val| legal_keys.include?(key)}
+      raise "Improperly formatted permission #{permission.inspect}. The following keys are illegal: #{illegal_keys.inspect}" if illegal_keys != {}
+    end
+    
+    # Enforces permission formatting, gets permissions for controller. If none are 
+    # defined, it gets them from the controller's nearest parent who has them defined.
+    # this gives the illusion of inherited permissions
+    def controller_permissions
+      permissions = []
+      permission_format = /permission\d+/       
+      @permissions = all_permissions[self.to_s] || inherited_permissions                                
+      @permissions.each_pair do |key, value|
+        value = symbolize_keys(value)
+        if key =~ permission_format && (value.has_key?(:roles) || value.has_key?(:role))
+          permissions.push([value])
+        else
+          raise "Incorrectly formatted permission: #{{key => value}.inspect}. Permission line must match #{permission_format.inspect}. Permission also must contain one 'role:' or 'roles:' node."
+        end
+      end
+      permissions
+    end
+    
+    def symbolize_keys(hash)
+      rehash = {}
+      hash.each_pair {|key, value| rehash[key.to_sym] = value}
+      rehash
+    end
+    
+    # sets permissions for class from the permissions file (if it is mentioned ther) 
+    # or from default if it is not. The default is no restrictions at all.
+    def all_permissions
+      @permissions_file ||= load_permissions_file
+      @permissions_file.has_key?(self.to_s) ? @permissions_file : no_permissions
+    end
+    
+    # raises an error if permissions file is not loaded or child nodes got deleted
+    # during YAML serialization
+    def load_permissions_file
+      begin
+        permissions_file = YAML.load_file(role_permissions_file_path)
+       # raise unless permissions_file && yaml_loaded_correctly(permissions_file)
+        rescue
+          raise "#{__FILE__ }: #{__LINE__}: in 'all_permissions': YAML Could not load role pemissions file at '#{role_permissions_file_path}', check the file location and YAML formatting. Duplicate YAML nodes may have been deleted during serialization."
+      end
+      permissions_file
+    end
+    
+    # make sure nothing is deleted in serialization
+    def yaml_loaded_correctly(permissions_file)
+      # scans a raw dump of the YAML file for entered values
+      number_of_value_nodes_in_file = 
+      YAML.dump(YAML.parse_file(role_permissions_file_path)).scan(/\s*value:\s*\w/).length
+      
+      # scans an inspect string of the hash for entered values, each value is "quoted".
+      number_of_value_nodes_in_hash =
+        permissions_file.inspect.scan(/"/).length / 2      
+      number_of_value_nodes_in_hash == number_of_value_nodes_in_file
+    end
+    
+    # default no permissions YAML doc
+    def no_permissions
+      no_permissions_doc = <<-YAML_END 
+      NoControllerHere: 
+        permission0: 
+            roles: 
+            options: 
+      YAML_END
+          
+      YAML.load(no_permissions_doc)
+    end
+        
+    # Allows for either "roles:" or "role:" syntax in config file
+    def add_roles(permission)
+      roles = []            
+      role_key = has_role_node(permission)
+      if role_key == :role
+        permission[:roles] = permission[role_key].dup
+        permission.delete role_key
+        role_key = :roles
+      end     
+      if permission[role_key].is_a?(Array)
+        permission[role_key].each do |role|
+          role = fix_comma_errors(role)           
+          role.each {|r| roles << r}
+        end
+      else
+        fix_comma_errors(permission[role_key]).each do |other_role|
+          other_role.each {|r| roles << r}
+        end
+      end
+       result = roles.compact      
+       (result != [] && result != [{}]) ? result : nil
+    end
+    
+    # YAML interperts [admin,user] as ["admin,user"]. This corrects YAMLs default
+    # behaviour by changing ["admin,user"] to ["admin","user"]
+    def fix_comma_errors(field)
+      field.is_a?(Array) ?  field.map {|f| split_fields(f)} : split_fields(field)
+    end
+    
+    def split_fields(field)
+      field = field.to_s.gsub(/\s+?/, '')
+      field.include?(',') ? symbolize_values(field.split(',')) : symbolize_values([field])
+    end
+    
+    def symbolize_values(array)
+      array.map {|val| val.to_s.to_sym}
+    end
+    
+    # Tells us whether the permissions defines a 'roles:' or 'role:' node.
+    # returns first encountered node (always 'roles' before'role') - never both.
+    def has_role_node(permission)      
+      roles = [:roles,:role].map {|key| key if permission.has_key?(key)}.compact      
+      case  
+        when roles.length == 1 then roles[0]
+      else 
+        raise "Improper Role Configuration: Permission has more than one role/roles node (nodes are #{roles.inspect}. Choose 'role' if there is one value, and 'roles' for an array of values. Change this in your config file at #{role_permissions_file_path})" 
+      end
+    end
+
+    # Transforms YAML hash formatting into correct format for require_role.
+    # Also, enforces correct values for the 'options:' node.   
+    def reformat_options(hash)
+      rehash = {}
+      options = [['if', 'unless'], ['only', 'except', 'for', 'for_all_except']]
+      hash.each_pair do |key, val|
+        case
+          when options[0].include?(key.to_s.downcase) then rehash[key.to_sym] = val.to_s
+          when options[1].include?(key.to_s.downcase) then rehash[key.to_sym] =
+               reformat_value(val)
+          else
+            raise "Unknown Option: #{key}, options are: #{options.flatten.inspect}"
+        end
+      end            
+      rehash
+    end
+    
+    def reformat_value(value)      
+      value.is_a?(Array) ? value.map{|val| val.to_s} : value.to_s      
+    end
+  end
+end