postman-collection - npm Package Compare versions

Comparing version 3.5.1-beta.1 to 3.5.1-beta.2

lib/collection/cookie.js

 var _ = require('../util').lodash,
     PropertyBase = require('./property-base').PropertyBase,
 
+    E = '',
+    EQ = '=',
     PAIR_SPLIT_REGEX = /; */,
+    COOKIES_SEPARATOR = '; ',
 
@@ -137,2 +140,3 @@ /**
              * @todo Accept date object and convert stringified date (timestamp only) to date object
+             * @todo Consider using Infinity as a default
              */
@@ -219,2 +223,44 @@ expires: _.isString(options.expires) ? new Date(options.expires) : options.expires,
         return decodeURIComponent(this.value);
+    },
+
+    toString: function () {
+        var str = Cookie.unparseSingle(this);
+
+        if (this.expires instanceof Date) {
+            // check for valid date
+            if (!Number.isNaN(this.expires.getTime())) {
+                str += '; Expires=' + this.expires.toGMTString();
+            }
+        }
+        else if (this.expires) {
+            str += '; Expires=' + this.expires;
+        }
+
+        if (this.maxAge && this.maxAge !== Infinity) {
+            str += '; Max-Age=' + this.maxAge;
+        }
+
+        if (this.domain && !this.hostOnly) {
+            str += '; Domain=' + this.domain;
+        }
+
+        if (this.path) {
+            str += '; Path=' + this.path;
+        }
+
+        if (this.secure) {
+            str += '; Secure';
+        }
+
+        if (this.httpOnly) {
+            str += '; HttpOnly';
+        }
+
+        if (this.extensions) {
+            this.extensions.forEach(function (ext) {
+                str += '; ' + ext;
+            });
+        }
+
+        return str;
     }
@@ -249,2 +295,23 @@ });
 
