spree 0.0.5

data/starter-app/vendor/plugins/engines/tasks/engines.rake

@@ -0,0 +1,176 @@
+# This code lets us redefine existing Rake tasks, which is extremely
+# handy for modifying existing Rails rake tasks.
+# Credit for the original snippet of code goes to Jeremy Kemper
+# http://pastie.caboo.se/9620
+unless Rake::TaskManager.methods.include?(:redefine_task)
+  module Rake
+    module TaskManager
+      def redefine_task(task_class, args, &block)
+        task_name, deps = resolve_args(args)
+        task_name = task_class.scope_name(@scope, task_name)
+        deps = [deps] unless deps.respond_to?(:to_ary)
+        deps = deps.collect {|d| d.to_s }
+        task = @tasks[task_name.to_s] = task_class.new(task_name, self)
+        task.application = self
+        @last_comment = nil
+        task.enhance(deps, &block)
+        task
+      end
+    end
+    class Task
+      class << self
+        def redefine_task(args, &block)
+          Rake.application.redefine_task(self, [args], &block)
+        end
+      end
+    end
+  end
+end
+
+namespace :db do
+  namespace :migrate do
+    desc 'Migrate database and plugins to current status.'
+    task :all => [ 'db:migrate', 'db:migrate:plugins' ]
+    
+    desc 'Migrate plugins to current status.'
+    task :plugins => :environment do
+      Engines.plugins.each do |plugin|
+        next unless File.exists? plugin.migration_directory
+        puts "Migrating plugin #{plugin.name} ..."
+        plugin.migrate
+      end
+    end
+
+    desc 'Migrate a specified plugin.'
+    task({:plugin => :environment}, :name, :version) do |task, args|
+      name = args[:name] || ENV['NAME']
+      if plugin = Engines.plugins[name]
+        version = args[:version] || ENV['VERSION']
+        puts "Migrating #{plugin.name} to " + (version ? "version #{version}" : 'latest version') + " ..."
+        plugin.migrate(version ? version.to_i : nil)
+      else
+        puts "Plugin #{name} does not exist."
+      end
+    end    
+  end
+end
+
+
+namespace :db do  
+  namespace :fixtures do
+    namespace :plugins do
+      
+      desc "Load plugin fixtures into the current environment's database."
+      task :load => :environment do
+        require 'active_record/fixtures'
+        ActiveRecord::Base.establish_connection(RAILS_ENV.to_sym)
+        Dir.glob(File.join(RAILS_ROOT, 'vendor', 'plugins', ENV['PLUGIN'] || '**', 
+                 'test', 'fixtures', '*.yml')).each do |fixture_file|
+          Fixtures.create_fixtures(File.dirname(fixture_file), File.basename(fixture_file, '.*'))
+        end
+      end
+      
+    end
+  end
+end
+
+# this is just a modification of the original task in railties/lib/tasks/documentation.rake, 
+# because the default task doesn't support subdirectories like <plugin>/app or
+# <plugin>/component. These tasks now include every file under a plugin's code paths (see
+# Plugin#code_paths).
+namespace :doc do
+
+  plugins = FileList['vendor/plugins/**'].collect { |plugin| File.basename(plugin) }
+
+  namespace :plugins do
+
+    # Define doc tasks for each plugin
+    plugins.each do |plugin|
+      desc "Create plugin documentation for '#{plugin}'"
+      Rake::Task.redefine_task(plugin => :environment) do
+        plugin_base   = RAILS_ROOT + "/vendor/plugins/#{plugin}"
+        options       = []
+        files         = Rake::FileList.new
+        options << "-o doc/plugins/#{plugin}"
+        options << "--title '#{plugin.titlecase} Plugin Documentation'"
+        options << '--line-numbers' << '--inline-source'
+        options << '-T html'
+
+        # Include every file in the plugin's code_paths (see Plugin#code_paths)
+        if Engines.plugins[plugin]
+          files.include("#{plugin_base}/{#{Engines.plugins[plugin].code_paths.join(",")}}/**/*.rb")
+        end
+        if File.exists?("#{plugin_base}/README")
+          files.include("#{plugin_base}/README")    
+          options << "--main '#{plugin_base}/README'"
+        end
+        files.include("#{plugin_base}/CHANGELOG") if File.exists?("#{plugin_base}/CHANGELOG")
+
+        if files.empty?
+          puts "No source files found in #{plugin_base}. No documentation will be generated."
+        else
+          options << files.to_s
+          sh %(rdoc #{options * ' '})
+        end
+      end
+    end
+  end
+end
+
+
+
+namespace :test do
+  task :warn_about_multiple_plugin_testing_with_engines do
+    puts %{-~============== A Moste Polite Warninge ===========================~-
+
+You may experience issues testing multiple plugins at once when using
+the code-mixing features that the engines plugin provides. If you do
+experience any problems, please test plugins individually, i.e.
+
+  $ rake test:plugins PLUGIN=my_plugin
+
+or use the per-type plugin test tasks:
+
+  $ rake test:plugins:units
+  $ rake test:plugins:functionals
+  $ rake test:plugins:integration
+  $ rake test:plugins:all
+
+Report any issues on http://dev.rails-engines.org. Thanks!
+
+-~===============( ... as you were ... )============================~-}
+  end
+  
+  namespace :plugins do
+
+    desc "Run the plugin tests in vendor/plugins/**/test (or specify with PLUGIN=name)"
+    task :all => [:warn_about_multiple_plugin_testing_with_engines, 
+                  :units, :functionals, :integration]
+    
+    desc "Run all plugin unit tests"
+    Rake::TestTask.new(:units => :setup_plugin_fixtures) do |t|
+      t.pattern = "vendor/plugins/#{ENV['PLUGIN'] || "**"}/test/unit/**/*_test.rb"
+      t.verbose = true
+    end
+    
+    desc "Run all plugin functional tests"
+    Rake::TestTask.new(:functionals => :setup_plugin_fixtures) do |t|
+      t.pattern = "vendor/plugins/#{ENV['PLUGIN'] || "**"}/test/functional/**/*_test.rb"
+      t.verbose = true
+    end
+    
+    desc "Integration test engines"
+    Rake::TestTask.new(:integration => :setup_plugin_fixtures) do |t|
+      t.pattern = "vendor/plugins/#{ENV['PLUGIN'] || "**"}/test/integration/**/*_test.rb"
+      t.verbose = true
+    end
+
+    desc "Mirrors plugin fixtures into a single location to help plugin tests"
+    task :setup_plugin_fixtures => :environment do
+      Engines::Testing.setup_plugin_fixtures
+    end
+    
+    # Patch the default plugin testing task to have setup_plugin_fixtures as a prerequisite
+    Rake::Task["test:plugins"].prerequisites << "test:plugins:setup_plugin_fixtures"
+  end  
+end

data/starter-app/vendor/plugins/in_place_editing/README

@@ -0,0 +1,14 @@
+InPlaceEditing
+==============
+
+Example:
+
+  # Controller
+  class BlogController < ApplicationController
+    in_place_edit_for :post, :title
+  end
+
+  # View
+  <%= in_place_editor_field :post, 'title' %>
+
+Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license  

data/starter-app/vendor/plugins/in_place_editing/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test in_place_editing plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for in_place_editing plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'InPlaceEditing'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/starter-app/vendor/plugins/in_place_editing/init.rb

@@ -0,0 +1,2 @@
+ActionController::Base.send :include, InPlaceEditing
+ActionController::Base.helper InPlaceMacrosHelper

data/starter-app/vendor/plugins/in_place_editing/lib/in_place_editing.rb

@@ -0,0 +1,25 @@
+module InPlaceEditing
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # Example:
+  #
+  #   # Controller
+  #   class BlogController < ApplicationController
+  #     in_place_edit_for :post, :title
+  #   end
+  #
+  #   # View
+  #   <%= in_place_editor_field :post, 'title' %>
+  #
+  module ClassMethods
+    def in_place_edit_for(object, attribute, options = {})
+      define_method("set_#{object}_#{attribute}") do
+        @item = object.to_s.camelize.constantize.find(params[:id])
+        @item.update_attribute(attribute, params[:value])
+        render :text => @item.send(attribute).to_s
+      end
+    end
+  end
+end

data/starter-app/vendor/plugins/in_place_editing/lib/in_place_macros_helper.rb

@@ -0,0 +1,71 @@
+module InPlaceMacrosHelper
+  # Makes an HTML element specified by the DOM ID +field_id+ become an in-place
+  # editor of a property.
+  #
+  # A form is automatically created and displayed when the user clicks the element,
+  # something like this:
+  #   <form id="myElement-in-place-edit-form" target="specified url">
+  #     <input name="value" text="The content of myElement"/>
+  #     <input type="submit" value="ok"/>
+  #     <a onclick="javascript to cancel the editing">cancel</a>
+  #   </form>
+  # 
+  # The form is serialized and sent to the server using an AJAX call, the action on
+  # the server should process the value and return the updated value in the body of
+  # the reponse. The element will automatically be updated with the changed value
+  # (as returned from the server).
+  # 
+  # Required +options+ are:
+  # <tt>:url</tt>::       Specifies the url where the updated value should
+  #                       be sent after the user presses "ok".
+  # 
+  # Addtional +options+ are:
+  # <tt>:rows</tt>::              Number of rows (more than 1 will use a TEXTAREA)
+  # <tt>:cols</tt>::              Number of characters the text input should span (works for both INPUT and TEXTAREA)
+  # <tt>:size</tt>::              Synonym for :cols when using a single line text input.
+  # <tt>:cancel_text</tt>::       The text on the cancel link. (default: "cancel")
+  # <tt>:save_text</tt>::         The text on the save link. (default: "ok")
+  # <tt>:loading_text</tt>::      The text to display while the data is being loaded from the server (default: "Loading...")
+  # <tt>:saving_text</tt>::       The text to display when submitting to the server (default: "Saving...")
+  # <tt>:external_control</tt>::  The id of an external control used to enter edit mode.
+  # <tt>:load_text_url</tt>::     URL where initial value of editor (content) is retrieved.
+  # <tt>:options</tt>::           Pass through options to the AJAX call (see prototype's Ajax.Updater)
+  # <tt>:with</tt>::              JavaScript snippet that should return what is to be sent
+  #                               in the AJAX call, +form+ is an implicit parameter
+  # <tt>:script</tt>::            Instructs the in-place editor to evaluate the remote JavaScript response (default: false)
+  # <tt>:click_to_edit_text</tt>::The text shown during mouseover the editable text (default: "Click to edit")
+  def in_place_editor(field_id, options = {})
+    function =  "new Ajax.InPlaceEditor("
+    function << "'#{field_id}', "
+    function << "'#{url_for(options[:url])}'"
+
+    js_options = {}
+    js_options['cancelText'] = %('#{options[:cancel_text]}') if options[:cancel_text]
+    js_options['okText'] = %('#{options[:save_text]}') if options[:save_text]
+    js_options['loadingText'] = %('#{options[:loading_text]}') if options[:loading_text]
+    js_options['savingText'] = %('#{options[:saving_text]}') if options[:saving_text]
+    js_options['rows'] = options[:rows] if options[:rows]
+    js_options['cols'] = options[:cols] if options[:cols]
+    js_options['size'] = options[:size] if options[:size]
+    js_options['externalControl'] = "'#{options[:external_control]}'" if options[:external_control]
+    js_options['loadTextURL'] = "'#{url_for(options[:load_text_url])}'" if options[:load_text_url]        
+    js_options['ajaxOptions'] = options[:options] if options[:options]
+    js_options['evalScripts'] = options[:script] if options[:script]
+    js_options['callback']   = "function(form) { return #{options[:with]} }" if options[:with]
+    js_options['clickToEditText'] = %('#{options[:click_to_edit_text]}') if options[:click_to_edit_text]
+    function << (', ' + options_for_javascript(js_options)) unless js_options.empty?
+    
+    function << ')'
+
+    javascript_tag(function)
+  end
+  
+  # Renders the value of the specified object and method with in-place editing capabilities.
+  def in_place_editor_field(object, method, tag_options = {}, in_place_editor_options = {})
+    tag = ::ActionView::Helpers::InstanceTag.new(object, method, self)
+    tag_options = {:tag => "span", :id => "#{object}_#{method}_#{tag.object.id}_in_place_editor", :class => "in_place_editor_field"}.merge!(tag_options)
+    in_place_editor_options[:url] = in_place_editor_options[:url] || url_for({ :action => "set_#{object}_#{method}", :id => tag.object.id })
+    tag.to_content_tag(tag_options.delete(:tag), tag_options) +
+    in_place_editor(tag_options[:id], in_place_editor_options)
+  end
+end

data/starter-app/vendor/plugins/in_place_editing/test/in_place_editing_test.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../test/test_helper'))
+require 'test/unit'
+
+class InPlaceEditingTest < Test::Unit::TestCase
+  include InPlaceEditing
+  include InPlaceMacrosHelper
+  
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::TextHelper
+  include ActionView::Helpers::FormHelper
+  include ActionView::Helpers::CaptureHelper
+  
+  def setup
+    @controller = Class.new do
+      def url_for(options)
+        url =  "http://www.example.com/"
+        url << options[:action].to_s if options and options[:action]
+        url
+      end
+    end
+    @controller = @controller.new
+  end
+  
+  def test_in_place_editor_external_control
+      assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.InPlaceEditor('some_input', 'http://www.example.com/inplace_edit', {externalControl:'blah'})\n//]]>\n</script>),
+        in_place_editor('some_input', {:url => {:action => 'inplace_edit'}, :external_control => 'blah'})
+  end
+  
+  def test_in_place_editor_size
+      assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.InPlaceEditor('some_input', 'http://www.example.com/inplace_edit', {size:4})\n//]]>\n</script>),
+        in_place_editor('some_input', {:url => {:action => 'inplace_edit'}, :size => 4})
+  end
+  
+  def test_in_place_editor_cols_no_rows
+      assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.InPlaceEditor('some_input', 'http://www.example.com/inplace_edit', {cols:4})\n//]]>\n</script>),
+        in_place_editor('some_input', {:url => {:action => 'inplace_edit'}, :cols => 4})
+  end
+  
+  def test_in_place_editor_cols_with_rows
+      assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.InPlaceEditor('some_input', 'http://www.example.com/inplace_edit', {cols:40, rows:5})\n//]]>\n</script>),
+        in_place_editor('some_input', {:url => {:action => 'inplace_edit'}, :rows => 5, :cols => 40})
+  end
+
+  def test_inplace_editor_loading_text
+      assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.InPlaceEditor('some_input', 'http://www.example.com/inplace_edit', {loadingText:'Why are we waiting?'})\n//]]>\n</script>),
+        in_place_editor('some_input', {:url => {:action => 'inplace_edit'}, :loading_text => 'Why are we waiting?'})
+  end
+  
+  def test_in_place_editor_url
+    assert_match "Ajax.InPlaceEditor('id-goes-here', 'http://www.example.com/action_to_set_value')",
+    in_place_editor( 'id-goes-here', :url => { :action => "action_to_set_value" })    
+  end
+  
+  def test_in_place_editor_load_text_url
+    assert_match "Ajax.InPlaceEditor('id-goes-here', 'http://www.example.com/action_to_set_value', {loadTextURL:'http://www.example.com/action_to_get_value'})",
+    in_place_editor( 'id-goes-here', 
+      :url => { :action => "action_to_set_value" }, 
+      :load_text_url => { :action => "action_to_get_value" })
+  end
+  
+  def test_in_place_editor_eval_scripts
+    assert_match "Ajax.InPlaceEditor('id-goes-here', 'http://www.example.com/action_to_set_value', {evalScripts:true})",
+    in_place_editor( 'id-goes-here', 
+      :url => { :action => "action_to_set_value" }, 
+      :script => true )
+  end
+  
+end

data/starter-app/vendor/plugins/paginating_find/CHANGELOG

@@ -0,0 +1,120 @@
+2008-02-08
+* Count query now uses the :from find option, if specified. Thanks to Rich Wertz.
+
+2007-11-13
+* Removed extraneous statement from collect_count_options. Thanks to Wolfgang Postler.
+
+2007-9-14
+* Count query now respects the distinct keyword if it is included in the :select option.  Thanks to Luke Pearce.
+
+2007-8-25
+* PagingEnumerator#each now returns self.  Thanks to Takeru Sasaki.
+* Addeed #to_xml to the PagingEnumerator.
+
+2007-8-24
+* No longer overwrite the AR #validate_find_options method. Instead just append :page to VALID_FIND_OPTIONS. Thanks for the suggestion Pratik.
+
+2007-7-24
+* Fixed a bug in handling the HAVING having clause. Thanks to Daniel Aborg for the patch!
+* Added support for Array#extract_options! added to Rails edge (9087).  Thanks to Alex Payne!
+* Tests no longer use with_scope since it became protected in Rails edge.
+
+2007-5-7
+* Now uses alias_method_chain. Thanks to Jeremy Larkin for the patch.
+
+2007-4-27
+* PagingEnumerator now supports Marshal.dump and Marshal.load. When marshaled, the enumerator loses its callback, so :auto => true is not supported in this scenario.
+
+2007-02-05
+* :current < 1 is now gracefully handled.  Thanks again to Benjamin Curtis and 21st Century Music.
+
+2007-01-24
+* Added paging_helper that provides paginating_links and paginating_links_each to ActionView::Base. Special thanks to Benjamin Curtis and 21st Century Music (http://21cmusic.com/)!
+
+2007-01-07
+* :first now defaults to 1 rather than the value of :page. Thanks to Jack Baty for bringing this to my attention.
+
+2006-12-28
+* primary_key used to build count select statement rather than "id" column. Thanks to Rich Cox.
+
+2006-12-21
+* Applied another fix to counting with :group option. Special thanks to Ben Weiner.
+* Placed tests for grouping in a separate class.
+
+2006-12-12
+* Removed rails from vendor directory.
+
+2006-11-27
+* For purposes of counting, the HAVING statement is now extracted from the :group option as a convenience for users that are hacking around the lack of a AR#find :having option. Thanks to Gavin Joyce for pointing out this usage of :group. More info here: http://www.mail-archive.com/rails-core@lists.rubyonrails.org/msg01876.html.
+* For purposes of counting, the :select option is now ignored in favor of table_name.id. Thanks to Aron Atkins for reporting a bug that led to this fix.
+
+2006-10-17
+* Count query no longer uses :limit. This option doesn't have the same effect on count as it does on find. The :limit is applied to the count after the query is performed, if necessary.
+* Count query no longer uses :group. Grouping during a count doesn't get any different count than not grouping.
+* Count query no longer uses :order for the same reasons that :group is no longer used.
+
+2006-09-26
+* Change log is now in reverse chronological order
+* Count query now respects :group and :order. Previous changes removing this functionality are no longer applicable.
+
+2006-09-19
+* Added :count option. Using this will cause the plugin to skip the automatic database count query (which can sometimes be slow).
+* The :limit option no longer affects whether the count query will run.
+* Fixed a bug reported by Lisa, where the count query was choking on grouped results. The count query now ignores :group.
+
+2006-09-14
+* Scoping now works correctly, even when enumeration is done outside the #with_scope code block.
+* Added the #empty? method.
+* Added #first_item and #last_item, which return the index of the first and last items on the current page. Thanks, Ilya!
+
+2006-09-10
+* Now works correctly :with_scope, nested :with_scope, and :include.
+* Now correctly counts when querying on through associations.
+* Rewrote paginating_find_test so that it uses real AR::Base models, rather than mocks.
+* Trying out a bare-bones instance of rails in order to run tests without having to install the plugin.
+
+2006-09-10
+* next_page? and previous_page? now return booleans rather than the page number. Thanks, Hammed.
+* next_page and previous_page have been added.
+* The total count now correctly respects conditions, includes, etc.  Thanks, Ilya
+
+2006-09-09
+* ArgumentError is now correctly thrown if options[:offset] is used. Thanks, jonni!
+
+2006-09-08
+* :conditions are now correctly respected when paging is enabled
+* :size now defaults to total number of records if less than ten.
+
+2006-09-06
+* Added #last_page! method. Only works when :auto => true.
+* Added #first_page! method. Only works when :auto => true.
+* Added the #move!(page) method. Only works when :auto => true.
+* Added the #previous_page!(page) method. Only works when :auto => true.
+* Added the #page_exists?(page) method.
+* The #load_page method is no longer protected.
+* Fixed bug in #to_a that was causing :limit to be exceeded.
+* An ArgumentError is now raised if both :page and :offset options are specified
+* The first page and current page can be specified separately, using the :first and :current options respectively.
+* Reversed semantics of automatic pagination. By default, the enumerator will stop after all records on current page. To enumerate all records, pass option :auto => true.
+* :manual_paging is no longer supported.  Use the :auto option instead. :auto defaults to false.
+* All paging options are now specified in a hash, keyed by :page.  This is mostly an aesthetics issue:
+	# The old way:
+    cogs = Cog.find(:all,
+                    :limit => 3000,
+                    :page_size => 10,
+                    :page => 1,
+                    :manual_paging => true)
+
+	# The new way:
+    cogs = Cog.find(:all,
+                    :limit => 3000,
+                    :page => {:size => 10,
+                              :current => 1})
+
+* The following :page options are supported in this revision:
+    :size    => Number of records in each page of results. Defaults to 1/10
+                the total size if total size > 10, otherwise defaults to
+                the total size.
+    :current => The current page. Optional, defaults to the first page: 1.
+    :first   => The first page. Optional, defaults to the current page.
+    :auto    => Automatically load the next page during invocation of #each. Defaults to false.