meio_mask-rails 0.1.0

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,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in masked_input_plugin_rails.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Rafael Macedo
+
+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,29 @@
+# MaskedInputRails
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'masked_input-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install masked_input-rails
+
+## 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 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/meio_mask-rails.rb

@@ -0,0 +1 @@
+require "meio_mask/rails"

data/lib/meio_mask/rails.rb

@@ -0,0 +1,7 @@
+require 'meio_mask/rails/engine'
+
+module MeioMask
+  module Rails
+
+  end
+end

data/lib/meio_mask/rails/engine.rb

@@ -0,0 +1,6 @@
+module MeioMask
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/meio_mask/rails/version.rb

@@ -0,0 +1,10 @@
+module MeioMask
+  module Rails
+    module Version
+      MAJOR = 0
+      MINOR = 1
+      PATCH = 0
+      STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+    end
+  end
+end

data/meio_mask-rails.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/meio_mask/rails/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Rafael Macedo"]
+  gem.email         = ["macedo.rafaelfernandes@gmail.com"]
+  gem.description   = "Easy way to use meio_mask jquery plugin on rails"
+  gem.summary       = gem.description
+  gem.homepage      = ""
+
+  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.name          = "meio_mask-rails"
+  gem.require_paths = ["lib"]
+  gem.version       = MeioMask::Rails::Version::STRING
+
+  gem.add_dependency "railties", "~> 3.1"
+end

data/vendor/assets/javascripts/jquery.meio.mask.js

