spree 0.9.4 → 0.10.0.beta

data/vendor/plugins/jrails/rails/init.rb

@@ -0,0 +1,15 @@
+# The following options can be changed by creating an initializer in config/initializers/jrails.rb
+
+# jRails uses jQuery.noConflict() by default
+# to use the default jQuery varibale, use:
+# ActionView::Helpers::PrototypeHelper::JQUERY_VAR = '$'
+
+# ActionView::Helpers::PrototypeHelper:: DISABLE_JQUERY_FORGERY_PROTECTION
+# Set this to disable forgery protection in ajax calls
+# This is handy if you want to use caching with ajax by injecting the forgery token via another means
+# for an example, see http://henrik.nyh.se/2008/05/rails-authenticity-token-with-jquery
+# ActionView::Helpers::PrototypeHelper::DISABLE_JQUERY_FORGERY_PROTECTION = true
+
+ActionView::Helpers::AssetTagHelper::JAVASCRIPT_DEFAULT_SOURCES = ['jquery','jquery-ui','jrails']
+ActionView::Helpers::AssetTagHelper::reset_javascript_include_default
+require 'jrails'

data/vendor/plugins/jrails/tasks/jrails.rake

@@ -0,0 +1,25 @@
+namespace :jrails do
+
+	namespace :js do
+		desc "Copies the jQuery and jRails javascripts to public/javascripts"
+		task :install do
+			puts "Copying files..."
+			project_dir = RAILS_ROOT + '/public/javascripts/'
+			scripts = Dir[File.join(File.dirname(__FILE__), '..', '/javascripts/', '*.js')]
+			FileUtils.cp(scripts, project_dir)
+			puts "files copied successfully."
+		end
+
+    desc 'Remove the prototype / script.aculo.us javascript files'
+    task :scrub do
+      puts "Removing files..."
+      files = %W[controls.js dragdrop.js effects.js prototype.js]
+      project_dir = File.join(RAILS_ROOT, 'public', 'javascripts')
+      files.each do |fname|
+        FileUtils.rm(File.join(project_dir, fname)) if File.exists?(File.join(project_dir, fname))
+      end
+      puts "files removed successfully."
+    end
+  end
+  
+end

data/vendor/plugins/jrails_auto_complete/README

@@ -0,0 +1,23 @@
+JrailsAutoComplete
+==================
+
+This plugin adds autocomplete support to jrails. This plugin works similarly to the build in rails auto complete
+
+
+Example
+=======
+In the controller you can use the macro function as such
+
+class ExampleController < ApplicationController
+    auto_complete_for :fruit, :name
+
+    ...
+end
+
+In your view:
+
+<%= javascript_include_tag 'jquery', 'jrails', 'jquery.suggest' %>
+...
+<%= text_field_with_auto_complete :fruit, :name %>
+
+Copyright (c) 2009 Marty Zalega, released under the MIT license

data/vendor/plugins/jrails_auto_complete/Rakefile

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

data/vendor/plugins/jrails_auto_complete/init.rb

@@ -0,0 +1,2 @@
+ActionController::Base.send :include, JrailsAutoComplete
+ActionController::Base.helper JrailsAutoCompleteMacroHelper

data/vendor/plugins/jrails_auto_complete/install.rb

@@ -0,0 +1,8 @@
+puts "Copying files..."
+dir = "javascripts"
+["jrails.autocomplete.js"].each do |js_file|
+	dest_file = File.join(RAILS_ROOT, "public", dir, js_file)
+	src_file = File.join(File.dirname(__FILE__) , dir, js_file)
+	FileUtils.cp_r(src_file, dest_file)
+end
+puts "Files copied - Installation complete!"

data/vendor/plugins/jrails_auto_complete/javascripts/jquery.suggest.js

