jquery_kwicks_rails 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8fd23e562a03dcdd9c94ee5b0f873b88544213e1
+  data.tar.gz: d6ad753fb99570c75f1a8af96239b3020a118d0c
+SHA512:
+  metadata.gz: c828c3e7dc01257ec6858fcdadac03d24dd1e2ccd8610c147c9424b964b71ee02b03d2b3cbdfbd45a9f6132b5251a26d5279baf2f0422a0d15aa1f2fa052daf3
+  data.tar.gz: ddaf9ebc82709b103670b9db87b066c30748b0e9bb57260ce9d661e3522e3f2507525c73fcde43f6d5c758a9668a4eef4264f0e12ddc765b920fec68f94e2ea0

data/.gitignore

@@ -0,0 +1,3 @@
+.bundle/
+.yardoc
+*.gem

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 1.0.0 (July 21, 2013)
+
+* initial release

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Guillermo Guerrero
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,164 @@
+# Kwicks for RubyOnRails
+A *Rails* plugin for having <b>Sexy Sliding Panels</b> on your application. 
+
+## Installation
+You can install this *gem* by
+
+```
+$ gem install jquery_kwicks_rails
+```
+
+Or bundle it on your app by adding this line at your *Gemfile*
+
+```ruby
+gem "jquery_kwicks_rails"
+```
+    
+
+## Get Started
+Add this to your *app/assets/javascripts/application.js* file
+
+```
+//= require kwicks
+```
+
+And this to your *app/assets/stylesheets/application.css* file
+
+```
+*= require kwicks
+```
+
+You're ready. All the *Kwicks* *JQuery* methods are available now.
+See [here](http://devsmash.com/projects/kwicks) some usage examples.
+
+## View Helpers
+This *gem* adds some view helpers to your app so you can create the HTML that kwicks 
+expect with easy.
+
+#### Horizontal panels
+
+```rhtml
+<%= kwicks do %>
+  <%= kwicks_panel %>
+  <%= kwicks_panel %>
+  <%= kwicks_panel %>
+<% end %>
+```
+
+
+#### Horizontal panels with some content.
+
+```rhtml
+<%= kwicks do %>
+  <%= kwicks_panel do %>
+    <%= link_to image_tag('image01.png'), a_path %>
+  <% end %>
+  <%= kwicks_panel do %>
+    <%= link_to image_tag('image02.png'), b_path %>
+  <% end %>
+  <%= kwicks_panel do %>
+    <%= link_to image_tag('image03.png'), c_path %>
+  <% end %>
+<% end %>
+```
+
+#### Vertical panels
+
+```rhtml
+<%= kwicks(orientation: 'vertical') do %>
+  <%= kwicks_panel %>
+  <%= kwicks_panel %>
+  <%= kwicks_panel %>
+<% end %>
+```
+
+Or
+
+```rhtml
+<%= kwicks_vertical do %>
+  <%= kwicks_panel %>
+  <%= kwicks_panel %>
+  <%= kwicks_panel %>
+<% end %>
+```
+
+
+#### Multidimensional kwicks!
+
+```rhtml
+<%= kwicks(id: "the_kwicks", class: "kwicks-rows", orientation: "vertical") do %>
+  <%= kwicks_panel do %>
+    <%= kwicks(class: "kwicks-columns") do %>
+      <%= kwicks_panel %>
+      <%= kwicks_panel %>
+      <%= kwicks_panel %>
+    <% end %>
+  <% end %>
+  <%= kwicks_panel do %>
+    <%= kwicks(class: "kwicks-columns") do %>
+      <%= kwicks_panel %>
+      <%= kwicks_panel %>
+      <%= kwicks_panel %>
+    <% end %>
+  <% end %>
+<% end %>
+```
+
+Where *styling* should look like:
+
+```scss
+.kwicks-rows {
+  width: 910px;
+  height: 555px;
+
+  .kwicks-panel {
+    width: 100%;
+
+    /* overridden by kwicks but good for when JavaScript is disabled */
+    height: 275px;
+    margin-top: 5px;
+  }
+}
+
+.kwicks-columns {
+  width: 100%;
+  height: 100%;
+
+  .kwicks-panel {
+    height: 100%;
+
+    /* overridden by kwicks but good for when JavaScript is disabled */
+    width: 300px;
+    margin-left: 5px;
+    float: left;
+
+    background-color: #23a543;
+  }
+}
+```
+
+And the *CoffeeScript* should look like:
+
+```coffeescript
+$(document).ready ->
+  $(".kwicks-rows").kwicks
+    maxSize: 400
+    behavior: 'menu'
+    spacing: 5
+    isVertical: true
+$(".kwicks-columns").kwicks
+    maxSize: 600
+    behavior: 'menu'
+    spacing: 5
+```
+
+
+## The *Easing* Plugin
+Go to [JQuery Easing site](http://gsgd.co.uk/sandbox/jquery/easing/) for more info about easing plugin.
+
+## The *Kwicks* Project
+Go to [Kwicks project site](http://devsmash.com/projects/kwicks) for more info and examples.
+Navigate [GitHub Kwicks Project](https://github.com/jmar777/kwicks) for source code.
+
+## License
+This project uses [*MIT-LICENSE*](http://en.wikipedia.org/wiki/MIT_License).

data/jquery_kwicks_rails.gemspec

@@ -0,0 +1,28 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "jquery_kwicks_rails/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "jquery_kwicks_rails"
+  s.version     = JqueryKwicksRails::VERSION
+  s.authors     = ["Guillermo Guerrero"]
+  s.email       = ["g.guerrero.bus@gmail.com"]
+  s.homepage    = "https://github.com/gguerrero/jquery_kwicks_rails"
+  s.license     = 'MIT'
+  s.summary     = "JQuery Sexy Sliding Panels for Rails apps"
+  s.description = %(The JQuery Sexy Sliding Panels for Rails 
+                    applications).strip.gsub(/\s{2,}/, ' ')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = Dir["test/**/*"]
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w[ README.md MIT-LICENSE ]
+  s.rdoc_options    += %w[ --title "JQuery Sexy Sliding Panels for Rails"
+                           --inline-source ]
+
+  s.add_dependency "rails", ">= 3.1"
+  s.add_dependency "jquery-rails", ">= 2.0.2"
+end

data/lib/jquery_kwicks_rails/engine.rb

@@ -0,0 +1,4 @@
+module JqueryKwicksRails
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/jquery_kwicks_rails/helper.rb

@@ -0,0 +1,26 @@
+module JqueryKwicksRails
+  module ViewHelpers
+    def kwicks(opts = {})
+      orientation = opts.delete(:orientation)
+      orientation = (orientation == "vertical") ? "vertical" : "horizontal"
+
+      opts[:class] = "#{opts[:class]} kwicks kwicks-#{orientation}".strip
+      content_tag(:ul, opts) { yield }
+    end
+
+    def kwicks_horizontal(opts = {}, &block)
+      kwicks(opts.merge(orientation: "horizontal"), &block)
+    end
+
+    def kwicks_vertical(opts = {}, &block)
+      kwicks(opts.merge(orientation: "vertical"), &block)
+    end
+
+    def kwicks_panel(opts = {})
+      opts[:class] = "#{opts[:class]} kwicks-panel".strip
+
+      (block_given?) ? content_tag(:li, opts) {yield} 
+                     : content_tag(:li, nil, opts)
+    end
+  end
+end

data/lib/jquery_kwicks_rails/version.rb

@@ -0,0 +1,3 @@
+module JqueryKwicksRails
+  VERSION = "1.0.0"
+end

data/lib/jquery_kwicks_rails.rb

@@ -0,0 +1,5 @@
+require 'jquery_kwicks_rails/version'
+require 'jquery_kwicks_rails/engine'
+require 'jquery_kwicks_rails/helper'
+
+ActionView::Base.send(:include, JqueryKwicksRails::ViewHelpers)

data/vendor/assets/javascripts/kwicks/index.js

@@ -0,0 +1,4 @@
+// Kwicks and Easing Javascripts are loaded on this file.
+//
+//= require jquery
+//= require_tree .

data/vendor/assets/javascripts/kwicks/jquery.easing.1.3.js

@@ -0,0 +1,205 @@
+/*
+ * jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/
+ *
+ * Uses the built in easing capabilities added In jQuery 1.1
+ * to offer multiple easing options
+ *
+ * TERMS OF USE - jQuery Easing
+ * 
+ * Open source under the BSD License. 
+ * 
+ * Copyright © 2008 George McGinley Smith
+ * 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 author nor the names of 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. 
+ *
+*/
+
+// t: current time, b: begInnIng value, c: change In value, d: duration
+jQuery.easing['jswing'] = jQuery.easing['swing'];
+
+jQuery.extend( jQuery.easing,
+{
+	def: 'easeOutQuad',
+	swing: function (x, t, b, c, d) {
+		//alert(jQuery.easing.default);
+		return jQuery.easing[jQuery.easing.def](x, t, b, c, d);
+	},
+	easeInQuad: function (x, t, b, c, d) {
+		return c*(t/=d)*t + b;
+	},
+	easeOutQuad: function (x, t, b, c, d) {
+		return -c *(t/=d)*(t-2) + b;
+	},
+	easeInOutQuad: function (x, t, b, c, d) {
+		if ((t/=d/2) < 1) return c/2*t*t + b;
+		return -c/2 * ((--t)*(t-2) - 1) + b;
+	},
+	easeInCubic: function (x, t, b, c, d) {
+		return c*(t/=d)*t*t + b;
+	},
+	easeOutCubic: function (x, t, b, c, d) {
+		return c*((t=t/d-1)*t*t + 1) + b;
+	},
+	easeInOutCubic: function (x, t, b, c, d) {
+		if ((t/=d/2) < 1) return c/2*t*t*t + b;
+		return c/2*((t-=2)*t*t + 2) + b;
+	},
+	easeInQuart: function (x, t, b, c, d) {
+		return c*(t/=d)*t*t*t + b;
+	},
+	easeOutQuart: function (x, t, b, c, d) {
+		return -c * ((t=t/d-1)*t*t*t - 1) + b;
+	},
+	easeInOutQuart: function (x, t, b, c, d) {
+		if ((t/=d/2) < 1) return c/2*t*t*t*t + b;
+		return -c/2 * ((t-=2)*t*t*t - 2) + b;
+	},
+	easeInQuint: function (x, t, b, c, d) {
+		return c*(t/=d)*t*t*t*t + b;
+	},
+	easeOutQuint: function (x, t, b, c, d) {
+		return c*((t=t/d-1)*t*t*t*t + 1) + b;
+	},
+	easeInOutQuint: function (x, t, b, c, d) {
+		if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b;
+		return c/2*((t-=2)*t*t*t*t + 2) + b;
+	},
+	easeInSine: function (x, t, b, c, d) {
+		return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
+	},
+	easeOutSine: function (x, t, b, c, d) {
+		return c * Math.sin(t/d * (Math.PI/2)) + b;
+	},
+	easeInOutSine: function (x, t, b, c, d) {
+		return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
+	},
+	easeInExpo: function (x, t, b, c, d) {
+		return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b;
+	},
+	easeOutExpo: function (x, t, b, c, d) {
+		return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
+	},
+	easeInOutExpo: function (x, t, b, c, d) {
+		if (t==0) return b;
+		if (t==d) return b+c;
+		if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b;
+		return c/2 * (-Math.pow(2, -10 * --t) + 2) + b;
+	},
+	easeInCirc: function (x, t, b, c, d) {
+		return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
+	},
+	easeOutCirc: function (x, t, b, c, d) {
+		return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
+	},
+	easeInOutCirc: function (x, t, b, c, d) {
+		if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
+		return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
+	},
+	easeInElastic: function (x, t, b, c, d) {
+		var s=1.70158;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var s = p/(2*Math.PI) * Math.asin (c/a);
+		return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
+	},
+	easeOutElastic: function (x, t, b, c, d) {
+		var s=1.70158;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var s = p/(2*Math.PI) * Math.asin (c/a);
+		return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
+	},
+	easeInOutElastic: function (x, t, b, c, d) {
+		var s=1.70158;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) p=d*(.3*1.5);
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var s = p/(2*Math.PI) * Math.asin (c/a);
+		if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
+		return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b;
+	},
+	easeInBack: function (x, t, b, c, d, s) {
+		if (s == undefined) s = 1.70158;
+		return c*(t/=d)*t*((s+1)*t - s) + b;
+	},
+	easeOutBack: function (x, t, b, c, d, s) {
+		if (s == undefined) s = 1.70158;
+		return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
+	},
+	easeInOutBack: function (x, t, b, c, d, s) {
+		if (s == undefined) s = 1.70158; 
+		if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
+		return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
+	},
+	easeInBounce: function (x, t, b, c, d) {
+		return c - jQuery.easing.easeOutBounce (x, d-t, 0, c, d) + b;
+	},
+	easeOutBounce: function (x, t, b, c, d) {
+		if ((t/=d) < (1/2.75)) {
+			return c*(7.5625*t*t) + b;
+		} else if (t < (2/2.75)) {
+			return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
+		} else if (t < (2.5/2.75)) {
+			return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
+		} else {
+			return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
+		}
+	},
+	easeInOutBounce: function (x, t, b, c, d) {
+		if (t < d/2) return jQuery.easing.easeInBounce (x, t*2, 0, c, d) * .5 + b;
+		return jQuery.easing.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b;
+	}
+});
+
+/*
+ *
+ * TERMS OF USE - EASING EQUATIONS
+ * 
+ * Open source under the BSD License. 
+ * 
+ * Copyright © 2001 Robert Penner
+ * 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 author nor the names of 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. 
+ *
+ */

data/vendor/assets/javascripts/kwicks/jquery.kwicks.js

@@ -0,0 +1,570 @@
+/*!
+ *  Kwicks: Sexy Sliding Panels for jQuery - v2.1.0
+ *  http://devsmash.com/projects/kwicks
+ *
+ *  Copyright 2013 Jeremy Martin (jmar777)
+ *  Contributors: Duke Speer (Duke3D), Guillermo Guerrero (gguerrero)
+ *  Released under the MIT license
+ *  http://www.opensource.org/licenses/mit-license.php
+ */
+
+(function($) {
+
+	/**
+	 *  API methods for the plugin
+	 */
+	var methods = {
+		init: function(opts) {
+			var defaults = {
+				maxSize: -1,
+				minSize: -1,
+				spacing: 5,
+				duration: 500,
+				isVertical: false,
+				easing: undefined,
+				behavior: null,
+				autoResize: true,
+				showSpeed: undefined
+			};
+			var o = $.extend(defaults, opts);
+
+			// validate and normalize options
+			if (o.minSize !== -1 && o.maxSize !== -1)
+				throw new Error('Kwicks options minSize and maxSize may not both be set');
+			if (o.behavior && o.behavior !== 'menu' && o.behavior !== 'slideshow')
+				throw new Error('Unrecognized Kwicks behavior specified: ' + o.behavior);
+			$.each(['minSize', 'maxSize'], function(i, prop) {
+				var val = o[prop];
+				switch (typeof val) {
+					case 'number':
+						o[prop + 'Units'] = 'px';
+						break;
+					case 'string':
+						if (val.slice(-1) === '%') {
+							o[prop + 'Units'] = '%';
+							o[prop] = +val.slice(0, -1) / 100;
+						} else if (val.slice(-2) === 'px') {
+							o[prop + 'Units'] = 'px';
+							o[prop] = +val.slice(0, -2);	
+						} else {
+							throw new Error('Invalid value for Kwicks option ' + prop + ': ' + val);
+						}
+						break;
+					default:
+						throw new Error('Invalid value for Kwicks option ' + prop + ': ' + val);
+				}
+			});
+						
+			return this.each(function() {
+				$(this).data('kwicks', new Kwick(this, o));
+			});
+		},
+		expand: function(index) {
+			return this.each(function() {
+				var $this = $(this),
+					$panel;
+
+				// if this is a container, then we require a panel index
+				if ($this.is('.kwicks-processed')) {
+					if (typeof index !== 'number')
+						throw new Error('Kwicks method "expand" requires an index');
+					// protect against jquery's eq(-index) feature
+					if (index >= 0) $panel = $this.children().eq(index);
+				}
+				// otherwise `this` should be a panel already
+				else if ($this.parent().is('.kwicks-processed')) {
+					// don't need panel in this scenario
+					$panel = $this;
+					index = $panel.index();
+				}
+				// if it's not a container or a panel, then this was an erroneous method call
+				else {
+					throw new Error('Cannot call "expand" method on a non-Kwicks element');
+				}
+
+				// try to trigger on panel, but default to container if panel doesn't exist
+				var $target = ($panel && $panel.length) ? $panel : $this;
+				$target.trigger('expand.kwicks', { index: index });				
+			});
+		},
+		expanded: function() {
+			var kwick = this.first().data('kwicks');
+			if (!kwick) throw new Error('Cannot called "expanded" method on a non-Kwicks element');
+			return kwick.expandedIndex;
+		},
+		select: function(index) {
+			return this.each(function() {
+				var $this = $(this),
+					$panel;
+
+				// if this is a container, then we require a panel index
+				if ($this.is('.kwicks-processed')) {
+					if (typeof index !== 'number')
+						throw new Error('Kwicks method "select" requires an index');
+					// protect against jquery's eq(-index) feature
+					if (index >= 0) $panel = $this.children().eq(index);
+				}
+				// otherwise `this` should be a panel already
+				else if ($this.parent().is('.kwicks-processed')) {
+					// don't need panel in this scenario
+					$panel = $this;
+					index = $panel.index();
+				}
+				// if it's not a container or a panel, then this was an erroneous method call
+				else {
+					throw new Error('Cannot call "expand" method on a non-Kwicks element');
+				}
+
+				// try to trigger on panel, but default to container if panel doesn't exist
+				var $target = ($panel && $panel.length) ? $panel : $this;
+				$target.trigger('select.kwicks', { index: index });				
+			});
+		},
+		selected: function() {
+			var kwick = this.first().data('kwicks');
+			if (!kwick) throw new Error('Cannot called "selected" method on a non-Kwicks element');
+			return kwick.selectedIndex;
+		},
+		resize: function(index) {
+			return this.each(function() {
+				var $this = $(this),
+					kwick = $this.data('kwicks');
+
+				if (!kwick) {
+					throw new Error('Cannot called "resize" method on a non-Kwicks element');
+				}
+
+				kwick.resize();			
+			});
+		}
+	};
+
+	/**
+	 *  Expose the actual plugin
+	 */
+	$.fn.kwicks = function(opts) {
+		if (methods[opts]) {
+			return methods[opts].apply(this, Array.prototype.slice.call(arguments, 1));
+		} else if (typeof opts === 'object' || !opts) {
+			return methods.init.apply(this, arguments);
+		} else {
+			throw new Error('Unrecognized kwicks method: ' + opts);
+		}
+	};
+
+	/**
+	 *  Special event for triggering default behavior on 'expand.kwicks' events
+	 */
+	$.event.special.expand = {
+		_default: function(e, data) {
+			if (e.namespace !== 'kwicks') return;
+			var $el = $(e.target);
+			var kwick = $el.data('kwicks') || $el.parent().data('kwicks');
+			// should we throw here?
+			if (!kwick) return;
+			kwick.expand(data.index);
+		}
+	};
+
+	/**
+	 *  Special event for triggering default behavior on 'select.kwicks' events
+	 */
+	$.event.special.select = {
+		_default: function(e, data) {
+			if (e.namespace !== 'kwicks') return;
+			var $el = $(e.target);
+			var kwick = $el.data('kwicks') || $el.parent().data('kwicks');
+			// should we throw here?
+			if (!kwick) return;
+			kwick.select(data.index);
+		}
+	};
+
+	/**
+	 *  Instantiates a new Kwick instance using the provided container and options.
+	 */
+	var Kwick = function Kwick(container, opts) {
+		this.opts = opts;
+
+		// references to our DOM elements
+		var orientation = opts.isVertical ? 'vertical' : 'horizontal';
+		this.$container = $(container).addClass('kwicks').addClass('kwicks-' + orientation);
+		this.$panels = this.$container.children();
+
+		// zero-based, -1 for "none"
+		this.selectedIndex = this.$panels.filter('.kwicks-selected').index();
+		this.expandedIndex = this.selectedIndex;
+
+		// each instance has a primary and a secondary dimension (primary is the animated dimension)
+		this.primaryDimension = opts.isVertical ? 'height' : 'width';
+		this.secondaryDimension = opts.isVertical ? 'width' : 'height';
+
+		// initialize panel sizes
+		this.calculatePanelSizes();
+
+		// likewise, we have primary and secondary alignments (all panels but the last use primary,
+		// which uses the secondary alignment). this is to allow the first and last panels to have
+		// fixed offsets. this reduces jittering, which is much more noticeable on the last item.
+		this.primaryAlignment = opts.isVertical ? 'top' : 'left';
+		this.secondaryAlignment = opts.isVertical ? 'bottom' : 'right';
+
+		// object for creating a "master" animation loop for all panel animations
+		this.$timer = $({ progress : 0 });
+
+		// the current offsets for each panel
+		this.offsets = this.getOffsetsForExpanded();
+
+		this.initStyles();
+		this.initBehavior();
+		this.initWindowResizeHandler();
+		this.initSlideShow();
+	};
+
+	/**
+	 * Calculates size, minSize, and maxSize based on the current size of the container and the
+	 * user-provided options.  The results will be stored on this.panelSize, this.panelMinSize, and
+	 * this.panelMaxSize.  This should be run on initialization and whenever the container's
+	 * primary dimension may have changed in size.
+	 */
+	Kwick.prototype.calculatePanelSizes = function() {
+		var opts = this.opts,
+			numPanels = this.$panels.length,
+			containerSize = this.getContainerSize(true),
+			sumSpacing = opts.spacing * (numPanels - 1),
+			sumPanelSize = containerSize - sumSpacing;
+
+		this.panelSize = sumPanelSize / numPanels;
+
+		if (opts.minSize === -1) {
+			if (opts.maxSize === -1) {
+				// if neither minSize or maxSize or set, then we try to pick a sensible default
+				if (numPanels < 5) {
+					this.panelMaxSize = containerSize / 3 * 2;
+				} else {
+					this.panelMaxSize = containerSize / 3;
+				}
+			} else if (opts.maxSizeUnits === '%') {
+				this.panelMaxSize = sumPanelSize * opts.maxSize;
+			} else {
+				this.panelMaxSize = opts.maxSize;
+			}
+
+			// at this point we know that this.panelMaxSize is set
+			this.panelMinSize = (sumPanelSize - this.panelMaxSize) / (numPanels - 1);
+		} else if (opts.maxSize === -1) {
+			// at this point we know that opts.minSize is set
+			if (opts.minSizeUnits === '%') {
+				this.panelMinSize = sumPanelSize * opts.minSize;
+			} else {
+				this.panelMinSize = opts.minSize;
+			}
+
+			// at this point we know that this.panelMinSize is set
+			this.panelMaxSize = sumPanelSize - (this.panelMinSize * (numPanels - 1));
+		}
+	};
+
+	/**
+	 *  Returns the calculated panel offsets based on the currently expanded panel.
+	 */
+	Kwick.prototype.getOffsetsForExpanded = function() {
+		// todo: cache the offset values
+		var expandedIndex = this.expandedIndex,
+			numPanels = this.$panels.length,
+			spacing = this.opts.spacing,
+			size = this.panelSize,
+			minSize = this.panelMinSize,
+			maxSize = this.panelMaxSize;
+
+		//first panel is always offset by 0
+		var offsets = [0];
+
+		for (var i = 1; i < numPanels; i++) {
+			// no panel is expanded
+			if (expandedIndex === -1) {
+				offsets[i] = i * (size + spacing);
+			}
+			// this panel is before or is the expanded panel
+			else if (i <= expandedIndex) {
+				offsets[i] = i * (minSize + spacing);
+			}
+			// this panel is after the expanded panel
+			else {
+				offsets[i] = maxSize + (minSize * (i - 1)) + (i * spacing);
+			}
+		}
+
+		return offsets;
+	};
+
+	/**
+	 *  Sets the style attribute on the specified element using the provided value.  This probably
+	 *  doesn't belong on Kwick.prototype, but here it is...
+	 */
+	Kwick.prototype.setStyle = (function() {
+		if ($.support.style) {
+			return function(el, style) { el.setAttribute('style', style); };
+		} else {
+			return function (el, style) { el.style.cssText = style; };
+		}
+	})();
+
+	/**
+	 *  Updates the offset and size styling of each panel based on the current values in
+	 *  `this.offsets`.  Also does some special handling to convert panels to absolute positioning
+	 *  the first time this is invoked.
+	 */
+	Kwick.prototype.updatePanelStyles = function() {
+		var offsets = this.offsets,
+			$panels = this.$panels,
+			pDim = this.primaryDimension,
+			pAlign = this.primaryAlignment,
+			sAlign = this.secondaryAlignment,
+			spacing = this.opts.spacing,
+			containerSize = this.getContainerSize();
+
+		// the kwicks-processed class ensures that panels are absolutely positioned, but on our
+		// first pass we need to set offsets, width|length, and positioning atomically to prevent
+		// mid-update repaints
+		var stylePrefix = !!this._stylesInited ? '' : 'position:absolute;',
+			offset, size, prevOffset, style;
+
+		// loop through remaining panels
+		for (var i = $panels.length; i--;) {
+			prevOffset = offset;
+			// todo: maybe we do one last pass at the end and round offsets, rather than on every
+			// update
+			offset = Math.round(offsets[i]);
+			if (i === $panels.length - 1) {
+				size = containerSize - offset;
+				style = sAlign + ':0;' + pDim + ':' + size + 'px;';
+			} else {
+				size = prevOffset - offset - spacing;
+				style = pAlign + ':' + offset + 'px;' + pDim + ':' + size + 'px;';
+			}
+			this.setStyle($panels[i], stylePrefix + style);
+		}
+
+		if (!this._stylesInited) {
+			this.$container.addClass('kwicks-processed');
+			this._stylesInited = true;
+		}
+	};
+
+	/**
+	 *  Sets initial styles on the container element and panels
+	 */
+	Kwick.prototype.initStyles = function() {
+		var opts = this.opts,
+			$container = this.$container,
+			$panels = this.$panels,
+			numPanels = $panels.length,
+			pDim = this.primaryDimension,
+			sDim = this.secondaryDimension;
+
+		this.updatePanelStyles();
+	};
+
+	/**
+	 *  Assuming for a moment that out-of-the-box behaviors aren't a horrible idea, this method
+	 *  encapsulates the initialization logic thereof.
+	 */
+	Kwick.prototype.initBehavior = function() {
+		if (!this.opts.behavior) return;
+
+		var $container = this.$container;
+		switch (this.opts.behavior) {
+			case 'menu':
+				this.$container.on('mouseleave', function() {
+					$container.kwicks('expand', -1);
+				}).children().on('mouseover', function() {
+					$(this).kwicks('expand');
+				}).click(function() {
+					$(this).kwicks('select');
+				});
+				break;
+			case 'slideshow':
+				this.$panels.click(function(){
+					$(this).kwicks('select');
+				});
+				break;
+			default:
+				throw new Error('Unrecognized behavior option: ' + this.opts.behavior);
+		}
+	};
+
+	/**
+	 * Sets up a throttled window resize handler that triggers resize logic for the panels
+	 * todo: hideous code, needs refactor for the eye bleeds
+	 */
+	Kwick.prototype.initWindowResizeHandler = function() {
+		if (!this.opts.autoResize) return;
+
+		var self = this,
+			prevTime = 0,
+			execScheduled = false;
+
+		var onResize = function(e) {
+			// if there's no event, then this is a scheduled from our setTimeout
+			if (!e) { execScheduled = false; }
+
+			// if we've already run in the last 20ms, then delay execution
+			var now = +new Date();
+			if (now - prevTime < 20) {
+				// if we already scheduled a run, don't do it again
+				if (execScheduled) return;
+				setTimeout(onResize, 20 - (now - prevTime));
+				execScheduled = true;
+				return;
+			}
+
+			// throttle rate is satisfied, go ahead and run
+			prevTime = now;
+			self.resize();			
+		}
+		$(window).on('resize', onResize);
+	};
+
+	/**
+	 * Initialize Slide Show behavior
+	 */
+	Kwick.prototype.initSlideShow = function() {
+		if (!this.opts.showSpeed || this.opts.behavior !== "slideshow") return;
+		if (isNaN(this.opts.showSpeed)) {
+			throw new Error('Invalid slideShow option (not a number): ' + this.opts.slideShow);
+		}
+
+		var self = this,
+			speed = parseInt(this.opts.showSpeed)*1000,
+			numSlides = this.$panels.length,
+			curSlide = 0;
+
+		clearInterval(this.slideShowInterval);
+		this.slideShowInterval = setInterval(function(){
+			self.expand(curSlide++ % numSlides);
+		},speed);
+	};
+
+	/**
+	 * Returns the size in pixels of the container's primary dimension. This value is cached as it
+	 * is used repeatedly during animation loops, but the cache can be cleared by passing `true`.
+	 * todo: benchmark to see if this caching business is even at all necessary.
+	 */
+	Kwick.prototype.getContainerSize = function(clearCache) {
+		var containerSize = this._containerSize;
+		if (clearCache || !containerSize) {
+			containerSize = this._containerSize = this.$container[this.primaryDimension]();
+		}
+		return containerSize;
+	};
+
+	/**
+	 *  Gets a reference to the currently expanded panel (if there is one)
+	 */
+	Kwick.prototype.getExpandedPanel = function() {
+		return this.expandedIndex === -1 ? $([]) : this.$panels.eq(this.expandedIndex);
+	};
+
+	/**
+	 *  Gets a reference to the currently collapsed panels (if there is any)
+	 */
+	Kwick.prototype.getCollapsedPanels = function() {
+		return this.expandedIndex === -1 ? $([]) : this.$panels.not(this.getExpandedPanel());
+	};
+
+	/**
+	 *  Gets a reference to the currently selected panel (if there is one)
+	 */
+	Kwick.prototype.getSelectedPanel = function() {
+		return this.selectedIndex === -1 ? $([]) : this.$panels.eq(this.selectedIndex);
+	};
+
+	/**
+	 *  Forces the panels to be updated in response to the container being resized.
+	 */
+	Kwick.prototype.resize = function(index) {
+		// bail out if container size hasn't changed
+		if (this.getContainerSize() === this.getContainerSize(true)) return;
+
+		this.calculatePanelSizes();
+		this.offsets = this.getOffsetsForExpanded();
+
+		// if the panels are currently being animated, we'll just set a flag that can be detected
+		// during the next animation step
+		if (this.isAnimated) {
+			this._dirtyOffsets = true;
+		} else {
+			// otherwise update the styles immediately
+			this.updatePanelStyles();
+		}
+	};
+
+	/**
+	 *  Selects (and expands) the panel with the specified index (use -1 to select none)
+	 */
+	Kwick.prototype.select = function(index) {
+		// make sure the panel isn't already selected
+		if (index === this.selectedIndex) {
+			// it's possible through the API to have a panel already selected but not expanded,
+			// so ensure that the panel really is expanded
+			return this.expand(index);
+		}
+
+		this.getSelectedPanel().removeClass('kwicks-selected');
+		this.selectedIndex = index;
+		this.getSelectedPanel().addClass('kwicks-selected');
+		this.expand(index);
+	};
+
+	/**
+	 *  Expands the panel with the specified index (use -1 to expand none)
+	 */
+	Kwick.prototype.expand = function(index) {
+		var self = this;
+
+		// if the index is -1, then default it to the currently selected index (which will also be
+		// -1 if no panels are currently selected)
+		if (index === -1) index = this.selectedIndex;
+
+		// make sure the panel isn't already expanded
+		if (index === this.expandedIndex) return;
+
+		this.getExpandedPanel().removeClass('kwicks-expanded');
+		this.getCollapsedPanels().removeClass('kwicks-collapsed');
+		this.expandedIndex = index;
+		this.getExpandedPanel().addClass('kwicks-expanded');
+		this.getCollapsedPanels().addClass('kwicks-collapsed');
+
+		// handle panel animation
+		var $timer = this.$timer,
+			numPanels = this.$panels.length,
+			startOffsets = this.offsets.slice(),
+			offsets = this.offsets,
+			targetOffsets = this.getOffsetsForExpanded();
+
+		$timer.stop()[0].progress = 0;
+		this.isAnimated = true;
+		$timer.animate({ progress: 1 }, {
+			duration: this.opts.duration,
+			easing: this.opts.easing,
+			step: function(progress) {
+				if (self._dirtyOffsets) {
+					offsets = self.offsets;
+					targetOffsets = self.getOffsetsForExpanded();
+					self._dirtyOffsets = false;
+				}
+				offsets.length = 0;
+				for (var i = 0; i < numPanels; i++) {
+					var targetOffset = targetOffsets[i],
+						newOffset = targetOffset - ((targetOffset - startOffsets[i]) * (1 - progress));
+					offsets[i] = newOffset;
+				}
+				self.updatePanelStyles();
+			},
+			complete:  function() {
+				self.isAnimated = false;
+			}
+		});
+	};
+
+})(jQuery);

data/vendor/assets/stylesheets/kwicks/index.css

@@ -0,0 +1,5 @@
+/*
+ * This file loads all Kwicks related CSS files
+ *= require_tree .
+ */
+ 

data/vendor/assets/stylesheets/kwicks/jquery.kwicks.css

@@ -0,0 +1,42 @@
+/*!
+ *  Kwicks: Sexy Sliding Panels for jQuery - v2.1.0
+ *  http://devsmash.com/projects/kwicks
+ *
+ *  Copyright 2013 Jeremy Martin (jmar777)
+ *  Contributors: Duke Speer (Duke3D), Guillermo Guerrero (gguerrero)
+ *  Released under the MIT license
+ *  http://www.opensource.org/licenses/mit-license.php
+ */
+
+/*
+ *  This file contains styles that are common to all kwicks instances based on 
+ *  jquery_kwicks_rails helpers.
+ *  Note that each kwicks instance requires additional styling.
+ */
+.kwicks {
+	display: block;
+	list-style-type: none;
+	list-style: none;
+	position: relative;
+	margin: 0;
+	padding: 0;
+}
+.kwicks > li.kwicks-panel {
+	display: block;
+	overflow: hidden;
+	padding: 0;
+	margin: 0;
+}
+.kwicks.kwicks-processed > li.kwicks-panel {
+	margin: 0;
+	position: absolute;
+}
+.kwicks-horizontal > li.kwicks-panel {
+	float: left;
+}
+.kwicks-horizontal > li.kwicks-panel:first-child {
+	margin-left: 0;
+}
+.kwicks-vertical > li.kwicks-panel:first-child {
+	margin-top: 0;
+}

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: jquery_kwicks_rails
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Guillermo Guerrero
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: jquery-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+description: The JQuery Sexy Sliding Panels for Rails applications
+email:
+- g.guerrero.bus@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- MIT-LICENSE
+files:
+- .gitignore
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- jquery_kwicks_rails.gemspec
+- lib/jquery_kwicks_rails.rb
+- lib/jquery_kwicks_rails/engine.rb
+- lib/jquery_kwicks_rails/helper.rb
+- lib/jquery_kwicks_rails/version.rb
+- vendor/assets/javascripts/kwicks/index.js
+- vendor/assets/javascripts/kwicks/jquery.easing.1.3.js
+- vendor/assets/javascripts/kwicks/jquery.kwicks.js
+- vendor/assets/stylesheets/kwicks/index.css
+- vendor/assets/stylesheets/kwicks/jquery.kwicks.css
+homepage: https://github.com/gguerrero/jquery_kwicks_rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --title
+- '"JQuery'
+- Sexy
+- Sliding
+- Panels
+- for
+- Rails"
+- --inline-source
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: JQuery Sexy Sliding Panels for Rails apps
+test_files: []
+has_rdoc: true