@@ -0,0 +1,683 @@
+/**
+ * jquery.meio.mask.js
+ * @author: fabiomcosta
+ * @version: 1.1.3
+ *
+ * Created by Fabio M. Costa on 2008-09-16. Please report any bug at http://www.meiocodigo.com
+ *
+ * Copyright (c) 2008 Fabio M. Costa http://www.meiocodigo.com
+ *
+ * The MIT License (http://www.opensource.org/licenses/mit-license.php)
+ *
+ * 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.
+ */
+
+(function($){
+    
+  var isIphone = (window.orientation != undefined),
+    // browsers like firefox2 and before and opera doenst have the onPaste event, but the paste feature can be done with the onInput event.
+    pasteEvent = (($.browser.opera || ($.browser.mozilla && parseFloat($.browser.version.substr(0,3)) < 1.9 ))? 'input': 'paste');
+    
+  $.event.special.paste = {
+    setup: function() {
+        if(this.addEventListener)
+            this.addEventListener(pasteEvent, pasteHandler, false);
+        else if (this.attachEvent)
+        this.attachEvent(pasteEvent, pasteHandler);
+    },
+
+    teardown: function() {
+      if(this.removeEventListener)
+            this.removeEventListener(pasteEvent, pasteHandler, false);
+        else if (this.detachEvent)
+        this.detachEvent(pasteEvent, pasteHandler);
+    }
+  };
+  
+  // the timeout is set because we can't get the value from the input without it
+  function pasteHandler(e){
+    var self = this;
+    e = $.event.fix(e || window.e);
+    e.type = 'paste';
+    // Execute the right handlers by setting the event type to paste
+    setTimeout(function(){ $.event.handle.call(self, e); }, 1);
+  };
+
+  $.extend({
+    mask : {
+      
+      // the mask rules. You may add yours!
+      // number rules will be overwritten
+      rules : {
+        'z': /[a-z]/,
+        'Z': /[A-Z]/,
+        'a': /[a-zA-Z]/,
+        '*': /[0-9a-zA-Z]/,
+        '@': /[0-9a-zA-ZçÇáàãâéèêíìóòôõúùü]/
+      },
+      
+      // these keys will be ignored by the mask.
+      // all these numbers where obtained on the keydown event
+      keyRepresentation : {
+        8 : 'backspace',
+        9 : 'tab',
+        13  : 'enter',
+        16  : 'shift',
+        17  : 'control',
+        18  : 'alt',
+        27  : 'esc',
+        33  : 'page up',
+        34  : 'page down',
+        35  : 'end',
+        36  : 'home',
+        37  : 'left',
+        38  : 'up',
+        39  : 'right',
+        40  : 'down',
+        45  : 'insert',
+        46  : 'delete',
+        116 : 'f5',
+        123 : 'f12',
+        224 : 'command'
+      },
+      
+      iphoneKeyRepresentation : {
+        10  : 'go',
+        127 : 'delete'
+      },
+      
+      signals : {
+        '+' : '',
+        '-' : '-'
+      },
+      
+      // default settings for the plugin
+      options : {
+        attr: 'alt', // an attr to look for the mask name or the mask itself
+        mask: null, // the mask to be used on the input
+        type: 'fixed', // the mask of this mask
+        maxLength: -1, // the maxLength of the mask
+        defaultValue: '', // the default value for this input
+        signal: false, // this should not be set, to use signal at masks put the signal you want ('-' or '+') at the default value of this mask.
+                 // See the defined masks for a better understanding.
+        
+        textAlign: true, // use false to not use text-align on any mask (at least not by the plugin, you may apply it using css)
+        selectCharsOnFocus: true, // select all chars from input on its focus
+        autoTab: true, // auto focus the next form element when you type the mask completely
+        setSize: false, // sets the input size based on the length of the mask (work with fixed and reverse masks only)
+        fixedChars : '[(),.:/ -]', // fixed chars to be used on the masks. You may change it for your needs!
+        
+        onInvalid : function(){},
+        onValid : function(){},
+        onOverflow : function(){}
+      },
+      
+      // masks. You may add yours!
+      // Ex: $.fn.setMask.masks.msk = {mask: '999'}
+      // and then if the 'attr' options value is 'alt', your input should look like:
+      // <input type="text" name="some_name" id="some_name" alt="msk" />
+      masks : {
+        'phone'       : { mask : '(99) 9999-9999' },
+        'phone-us'      : { mask : '(999) 999-9999' },
+        'cpf'       : { mask : '999.999.999-99' }, // cadastro nacional de pessoa fisica
+        'cnpj'        : { mask : '99.999.999/9999-99' },
+        'date'        : { mask : '39/19/9999' }, //uk date
+        'date-us'     : { mask : '19/39/9999' },
+        'cep'       : { mask : '99999-999' },
+        'time'        : { mask : '29:59' },
+        'cc'        : { mask : '9999 9999 9999 9999' }, //credit card mask
+        'integer'     : { mask : '999.999.999.999', type : 'reverse' },       
+        'decimal'     : { mask : '99,999.999.999.999', type : 'reverse', defaultValue : '000' },
+        'decimal-us'    : { mask : '99.999,999,999,999', type : 'reverse', defaultValue : '000' },
+        'signed-decimal'  : { mask : '99,999.999.999.999', type : 'reverse', defaultValue : '+000' },
+        'signed-decimal-us' : { mask : '99,999.999.999.999', type : 'reverse', defaultValue : '+000' }
+      },
+      
+      init : function(){
+        // if has not inited...
+        if( !this.hasInit ){
+
+          var self = this, i,
+            keyRep = (isIphone)? this.iphoneKeyRepresentation: this.keyRepresentation;
+            
+          this.ignore = false;
+      
+          // constructs number rules
+          for(i=0; i<=9; i++) this.rules[i] = new RegExp('[0-'+i+']');
+        
+          this.keyRep = keyRep;
+          // ignore keys array creation for iphone or the normal ones
+          this.ignoreKeys = [];
+          $.each(keyRep,function(key){
+            self.ignoreKeys.push( parseInt(key) );
+          });
+          
+          this.hasInit = true;
+        }
+      },
+      
+      set: function(el,options){
+        
+        var maskObj = this,
+          $el = $(el),
+          mlStr = 'maxLength';
+        
+        options = options || {};
+        this.init();
+        
+        return $el.each(function(){
+          
+          if(options.attr) maskObj.options.attr = options.attr;
+          
+          var $this = $(this),
+            o = $.extend({}, maskObj.options),
+            attrValue = $this.attr(o.attr),
+            tmpMask = '';
+            
+          // then we look for the 'attr' option
+          tmpMask = (typeof options == 'string')? options: (attrValue != '')? attrValue: null;
+          if(tmpMask) o.mask = tmpMask;
+          
+          // then we see if it's a defined mask
+          if(maskObj.masks[tmpMask]) o = $.extend(o, maskObj.masks[tmpMask]);
+          
+          // then it looks if the options is an object, if it is we will overwrite the actual options
+          if(typeof options == 'object' && options.constructor != Array) o = $.extend(o, options);
+          
+          //then we look for some metadata on the input
+          if($.metadata) o = $.extend(o, $this.metadata());
+          
+          if(o.mask != null){
+            
+            if($this.data('mask')) maskObj.unset($this);
+            
+            var defaultValue = o.defaultValue,
+              reverse = (o.type=='reverse'),
+              fixedCharsRegG = new RegExp(o.fixedChars, 'g');
+            
+            if(o.maxLength == -1) o.maxLength = $this.attr(mlStr);
+            
+            o = $.extend({}, o,{
+              fixedCharsReg: new RegExp(o.fixedChars),
+              fixedCharsRegG: fixedCharsRegG,
+              maskArray: o.mask.split(''),
+              maskNonFixedCharsArray: o.mask.replace(fixedCharsRegG, '').split('')
+            });
+            
+            //setSize option (this is not removed from the input (while removing the mask) since this would be kind of funky)
+            if((o.type=='fixed' || reverse) && o.setSize && !$this.attr('size')) $this.attr('size', o.mask.length);
+            
+            //sets text-align right for reverse masks
+            if(reverse && o.textAlign) $this.css('text-align', 'right');
+            
+            if(this.value!='' || defaultValue!=''){
+              // apply mask to the current value of the input or to the default value
+              var val = maskObj.string((this.value!='')? this.value: defaultValue, o);
+              //setting defaultValue fixes the reset button from the form
+              this.defaultValue = val;
+              $this.val(val);
+            }
+            
+            // compatibility patch for infinite mask, that is now repeat
+            if(o.type=='infinite') o.type = 'repeat';
+            
+            $this.data('mask', o);
+            
+            // removes the maxLength attribute (it will be set again if you use the unset method)
+            $this.removeAttr(mlStr);
+            
+            // setting the input events
+            $this.bind('keydown.mask', {func:maskObj._onKeyDown, thisObj:maskObj}, maskObj._onMask)
+              .bind('keypress.mask', {func:maskObj._onKeyPress, thisObj:maskObj}, maskObj._onMask)
+              .bind('keyup.mask', {func:maskObj._onKeyUp, thisObj:maskObj}, maskObj._onMask)
+              .bind('paste.mask', {func:maskObj._onPaste, thisObj:maskObj}, maskObj._onMask)
+              .bind('focus.mask', maskObj._onFocus)
+              .bind('blur.mask', maskObj._onBlur)
+              .bind('change.mask', maskObj._onChange);
+          }
+        });
+      },
+      
+      //unsets the mask from el
+      unset : function(el){
+        var $el = $(el);
+        
+        return $el.each(function(){
+          var $this = $(this);
+          if($this.data('mask')){
+            var maxLength = $this.data('mask').maxLength;
+            if(maxLength != -1) $this.attr('maxLength', maxLength);
+            $this.unbind('.mask')
+              .removeData('mask');
+          }
+        });
+      },
+      
+      //masks a string
+      string : function(str, options){
+        this.init();
+        var o={};
+        if(typeof str != 'string') str = String(str);
+        switch(typeof options){
+          case 'string':
+            // then we see if it's a defined mask 
+            if(this.masks[options]) o = $.extend(o, this.masks[options]);
+            else o.mask = options;
+            break;
+          case 'object':
+            o = options;
+        }
+        if(!o.fixedChars) o.fixedChars = this.options.fixedChars;
+
+        var fixedCharsReg = new RegExp(o.fixedChars),
+          fixedCharsRegG = new RegExp(o.fixedChars, 'g');
+          
+        // insert signal if any
+        if( (o.type=='reverse') && o.defaultValue ){
+          if( typeof this.signals[o.defaultValue.charAt(0)] != 'undefined' ){
+            var maybeASignal = str.charAt(0);
+            o.signal = (typeof this.signals[maybeASignal] != 'undefined') ? this.signals[maybeASignal] : this.signals[o.defaultValue.charAt(0)];
+            o.defaultValue = o.defaultValue.substring(1);
+          }
+        }
+        
+        return this.__maskArray(str.split(''),
+              o.mask.replace(fixedCharsRegG, '').split(''),
+              o.mask.split(''),
+              o.type,
+              o.maxLength,
+              o.defaultValue,
+              fixedCharsReg,
+              o.signal);
+      },
+      
+      // all the 3 events below are here just to fix the change event on reversed masks.
+      // It isn't fired in cases that the keypress event returns false (needed).
+      _onFocus: function(e){
+        var $this = $(this), dataObj = $this.data('mask');
+        dataObj.inputFocusValue = $this.val();
+        dataObj.changed = false;
+        if(dataObj.selectCharsOnFocus) $this.select();
+      },
+      
+      _onBlur: function(e){
+        var $this = $(this), dataObj = $this.data('mask');
+        if(dataObj.inputFocusValue != $this.val() && !dataObj.changed)
+          $this.trigger('change');
+      },
+      
+      _onChange: function(e){
+        $(this).data('mask').changed = true;
+      },
+      
+      _onMask : function(e){
+        var thisObj = e.data.thisObj,
+          o = {};
+        o._this = e.target;
+        o.$this = $(o._this);
+        // if the input is readonly it does nothing
+        if(o.$this.attr('readonly')) return true;
+        o.data = o.$this.data('mask');
+        o[o.data.type] = true;
+        o.value = o.$this.val();
+        o.nKey = thisObj.__getKeyNumber(e);
+        o.range = thisObj.__getRange(o._this);
+        o.valueArray = o.value.split('');
+        return e.data.func.call(thisObj, e, o);
+      },
+      
+      _onKeyDown : function(e,o){
+        // lets say keypress at desktop == keydown at iphone (theres no keypress at iphone)
+        this.ignore = $.inArray(o.nKey, this.ignoreKeys) > -1 || e.ctrlKey || e.metaKey || e.altKey;
+        if(this.ignore){
+          var rep = this.keyRep[o.nKey];
+          o.data.onValid.call(o._this, rep? rep: '', o.nKey);
+        }
+        return isIphone ? this._keyPress(e, o) : true;
+      },
+      
+      _onKeyUp : function(e, o){
+        //9=TAB_KEY 16=SHIFT_KEY
+        //this is a little bug, when you go to an input with tab key
+        //it would remove the range selected by default, and that's not a desired behavior
+        if(o.nKey==9 || o.nKey==16) return true;
+        
+        if(o.data.type=='repeat'){
+          this.__autoTab(o);
+          return true;
+        }
+
+        return this._onPaste(e, o);
+      },
+      
+      _onPaste : function(e,o){
+        // changes the signal at the data obj from the input
+        if(o.reverse) this.__changeSignal(e.type, o);
+        
+        var $thisVal = this.__maskArray(
+          o.valueArray,
+          o.data.maskNonFixedCharsArray,
+          o.data.maskArray,
+          o.data.type,
+          o.data.maxLength,
+          o.data.defaultValue,
+          o.data.fixedCharsReg,
+          o.data.signal
+        );
+        
+        o.$this.val( $thisVal );
+        // this makes the caret stay at first position when 
+        // the user removes all values in an input and the plugin adds the default value to it (if it haves one).
+        if( !o.reverse && o.data.defaultValue.length && (o.range.start==o.range.end) )
+          this.__setRange(o._this, o.range.start, o.range.end);
+          
+        //fix so ie's and safari's caret won't go to the end of the input value.
+        if( ($.browser.msie || $.browser.safari) && !o.reverse)
+          this.__setRange(o._this,o.range.start,o.range.end);
+        
+        if(this.ignore) return true;
+        
+        this.__autoTab(o);
+        return true;
+      },
+      
+      _onKeyPress: function(e, o){
+        
+        if(this.ignore) return true;
+        
+        // changes the signal at the data obj from the input
+        if(o.reverse) this.__changeSignal(e.type, o);
+        
+        var c = String.fromCharCode(o.nKey),
+          rangeStart = o.range.start,
+          rawValue = o.value,
+          maskArray = o.data.maskArray;
+        
+        if(o.reverse){
+            // the input value from the range start to the value start
+          var valueStart = rawValue.substr(0, rangeStart),
+            // the input value from the range end to the value end
+            valueEnd = rawValue.substr(o.range.end, rawValue.length);
+          
+          rawValue = valueStart+c+valueEnd;
+          //necessary, if not decremented you will be able to input just the mask.length-1 if signal!=''
+          //ex: mask:99,999.999.999 you will be able to input 99,999.999.99
+          if(o.data.signal && (rangeStart-o.data.signal.length > 0)) rangeStart-=o.data.signal.length;
+        }
+
+        var valueArray = rawValue.replace(o.data.fixedCharsRegG, '').split(''),
+          // searches for fixed chars begining from the range start position, till it finds a non fixed
+          extraPos = this.__extraPositionsTill(rangeStart, maskArray, o.data.fixedCharsReg);
+        
+        o.rsEp = rangeStart+extraPos;
+        
+        if(o.repeat) o.rsEp = 0;
+        
+        // if the rule for this character doesnt exist (value.length is bigger than mask.length)
+        // added a verification for maxLength in the case of the repeat type mask
+        if( !this.rules[maskArray[o.rsEp]] || (o.data.maxLength != -1 && valueArray.length >= o.data.maxLength && o.repeat)){
+          // auto focus on the next input of the current form
+          o.data.onOverflow.call(o._this, c, o.nKey);
+          return false;
+        }
+        
+        // if the new character is not obeying the law... :P
+        else if( !this.rules[maskArray[o.rsEp]].test( c ) ){
+          o.data.onInvalid.call(o._this, c, o.nKey);
+          return false;
+        }
+        
+        else o.data.onValid.call(o._this, c, o.nKey);
+        
+        var $thisVal = this.__maskArray(
+          valueArray,
+          o.data.maskNonFixedCharsArray,
+          maskArray,
+          o.data.type,
+          o.data.maxLength,
+          o.data.defaultValue,
+          o.data.fixedCharsReg,
+          o.data.signal,
+          extraPos
+        );
+        
+        o.$this.val( $thisVal );
+        
+        return (o.reverse)? this._keyPressReverse(e, o): (o.fixed)? this._keyPressFixed(e, o): true;
+      },
+      
+      _keyPressFixed: function(e, o){
+
+        if(o.range.start==o.range.end){
+          // the 0 thing is cause theres a particular behavior i wasnt liking when you put a default
+          // value on a fixed mask and you select the value from the input the range would go to the
+          // end of the string when you enter a char. with this it will overwrite the first char wich is a better behavior.
+          // opera fix, cant have range value bigger than value length, i think it loops thought the input value...
+          if((o.rsEp==0 && o.value.length==0) || o.rsEp < o.value.length)
+            this.__setRange(o._this, o.rsEp, o.rsEp+1); 
+        }
+        else
+          this.__setRange(o._this, o.range.start, o.range.end);
+          
+        return true;
+      },
+      
+      _keyPressReverse: function(e, o){
+        //fix for ie
+        //this bug was pointed by Pedro Martins
+        //it fixes a strange behavior that ie was having after a char was inputted in a text input that
+        //had its content selected by any range 
+        if($.browser.msie && ((o.range.start==0 && o.range.end==0) || o.range.start != o.range.end ))
+          this.__setRange(o._this, o.value.length);
+        return false;
+      },
+      
+      __autoTab: function(o){
+        if(o.data.autoTab
+          && (
+            (
+              o.$this.val().length >= o.data.maskArray.length 
+              && !o.repeat 
+            ) || (
+              o.data.maxLength != -1
+              && o.valueArray.length >= o.data.maxLength
+              && o.repeat
+            )
+          )
+        ){
+          var nextEl = this.__getNextInput(o._this, o.data.autoTab);
+          if(nextEl){
+            o.$this.trigger('blur');
+            nextEl.focus().select();
+          }
+        }
+      },
+      
+      // changes the signal at the data obj from the input      
+      __changeSignal : function(eventType,o){
+        if(o.data.signal!==false){
+          var inputChar = (eventType=='paste')? o.value.charAt(0): String.fromCharCode(o.nKey);
+          if( this.signals && (typeof this.signals[inputChar] != 'undefined') ){
+            o.data.signal = this.signals[inputChar];
+          }
+        }
+      },
+      
+      __getKeyNumber : function(e){
+        return (e.charCode||e.keyCode||e.which);
+      },
+      
+      // this function is totaly specific to be used with this plugin, youll never need it
+      // it gets the array representing an unmasked string and masks it depending on the type of the mask
+      __maskArray : function(valueArray, maskNonFixedCharsArray, maskArray, type, maxlength, defaultValue, fixedCharsReg, signal, extraPos){
+        if(type == 'reverse') valueArray.reverse();
+        valueArray = this.__removeInvalidChars(valueArray, maskNonFixedCharsArray, type=='repeat'||type=='infinite');
+        if(defaultValue) valueArray = this.__applyDefaultValue.call(valueArray, defaultValue);
+        valueArray = this.__applyMask(valueArray, maskArray, extraPos, fixedCharsReg);
+        switch(type){
+          case 'reverse':
+            valueArray.reverse();
+            return (signal || '')+valueArray.join('').substring(valueArray.length-maskArray.length);
+          case 'infinite': case 'repeat':
+            var joinedValue = valueArray.join('');
+            return (maxlength != -1 && valueArray.length >= maxlength)? joinedValue.substring(0, maxlength): joinedValue;
+          default:
+            return valueArray.join('').substring(0, maskArray.length);
+        }
+        return '';
+      },
+      
+      // applyes the default value to the result string
+      __applyDefaultValue : function(defaultValue){
+        var defLen = defaultValue.length,thisLen = this.length,i;
+        //removes the leading chars
+        for(i=thisLen-1;i>=0;i--){
+          if(this[i]==defaultValue.charAt(0)) this.pop();
+          else break;
+        }
+        // apply the default value
+        for(i=0;i<defLen;i++) if(!this[i])
+          this[i] = defaultValue.charAt(i);
+          
+        return this;
+      },
+      
+      // Removes values that doesnt match the mask from the valueArray
+      // Returns the array without the invalid chars.
+      __removeInvalidChars : function(valueArray, maskNonFixedCharsArray, repeatType){
+        // removes invalid chars
+        for(var i=0, y=0; i<valueArray.length; i++ ){
+          if( maskNonFixedCharsArray[y] &&
+            this.rules[maskNonFixedCharsArray[y]] &&
+            !this.rules[maskNonFixedCharsArray[y]].test(valueArray[i]) ){
+              valueArray.splice(i,1);
+              if(!repeatType) y--;
+              i--;
+          }
+          if(!repeatType) y++;
+        }
+        return valueArray;
+      },
+      
+      // Apply the current input mask to the valueArray and returns it. 
+      __applyMask : function(valueArray, maskArray, plus, fixedCharsReg){
+        if( typeof plus == 'undefined' ) plus = 0;
+        // apply the current mask to the array of chars
+        for(var i=0; i<valueArray.length+plus; i++ ){
+          if( maskArray[i] && fixedCharsReg.test(maskArray[i]) )
+            valueArray.splice(i, 0, maskArray[i]);
+        }
+        return valueArray;
+      },
+      
+      // searches for fixed chars begining from the range start position, till it finds a non fixed
+      __extraPositionsTill : function(rangeStart, maskArray, fixedCharsReg){
+        var extraPos = 0;
+        while(fixedCharsReg.test(maskArray[rangeStart++])){
+          extraPos++;
+        }
+        return extraPos;
+      },
+      
+      __getNextInput: function(input, selector){
+        var formEls = input.form.elements,
+          initialInputIndex = $.inArray(input, formEls) + 1,
+          $input = null,
+          i;
+        // look for next input on the form of the pased input
+        for(i = initialInputIndex; i < formEls.length; i++){
+          $input = $(formEls[i]);
+          if(this.__isNextInput($input, selector))
+            return $input;
+        }
+          
+        var forms = document.forms,
+          initialFormIndex = $.inArray(input.form, forms) + 1,
+          y, tmpFormEls = null;
+        // look for the next forms for the next input
+        for(y = initialFormIndex; y < forms.length; y++){
+          tmpFormEls = forms[y].elements;
+          for(i = 0; i < tmpFormEls.length; i++){
+            $input = $(tmpFormEls[i]);
+            if(this.__isNextInput($input, selector))
+              return $input;
+          }
+        }
+        return null;
+      },
+      
+      __isNextInput: function($formEl, selector){
+        var formEl = $formEl.get(0);
+        return formEl
+          && (formEl.offsetWidth > 0 || formEl.offsetHeight > 0)
+          && formEl.nodeName != 'FIELDSET'
+          && (selector === true || (typeof selector == 'string' && $formEl.is(selector)));
+      },
+      
+      // http://www.bazon.net/mishoo/articles.epl?art_id=1292
+      __setRange : function(input, start, end) {
+        if(typeof end == 'undefined') end = start;
+        if (input.setSelectionRange){
+          input.setSelectionRange(start, end);
+        }
+        else{
+          // assumed IE
+          var range = input.createTextRange();
+          range.collapse();
+          range.moveStart('character', start);
+          range.moveEnd('character', end - start);
+          range.select();
+        }
+      },
+      
+      // adaptation from http://digitarald.de/project/autocompleter/
+      __getRange : function(input){
+        if (!$.browser.msie) return {start: input.selectionStart, end: input.selectionEnd};
+        var pos = {start: 0, end: 0},
+          range = document.selection.createRange();
+        pos.start = 0 - range.duplicate().moveStart('character', -100000);
+        pos.end = pos.start + range.text.length;
+        return pos;
+      },
+      
+      //deprecated
+      unmaskedVal : function(el){
+        return $(el).val().replace($.mask.fixedCharsRegG, '');
+      }
+      
+    }
+  });
+  
+  $.fn.extend({
+    setMask : function(options){
+      return $.mask.set(this, options);
+    },
+    unsetMask : function(){
+      return $.mask.unset(this);
+    },
+    //deprecated
+    unmaskedVal : function(){
+      return $.mask.unmaskedVal(this[0]);
+    }
+  });
+})(jQuery);
+

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: meio_mask-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Rafael Macedo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Easy way to use meio_mask jquery plugin on rails
+email:
+- macedo.rafaelfernandes@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/meio_mask-rails.rb
+- lib/meio_mask/rails.rb
+- lib/meio_mask/rails/engine.rb
+- lib/meio_mask/rails/version.rb
+- meio_mask-rails.gemspec
+- vendor/assets/javascripts/jquery.meio.mask.js
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Easy way to use meio_mask jquery plugin on rails
+test_files: []