jquery-benignware-rails 0.0.3 → 0.0.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OTY1OThmNmVkZTQyYmQ1YTNhOTNkMzc4ZDFmYjBiYmZhNjgxM2IwYg==
+    MTU4ZTY3N2UyMWU2MzBiNzZlODBlNGYwZjUzYzdhYmViMjhiODcxZA==
   data.tar.gz: !binary |-
-    YTk3NWRmY2IzYTUyZmFlNWViMzZhNzExNWQxNzZhNzFkZDJiYjZiZA==
+    YjhjMDVhNjkyNmVmNzQ2ZGQ1OTZmNmY2Yzg4MzBlMmZjZGVmYmRhZg==
 SHA512:
   metadata.gz: !binary |-
-    MmQ0ZWFiMjFiMDUyMzUzNmY2YjFkZDkxNDk2MTI1NmQwYTg3MzI5OWM2OTg4
-    OTg4M2JjYzdlZDY0ODAxOTU3NzFjOWRhNzIxYzU3YWU5MDMwZjU5MDk5NmRi
-    YzY2NjljMDM3OWQ2OWE2M2NlNTM1NmE5NzJlMmVkOGQ0ZmU3Mzg=
+    MGMwYjlhMGI2NGI3MWM4Y2IwZWU5NWYxZjFhNzJjMGVmNDMzOGZkZTU3NzZh
+    OWQwYWE0Nzc5NmFmOWM1NDk3NzNiMjRmNDE5YmUzNWY2MjYwMmFlMGE2ZDJm
+    Yjg3ZmU5NWNjODM2NmVlMDE1YmFlM2ZmM2JmMTVhMmMyOTc1MjA=
   data.tar.gz: !binary |-
-    MGU1MGY5NmI0MzI3MTY5ZjBjZDk1OGFhODRjZTI2YThjYTZhM2U3NmUzNzNl
-    NGE0MWJlM2VlMDRkNDAzNjM5ZjA1YzRlYjcwZDYyZTA5YWQzZDlkYmQxZmFj
-    MjZhNzczMWE3ZmM4MjU2ZWEyM2RlZDhmMjgwZmY1YTZhNzA4ODM=
+    YmE0ZGIzZDY2ODIyMTRmMjg1N2I1YjAzM2IyYjI0Y2QwNjA3OWU4NzlkY2Ux
+    MGJiYzY3ZjU2YTIxZTczNmFkZDVkMzgyNGI3NzMwN2FjMDNjMzg1MGY4OWVi
+    MjBhZDFlMGU2YjAxYTUyZWE2YTQ0ZjZkZDUzZTNiY2QxN2M1Mzk=

data/.gitmodules

@@ -1,9 +1,15 @@
 [submodule "submodules/jquery-checkview"]
 	path = submodules/jquery-checkview
 	url = https://github.com/benignware/jquery-checkview
-[submodule "submodules/jquery-back-to-top"]
-	path = submodules/jquery-back-to-top
-	url = https://github.com/benignware/jquery-back-to-top
 [submodule "submodules/jquery-responsive-text"]
 	path = submodules/jquery-responsive-text
 	url = https://github.com/benignware/jquery-responsive-text
+[submodule "submodules/jquery-nativepicker"]
+	path = submodules/jquery-nativepicker
+	url = https://github.com/benignware/jquery-nativepicker.git
+[submodule "submodules/jquery-touchclick"]
+	path = submodules/jquery-touchclick
+	url = https://github.com/benignware/jquery-touchclick.git
+[submodule "submodules/bootstrap-dropdown-control"]
+	path = submodules/bootstrap-dropdown-control
+	url = https://github.com/benignware/bootstrap-dropdown-control.git

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

@@ -1,7 +1,7 @@
 module Jquery
   module Benignware
     module Rails
-      VERSION = "0.0.3"
+      VERSION = "0.0.5"
     end
   end
 end

data/vendor/assets/javascripts/benignware/bootstrap.dropdown-control.js