@@ -0,0 +1,276 @@
+	
+	/*
+	 *	jquery.suggest 1.1 - 2007-08-06
+	 *	
+	 *	Uses code and techniques from following libraries:
+	 *	1. http://www.dyve.net/jquery/?autocomplete
+	 *	2. http://dev.jquery.com/browser/trunk/plugins/interface/iautocompleter.js	
+	 *
+	 *	All the new stuff written by Peter Vulgaris (www.vulgarisoip.com)	
+	 *	Feel free to do whatever you want with this file
+	 *
+	 */
+	
+	(function($) {
+        var defaults = {
+          delay: 100,
+          resultsClass: 'jquery-suggestion-results',
+          selectClass: 'jquery-suggestion-select',
+          matchClass: 'jquery-suggestion-match',
+          minchars: 2,
+          onSelect: function($input, $result) {
+              $input.val($result.data('autocomplete:value'));
+          },
+          maxCacheSize: 65536,
+          source: '',
+          method: 'get',
+          dataType: 'json',
+          params: '',
+          queryParam: 'q'
+        };
+
+		$.suggest = function(input, options) {
+            options = $.extend({}, defaults, options);
+
+			var $input = $(input).attr("autocomplete", "off");
+			var $results = $('<ul></ul>');
+
+			var timeout = false;		// hold timeout ID for suggestion results to appear	
+			var prevLength = 0;			// last recorded length of $input.val()
+			var cache = [];				// cache MRU list
+			var cacheSize = 0;			// size of cache in chars (bytes?)
+			
+			$results.addClass(options.resultsClass).appendTo('body').hide();
+
+			resetPosition();
+			$(window)
+				.load(resetPosition)		// just in case user is changing size of page while loading
+				.resize(resetPosition);
+
+			$input.blur(function() {
+				setTimeout(function() { $results.hide() }, 200);
+			});
+			
+			// help IE users if possible
+			if ($results.bgiframe) $results.bgiframe();
+
+			// I really hate browser detection, but I don't see any other way
+			if ($.browser.mozilla)
+				$input.keypress(processKey);	// onkeypress repeats arrow keys in Mozilla/Opera
+			else
+				$input.keydown(processKey);		// onkeydown repeats arrow keys in IE/Safari
+
+			function resetPosition() {
+				// requires jquery.dimension plugin
+				var offset = $input.offset();
+				$results.css({
+					top: (offset.top + input.offsetHeight) + 'px',
+					left: offset.left + 'px'
+				});
+			}
+			
+			function processKey(e) {
+				// handling up/down/escape requires results to be visible
+				// handling enter/tab requires that AND a result to be selected
+				if ((/27$|38$|40$/.test(e.keyCode) && $results.is(':visible')) ||
+					(/^13$|^9$/.test(e.keyCode) && getCurrentResult())) {
+		            
+		            if (e.preventDefault)
+		                e.preventDefault();
+					if (e.stopPropagation)
+		                e.stopPropagation();
+
+					e.cancelBubble = true;
+					e.returnValue = false;
+				
+					switch(e.keyCode) {
+						case 38: // up
+							prevResult();
+							break;
+						case 40: // down
+							nextResult();
+							break;
+						case 9:  // tab
+						case 13: // return
+							selectCurrentResult();
+							break;
+						case 27: //	escape
+							$results.hide();
+							break;
+					}
+				}
+                else if ($input.val().length != prevLength) {
+					if (timeout) 
+						clearTimeout(timeout);
+					timeout = setTimeout(suggest, options.delay);
+					prevLength = $input.val().length;
+				}			
+			}
+			
+			function suggest() {
+				var q = $.trim($input.val());
+
+				if (q.length >= options.minchars) {
+					cached = checkCache(q);
+					if (cached) {
+						displayItems(cached['items']);
+					}
+                    else {
+                        var params = options.queryParam + '=' + q + (options.params.length ? '&' + options.params : '');
+                        $.ajax({
+                           type: options.method,
+                           url: options.source,
+                           dataType: options.dataType,
+                           data: params,
+                           success: function(data) {
+                               $results.hide();
+
+                               displayItems(data);
+                               addToCache(q, data);
+                           },
+                           error: function(xmlhttp, text) {
+                               $results.hide();
+                               alert(text);
+                           }
+                        });
+					}
+				}
+                else {
+					$results.hide();
+				}
+			}
+			
+			function checkCache(q) {
+				for (var i = 0; i < cache.length; i++)
+					if (cache[i]['q'] == q) {
+						cache.unshift(cache.splice(i, 1)[0]);
+						return cache[0];
+					}
+				return false;
+			}
+			
+			function addToCache(q, items) {
+                var size = 0;
+                $.each(items, function() {
+                   ++size;
+                });
+
+				while (cache.length && (cacheSize + size > options.maxCacheSize)) {
+					var cached = cache.pop();
+					cacheSize -= cached['size'];
+				}
+				
+				cache.push({
+					q: q,
+					size: size,
+					items: items
+				});
+				cacheSize += size;
+			}
+			
+			function displayItems(items) {
+				if (!items)
+					return;
+				var empty = true;
+                $results.empty();
+				$.each(items, function(value, display) {
+                    var $item = $('<li></li>').html(display).data('autocomplete:value', value);
+                    $results.append($item);
+                    empty = false;
+                });
+
+                if (empty) {
+					$results.hide();
+					return;
+				}
+
+                resetPosition();
+				$results
+                    .width($input.width())
+                    .show()
+					.children('li')
+					.mouseover(function() {
+						$results.children('li').removeClass(options.selectClass);
+						$(this).addClass(options.selectClass);
+					})
+					.click(function(e) {
+						e.preventDefault(); 
+						e.stopPropagation();
+						selectCurrentResult();
+					});		
+			}
+			
+			function parseTxt(txt, q) {
+				var items = [];
+				var tokens = txt.split(options.delimiter);
+				
+				// parse returned data for non-empty items
+				for (var i = 0; i < tokens.length; i++) {
+					var token = $.trim(tokens[i]);
+					if (token) {
+						token = token.replace(
+							new RegExp(q, 'ig'), 
+							function(q) { return '<span class="' + options.matchClass + '">' + q + '</span>' }
+							);
+						items[items.length] = token;
+					}
+				}
+				return items;
+			}
+			
+			function getCurrentResult() {
+				if (!$results.is(':visible'))
+					return false;
+			
+				var $currentResult = $results.children('li.' + options.selectClass);
+				if (!$currentResult.length)
+					$currentResult = false;
+					
+				return $currentResult;
+			}
+			
+			function selectCurrentResult() {
+				$currentResult = getCurrentResult();
+			
+				if ($currentResult) {
+                    options.onSelect.call(this, $input, $currentResult);
+					$results.hide();
+				}
+			}
+			
+			function nextResult() {
+				$currentResult = getCurrentResult();
+			
+				if ($currentResult)
+					$currentResult
+						.removeClass(options.selectClass)
+						.next()
+							.addClass(options.selectClass);
+				else
+					$results.children('li:first-child').addClass(options.selectClass);
+			}
+			
+			function prevResult() {
+				$currentResult = getCurrentResult();
+			
+				if ($currentResult)
+					$currentResult
+						.removeClass(options.selectClass)
+						.prev()
+							.addClass(options.selectClass);
+				else
+					$results.children('li:last-child').addClass(options.selectClass);
+			}
+		}
+		
+		$.fn.suggest = function(source, options) {
+			if (!source)
+				return;
+            options.source = source;
+			this.each(function() {
+				new $.suggest(this, options);
+			});
+			return this;
+		};
+	})(jQuery);
+	

