view release on metacpan or  search on metacpan

share/vendor/js/uritemplates.js  view on Meta::CPAN

            // NOTE: by storing tupples we make sure a null return is validly consistent too in expansions
        }
    }
    return result;
};

CachingContext.prototype.lookupRaw = function(key) {
    return CachingContext.lookup(this, this.raw, key);
};

CachingContext.lookup = function(me, context, key) {
    var result = context[key];
    if (result !== undefined) {
        return result;
    } else {
        var keyparts = key.split('.');
        var i = 0, keysplits = keyparts.length - 1;
        for (i = 0; i<keysplits; i++) {
            var leadKey = keyparts.slice(0, keysplits - i).join('.');
            var trailKey = keyparts.slice(-i-1).join('.');
            var leadContext = context[leadKey];
            if (leadContext !== undefined) {
                return CachingContext.lookup(me, leadContext, trailKey);
            }
        }
        return undefined;
    }
};


function UriTemplate(set) {
    this.set = set;
}

UriTemplate.prototype.expand = function(context) {
    var cache = new CachingContext(context);
    var res = "";
    var i = 0, cnt = this.set.length;
    for (i = 0; i<cnt; i++ ) {
        res += this.set[i].expand(cache);
    }
    return res;
};

//TODO: change since draft-0.6 about characters in literals
/* extract:
The characters outside of expressions in a URI Template string are intended to be copied literally to the URI-reference if the character is allowed in a URI (reserved / unreserved / pct-encoded) or, if not allowed, copied to the URI-reference in its ...
*/
function Literal(txt ) {
    this.txt = txt;
}

Literal.prototype.expand = function() {
    return this.txt;
};



var RESERVEDCHARS_RE = new RegExp("[:/?#\\[\\]@!$&()*+,;=']","g");
function encodeNormal(val) {
    return encodeURIComponent(val).replace(RESERVEDCHARS_RE, function(s) {return escape(s);} );
}

//var SELECTEDCHARS_RE = new RegExp("[]","g");
function encodeReserved(val) {
    //return encodeURI(val).replace(SELECTEDCHARS_RE, function(s) {return escape(s)} );
    return encodeURI(val); // no need for additional replace if selected-chars is empty
}


function addUnNamed(name, key, val) {
    return key + (key.length > 0 ? "=" : "") + val;
}

function addNamed(name, key, val, noName) {
    noName = noName || false;
    if (noName) { name = ""; }
    
    if (!key || key.length === 0)  {
        key = name;
    }
    return key + (key.length > 0 ? "=" : "") + val;
}

function addLabeled(name, key, val, noName) {
    noName = noName || false;
    if (noName) { name = ""; }
    
    if (!key || key.length === 0)  {
        key = name;
    }
    return key + (key.length > 0 && val ? "=" : "") + val;
}


var simpleConf = { 
    prefix : "",     joiner : ",",     encode : encodeNormal,    builder : addUnNamed
};
var reservedConf = { 
    prefix : "",     joiner : ",",     encode : encodeReserved,  builder : addUnNamed
};
var fragmentConf = { 
    prefix : "#",    joiner : ",",     encode : encodeReserved,  builder : addUnNamed
};
var pathParamConf = { 
    prefix : ";",    joiner : ";",     encode : encodeNormal,    builder : addLabeled
};
var formParamConf = { 
    prefix : "?",    joiner : "&",     encode : encodeNormal,    builder : addNamed
};
var formContinueConf = { 
    prefix : "&",    joiner : "&",     encode : encodeNormal,    builder : addNamed
};
var pathHierarchyConf = { 
    prefix : "/",    joiner : "/",     encode : encodeNormal,    builder : addUnNamed
};
var labelConf = { 
    prefix : ".",    joiner : ".",     encode : encodeNormal,    builder : addUnNamed
};


function Expression(conf, vars ) {
    extend(this, conf);
    this.vars = vars;
}

share/vendor/js/uritemplates.js  view on Meta::CPAN

        if (obj.hasOwnProperty(k) ) {
            if (obj[k] !== null && obj[k] !== undefined) {
                buffer.append(joiner + k + ',').append(obj[k], encoder);
                joiner = ",";
            }
        }
    }
    return buffer.str;
}


function simpleValueHandler(me, val, valprops, encoder, adder) {
    var result;
    
    if (valprops.isArr) {
        result = arrayToString(val, encoder, me.maxLength);
    } else if (valprops.isObj) {
        result = objectToString(val, encoder, me.maxLength);
    } else {
        var buffer = new Buffer(me.maxLength);
        result = buffer.append(val, encoder).str;
    }       
    
    adder("", result);
}

function explodeValueHandler(me, val, valprops, encoder, adder) {
    if (valprops.isArr) {
        var i = 0, cnt = val.length;
        for (i = 0; i<cnt; i++) {
            adder("", encoder(val[i]) );
        }
    } else if (valprops.isObj) {
        var k;
        for (k in val) {
            if (val.hasOwnProperty(k)) {
                adder(k, encoder(val[k]) );
            }
        }
    } else { // explode-requested, but single value
        adder("", encoder(val));
    }
}

function valueProperties(val) {
    var isArr = false;
    var isObj = false;
    var isUndef = true;  //note: "" is empty but not undef
    
    if (val !== null && val !== undefined) {
        isArr = (val.constructor === Array);
        isObj = (val.constructor === Object);
        isUndef = (isArr && val.length === 0) || (isObj && isEmptyObject(val));
    } 
    
    return {isArr: isArr, isObj: isObj, isUndef: isUndef};
}


function VarSpec (name, vhfn, nums) {
    this.name = unescape(name); 
    this.valueHandler = vhfn;
    this.maxLength = nums;
}


VarSpec.build = function(name, expl, part, nums) {
    var valueHandler, valueModifier;
    
    if (!!expl) { //interprete as boolean
        valueHandler = explodeValueHandler;
    } else {
        valueHandler = simpleValueHandler;
    }
    
    if (!part) {
        nums = UNBOUND;
    }
    
    return new VarSpec(name, valueHandler, nums);
};


VarSpec.prototype.addValues = function(context, encoder, adder) {
    var val = context.get(this.name);
    var valprops = valueProperties(val);
    if (valprops.isUndef) { return; } // ignore empty values 
    this.valueHandler(this, val, valprops, encoder, adder);
};
    
    

//----------------------------------------------parsing logic
// How each varspec should look like
var VARSPEC_RE=/([^*:]*)((\*)|(:)([0-9]+))?/;

var match2varspec = function(m) {
    var name = m[1];
    var expl = m[3];
    var part = m[4];
    var nums = parseInt(m[5], 10);
    
    return VarSpec.build(name, expl, part, nums);
};


// Splitting varspecs in list with:
var LISTSEP=",";

// How each template should look like
var TEMPL_RE=/(\{([+#.;?&\/])?(([^.*:,{}|@!=$()][^*:,{}$()]*)(\*|:([0-9]+))?(,([^.*:,{}][^*:,{}]*)(\*|:([0-9]+))?)*)\})/g;
// Note: reserved operators: |!@ are left out of the regexp in order to make those templates degrade into literals 
// (as expected by the spec - see tests.html "reserved operators")


var match2expression = function(m) {
    var expr = m[0];
    var ops = m[2] || '';
    var vars = m[3].split(LISTSEP);
    var i = 0, len = vars.length;
    for (i = 0; i<len; i++) {