switchery-rails 0.1.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08e744c4b7d4f10a31bcad0bf39e08addde8a84e
-  data.tar.gz: 9d29c526d5cceb4e2fb9fc25df43d43d005b81e2
+  metadata.gz: 67fef65691b2777c85b1264bbbe619f21a943311
+  data.tar.gz: b7fd5512ba99d5d581fac9b1762685082ce1a043
 SHA512:
-  metadata.gz: e2cda3fcbd2062ae1dbff9520f179a62620c1589b6f1b66015ba83229c79853b6441dcc1d711396a7fa344d893dd826316bedeaf67144df9e64168f0be51214e
-  data.tar.gz: 55c1bb340bd4a2583db26c607945d8e87bd03a8da1be11e7853cf5a3894cc021d57d86b76826b451e9fac3780acfa948409961590d6acbd1d76eecb6aa890701
+  metadata.gz: ddf413a66709204db4aac7fc5a68b49a0fb8cef7de69cb2bf42afc59e736585949e41a975d3be13da8011437649652ad28d61d0a58026b1805abf15e10a7b6b0
+  data.tar.gz: b04a4bb9838674e3e22a9f79d351372423d4eaea1f48b50c7e0613112121fcc27b44572a0229a9bbdaffb23dcb331329275213d310f7fb58a41421ae0d7495b7

data/Dockerfile

@@ -0,0 +1,53 @@
+# Switchery-rails gem Dockerfile
+#
+# How to use it
+# =============
+#
+# $ sudo docker build -t zedtux/switchery-rails .
+# $ sudo docker run -it zedtux/switchery-rails
+# rake build             # Build switchery-rails-0.1.0.gem into the pkg directory
+# rake install           # Build and install switchery-rails-0.1.0.gem into system gems
+# rake install:local     # Build and install switchery-rails-0.1.0.gem into system gems without network access
+# rake release           # Create tag v0.1.0 and build and push switchery-rails-0.1.0.gem to Rubygems
+# rake update_switchery  # Update the Switchery Javascript and CSS files
+#
+# Update the Switchery library
+# ----------------------------
+#
+# Update the file `lib/switchery/rails/version.rb` in order to set the Switchery version to download then:
+#
+# $ sudo docker run --rm -v `pwd`:/gem/ -it zedtux/switchery-rails rake update_switchery
+# Downlading Switchery 0.8.0 ...
+# Done!
+#
+
+# ~~~~ Image base ~~~~
+# Base image with the latest Ruby only
+FROM litaio/ruby:2.2.2
+MAINTAINER Guillaume Hain zedtux@zedroot.org
+
+
+# ~~~~ Set up the environment ~~~~
+ENV DEBIAN_FRONTEND noninteractive
+
+# ~~~~ OS Maintenance ~~~~
+RUN apt-get update && apt-get install -y git
+
+# ~~~~ Rails Preparation ~~~~
+# Rubygems and Bundler
+RUN touch ~/.gemrc && \
+  echo "gem: --no-ri --no-rdoc" >> ~/.gemrc && \
+  gem install rubygems-update && \
+  update_rubygems && \
+  gem install bundler && \
+  mkdir -p /gem/
+
+WORKDIR /gem/
+ADD . /gem/
+RUN bundle install
+
+# Import the gem source code
+VOLUME .:/gem/
+
+ENTRYPOINT ["bundle", "exec"]
+CMD ["rake", "-T"]

data/README.md

@@ -1,6 +1,6 @@
 # switchery-rails
 
