faker 1.0.0

package/lib/helpers.js

@@ -0,0 +1,124 @@
+var faker = require('../index');
+
+// backword-compatibility
+exports.randomNumber = function (range) {
+    return faker.random.number(range);
+};
+
+// backword-compatibility
+exports.randomize = function (array) {
+    return faker.random.array_element(array);
+};
+
+// slugifies string
+exports.slugify = function (string) {
+    return string.replace(/ /g, '-').replace(/[^\w\.\-]+/g, '');
+};
+
+// parses string for a symbol and replace it with a random number from 1-10
+exports.replaceSymbolWithNumber = function (string, symbol) {
+    // default symbol is '#'
+    if (symbol === undefined) {
+        symbol = '#';
+    }
+
+    var str = '';
+    for (var i = 0; i < string.length; i++) {
+        if (string[i] == symbol) {
+            str += Math.floor(Math.random() * 10);
+        } else {
+            str += string[i];
+        }
+    }
+    return str;
+};
+
+// takes an array and returns it randomized
+exports.shuffle = function (o) {
+    for (var j, x, i = o.length; i; j = parseInt(Math.random() * i, 10), x = o[--i], o[i] = o[j], o[j] = x);
+    return o;
+};
+
+exports.createCard = function () {
+    return {
+        "name": faker.Name.findName(),
+        "username": faker.Internet.userName(),
+        "email": faker.Internet.email(),
+        "address": {
+            "streetA": faker.Address.streetName(),
+            "streetB": faker.Address.streetAddress(),
+            "streetC": faker.Address.streetAddress(true),
+            "streetD": faker.Address.secondaryAddress(),
+            "city": faker.Address.city(),
+            "ukCounty": faker.Address.ukCounty(),
+            "ukCountry": faker.Address.ukCountry(),
+            "zipcode": faker.Address.zipCode(),
+            "geo": {
+                "lat": faker.Address.latitude(),
+                "lng": faker.Address.longitude()
+            }
+        },
+        "phone": faker.PhoneNumber.phoneNumber(),
+        "website": faker.Internet.domainName(),
+        "company": {
+            "name": faker.Company.companyName(),
+            "catchPhrase": faker.Company.catchPhrase(),
+            "bs": faker.Company.bs()
+        },
+        "posts": [
+            {
+                "words": faker.Lorem.words(),
+                "sentence": faker.Lorem.sentence(),
+                "sentences": faker.Lorem.sentences(),
+                "paragraph": faker.Lorem.paragraph()
+            },
+            {
+                "words": faker.Lorem.words(),
+                "sentence": faker.Lorem.sentence(),
+                "sentences": faker.Lorem.sentences(),
+                "paragraph": faker.Lorem.paragraph()
+            },
+            {
+                "words": faker.Lorem.words(),
+                "sentence": faker.Lorem.sentence(),
+                "sentences": faker.Lorem.sentences(),
+                "paragraph": faker.Lorem.paragraph()
+            }
+        ]
+    };
+};
+
+
+exports.userCard = function () {
+    return {
+        "name": faker.Name.findName(),
+        "username": faker.Internet.userName(),
+        "email": faker.Internet.email(),
+        "address": {
+            "street": faker.Address.streetName(true),
+            "suite": faker.Address.secondaryAddress(),
+            "city": faker.Address.city(),
+            "zipcode": faker.Address.zipCode(),
+            "geo": {
+                "lat": faker.Address.latitude(),
+                "lng": faker.Address.longitude()
+            }
+        },
+        "phone": faker.PhoneNumber.phoneNumber(),
+        "website": faker.Internet.domainName(),
+        "company": {
+            "name": faker.Company.companyName(),
+            "catchPhrase": faker.Company.catchPhrase(),
+            "bs": faker.Company.bs()
+        }
+    };
+};
+
+
+/*
+String.prototype.capitalize = function () { //v1.0
+    return this.replace(/\w+/g, function (a) {
+        return a.charAt(0).toUpperCase() + a.substr(1).toLowerCase();
+    });
+};
+*/

package/lib/image.js

@@ -0,0 +1,58 @@
+var faker = require('../index');
+
+var image = {
+  avatar: function () {
+    return faker.random.avatar_uri();
+  },
+  imageUrl: function (width, height, category) {
+      var width = width || 640;
+      var height = height || 480;
+
+      var url ='http://lorempixel.com/' + width + '/' + height;
+      if (typeof category !== 'undefined') {
+        url += '/' + category;
+      }
+      return url;
+  },
+  abstractImage: function (width, height) {
+    return this.imageUrl(width, height, 'abstract');
+  },
+  animals: function (width, height) {
+    return this.imageUrl(width, height, 'animals');
+  },
+  business: function (width, height) {
+    return this.imageUrl(width, height, 'business');
+  },
+  cats: function (width, height) {
+    return this.imageUrl(width, height, 'cats');
+  },
+  city: function (width, height) {
+    return this.imageUrl(width, height, 'city');
+  },
+  food: function (width, height) {
+    return this.imageUrl(width, height, 'food');
+  },
+  nightlife: function (width, height) {
+    return this.imageUrl(width, height, 'nightlife');
+  },
+  fashion: function (width, height) {
+    return this.imageUrl(width, height, 'fashion');
+  },
+  people: function (width, height) {
+    return this.imageUrl(width, height, 'people');
+  },
+  nature: function (width, height) {
+    return this.imageUrl(width, height, 'nature');
+  },
+  sports: function (width, height) {
+    return this.imageUrl(width, height, 'sports');
+  },
+  technics: function (width, height) {
+    return this.imageUrl(width, height, 'technics');
+  },
+  transport: function (width, height) {
+    return this.imageUrl(width, height, 'transport');
+  }
+};
+
+module.exports = image;

