Merge remote-tracking branch 'origin/master'

Author: JamesMessinger

README.md

@@ -8,6 +8,7 @@ JSON Schema $Ref Parser
 [![npm](https://img.shields.io/npm/v/json-schema-ref-parser.svg)](https://www.npmjs.com/package/json-schema-ref-parser)
 [![Dependencies](https://david-dm.org/APIDevTools/json-schema-ref-parser.svg)](https://david-dm.org/APIDevTools/json-schema-ref-parser)
 [![License](https://img.shields.io/npm/l/json-schema-ref-parser.svg)](LICENSE)
+[![Buy us a tree](https://img.shields.io/badge/Treeware-%F0%9F%8C%B3-lightgreen)](https://plant.treeware.earth/APIDevTools/json-schema-ref-parser)
 
 
 [![OS and Browser Compatibility](https://apitools.dev/img/badges/ci-badges-with-ie.svg)](https://github.com/APIDevTools/json-schema-ref-parser/blob/master/.github/workflows/CI-CD.yaml)
@@ -138,17 +139,21 @@ To build/test the project locally on your computer:
 2. __Install dependencies__<br>
 `npm install`
 
-3. __Run the build script__<br>
-`npm run build`
-
-4. __Run the tests__<br>
+3. __Run the tests__<br>
 `npm test`
 
 
+
 License
 --------------------------
 JSON Schema $Ref Parser is 100% free and open-source, under the [MIT license](LICENSE). Use it however you want.
 
+If you use JSON Schema $Ref Parser, then we ask that you [**buy the world a tree**](https://plant.treeware.earth/APIDevTools/json-schema-ref-parser) to thank us for our work.
+
+By contributing to the Treeware forest you’ll be creating employment for local families and restoring wildlife habitats.  Read more about Treeware at [treeware.earth](http://treeware.earth)
+
+
+
 Big Thanks To
 --------------------------
 Thanks to these awesome companies for their support of Open Source developers ❤

lib/util/url.js

@@ -29,7 +29,19 @@ exports.resolve = require("url").resolve;
  * @returns {string}
  */
 exports.cwd = function cwd () {
-  return process.browser ? location.href : process.cwd() + "/";
+  if (process.browser) {
+    return location.href;
+  }
+
+  let path = process.cwd();
+
+  let lastChar = path.slice(-1);
+  if (lastChar === "/" || lastChar === "\\") {
+    return path;
+  }
+  else {
+    return path + "/";
+  }
 };
 
 /**

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-ref-parser",
-  "version": "7.1.3",
+  "version": "7.1.4",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
   "keywords": [
     "json",

package.json

@@ -0,0 +1,107 @@
+"use strict";
+
+const { expect } = require("chai");
+const { resolve } = require("path");
+const $RefParser = require("../../..");
+const path = require("../../utils/path");
+const helper = require("../../utils/helper");
+const url = require("../../../lib/util/url");
+const parsedSchema = require("./parsed");
+const dereferencedSchema = require("./dereferenced");
+const bundledSchema = require("./bundled");
+
+describe("When executed in the context of root directory", () => {
+  // Store the OS root directory
+  const root = resolve("/");
+
+  // Store references to the original methods
+  const originalProcessCwd = process.cwd;
+  const originalUrlCwd = url.cwd;
+
+  /**
+   * A mock `process.cwd()` implementation that always returns the root diretory
+   */
+  function mockProcessCwd () {
+    return root;
+  }
+
+  /**
+   * Temporarily mocks `process.cwd()` while calling the real `url.cwd()` implemenation
+   */
+  function mockUrlCwd () {
+    try {
+      process.cwd = mockProcessCwd;
+      return originalUrlCwd.apply(null, arguments);
+    }
+    finally {
+      process.cwd = originalProcessCwd;
+    }
+  }
+
+  beforeEach("Mock process.cwd and url.cwd", () => {
+    url.cwd = mockUrlCwd;
+  });
+
+  afterEach("Restore process.cwd and url.cwd", () => {
+    url.cwd = originalUrlCwd;
+    process.cwd = originalProcessCwd; // already restored by the finally block above, but just in case
+  });
+
+
+  it("should parse successfully from an absolute path", async () => {
+    let parser = new $RefParser();
+    const schema = await parser.parse(path.abs("specs/absolute-root/absolute-root.yaml"));
+    expect(schema).to.equal(parser.schema);
+    expect(schema).to.deep.equal(parsedSchema.schema);
+    expect(parser.$refs.paths()).to.deep.equal([
+      path.abs("specs/absolute-root/absolute-root.yaml")
+    ]);
+  });
+
+  it("should parse successfully from a url", async () => {
+    let parser = new $RefParser();
+    const schema = await parser.parse(path.url("specs/absolute-root/absolute-root.yaml"));
+    expect(schema).to.equal(parser.schema);
+    expect(schema).to.deep.equal(parsedSchema.schema);
+    expect(parser.$refs.paths()).to.deep.equal([path.url("specs/absolute-root/absolute-root.yaml")]);
+  });
+
+  it("should resolve successfully from an absolute path", helper.testResolve(
+    path.abs("specs/absolute-root/absolute-root.yaml"),
+    path.abs("specs/absolute-root/absolute-root.yaml"), parsedSchema.schema,
+    path.abs("specs/absolute-root/definitions/definitions.json"), parsedSchema.definitions,
+    path.abs("specs/absolute-root/definitions/name.yaml"), parsedSchema.name,
+    path.abs("specs/absolute-root/definitions/required-string.yaml"), parsedSchema.requiredString
+  ));
+
+  it("should resolve successfully from a url", helper.testResolve(
+    path.url("specs/absolute-root/absolute-root.yaml"),
+    path.url("specs/absolute-root/absolute-root.yaml"), parsedSchema.schema,
+    path.url("specs/absolute-root/definitions/definitions.json"), parsedSchema.definitions,
+    path.url("specs/absolute-root/definitions/name.yaml"), parsedSchema.name,
+    path.url("specs/absolute-root/definitions/required-string.yaml"), parsedSchema.requiredString
+  ));
+
+  it("should dereference successfully", async () => {
+    let parser = new $RefParser();
+    const schema = await parser.dereference(path.abs("specs/absolute-root/absolute-root.yaml"));
+    expect(schema).to.equal(parser.schema);
+    expect(schema).to.deep.equal(dereferencedSchema);
+    // Reference equality
+    expect(schema.properties.name).to.equal(schema.definitions.name);
+    expect(schema.definitions["required string"])
+      .to.equal(schema.definitions.name.properties.first)
+      .to.equal(schema.definitions.name.properties.last)
+      .to.equal(schema.properties.name.properties.first)
+      .to.equal(schema.properties.name.properties.last);
+    // The "circular" flag should NOT be set
+    expect(parser.$refs.circular).to.equal(false);
+  });
+
+  it("should bundle successfully", async () => {
+    let parser = new $RefParser();
+    const schema = await parser.bundle(path.abs("specs/absolute-root/absolute-root.yaml"));
+    expect(schema).to.equal(parser.schema);
+    expect(schema).to.deep.equal(bundledSchema);
+  });
+});

test/specs/absolute-root/absolute-root.spec.js

@@ -0,0 +1,17 @@
+title: Person
+type: object
+required:
+  - name
+properties:
+  name:
+    $ref: "#/definitions/name"
+  age:
+    type: integer
+    minimum: 0
+  gender:
+    type: string
+    enum:
+      - male
+      - female
+definitions:
+  $ref: definitions/definitions.json

test/specs/absolute-root/absolute-root.yaml

@@ -0,0 +1,69 @@
+"use strict";
+
+module.exports =
+{
+  title: "Person",
+  type: "object",
+  required: [
+    "name"
+  ],
+  properties: {
+    name: {
+      $ref: "#/definitions/name"
+    },
+    age: {
+      type: "integer",
+      minimum: 0
+    },
+    gender: {
+      type: "string",
+      enum: [
+        "male",
+        "female"
+      ]
+    }
+  },
+  definitions: {
+    "required string": {
+      title: "required string",
+      type: "string",
+      minLength: 1
+    },
+    string: {
+      $ref: "#/definitions/required%20string/type"
+    },
+    name: {
+      title: "name",
+      type: "object",
+      required: [
+        "first",
+        "last"
+      ],
+      properties: {
+        first: {
+          $ref: "#/definitions/required%20string"
+        },
+        last: {
+          $ref: "#/definitions/required%20string"
+        },
+        middle: {
+          type: {
+            $ref: "#/definitions/required%20string/type"
+          },
+          minLength: {
+            $ref: "#/definitions/required%20string/minLength"
+          }
+        },
+        prefix: {
+          $ref: "#/definitions/required%20string",
+          minLength: 3
+        },
+        suffix: {
+          $ref: "#/definitions/name/properties/prefix",
+          type: "string",
+          maxLength: 3
+        }
+      }
+    }
+  }
+};

test/specs/absolute-root/bundled.js

@@ -0,0 +1,11 @@
+{
+  "required string": {
+    "$ref": "required-string.yaml"
+  },
+  "string": {
+    "$ref": "#/required%20string/type"
+  },
+  "name": {
+    "$ref": "../definitions/name.yaml"
+  }
+}

test/specs/absolute-root/definitions/definitions.json

@@ -0,0 +1,22 @@
+title: name
+type: object
+required:
+  - first
+  - last
+properties:
+  first:
+    $ref: ../definitions/definitions.json#/required string
+  last:
+    $ref: ./required-string.yaml
+  middle:
+    type:
+      $ref: "#/properties/first/type"
+    minLength:
+      $ref: "#/properties/first/minLength"
+  prefix:
+    $ref: "#/properties/last"
+    minLength: 3
+  suffix:
+    type: string
+    $ref: "#/properties/prefix"
+    maxLength: 3

test/specs/absolute-root/definitions/name.yaml

@@ -0,0 +1,3 @@
+title: required string
+type: string
+minLength: 1