Added: Many new class methods

Removed: lol method
Added: Comments on class methods
Added methods: lineBreak, br, tab, word, anyOf, any, range, modifiers,
multiple-loop

Author: jehna

VerbalExpressions.js

@@ -52,67 +52,224 @@ window.VerbalExpression = (function(){
     // Define the class methods.
     VerbalExpression.prototype = {
 
+        // Variables to hold the whole
+        // expression construction in order
+        _prefixes : "",
         _source : "",
+        _suffixes : "",
+        _modifiers : "gm", // default to global multiline matching
 
-        lol: function( value ){
-            console.log( "loL" );
-            this.compile( value );
-            return( this );
-        },
 
+        // Sanitation function for adding
+        // anything safely to the expression
         sanitize : function( value ) {
             return value.replace(/[^\w]/g, function(character) { return "\\" + character; });
         },
 
-        startOfLine: function() {
-            if(this.source.indexOf( "^" ) !== 0) this._source = "^" + this._source;
+        // Function to add stuff to the
+        // expression. Also compiles the
+        // new expression so it's ready to
+        // be used.
+        add: function( value ) {
+            this._source += value || "";
+            this.compile(this._prefixes + this._source + this._suffixes, this._modifiers);
+            return( this );
+        },
+        
+        // Start and end of line functions
+        startOfLine: function( enable ) {
+            enable = ( enable != false );
+            this._prefixes = enable ? "^" : "";
             this.add( "" );
             return( this );
         },
 
-        add: function( value ) {
-            this._source += value || "";
-            this.compile(this._source);
+        endOfLine : function( enable ) {
+            enable = ( enable != false );
+            this._suffixes = enable ? "$" : "";
+            this.add( "" );
             return( this );
         },
 
+        // We try to keep the syntax ass
+        // user-friendly as possible.
+        // So we can use the "normal"
+        // behaviour to split the "scentences"
+        // naturally.
         then : function( value ) {
             value = this.sanitize(value);
             this.add( "(" + value + ")" );
             return( this );
         },
 
+        // And because we can't start with
+        // "then" function, we create an alias
+        // to be used as the first function
+        // of the chain.
         find : function( value ) {
             return( this.then( value ) );
         },
 
+        // Maybe is used to add values with ?
         maybe : function( value ) {
             value = this.sanitize(value);
             this.add( "(" + value + ")?" );
             return( this );
         },
 
+        // Any character any times
         anything : function() {
             this.add( "(.*)" );
             return( this );
         },
 
-        endOfLine : function() {
-            this.add( "$" );
-            return( this );
-        },
-        
+        // Anything but these characters
         anythingBut : function( value ) {
             value = this.sanitize(value);
             this.add( "([^" + value + "]*)" );
             return( this );
         },
 
+        // Shorthand function for the
+        // String.replace function to
+        // give more logical flow if, for
+        // example, we're doing multiple
+        // replacements on one regexp.
         replace : function( source, value ) {
             source = source.toString();
             return source.replace( this, value );
+        },
+        
+        
+        /// Add regular expression special ///
+        /// characters                     ///
+        
+        // Line break
+        lineBreak : function() {
+            this.add( "(\\n|(\\r\\n))" ); // Unix + windows CLRF
+            return( this );
+        },
+        // And a shorthand for html-minded
+        br : function() {
+            return this.lineBreak();
+        },
+        
+        // Tab (duh?)
+        tab : function() {
+            this.add( "\\t" );
+            return( this );
+        },
+        
+        // Any alphanumeric
+        word : function() {
+            this.add( "\\w+" );
+            return( this );
+        },
+        
+        // Any given character
+        anyOf : function( value ) {
+            value = this.sanitize(value);
+            this.add( "["+ value +"]" );
+            return( this );
+        },
+        
+        // Shorthand
+        any : function( value ) {
+            return( this.anyOf( value ) );
+        },
+        
+        // Usage: .range( from, to [, from, to ...] )
+        range : function() {
+            
+            var value = "[";
+            console.log(arguments);
+            
+            for(var _from = 0; _from < arguments.length; _from += 2) {
+                var _to = _from+1;
+                if(arguments.length <= to) break;
+                
+                var from = this.sanitize( arguments[_from] );
+                var to = this.sanitize( arguments[_to] );
+                
+                value += from + "-" + to;
+            }
+            
+            value += "]";
+            
+            this.add( value );
+            return( this );
+        },
+        
+        
+        /// Modifiers      ///
+        
+        // Modifier abstraction
+        addModifier : function( modifier ) {
+            if( this._modifiers.indesxOf( modifier ) == -1 ) {
+                this._modifiers += modifier;
+            }
+            this.add("");
+            return( this );
+        },
+        removeModifier : function( modifier ) {
+            this._modifiers = this._modifiers.replace( modifier, "" );
+            this.add("");
+            return( this );
+        },
+        
+        // Case-insensitivity modifier
+        withAnyCase : function( enable ) {
+            
+            if(enable != false) this.addModifier( "i" );
+            else this.removeModifier( "i" );
+            
+            this.add( "" );
+            return( this );
+            
+        },
+        
+        // Default behaviour is with "g" modifier,
+        // so we can turn this another way around
+        // than other modifiers
+        stopAtFirst : function( enable ) {
+            
+            if(enable != false) this.removeModifier( "g" );
+            else this.addModifier( "g" );
+            
+            this.add( "" );
+            return( this );
+            
+        },
+        
+        // Multiline, also reversed
+        searhOneLine : function( enable ) {
+            
+            if(enable != false) this.removeModifier( "m" );
+            else this.addModifier( "m" );
+            
+            this.add( "" );
+            return( this );
+            
+        },
+        
+        
+        
+        /// Loops  ///
+        
+        multiple : function( value ) {
+            // Use expression or string
+            value = value.source ? value.source : this.sanitize(value);
+            switch(value.substr(-1)) {
+                case "*":
+                case "+":
+                    break;
+                default:
+                    value += "+";
+            }
+            this.add( value );
+            return( this );
         }
- 
+        
     };