@@ -0,0 +1,210 @@
+
+// Ensure private scope + aliases
++function ( $, window) {
+
+  var pluginName = "dropdownControl";
+  
+  var _super = $.fn.dropdown;
+  
+  // TODO: defaults have no effect
+  $.extend(_super.Constructor.DEFAULTS, { 
+    showOnFocus: false, 
+    focusInput: false
+  });
+  
+  var backdrop = '.dropdown-backdrop';
+  var toggle = '[data-toggle=actions]';
+  
+  var inputSelector = "input[type!='hidden']";
+  
+  // bootstrap original helper methods
+  function getParent($this) {
+    var selector = $this.attr('data-target');
+    if (!selector) {
+      selector = $this.attr('href');
+      selector = selector && /#/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, ''); //strip for ie7
+    }
+    var $parent = selector && $(selector);
+    return $parent && $parent.length ? $parent : $this.parent();
+  }
+
+  function getBackdrop($element) {
+    var parent = getParent($element);
+    return parent.find('.dropdown-backdrop');
+  }
+
+  function clearMenu(toggle) {
+    $(backdrop).remove();
+    
+    $(toggle).each(function (e) {
+      
+      var $parent = getParent($(this));
+      if (!$parent.hasClass('open')) return
+      
+      $parent.trigger(e = $.Event('hide.bs.dropdown'));
+      if (e.isDefaultPrevented()) return
+      $parent.removeClass('open').trigger('hidden.bs.dropdown');
+      // blur inputs
+      $parent.find(".dropdown-menu " + inputSelector).blur();
+    });
+  }
+  
+  
+  // custom helper methods
+  function getMenu($element) {
+    return $element.next('.dropdown-menu');
+  }
+  
+  function isOpen($element) {
+    return getParent($element).hasClass('open');
+  }
+  
+  function focusInput(menu) {
+    menu.find(inputSelector).first().focus();
+  }
+  
+  // create a new constructor
+  function DropdownControl(element, options) {
+  
+       // call the original constructor
+      //_super.Constructor.apply( this, arguments );
+      
+      // do custom constructor stuff here
+      var $element = $(element);
+      
+      var toggle = element;
+      var parent = getParent($element);
+      var menu = getMenu($element);
+        
+      // init key events
+      $element.on('keydown.bs.dropdown.data-api', DropdownControl.prototype.keydown);
+      
+      // show on focus
+      $element.on('focus', function(event) {
+        if (!clickContext && options.showOnFocus && !isOpen($element)) {
+          event.preventDefault();
+          DropdownControl.prototype.toggle.apply(this, arguments);
+          if (options.focusInput) {
+            focusInput(menu); 
+          }
+        }
+      });
+      
+      // start click context on toggle element
+      $element.on('mousedown touchstart', function(event) {
+        if (!clickContext) {
+          clickContext = true;
+        }
+      });
+      
+      // start click context on parent element
+      parent.on('mousedown touchstart', function(event) {
+        if (!clickContext) {
+          clickContext = true;
+        }
+      });
+      
+      $element.on('click', function(event) {
+        if (isOpen($element)) {
+          if (!('ontouchstart' in window)) {
+            clearMenu($element);
+          }
+        } else {
+          DropdownControl.prototype.toggle.apply(this, arguments);
+          if (options.focusInput) {
+            focusInput(menu); 
+          }
+        }
+        
+        event.stopImmediatePropagation();
+        event.preventDefault();
+        clickContext = false;
+      });
+      
+      // end click context on parent click
+      parent.on('click', function(event) {
+        clickContext = false;
+        event.stopImmediatePropagation();
+      });
+
+      
+      var clickContext = false;
+      
+      
+      // clear menu on blur
+      menu.find(inputSelector).on('blur', function(event) {
+        if (!clickContext) {
+          window.setTimeout(function() {
+            if (isOpen($element)) {
+              
+              if (!menu.has(document.activeElement).length) {
+                clearMenu(element);
+              }
+            }
+            
+          }, 0);
+        }
+      });
+      
+      
+      // close on click outside
+      $(document)
+        .on('mousedown touchstart', function(event) {
+          var parent = getParent($element);
+          if (isOpen($element) && 
+            (!parent.is(event.target) && !parent.has(event.target).length)) {
+            clearMenu($element);
+          }
+        })
+        .on('click.bs.dropdown.data-api', function(event) {
+        });
+      
+     
+      
+  };
+
+  
+  // extend prototypes and add a super function
+  DropdownControl.prototype = $.extend({}, _super.Constructor.prototype, {
+      Constructor: DropdownControl,
+      toggle: function(e) {
+        if (!isOpen($(this))) {
+          _super.Constructor.prototype.toggle.apply(this, e);    
+          // remove backdrop      
+          var backdrop = getBackdrop($(this));
+          backdrop.remove();
+        } else {
+          // do nothing
+        }
+      }, 
+      keyDown: function(e) {
+        _super.Constructor.prototype.keyDown.apply(this, e);
+      }
+  });
+  
+  
+  // plugin initialization
+  var pluginClass = DropdownControl;
+  $.fn[pluginName] = $.extend(function(option) {
+
+    var args = $.makeArray(arguments),
+        option = args.shift();
+
+    return this.each(function() {
+
+        var $this = $(this);
+        var data = $this.data(pluginName),
+            options = $.extend({}, _super.defaults, $this.data(), typeof option == 'object' && option);
+
+        if ( !data ) {
+            $this.data(pluginName, (data = new pluginClass(this, options)));
+        }
+        if (typeof option == 'string') {
+            data[option].apply( data, args );
+        }
+        
+    });
+
+  }, $.fn[pluginName]);
+  
+}( jQuery, window );