-Switchery for Rails.
+[Switchery](https://github.com/abpetkov/switchery) for Rails.
 
 ## Installation
 

data/Rakefile

@@ -14,6 +14,6 @@ task :update_switchery do
 
   FileUtils.mkdir_p('vendor/assets/javascripts')
   FileUtils.mkdir_p('vendor/assets/stylesheets')
-  download_switchery(Switchery::Rails::SWITCHERY_VERSION)
+  download_switchery(Switchery::Rails::VERSION)
   puts "\e[32mDone!\e[0m"
 end

data/lib/switchery/rails/version.rb

@@ -1,6 +1,5 @@
 module Switchery
   module Rails
-    VERSION = '0.1.0'
-    SWITCHERY_VERSION = '0.7.0'
+    VERSION = '0.8.0'
   end
 end

data/vendor/assets/javascripts/switchery.js

@@ -98,7 +98,7 @@ require.latest = function (name, returnPath) {
   }
   // if the build contains more than one branch of the same module
   // you should not use this funciton
-  var module = otherCandidates.pop().name;
+  var module = otherCandidates.sort(function(a, b) {return a.name > b.name})[0].name;
   if (returnPath === true) {
     return module;
   }
@@ -1195,15 +1195,377 @@ ClassList.prototype.contains = function(name){
 
 });
 
