Logic Quiz

numbrscribe.js

var NumbrScribe = (function(plugin){
  plugin = {
    write:function(data){
      //Validate Data
      var integer = Number(data),
          isInteger = (integer % 1 === 0) ? true : false,
          maxLength = plugin.digits.increments.length * 3,
          tooLarge = (data.toString().split('').length > maxLength) ? true : false,
          state,
          output;

      //Negative Zero Doesn't exist
      if(data.substring(1) == "0" && integer === 0) isInteger = false;

      //Output success/error based on inputed data
      if(isInteger && !tooLarge){
        //Check if valid number is +/-
        var value = (integer < 0) ? data.substring(1) : data,
            transcribed = plugin.convert(value);

        //Success
        state = 'success';
        output = (integer < 0) ? 'negative '+transcribed : transcribed;
      } else {
        //Error
        state = 'error';

        if(tooLarge){
          output = plugin.errorMsg(2);
        } else {
          output = (integer !== integer) ? plugin.errorMsg(0) : plugin.errorMsg(1);
        }
      }
      
      plugin.setStatus(state);
      return output;
    },
    convert: function(value){
      //Convert A Number to String
      var numToString = function(number){
        return number.toString();
      };

      //Check How Many Units are in Number
      var numLength = function(number){
        return numToString(number).split('').length;
      };

      //Get Subsets of Numbers
      var getSubNum = function(number, first, last){
        if(typeof last === 'undefined'){
          return Number(numToString(number).substring(first));
        } else {
          return Number(numToString(number).substring(first, last));
        }
      };

      //Scribe Sets of numbers in the 100s
      var scribeIteration = function(rawNumber){
        //Readable version of numbers in 100s
        var hundredsToWords = function(number){
          var hundredDigitWord = singlesToWords(getSubNum(number, 0, 1))+' hundred';

          if(number % 100 !== 0){
            if(Number(getSubNum(number, 1)) < 10){
              hundredDigitWord +=' and '+singlesToWords(getSubNum(number, 2));
            } else {
              hundredDigitWord +=' and '+doublesToWords(getSubNum(number, 1));
            }
          }

          return hundredDigitWord;
        };

        //Readable version of numbers in 10s
        var doublesToWords = function(number){
          var doubleDigitWord;

          if(number > 19){
            doubleDigitWord = plugin.digits.tens[getSubNum(number, 0, 1)];
            if(number % 10 !== 0){
              doubleDigitWord +='-'+singlesToWords(getSubNum(number, 1));
            }
          } else {
            doubleDigitWord = plugin.digits.doubles[getSubNum(number, 1)];
          }

          return doubleDigitWord;
        };

        //Readable Numbers to < 10
        var singlesToWords = function(number){
          return plugin.digits.singles[number];
        }; 

        //Process the RawNumber param that was inputed
        var rawLength = numLength(rawNumber),
            numWord;
        
        if(rawLength == 3){
          numWord = hundredsToWords(rawNumber);
        } else if(rawLength == 2){
          numWord = doublesToWords(rawNumber);
        } else {
          numWord = singlesToWords(rawNumber);
        }

        //Return Word
        return numWord;
      };

      //What we will return to echo
      var output,
          readableNumber,
          flagged;

      //If # < 1000 we can transcribe immediately
      if(numLength(value) < 4){
        readableNumber = scribeIteration(value);
      } else {
        //Prep before iterating number sets in 3s
        var scribedSets = [],
            setsCount = (numLength(value)/3),
            startPos = (setsCount % 1 !== 0) ? (numLength(value) - (Math.floor(setsCount)*3)) - 1 : 2,
            integerArray = value.split(''),
            set = '',
            setIdx;

          //Transcribe in sets of Hundreds
          for (i = 0; i < integerArray.length; ++i) {
            set += integerArray[i];
            if(i == startPos || setIdx == 2){
              var convertedSet = (Number(set) !== 0) ? scribeIteration(Number(set)) : '';
              scribedSets.push(convertedSet);     
              set = '';
              setIdx = 0;
            } else if(i > startPos) {
              ++setIdx;
            }
          }

          //Reverse the transcribed sets for easy incremental labeling
          var reversedArray = scribedSets.reverse(),
              reversedSets = [];

          //Label the sets of hundreds with the larger increments
          for (i = 0; i < reversedArray.length; ++i) {
            var increments = plugin.digits.increments[i],
                compiledWords = (i === 0) ? scribedSets[i] : scribedSets[i]+' '+increments,
                formated = (i == reversedArray.length-1) ? compiledWords : ' '+compiledWords;
            
            if(i !== 0 && formated != ' zero' && scribedSets[i]){
              reversedSets.push(formated);
            } else if(i === 0 && scribedSets[i]){
              reversedSets.push(formated);
            }
          }

          //Reverse again to the correct order
          readableNumber = reversedSets.reverse().toString();

      }

      return readableNumber;
    },
    digits:{
      singles:[
        'zero','one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'
      ],
      doubles:[
        'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'
      ],
      tens:[
        'zero','ten','twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'
      ],
      increments:[
        'hundred', 'thousand', 'million', 'billion', 'trillion', 'quadrillion', 'quintillion', 'sextillion', 'septillion',
        'octillion', 'nonillion', 'decillion', 'undecillion', 'duodecillion', 'tredecillion', 'quattuordecillion',
        'quindecillion', 'sexdecillion', 'septendecillion', 'octodecillion', 'novemdecillion', 'vigintillion', 'centillion'
      ]
    },
    hasErrors:function(){
      return plugin.errors.status;
    },
    errorMsg:function(flag){
      return plugin.errors.flags[flag];
    },
    setStatus:function(type){
      var status = (type == 'error') ? true : false;
      plugin.errors.status = status;
    },
    errors: {
      status: false,
      flags:[
        'Please input a valid number',
        'Really?',
        'The number you entered is too large'
      ]
    }
  };

  return plugin;

})(NumbrScribe || {});