package/lib/internet.js

@@ -0,0 +1,53 @@
+var faker = require('../index');
+
+var internet = {
+    email: function () {
+        return faker.Helpers.slugify(this.userName()) + "@" + faker.Helpers.slugify(this.domainName());
+    },
+
+    userName: function () {
+        var result;
+        switch (faker.random.number(2)) {
+        case 0:
+            result = faker.random.first_name();
+            break;
+        case 1:
+            result = faker.random.first_name() + faker.random.array_element([".", "_"]) + faker.random.last_name();
+            break;
+        }
+        return result;
+    },
+
+    domainName: function () {
+        return this.domainWord() + "." + faker.random.domain_suffix();
+    },
+
+    domainWord:  function () {
+        return faker.random.first_name().toLowerCase();
+    },
+
+    ip: function () {
+        var randNum = function () {
+            return (Math.random() * 254 + 1).toFixed(0);
+        };
+
+        var result = [];
+        for (var i = 0; i < 4; i++) {
+            result[i] = randNum();
+        }
+
+        return result.join(".");
+    },
+
+    color: function (baseRed255, baseGreen255, baseBlue255) {
+
+        // based on awesome response : http://stackoverflow.com/questions/43044/algorithm-to-randomly-generate-an-aesthetically-pleasing-color-palette
+        var red = Math.floor((faker.random.number(256) + baseRed255) / 2);
+        var green = Math.floor((faker.random.number(256) + baseRed255) / 2);
+        var blue = Math.floor((faker.random.number(256) + baseRed255) / 2);
+
+        return '#' + red.toString(16) + green.toString(16) + blue.toString(16);
+    }
+};
+
+module.exports = internet;

package/lib/lorem.js

@@ -0,0 +1,45 @@
+var faker = require('../index');
+var Helpers = require('./helpers');
+var definitions = require('../lib/definitions');
+
+var lorem = {
+    words: function (num) {
+        if (typeof num == 'undefined') { num = 3; }
+        return Helpers.shuffle(definitions.lorem).slice(0, num);
+    },
+
+    sentence: function (wordCount, range) {
+        if (typeof wordCount == 'undefined') { wordCount = 3; }
+        if (typeof range == 'undefined') { range = 7; }
+
+        // strange issue with the node_min_test failing for captialize, please fix and add this back
+        //return  this.words(wordCount + Helpers.randomNumber(range)).join(' ').capitalize();
+
+        return  this.words(wordCount + faker.random.number(7)).join(' ');
+    },
+
+    sentences: function (sentenceCount) {
+        if (typeof sentenceCount == 'undefined') { sentenceCount = 3; }
+        var sentences = [];
+        for (sentenceCount; sentenceCount > 0; sentenceCount--) {
+            sentences.push(this.sentence());
+        }
+        return sentences.join("\n");
+    },
+
+    paragraph: function (sentenceCount) {
+        if (typeof sentenceCount == 'undefined') { sentenceCount = 3; }
+        return this.sentences(sentenceCount + faker.random.number(3));
+    },
+
+    paragraphs: function (paragraphCount) {
+        if (typeof paragraphCount == 'undefined') { paragraphCount = 3; }
+        var paragraphs = [];
+        for (paragraphCount; paragraphCount > 0; paragraphCount--) {
+            paragraphs.push(this.paragraph());
+        }
+        return paragraphs.join("\n \r\t");
+    }
+};
+
+module.exports = lorem;

package/lib/name.js

@@ -0,0 +1,34 @@
+var faker = require('../index');
+
+var _name = {
+    firstName: function () {
+        return faker.random.first_name();
+    },
+
+    //Working as intended
+    firstNameFemale: function () {
+        return faker.random.first_name();
+    },
+    //Working as intended
+    firstNameMale: function () {
+        return faker.random.first_name();
+    },
+
+    lastName: function () {
+        return faker.random.last_name();
+    },
+
+    findName: function () {
+        var r = faker.random.number(8);
+        switch (r) {
+        case 0:
+            return faker.random.name_prefix() + " " + this.firstName() + " " + this.lastName();
+        case 1:
+            return this.firstName() + " " + this.lastName() + " " + faker.random.name_suffix();
+        }
+
+        return this.firstName() + " " + this.lastName();
+    }
+};
+
+module.exports = _name;

