ref: Create internal path utils

Author: kamilogorek

packages/browser/package.json

@@ -40,7 +40,6 @@
     "rollup": "^0.58.2",
     "rollup-plugin-commonjs": "^9.1.3",
     "rollup-plugin-license": "^0.6.0",
-    "rollup-plugin-node-builtins": "^2.1.2",
     "rollup-plugin-node-resolve": "^3.3.0",
     "rollup-plugin-npm": "^2.0.0",
     "rollup-plugin-typescript2": "^0.13.0",

packages/browser/rollup.config.js

@@ -3,7 +3,6 @@ import uglify from 'rollup-plugin-uglify';
 import resolve from 'rollup-plugin-node-resolve';
 import typescript from 'rollup-plugin-typescript2';
 import license from 'rollup-plugin-license';
-import builtins from 'rollup-plugin-node-builtins';
 
 const commitHash = require('child_process')
   .execSync('git rev-parse --short HEAD', { encoding: 'utf-8' })
@@ -18,7 +17,6 @@ const bundleConfig = {
   },
   context: 'window',
   plugins: [
-    builtins(),
     typescript({
       tsconfig: 'tsconfig.build.json',
       tsconfigOverride: { compilerOptions: { declaration: false } },

packages/core/src/integrations/pluggable/rewriteframes.ts

@@ -1,6 +1,6 @@
 import { getCurrentHub, Scope } from '@sentry/hub';
 import { Integration, SentryEvent, StackFrame } from '@sentry/types';
-import { basename, relative } from 'path';
+import { basename, relative } from '@sentry/utils/path';
 
 type StackFrameIteratee = (frame: StackFrame) => Promise<StackFrame>;
 

packages/node/src/parsers.ts

@@ -1,7 +1,7 @@
 import { SentryEvent, SentryException, StackFrame } from '@sentry/types';
 import { readFileAsync } from '@sentry/utils/fs';
+import { basename, dirname } from '@sentry/utils/path';
 import { snipLine } from '@sentry/utils/string';
-import * as path from 'path';
 import * as stacktrace from 'stack-trace';
 
 const LINES_OF_CONTEXT: number = 7;
@@ -25,7 +25,7 @@ function getFunction(frame: stacktrace.StackFrame): string {
   }
 }
 
-const mainModule: string = `${(require.main && require.main.filename && path.dirname(require.main.filename)) ||
+const mainModule: string = `${(require.main && require.main.filename && dirname(require.main.filename)) ||
   global.process.cwd()}/`;
 
 /** JSDoc */
@@ -35,8 +35,8 @@ function getModule(filename: string, base?: string): string {
   }
 
   // It's specifically a module
-  const file = path.basename(filename, '.js');
-  filename = path.dirname(filename); // tslint:disable-line:no-parameter-reassignment
+  const file = basename(filename, '.js');
+  filename = dirname(filename); // tslint:disable-line:no-parameter-reassignment
   let n = filename.lastIndexOf('/node_modules/');
   if (n > -1) {
     // /node_modules/ is 14 chars

packages/utils/src/fs.ts

@@ -1,5 +1,5 @@
 import { mkdir, mkdirSync, readFile, statSync } from 'fs';
-import { dirname, resolve } from 'path';
+import { dirname, resolve } from './path';
 
 const _0777 = parseInt('0777', 8);
 

packages/utils/src/path.ts

@@ -0,0 +1,178 @@
+// Slightly modified (no IE8 support, ES6) and transcribed to TypeScript
+// https://raw.githubusercontent.com/calvinmetcalf/rollup-plugin-node-builtins/master/src/es6/path.js
+
+/** JSDoc */
+function normalizeArray(parts: string[], allowAboveRoot?: boolean): string[] {
+  // if the path tries to go above the root, `up` ends up > 0
+  let up = 0;
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const last = parts[i];
+    if (last === '.') {
+      parts.splice(i, 1);
+    } else if (last === '..') {
+      parts.splice(i, 1);
+      up++;
+    } else if (up) {
+      parts.splice(i, 1);
+      up--;
+    }
+  }
+
+  // if the path is allowed to go above the root, restore leading ..s
+  if (allowAboveRoot) {
+    for (; up--; up) {
+      parts.unshift('..');
+    }
+  }
+
+  return parts;
+}
+
+// Split a filename into [root, dir, basename, ext], unix version
+// 'root' is just a slash, or nothing.
+const splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+/** JSDoc */
+function splitPath(filename: string): string[] {
+  const parts = splitPathRe.exec(filename);
+  return parts ? parts.slice(1) : [];
+}
+
+// path.resolve([from ...], to)
+// posix version
+/** JSDoc */
+export function resolve(...args: string[]): string {
+  let resolvedPath = '';
+  let resolvedAbsolute = false;
+
+  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    const path = i >= 0 ? args[i] : '/';
+
+    // Skip empty entries
+    if (!path) {
+      continue;
+    }
+
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = path.charAt(0) === '/';
+  }
+
+  // At this point the path should be resolved to a full absolute path, but
+  // handle relative paths to be safe (might happen when process.cwd() fails)
+
+  // Normalize the path
+  resolvedPath = normalizeArray(resolvedPath.split('/').filter(p => !!p), !resolvedAbsolute).join('/');
+
+  return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';
+}
+
+/** JSDoc */
+function trim(arr: string[]): string[] {
+  let start = 0;
+  for (; start < arr.length; start++) {
+    if (arr[start] !== '') {
+      break;
+    }
+  }
+
+  let end = arr.length - 1;
+  for (; end >= 0; end--) {
+    if (arr[end] !== '') {
+      break;
+    }
+  }
+
+  if (start > end) {
+    return [];
+  }
+  return arr.slice(start, end - start + 1);
+}
+
+// path.relative(from, to)
+// posix version
+/** JSDoc */
+export function relative(from: string, to: string): string {
+  // tslint:disable:no-parameter-reassignment
+  from = resolve(from).substr(1);
+  to = resolve(to).substr(1);
+
+  const fromParts = trim(from.split('/'));
+  const toParts = trim(to.split('/'));
+
+  const length = Math.min(fromParts.length, toParts.length);
+  let samePartsLength = length;
+  for (let i = 0; i < length; i++) {
+    if (fromParts[i] !== toParts[i]) {
+      samePartsLength = i;
+      break;
+    }
+  }
+
+  let outputParts = [];
+  for (let i = samePartsLength; i < fromParts.length; i++) {
+    outputParts.push('..');
+  }
+
+  outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+  return outputParts.join('/');
+}
+
+// path.normalize(path)
+// posix version
+/** JSDoc */
+export function normalize(path: string): string {
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSlash = path.substr(-1) === '/';
+
+  // Normalize the path
+  let normalizedPath = normalizeArray(path.split('/').filter(p => !!p), !isPathAbsolute).join('/');
+
+  if (!normalizedPath && !isPathAbsolute) {
+    normalizedPath = '.';
+  }
+  if (normalizedPath && trailingSlash) {
+    normalizedPath += '/';
+  }
+
+  return (isPathAbsolute ? '/' : '') + normalizedPath;
+}
+
+// posix version
+/** JSDoc */
+export function isAbsolute(path: string): boolean {
+  return path.charAt(0) === '/';
+}
+
+// posix version
+/** JSDoc */
+export function join(...args: string[]): string {
+  return normalize(args.join('/'));
+}
+
+/** JSDoc */
+export function dirname(path: string): string {
+  const result = splitPath(path);
+  const root = result[0];
+  let dir = result[1];
+
+  if (!root && !dir) {
+    // No dirname whatsoever
+    return '.';
+  }
+
+  if (dir) {
+    // It has a dirname, strip trailing slash
+    dir = dir.substr(0, dir.length - 1);
+  }
+
+  return root + dir;
+}
+
+/** JSDoc */
+export function basename(path: string, ext?: string): string {
+  let f = splitPath(path)[2];
+  if (ext && f.substr(ext.length * -1) === ext) {
+    f = f.substr(0, f.length - ext.length);
+  }
+  return f;
+}

packages/utils/src/store.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join } from 'path';
 import { mkdirpSync } from './fs';
+import { dirname, join } from './path';
 
 /**
  * Lazily serializes data to a JSON file to persist. When created, it loads data

packages/utils/test/store.test.ts

@@ -1,15 +1,15 @@
 import { expect } from 'chai';
 import * as fs from 'fs';
 import * as os from 'os';
-import * as path from 'path';
+import { join } from '../path';
 
 import { Store } from '../src/store';
 
 jest.useFakeTimers();
 
-const folder = path.join(os.tmpdir(), 'test');
+const folder = join(os.tmpdir(), 'test');
 const filename = 'data';
-const finalFilename = path.join(folder, `${filename}.json`);
+const finalFilename = join(folder, `${filename}.json`);
 const inital = ['a', 'b'];
 let store: Store<string[]>;
 
@@ -58,11 +58,11 @@ describe('Store', () => {
   });
 
   it('should create all intermediate folders', async () => {
-    const newPath = path.join(folder, 'test');
+    const newPath = join(folder, 'test');
     store = new Store<string[]>(newPath, filename, inital);
     store.update(current => current.map(value => `${value}1`));
     jest.runAllTimers();
-    const realFilename = path.join(newPath, `${filename}.json`);
+    const realFilename = join(newPath, `${filename}.json`);
     expect(fs.existsSync(folder)).to.be.true;
     expect(fs.existsSync(newPath)).to.be.true;
     expect(fs.existsSync(realFilename)).to.be.true;