data/vendor/assets/javascripts/benignware/jquery.nativepicker.js

@@ -0,0 +1,266 @@
+
++function ( $, window) {
+  
+  window.console = window.console || {
+    log: function() {}, 
+    info: function() {}
+  };
+  
+  var pluginName = 'nativepicker';
+  
+  var defaults = {
+    // options
+    type: 'auto', 
+    toggleEvent: 'touchstart mousedown', 
+    // callback
+    show: null, 
+    change: null
+  };
+  
+  // http://stackoverflow.com/questions/6525538/convert-utc-date-time-to-local-date-time-using-javascript
+  function convertUTCDateToLocalDate(date) {
+    var newDate = new Date(date.getTime());
+    var offset = date.getTimezoneOffset() / 60;
+    var hours = date.getHours();
+    newDate.setHours(hours - offset);
+    return newDate;   
+  }
+  
+  // http://stackoverflow.com/questions/10830357/javascript-toisostring-ignores-timezone-offset
+  function getLocalIsoString(date) {
+    date = convertUTCDateToLocalDate(date);
+    var padDigits = function padDigits(number, digits) {
+        return Array(Math.max(digits - String(number).length + 1, 0)).join(0) + number;
+    };
+
+    var tzOffset = date.getTimezoneOffset() + 30 * -1,
+        tzHour = padDigits( Math.floor(tzOffset / 60), 2 ),
+        tzMin = padDigits( (tzOffset % 60), 2 ),
+        tz = "";
+
+    tz = tzHour > 0 ? "+" : "-";
+    tz = tz + tzHour + ":" + tzMin;
+
+    return date.getFullYear() 
+            + "-" + padDigits((date.getMonth()+1),2) 
+            + "-" + padDigits(date.getDate(),2) 
+            + "T" 
+            + padDigits(date.getHours(),2)
+            + ":" + padDigits(date.getMinutes(),2)
+            + ":" + padDigits(date.getSeconds(),2)
+            + "." + padDigits(date.getMilliseconds(),2)
+            + tz;
+  }
+  
+  // TODO: cache results
+  function isTypeSupported(type) {
+    
+    switch (type) {
+      
+      // html4 input types
+      case 'select': 
+      case 'text':
+      case 'textarea':
+        result = true;
+        break;
+      default: 
+        // detect html5 input types
+        var i = document.createElement('input');
+        i.setAttribute("type", type);
+        // general support
+        if (i.getAttribute('type') == type) {
+          // exact support
+          switch (type) {
+            case 'date': 
+              var testValue = "not a timestring";
+              i.setAttribute('value', testValue);
+              // html5 date control accepts iso time strings only
+              if (!i.value) {
+                result = true;
+                break;
+              }
+            default: 
+              result = false;
+          }
+        }
+        delete i;
+    }
+    
+    
+    return result;
+  }
+  
+  var pluginClass = function NativePicker(element, options) {
+    
+    var nativePicker = this;
+    var inputSelector = options.inputSelector;
+    var $element = $(element);
+    var picker, toggle;
+    
+    // TODO: define exact relations and provide as option
+    var inputSelector = "select, input[type='text]', input[type='date'], textarea"; 
+    
+    
+    function getType() {
+      if (options.type && options.type != 'auto') {
+        return options.type;
+      }
+      var picker = getPicker();
+      
+      if (picker) {
+        var tagName = picker.prop('tagName').toLowerCase();
+        switch (tagName) {
+          case 'select': 
+          case 'textarea': 
+            return tagName;
+          case 'input': 
+            return picker.prop('type');
+        }
+      }
+      return null;
+    }
+    
+    function getPicker() {
+      
+      if (!picker) {
+        picker = $element.is(options.inputSelector) ? $element : (function() {
+          // create the picker
+          var picker = null;
+          var type = getType();
+          switch (type) {
+            case 'select': 
+              picker = document.createElement(type);
+              break;
+            default: 
+              picker = document.createElement('input');
+              picker.setAttribute('type', type);
+              picker.setAttribute('min', options.min);
+          }
+          $(picker).on('change', function(event) {
+            pickerChanged();
+          });
+         
+          element.parentNode.insertBefore(picker, element); 
+          return $(picker);
+        })();
+      }
+      return picker;
+    }
+    
+    function getToggle() {
+      toggle = options.toggle ? 
+        typeof (options.toggle) == "function" ? options.toggle.call(element) : $(options.toggle)
+        : $element;
+      return toggle;
+    }
+    
+    var toggle = getToggle(); 
+    
+    function layout() {
+      var picker = getPicker();
+      var toggle = getToggle();
+      if (picker && toggle) {
+        picker.css({
+          opacity: 0, 
+          position: 'absolute', 
+          zIndex: -1, 
+          width: toggle.outerWidth(false), 
+          height: toggle.outerHeight(false), 
+          display: ''
+        });
+      }
+    }
+    
+    function toggleHandler(event) {
+      event.stopImmediatePropagation();
+      event.preventDefault();
+      showPicker();
+    }
+    
+    function showPicker() {
+      input = getPicker();
+      if (options.show) {
+        options.show.call(element);
+      }
+      input.focus();
+    }
+    
+    this.getPickerValue = function() {
+      value = getPicker().prop('value');
+      if (!value) {
+        // default values
+        if (options.min) {
+          value = options.min;
+        } else {
+          value = "";
+        }
+      }
+      return value;
+    };
+    
+    this.setPickerValue = function(value) {
+      if (value instanceof Date) {
+        value = getLocalIsoString(value).substring(0, 10);
+      }
+      getPicker().prop('value', value);
+    };
+    
+    function pickerChanged() {
+      var value = nativePicker.getPickerValue();
+
+      // update toggle content      
+      switch (toggle.prop('tagName').toLowerCase()) {
+        case 'input': 
+        case 'select': 
+          toggle.prop('value', value);
+          break;
+        default: 
+          toggle.html(value);
+      }
+      if (options.change) {
+        value = options.change.call(element, value);
+      }
+    }
+    
+    // TODO: as option
+    function isSupported() {
+      return ( /Android|webOS|iPhone|iPad|iPod|BlackBerry/i.test(navigator.userAgent) );
+    }
+    
+    function init() {
+      
+      if (!isSupported()) {
+        // native picker not supported or required in general 
+        return;
+      }
+      
+      var type = getType();
+      if (type && !isTypeSupported(type)) {
+        // input type is not natively supported
+        return;
+      }
+      
+      // bind
+      getToggle().bind(options.toggleEvent, toggleHandler);
+      
+      // initial layout      
+      layout.call(this);
+    }
+    
+    init.call(this);
+    
+  };
+  
+
+  // bootstrap plugin
+  $.fn[pluginName] = function(options) {
+    options = $.extend({}, defaults, options);
+    return this.each(function() {
+      if (!$(this).data(pluginName)) {
+        $(this).data(pluginName, new pluginClass(this, options));
+      }
+      return $(this);
+    });
+  };
+
+}( jQuery, window );