data/vendor/plugins/jrails_auto_complete/javascripts/jrails.autocomplete.js

@@ -0,0 +1,274 @@
+(function($) {
+    function stopEvent(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        e.stopped = true;
+    }
+
+    function getFirstDifferencePos(newS, oldS) {
+        var boundary = Math.min(newS.length, oldS.length);
+        for (var index = 0; index < boundary; ++index)
+            if (newS[index] != oldS[index]) return index;
+        return boundary;
+    }
+
+    var AutoComplete = function(element, update, url, options) {
+        var autocomplete        = this;
+
+        this.element            = element;
+        this.url                = url;
+        this.update             = update;
+        this.hasFocus           = false;
+        this.changed            = false;
+        this.active             = false;
+        this.index              = 0;
+        this.entryCount         = 0;
+        this.oldElementValue    = this.element.value;
+        this.observer           = null;
+        this.options = $.extend({
+            paramName: this.element.name,
+            type: 'GET',
+            tokens: [],
+            frequency: 0.4,
+            minChars: 1,
+            onShow: function(element, update) {
+                if (!update.style.position || update.style.position == 'absolute') {
+                    var position = $(element).position();
+                    $(update).css({
+                       position: 'absolute',
+                       left: position.left + 'px',
+                       top: $(element).outerHeight() + position.top + 'px',
+                       width: $(element).outerWidth() + 'px'
+                    });
+                }
+                $(update).fadeIn();
+            },
+            onHide: function(element, update) {
+                $(update).fadeOut();
+            }
+        }, options);
+
+        if (typeof(this.options.tokens) == 'string') {
+            this.options.tokens = new Array(this.options.tokens);
+        }
+        if (!$.inArray("\n", this.options.tokens)) {
+            this.options.tokens.push("\n");
+        }
+
+        $(this.update).hide();
+        $(this.element).attr('autocomplete', 'off')
+        .blur(function(e) { autocomplete.onBlur(e); })
+        .keypress(function(e) { autocomplete.onKeyPress(e); });
+    }
+    $.extend(AutoComplete.prototype, {
+        show: function() {
+            if ($(this.update).not(':visible')) this.options.onShow(this.element, this.update);
+        },
+        hide: function() {
+            this.stopIndicator();
+            if ($(this.update).is(':visible')) this.options.onHide(this.element, this.update);
+        },
+        startIndicator: function() {
+            if (this.options.indicator) $('#' + this.options.indicator).show();
+        },
+        stopIndicator: function() {
+            if (this.options.indicator) $('#' + this.options.indicator).hide();
+        },
+        onKeyPress: function(e) {
+            var autocomplete = this;
+
+            if (this.active) {
+                switch (e.keyCode) {
+                    case 9:     // tab
+                    case 13:    // return
+                        this.selectEntry();
+                        stopEvent(e);
+                    case 27:    // esc
+                        this.hide();
+                        this.active = false;
+                        stopEvent(e);
+                    case 37:    // left
+                    case 39:    // right
+                        return;
+                    case 38:    // up
+                        this.markPrevious();
+                        this.render();
+                        stopEvent(e);
+                        return;
+                    case 40:    // down
+                        this.markNext();
+                        this.render();
+                        stopEvent(e);
+                        return;
+                }
+            }
+            else if (e.keyCode == 9 || e.keyCode == 13) return;
+
+            this.changed = this.hasFocus = true;
+            if (this.observer) clearTimeout(this.observer);
+            this.observer = setTimeout(function() { autocomplete.onObserverEvent(); }, this.options.frequency * 1000);
+        },
+        activate: function() {
+            this.changed = false;
+            this.hasFocus = true;
+            this.getUpdatedChoices();
+        },
+        onHover: function(e) {
+            if (this.index != e.target.autocompleteIndex) {
+                this.index = e.target.autocompleteIndex;
+                this.render();
+            }
+            stopEvent(e);
+        },
+        onClick: function(e) {
+            this.index = e.target.autocompleteIndex;
+            this.selectEntry();
+            this.hide();
+        },
+        onBlur: function(e) {
+            var autocomplete = this;
+            setTimeout(function() { autocomplete.hide(); }, 250);
+            this.active = this.hasFocus = false;
+        },
+        render: function() {
+            if (this.entryCount > 0) {
+                for (var i = 0; i < this.entryCount; ++i) {
+                    $(this.getEntry(i))[this.index == i ? 'addClass' : 'removeClass']('selected');
+                }
+                if (this.hasFocus) {
+                    this.show();
+                    this.active = true;
+                }
+            }
+            else {
+                this.active = false;
+                this.hide();
+            }
+        },
+        markPrevious: function() {
+            if (this.index > 0) --this.index;
+            else this.index = this.entryCount - 1;
+        },
+        markNext: function() {
+            if (this.index < this.entryCount - 1) ++this.index;
+            else this.index = 0;
+        },
+        getEntry: function(i) {
+            return $(this.update.firstChild).children('li').get(i);
+        },
+        getCurrentEntry: function() {
+            return this.getEntry(this.index);
+        },
+        selectEntry: function() {
+            this.active = false;
+            this.updateElement(this.getCurrentEntry());
+        },
+        updateElement: function(element) {
+            if (this.options.updateElement) {
+                this.options.updateElement(element);
+                return;
+            }
+
+            var value = $.trim(this.options.select ?
+                $('.' + this.options.select, element).text() :
+                $(element).text());
+
+            var bounds = this.getTokenBounds();
+            if (bounds[0] != -1) {
+                var newValue = this.element.value.substr(0, bounds[0]);
+                var whitespace = this.element.value.substr(bounds[0]).match(/^\s+/);
+                if (whitespace) newValue += whitespace[0];
+                this.element.value = newValue + value + this.element.value.substr(bounds[1]);
+            }
+            else {
+                this.element.value = value;
+            }
+
+            this.oldElementValue = $(this.element).focus().val();
+
+            if (this.options.afterUpdateElement) this.options.afterUpdateElement(this.element, element);
+        },
+        updateChoices: function(choices) {
+            if (!this.changed && this.hasFocus) {
+                $(this.update).html($.trim(choices));
+                var i = 0, autocomplete = this;
+                this.entryCount = $(this.update.firstChild).children('li').each(function() {
+                    this.autocompleteIndex = i++;
+                    autocomplete.addObservers(this);
+                }).length;
+            }
+
+            this.stopIndicator();
+            this.index = 0;
+
+            if (this.entryCount == 1 && this.options.autoSelect) {
+                this.selectEntry();
+                this.hide();
+            }
+            else {
+                this.render();
+            }
+        },
+        addObservers: function(element) {
+            var autocomplete = this;
+            $(element)
+                .mouseover(function(e) { autocomplete.onHover(e); })
+                .click(function(e) { autocomplete.onClick(e); });
+        },
+        onObserverEvent: function() {
+            this.changed = false;
+            this.tokenBounds = null;
+            if (this.getToken().length >= this.options.minChars) {
+                this.getUpdatedChoices();
+            }
+            else {
+                this.active = false;
+                this.hide();
+            }
+            this.oldElementValue = this.element.value;
+        },
+        getToken: function() {
+            var bounds = this.getTokenBounds();
+            return $.trim(this.element.value.substring(bounds[0], bounds[1]));
+        },
+        getTokenBounds: function() {
+            if (null != this.tokenBounds) return this.tokenBounds;
+            var value = $.trim(this.element.value);
+            if (!value.length) return [-1, 0];
+            var diff = getFirstDifferencePos(value, this.oldElementValue);
+            var offset = (diff == this.oldElementValue.length ? 1 : 0);
+            var prevTokenPos = -1, nextTokenPos = value.length;
+            for (var tp = null, index = 0, l = this.options.tokens.length; index < l; ++index) {
+                tp = value.lastIndexOf(this.options.tokens[index], diff + offset - 1);
+                if (tp > prevTokenPos) prevTokenPos = tp;
+                tp = value.indexOf(this.options.tokens[index], diff + offset);
+                if (-1 != tp && tp < nextTokenPos) nextTokenPos = tp;
+            }
+            return (this.tokenBounds = [prevTokenPos + 1, nextTokenPos]);
+        },
+        getUpdatedChoices: function() {
+            this.startIndicator();
+
+            var autocomplete = this, entry = encodeURIComponent(this.options.paramName) + '=' + encodeURIComponent(this.getToken());
+            this.options.data = this.options.callback ? this.options.callback(this.element, entry) : entry;
+
+            if (this.options.defaultParams) this.options.data += '&' + this.options.defaultParams;
+            var ajaxOptions = $.extend({}, this.options, {
+                url: this.url,
+                success: function(data, status) {
+                    autocomplete.updateChoices(data);
+                }
+            });
+            $.ajax(ajaxOptions);
+        }
+    });
+
+    $.fn.autocomplete = function(options) {
+        var update = $('#' + options.update).get(0), url = options.url;
+        options.update = options.url = undefined;
+        this.filter(':text').each(function() {
+            new AutoComplete(this, update, url, options);
+        });
+        return this;
+    }
+})(jQuery);