+    unparse: function (cookies) {
+        if (!_.isArray(cookies) && !PropertyList.isPropertyList(cookies)) {
+            return E;
+        }
+
+        return cookies.map(Cookie.unparseSingle).join(COOKIES_SEPARATOR);
+    },
+
+    unparseSingle: function (cookie) {
+        if (!_.isObject(cookie)) { return E; }
+
+        var value = _.isNil(cookie.value) ? E : cookie.value;
+
+        // for the empty name, return just the value to match the browser behavior
+        if (!cookie.name) {
+            return value;
+        }
+
+        return cookie.name + EQ + value;
+    },
+
     /**
@@ -289,2 +356,6 @@ * Cookie header parser
 
+    stringify: function (cookie) {
+        return Cookie.prototype.toString.call(cookie);
+    },
+
     /**
@@ -291,0 +362,0 @@ * Splits a Cookie parameter into a key and a value

lib/collection/variable-scope.js

@@ -320,2 +320,22 @@ var _ = require('../util').lodash,
     /**
+     * Replace all variable names with their values in the given template.
+     *
+     * @param {String|Object} template - A string or an object to replace variables in
+     * @returns {String|Object} The string or object with variables (if any) substituted with their values
+     */
+    replaceIn: function (template) {
+        if (_.isString(template) || _.isArray(template)) {
+            // convert template to object because replaceSubstitutionsIn only accepts objects
+            var result = Property.replaceSubstitutionsIn({ template: template }, _.concat(this.values, this._layers));
+            return result.template;
+        }
+
+        if (_.isObject(template)) {
+            return Property.replaceSubstitutionsIn(template, _.concat(this.values, this._layers));
+        }
+
+        return template;
+    },
+
+    /**
      * Enable mutation tracking.
@@ -322,0 +342,0 @@ *

lib/superstring/dynamic-variables.js

@@ -81,3 +81,3 @@ var faker = require('faker/locale/en'),
         $guid: {
-            description: 'Generates a v4 style guid',
+            description: 'A v4 style guid',
             generator: function () {
@@ -89,3 +89,3 @@ return uuid.v4();
         $timestamp: {
-            description: 'Generates the current timestamp',
+            description: 'The current timestamp',
             generator: function () {
@@ -97,3 +97,3 @@ return Math.round(Date.now() / 1000);
         $randomInt: {
-            description: 'Generates a random integer between 1 and 1000',
+            description: 'A random integer between 1 and 1000',
             generator: function () {
@@ -107,3 +107,3 @@ return ~~(Math.random() * (1000 + 1));
         $randomPhoneNumber: {
-            description: 'Generates a random phone number',
+            description: 'A random 10-digit phone number',
             generator: function () {
@@ -117,3 +117,3 @@ return faker.phone.phoneNumberFormat(0);
         $randomPhoneNumberExt: {
-            description: 'Generates a random phone number with extension',
+            description: 'A random phone number with extension (12 digits)',
             generator: function () {
@@ -127,3 +127,3 @@ return faker.random.number({ min: 1, max: 99 }) + '-' + faker.phone.phoneNumberFormat(0);
         $randomLocale: {
-            description: 'Generates a random locale',
+            description: 'A random two-letter language code (ISO 639-1)',
             generator: function () {
@@ -137,3 +137,3 @@ return faker.random.arrayElement(LOCALES);
         $randomWords: {
-            description: 'Generates some random words',
+            description: 'Some random words',
             generator: function () {
@@ -154,3 +154,3 @@ var words = [],
         $randomFilePath: {
-            description: 'Generates a random path for a file',
+            description: 'A random file path',
             generator: function () {
@@ -164,3 +164,3 @@ return dynamicGenerators.$randomDirectoryPath.generator() + '/' + faker.system.fileName();
         $randomDirectoryPath: {
-            description: 'Generates a random directory path',
+            description: 'A random directory path',
             generator: function () {
@@ -172,27 +172,27 @@ return faker.random.arrayElement(DIRECTORY_PATHS);
         $randomCity: {
-            description: 'Generates a random city',
+            description: 'A random city name',
             generator: faker.address.city
         },
         $randomStreetName: {
-            description: 'Generates a random street name',
+            description: 'A random street name',
             generator: faker.address.streetName
         },
         $randomStreetAddress: {
-            description: 'Generates a random street address',
+            description: 'A random street address (e.g. 1234 Main Street)',
             generator: faker.address.streetAddress
         },
         $randomCountry: {
-            description: 'Generates a random country',
+            description: 'A random country',
             generator: faker.address.country
         },
         $randomCountryCode: {
-            description: 'Generates a random country code',
+            description: 'A random 2-letter country code (ISO 3166-1 alpha-2)',
             generator: faker.address.countryCode
         },
         $randomLatitude: {
-            description: 'Generates a random latitude',
+            description: 'A random latitude coordinate',
             generator: faker.address.latitude
         },
         $randomLongitude: {
-            description: 'Generates a random longitude',
+            description: 'A random longitude coordinate',
             generator: faker.address.longitude
@@ -202,23 +202,23 @@ },
         $randomColor: {
-            description: 'Generates a random color',
+            description: 'A random color',
             generator: faker.commerce.color
         },
         $randomDepartment: {
-            description: 'Generates a random commerce department',
+            description: 'A random commerce category (e.g. electronics, clothing)',
             generator: faker.commerce.department
         },
         $randomProductName: {
-            description: 'Generates a random product name',
+            description: 'A random product name (e.g. handmade concrete tuna)',
             generator: faker.commerce.productName
         },
         $randomProductAdjective: {
-            description: 'Generates a random product adjective',
+            description: 'A random product adjective (e.g. tasty, eco-friendly)',
             generator: faker.commerce.productAdjective
         },
         $randomProductMaterial: {
-            description: 'Generates a random product material',
+            description: 'A random product material (e.g. steel, plastic, leather)',
             generator: faker.commerce.productMaterial
         },
         $randomProduct: {
-            description: 'Generates a random product',
+            description: 'A random product (e.g. shoes, table, chair)',
             generator: faker.commerce.product
@@ -228,39 +228,39 @@ },
         $randomCompanyName: {
-            description: 'Generates a random company name',
+            description: 'A random company name',
             generator: faker.company.companyName
         },
         $randomCompanySuffix: {
-            description: 'Generates a random company suffix',
+            description: 'A random company suffix (e.g. Inc, LLC, Group)',
             generator: faker.company.companySuffix
         },
         $randomCatchPhrase: {
-            description: 'Generates a random company catchphrase',
+            description: 'A random catchphrase',
             generator: faker.company.catchPhrase
         },
         $randomBs: {
-            description: 'Generates a random company Bs',
+            description: 'A random phrase of business speak',
             generator: faker.company.bs
         },
         $randomCatchPhraseAdjective: {
-            description: 'Generates a random catchphrase adjective',
+            description: 'A random catchphrase adjective',
             generator: faker.company.catchPhraseAdjective
         },
         $randomCatchPhraseDescriptor: {
-            description: 'Generates a random catchphrase descriptor',
+            description: 'A random catchphrase descriptor',
             generator: faker.company.catchPhraseDescriptor
         },
         $randomCatchPhraseNoun: {
-            description: 'Generates a random catchphrase noun',
+            description: 'Randomly generates a catchphrase noun',
             generator: faker.company.catchPhraseNoun
         },
         $randomBsAdjective: {
-            description: 'Generates a random company Bs adjective',
+            description: 'A random business speak adjective',
             generator: faker.company.bsAdjective
         },
         $randomBsBuzz: {
-            description: 'Generates a random company Bs buzz',
+            description: 'A random business speak buzzword',
             generator: faker.company.bsBuzz
         },
         $randomBsNoun: {
-            description: 'Generates a random company Bs noun',
+            description: 'A random business speak noun',
             generator: faker.company.bsNoun
@@ -270,15 +270,15 @@ },
         $randomDatabaseColumn: {
-            description: 'Generates a random database column name',
+            description: 'A random database column name (e.g. updatedAt, token, group)',
             generator: faker.database.column
         },
         $randomDatabaseType: {
-            description: 'Generates a random database type',
+            description: 'A random database type (e.g. tiny int, double, point)',
             generator: faker.database.type
         },
         $randomDatabaseCollation: {
-            description: 'Generates a random database collation',
+            description: 'A random database collation (e.g. cp1250_bin)',
             generator: faker.database.collation
         },
         $randomDatabaseEngine: {
-            description: 'Generates a random database engine',
+            description: 'A random database engine (e.g. Memory, Archive, InnoDB)',
             generator: faker.database.engine
@@ -288,19 +288,19 @@ },
         $randomDatePast: {
-            description: 'Generates a random past date',
+            description: 'A random past datetime',
             generator: faker.date.past
         },
         $randomDateFuture: {
-            description: 'Generates a random future date',
+            description: 'A random future datetime',
             generator: faker.date.future
         },
         $randomDateRecent: {
-            description: 'Generates a random recent date',
+            description: 'A random recent datetime',
             generator: faker.date.recent
         },
         $randomMonth: {
-            description: 'Generates a random month',
+            description: 'A random month',
             generator: faker.date.month
         },
         $randomWeekday: {
-            description: 'Generates a random weekday',
+            description: 'A random weekday',
             generator: faker.date.weekday
@@ -310,43 +310,43 @@ },
         $randomBankAccount: {
-            description: 'Generates a random bank account',
+            description: 'A random 8-digit bank account number',
             generator: faker.finance.account
         },
         $randomBankAccountName: {
-            description: 'Generates a random bank account name',
+            description: 'A random bank account name (e.g. savings account, checking account)',
             generator: faker.finance.accountName
         },
         $randomCreditCardMask: {
-            description: 'Generates a random masked credit card number',
+            description: 'A random masked credit card number',
             generator: faker.finance.mask
         },
         $randomPrice: {
-            description: 'Generates a random price',
+            description: 'A random price between 100.00 and 999.00',
             generator: faker.finance.amount
         },
         $randomTransactionType: {
-            description: 'Generates a random transaction type',
+            description: 'A random transaction type (e.g. invoice, payment, deposit)',
             generator: faker.finance.transactionType
         },
         $randomCurrencyCode: {
-            description: 'Generates a random currency code',
+            description: 'A random 3-letter currency code (ISO-4217)',
             generator: faker.finance.currencyCode
         },
         $randomCurrencyName: {
-            description: 'Generates a random currency name',
+            description: 'A random currency name',
             generator: faker.finance.currencyName
         },
         $randomCurrencySymbol: {
-            description: 'Generates a random currency symbol',
+            description: 'A random currency symbol',
             generator: faker.finance.currencySymbol
         },
         $randomBitcoin: {
-            description: 'Generates a random bitcoin address',
+            description: 'A random bitcoin address',
             generator: faker.finance.bitcoinAddress
         },
         $randomBankAccountIban: {
-            description: 'Generates a random bank account IBAN',
+            description: 'A random 15-31 character IBAN (International Bank Account Number)',
             generator: faker.finance.iban
         },
         $randomBankAccountBic: {
-            description: 'Generates a random bank account BIC',
+            description: 'A random BIC (Bank Identifier Code)',
             generator: faker.finance.bic
@@ -356,92 +356,84 @@ },
         $randomAbbreviation: {
-            description: 'Generates a random abbreviation',
+            description: 'A random abbreviation',
             generator: faker.hacker.abbreviation
         },
         $randomAdjective: {
-            description: 'Generates a random adjective',
+            description: 'A random adjective',
             generator: faker.hacker.adjective
         },
         $randomNoun: {
-            description: 'Generates a random noun',
+            description: 'A random noun',
             generator: faker.hacker.noun
         },
         $randomVerb: {
-            description: 'Generates a random verb',
+            description: 'A random verb',
             generator: faker.hacker.verb
         },
         $randomIngverb: {
-            description: 'Generates a random verb ending with an ing',
+            description: 'A random verb ending in “-ing”',
             generator: faker.hacker.ingverb
         },
         $randomPhrase: {
-            description: 'Generates a random phrase',
+            description: 'A random phrase',
             generator: faker.hacker.phrase
         },
 
-        $randomImage: {
-            description: 'Generates a random image',
-            generator: faker.image.image
-        },
         $randomAvatarImage: {
-            description: 'Generates a random avatar image',
+            description: 'A random avatar image',
             generator: faker.image.avatar
         },
         $randomImageUrl: {
-            description: 'Generates a random image URL',
+            description: 'A URL for a random image',
             generator: faker.image.imageUrl
         },
         $randomAbstractImage: {
-            description: 'Generates a random abstract image URL',
+            description: 'A URL for a random abstract image',
             generator: faker.image.abstract
         },
         $randomAnimalsImage: {
-            description: 'Generates a random animals image URL',
+            description: 'A URL for a random animal image',
             generator: faker.image.animals
         },
         $randomBusinessImage: {
-            description: 'Generates a random business image URL',
+            description: 'A URL for a random stock business image',
             generator: faker.image.business
         },
         $randomCatsImage: {
-            description: 'Generates a random cat image URL',
+            description: 'A URL for a random cat image',
             generator: faker.image.cats
         },
         $randomCityImage: {
-            description: 'Generates a random city image URL',
+            description: 'A URL for a random city image',
             generator: faker.image.city
         },
         $randomFoodImage: {
-            description: 'Generates a random food image URL',
+            description: 'A URL for a random food image',
             generator: faker.image.food
         },
         $randomNightlifeImage: {
-            description: 'Generates a random nightlife image URL',
+            description: 'A URL for a random nightlife image',
             generator: faker.image.nightlife
         },
         $randomFashionImage: {
-            description: 'Generates a random fashion image URL',
+            description: 'A URL for a random fashion image',
             generator: faker.image.fashion
         },
         $randomPeopleImage: {
-            description: 'Generates a random people image URL',
+            description: 'A URL for a random image of a person',
             generator: faker.image.people
         },
         $randomNatureImage: {
-            description: 'Generates a random nature image URL',
+            description: 'A URL for a random nature image',
             generator: faker.image.nature
         },
         $randomSportsImage: {
-            description: 'Generates a random sports image URL',
+            description: 'A URL for a random sports image',
             generator: faker.image.sports
         },
-        $randomTechnicsImage: {
-            description: 'Generates a random technics image URL',
-            generator: faker.image.technics
-        },
         $randomTransportImage: {
-            description: 'Generates a random transport image URL',
+            description: 'A URL for a random transportation image',
             generator: faker.image.transport
         },
         $randomImageDataUri: {
-            description: 'Generates a random image data URI',
+            description: 'A random image data URI',
             generator: faker.image.dataUri
@@ -451,55 +443,55 @@ },
         $randomEmail: {
-            description: 'Generates a random email',
+            description: 'A random email address',
             generator: faker.internet.email
         },
         $randomExampleEmail: {
-            description: 'Generates a random example email',
+            description: 'A random email address from an “example” domain (e.g. [e-mail])',
             generator: faker.internet.exampleEmail
         },
         $randomUserName: {
-            description: 'Generates a random username',
+            description: 'A random username',
             generator: faker.internet.userName
         },
         $randomProtocol: {
-            description: 'Generates a random internet protocol',
+            description: 'A random internet protocol',
             generator: faker.internet.protocol
         },
         $randomUrl: {
-            description: 'Generates a random URL',
+            description: 'A random URL',
             generator: faker.internet.url
         },
         $randomDomainName: {
-            description: 'Generates a random domain name',
+            description: 'A random domain name (e.g. gracie.biz, trevor.info)',
             generator: faker.internet.domainName
         },
         $randomDomainSuffix: {
-            description: 'Generates a random domain suffix',
+            description: 'A random domain suffix (e.g. .com, .net, .org)',
             generator: faker.internet.domainSuffix
         },
         $randomDomainWord: {
-            description: 'Generates a random domain word',
+            description: 'A random unqualified domain name (a name with no dots)',
             generator: faker.internet.domainWord
         },
         $randomIP: {
-            description: 'Generates a random IPv4 address',
+            description: 'A random IPv4 address',
             generator: faker.internet.ip
         },
         $randomIPV6: {
-            description: 'Generates a random IPv6 address',
+            description: 'A random IPv6 address',
             generator: faker.internet.ipv6
         },
         $randomUserAgent: {
-            description: 'Generates a random user agent',
+            description: 'A random user agent',
             generator: faker.internet.userAgent
         },
         $randomHexColor: {
-            description: 'Generates a random hex color',
+            description: 'A random hex value',
             generator: faker.internet.color
         },
         $randomMACAddress: {
-            description: 'Generates a random MAC address',
+            description: 'A random MAC address',
             generator: faker.internet.mac
         },
         $randomPassword: {
-            description: 'Generates a random password',
+            description: 'A random 15-character alpha-numeric password',
             generator: faker.internet.password
@@ -509,35 +501,35 @@ },
         $randomLoremWord: {
-            description: 'Generates a random lorem word',
+            description: 'A random word of lorem ipsum text',
             generator: faker.lorem.word
         },
         $randomLoremWords: {
-            description: 'Generates some random lorem words',
+            description: 'Some random words of lorem ipsum text',
             generator: faker.lorem.words
         },
         $randomLoremSentence: {
-            description: 'Generates a random lorem sentence',
+            description: 'A random sentence of lorem ipsum text',
             generator: faker.lorem.sentence
         },
         $randomLoremSlug: {
-            description: 'Generates a random lorem slug',
+            description: 'A random lorem ipsum URL slug',
             generator: faker.lorem.slug
         },
         $randomLoremSentences: {
-            description: 'Generates some random lorem sentences',
+            description: 'A random 2-6 sentences of lorem ipsum text',
             generator: faker.lorem.sentences
         },
         $randomLoremParagraph: {
-            description: 'Generates a random lorem paragraph',
+            description: 'A random paragraph of lorem ipsum text',
             generator: faker.lorem.paragraph
         },
         $randomLoremParagraphs: {
-            description: 'Generates some random lorem paragraphs',
+            description: '3 random paragraphs of lorem ipsum text',
             generator: faker.lorem.paragraphs
         },
         $randomLoremText: {
-            description: 'Generates some random lorem text',
+            description: 'A random amount of lorem ipsum text',
             generator: faker.lorem.text
         },
         $randomLoremLines: {
-            description: 'Generates some random lorem lines',
+            description: '1-5 random lines of lorem ipsum',
             generator: faker.lorem.lines
@@ -547,35 +539,35 @@ },
         $randomFirstName: {
-            description: 'Generates a random first name',
+            description: 'A random first name',
             generator: faker.name.firstName
         },
         $randomLastName: {
-            description: 'Generates a random last name',
+            description: 'A random last name',
             generator: faker.name.lastName
         },
         $randomFullName: {
-            description: 'Generates a random full name',
+            description: 'A random first and last name',
             generator: faker.name.findName
         },
         $randomJobTitle: {
-            description: 'Generates a random job title',
+            description: 'A random job title (e.g. senior software developer)',
             generator: faker.name.jobTitle
         },
         $randomNamePrefix: {
-            description: 'Generates a random name prefix',
+            description: 'A random name prefix (e.g. Mr., Mrs., Dr.)',
             generator: faker.name.prefix
         },
         $randomNameSuffix: {
-            description: 'Generates a random name suffix',
+            description: 'A random name suffix (e.g. Jr., MD, PhD)',
             generator: faker.name.suffix
         },
         $randomJobDescriptor: {
-            description: 'Generates a random job descriptor',
+            description: 'A random job descriptor (e.g., senior, chief, corporate, etc.)',
             generator: faker.name.jobDescriptor
         },
         $randomJobArea: {
-            description: 'Generates a random job area',
+            description: 'A random job area (e.g. branding, functionality, usability)',
             generator: faker.name.jobArea
         },
         $randomJobType: {
-            description: 'Generates a random job type',
+            description: 'A random job type (e.g. supervisor, manager, coordinator, etc.)',
             generator: faker.name.jobType
@@ -585,15 +577,15 @@ },
         $randomUUID: {
-            description: 'Generates a random UUID',
+            description: 'A random 36-character UUID',
             generator: faker.random.uuid
         },
         $randomBoolean: {
-            description: 'Generates a random boolean value (true/false)',
+            description: 'A random boolean value (true/false)',
             generator: faker.random.boolean
         },
         $randomWord: {
-            description: 'Generates a random word',
+            description: 'A random word',
             generator: faker.random.word
         },
         $randomAlphaNumeric: {
-            description: 'Generates a random alpha-numeric value',
+            description: 'A random alpha-numeric character',
             generator: faker.random.alphaNumeric
@@ -603,31 +595,31 @@ },
         $randomFileName: {
-            description: 'Generates a random file name',
+            description: 'A random file name (includes uncommon extensions)',
             generator: faker.system.fileName
         },
         $randomCommonFileName: {
-            description: 'Generates a random common file name',
+            description: 'A random file name',
             generator: faker.system.commonFileName
         },
         $randomMimeType: {
-            description: 'Generates a random mime type',
+            description: 'A random MIME type',
             generator: faker.system.mimeType
         },
         $randomCommonFileType: {
-            description: 'Generates a random common file type',
+            description: 'A random, common file type (e.g., video, text, image, etc.)',
             generator: faker.system.commonFileType
         },
         $randomCommonFileExt: {
-            description: 'Generates a random common file extension',
+            description: 'A random, common file extension (.doc, .jpg, etc.)',
             generator: faker.system.commonFileExt
         },
         $randomFileType: {
-            description: 'Generates a random file type',
+            description: 'A random file type (includes uncommon file types)',
             generator: faker.system.fileType
         },
         $randomFileExt: {
-            description: 'Generates a random file extension',
+            description: 'A random file extension (includes uncommon extensions)',
             generator: faker.system.fileExt
         },
         $randomSemver: {
-            description: 'Generates a random semantic version number',
+            description: 'A random semantic version number',
             generator: faker.system.semver
@@ -634,0 +626,0 @@ }

package.json

@@ -5,3 +5,3 @@ {
   "author": "Postman Labs <[e-mail]>",
-  "version": "3.5.1-beta.1",
+  "version": "3.5.1-beta.2",
   "keywords": [
@@ -54,3 +54,3 @@ "postman"
     "bipbip": "0.4.1",
-    "browserify": "16.2.3",
+    "browserify": "16.3.0",
     "btoa": "1.2.1",
@@ -91,5 +91,6 @@ "chai": "4.2.0",
     "ignore": [
-      "file-type"
+      "file-type",
+      "eslint-plugin-jsdoc"
     ]
   }
 }

No alert changes

Improved metrics

Total package byte prevSize

523697

increased by0.52%

Lines of code

11297

increased by0.57%

No dependency changes