jquery-unslider-rails 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a70b38df6accd06831f86e04323ef4769d0974ad
+  data.tar.gz: 96fe4c2da750b90fb50cd515937d9be63ae5c2f3
+SHA512:
+  metadata.gz: 1fbaa393e7e173a472308373e553ed9d8fa70c7ed1d2e80da86643c57b04b7b02f02a54cfd349ea5f41466f226dfc9b290128244f51774ac707802d0a5edf5e9
+  data.tar.gz: f912f537d24df7f262c3a13b590756be84417f868955b9cdade67b11822109db64cccb69ecbce88a2eacb9e1919aae612d9515ad593c43c2f14280db96715f0e

data/LICENSE

@@ -0,0 +1,19 @@
+The MIT License (MIT)
+
+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,16 @@
+# jquery-unslider-rails
+
+[jQuery Unslider](https://github.com/idiot/unslider) plugin for jQuery, written by [Visual Idiot](https://github.com/idiot), packaged for the Rails asset pipeline.
+
+## Usage
+
+This gem ships with with a minified version of the library. Feel free to use either of the following:
+
+```
+//= require jquery-unslider
+//= require jquery-unslider.min
+```
+
+## Disclaimer
+
+This repo is a Rails gem package. All issues with the library should be reported on the library's [GitHub page](https://github.com/idiot/unslider). This repo will be updated each time a new version of the library is released.

data/lib/jquery-unslider-rails.rb

@@ -0,0 +1,8 @@
+require 'jquery-unslider-rails/version'
+
+module JqueryUnsliderRails
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/jquery-unslider-rails/version.rb

@@ -0,0 +1,5 @@
+module JqueryUnsliderRails
+  module Rails
+    VERSION = '2.0.0'
+  end
+end

data/vendor/assets/javascripts/jquery-unslider.js

@@ -0,0 +1,651 @@
+/**
+ *   Unslider
+ *   version 2.0
+ *   by @idiot and friends
+ */
+
+(function(factory) {
+    if (typeof module === 'object' && typeof module.exports === 'object') {
+        factory(require('jquery'));
+    } else if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define([], factory(window.jQuery));
+    } else {
+        factory(window.jQuery);
+    }
+}(function($) {
+    //  Don't throw any errors when jQuery
+    if(!$) {
+        return console.warn('Unslider needs jQuery');
+    }
+
+    $.Unslider = function(context, options) {
+        var self = this;
+
+        //  Create an Unslider reference we can use everywhere
+        self._ = 'unslider';
+
+        //  Store our default options in here
+        //  Everything will be overwritten by the jQuery plugin though
+        self.defaults = {
+            //  Should the slider move on its own or only when
+            //  you interact with the nav/arrows?
+            //  Only accepts boolean true/false.
+            autoplay: false,
+
+            //  3 second delay between slides moving, pass
+            //  as a number in milliseconds.
+            delay: 3000,
+
+            //  Animation speed in millseconds
+            speed: 750,
+
+            //  An easing string to use. If you're using Velocity, use a
+            //  Velocity string otherwise you can use jQuery/jQ UI options.
+            easing: 'swing', // [.42, 0, .58, 1],
+
+            //  Does it support keyboard arrows?
+            //  Can pass either true or false -
+            //  or an object with the keycodes, like so:
+            //  {
+            //   prev: 37,
+            //   next: 39
+            // }
+            //  You can call any internal method name
+            //  before the keycode and it'll be called.
+            keys: {
+                prev: 37,
+                next: 39
+            },
+
+            //  Do you want to generate clickable navigation
+            //  to skip to each slide? Accepts boolean true/false or
+            //  a callback function per item to generate.
+            nav: true,
+
+            //  Should there be left/right arrows to go back/forth?
+            //   -> This isn't keyboard support.
+            //  Either set true/false, or an object with the HTML
+            //  elements for each arrow like below:
+            arrows: {
+                prev: '<a class="' + self._ + '-arrow prev">Prev</a>',
+                next: '<a class="' + self._ + '-arrow next">Next</a>'
+            },
+
+            //  How should Unslider animate?
+            //  It can do one of the following types:
+            //  "fade": each slide fades in to each other
+            //  "horizontal": each slide moves from left to right
+            //  "vertical": each slide moves from top to bottom
+            animation: 'horizontal',
+
+            //  If you don't want to use a list to display your slides,
+            //  you can change it here. Not recommended and you'll need
+            //  to adjust the CSS accordingly.
+            selectors: {
+                container: 'ul:first',
+                slides: 'li'
+            },
+
+            //  Do you want to animate the heights of each slide as
+            //  it moves
+            animateHeight: false,
+
+            //  Active class for the nav
+            activeClass: self._ + '-active',
+
+            //  Have swipe support?
+            //  You can set this here with a boolean and always use
+            //  initSwipe/destroySwipe later on.
+            swipe: true,
+            // Swipe threshold -
+            // lower float for enabling short swipe
+            swipeThreshold: 0.2
+        };
+
+        //  Set defaults
+        self.$context = context;
+        self.options = {};
+
+        //  Leave our elements blank for now
+        //  Since they get changed by the options, we'll need to
+        //  set them in the init method.
+        self.$parent = null;
+        self.$container = null;
+        self.$slides = null;
+        self.$nav = null;
+        self.$arrows = [];
+
+        //  Set our indexes and totals
+        self.total = 0;
+        self.current = 0;
+
+        //  Generate a specific random ID so we don't dupe events
+        self.prefix = self._ + '-';
+        self.eventSuffix = '.' + self.prefix + ~~(Math.random() * 2e3);
+
+        //  In case we're going to use the autoplay
+        self.interval = null;
+
+        //  Get everything set up innit
+        self.init = function(options) {
+            //  Set up our options inside here so we can re-init at
+            //  any time
+            self.options = $.extend({}, self.defaults, options);
+
+            //  Our elements
+            self.$container = self.$context.find(self.options.selectors.container).addClass(self.prefix + 'wrap');
+            self.$slides = self.$container.children(self.options.selectors.slides);
+
+            //  We'll manually init the container
+            self.setup();
+
+            //  We want to keep this script as small as possible
+            //  so we'll optimise some checks
+            $.each(['nav', 'arrows', 'keys', 'infinite'], function(index, module) {
+                self.options[module] && self['init' + $._ucfirst(module)]();
+            });
+
+            //  Add swipe support
+            if(jQuery.event.special.swipe && self.options.swipe) {
+                self.initSwipe();
+            }
+
+            //  If autoplay is set to true, call self.start()
+            //  to start calling our timeouts
+            self.options.autoplay && self.start();
+
+            //  We should be able to recalculate slides at will
+            self.calculateSlides();
+
+            //  Listen to a ready event
+            self.$context.trigger(self._ + '.ready');
+
+            //  Everyday I'm chainin'
+            return self.animate(self.options.index || self.current, 'init');
+        };
+
+        self.setup = function() {
+            //  Add a CSS hook to the main element
+            self.$context.addClass(self.prefix + self.options.animation).wrap('<div class="' + self._ + '" />');
+            self.$parent = self.$context.parent('.' + self._);
+
+            //  We need to manually check if the container is absolutely
+            //  or relatively positioned
+            var position = self.$context.css('position');
+
+            //  If we don't already have a position set, we'll
+            //  automatically set it ourselves
+            if(position === 'static') {
+                self.$context.css('position', 'relative');
+            }
+
+            self.$context.css('overflow', 'hidden');
+        };
+
+        //  Set up the slide widths to animate with
+        //  so the box doesn't float over
+        self.calculateSlides = function() {
+            // update slides before recalculating the total
+            self.$slides = self.$container.children(self.options.selectors.slides);
+
+            self.total = self.$slides.length;
+
+            //  Set the total width
+            if(self.options.animation !== 'fade') {
+                var prop = 'width';
+
+                if(self.options.animation === 'vertical') {
+                    prop = 'height';
+                }
+
+                self.$container.css(prop, (self.total * 100) + '%').addClass(self.prefix + 'carousel');
+                self.$slides.css(prop, (100 / self.total) + '%');
+            }
+        };
+
+
+        //  Start our autoplay
+        self.start = function() {
+            self.interval = setTimeout(function() {
+                //  Move on to the next slide
+                self.next();
+
+                //  If we've got autoplay set up
+                //  we don't need to keep starting
+                //  the slider from within our timeout
+                //  as .animate() calls it for us
+            }, self.options.delay);
+
+            return self;
+        };
+
+        //  And pause our timeouts
+        //  and force stop the slider if needed
+        self.stop = function() {
+            clearTimeout(self.interval);
+
+            return self;
+        };
+
+
+        //  Set up our navigation
+        self.initNav = function() {
+            var $nav = $('<nav class="' + self.prefix + 'nav"><ol /></nav>');
+
+            //  Build our click navigation item-by-item
+            self.$slides.each(function(key) {
+                //  If we've already set a label, let's use that
+                //  instead of generating one
+                var label = this.getAttribute('data-nav') || key + 1;
+
+                //  Listen to any callback functions
+                if($.isFunction(self.options.nav)) {
+                    label = self.options.nav.call(self.$slides.eq(key), key, label);
+                }
+
+                //  And add it to our navigation item
+                $nav.children('ol').append('<li data-slide="' + key + '">' + label + '</li>');
+            });
+
+            //  Keep a copy of the nav everywhere so we can use it
+            self.$nav = $nav.insertAfter(self.$context);
+
+            //  Now our nav is built, let's add it to the slider and bind
+            //  for any click events on the generated links
+            self.$nav.find('li').on('click' + self.eventSuffix, function() {
+                //  Cache our link and set it to be active
+                var $me = $(this).addClass(self.options.activeClass);
+
+                //  Set the right active class, remove any other ones
+                $me.siblings().removeClass(self.options.activeClass);
+
+                //  Move the slide
+                self.animate($me.attr('data-slide'));
+            });
+        };
+
+
+        //  Set up our left-right arrow navigation
+        //  (Not keyboard arrows, prev/next buttons)
+        self.initArrows = function() {
+            if(self.options.arrows === true) {
+                self.options.arrows = self.defaults.arrows;
+            }
+
+            //  Loop our options object and bind our events
+            $.each(self.options.arrows, function(key, val) {
+                //  Add our arrow HTML and bind it
+                self.$arrows.push(
+                    $(val).insertAfter(self.$context).on('click' + self.eventSuffix, self[key])
+                );
+            });
+        };
+
+
+        //  Set up our keyboad navigation
+        //  Allow binding to multiple keycodes
+        self.initKeys = function() {
+            if(self.options.keys === true) {
+                self.options.keys = self.defaults.keys;
+            }
+
+            $(document).on('keyup' + self.eventSuffix, function(e) {
+                $.each(self.options.keys, function(key, val) {
+                    if(e.which === val) {
+                        $.isFunction(self[key]) && self[key].call(self);
+                    }
+                });
+            });
+        };
+
+        //  Requires jQuery.event.swipe
+        //  -> stephband.info/jquery.event.swipe
+        self.initSwipe = function() {
+            var width = self.$slides.width();
+
+            //  We don't want to have a tactile swipe in the slider
+            //  in the fade animation, as it can cause some problems
+            //  with layout, so we'll just disable it.
+            if(self.options.animation !== 'fade') {
+
+                self.$container.on({
+
+                    movestart: function(e) {
+                        //  If the movestart heads off in a upwards or downwards
+                        //  direction, prevent it so that the browser scrolls normally.
+                        if((e.distX > e.distY && e.distX < -e.distY) || (e.distX < e.distY && e.distX > -e.distY)) {
+                            return !!e.preventDefault();
+                        }
+
+                        self.$container.css('position', 'relative');
+                    },
+
+                    move: function(e) {
+                        self.$container.css('left', -(100 * self.current) + (100 * e.distX / width) + '%');
+                    },
+
+                    moveend: function(e) {
+                        // Check if swiped distance is greater than threshold.
+                        // If yes slide to next/prev slide. If not animate to
+                        // starting point.
+
+                        if((Math.abs(e.distX) / width) > self.options.swipeThreshold) {
+
+                            self[e.distX < 0 ? 'next' : 'prev']();
+                        }
+                        else {
+
+                            self.$container.animate({left: -(100 * self.current) + '%' }, self.options.speed / 2 );
+                        }
+                    }
+                });
+            }
+        };
+
+        //  Infinite scrolling is a massive pain in the arse
+        //  so we need to create a whole bloody function to set
+        //  it up. Argh.
+        self.initInfinite = function() {
+            var pos = ['first', 'last'];
+
+            $.each(pos, function(index, item) {
+                self.$slides.push.apply(
+                    self.$slides,
+
+                    //  Exclude all cloned slides and call .first() or .last()
+                    //  depending on what `item` is.
+                    self.$slides.filter(':not(".' + self._ + '-clone")')[item]()
+
+                    //  Make a copy of it and identify it as a clone
+                    .clone().addClass(self._ + '-clone')
+
+                    //  Either insert before or after depending on whether we're
+                    //  the first or last clone
+                    ['insert' + (index === 0 ? 'After' : 'Before')](
+                        //  Return the other element in the position array
+                        //  if item = first, return "last"
+                        self.$slides[pos[~~!index]]()
+                    )
+                );
+            });
+        };
+
+        //  Remove any trace of arrows
+        //  Loop our array of arrows and use jQuery to remove
+        //  It'll unbind any event handlers for us
+        self.destroyArrows = function() {
+            $.each(self.$arrows, function(i, $arrow) {
+                $arrow.remove();
+            });
+        };
+
+        //  Remove any swipe events and reset the position
+        self.destroySwipe = function() {
+            //  We bind to 4 events, so we'll unbind those
+            self.$container.off('movestart move moveend');
+        };
+
+        //  Unset the keyboard navigation
+        //  Remove the handler
+        self.destroyKeys = function() {
+            //  Remove the event handler
+            $(document).off('keyup' + self.eventSuffix);
+        };
+
+        self.setIndex = function(to) {
+            if(to < 0) {
+                to = self.total - 1;
+            }
+
+            self.current = Math.min(Math.max(0, to), self.total - 1);
+
+            if(self.options.nav) {
+                self.$nav.find('[data-slide="' + self.current + '"]')._active(self.options.activeClass);
+            }
+
+            self.$slides.eq(self.current)._active(self.options.activeClass);
+
+            return self;
+        };
+
+        //  Despite the name, this doesn't do any animation - since there's
+        //  now three different types of animation, we let this method delegate
+        //  to the right type, keeping the name for backwards compat.
+        self.animate = function(to, dir) {
+            //  Animation shortcuts
+            //  Instead of passing a number index, we can now
+            //  use .data('unslider').animate('last');
+            //  or .unslider('animate:last')
+            //  to go to the very last slide
+            if(to === 'first') to = 0;
+            if(to === 'last') to = self.total;
+
+            //  Don't animate if it's not a valid index
+            if(isNaN(to)) {
+                return self;
+            }
+
+            if(self.options.autoplay) {
+                self.stop().start();
+            }
+
+            self.setIndex(to);
+
+            //  Add a callback method to do stuff with
+            self.$context.trigger(self._ + '.change', [to, self.$slides.eq(to)]);
+
+            //  Delegate the right method - everything's named consistently
+            //  so we can assume it'll be called "animate" +
+            var fn = 'animate' + $._ucfirst(self.options.animation);
+
+            //  Make sure it's a valid animation method, otherwise we'll get
+            //  a load of bug reports that'll be really hard to report
+            if($.isFunction(self[fn])) {
+                self[fn](self.current, dir);
+            }
+
+            return self;
+        };
+
+
+        //  Shortcuts for animating if we don't know what the current
+        //  index is (i.e back/forward)
+        //  For moving forward we need to make sure we don't overshoot.
+        self.next = function() {
+            var target = self.current + 1;
+
+            //  If we're at the end, we need to move back to the start
+            if(target >= self.total) {
+                target = 0;
+            }
+
+            return self.animate(target, 'next');
+        };
+
+        //  Previous is a bit simpler, we can just decrease the index
+        //  by one and check if it's over 0.
+        self.prev = function() {
+            return self.animate(self.current - 1, 'prev');
+        };
+
+
+        //  Our default animation method, the old-school left-to-right
+        //  horizontal animation
+        self.animateHorizontal = function(to) {
+            var prop = 'left';
+
+            //  Add RTL support, slide the slider
+            //  the other way if the site is right-to-left
+            if(self.$context.attr('dir') === 'rtl') {
+                prop = 'right';
+            }
+
+            if(self.options.infinite) {
+                //  So then we need to hide the first slide
+                self.$container.css('margin-' + prop, '-100%');
+            }
+
+            return self.slide(prop, to);
+        };
+
+        //  The same animation methods, but vertical support
+        //  RTL doesn't affect the vertical direction so we
+        //  can just call as is
+        self.animateVertical = function(to) {
+            self.options.animateHeight = true;
+
+            //  Normal infinite CSS fix doesn't work for
+            //  vertical animation so we need to manually set it
+            //  with pixels. Ah well.
+            if(self.options.infinite) {
+                self.$container.css('margin-top', -self.$slides.outerHeight());
+            }
+
+            return self.slide('top', to);
+        };
+
+        //  Actually move the slide now
+        //  We have to pass a property to animate as there's
+        //  a few different directions it can now move, but it's
+        //  otherwise unchanged from before.
+        self.slide = function(prop, to) {
+            //  If we want to change the height of the slider
+            //  to match the current slide, you can set
+            //  {animateHeight: true}
+            self.animateHeight(to);
+
+            //  For infinite sliding we add a dummy slide at the end and start
+            //  of each slider to give the appearance of being infinite
+            if(self.options.infinite) {
+                var dummy;
+
+                //  Going backwards to last slide
+                if(to === self.total - 1) {
+                    //  We're setting a dummy position and an actual one
+                    //  the dummy is what the index looks like
+                    //  (and what we'll silently update to afterwards),
+                    //  and the actual is what makes it not go backwards
+                    dummy = self.total - 3;
+                    to = -1;
+                }
+
+                //  Going forwards to first slide
+                if(to === self.total - 2) {
+                    dummy = 0;
+                    to = self.total - 2;
+                }
+
+                //  If it's a number we can safely set it
+                if(typeof dummy === 'number') {
+                    self.setIndex(dummy);
+
+                    //  Listen for when the slide's finished transitioning so
+                    //  we can silently move it into the right place and clear
+                    //  this whole mess up.
+                    self.$context.on(self._ + '.moved', function() {
+                        if(self.current === dummy) {
+                            self.$container.css(prop, -(100 * dummy) + '%').off(self._ + '.moved');
+                        }
+                    });
+                }
+            }
+
+            //  We need to create an object to store our property in
+            //  since we don't know what it'll be.
+            var obj = {};
+
+            //  Manually create it here
+            obj[prop] = -(100 * to) + '%';
+
+            //  And animate using our newly-created object
+            return self._move(self.$container, obj);
+        };
+
+
+        //  Fade between slides rather than, uh, sliding it
+        self.animateFade = function(to) {
+            //  If we want to change the height of the slider
+            //  to match the current slide, you can set
+            //  {animateHeight: true}
+            self.animateHeight(to);
+
+            var $active = self.$slides.eq(to).addClass(self.options.activeClass);
+
+            //  Toggle our classes
+            self._move($active.siblings().removeClass(self.options.activeClass), {opacity: 0});
+            self._move($active, {opacity: 1}, false);
+        };
+
+        // Animate height of slider
+        self.animateHeight = function(to) {
+            //  If we want to change the height of the slider
+            //  to match the current slide, you can set
+            //  {animateHeight: true}
+            if (self.options.animateHeight) {
+                self._move(self.$context, {height: self.$slides.eq(to).outerHeight()}, false);
+            }
+        };
+
+        self._move = function($el, obj, callback, speed) {
+            if(callback !== false) {
+                callback = function() {
+                    self.$context.trigger(self._ + '.moved');
+                };
+            }
+
+            return $el._move(obj, speed || self.options.speed, self.options.easing, callback);
+        };
+
+        //  Allow daisy-chaining of methods
+        return self.init(options);
+    };
+
+    //  Internal (but global) jQuery methods
+    //  They're both just helpful types of shorthand for
+    //  anything that might take too long to write out or
+    //  something that might be used more than once.
+    $.fn._active = function(className) {
+        return this.addClass(className).siblings().removeClass(className);
+    };
+
+    //  The equivalent to PHP's ucfirst(). Take the first
+    //  character of a string and make it uppercase.
+    //  Simples.
+    $._ucfirst = function(str) {
+        //  Take our variable, run a regex on the first letter
+        return (str + '').toLowerCase().replace(/^./, function(match) {
+            //  And uppercase it. Simples.
+            return match.toUpperCase();
+        });
+    };
+
+    $.fn._move = function() {
+        this.stop(true, true);
+        return $.fn[$.fn.velocity ? 'velocity' : 'animate'].apply(this, arguments);
+    };
+
+    //  And set up our jQuery plugin
+    $.fn.unslider = function(opts) {
+        return this.each(function() {
+            var $this = $(this);
+
+            //  Allow usage of .unslider('function_name')
+            //  as well as using .data('unslider') to access the
+            //  main Unslider object
+            if(typeof opts === 'string' && $this.data('unslider')) {
+                opts = opts.split(':');
+
+                var call = $this.data('unslider')[opts[0]];
+
+                //  Do we have arguments to pass to the string-function?
+                if($.isFunction(call)) {
+                    return call.apply($this, opts[1] ? opts[1].split(',') : null);
+                }
+            }
+
+            return $this.data('unslider', new $.Unslider($this, opts));
+        });
+    };
+
+}));

