autotab-rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9351c775fcd31092b75263022302081712754caf
+  data.tar.gz: c62d02214f1f6d6c2fad18603aab24d6e46c48bd
+SHA512:
+  metadata.gz: 7f6c9b6a08e5cc15765c57cf121c551b368b28a5de0c91d98750288aee4615af1e728b419acae402e8ae4170f8b84df4bfd9622d970157ae2a5548b9bed510b1
+  data.tar.gz: 3c0aa3a3b2a07db7f14e5c6426acd38ee7612ba2fe5a8618e3f7a807b4d773a498002a103617cdbc43c0c97cf163bcba7f99960e8dcbb28f5defb11007f16300

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in autotab-rails.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2013 by Sachin Singh
+
+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,63 @@
+# AutoTab for rails asset pipeline
+
+[Autotab](https://github.com/Mathachew/jquery-autotab) is a jQuery plugin that provides auto tabbing and filtering on text fields in a form. Once the maximum number of characters has been reached within a text field, the focus is automatically set to a defined element. Likewise, clearing out the text field's content by pressing backspace eventually places the focus on a previous element.
+
+The `autotab-rails` gem integrates the `AutoTab` with the Rails asset pipeline.
+
+## Usage
+
+### Install autotab-rails gem
+
+Include `autotab-rails` in Gemefile
+
+    gem 'autotab-rails'
+
+Then run `bundle install`
+
+### Include autotab javascript assets
+
+Add to your `app/assets/javascripts/application.js` if use with jQuery
+
+    //= require autotab-jquery
+
+### Enable autotab javascript by specific css class
+
+Add to one coffee script file, like `custom.js.coffee`
+
+  $(document).ready ->
+    $("#first").autotab
+      target: "second"
+      format: "numeric"
+
+    $("#second").autotab
+      target: "third"
+      format: "numeric"
+      previous: "first"
+
+    $("#third").autotab
+      previous: "second"
+      format: "numeric"
+
+    return
+
+And this file must be included in `application.js`
+
+    //= require autotab-jquery
+    //= require custom
+
+
+## Gem maintenance
+
+Maintain `autotab-rails` gem with `Rake` commands.
+
+Update origin autotab source files.
+
+    rake update-autotab
+
+Publish gem.
+
+    rake release
+
+## License
+
+use MIT license.

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require File.expand_path('../lib/autotab-rails/source_file', __FILE__)
+
+desc "Update with Harvest's AutoTab Library"
+task 'update-autotab', 'repository_url', 'branch' do |task, args|
+  remote = args['repository_url'] || 'https://github.com/sachin87/autotab-rails'
+  branch = args['branch'] || 'master'
+  files = SourceFile.new
+  files.fetch remote, branch
+  files.cleanup
+end

data/autotab-rails.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/autotab-rails/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Sachin Singh']
+  gem.email         = ['sachin.y87@hmail.com']
+  gem.description   = %q{AutoTab is a is a jQuery plugin that provides auto tabbing and filtering on text fields in a form.}
+  gem.summary       = %q{Integrate AutoTab javascript library with Rails asset pipeline}
+  gem.homepage      = 'https://github.com/sachin87/autotab-rails'
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = 'autotab-rails'
+  gem.require_paths = ['lib']
+  gem.version       = AutoTab::Rails::VERSION
+
+  gem.add_dependency 'railties', '>= 3.0'
+
+  gem.add_development_dependency 'bundler', '>= 1.0'
+  gem.add_development_dependency 'rails', '>= 3.0'
+  gem.add_development_dependency 'thor', '>= 0.14'
+end

data/lib/autotab-rails.rb

@@ -0,0 +1,15 @@
+require 'autotab-rails/version'
+
+module AutoTab
+  module Rails
+  end
+end
+
+case ::Rails.version.to_s
+when /^4/
+  require 'autotab-rails/engine'
+when /^3\.[12]/
+  require 'autotab-rails/engine3'
+when /^3\.[0]/
+  require 'autotab-rails/railtie'
+end

data/lib/autotab-rails/engine.rb

@@ -0,0 +1,9 @@
+module AutoTab
+  module Rails
+    class Engine < ::Rails::Engine
+      rake_tasks do
+        load 'autotab-rails/tasks.rake'
+      end
+    end
+  end
+end

data/lib/autotab-rails/engine3.rb

@@ -0,0 +1,8 @@
+module Autotab
+  module Rails
+    class Engine3 < ::Rails::Engine
+      initializer 'autotab.assets.precompile' do |app|
+      end
+    end
+  end
+end

data/lib/autotab-rails/railtie.rb

@@ -0,0 +1,6 @@
+module AutoTab
+  module Rails
+    class Railtie < ::Rails::Railtie
+    end
+  end
+end

data/lib/autotab-rails/source_file.rb

@@ -0,0 +1,33 @@
+require 'thor'
+require 'json'
+
+class SourceFile < Thor
+  include Thor::Actions
+
+  desc 'fetch source files', 'fetch source files from GitHub'
+  def fetch remote, branch
+    self.destination_root = 'vendor/assets'
+    get "#{remote}/raw/#{branch}/js/autotab-jquery.js", 'javascripts/autotab-jquery.js'
+    get "#{remote}/raw/#{branch}/js/autotab-jquery.min.js", 'javascripts/autotab-jquery.min.js'
+    get "#{remote}/raw/#{branch}/component.json", 'component.json'
+    bump_version
+  end
+
+  desc 'clean up useless files', 'clean up useless files'
+  def cleanup
+    self.destination_root = 'vendor/assets'
+    remove_file 'component.json'
+  end
+
+  protected
+
+  def bump_version
+    inside destination_root do
+      component_json = JSON.load(File.open('component.json'))
+      version = component_json['version']
+      gsub_file '../../lib/autotab-rails/version.rb', /AUTO_TAB_VERSION\s=\s'(\d|\.)+'$/ do |match|
+        %Q{AUTO_TAB_VERSION = '#{version}'}
+      end
+    end
+  end
+end

data/lib/autotab-rails/tasks.rake

@@ -0,0 +1,11 @@
+require 'fileutils'
+
+desc 'Create nondigest versions of all autotab digest assets'
+task 'assets:precompile' do
+  fingerprint = /\-[0-9a-f]{32}\./
+  Dir['public/assets/jquery.autotab*'].each do |file|
+    next unless file =~ fingerprint
+    nondigest = file.sub fingerprint, '.'
+    FileUtils.cp file, nondigest, verbose: true
+  end
+end

data/lib/autotab-rails/version.rb

@@ -0,0 +1,6 @@
+module AutoTab
+  module Rails
+    VERSION = '0.0.1'
+    AUTO_TAB_VERSION = '0.0.1'
+  end
+end

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

@@ -0,0 +1,524 @@
+/**
+ * Autotab - jQuery plugin 1.5.5
+ * https://github.com/Mathachew/jquery-autotab
+ * 
+ * Copyright (c) 2013 Matthew Miller
+ * 
+ * Licensed under the MIT licensing:
+ *   http://www.opensource.org/licenses/mit-license.php
+ */
+
+(function ($) {
+    var platform = navigator.platform,
+        settings = {
+            tabPause: 800,
+            focusChange: null,
+            iOS: (platform === 'iPad' || platform === 'iPhone' || platform === 'iPod'),
+            firefox: (typeof InstallTrigger !== 'undefined')
+        };
+
+    // Native get/setAttribute methods are much faster than $.data, so $.data is used for objects only: http://jsperf.com/dataset-vs-jquery-data/4
+    // When removing then resetting auto tab, storing an object resulted in overwritten values, leading to this implementation
+    var setSettings = function (e, settings) {
+        if (settings === null || typeof settings === 'undefined') {
+            return;
+        }
+
+        for (var key in settings) {
+            $(e).data('autotab-' + key, settings[key]);
+        }
+    };
+
+    var getSettings = function (e) {
+        var settings = {
+            format: 'all',
+            loaded: false,
+            disabled: false,
+            pattern: null,
+            uppercase: false,
+            lowercase: false,
+            nospace: false,
+            maxlength: 2147483647,
+            target: null,
+            previous: null,
+            trigger: null,
+            originalValue: '',
+            changed: false
+        };
+
+        for (var key in settings) {
+            settings[key] = $(e).data('autotab-' + key) || settings[key];
+        }
+
+        // Save settings on first run
+        if (!settings.loaded) {
+            if (settings.trigger !== null && typeof settings.trigger === 'string') {
+                settings.trigger = settings.trigger.toString();
+            }
+
+            setSettings(e, settings);
+        }
+
+        return settings;
+    };
+
+    // The 1ms timeouts allow for keypress events to complete in case a
+    // custom function or exterior method calls for a manual auto tab
+    $.autotab = {
+        next: function () {
+            var e = $(document.activeElement);
+
+            if (e.length) {
+                e.trigger('autotab-next');
+            }
+        },
+        previous: function () {
+            var e = $(document.activeElement);
+
+            if (e.length) {
+                e.trigger('autotab-previous');
+            }
+        }
+    };
+
+    $.fn.autotab = function (method, options) {
+        if (!this.length) {
+            return this;
+        }
+
+        // Apply filter options
+        if (method == 'filter') {
+            if (typeof options === 'string' || typeof options === 'function') {
+                options = { format: options };
+            }
+
+            for (var i = 0, length = this.length; i < length; i++) {
+                var defaults = getSettings(this[i]),
+                    newOptions = options;
+
+                // Retain the established target/previous values as this area is for filtering only
+                newOptions.target = defaults.target;
+                newOptions.previous = defaults.previous;
+
+                $.extend(defaults, newOptions);
+                setSettings(this[i], defaults);
+            }
+        }
+        // Disable auto tab and filtering
+        else if (method == 'remove' || method == 'destroy' || method == 'disable') {
+            for (var i = 0, length = this.length; i < length; i++) {
+                var defaults = getSettings(this[i]);
+
+                defaults.disabled = true;
+
+                setSettings(this[i], defaults);
+            }
+        }
+        // Re-enable auto tab and filtering
+        else if (method == 'restore' || method == 'enable') {
+            for (var i = 0, length = this.length; i < length; i++) {
+                var defaults = getSettings(this[i]);
+
+                defaults.disabled = false;
+
+                setSettings(this[i], defaults);
+            }
+        }
+        else {
+            if (method === null || typeof method === 'undefined') {
+                options = {};
+            }
+            else if (typeof method === 'string' || typeof method === 'function') {
+                options = { format: method };
+            }
+            else if (typeof method === 'object') {
+                options = method;
+            }
+
+            // Bind key events to element(s) passed
+            if (this.length > 1) {
+                for (var i = 0, length = this.length; i < length; i++) {
+                    var n = i + 1,
+                        p = i - 1,
+                        newOptions = options;
+
+                    if (i > 0 && n < length) {
+                        newOptions.target = this[n];
+                        newOptions.previous = this[p];
+                    }
+                    else if (i > 0) {
+                        newOptions.target = null;
+                        newOptions.previous = this[p];
+                    }
+                    else {
+                        newOptions.target = this[n];
+                        newOptions.previous = null;
+                    }
+
+                    autotabBind(this[i], newOptions);
+                }
+            }
+            else {
+                autotabBind(this[0], options);
+            }
+        }
+
+        return this;
+    };
+
+    var filterValue = function (e, value, defaults) {
+        if (typeof defaults.format === 'function') {
+            return defaults.format(value, e);
+        }
+
+        var pattern = null;
+
+        switch (defaults.format) {
+            case 'text':
+                pattern = new RegExp('[0-9]+', 'g');
+                break;
+
+            case 'alpha':
+                pattern = new RegExp('[^a-zA-Z]+', 'g');
+                break;
+
+            case 'number':
+            case 'numeric':
+                pattern = new RegExp('[^0-9]+', 'g');
+                break;
+
+            case 'alphanumeric':
+                pattern = new RegExp('[^0-9a-zA-Z]+', 'g');
+                break;
+
+            case 'hex':
+            case 'hexadecimal':
+                pattern = new RegExp('[^0-9A-Fa-f]+', 'g');
+                break;
+
+            case 'custom':
+                pattern = new RegExp(defaults.pattern, 'g');
+                break;
+
+            case 'all':
+            default:
+                break;
+        }
+
+        if (pattern !== null) {
+            value = value.replace(pattern, '');
+        }
+
+        if (defaults.nospace) {
+            pattern = new RegExp('[ ]+', 'g');
+            value = value.replace(pattern, '');
+        }
+
+        if (defaults.uppercase) {
+            value = value.toUpperCase();
+        }
+
+        if (defaults.lowercase) {
+            value = value.toLowerCase();
+        }
+
+        return value;
+    };
+
+    var autotabBind = function (element, options) {
+        var defaults = getSettings(element);
+
+        if (defaults.disabled) {
+            defaults.disabled = false;
+            defaults.target = null;
+            defaults.previous = null;
+        }
+
+        $.extend(defaults, options);
+
+        // Sets targets to element based on the name or ID passed if they are not currently objects
+        if (typeof defaults.target === 'string' || !(defaults.target instanceof jQuery)) {
+            defaults.target = $(defaults.target);
+        }
+
+        if (typeof defaults.previous === 'string' || !(defaults.previous instanceof jQuery)) {
+            defaults.previous = $(defaults.previous);
+        }
+
+        var oldMaxlength = element.maxLength;
+
+        // defaults.maxlength has not changed and maxlength was specified
+        if (defaults.maxlength == 2147483647 && oldMaxlength != 2147483647 && oldMaxlength != -1) {
+            defaults.maxlength = oldMaxlength;
+        }
+        // defaults.maxlength overrides maxlength
+        else if (defaults.maxlength > 0) {
+            element.maxLength = defaults.maxlength;
+        }
+        // defaults.maxlength and maxlength have not been specified
+        // A target cannot be used since there is no defined maxlength
+        else {
+            defaults.target = null;
+        }
+
+        if (!defaults.loaded) {
+            defaults.loaded = true;
+            setSettings(element, defaults);
+        }
+        else {
+            setSettings(element, defaults);
+            return;
+        }
+
+        $(element).on('autotab-next', function (event, defaults) {
+            var self = this;
+            setTimeout(function () {
+                if (!defaults) {
+                    defaults = getSettings(self);
+                }
+
+                if (!defaults.disabled && defaults.target.length) {
+                    // Using focus on iOS devices is a pain, so use the browser's next/previous buttons to proceed
+                    if (!settings.iOS) {
+                        defaults.target.focus().select();
+                        settings.focusChange = new Date();
+                    }
+                }
+            }, 1);
+        }).on('autotab-previous', function (event, defaults) {
+            var self = this;
+            setTimeout(function () {
+                if (!defaults) {
+                    defaults = getSettings(self);
+                }
+
+                var previous = defaults.previous;
+
+                if (!defaults.disabled && previous.length) {
+                    var value = previous.val();
+
+                    if (value.length) {
+                        previous.focus().val(value.substring(0, value.length - 1));
+                        setSettings(previous, { changed: true });
+                    }
+                    else {
+                        previous.focus();
+                    }
+
+                    settings.focusChange = null;
+                }
+            }, 1);
+        }).on('focus', function () {
+            setSettings(this, { originalValue: this.value });
+        }).on('blur', function () {
+            var defaults = getSettings(this);
+
+            if (defaults.changed && this.value != defaults.originalValue) {
+                setSettings(this, { changed: false });
+                $(this).change();
+            }
+        }).on('keydown', function (e) {
+            var defaults = getSettings(this);
+
+            if (!defaults || defaults.disabled) {
+                return true;
+            }
+
+            var keyCode = e.which || e.charCode;
+
+            // Go to the previous element when backspace
+            // is pressed in an empty input field
+            if (keyCode == 8) {
+                if (this.value.length === 0 && defaults.previous.length) {
+                    $(this).trigger('autotab-previous', defaults);
+                }
+                else {
+                    setSettings(this, { changed: (this.value != defaults.originalValue) });
+                }
+            }
+            else if (keyCode == 9 && settings.focusChange !== null) {
+                // Tab backwards
+                if (e.shiftKey) {
+                    settings.focusChange = null;
+                    return;
+                }
+
+                if ((new Date().getTime() - settings.focusChange.getTime()) < settings.tabPause) {
+                    settings.focusChange = null;
+                    return false;
+                }
+            }
+        }).on('keypress', function (e) {
+            var defaults = getSettings(this),
+                keyCode = e.which || e.keyCode;
+
+            // e.charCode == 0 indicates a special key has been pressed, which only Firefox triggers
+            if (!defaults || defaults.disabled || (settings.firefox && e.charCode === 0) || e.ctrlKey || e.altKey || keyCode == 13 || this.type != 'text') {
+                return true;
+            }
+
+            var keyChar = String.fromCharCode(keyCode);
+
+            // Prevents auto tabbing when defaults.trigger is pressed
+            if (defaults.trigger !== null && defaults.trigger.indexOf(keyChar) >= 0) {
+                if (settings.focusChange !== null && (new Date().getTime() - settings.focusChange.getTime()) < settings.tabPause) {
+                    settings.focusChange = null;
+                }
+                else {
+                    $(this).trigger('autotab-next', defaults);
+                }
+
+                return false;
+            }
+
+            settings.focusChange = null;
+
+            var hasValue = document.selection && document.selection.createRange ? true : (e.charCode > 0);
+
+            keyChar = filterValue(this, keyChar, defaults);
+
+            if (hasValue && (keyChar === null || keyChar === '')) {
+                return false;
+            }
+
+            // Many, many thanks to Tim Down for this solution: http://stackoverflow.com/a/3923320/94656
+            if (hasValue && (this.value.length <= this.maxLength)) {
+                var start, end,
+                    selectionType = 0;
+
+                if (typeof this.selectionStart === 'number' && typeof this.selectionEnd === 'number') {
+                    // Non-IE browsers and IE 9
+                    start = this.selectionStart;
+                    end = this.selectionEnd;
+                    selectionType = 1;
+                }
+                else if (document.selection && document.selection.createRange) {
+                    // For IE up to version 8
+                    var selectionRange = document.selection.createRange(),
+                        textInputRange = this.createTextRange(),
+                        precedingRange = this.createTextRange(),
+                        bookmark = selectionRange.getBookmark();
+                    textInputRange.moveToBookmark(bookmark);
+                    precedingRange.setEndPoint("EndToStart", textInputRange);
+                    start = precedingRange.text.length;
+                    end = start + selectionRange.text.length;
+                    selectionType = 2;
+                }
+
+                // Text is fully selected, so it needs to be replaced
+                if (start === 0 && end == this.value.length) {
+                    this.value = keyChar;
+                    setSettings(this, { changed: (this.value != defaults.originalValue) });
+                }
+                else {
+                    if (this.value.length == this.maxLength && start === end) {
+                        $(this).trigger('autotab-next', defaults);
+                        return false;
+                    }
+
+                    this.value = this.value.slice(0, start) + keyChar + this.value.slice(end);
+                    setSettings(this, { changed: (this.value != defaults.originalValue) });
+                }
+
+                // Prevents the cursor position from being set to the end of the text box
+                // This is called even if the text is fully selected and replaced due to an unexpected behavior in IE6 and up (#32)
+                if (this.value.length != defaults.maxlength) {
+                    start++;
+
+                    if (selectionType == 1) {
+                        this.selectionStart = this.selectionEnd = start;
+                    }
+                    else if (selectionType == 2) {
+                        var range = this.createTextRange();
+                        range.collapse(true);
+                        range.moveEnd('character', start);
+                        range.moveStart('character', start);
+                        range.select();
+                    }
+                }
+            }
+
+            if (this.value.length == defaults.maxlength) {
+                $(this).trigger('autotab-next', defaults);
+            }
+
+            return false;
+        }).on('paste', function (e) {
+            var defaults = getSettings(this);
+
+            if (!defaults) {
+                return true;
+            }
+
+            this.maxLength = 2147483647;
+
+            (function (e, originDefaults) {
+                setTimeout(function () {
+                    var lastIndex = -1,
+                        hiddenInput = document.createElement('input');
+                    hiddenInput.type = 'hidden';
+                    hiddenInput.value = e.value.toLowerCase();
+
+                    e.maxLength = originDefaults.maxlength;
+                    e.value = filterValue(e, e.value, originDefaults).substr(0, originDefaults.maxlength);
+
+                    var handlePaste = function (e, previousValue) {
+                        if (!e) {
+                            return;
+                        }
+
+                        for (var i = 0, count = previousValue.length; i < count; i++) {
+                            lastIndex = hiddenInput.value.indexOf(previousValue.charAt(i), lastIndex) + 1;
+                        }
+
+                        var defaults = getSettings(e),
+                            trimmedValue = hiddenInput.value.substr(lastIndex),
+                            filteredValue = filterValue(e, trimmedValue, defaults).substr(0, defaults.maxlength);
+
+                        if (!filteredValue) {
+                            e.value = '';
+                            return;
+                        }
+
+                        e.value = filteredValue;
+
+                        if (filteredValue.length == defaults.maxlength) {
+                            $(e).trigger('autotab-next', defaults);
+
+                            if (!settings.iOS) {
+                                handlePaste(defaults.target[0], filteredValue);
+                            }
+                        }
+
+                    };
+
+                    if (e.value.length == originDefaults.maxlength) {
+                        $(e).trigger('autotab-next', defaults);
+
+                        if (!settings.iOS) {
+                            handlePaste(originDefaults.target[0], e.value.toLowerCase());
+                        }
+                    }
+                }, 1);
+            })(this, defaults);
+        });
+    };
+
+    // Backwards compatibility
+    $.fn.autotab_magic = function (focus) {
+        $(this).autotab();
+    };
+    $.fn.autotab_filter = function (options) {
+        var defaults = {};
+
+        if (typeof options === 'string' || typeof options === 'function') {
+            defaults.format = options;
+        }
+        else {
+            $.extend(defaults, options);
+        }
+
+        $(this).autotab('filter', defaults);
+    };
+
+})(jQuery);

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

@@ -0,0 +1,22 @@
+/**
+ * Autotab - jQuery plugin 1.5.5
+ * https://github.com/Mathachew/jquery-autotab
+ * 
+ * Copyright (c) 2013 Matthew Miller
+ * 
+ * Licensed under the MIT licensing:
+ *   http://www.opensource.org/licenses/mit-license.php
+ */
+
+(function(e){var n=navigator.platform,m=null,p="iPad"===n||"iPhone"===n||"iPod"===n,t="undefined"!==typeof InstallTrigger,h=function(b,c){if(null!==c&&"undefined"!==typeof c)for(var a in c)e(b).data("autotab-"+a,c[a])},k=function(b){var c={format:"all",loaded:!1,disabled:!1,pattern:null,uppercase:!1,lowercase:!1,nospace:!1,maxlength:2147483647,target:null,previous:null,trigger:null,originalValue:"",changed:!1},a;for(a in c)c[a]=e(b).data("autotab-"+a)||c[a];c.loaded||(null!==c.trigger&&"string"===
+typeof c.trigger&&(c.trigger=c.trigger.toString()),h(b,c));return c};e.autotab={next:function(){var b=e(document.activeElement);b.length&&b.trigger("autotab-next")},previous:function(){var b=e(document.activeElement);b.length&&b.trigger("autotab-previous")}};e.fn.autotab=function(b,c){if(!this.length)return this;if("filter"==b){if("string"===typeof c||"function"===typeof c)c={format:c};for(var a=0,d=this.length;a<d;a++){var f=k(this[a]),l=c;l.target=f.target;l.previous=f.previous;e.extend(f,l);h(this[a],
+f)}}else if("remove"==b||"destroy"==b||"disable"==b)for(a=0,d=this.length;a<d;a++)f=k(this[a]),f.disabled=!0,h(this[a],f);else if("restore"==b||"enable"==b)for(a=0,d=this.length;a<d;a++)f=k(this[a]),f.disabled=!1,h(this[a],f);else if(null===b||"undefined"===typeof b?c={}:"string"===typeof b||"function"===typeof b?c={format:b}:"object"===typeof b&&(c=b),1<this.length)for(a=0,d=this.length;a<d;a++){var f=a+1,r=a-1,l=c;0<a&&f<d?(l.target=this[f],l.previous=this[r]):0<a?(l.target=null,l.previous=this[r]):
+(l.target=this[f],l.previous=null);s(this[a],l)}else s(this[0],c);return this};var q=function(b,c,a){if("function"===typeof a.format)return a.format(c,b);b=null;switch(a.format){case "text":b=RegExp("[0-9]+","g");break;case "alpha":b=RegExp("[^a-zA-Z]+","g");break;case "number":case "numeric":b=RegExp("[^0-9]+","g");break;case "alphanumeric":b=RegExp("[^0-9a-zA-Z]+","g");break;case "hex":case "hexadecimal":b=RegExp("[^0-9A-Fa-f]+","g");break;case "custom":b=RegExp(a.pattern,"g")}null!==b&&(c=c.replace(b,
+""));a.nospace&&(b=RegExp("[ ]+","g"),c=c.replace(b,""));a.uppercase&&(c=c.toUpperCase());a.lowercase&&(c=c.toLowerCase());return c},s=function(b,c){var a=k(b);a.disabled&&(a.disabled=!1,a.target=null,a.previous=null);e.extend(a,c);"string"!==typeof a.target&&a.target instanceof jQuery||(a.target=e(a.target));"string"!==typeof a.previous&&a.previous instanceof jQuery||(a.previous=e(a.previous));var d=b.maxLength;2147483647==a.maxlength&&2147483647!=d&&-1!=d?a.maxlength=d:0<a.maxlength?b.maxLength=
+a.maxlength:a.target=null;a.loaded?h(b,a):(a.loaded=!0,h(b,a),e(b).on("autotab-next",function(a,b){var c=this;setTimeout(function(){b||(b=k(c));b.disabled||!b.target.length||p||(b.target.focus().select(),m=new Date)},1)}).on("autotab-previous",function(a,b){var c=this;setTimeout(function(){b||(b=k(c));var a=b.previous;if(!b.disabled&&a.length){var f=a.val();f.length?(a.focus().val(f.substring(0,f.length-1)),h(a,{changed:!0})):a.focus();m=null}},1)}).on("focus",function(){h(this,{originalValue:this.value})}).on("blur",
+function(){var a=k(this);a.changed&&this.value!=a.originalValue&&(h(this,{changed:!1}),e(this).change())}).on("keydown",function(a){var b=k(this);if(!b||b.disabled)return!0;var c=a.which||a.charCode;if(8==c)0===this.value.length&&b.previous.length?e(this).trigger("autotab-previous",b):h(this,{changed:this.value!=b.originalValue});else if(9==c&&null!==m)if(a.shiftKey)m=null;else if(800>(new Date).getTime()-m.getTime())return m=null,!1}).on("keypress",function(a){var b=k(this),c=a.which||a.keyCode;
+if(!b||b.disabled||t&&0===a.charCode||a.ctrlKey||a.altKey||13==c||"text"!=this.type)return!0;c=String.fromCharCode(c);if(null!==b.trigger&&0<=b.trigger.indexOf(c))return null!==m&&800>(new Date).getTime()-m.getTime()?m=null:e(this).trigger("autotab-next",b),!1;m=null;a=document.selection&&document.selection.createRange?!0:0<a.charCode;c=q(this,c,b);if(a&&(null===c||""===c))return!1;if(a&&this.value.length<=this.maxLength){var g,d;a=0;if("number"===typeof this.selectionStart&&"number"===typeof this.selectionEnd)g=
+this.selectionStart,d=this.selectionEnd,a=1;else if(document.selection&&document.selection.createRange){d=document.selection.createRange();g=this.createTextRange();a=this.createTextRange();var u=d.getBookmark();g.moveToBookmark(u);a.setEndPoint("EndToStart",g);g=a.text.length;d=g+d.text.length;a=2}if(0===g&&d==this.value.length)this.value=c;else{if(this.value.length==this.maxLength&&g===d)return e(this).trigger("autotab-next",b),!1;this.value=this.value.slice(0,g)+c+this.value.slice(d)}h(this,{changed:this.value!=
+b.originalValue});this.value.length!=b.maxlength&&(g++,1==a?this.selectionStart=this.selectionEnd=g:2==a&&(c=this.createTextRange(),c.collapse(!0),c.moveEnd("character",g),c.moveStart("character",g),c.select()))}this.value.length==b.maxlength&&e(this).trigger("autotab-next",b);return!1}).on("paste",function(a){var b=k(this);if(!b)return!0;this.maxLength=2147483647;(function(a,c){setTimeout(function(){var d=-1,f=document.createElement("input");f.type="hidden";f.value=a.value.toLowerCase();a.maxLength=
+c.maxlength;a.value=q(a,a.value,c).substr(0,c.maxlength);var h=function(a,b){if(a){for(var c=0,g=b.length;c<g;c++)d=f.value.indexOf(b.charAt(c),d)+1;c=k(a);g=f.value.substr(d);(g=q(a,g,c).substr(0,c.maxlength))?(a.value=g,g.length==c.maxlength&&(e(a).trigger("autotab-next",c),p||h(c.target[0],g))):a.value=""}};a.value.length==c.maxlength&&(e(a).trigger("autotab-next",b),p||h(c.target[0],a.value.toLowerCase()))},1)})(this,b)}))};e.fn.autotab_magic=function(b){e(this).autotab()};e.fn.autotab_filter=
+function(b){var c={};"string"===typeof b||"function"===typeof b?c.format=b:e.extend(c,b);e(this).autotab("filter",c)}})(jQuery);

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: autotab-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sachin Singh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.14'
+description: AutoTab is a is a jQuery plugin that provides auto tabbing and filtering
+  on text fields in a form.
+email:
+- sachin.y87@hmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- autotab-rails.gemspec
+- lib/autotab-rails.rb
+- lib/autotab-rails/engine.rb
+- lib/autotab-rails/engine3.rb
+- lib/autotab-rails/railtie.rb
+- lib/autotab-rails/source_file.rb
+- lib/autotab-rails/tasks.rake
+- lib/autotab-rails/version.rb
+- vendor/assets/javascripts/autotab-jquery.js
+- vendor/assets/javascripts/autotab-jquery.min.js
+homepage: https://github.com/sachin87/autotab-rails
+licenses: []
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Integrate AutoTab javascript library with Rails asset pipeline
+test_files: []