143 package namespace (#145)

* Starting some work for #143

* Starting shell for gradle version

* Get gradle source and gradle plugin version

* Gradle version compare

* Set and get namespace ops

* Tests

Author: mlynch

packages/common/test/fixtures/ios-and-android/android/app/build.gradle

@@ -1,6 +1,7 @@
 apply plugin: 'com.android.application'
 
 android {
+    namespace "io.ionic.starter"
     compileSdkVersion rootProject.ext.compileSdkVersion
     defaultConfig {
         applicationId "io.ionic.starter"

packages/configure/test/ops/android.gradle.test.ts

@@ -18,7 +18,7 @@ const makeOp = (name: string, value: any): Operation => ({
   displayText: expect.anything(),
 });
 
-describe('op: android.gralde', () => {
+describe('op: android.gradle', () => {
   let dir: string;
   let ctx: Context;
 
@@ -55,6 +55,7 @@ describe('op: android.gralde', () => {
 apply plugin: 'com.android.application'
 
 android {
+    namespace "io.ionic.starter"
     compileSdkVersion rootProject.ext.compileSdkVersion
     defaultConfig {
         applicationId "io.ionic.starter"

packages/project/src/android/gradle-file.ts

@@ -104,7 +104,7 @@ export class GradleFile extends VFSStorable {
    */
   // This is a beast, sorry. Hey, at least there's tests
   // In the future, this could be moved to the Java `gradle-parse` package provided in this monorepo
-  // along with modifying the AST to inject our script but this works fine forn ow
+  // along with modifying the AST to inject our script but this works fine for now
   private async replaceInGradleFile(
     toInject: any,
     targetNode: { node: GradleASTNode; depth: number },
@@ -441,6 +441,27 @@ export class GradleFile extends VFSStorable {
     }
   }
 
+  getSource(node: GradleASTNode) {
+    if (!this.parsed || !this.source) {
+      throw new Error('Call parse() first to load Gradle file');
+    }
+
+    const lines = this.source.split(/\r?\n/);
+
+    const sourceLines = lines.slice(node.source.line - 1, node.source.lastLine);
+
+    const firstLine = sourceLines[0].slice(Math.max(0, node.source.column - 1));
+    const lastLine = sourceLines[sourceLines.length - 1].slice(0, node.source.lastColumn);
+
+    if (sourceLines.length > 2) {
+      return [firstLine, ...sourceLines.slice(1, sourceLines.length - 1), lastLine].join('\n');
+    } else if (sourceLines.length == 2) {
+      return [firstLine, lastLine].join('\n');
+    } else {
+      return firstLine;
+    }
+  }
+
   private getDepth(pathObject: any) {
     let depth = 0;
     let n = pathObject;
@@ -642,6 +663,38 @@ export class GradleFile extends VFSStorable {
     return null;
   }
 
+  async getNamespace(): Promise<string | null> {
+    const source = await this.getGradleSource();
+
+    if (source) {
+      const namespace = source.match(/namespace\s+["']([^"']+)["']/);
+
+      if (!namespace) {
+        return null;
+      }
+
+      return namespace[1];
+    }
+    return null;
+  }
+
+  async setNamespace(namespace: string) {
+    const source = await this.getGradleSource();
+
+    if (source) {
+      Logger.v('gradle', 'setNamespace', `to ${namespace} in ${this.filename}`);
+
+      return this.replaceProperties({
+        android: {
+          namespace: {}
+        }
+      }, {
+        namespace: `"${namespace}"`
+      });
+    }
+  }
+
+
   /*
   Generate a fragment of Gradle/Groovy code given the inject object
 

packages/project/src/android/project.ts

@@ -20,6 +20,7 @@ import { PropertiesFile } from '../properties';
 import { PlatformProject } from '../platform-project';
 import { readSource } from '../read-src';
 import { Logger } from '../logger';
+import { compare } from '../util/gradle-versions';
 
 export class AndroidProject extends PlatformProject {
   private manifest: XmlFile;
@@ -168,6 +169,7 @@ export class AndroidProject extends PlatformProject {
 
     this.manifest.getDocumentElement()?.setAttribute('package', packageName);
     await this.appBuildGradle?.setApplicationId(packageName);
+    await this.appBuildGradle?.setNamespace(packageName);
     Logger.v('android', 'setPackageName', `set manifest package attribute and applicationId to ${packageName}`);
     this.manifest.setAttrs('manifest/application/activity', {
       'android:name': `${packageName}.MainActivity`,
@@ -240,7 +242,31 @@ export class AndroidProject extends PlatformProject {
     return `${parts[parts.length - 1]}.java`;
   }
 
-  getPackageName() {
+  async getGradlePluginVersion() {
+    await this.buildGradle?.parse();
+
+    const found = this.buildGradle?.find({
+      buildscript: {
+        dependencies: {
+          classpath: {}
+        }
+      }
+    });
+
+    const sources = (found ?? []).map(f => this.buildGradle?.getSource(f.node) ?? '');
+
+    const gradleLine = sources.find(s => s.indexOf('com.android.tools.build:gradle:'));
+
+    return gradleLine?.match(/:([\d.]+)/)?.[1] ?? null;
+  }
+
+  async getPackageName() {
+    const namespace = await this.appBuildGradle?.getNamespace();
+
+    if (namespace) {
+      return namespace;
+    }
+
     return this.manifest.getDocumentElement()?.getAttribute('package');
   }
 

packages/project/src/util/gradle-versions.ts

@@ -0,0 +1,44 @@
+export function compare(version1: string, version2: string) {
+  // Split the version strings into arrays of individual version components
+  const version1Components = version1.split('.');
+  const version2Components = version2.split('.');
+
+  // Iterate through each component of the version strings
+  for (let i = 0; i < version1Components.length || i < version2Components.length; i++) {
+    // Convert the current component to a number (or NaN if it can't be converted)
+    const version1Component = Number(version1Components[i]);
+    const version2Component = Number(version2Components[i]);
+
+    // If one of the components is NaN (not a number), we need to handle it differently
+    if (isNaN(version1Component) || isNaN(version2Component)) {
+      // Compare the non-numeric components as strings
+      const stringCompareResult = compareStringComponents(version1Components[i], version2Components[i]);
+      if (stringCompareResult !== 0) {
+        return stringCompareResult;
+      }
+    } else {
+      // Compare the numeric components
+      if (version1Component > version2Component) {
+        return 1;
+      } else if (version1Component < version2Component) {
+        return -1;
+      }
+    }
+  }
+
+  // If we've made it this far, the versions are either equal or one is a prefix of the other
+  // In either case, we consider them equal
+  return 0;
+}
+
+function compareStringComponents(str1: string, str2: string) {
+  if (str1 === str2) {
+    return 0;
+  } else if (str1 === undefined) {
+    return -1;
+  } else if (str2 === undefined) {
+    return 1;
+  } else {
+    return str1.localeCompare(str2);
+  }
+}

packages/project/test/gradle-file.android.test.ts

@@ -61,6 +61,45 @@ describe('project - android - gradle', () => {
     expect(nodes.length).not.toBe(0);
   });
 
+  it('Should get source code for found node', async () => {
+    const gradle = new GradleFile(
+      join(project.config.android!.path!, 'build.gradle'),
+      vfs,
+    );
+    await gradle.parse();
+
+    let nodes = gradle.find({
+      buildscript: {
+        dependencies: {
+          classpath: {}
+        },
+      },
+    });
+
+    let source = gradle.getSource(nodes[0].node);
+
+    expect(source).toBe("classpath 'com.android.tools.build:gradle:4.2.1'");
+
+    nodes = gradle.find({
+      buildscript: {
+        dependencies: {
+        },
+      },
+    });
+
+    source = gradle.getSource(nodes[0].node);
+
+    expect(source).toBe(`
+    dependencies {
+        classpath 'com.android.tools.build:gradle:4.2.1'
+        classpath 'com.google.gms:google-services:4.3.5'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+`.trim());
+  });
+
   it('Should find exact element in parsed Gradle', async () => {
     const gradle = new GradleFile(join(project.config.android!.path!, 'build.gradle'), vfs);
     await gradle.parse();
@@ -548,4 +587,19 @@ intunemam {
     cordovaAndroidVersion = '7.0.0'
 }`);
   });
+
+  it('Should get and set namespace', async () => {
+    const gradle = new GradleFile(
+      join(project.config.android!.path!, 'app', 'build.gradle'),
+      vfs,
+    );
+
+    let namespace = await gradle.getNamespace();
+    expect(namespace).toBe('io.ionic.starter');
+
+    await gradle.setNamespace('io.ionic.test');
+
+    namespace = await gradle.getNamespace();
+    expect(namespace).toBe('io.ionic.test');
+  });
 });

packages/project/test/project.android.test.ts

@@ -43,10 +43,19 @@ describe('project - android', () => {
     expect(project.android?.getMainActivityFilename()).toBe('MainActivity.java');
   });
 
+  it('should get gradle plugin version', async () => {
+    expect(await project.android?.getGradlePluginVersion()).toBe('4.2.1');
+  });
+
+  it('should get package name', async () => {
+    expect(await project.android?.getPackageName()).toBe('io.ionic.starter');
+  });
+
   it('should set package name', async () => {
     await project.android?.setPackageName('com.ionicframework.awesome');
-    expect(project.android?.getPackageName()).toBe('com.ionicframework.awesome');
+    expect(await project.android?.getPackageName()).toBe('com.ionicframework.awesome');
     expect(await project.android?.getAppBuildGradle()?.getApplicationId()).toBe('com.ionicframework.awesome');
+    expect(await project.android?.getAppBuildGradle()?.getNamespace()).toBe('com.ionicframework.awesome');
     const newSource = await readFile(join(project.config.android?.path!, 'app/src/main/java/com/ionicframework/awesome/MainActivity.java'), { encoding: 'utf-8' });
     expect(newSource.indexOf('package com.ionicframework.awesome;')).toBe(0);
     expect(!(await pathExists(join(project.config.android?.path!, 'app/src/main/java/io')))).toBe(true);
@@ -55,14 +64,14 @@ describe('project - android', () => {
   });
 
   it('should not error setting same package name', async () => {
-    const packageName = project.android?.getPackageName();
+    const packageName = await project.android?.getPackageName();
     await project.android?.setPackageName(packageName!);
-    expect(project.android?.getPackageName()).toBe(packageName);
+    expect(await project.android?.getPackageName()).toBe(packageName);
   });
 
   it('should set package name longer than current package', async () => {
     await project.android?.setPackageName('com.ionicframework.awesome.long');
-    expect(project.android?.getPackageName()).toBe('com.ionicframework.awesome.long');
+    expect(await project.android?.getPackageName()).toBe('com.ionicframework.awesome.long');
     expect(await project.android?.getAppBuildGradle()?.getApplicationId()).toBe('com.ionicframework.awesome.long');
     const newSource = await readFile(join(project.config.android?.path!, 'app/src/main/java/com/ionicframework/awesome/long/MainActivity.java'), { encoding: 'utf-8' });
     expect(newSource.indexOf('package com.ionicframework.awesome.long;')).toBe(0);
@@ -73,7 +82,7 @@ describe('project - android', () => {
 
   it('should set package name shorter than current package', async () => {
     await project.android?.setPackageName('com.super');
-    expect(project.android?.getPackageName()).toBe('com.super');
+    expect(await project.android?.getPackageName()).toBe('com.super');
     expect(await project.android?.getAppBuildGradle()?.getApplicationId()).toBe('com.super');
     const newSource = await readFile(join(project.config.android?.path!, 'app/src/main/java/com/super/MainActivity.java'), { encoding: 'utf-8' });
     expect(newSource.indexOf('package com.super;')).toBe(0);
@@ -226,6 +235,7 @@ describe('project - android', () => {
     expect(appBuildGradleSource!.getData()?.getDocument()).toBe(`apply plugin: 'com.android.application'
 
 android {
+    namespace "io.ionic.starter"
     compileSdkVersion rootProject.ext.compileSdkVersion
     defaultConfig {
         applicationId "io.ionic.starter"

packages/project/test/util/gradle-versions.test.ts

@@ -0,0 +1,11 @@
+import { compare } from '../../src/util/gradle-versions';
+
+describe('Gradle versions', () => {
+  it('should compare two gradle versions', () => {
+    expect(compare('1.5.2', '1.6.2')).toBe(-1);
+    expect(compare('1.8.2', '1.6.2')).toBe(1);
+    expect(compare('[1.0,)', '[1.2,)')).toBe(-1);
+    expect(compare('1.8.2-beta1-SNAPSHOT', '1.8.2')).toBe(1);
+    expect(compare('1.8.2-beta1', '1.8.2-beta1')).toBe(0);
+  });
+});