data/vendor/assets/javascripts/jquery-unslider.min.js

@@ -0,0 +1 @@
+!function($){return $?($.Unslider=function(t,n){var e=this;return e._="unslider",e.defaults={autoplay:!1,delay:3e3,speed:750,easing:"swing",keys:{prev:37,next:39},nav:!0,arrows:{prev:'<a class="'+e._+'-arrow prev">Prev</a>',next:'<a class="'+e._+'-arrow next">Next</a>'},animation:"horizontal",selectors:{container:"ul:first",slides:"li"},animateHeight:!1,activeClass:e._+"-active",swipe:!0,swipeThreshold:.2},e.$context=t,e.options={},e.$parent=null,e.$container=null,e.$slides=null,e.$nav=null,e.$arrows=[],e.total=0,e.current=0,e.prefix=e._+"-",e.eventSuffix="."+e.prefix+~~(2e3*Math.random()),e.interval=null,e.init=function(t){return e.options=$.extend({},e.defaults,t),e.$container=e.$context.find(e.options.selectors.container).addClass(e.prefix+"wrap"),e.$slides=e.$container.children(e.options.selectors.slides),e.setup(),$.each(["nav","arrows","keys","infinite"],function(t,n){e.options[n]&&e["init"+$._ucfirst(n)]()}),jQuery.event.special.swipe&&e.options.swipe&&e.initSwipe(),e.options.autoplay&&e.start(),e.calculateSlides(),e.$context.trigger(e._+".ready"),e.animate(e.options.index||e.current,"init")},e.setup=function(){e.$context.addClass(e.prefix+e.options.animation).wrap('<div class="'+e._+'" />'),e.$parent=e.$context.parent("."+e._);var t=e.$context.css("position");"static"===t&&e.$context.css("position","relative"),e.$context.css("overflow","hidden")},e.calculateSlides=function(){if(e.total=e.$slides.length,"fade"!==e.options.animation){var t="width";"vertical"===e.options.animation&&(t="height"),e.$container.css(t,100*e.total+"%").addClass(e.prefix+"carousel"),e.$slides.css(t,100/e.total+"%")}},e.start=function(){return e.interval=setTimeout(function(){e.next()},e.options.delay),e},e.stop=function(){return clearTimeout(e.interval),e},e.initNav=function(){var t=$('<nav class="'+e.prefix+'nav"><ol /></nav>');e.$slides.each(function(n){var i=this.getAttribute("data-nav")||n+1;$.isFunction(e.options.nav)&&(i=e.options.nav.call(e.$slides.eq(n),n,i)),t.children("ol").append('<li data-slide="'+n+'">'+i+"</li>")}),e.$nav=t.insertAfter(e.$context),e.$nav.find("li").on("click"+e.eventSuffix,function(){var t=$(this).addClass(e.options.activeClass);t.siblings().removeClass(e.options.activeClass),e.animate(t.attr("data-slide"))})},e.initArrows=function(){e.options.arrows===!0&&(e.options.arrows=e.defaults.arrows),$.each(e.options.arrows,function(t,n){e.$arrows.push($(n).insertAfter(e.$context).on("click"+e.eventSuffix,e[t]))})},e.initKeys=function(){e.options.keys===!0&&(e.options.keys=e.defaults.keys),$(document).on("keyup"+e.eventSuffix,function(t){$.each(e.options.keys,function(n,i){t.which===i&&$.isFunction(e[n])&&e[n].call(e)})})},e.initSwipe=function(){var t=e.$slides.width();"fade"!==e.options.animation&&e.$container.on({movestart:function(t){return t.distX>t.distY&&t.distX<-t.distY||t.distX<t.distY&&t.distX>-t.distY?!!t.preventDefault():void e.$container.css("position","relative")},move:function(n){e.$container.css("left",-(100*e.current)+100*n.distX/t+"%")},moveend:function(n){Math.abs(n.distX)/t>e.options.swipeThreshold?e[n.distX<0?"next":"prev"]():e.$container.animate({left:-(100*e.current)+"%"},e.options.speed/2)}})},e.initInfinite=function(){var t=["first","last"];$.each(t,function(n,i){e.$slides.push.apply(e.$slides,e.$slides.filter(':not(".'+e._+'-clone")')[i]().clone().addClass(e._+"-clone")["insert"+(0===n?"After":"Before")](e.$slides[t[~~!n]]()))})},e.destroyArrows=function(){$.each(e.$arrows,function(t,n){n.remove()})},e.destroySwipe=function(){e.$container.off("movestart move moveend")},e.destroyKeys=function(){$(document).off("keyup"+e.eventSuffix)},e.setIndex=function(t){return 0>t&&(t=e.total-1),e.current=Math.min(Math.max(0,t),e.total-1),e.options.nav&&e.$nav.find('[data-slide="'+e.current+'"]')._active(e.options.activeClass),e.$slides.eq(e.current)._active(e.options.activeClass),e},e.animate=function(t,n){if("first"===t&&(t=0),"last"===t&&(t=e.total),isNaN(t))return e;e.options.autoplay&&e.stop().start(),e.setIndex(t),e.$context.trigger(e._+".change",[t,e.$slides.eq(t)]);var i="animate"+$._ucfirst(e.options.animation);return $.isFunction(e[i])&&e[i](e.current,n),e},e.next=function(){var t=e.current+1;return t>=e.total&&(t=0),e.animate(t,"next")},e.prev=function(){return e.animate(e.current-1,"prev")},e.animateHorizontal=function(t){var n="left";return"rtl"===e.$context.attr("dir")&&(n="right"),e.options.infinite&&e.$container.css("margin-"+n,"-100%"),e.slide(n,t)},e.animateVertical=function(t){return e.options.animateHeight=!0,e.options.infinite&&e.$container.css("margin-top",-e.$slides.outerHeight()),e.slide("top",t)},e.slide=function(t,n){if(e.options.animateHeight&&e._move(e.$context,{height:e.$slides.eq(n).outerHeight()},!1),e.options.infinite){var i;n===e.total-1&&(i=e.total-3,n=-1),n===e.total-2&&(i=0,n=e.total-2),"number"==typeof i&&(e.setIndex(i),e.$context.on(e._+".moved",function(){e.current===i&&e.$container.css(t,-(100*i)+"%").off(e._+".moved")}))}var o={};return o[t]=-(100*n)+"%",e._move(e.$container,o)},e.animateFade=function(t){var n=e.$slides.eq(t).addClass(e.options.activeClass);e._move(n.siblings().removeClass(e.options.activeClass),{opacity:0}),e._move(n,{opacity:1},!1)},e._move=function(t,n,i,o){return i!==!1&&(i=function(){e.$context.trigger(e._+".moved")}),t._move(n,o||e.options.speed,e.options.easing,i)},e.init(n)},$.fn._active=function(t){return this.addClass(t).siblings().removeClass(t)},$._ucfirst=function(t){return(t+"").toLowerCase().replace(/^./,function(t){return t.toUpperCase()})},$.fn._move=function(){return this.stop(!0,!0),$.fn[$.fn.velocity?"velocity":"animate"].apply(this,arguments)},void($.fn.unslider=function(t){return this.each(function(){var n=$(this);if("string"==typeof t&&n.data("unslider")){t=t.split(":");var e=n.data("unslider")[t[0]];if($.isFunction(e))return e.apply(n,t[1]?t[1].split(","):null)}return n.data("unslider",new $.Unslider(n,t))})})):console.warn("Unslider needs jQuery")}(window.jQuery);

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: jquery-unslider-rails
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Curt Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-13 00:00:00.000000000 Z
+dependencies: []
+description: A build of the jQuery Unslider Plugin, written by written by Visual Idiot,
+  packaged for the Rails asset pipeline.
+email:
+- curt@meows.us
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/jquery-unslider-rails.rb
+- lib/jquery-unslider-rails/version.rb
+- vendor/assets/javascripts/jquery-unslider.js
+- vendor/assets/javascripts/jquery-unslider.min.js
+homepage: https://github.com/meowsus/jquery-unslider-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A build of the jQuery Unslider Plugin, written by written by Visual Idiot,
+  packaged for the Rails asset pipeline.
+test_files: []