+require.register("component~event@0.1.4", function (exports, module) {
+var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',
+    unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
+    prefix = bind !== 'addEventListener' ? 'on' : '';
+
+/**
+ * Bind `el` event `type` to `fn`.
+ *
+ * @param {Element} el
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @return {Function}
+ * @api public
+ */
+
+exports.bind = function(el, type, fn, capture){
+  el[bind](prefix + type, fn, capture || false);
+  return fn;
+};
+
+/**
+ * Unbind `el` event `type`'s callback `fn`.
+ *
+ * @param {Element} el
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @return {Function}
+ * @api public
+ */
+
+exports.unbind = function(el, type, fn, capture){
+  el[unbind](prefix + type, fn, capture || false);
+  return fn;
+};
+});
+
+require.register("component~query@0.0.3", function (exports, module) {
+function one(selector, el) {
+  return el.querySelector(selector);
+}
+
+exports = module.exports = function(selector, el){
+  el = el || document;
+  return one(selector, el);
+};
+
+exports.all = function(selector, el){
+  el = el || document;
+  return el.querySelectorAll(selector);
+};
+
+exports.engine = function(obj){
+  if (!obj.one) throw new Error('.one callback required');
+  if (!obj.all) throw new Error('.all callback required');
+  one = obj.one;
+  exports.all = obj.all;
+  return exports;
+};
+
+});
+
+require.register("component~matches-selector@0.1.5", function (exports, module) {
+/**
+ * Module dependencies.
+ */
+
+var query = require('component~query@0.0.3');
+
+/**
+ * Element prototype.
+ */
+
+var proto = Element.prototype;
+
+/**
+ * Vendor function.
+ */
+
+var vendor = proto.matches
+  || proto.webkitMatchesSelector
+  || proto.mozMatchesSelector
+  || proto.msMatchesSelector
+  || proto.oMatchesSelector;
+
+/**
+ * Expose `match()`.
+ */
+
+module.exports = match;
+
+/**
+ * Match `el` to `selector`.
+ *
+ * @param {Element} el
+ * @param {String} selector
+ * @return {Boolean}
+ * @api public
+ */
+
+function match(el, selector) {
+  if (!el || el.nodeType !== 1) return false;
+  if (vendor) return vendor.call(el, selector);
+  var nodes = query.all(selector, el.parentNode);
+  for (var i = 0; i < nodes.length; ++i) {
+    if (nodes[i] == el) return true;
+  }
+  return false;
+}
+
+});
+
+require.register("component~closest@0.1.4", function (exports, module) {
+var matches = require('component~matches-selector@0.1.5')
+
+module.exports = function (element, selector, checkYoSelf, root) {
+  element = checkYoSelf ? {parentNode: element} : element
+
+  root = root || document
+
+  // Make sure `element !== document` and `element != null`
+  // otherwise we get an illegal invocation
+  while ((element = element.parentNode) && element !== document) {
+    if (matches(element, selector))
+      return element
+    // After `matches` on the edge case that
+    // the selector matches the root
+    // (when the root is not the document)
+    if (element === root)
+      return
+  }
+}
+
+});
+
+require.register("component~delegate@0.2.3", function (exports, module) {
+/**
+ * Module dependencies.
+ */
+
+var closest = require('component~closest@0.1.4')
+  , event = require('component~event@0.1.4');
+
+/**
+ * Delegate event `type` to `selector`
+ * and invoke `fn(e)`. A callback function
+ * is returned which may be passed to `.unbind()`.
+ *
+ * @param {Element} el
+ * @param {String} selector
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @return {Function}
+ * @api public
+ */
+
+exports.bind = function(el, selector, type, fn, capture){
+  return event.bind(el, type, function(e){
+    var target = e.target || e.srcElement;
+    e.delegateTarget = closest(target, selector, true, el);
+    if (e.delegateTarget) fn.call(el, e);
+  }, capture);
+};
+
+/**
+ * Unbind event `type`'s callback `fn`.
+ *
+ * @param {Element} el
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @api public
+ */
+
+exports.unbind = function(el, type, fn, capture){
+  event.unbind(el, type, fn, capture);
+};
+
+});
+
+require.register("component~events@1.0.9", function (exports, module) {
+
+/**
+ * Module dependencies.
+ */
+
+var events = require('component~event@0.1.4');
+var delegate = require('component~delegate@0.2.3');
+
+/**
+ * Expose `Events`.
+ */
+
+module.exports = Events;
+
+/**
+ * Initialize an `Events` with the given
+ * `el` object which events will be bound to,
+ * and the `obj` which will receive method calls.
+ *
+ * @param {Object} el
+ * @param {Object} obj
+ * @api public
+ */
+
+function Events(el, obj) {
+  if (!(this instanceof Events)) return new Events(el, obj);
+  if (!el) throw new Error('element required');
+  if (!obj) throw new Error('object required');
+  this.el = el;
+  this.obj = obj;
+  this._events = {};
+}
+
+/**
+ * Subscription helper.
+ */
+
+Events.prototype.sub = function(event, method, cb){
+  this._events[event] = this._events[event] || {};
+  this._events[event][method] = cb;
+};
+
+/**
+ * Bind to `event` with optional `method` name.
+ * When `method` is undefined it becomes `event`
+ * with the "on" prefix.
+ *
+ * Examples:
+ *
+ *  Direct event handling:
+ *
+ *    events.bind('click') // implies "onclick"
+ *    events.bind('click', 'remove')
+ *    events.bind('click', 'sort', 'asc')
+ *
+ *  Delegated event handling:
+ *
+ *    events.bind('click li > a')
+ *    events.bind('click li > a', 'remove')
+ *    events.bind('click a.sort-ascending', 'sort', 'asc')
+ *    events.bind('click a.sort-descending', 'sort', 'desc')
+ *
+ * @param {String} event
+ * @param {String|function} [method]
+ * @return {Function} callback
+ * @api public
+ */
+
+Events.prototype.bind = function(event, method){
+  var e = parse(event);
+  var el = this.el;
+  var obj = this.obj;
+  var name = e.name;
+  var method = method || 'on' + name;
+  var args = [].slice.call(arguments, 2);
+
+  // callback
+  function cb(){
+    var a = [].slice.call(arguments).concat(args);
+    obj[method].apply(obj, a);
+  }
+
+  // bind
+  if (e.selector) {
+    cb = delegate.bind(el, e.selector, name, cb);
+  } else {
+    events.bind(el, name, cb);
+  }
+
+  // subscription for unbinding
+  this.sub(name, method, cb);
+
+  return cb;
+};
+
+/**
+ * Unbind a single binding, all bindings for `event`,
+ * or all bindings within the manager.
+ *
+ * Examples:
+ *
+ *  Unbind direct handlers:
+ *
+ *     events.unbind('click', 'remove')
+ *     events.unbind('click')
+ *     events.unbind()
+ *
+ * Unbind delegate handlers:
+ *
+ *     events.unbind('click', 'remove')
+ *     events.unbind('click')
+ *     events.unbind()
+ *
+ * @param {String|Function} [event]
+ * @param {String|Function} [method]
+ * @api public
+ */
+
+Events.prototype.unbind = function(event, method){
+  if (0 == arguments.length) return this.unbindAll();
+  if (1 == arguments.length) return this.unbindAllOf(event);
+
+  // no bindings for this event
+  var bindings = this._events[event];
+  if (!bindings) return;
+
+  // no bindings for this method
+  var cb = bindings[method];
+  if (!cb) return;
+
+  events.unbind(this.el, event, cb);
+};
+
+/**
+ * Unbind all events.
+ *
+ * @api private
+ */
+
+Events.prototype.unbindAll = function(){
+  for (var event in this._events) {
+    this.unbindAllOf(event);
+  }
+};
+
+/**
+ * Unbind all events for `event`.
+ *
+ * @param {String} event
+ * @api private
+ */
+
+Events.prototype.unbindAllOf = function(event){
+  var bindings = this._events[event];
+  if (!bindings) return;
+
+  for (var method in bindings) {
+    this.unbind(event, method);
+  }
+};
+
+/**
+ * Parse `event`.
+ *
+ * @param {String} event
+ * @return {Object}
+ * @api private
+ */
+
+function parse(event) {
+  var parts = event.split(/ +/);
+  return {
+    name: parts.shift(),
+    selector: parts.join(' ')
+  }
+}
+
+});
+
 require.register("switchery", function (exports, module) {
 /**
- * Switchery 0.7.0
+ * Switchery 0.8.0
  * http://abpetkov.github.io/switchery/
  *
  * Authored by Alexander Petkov
  * https://github.com/abpetkov
  *
- * Copyright 2013-2014, Alexander Petkov
+ * Copyright 2013-2015, Alexander Petkov
  * License: The MIT License (MIT)
  * http://opensource.org/licenses/MIT
  *
@@ -1215,7 +1577,8 @@ require.register("switchery", function (exports, module) {
 
 var transitionize = require('abpetkov~transitionize@0.0.3')
   , fastclick = require('ftlabs~fastclick@v0.6.11')
-  , classes = require('component~classes@1.2.1');
+  , classes = require('component~classes@1.2.1')
+  , events = require('component~events@1.0.9');
 
 /**
  * Expose `Switchery`.
@@ -1230,14 +1593,15 @@ module.exports = Switchery;
  */
 
 var defaults = {
-    color          : '#64bd63'
-  , secondaryColor : '#dfdfdf'
-  , jackColor      : '#fff'
-  , className      : 'switchery'
-  , disabled       : false
-  , disabledOpacity: 0.5
-  , speed          : '0.4s'
-  , size           : 'default'
+    color             : '#64bd63'
+  , secondaryColor    : '#dfdfdf'
+  , jackColor         : '#fff'
+  , jackSecondaryColor: null
+  , className         : 'switchery'
+  , disabled          : false
+  , disabledOpacity   : 0.5
+  , speed             : '0.4s'
+  , size              : 'default'
 };
 
 /**
@@ -1261,6 +1625,7 @@ function Switchery(element, options) {
   }
 
   if (this.element != null && this.element.type == 'checkbox') this.init();
+  if (this.isDisabled() === true) this.disable();
 }
 
 /**
@@ -1296,6 +1661,7 @@ Switchery.prototype.create = function() {
   this.jack = document.createElement('small');
   this.switcher.appendChild(this.jack);
   this.switcher.className = this.options.className;
+  this.events = events(this.switcher, this);
 
   return this.switcher;
 };
@@ -1312,28 +1678,6 @@ Switchery.prototype.insertAfter = function(reference, target) {
   reference.parentNode.insertBefore(target, reference.nextSibling);
 };
 
-/**
- * See if input is checked.
- *
- * @returns {Boolean}
- * @api private
- */
-
-Switchery.prototype.isChecked = function() {
-  return this.element.checked;
-};
-
-/**
- * See if switcher should be disabled.
- *
- * @returns {Boolean}
- * @api private
- */
-
-Switchery.prototype.isDisabled = function() {
-  return this.options.disabled || this.element.disabled || this.element.readOnly;
-};
-
 /**
  * Set switch jack proper position.
  *
@@ -1363,7 +1707,7 @@ Switchery.prototype.setPosition = function (clicked) {
     this.switcher.style.boxShadow = 'inset 0 0 0 0 ' + this.options.secondaryColor;
     this.switcher.style.borderColor = this.options.secondaryColor;
     this.switcher.style.backgroundColor = (this.options.secondaryColor !== defaults.secondaryColor) ? this.options.secondaryColor : '#fff';
-    this.jack.style.backgroundColor = this.options.jackColor;
+    this.jack.style.backgroundColor = (this.options.jackSecondaryColor !== this.options.jackColor) ? this.options.jackSecondaryColor : this.options.jackColor;
     this.setSpeed();
   }
 };
@@ -1376,7 +1720,10 @@ Switchery.prototype.setPosition = function (clicked) {
 
 Switchery.prototype.setSpeed = function() {
   var switcherProp = {}
-    , jackProp = { 'left': this.options.speed.replace(/[a-z]/, '') / 2 + 's' };
+    , jackProp = {
+        'background-color': this.options.speed
+      , 'left': this.options.speed.replace(/[a-z]/, '') / 2 + 's'
+    };
 
   if (this.isChecked()) {
     switcherProp = {
@@ -1480,29 +1827,24 @@ Switchery.prototype.handleChange = function() {
  */
 
 Switchery.prototype.handleClick = function() {
-  var self = this
-    , switcher = this.switcher
-    , parent = self.element.parentNode.tagName.toLowerCase()
-    , labelParent = (parent === 'label') ? false : true;
+  var switcher = this.switcher;
 
-  if (this.isDisabled() === false) {
-    fastclick(switcher);
+  fastclick(switcher);
+  this.events.bind('click', 'bindClick');
+};
 
-    if (switcher.addEventListener) {
-      switcher.addEventListener('click', function(e) {
-        self.setPosition(labelParent);
-        self.handleOnchange(self.element.checked);
-      });
-    } else {
-      switcher.attachEvent('onclick', function() {
-        self.setPosition(labelParent);
-        self.handleOnchange(self.element.checked);
-      });
-    }
-  } else {
-    this.element.disabled = true;
-    this.switcher.style.opacity = this.options.disabledOpacity;
-  }
+/**
+ * Attach all methods that need to happen on switcher click.
+ *
+ * @api private
+ */
+
+Switchery.prototype.bindClick = function() {
+  var parent = this.element.parentNode.tagName.toLowerCase()
+    , labelParent = (parent === 'label') ? false : true;
+
+  this.setPosition(labelParent);
+  this.handleOnchange(this.element.checked);
 };
 
 /**
@@ -1541,6 +1883,66 @@ Switchery.prototype.init = function() {
   this.handleClick();
 };
 
+/**
+ * See if input is checked.
+ *
+ * @returns {Boolean}
+ * @api public
+ */
+
+Switchery.prototype.isChecked = function() {
+  return this.element.checked;
+};
+
+/**
+ * See if switcher should be disabled.
+ *
+ * @returns {Boolean}
+ * @api public
+ */
+
+Switchery.prototype.isDisabled = function() {
+  return this.options.disabled || this.element.disabled || this.element.readOnly;
+};
+
+/**
+ * Destroy all event handlers attached to the switch.
+ *
+ * @api public
+ */
+
+Switchery.prototype.destroy = function() {
+  this.events.unbind();
+};
+
+/**
+ * Enable disabled switch element.
+ *
+ * @api public
+ */
+
+Switchery.prototype.enable = function() {
+  if (this.options.disabled) this.options.disabled = false;
+  if (this.element.disabled) this.element.disabled = false;
+  if (this.element.readOnly) this.element.readOnly = false;
+  this.switcher.style.opacity = 1;
+  this.events.bind('click', 'bindClick');
+};
+
+/**
+ * Disable switch element.
+ *
+ * @api public
+ */
+
+Switchery.prototype.disable = function() {
+  if (this.options.disabled) this.options.disabled = true;
+  if (this.element.disabled) this.element.disabled = true;
+  if (this.element.readOnly) this.element.readOnly = true;
+  this.switcher.style.opacity = this.options.disabledOpacity;
+  this.destroy();
+};
+
 });
 
 if (typeof exports == "object") {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: switchery-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Guillaume Hain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-18 00:00:00.000000000 Z
+date: 2015-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -63,6 +63,7 @@ files:
 - ".ruby-gemset"
 - ".ruby-version"
 - CHANGELOG.md
+- Dockerfile
 - Gemfile
 - LICENSE
 - README.md
@@ -94,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Use Switchery for Rails