inputmask-multi-rails 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODYxNWIwY2UxZjI5ZDdkYzMyMmE4YmUzMjhjZjNmMjIyYzFlMWM2MQ==
+  data.tar.gz: !binary |-
+    OWIxODA5OTNkNjIzMzU4ZDdlNTU4YTdjMWMwMzcyN2FjOTI5ZDAxNQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZjczZmU4YTZmZDQ1YWZlMTI3Y2RhYTJkYWYzZjVhZmYxN2VmZTVhZTA5YTMz
+    NDg2NjE4NDNjZmJiMDJkMjRhZWRhYTM3MWI3NGZmNmU0MTNmZDVkY2YwMmQw
+    MjNjYTNhMWI1OWViMzZiMTU5ZDVkNWEyZjI3OTBhNGNkOGVkMDk=
+  data.tar.gz: !binary |-
+    MWY4NDk4ZjgwNzM5YTQzYjllMGQzZDM1MGFlNGJjMTgxM2QyOWJlZGYxZTM0
+    MTI5ZmM4N2ZlYjBkMDBiZWI3MzFiMTFlZjY5YjA1ODQ5NDJjN2M3MDdhNWFi
+    NjdmNzIyMmY0NmFmYzA0NDUxNmJmYmM5NGJmYzIwNjk5YmZiNWQ=

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 vaski
+
+MIT License
+
+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,39 @@
+# Inputmask::Multi::Rails
+
+Inputmask Multi for Rails. https://github.com/andr-04/inputmask-multi
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'inputmask-multi-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install inputmask-multi-rails
+
+Add the following to your `app/assets/javascripts/application.js`:
+
+    //= require jquery.bind-first
+    //= require jquery.inputmask
+    //= require jquery.inputmask-multi
+
+You can also get the masks files to public directory by running the install generator:
+
+    $ rails generate inputmask_multi_rails:install
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/inputmask-multi-rails.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'inputmask-multi-rails/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'inputmask-multi-rails'
+  gem.version       = InputmaskMultiRails::VERSION
+  gem.authors       = ['vaski']
+  gem.email         = ['vadimmasakovski@gmail.com']
+  gem.description   = %q{Inputmask Multi for Rails. https://github.com/andr-04/inputmask-multi}
+  gem.summary       = %q{Inputmask Multi for Rails. https://github.com/andr-04/inputmask-multi}
+  gem.homepage      = 'https://github.com/vaski/inputmask-multi-rails'
+  gem.license       = 'MIT'
+
+  gem.files         = `git    ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'railties', '~> 3.1'
+end

data/lib/generators/inputmask_multi_rails/install_generator.rb

@@ -0,0 +1,17 @@
+require 'rails'
+
+module InputmaskMultiRails
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      desc 'Copy Inputmask Multi masks files to public directory.'
+      source_root File.expand_path('../../../../vendor/assets/javascripts', __FILE__)
+
+      def copy_public_data
+        say_status('copying', 'phone-codes.json, phones-ru.json, phones-us.json', :green)
+        copy_file 'phone-codes.json', 'public/phone-codes.json'
+        copy_file 'phones-ru.json', 'public/phones-ru.json'
+        copy_file 'phones-us.json', 'public/phones-us.json'
+      end
+    end
+  end
+end

data/lib/inputmask-multi-rails.rb

@@ -0,0 +1,6 @@
+require 'inputmask-multi-rails/version'
+
+module InputmaskMultiRails
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/inputmask-multi-rails/version.rb

@@ -0,0 +1,3 @@
+module InputmaskMultiRails
+  VERSION = '0.0.1'
+end

data/vendor/assets/javascripts/jquery.bind-first.js

@@ -0,0 +1,8 @@
+/*
+ * jQuery.bind-first library v0.2.0
+ * Copyright (c) 2013 Vladimir Zhuravlev
+ *
+ * Released under MIT License
+ *
+ * Date: Sun Jan 20 16:12:09 ICT 2013
+ **/(function(a){function e(b,c,e){var f=c.split(/\s+/);b.each(function(){for(var b=0;b<f.length;++b){var c=a.trim(f[b]).match(/[^\.]+/i)[0];d(a(this),c,e)}})}function d(a,d,e){var f=c(a),g=f[d];if(!b){var h=e?g.splice(g.delegateCount-1,1)[0]:g.pop();g.splice(e?0:g.delegateCount||0,0,h)}else e?f.live.unshift(f.live.pop()):g.unshift(g.pop())}function c(c){return b?c.data("events"):a._data(c[0]).events}var b=parseFloat(a.fn.jquery)<1.7;a.fn.bindFirst=function(){var b=a.makeArray(arguments),c=b.shift();c&&(a.fn.bind.apply(this,arguments),e(this,c));return this},a.fn.delegateFirst=function(){var b=a.makeArray(arguments),c=b[1];c&&(b.splice(0,2),a.fn.delegate.apply(this,arguments),e(this,c,!0));return this},a.fn.liveFirst=function(){var b=a.makeArray(arguments);b.unshift(this.selector),a.fn.delegateFirst.apply(a(document),b);return this}})(jQuery)

data/vendor/assets/javascripts/jquery.inputmask-multi.js

@@ -0,0 +1,382 @@
+/*
+ * @license Multi Input Mask plugin for jquery
+ * https://github.com/andr-04/inputmask-multi
+ * Copyright (c) 2012 Andrey Egorov
+ * Licensed under the MIT license (http://www.opensource.org/licenses/mit-license.php)
+ * Version: 1.0.1
+ *
+ * Requriements:
+ * https://github.com/RobinHerbots/jquery.inputmask
+ * https://github.com/private-face/jquery.bind-first
+ */
+(function ($) {
+    $.masksLoad = function(url) {
+        var maskList;
+        $.ajax({
+            url: url,
+            async: false,
+            dataType: 'json',
+            success: function (response) {
+                maskList = response;
+            }
+        });
+        return maskList;
+    }
+
+    $.masksSort = function(maskList, defs, match, key) {
+        maskList.sort(function (a, b) {
+            var ia = 0, ib = 0;
+            for (; (ia<a[key].length && ib<b[key].length);) {
+                var cha = a[key].charAt(ia);
+                var chb = b[key].charAt(ib);
+                if (!match.test(cha)) {
+                    ia++;
+                    continue;
+                }
+                if (!match.test(chb)) {
+                    ib++;
+                    continue;
+                }
+                if ($.inArray(cha, defs) != -1 && $.inArray(chb, defs) == -1) {
+                    return 1;
+                }
+                if ($.inArray(cha, defs) == -1 && $.inArray(chb, defs) != -1) {
+                    return -1;
+                }
+                if ($.inArray(cha, defs) == -1 && $.inArray(chb, defs) == -1) {
+                    if (cha != chb) {
+                        return cha < chb ? -1 : 1;
+                    }
+                }
+                ia++;
+                ib++;
+            }
+            for (; (ia<a[key].length || ib<b[key].length);) {
+                if (ia<a[key].length && !match.test(a[key].charAt(ia))) {
+                    ia++;
+                    continue;
+                }
+                if (ib<b[key].length && !match.test(b[key].charAt(ib))) {
+                    ib++;
+                    continue;
+                }
+                if (ia<a[key].length) {
+                    return 1;
+                }
+                if (ib<b[key].length) {
+                    return -1;
+                }
+            }
+            return 0;
+        });
+        return maskList;
+    }
+
+    $.fn.inputmasks = function(maskOpts, mode) {
+        //Helper Functions
+        var caret = function(begin, end) {
+            if (typeof begin == 'number') {
+                end = (typeof end == 'number') ? end : begin;
+                if (this.setSelectionRange) {
+                    this.setSelectionRange(begin, end);
+                } else if (this.createTextRange) {
+                    var range = this.createTextRange();
+                    range.collapse(true);
+                    range.moveEnd('character', end);
+                    range.moveStart('character', begin);
+                    range.select();
+                }
+            } else {
+                if (this.setSelectionRange) {
+                    begin = this.selectionStart;
+                    end = this.selectionEnd;
+                } else if (document.selection && document.selection.createRange) {
+                    var range = document.selection.createRange();
+                    begin = 0 - range.duplicate().moveStart('character', -100000);
+                    end = begin + range.text.length;
+                }
+                return {
+                    begin: begin,
+                    end: end
+                };
+            }
+        };
+
+        var keys = Object.keys || function(obj) {
+            if (obj !== Object(obj)) {
+                throw new TypeError('Invalid object');
+            }
+            var keys = [];
+            for (var key in obj) {
+                keys[keys.length] = key;
+            }
+            return keys;
+        };
+
+        maskOpts = $.extend(true, {
+            onMaskChange: $.noop
+        }, maskOpts);
+        var defs = {};
+        for (var def in maskOpts.inputmask.definitions) {
+            var validator = maskOpts.inputmask.definitions[def].validator;
+            switch (typeof validator) {
+                case "string":
+                    defs[def] = new RegExp(validator);
+                    break;
+                case "object":
+                    if ("test" in maskOpts.definitions[def].validator) {
+                        defs[def] = validator;
+                    }
+                    break;
+                case "function":
+                    defs[def] = {
+                        test: validator
+                    };
+                    break;
+            }
+        }
+        maskOpts.inputmask.definitions[maskOpts.replace] = {
+            validator: maskOpts.match.source,
+            cardinality: 1
+        };
+        var iphone = navigator.userAgent.match(/iphone/i) != null;
+        var oldmatch = false;
+        var placeholder = $.extend(true, {}, $.inputmask.defaults, maskOpts.inputmask).placeholder;
+        var insertMode = $.extend(true, {}, $.inputmask.defaults, maskOpts.inputmask).insertMode;
+
+        var maskMatch = function(text) {
+            var mtxt = "";
+            for (var i=0; i<text.length; i++) {
+                var ch = text.charAt(i);
+                if (ch == placeholder) {
+                    break;
+                }
+                if (maskOpts.match.test(ch)) {
+                    mtxt += ch;
+                }
+            }
+            for (var mid in maskOpts.list) {
+                var mask = maskOpts.list[mid][maskOpts.listKey];
+                var pass = true;
+                for (var it=0, im=0; (it<mtxt.length && im<mask.length);) {
+                    var chm = mask.charAt(im);
+                    var cht = mtxt.charAt(it);
+                    if (!maskOpts.match.test(chm) && !(chm in defs)) {
+                        im++;
+                        continue;
+                    }
+                    if (((chm in defs) && defs[chm].test(cht)) || (cht == chm)) {
+                        it++;
+                        im++;
+                    } else {
+                        pass = false;
+                        break;
+                    }
+                }
+                if (pass && it==mtxt.length) {
+                    var determined = mask.substr(im).search(maskOpts.match) == -1;
+                    mask = mask.replace(new RegExp([maskOpts.match.source].concat(keys(defs)).join('|'), 'g'), maskOpts.replace);
+                    var completed = mask.substr(im).search(maskOpts.replace) == -1;
+                    return {
+                        mask: mask,
+                        obj: maskOpts.list[mid],
+                        determined: determined,
+                        completed: completed
+                    };
+                }
+            }
+            return false;
+        }
+
+        var caretApply = function(oldMask, newMask, oldPos) {
+            if (!oldMask) {
+                return 0;
+            }
+            var pos = 0, startPos = 0;
+            for (; pos < oldPos.begin; pos++) {
+                if (oldMask.charAt(pos) == maskOpts.replace) {
+                    startPos++;
+                }
+            }
+            var endPos = 0;
+            for (; pos < oldPos.end; pos++) {
+                if (oldMask.charAt(pos) == maskOpts.replace) {
+                    endPos++;
+                }
+            }
+            for (pos = 0; (pos < newMask.length && (startPos > 0 || newMask.charAt(pos) != maskOpts.replace)); pos++) {
+                if (newMask.charAt(pos) == maskOpts.replace) {
+                    startPos--;
+                }
+            }
+            startPos = pos;
+            for (; (pos < newMask.length && endPos > 0); pos++) {
+                if (newMask.charAt(pos) == maskOpts.replace) {
+                    endPos--;
+                }
+            }
+            endPos = pos;
+            return {
+                begin: startPos,
+                end: endPos
+            };
+        }
+
+        var maskUnbind = function() {
+            $(this)
+            .unbind("keypress.inputmask", masksKeyPress)
+            .unbind("input.inputmask", masksPaste)
+            .unbind("paste.inputmask", masksPaste)
+            .unbind("dragdrop.inputmask", masksPaste)
+            .unbind("drop.inputmask", masksPaste)
+            .unbind("keydown.inputmask", masksKeyDown)
+            .unbind("setvalue.inputmask", masksSetValue)
+            .unbind("blur.inputmask", masksChange);
+        }
+
+        var maskRebind = function() {
+            maskUnbind.call(this);
+            $(this)
+            .bindFirst("keypress.inputmask", masksKeyPress)
+            .bindFirst("input.inputmask", masksPaste)
+            .bindFirst("paste.inputmask", masksPaste)
+            .bindFirst("dragdrop.inputmask", masksPaste)
+            .bindFirst("drop.inputmask", masksPaste)
+            .bindFirst("keydown.inputmask", masksKeyDown)
+            .bindFirst("setvalue.inputmask", masksSetValue)
+            .bind("blur.inputmask", masksChange);
+        }
+
+        var maskApply = function(match, newtext) {
+            if (match && (newtext || match.mask != oldmatch.mask)) {
+                var caretPos;
+                if (!newtext) {
+                    caretPos = caretApply(oldmatch.mask, match.mask, caret.call(this));
+                }
+                if (newtext) {
+                    if (this._valueSet) {
+                        this._valueSet(newtext);
+                    } else {
+                        this.value = newtext;
+                    }
+                }
+                $(this).inputmask(match.mask, $.extend(true, maskOpts.inputmask, {
+                    insertMode: insertMode
+                }));
+                if (!newtext) {
+                    caret.call(this, caretPos.begin, caretPos.end);
+                }
+            }
+            oldmatch = match;
+            maskOpts.onMaskChange.call(this, match.obj, match.determined);
+            return true;
+        }
+
+        var keyboardApply = function(e, text, insert) {
+            var match = maskMatch(text);
+            if (!match || match.obj != oldmatch.obj || match.determined != oldmatch.determined) {
+                if (match) {
+                    maskUnbind.call(this);
+                    if (insert) {
+                        maskApply.call(this, match);
+                        $(this).trigger(e);
+                    } else {
+                        $(this).trigger(e);
+                        maskApply.call(this, match);
+                    }
+                    maskRebind.call(this);
+                }
+                e.stopImmediatePropagation();
+                return false;
+            }
+            return true;
+        }
+
+        var masksKeyDown = function(e) {
+            e = e || window.event;
+            var k = e.which || e.charCode || e.keyCode;
+            if (k == 8 || k == 46 || (iphone && k == 127)) { // delete or backspace
+                var text = this._valueGet();
+                var caretPos = caret.call(this);
+                if (caretPos.begin == caretPos.end || (!insertMode && caretPos.begin == caretPos.end-1)) {
+                    var pos = caretPos.begin;
+                    do {
+                        if (k != 46) { // backspace
+                            pos--;
+                        }
+                        var chr = text.charAt(pos);
+                        text = text.substring(0, pos) + text.substring(pos+1);
+                    } while (pos>0 && pos<text.length && chr != placeholder && !maskOpts.match.test(chr));
+                } else {
+                    var test = text.substring(0, caretPos.begin) + text.substring(caretPos.end);
+                    if (test.search(maskOpts.match) == -1) {
+                        text = test;
+                    }
+                }
+                return keyboardApply.call(this, e, text, false);
+            }
+            if (k == 45) { // insert
+                insertMode = !insertMode;
+            }
+            return true;
+        }
+
+        var masksKeyPress = function(e) {
+            var text = this._valueGet();
+            e = e || window.event;
+            var k = e.which || e.charCode || e.keyCode, c = String.fromCharCode(k);
+            caretPos = caret.call(this);
+            text = text.substring(0, caretPos.begin) + c + text.substring(caretPos.end);
+            return keyboardApply.call(this, e, text, true);
+        }
+
+        var masksChange = function(e) {
+            var match = maskMatch(this._valueGet());
+            maskApply.call(this, match);
+            maskRebind.call(this);
+            return true;
+        }
+
+        var masksSetValue = function(e) {
+            maskInit.call(this);
+            e.stopImmediatePropagation();
+            return true;
+        }
+
+        var maskInit = function() {
+            var text;
+            if (this._valueGet) {
+                text = this._valueGet();
+            } else {
+                text = this.value;
+            }
+            var match = maskMatch(text);
+            while (!match && text.length>0) {
+                text = text.substr(0, text.length-1);
+                match = maskMatch(text);
+            }
+            maskApply.call(this, match, text);
+            maskRebind.call(this);
+        }
+
+        var masksPaste = function(e) {
+            var input = this;
+            setTimeout(function() {
+                maskInit.call(input);
+            }, 0);
+            e.stopImmediatePropagation();
+            return true;
+        }
+
+        switch (mode) {
+            case "isCompleted":
+                var res = maskMatch((this[0]._valueGet && this[0]._valueGet()) || this[0].value);
+                return (res && res.completed);
+            default:
+                this.each(function () {
+                    maskInit.call(this);
+                });
+                return this;
+        }
+    }
+})(jQuery);