package/lib/phone_number.js

@@ -0,0 +1,16 @@
+var faker = require('../index');
+var Helpers = require('./helpers');
+var definitions = require('./definitions');
+
+var phone = {
+    phoneNumber: function () {
+        return Helpers.replaceSymbolWithNumber(faker.random.phone_formats());
+    },
+
+    // FIXME: this is strange passing in an array index.
+    phoneNumberFormat: function (phoneFormatsArrayIndex) {
+        return Helpers.replaceSymbolWithNumber(definitions.phone_formats[phoneFormatsArrayIndex]);
+    }
+};
+
+module.exports = phone;

package/lib/random.js

@@ -0,0 +1,106 @@
+var definitions = require('./definitions');
+
+var random = {
+    // returns a single random number based on a range
+    number: function (range) {
+        return Math.floor(Math.random() * range);
+    },
+
+    // takes an array and returns the array randomly sorted
+    array_element: function (array) {
+        var r = Math.floor(Math.random() * array.length);
+        return array[r];
+    },
+
+    city_prefix: function () {
+        return this.array_element(definitions.city_prefix);
+    },
+
+    city_suffix: function () {
+        return this.array_element(definitions.city_suffix);
+    },
+
+    street_suffix: function () {
+        return this.array_element(definitions.street_suffix);
+    },
+
+    br_state: function () {
+        return this.array_element(definitions.br_state);
+    },
+
+    br_state_abbr: function () {
+        return this.array_element(definitions.br_state_abbr);
+    },
+
+    us_state: function () {
+        return this.array_element(definitions.us_state);
+    },
+
+    us_state_abbr: function () {
+        return this.array_element(definitions.us_state_abbr);
+    },
+
+    uk_county: function () {
+        return this.array_element(definitions.uk_county);
+    },
+
+    uk_country: function () {
+        return this.array_element(definitions.uk_country);
+    },
+
+    first_name: function () {
+        return this.array_element(definitions.first_name);
+    },
+
+    last_name: function () {
+        return this.array_element(definitions.last_name);
+    },
+
+    name_prefix: function () {
+        return this.array_element(definitions.name_prefix);
+    },
+
+    name_suffix: function () {
+        return this.array_element(definitions.name_suffix);
+    },
+
+    catch_phrase_adjective: function () {
+        return this.array_element(definitions.catch_phrase_adjective);
+    },
+
+    catch_phrase_descriptor: function () {
+        return this.array_element(definitions.catch_phrase_descriptor);
+    },
+
+    catch_phrase_noun: function () {
+        return this.array_element(definitions.catch_phrase_noun);
+    },
+
+    bs_adjective: function () {
+        return this.array_element(definitions.bs_adjective);
+    },
+
+    bs_buzz: function () {
+        return this.array_element(definitions.bs_buzz);
+    },
+
+    bs_noun: function () {
+        return this.array_element(definitions.bs_noun);
+    },
+
+    phone_formats: function () {
+        return this.array_element(definitions.phone_formats);
+    },
+
+    domain_suffix: function () {
+        return this.array_element(definitions.domain_suffix);
+    },
+
+    avatar_uri: function () {
+        return this.array_element(definitions.avatar_uri);
+    }
+
+
+};
+
+module.exports = random;

package/lib/tree.js

@@ -0,0 +1,69 @@
+var faker = require('../index');
+
+var tree = {
+
+    clone: function clone(obj) {
+        if (obj == null || typeof(obj) != 'object')
+            return obj;
+
+        var temp = obj.constructor(); // changed
+
+        for (var key in obj) {
+            temp[key] = this.clone(obj[key]);
+        }
+        return temp;
+    },
+
+    createTree: function (depth, width, obj) {
+        if (!obj) {
+            throw {
+                name: "ObjectError",
+                message: "there needs to be an object passed in"
+            };
+        }
+
+
+        if (width <= 0) {
+            throw {
+                name: "TreeParamError",
+                message: "width must be greater than zero"
+            };
+        }
+
+        var newObj = this.clone(obj);
+
+        for (var prop in newObj) {
+            if (newObj.hasOwnProperty(prop)) {
+                var value = null;
+                if (newObj[prop] !== "__RECURSE__") {
+                    value = eval(newObj[prop]);
+                }
+                else {
+                    if (depth !== 0) {
+                        value = [];
+                        var evalWidth = 1;
+
+                        if (typeof(width) == "function") {
+                            evalWidth = width();
+                        }
+                        else {
+                            evalWidth = width;
+                        }
+
+                        for (var i = 0; i < evalWidth; i++) {
+                            value.push(this.createTree(depth - 1, width, obj));
+                        }
+
+                    }
+                }
+
+                newObj[prop] = value;
+            }
+        }
+
+        return newObj;
+    }
+
+};
+
+module.exports = tree;