lory-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 01eb60e45b8bef97723965bd65f3ca8b9b4c7ca8
+  data.tar.gz: 5e8d5787011a1c88591f30210cbddfeb2d98c857
+SHA512:
+  metadata.gz: c17fa31c58247fe617d93651f5813a42042de6a843c50cd60bdc5d51c681fe65109520b1881a80e11dad2e6382598a305e4c7a1da0899622890de41a0d1c6a0e
+  data.tar.gz: 43ff5cfec127ffaadfbe5134d48308650836c5a040e8ee8ea0a53b69f6bb35618655e56e792bab52ac9a94aefbabdf4328a20e914ec7bc3027f56b02f8a1bbf6

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+*.gem

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.16.0

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at tanvir002700@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in lory-rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 tanvir hasan
+
+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,60 @@
+# Lory::Rails
+[![Gem Version](https://badge.fury.io/rb/lory-rails.svg)](https://rubygems.org/gems/lory-rails) 
+[![Downloads](https://img.shields.io/gem/dt/lory-rails.svg)](https://rubygems.org/gems/lory-rails)
+[![GitHub last commit (branch)](https://img.shields.io/github/last-commit/tanvir002700/lory-rails/master.svg)](https://github.com/tanvir002700/lory-rails)
+[![license](https://img.shields.io/github/license/tanvir002700/lory-rails.svg)](https://github.com/tanvir002700/lory-rails/blob/master/LICENSE)
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/lory/rails`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lory-rails'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lory-rails
+    
+And then edit your app/assets/stylesheets/application.js file to look something like:
+``` css
+/*
+*= require_self
+*= require jqeury
+*= require jquery-ui
+*= require lory
+*= require_tree .
+*/
+```
+
+**lory-rails is dependant on jQuery, so make sure you have it in your Gemfile.**
+
+## Usage
+
+View [lory](http://meandmax.github.io/lory) for complete useage information.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/tanvir002700/lory-rails. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Lory::Rails project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/tanvir002700/lory-rails/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/VERSIONS.md

@@ -0,0 +1,5 @@
+# Bundled Versions
+
+| Gem    | lory |
+|--------|-----------|
+| 0.1.0  | 2.4.0

data/lib/lory/rails.rb

@@ -0,0 +1,2 @@
+require "lory/rails/version"
+require "lory/rails/engine" if defined? Rails

data/lib/lory/rails/engine.rb

@@ -0,0 +1,6 @@
+module Lory
+  module Rails
+    class Engine < ::Rails::Engine; end
+  end
+end
+

data/lib/lory/rails/version.rb

@@ -0,0 +1,5 @@
+module Lory
+  module Rails
+    VERSION = "0.1.0"
+  end
+end

data/lory-rails.gemspec

@@ -0,0 +1,36 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "lory/rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "lory-rails"
+  spec.version       = Lory::Rails::VERSION
+  spec.authors       = ["tanvir hasan"]
+  spec.email         = ["tanvir002700@gmail.com"]
+
+  spec.summary       = %q{This gem packages the js lory.js plugin. So you never have to download a custom package through the web interface again.}
+  spec.description   = %q{Touch enabled minimalistic slider written in vanilla JavaScript.}
+  spec.homepage      = "https://rubygems.org/gems/lory-rails"
+  spec.license       = "MIT"
+  spec.metadata      = { 'source_code_uri' => 'https://github.com/tanvir002700/lory-rails' }
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/vendor/assets/javascripts/lory.js

@@ -0,0 +1,1007 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else {
+		var a = factory();
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(typeof self !== 'undefined' ? self : this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, {
+/******/ 				configurable: false,
+/******/ 				enumerable: true,
+/******/ 				get: getter
+/******/ 			});
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 7);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports) {
+
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || Function("return this")() || (1,eval)("this");
+} catch(e) {
+	// This works if the window reference is available
+	if(typeof window === "object")
+		g = window;
+}
+
+// g can still be undefined, but nothing to do about it...
+// We return undefined, instead of nothing here, so it's
+// easier to handle this case. if(!global) { ...}
+
+module.exports = g;
+
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; /* globals jQuery */
+
+exports.lory = lory;
+
+var _detectPrefixes = __webpack_require__(2);
+
+var _detectPrefixes2 = _interopRequireDefault(_detectPrefixes);
+
+var _detectSupportsPassive = __webpack_require__(3);
+
+var _detectSupportsPassive2 = _interopRequireDefault(_detectSupportsPassive);
+
+var _dispatchEvent = __webpack_require__(4);
+
+var _dispatchEvent2 = _interopRequireDefault(_dispatchEvent);
+
+var _defaults = __webpack_require__(6);
+
+var _defaults2 = _interopRequireDefault(_defaults);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var slice = Array.prototype.slice;
+
+function lory(slider, opts) {
+    var position = void 0;
+    var slidesWidth = void 0;
+    var frameWidth = void 0;
+    var slides = void 0;
+
+    /**
+     * slider DOM elements
+     */
+    var frame = void 0;
+    var slideContainer = void 0;
+    var prevCtrl = void 0;
+    var nextCtrl = void 0;
+    var prefixes = void 0;
+    var transitionEndCallback = void 0;
+
+    var index = 0;
+    var options = {};
+    var touchEventParams = (0, _detectSupportsPassive2.default)() ? { passive: true } : false;
+
+    /**
+     * if object is jQuery convert to native DOM element
+     */
+    if (typeof jQuery !== 'undefined' && slider instanceof jQuery) {
+        slider = slider[0];
+    }
+
+    /**
+     * private
+     * set active class to element which is the current slide
+     */
+    function setActiveElement(slides, currentIndex) {
+        var _options = options,
+            classNameActiveSlide = _options.classNameActiveSlide;
+
+
+        slides.forEach(function (element, index) {
+            if (element.classList.contains(classNameActiveSlide)) {
+                element.classList.remove(classNameActiveSlide);
+            }
+        });
+
+        slides[currentIndex].classList.add(classNameActiveSlide);
+    }
+
+    /**
+     * private
+     * setupInfinite: function to setup if infinite is set
+     *
+     * @param  {array} slideArray
+     * @return {array} array of updated slideContainer elements
+     */
+    function setupInfinite(slideArray) {
+        var _options2 = options,
+            infinite = _options2.infinite;
+
+
+        var front = slideArray.slice(0, infinite);
+        var back = slideArray.slice(slideArray.length - infinite, slideArray.length);
+
+        front.forEach(function (element) {
+            var cloned = element.cloneNode(true);
+
+            slideContainer.appendChild(cloned);
+        });
+
+        back.reverse().forEach(function (element) {
+            var cloned = element.cloneNode(true);
+
+            slideContainer.insertBefore(cloned, slideContainer.firstChild);
+        });
+
+        slideContainer.addEventListener(prefixes.transitionEnd, onTransitionEnd);
+
+        return slice.call(slideContainer.children);
+    }
+
+    /**
+     * [dispatchSliderEvent description]
+     * @return {[type]} [description]
+     */
+    function dispatchSliderEvent(phase, type, detail) {
+        (0, _dispatchEvent2.default)(slider, phase + '.lory.' + type, detail);
+    }
+
+    /**
+     * translates to a given position in a given time in milliseconds
+     *
+     * @to        {number} number in pixels where to translate to
+     * @duration  {number} time in milliseconds for the transistion
+     * @ease      {string} easing css property
+     */
+    function translate(to, duration, ease) {
+        var style = slideContainer && slideContainer.style;
+
+        if (style) {
+            style[prefixes.transition + 'TimingFunction'] = ease;
+            style[prefixes.transition + 'Duration'] = duration + 'ms';
+
+            if (prefixes.hasTranslate3d) {
+                style[prefixes.transform] = 'translate3d(' + to + 'px, 0, 0)';
+            } else {
+                style[prefixes.transform] = 'translate(' + to + 'px, 0)';
+            }
+        }
+    }
+
+    /**
+     * slidefunction called by prev, next & touchend
+     *
+     * determine nextIndex and slide to next postion
+     * under restrictions of the defined options
+     *
+     * @direction  {boolean}
+     */
+    function slide(nextIndex, direction) {
+        var _options3 = options,
+            slideSpeed = _options3.slideSpeed,
+            slidesToScroll = _options3.slidesToScroll,
+            infinite = _options3.infinite,
+            rewind = _options3.rewind,
+            rewindSpeed = _options3.rewindSpeed,
+            ease = _options3.ease,
+            classNameActiveSlide = _options3.classNameActiveSlide;
+
+
+        var duration = slideSpeed;
+
+        var nextSlide = direction ? index + 1 : index - 1;
+        var maxOffset = Math.round(slidesWidth - frameWidth);
+
+        dispatchSliderEvent('before', 'slide', {
+            index: index,
+            nextSlide: nextSlide
+        });
+
+        /**
+         * Reset control classes
+         */
+        if (prevCtrl) {
+            prevCtrl.classList.remove('disabled');
+        }
+        if (nextCtrl) {
+            nextCtrl.classList.remove('disabled');
+        }
+
+        if (typeof nextIndex !== 'number') {
+            if (direction) {
+                nextIndex = index + slidesToScroll;
+            } else {
+                nextIndex = index - slidesToScroll;
+            }
+        }
+
+        nextIndex = Math.min(Math.max(nextIndex, 0), slides.length - 1);
+
+        if (infinite && direction === undefined) {
+            nextIndex += infinite;
+        }
+
+        var nextOffset = Math.min(Math.max(slides[nextIndex].offsetLeft * -1, maxOffset * -1), 0);
+
+        if (rewind && Math.abs(position.x) === maxOffset && direction) {
+            nextOffset = 0;
+            nextIndex = 0;
+            duration = rewindSpeed;
+        }
+
+        /**
+         * translate to the nextOffset by a defined duration and ease function
+         */
+        translate(nextOffset, duration, ease);
+
+        /**
+         * update the position with the next position
+         */
+        position.x = nextOffset;
+
+        /**
+         * update the index with the nextIndex only if
+         * the offset of the nextIndex is in the range of the maxOffset
+         */
+        if (slides[nextIndex].offsetLeft <= maxOffset) {
+            index = nextIndex;
+        }
+
+        if (infinite && (nextIndex === slides.length - infinite || nextIndex === 0)) {
+            if (direction) {
+                index = infinite;
+            }
+
+            if (!direction) {
+                index = slides.length - infinite * 2;
+            }
+
+            position.x = slides[index].offsetLeft * -1;
+
+            transitionEndCallback = function transitionEndCallback() {
+                translate(slides[index].offsetLeft * -1, 0, undefined);
+            };
+        }
+
+        if (classNameActiveSlide) {
+            setActiveElement(slice.call(slides), index);
+        }
+
+        /**
+         * update classes for next and prev arrows
+         * based on user settings
+         */
+        if (prevCtrl && !infinite && nextIndex === 0) {
+            prevCtrl.classList.add('disabled');
+        }
+
+        if (nextCtrl && !infinite && !rewind && nextIndex + 1 === slides.length) {
+            nextCtrl.classList.add('disabled');
+        }
+
+        dispatchSliderEvent('after', 'slide', {
+            currentSlide: index
+        });
+    }
+
+    /**
+     * public
+     * setup function
+     */
+    function setup() {
+        dispatchSliderEvent('before', 'init');
+
+        prefixes = (0, _detectPrefixes2.default)();
+        options = _extends({}, _defaults2.default, opts);
+
+        var _options4 = options,
+            classNameFrame = _options4.classNameFrame,
+            classNameSlideContainer = _options4.classNameSlideContainer,
+            classNamePrevCtrl = _options4.classNamePrevCtrl,
+            classNameNextCtrl = _options4.classNameNextCtrl,
+            enableMouseEvents = _options4.enableMouseEvents,
+            classNameActiveSlide = _options4.classNameActiveSlide,
+            initialIndex = _options4.initialIndex;
+
+
+        index = initialIndex;
+        frame = slider.getElementsByClassName(classNameFrame)[0];
+        slideContainer = frame.getElementsByClassName(classNameSlideContainer)[0];
+        prevCtrl = slider.getElementsByClassName(classNamePrevCtrl)[0];
+        nextCtrl = slider.getElementsByClassName(classNameNextCtrl)[0];
+
+        position = {
+            x: slideContainer.offsetLeft,
+            y: slideContainer.offsetTop
+        };
+
+        if (options.infinite) {
+            slides = setupInfinite(slice.call(slideContainer.children));
+        } else {
+            slides = slice.call(slideContainer.children);
+
+            if (prevCtrl) {
+                prevCtrl.classList.add('disabled');
+            }
+
+            if (nextCtrl && slides.length === 1 && !options.rewind) {
+                nextCtrl.classList.add('disabled');
+            }
+        }
+
+        reset();
+
+        if (classNameActiveSlide) {
+            setActiveElement(slides, index);
+        }
+
+        if (prevCtrl && nextCtrl) {
+            prevCtrl.addEventListener('click', prev);
+            nextCtrl.addEventListener('click', next);
+        }
+
+        frame.addEventListener('touchstart', onTouchstart, touchEventParams);
+
+        if (enableMouseEvents) {
+            frame.addEventListener('mousedown', onTouchstart);
+            frame.addEventListener('click', onClick);
+        }
+
+        options.window.addEventListener('resize', onResize);
+
+        dispatchSliderEvent('after', 'init');
+    }
+
+    /**
+     * public
+     * reset function: called on resize
+     */
+    function reset() {
+        var _options5 = options,
+            infinite = _options5.infinite,
+            ease = _options5.ease,
+            rewindSpeed = _options5.rewindSpeed,
+            rewindOnResize = _options5.rewindOnResize,
+            classNameActiveSlide = _options5.classNameActiveSlide,
+            initialIndex = _options5.initialIndex;
+
+
+        slidesWidth = slideContainer.getBoundingClientRect().width || slideContainer.offsetWidth;
+        frameWidth = frame.getBoundingClientRect().width || frame.offsetWidth;
+
+        if (frameWidth === slidesWidth) {
+            slidesWidth = slides.reduce(function (previousValue, slide) {
+                return previousValue + slide.getBoundingClientRect().width || slide.offsetWidth;
+            }, 0);
+        }
+
+        if (rewindOnResize) {
+            index = initialIndex;
+        } else {
+            ease = null;
+            rewindSpeed = 0;
+        }
+
+        if (infinite) {
+            translate(slides[index + infinite].offsetLeft * -1, 0, null);
+
+            index = index + infinite;
+            position.x = slides[index].offsetLeft * -1;
+        } else {
+            translate(slides[index].offsetLeft * -1, rewindSpeed, ease);
+            position.x = slides[index].offsetLeft * -1;
+        }
+
+        if (classNameActiveSlide) {
+            setActiveElement(slice.call(slides), index);
+        }
+    }
+
+    /**
+     * public
+     * slideTo: called on clickhandler
+     */
+    function slideTo(index) {
+        slide(index);
+    }
+
+    /**
+     * public
+     * returnIndex function: called on clickhandler
+     */
+    function returnIndex() {
+        return index - options.infinite || 0;
+    }
+
+    /**
+     * public
+     * prev function: called on clickhandler
+     */
+    function prev() {
+        slide(false, false);
+    }
+
+    /**
+     * public
+     * next function: called on clickhandler
+     */
+    function next() {
+        slide(false, true);
+    }
+
+    /**
+     * public
+     * destroy function: called to gracefully destroy the lory instance
+     */
+    function destroy() {
+        dispatchSliderEvent('before', 'destroy');
+
+        // remove event listeners
+        frame.removeEventListener(prefixes.transitionEnd, onTransitionEnd);
+        frame.removeEventListener('touchstart', onTouchstart, touchEventParams);
+        frame.removeEventListener('touchmove', onTouchmove, touchEventParams);
+        frame.removeEventListener('touchend', onTouchend);
+        frame.removeEventListener('mousemove', onTouchmove);
+        frame.removeEventListener('mousedown', onTouchstart);
+        frame.removeEventListener('mouseup', onTouchend);
+        frame.removeEventListener('mouseleave', onTouchend);
+        frame.removeEventListener('click', onClick);
+
+        options.window.removeEventListener('resize', onResize);
+
+        if (prevCtrl) {
+            prevCtrl.removeEventListener('click', prev);
+        }
+
+        if (nextCtrl) {
+            nextCtrl.removeEventListener('click', next);
+        }
+
+        // remove cloned slides if infinite is set
+        if (options.infinite) {
+            Array.apply(null, Array(options.infinite)).forEach(function () {
+                slideContainer.removeChild(slideContainer.firstChild);
+                slideContainer.removeChild(slideContainer.lastChild);
+            });
+        }
+
+        dispatchSliderEvent('after', 'destroy');
+    }
+
+    // event handling
+
+    var touchOffset = void 0;
+    var delta = void 0;
+    var isScrolling = void 0;
+
+    function onTransitionEnd() {
+        if (transitionEndCallback) {
+            transitionEndCallback();
+
+            transitionEndCallback = undefined;
+        }
+    }
+
+    function onTouchstart(event) {
+        var _options6 = options,
+            enableMouseEvents = _options6.enableMouseEvents;
+
+        var touches = event.touches ? event.touches[0] : event;
+
+        if (enableMouseEvents) {
+            frame.addEventListener('mousemove', onTouchmove);
+            frame.addEventListener('mouseup', onTouchend);
+            frame.addEventListener('mouseleave', onTouchend);
+        }
+
+        frame.addEventListener('touchmove', onTouchmove, touchEventParams);
+        frame.addEventListener('touchend', onTouchend);
+
+        var pageX = touches.pageX,
+            pageY = touches.pageY;
+
+
+        touchOffset = {
+            x: pageX,
+            y: pageY,
+            time: Date.now()
+        };
+
+        isScrolling = undefined;
+
+        delta = {};
+
+        dispatchSliderEvent('on', 'touchstart', {
+            event: event
+        });
+    }
+
+    function onTouchmove(event) {
+        var touches = event.touches ? event.touches[0] : event;
+        var pageX = touches.pageX,
+            pageY = touches.pageY;
+
+
+        delta = {
+            x: pageX - touchOffset.x,
+            y: pageY - touchOffset.y
+        };
+
+        if (typeof isScrolling === 'undefined') {
+            isScrolling = !!(isScrolling || Math.abs(delta.x) < Math.abs(delta.y));
+        }
+
+        if (!isScrolling && touchOffset) {
+            event.preventDefault();
+            translate(position.x + delta.x, 0, null);
+        }
+
+        // may be
+        dispatchSliderEvent('on', 'touchmove', {
+            event: event
+        });
+    }
+
+    function onTouchend(event) {
+        /**
+         * time between touchstart and touchend in milliseconds
+         * @duration {number}
+         */
+        var duration = touchOffset ? Date.now() - touchOffset.time : undefined;
+
+        /**
+         * is valid if:
+         *
+         * -> swipe attempt time is over 300 ms
+         * and
+         * -> swipe distance is greater than 25px
+         * or
+         * -> swipe distance is more then a third of the swipe area
+         *
+         * @isValidSlide {Boolean}
+         */
+        var isValid = Number(duration) < 300 && Math.abs(delta.x) > 25 || Math.abs(delta.x) > frameWidth / 3;
+
+        /**
+         * is out of bounds if:
+         *
+         * -> index is 0 and delta x is greater than 0
+         * or
+         * -> index is the last slide and delta is smaller than 0
+         *
+         * @isOutOfBounds {Boolean}
+         */
+        var isOutOfBounds = !index && delta.x > 0 || index === slides.length - 1 && delta.x < 0;
+
+        var direction = delta.x < 0;
+
+        if (!isScrolling) {
+            if (isValid && !isOutOfBounds) {
+                slide(false, direction);
+            } else {
+                translate(position.x, options.snapBackSpeed);
+            }
+        }
+
+        touchOffset = undefined;
+
+        /**
+         * remove eventlisteners after swipe attempt
+         */
+        frame.removeEventListener('touchmove', onTouchmove);
+        frame.removeEventListener('touchend', onTouchend);
+        frame.removeEventListener('mousemove', onTouchmove);
+        frame.removeEventListener('mouseup', onTouchend);
+        frame.removeEventListener('mouseleave', onTouchend);
+
+        dispatchSliderEvent('on', 'touchend', {
+            event: event
+        });
+    }
+
+    function onClick(event) {
+        if (delta.x) {
+            event.preventDefault();
+        }
+    }
+
+    function onResize(event) {
+        reset();
+
+        dispatchSliderEvent('on', 'resize', {
+            event: event
+        });
+    }
+
+    // trigger initial setup
+    setup();
+
+    // expose public api
+    return {
+        setup: setup,
+        reset: reset,
+        slideTo: slideTo,
+        returnIndex: returnIndex,
+        prev: prev,
+        next: next,
+        destroy: destroy
+    };
+}
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = detectPrefixes;
+/**
+ * Detecting prefixes for saving time and bytes
+ */
+function detectPrefixes() {
+    var transform = void 0;
+    var transition = void 0;
+    var transitionEnd = void 0;
+    var hasTranslate3d = void 0;
+
+    (function () {
+        var el = document.createElement('_');
+        var style = el.style;
+
+        var prop = void 0;
+
+        if (style[prop = 'webkitTransition'] === '') {
+            transitionEnd = 'webkitTransitionEnd';
+            transition = prop;
+        }
+
+        if (style[prop = 'transition'] === '') {
+            transitionEnd = 'transitionend';
+            transition = prop;
+        }
+
+        if (style[prop = 'webkitTransform'] === '') {
+            transform = prop;
+        }
+
+        if (style[prop = 'msTransform'] === '') {
+            transform = prop;
+        }
+
+        if (style[prop = 'transform'] === '') {
+            transform = prop;
+        }
+
+        document.body.insertBefore(el, null);
+        style[transform] = 'translate3d(0, 0, 0)';
+        hasTranslate3d = !!global.getComputedStyle(el).getPropertyValue(transform);
+        document.body.removeChild(el);
+    })();
+
+    return {
+        transform: transform,
+        transition: transition,
+        transitionEnd: transitionEnd,
+        hasTranslate3d: hasTranslate3d
+    };
+}
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = detectSupportsPassive;
+function detectSupportsPassive() {
+    var supportsPassive = false;
+
+    try {
+        var opts = Object.defineProperty({}, 'passive', {
+            get: function get() {
+                supportsPassive = true;
+            }
+        });
+
+        window.addEventListener('testPassive', null, opts);
+        window.removeEventListener('testPassive', null, opts);
+    } catch (e) {}
+
+    return supportsPassive;
+}
+
+/***/ }),
+/* 4 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = dispatchEvent;
+
+var _customEvent = __webpack_require__(5);
+
+var _customEvent2 = _interopRequireDefault(_customEvent);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * dispatch custom events
+ *
+ * @param  {element} el         slideshow element
+ * @param  {string}  type       custom event name
+ * @param  {object}  detail     custom detail information
+ */
+function dispatchEvent(target, type, detail) {
+    var event = new _customEvent2.default(type, {
+        bubbles: true,
+        cancelable: true,
+        detail: detail
+    });
+
+    target.dispatchEvent(event);
+}
+
+/***/ }),
+/* 5 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(global) {
+var NativeCustomEvent = global.CustomEvent;
+
+function useNative () {
+  try {
+    var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } });
+    return  'cat' === p.type && 'bar' === p.detail.foo;
+  } catch (e) {
+  }
+  return false;
+}
+
+/**
+ * Cross-browser `CustomEvent` constructor.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent
+ *
+ * @public
+ */
+
+module.exports = useNative() ? NativeCustomEvent :
+
+// IE >= 9
+'undefined' !== typeof document && 'function' === typeof document.createEvent ? function CustomEvent (type, params) {
+  var e = document.createEvent('CustomEvent');
+  if (params) {
+    e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail);
+  } else {
+    e.initCustomEvent(type, false, false, void 0);
+  }
+  return e;
+} :
+
+// IE <= 8
+function CustomEvent (type, params) {
+  var e = document.createEventObject();
+  e.type = type;
+  if (params) {
+    e.bubbles = Boolean(params.bubbles);
+    e.cancelable = Boolean(params.cancelable);
+    e.detail = params.detail;
+  } else {
+    e.bubbles = false;
+    e.cancelable = false;
+    e.detail = void 0;
+  }
+  return e;
+}
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
+
+/***/ }),
+/* 6 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = {
+  /**
+   * slides scrolled at once
+   * @slidesToScroll {Number}
+   */
+  slidesToScroll: 1,
+
+  /**
+   * time in milliseconds for the animation of a valid slide attempt
+   * @slideSpeed {Number}
+   */
+  slideSpeed: 300,
+
+  /**
+   * time in milliseconds for the animation of the rewind after the last slide
+   * @rewindSpeed {Number}
+   */
+  rewindSpeed: 600,
+
+  /**
+   * time for the snapBack of the slider if the slide attempt was not valid
+   * @snapBackSpeed {Number}
+   */
+  snapBackSpeed: 200,
+
+  /**
+   * Basic easing functions: https://developer.mozilla.org/de/docs/Web/CSS/transition-timing-function
+   * cubic bezier easing functions: http://easings.net/de
+   * @ease {String}
+   */
+  ease: 'ease',
+
+  /**
+   * if slider reached the last slide, with next click the slider goes back to the startindex.
+   * use infinite or rewind, not both
+   * @rewind {Boolean}
+   */
+  rewind: false,
+
+  /**
+   * number of visible slides or false
+   * use infinite or rewind, not both
+   * @infinite {number}
+   */
+  infinite: false,
+
+  /**
+   * the slide index to show when the slider is initialized.
+   * @initialIndex {number}
+   */
+  initialIndex: 0,
+
+  /**
+   * class name for slider frame
+   * @classNameFrame {string}
+   */
+  classNameFrame: 'js_frame',
+
+  /**
+   * class name for slides container
+   * @classNameSlideContainer {string}
+   */
+  classNameSlideContainer: 'js_slides',
+
+  /**
+   * class name for slider prev control
+   * @classNamePrevCtrl {string}
+   */
+  classNamePrevCtrl: 'js_prev',
+
+  /**
+   * class name for slider next control
+   * @classNameNextCtrl {string}
+   */
+  classNameNextCtrl: 'js_next',
+
+  /**
+   * class name for current active slide
+   * if emptyString then no class is set
+   * @classNameActiveSlide {string}
+   */
+  classNameActiveSlide: 'active',
+
+  /**
+   * enables mouse events for swiping on desktop devices
+   * @enableMouseEvents {boolean}
+   */
+  enableMouseEvents: false,
+
+  /**
+   * window instance
+   * @window {object}
+   */
+  window: window,
+
+  /**
+   * If false, slides lory to the first slide on window resize.
+   * @rewindOnResize {boolean}
+   */
+  rewindOnResize: true
+};
+
+/***/ }),
+/* 7 */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(1);
+
+
+/***/ })
+/******/ ]);
+});

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: lory-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- tanvir hasan
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Touch enabled minimalistic slider written in vanilla JavaScript.
+email:
+- tanvir002700@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSIONS.md
+- lib/lory/rails.rb
+- lib/lory/rails/engine.rb
+- lib/lory/rails/version.rb
+- lory-rails.gemspec
+- vendor/assets/javascripts/lory.js
+homepage: https://rubygems.org/gems/lory-rails
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/tanvir002700/lory-rails
+  allowed_push_host: https://rubygems.org
+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.6.11
+signing_key: 
+specification_version: 4
+summary: This gem packages the js lory.js plugin. So you never have to download a
+  custom package through the web interface again.
+test_files: []