support preliminary breakpoints (android only, no source maps)

Author: blagoev

adapter/pathTransformer.ts

@@ -4,6 +4,7 @@
 
 import * as utils from '../webkit/utilities';
 import {DebugProtocol} from 'vscode-debugprotocol';
+import * as path from 'path';
 import {ISetBreakpointsArgs, IDebugTransformer, ILaunchRequestArgs, IAttachRequestArgs, IStackTraceResponseBody} from '../webkit/WebKitAdapterInterfaces';
 
 interface IPendingBreakpoint {
@@ -21,6 +22,7 @@ export class PathTransformer implements IDebugTransformer {
     private _clientPathToWebkitUrl = new Map<string, string>();
     private _webkitUrlToClientPath = new Map<string, string>();
     private _pendingBreakpointsByPath = new Map<string, IPendingBreakpoint>();
+    private inferedDeviceRoot :string = null;
 
     public launch(args: ILaunchRequestArgs): void {
         this._webRoot = utils.getAppRoot(args);
@@ -51,7 +53,38 @@ export class PathTransformer implements IDebugTransformer {
                 args.source.path = this._clientPathToWebkitUrl.get(url);
                 utils.Logger.log(`Paths.setBP: Resolved ${url} to ${args.source.path}`);
                 resolve();
-            } else {
+            }
+            else if (this.inferedDeviceRoot) {
+                utils.Logger.log(`Paths.setBP: No target url cached for client path: ${url}. Using inffered device root to set breakpoint`);
+
+                let inferedUrl = url.replace(this._webRoot, this.inferedDeviceRoot).replace(/\\/g, "/");
+
+                //change device path if {N} core module or {N} module
+                if (inferedUrl.indexOf("/node_modules/tns-core-modules/") != -1)
+                {
+                    inferedUrl = inferedUrl.replace("/node_modules/tns-core-modules/", "/app/tns_modules/");
+                }
+                else if (inferedUrl.indexOf("/node_modules/") != -1)
+                {
+                    inferedUrl = inferedUrl.replace("/node_modules/", "/app/tns_modules/");
+                }
+
+                //change platform specific paths
+                if (inferedUrl.indexOf(".android.") != -1)
+                {
+                    inferedUrl = inferedUrl.replace(".android.", ".");
+                }
+                else if (inferedUrl.indexOf(".ios.") != -1)
+                {
+                    inferedUrl = inferedUrl.replace(".ios.", ".");
+                }
+
+                args.source.path = inferedUrl;
+                this._pendingBreakpointsByPath.set(args.source.path, { resolve, reject, args });
+                 utils.Logger.log("resolving infered promise on path  " + url);
+                resolve();
+            }
+            else {
                 utils.Logger.log(`Paths.setBP: No target url cached for client path: ${url}, waiting for target script to be loaded.`);
                 args.source.path = url;
                 this._pendingBreakpointsByPath.set(args.source.path, { resolve, reject, args });
@@ -70,6 +103,17 @@ export class PathTransformer implements IDebugTransformer {
 
     public scriptParsed(event: DebugProtocol.Event): void {
         const webkitUrl: string = event.body.scriptUrl;
+        if (!this.inferedDeviceRoot)
+        {
+            this.inferedDeviceRoot = utils.inferDeviceRoot(this._webRoot, this._platform, webkitUrl);
+             utils.Logger.log("\n\n\n ***Inferred device root: " + this.inferedDeviceRoot + "\n\n\n");
+
+            if (this.inferedDeviceRoot.indexOf("/data/user/0/") != -1)
+            {
+                this.inferedDeviceRoot = this.inferedDeviceRoot.replace("/data/user/0/", "/data/data/");
+            }
+        }
+
         const clientPath = utils.webkitUrlToClientPath(this._webRoot, this._platform, webkitUrl);
 
         if (!clientPath) {

webkit/utilities.ts

@@ -240,13 +240,13 @@ export function webkitUrlToClientPath(webRoot: string, additionalFileExtension:
         return '';
     }
 
-    aUrl = decodeURI(aUrl);
-
-    // If we don't have the client workingDirectory for some reason, don't try to map the url to a client path
+     // If we don't have the client workingDirectory for some reason, don't try to map the url to a client path
     if (!webRoot) {
         return '';
     }
 
+    aUrl = decodeURI(aUrl);
+
     // Search the filesystem under the webRoot for the file that best matches the given url
     let pathName = url.parse(canonicalizeUrl(aUrl)).pathname;
     if (!pathName || pathName === '/') {
@@ -261,14 +261,16 @@ export function webkitUrlToClientPath(webRoot: string, additionalFileExtension:
         return nsProjectFile;
     }
 
+    let shiftedParts = [];
     let pathParts = pathName.split(path.sep);
     while (pathParts.length > 0) {
         const clientPath = path.join(webRoot, pathParts.join(path.sep));
         if (existsSync(clientPath)) {
             return canonicalizeUrl(clientPath);
         }
 
-        pathParts.shift();
+       let shifted = pathParts.shift();
+       shiftedParts.push(shifted);
     }
 
     //check for {N} android internal files
@@ -285,6 +287,64 @@ export function webkitUrlToClientPath(webRoot: string, additionalFileExtension:
     return '';
 }
 
+/**
+ * Infers the device root of a given path.
+ * The device root is the parent directory of all {N} source files
+ * This implementation assumes that all files are all under one common root on the device
+ * Returns all the device parent directories of a source file until the file is found on the client by client path
+ */
+export function inferDeviceRoot(projectRoot: string, additionalFileExtension: string, aUrl: string): string {
+    if (!aUrl) {
+        return null;
+    }
+
+    // If we don't have the projectRoot for some reason, don't try to map the url to a client path
+    if (!projectRoot) {
+        return null;
+    }
+
+    aUrl = decodeURI(aUrl);
+
+    // Search the filesystem under the webRoot for the file that best matches the given url
+    let pathName = url.parse(canonicalizeUrl(aUrl)).pathname;
+    if (!pathName || pathName === '/') {
+        return null;
+    }
+
+    // Dealing with the path portion of either a url or an absolute path to remote file.
+    // Need to force path.sep separator
+    pathName = pathName.replace(/\//g, path.sep);
+
+    let shiftedParts = [];
+    let pathParts = pathName.split(path.sep);
+    while (pathParts.length > 0) {
+        const clientPath = path.join(projectRoot, pathParts.join(path.sep));
+        if (existsSync(clientPath)) {
+            //return canonicalizeUrl(clientPath);
+            return shiftedParts.join(path.sep).replace(/\\/g, "/");
+        }
+
+       let shifted = pathParts.shift();
+       shiftedParts.push(shifted);
+    }
+
+    //check for {N} android internal files
+    shiftedParts = [];
+    pathParts = pathName.split(path.sep);
+    while (pathParts.length > 0) {
+        const clientPath = path.join(projectRoot, "platforms/android/src/main/assets", pathParts.join(path.sep));
+        if (existsSync(clientPath)) {
+            //return canonicalizeUrl(clientPath);
+            return shiftedParts.join(path.sep).replace(/\\/g, "/");
+        }
+
+        let shifted = pathParts.shift();
+        shiftedParts.push(shifted);
+    }
+
+    return null;
+}
+
 /**
  * Modify a url either from the client or the webkit target to a common format for comparing.
  * The client can handle urls in this format too.