c80_contest 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8589be081b886f52a64155f93fd213212bdb464
-  data.tar.gz: 0f520526b5c616e128d99cebad12fe29176d629e
+  metadata.gz: 1bffc4588cf22bb6aca523694a936ccc9fdc350d
+  data.tar.gz: 82f92265d25042fdccef7a1bb94229bd4174b1f6
 SHA512:
-  metadata.gz: 54652353065ecc637623af8f306769d15392ee352461f3843a146c937ed52a80cdcb69f35dd0528db276701465bfffa98c5d55357c6edbd58027cd5ed8d32ea9
-  data.tar.gz: ac0b82549ed7284a26b7fe29c851614ef0d7a7beca11ac8ec56ae51ec9298389440332dc76593dfe19c65cee292659f31fb6c5ca6c8d0f42e28b8744ea8d31f1
+  metadata.gz: 517885840fe6599b9aaacbcbd24a5e24f3f0b2c6bfdd077bf9111f637ef43c95e5fc5ac992ddb502d81631af080caf0034c408cd06bee2416f83ee53ae17245d
+  data.tar.gz: 3daedefbdc507583b9f1b0616f27c1a122bfc10e232d406169976c52bd7df3c0c166cd10664dea35ec849379948f3a7eea3f34ba5bc3d28236b3268352b83eeb

data/app/assets/javascripts/c80_contest.js.coffee

@@ -1,4 +1,5 @@
 #= require_directory ./lib/fileinput
 # require_directory ./lib/jqx
-#= require_directory ./lib/numbered
+# require_directory ./lib/numbered
+#= require_directory ./lib/masked_input
 #= require c80_contest/frontend/ajax_bid_form

data/app/assets/javascripts/c80_contest/frontend/ajax_bid_form.js