data/vendor/assets/javascripts/benignware/jquery.touchclick.js

@@ -0,0 +1,175 @@
+
++function ( $, window) {
+  
+  window.console = window.console || {
+    log: function() {}, 
+    info: function() {}
+  };
+  
+  var pluginName = 'touchclick';
+  
+  var defaults = {
+    draggingTimeout: 100, 
+    scrollingTimeout: 750, 
+    preventClickTimeout: 500
+  };
+  
+  function getOverflowContainer(elem) {
+    while (elem && elem.nodeType == 1) {
+      if (elem.nodeName.toLowerCase() == 'body' || elem.nodeName.toLowerCase() == 'html') {
+        break;
+      }
+      var overflow = $(elem).css('overflow');
+      if (overflow == 'auto' || overflow == 'scroll') {
+        return elem;
+      }
+      elem = elem.parentNode;
+    }
+    return window;
+  }
+  
+  // helper methods
+
+  var pluginClass = function TouchClick(element, options) {
+    
+    var touchClick = this;
+    
+    var $element = $(element);
+    var $window = $(window);
+    
+    var dragging = false;
+    var draggingTimeoutId = null;
+    var preventClick = false;
+    var touchStartElement = null;
+    
+    var overflowContainer = null;
+    var scrolling = false;
+    var touchStartScrollPos = null;
+    var scrollingTimeoutId = null;
+    
+    $element.bind('touchstart', function(event) {
+      
+      touchStartScrollPos = null;
+      overflowContainer = getOverflowContainer(event.target);
+      if (overflowContainer) {
+        var scrollPos = {
+          x: overflowContainer.scrollLeft, 
+          y: overflowContainer.scrollTop
+        };
+        touchStartScrollPos = scrollPos;
+      }
+      window.clearTimeout(draggingTimeoutId);
+      window.clearTimeout(scrollingTimeoutId);
+      dragging = false;
+      scrolling = false;
+      touchStartElement = event.target;
+      
+      $(event.target).unbind('scroll', scrollHandler);
+      if (overflowContainer && (overflowContainer.scrollHeight > 0 || overflowContainer.scrollWidth > 0)) {
+        $(overflowContainer).bind('scroll', scrollHandler);
+      }
+      
+      $(event.target).unbind('click', preventClickHandler);
+      
+    });
+    
+    $element.bind('touchmove', function(event) {
+      dragging = true;
+      if (overflowContainer) {
+        var scrollPos = {
+          x: overflowContainer.scrollLeft, 
+          y: overflowContainer.scrollTop
+        };
+        if (touchStartScrollPos) {
+          if (touchStartScrollPos.x != scrollPos.x || touchStartScrollPos.y != scrollPos.y) {
+            scrolling = true;
+          }
+        }
+      }
+    });
+    
+    function preventClickHandler(event, custom) {
+      
+      
+      
+      if (!custom) {
+        // prevent original event
+        //event.preventDefault();
+        // prevent propagation
+        event.stopImmediatePropagation();
+        $(this).unbind('click', preventClickHandler);
+        
+      } else {
+        // custom click actions
+        
+        //$(event.target).focus();
+        
+        // open links 
+        window.setTimeout(function() {
+          if (custom && !event.isDefaultPrevented()) {
+            var a = $(event.target).is('a[href]') ? event.target : $(event.target).parents('a[href]')[0];
+            if (a && a.href) {
+              window.location.href = a.href;
+            }
+          }
+        }, 1);
+      }
+    }
+    
+    $element.bind('touchend', function(event) {
+      
+      $(event.target).unbind('click', preventClickHandler);
+      
+      if (!scrolling && !dragging && event.target == touchStartElement) {
+        
+        $(event.target).bind('click', preventClickHandler);
+        
+        var events = jQuery._data(event.target).events;
+        if (events && events['click'] && events['click'].length > 1) {
+          var onClickHandlers = events['click'];
+          onClickHandlers.splice(0, 0, onClickHandlers.pop());
+        }
+        
+        $(event.target).trigger({
+          type: 'click', 
+          bubbles: true
+        }, [true]);
+        
+        $(event.target).focus();
+        
+        event.preventDefault();
+        event.stopImmediatePropagation();
+      }
+      
+      window.clearTimeout(draggingTimeoutId);
+      draggingTimeoutId = window.setTimeout(function() {
+        dragging = false;
+      }, options.draggingTimeout);
+      
+      
+    });
+    
+    function scrollHandler(event) {
+      scrolling = true;
+      window.clearTimeout(draggingTimeoutId);
+      draggingTimeoutId = window.setTimeout(function() {
+        scrolling = false;
+        $(this).unbind('scroll', scrollHandler);
+      }, options.scrollingTimeout);
+    }
+    
+  };
+  
+
+  // bootstrap plugin
+  $.fn[pluginName] = function(options) {
+    options = $.extend({}, defaults, options);
+    return this.each(function() {
+      if (!$(this).data(pluginName)) {
+          $(this).data(pluginName, new pluginClass(this, options));
+      }
+      return $(this);
+    });
+  };
+
+}( jQuery, window );

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jquery-benignware-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - rexblack
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-19 00:00:00.000000000 Z
+date: 2013-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -46,9 +46,12 @@ files:
 - jquery-benignware-rails.gemspec
 - lib/jquery-benignware-rails.rb
 - lib/jquery-benignware-rails/version.rb
+- vendor/assets/javascripts/benignware/bootstrap.dropdown-control.js
 - vendor/assets/javascripts/benignware/jquery.backToTop.js
 - vendor/assets/javascripts/benignware/jquery.checkView.js
+- vendor/assets/javascripts/benignware/jquery.nativepicker.js
 - vendor/assets/javascripts/benignware/jquery.responsiveText.js
+- vendor/assets/javascripts/benignware/jquery.touchclick.js
 - vendor/assets/stylesheets/benignware/jquery-checkview.bootstrap.css
 homepage: ''
 licenses: []
@@ -69,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.9
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: gem summary