@@ -110,11 +110,13 @@ $(function () {
                 //     mask: '+# (###) ###-##-##'
                 // });
 
-                var numberedFromClass = new Numbered('form#form_bid input#bid_phone', {
-                    mask: '+# (###) ###-##-##',
-                    empty: '_',
-                    placeholder: true
-                });
+                // var numberedFromClass = new Numbered('form#form_bid input#bid_phone', {
+                //     mask: '+# (###) ###-##-##',
+                //     empty: '_',
+                //     placeholder: true
+                // });
+
+                $form.find('input#bid_phone').mask('+9(999)999-99-99');
 
                 setTimeout(function () {
                     $("#bid_photo").fileinput();

data/app/assets/javascripts/lib/masked_input/jquery.maskedinput.js

@@ -0,0 +1,453 @@
+(function (factory) {
+    if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(['jquery'], factory);
+    } else if (typeof exports === 'object') {
+        // Node/CommonJS
+        factory(require('jquery'));
+    } else {
+        // Browser globals
+        factory(jQuery);
+    }
+}(function ($) {
+
+    var ua = navigator.userAgent,
+        iPhone = /iphone/i.test(ua),
+        chrome = /chrome/i.test(ua),
+        android = /android/i.test(ua),
+        caretTimeoutId;
+
+    $.mask = {
+        //Predefined character definitions
+        definitions: {
+            '9': "[0-9]",
+            'a': "[A-Za-z]",
+            '*': "[A-Za-z0-9]"
+        },
+        autoclear: true,
+        dataName: "rawMaskFn",
+        placeholder: '_'
+    };
+
+    $.fn.extend({
+        //Helper Function for Caret positioning
+        caret: function(begin, end) {
+            var range;
+
+            if (this.length === 0 || this.is(":hidden") || this.get(0) !== document.activeElement) {
+                return;
+            }
+
+            if (typeof begin == 'number') {
+                end = (typeof end === 'number') ? end : begin;
+                return this.each(function() {
+                    if (this.setSelectionRange) {
+                        this.setSelectionRange(begin, end);
+                    } else if (this.createTextRange) {
+                        range = this.createTextRange();
+                        range.collapse(true);
+                        range.moveEnd('character', end);
+                        range.moveStart('character', begin);
+                        range.select();
+                    }
+                });
+            } else {
+                if (this[0].setSelectionRange) {
+                    begin = this[0].selectionStart;
+                    end = this[0].selectionEnd;
+                } else if (document.selection && document.selection.createRange) {
+                    range = document.selection.createRange();
+                    begin = 0 - range.duplicate().moveStart('character', -100000);
+                    end = begin + range.text.length;
+                }
+                return { begin: begin, end: end };
+            }
+        },
+        unmask: function() {
+            return this.trigger("unmask");
+        },
+        mask: function(mask, settings) {
+            var input,
+                defs,
+                tests,
+                partialPosition,
+                firstNonMaskPos,
+                lastRequiredNonMaskPos,
+                len,
+                oldVal;
+
+            if (!mask && this.length > 0) {
+                input = $(this[0]);
+                var fn = input.data($.mask.dataName)
+                return fn?fn():undefined;
+            }
+
+            settings = $.extend({
+                autoclear: $.mask.autoclear,
+                placeholder: $.mask.placeholder, // Load default placeholder
+                completed: null
+            }, settings);
+
+
+            defs = $.mask.definitions;
+            tests = [];
+            partialPosition = len = mask.length;
+            firstNonMaskPos = null;
+
+            mask = String(mask);
+
+            $.each(mask.split(""), function(i, c) {
+                if (c == '?') {
+                    len--;
+                    partialPosition = i;
+                } else if (defs[c]) {
+                    tests.push(new RegExp(defs[c]));
+                    if (firstNonMaskPos === null) {
+                        firstNonMaskPos = tests.length - 1;
+                    }
+                    if(i < partialPosition){
+                        lastRequiredNonMaskPos = tests.length - 1;
+                    }
+                } else {
+                    tests.push(null);
+                }
+            });
+
+            return this.trigger("unmask").each(function() {
+                var input = $(this),
+                    buffer = $.map(
+                        mask.split(""),
+                        function(c, i) {
+                            if (c != '?') {
+                                return defs[c] ? getPlaceholder(i) : c;
+                            }
+                        }),
+                    defaultBuffer = buffer.join(''),
+                    focusText = input.val();
+
+                function tryFireCompleted(){
+                    if (!settings.completed) {
+                        return;
+                    }
+
+                    for (var i = firstNonMaskPos; i <= lastRequiredNonMaskPos; i++) {
+                        if (tests[i] && buffer[i] === getPlaceholder(i)) {
+                            return;
+                        }
+                    }
+                    settings.completed.call(input);
+                }
+
+                function getPlaceholder(i){
+                    if(i < settings.placeholder.length)
+                        return settings.placeholder.charAt(i);
+                    return settings.placeholder.charAt(0);
+                }
+
+                function seekNext(pos) {
+                    while (++pos < len && !tests[pos]);
+                    return pos;
+                }
+
+                function seekPrev(pos) {
+                    while (--pos >= 0 && !tests[pos]);
+                    return pos;
+                }
+
+                function shiftL(begin,end) {
+                    var i,
+                        j;
+
+                    if (begin<0) {
+                        return;
+                    }
+
+                    for (i = begin, j = seekNext(end); i < len; i++) {
+                        if (tests[i]) {
+                            if (j < len && tests[i].test(buffer[j])) {
+                                buffer[i] = buffer[j];
+                                buffer[j] = getPlaceholder(j);
+                            } else {
+                                break;
+                            }
+
+                            j = seekNext(j);
+                        }
+                    }
+                    writeBuffer();
+                    input.caret(Math.max(firstNonMaskPos, begin));
+                }
+
+                function shiftR(pos) {
+                    var i,
+                        c,
+                        j,
+                        t;
+
+                    for (i = pos, c = getPlaceholder(pos); i < len; i++) {
+                        if (tests[i]) {
+                            j = seekNext(i);
+                            t = buffer[i];
+                            buffer[i] = c;
+                            if (j < len && tests[j].test(t)) {
+                                c = t;
+                            } else {
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                function androidInputEvent(e) {
+                    var curVal = input.val();
+                    var pos = input.caret();
+
+                    var proxy = function () {
+                        $.proxy($.fn.caret, input, pos.begin, pos.begin)();
+                    };
+
+                    if (oldVal && oldVal.length && oldVal.length > curVal.length ) {
+                        // a deletion or backspace happened
+                        checkVal(true);
+                        while (pos.begin > 0 && !tests[pos.begin-1])
+                            pos.begin--;
+                        if (pos.begin === 0)
+                        {
+                            while (pos.begin < firstNonMaskPos && !tests[pos.begin])
+                                pos.begin++;
+                        }
+                        setTimeout(proxy, 0);
+                    } else {
+                        var pos2 = checkVal(true);
+                        var lastEnteredValue = curVal.charAt(pos.begin);
+                        if (pos.begin < len){
+                            if(!tests[pos.begin]){
+                                pos.begin++;
+                                if(tests[pos.begin].test(lastEnteredValue)){
+                                    pos.begin++;
+                                }
+                            }else{
+                                if(tests[pos.begin].test(lastEnteredValue)){
+                                    pos.begin++;
+                                }
+                            }
+                        }
+                        setTimeout(proxy, 0);
+                    }
+                    tryFireCompleted();
+                }
+
+
+                function blurEvent(e) {
+                    checkVal();
+
+                    if (input.val() != focusText)
+                        input.change();
+                }
+
+                function keydownEvent(e) {
+                    if (input.prop("readonly")){
+                        return;
+                    }
+
+                    var k = e.which || e.keyCode,
+                        pos,
+                        begin,
+                        end;
+                    oldVal = input.val();
+                    //backspace, delete, and escape get special treatment
+                    if (k === 8 || k === 46 || (iPhone && k === 127)) {
+                        pos = input.caret();
+                        begin = pos.begin;
+                        end = pos.end;
+
+                        if (end - begin === 0) {
+                            begin=k!==46?seekPrev(begin):(end=seekNext(begin-1));
+                            end=k===46?seekNext(end):end;
+                        }
+                        clearBuffer(begin, end);
+                        shiftL(begin, end - 1);
+
+                        e.preventDefault();
+                    } else if( k === 13 ) { // enter
+                        blurEvent.call(this, e);
+                    } else if (k === 27) { // escape
+                        input.val(focusText);
+                        input.caret(0, checkVal());
+                        e.preventDefault();
+                    }
+                }
+
+                function keypressEvent(e) {
+                    if (input.prop("readonly")){
+                        return;
+                    }
+
+                    var k = e.which || e.keyCode,
+                        pos = input.caret(),
+                        p,
+                        c,
+                        next;
+
+                    if (e.ctrlKey || e.altKey || e.metaKey || k < 32) {//Ignore
+                        return;
+                    } else if ( k && k !== 13 ) {
+                        if (pos.end - pos.begin !== 0){
+                            clearBuffer(pos.begin, pos.end);
+                            shiftL(pos.begin, pos.end-1);
+                        }
+
+                        p = seekNext(pos.begin - 1);
+                        if (p < len) {
+                            c = String.fromCharCode(k);
+                            if (tests[p].test(c)) {
+                                shiftR(p);
+
+                                buffer[p] = c;
+                                writeBuffer();
+                                next = seekNext(p);
+
+                                if(android){
+                                    //Path for CSP Violation on FireFox OS 1.1
+                                    var proxy = function() {
+                                        $.proxy($.fn.caret,input,next)();
+                                    };
+
+                                    setTimeout(proxy,0);
+                                }else{
+                                    input.caret(next);
+                                }
+                                if(pos.begin <= lastRequiredNonMaskPos){
+                                    tryFireCompleted();
+                                }
+                            }
+                        }
+                        e.preventDefault();
+                    }
+                }
+
+                function clearBuffer(start, end) {
+                    var i;
+                    for (i = start; i < end && i < len; i++) {
+                        if (tests[i]) {
+                            buffer[i] = getPlaceholder(i);
+                        }
+                    }
+                }
+
+                function writeBuffer() { input.val(buffer.join('')); }
+
+                function checkVal(allow) {
+                    //try to place characters where they belong
+                    var test = input.val(),
+                        lastMatch = -1,
+                        i,
+                        c,
+                        pos;
+
+                    for (i = 0, pos = 0; i < len; i++) {
+                        if (tests[i]) {
+                            buffer[i] = getPlaceholder(i);
+                            while (pos++ < test.length) {
+                                c = test.charAt(pos - 1);
+                                if (tests[i].test(c)) {
+                                    buffer[i] = c;
+                                    lastMatch = i;
+                                    break;
+                                }
+                            }
+                            if (pos > test.length) {
+                                clearBuffer(i + 1, len);
+                                break;
+                            }
+                        } else {
+                            if (buffer[i] === test.charAt(pos)) {
+                                pos++;
+                            }
+                            if( i < partialPosition){
+                                lastMatch = i;
+                            }
+                        }
+                    }
+                    if (allow) {
+                        writeBuffer();
+                    } else if (lastMatch + 1 < partialPosition) {
+                        if (settings.autoclear || buffer.join('') === defaultBuffer) {
+                            // Invalid value. Remove it and replace it with the
+                            // mask, which is the default behavior.
+                            if(input.val()) input.val("");
+                            clearBuffer(0, len);
+                        } else {
+                            // Invalid value, but we opt to show the value to the
+                            // user and allow them to correct their mistake.
+                            writeBuffer();
+                        }
+                    } else {
+                        writeBuffer();
+                        input.val(input.val().substring(0, lastMatch + 1));
+                    }
+                    return (partialPosition ? i : firstNonMaskPos);
+                }
+
+                input.data($.mask.dataName,function(){
+                    return $.map(buffer, function(c, i) {
+                        return tests[i]&&c!=getPlaceholder(i) ? c : null;
+                    }).join('');
+                });
+
+
+                input
+                    .one("unmask", function() {
+                        input
+                            .off(".mask")
+                            .removeData($.mask.dataName);
+                    })
+                    .on("focus.mask", function() {
+                        if (input.prop("readonly")){
+                            return;
+                        }
+
+                        clearTimeout(caretTimeoutId);
+                        var pos;
+
+                        focusText = input.val();
+
+                        pos = checkVal();
+
+                        caretTimeoutId = setTimeout(function(){
+                            if(input.get(0) !== document.activeElement){
+                                return;
+                            }
+                            writeBuffer();
+                            if (pos == mask.replace("?","").length) {
+                                input.caret(0, pos);
+                            } else {
+                                input.caret(pos);
+                            }
+                        }, 10);
+                    })
+                    .on("blur.mask", blurEvent)
+                    .on("keydown.mask", keydownEvent)
+                    .on("keypress.mask", keypressEvent)
+                    .on("input.mask paste.mask", function() {
+                        if (input.prop("readonly")){
+                            return;
+                        }
+
+                        setTimeout(function() {
+                            var pos=checkVal(true);
+                            input.caret(pos);
+                            tryFireCompleted();
+                        }, 0);
+                    });
+                if (chrome && android)
+                {
+                    input
+                        .off('input.mask')
+                        .on('input.mask', androidInputEvent);
+                }
+                checkVal(); //Perform initial check for existing values
+            });
+        }
+    });
+}));

data/app/views/c80_contest/shared/_bid_form.html.erb

@@ -33,7 +33,7 @@
 
             <div class="form-group clearfix">
               <%= f.label :phone, settings.form_label_phone, class: 'control-label must' %>
-              <%= f.text_field :phone, class: 'form-control' %>
+              <%= f.text_field :phone, class: 'form-control', type: 'tel' %>
               <span class="help-block col-md-12"></span>
             </div>
 

data/lib/c80_contest/version.rb

@@ -1,3 +1,3 @@
 module C80Contest
-  VERSION = '0.1.7'
+  VERSION = '0.1.8'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: c80_contest
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - C80609A
@@ -265,6 +265,7 @@ files:
 - app/assets/javascripts/lib/fileinput/themes/gly/theme.js
 - app/assets/javascripts/lib/jqx/jqxcore.js
 - app/assets/javascripts/lib/jqx/jqxmaskedinput.js
+- app/assets/javascripts/lib/masked_input/jquery.maskedinput.js
 - app/assets/javascripts/lib/numbered/numbered.js
 - app/assets/stylesheets/c80_contest.scss
 - app/assets/stylesheets/c80_contest/backend/bid_page.scss