Merge pull request #32 from AlexandrouR/kotlinProject

Builder patter refactoring.

Author: AlexandrouR

.gitignore

@@ -25,7 +25,7 @@ gradle-app.setting
 # Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
 !gradle-wrapper.jar
 
-# Cache of project
+# Cache of javaProject
 .gradletasknamecache
 
 # Work around https://youtrack.jetbrains.com/issue/IDEA-116898

src/main/java/org/web3j/console/Runner.java

@@ -69,10 +69,10 @@ public static void main(String[] args) throws Exception {
                     TruffleJsonFunctionWrapperGenerator.run(tail(args));
                     break;
                 case COMMAND_NEW:
-                    ProjectCreator.main(args);
+                    ProjectCreator.main(tail(args));
                     break;
                 case COMMAND_IMPORT:
-                    ProjectImporter.main(args);
+                    ProjectImporter.main(tail(args));
                     break;
                 case "version":
                     Console.exitSuccess(
@@ -86,7 +86,7 @@ public static void main(String[] args) throws Exception {
                     ContractAuditor.main(tail(args));
                     break;
                 case COMMAND_GENERATE_TESTS:
-                    UnitTestCreator.main(args);
+                    UnitTestCreator.main(tail(args));
                     break;
                 default:
                     Console.exitError(USAGE);

src/main/java/org/web3j/console/project/AbstractProject.java

@@ -0,0 +1,165 @@
+/*
+ * Copyright 2020 Web3 Labs Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package org.web3j.console.project;
+
+import java.io.File;
+import java.io.IOException;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+
+import org.web3j.codegen.Console;
+import org.web3j.console.project.templates.TemplateProvider;
+import org.web3j.console.project.utils.ProgressCounter;
+import org.web3j.console.project.utils.ProjectUtils;
+import org.web3j.crypto.CipherException;
+
+public abstract class AbstractProject<T extends AbstractProject<T>> {
+    private T project;
+
+    protected final boolean withTests;
+    protected final boolean withFatJar;
+    protected final boolean withWallet;
+    protected final boolean withSampleCode;
+    protected final String command;
+    protected final String solidityImportPath;
+    protected final ProjectStructure projectStructure;
+    protected ProjectWallet projectWallet;
+    protected ProgressCounter progressCounter = new ProgressCounter(true);
+
+    protected abstract T getProjectInstance();
+
+    protected AbstractProject(
+            boolean withTests,
+            boolean withFatJar,
+            boolean withWallet,
+            boolean withSampleCode,
+            String command,
+            String solidityImportPath,
+            ProjectStructure projectStructure) {
+        this.withTests = withTests;
+        this.withFatJar = withFatJar;
+        this.withWallet = withWallet;
+        this.withSampleCode = withSampleCode;
+        this.command = command;
+        this.solidityImportPath = solidityImportPath;
+        this.projectStructure = projectStructure;
+        this.project = getProjectInstance();
+    }
+
+    public ProjectStructure getProjectStructure() {
+        return project.projectStructure;
+    }
+
+    public ProjectWallet getProjectWallet() {
+        return project.projectWallet;
+    }
+
+    protected void buildGradleProject(final String pathToDirectory)
+            throws IOException, InterruptedException {
+        if (!isWindows()) {
+            setExecutable(pathToDirectory, "gradlew");
+            executeBuild(
+                    new File(pathToDirectory), new String[] {"bash", "-c", "./gradlew build -q"});
+        } else {
+            setExecutable(pathToDirectory, "gradlew.bat");
+            executeBuild(
+                    new File(pathToDirectory),
+                    new String[] {"cmd.exe", "/c", "gradlew.bat build -q"});
+        }
+    }
+
+    private boolean isWindows() {
+        return System.getProperty("os.name").toLowerCase().startsWith("windows");
+    }
+
+    private void setExecutable(final String pathToDirectory, final String gradlew) {
+        final File f = new File(pathToDirectory + File.separator + gradlew);
+        final boolean isExecutable = f.setExecutable(true);
+    }
+
+    private void executeBuild(final File workingDir, final String[] command)
+            throws InterruptedException, IOException {
+        executeProcess(workingDir, command);
+    }
+
+    private void executeProcess(File workingDir, String[] command)
+            throws InterruptedException, IOException {
+        int exitCode =
+                new ProcessBuilder(command)
+                        .directory(workingDir)
+                        .redirectErrorStream(true)
+                        .redirectOutput(File.createTempFile("w3j", "cli"))
+                        .start()
+                        .waitFor();
+        if (exitCode != 0) {
+            Console.exitError("Could not build project.");
+        }
+    }
+
+    protected void createFatJar(String pathToDirectory) throws IOException, InterruptedException {
+        if (!isWindows()) {
+            executeProcess(
+                    new File(pathToDirectory),
+                    new String[] {"bash", "./gradlew", "shadowJar", "-q"});
+        } else {
+            executeProcess(
+                    new File(pathToDirectory),
+                    new String[] {"cmd.exe", "/c", "./gradlew.bat shadowJar", "-q"});
+        }
+    }
+
+    protected void generateWallet()
+            throws CipherException, InvalidAlgorithmParameterException, NoSuchAlgorithmException,
+                    NoSuchProviderException, IOException {
+        projectStructure.createWalletDirectory();
+        projectWallet =
+                new ProjectWallet(
+                        ProjectUtils.generateWalletPassword(), projectStructure.getWalletPath());
+        ProjectWriter.writeResourceFile(
+                projectWallet.getWalletPassword(),
+                projectWallet.getPasswordFileName(),
+                projectStructure.getWalletPath());
+    }
+
+    protected void generateTopLevelDirectories(ProjectStructure projectStructure) {
+        projectStructure.createMainDirectory();
+        projectStructure.createTestDirectory();
+        projectStructure.createSolidityDirectory();
+        projectStructure.createWrapperDirectory();
+    }
+
+    public void createProject()
+            throws IOException, InterruptedException, NoSuchAlgorithmException,
+                    NoSuchProviderException, InvalidAlgorithmParameterException, CipherException {
+        generateTopLevelDirectories(projectStructure);
+        if (withWallet) {
+            generateWallet();
+        }
+        getTemplateProvider().generateFiles(projectStructure);
+        progressCounter.processing("Creating " + projectStructure.projectName);
+        buildGradleProject(projectStructure.getProjectRoot());
+
+        if (withTests) {
+            generateTests(projectStructure);
+        }
+        if (withFatJar) {
+            createFatJar(projectStructure.getProjectRoot());
+        }
+        progressCounter.setLoading(false);
+    }
+
+    protected abstract TemplateProvider getTemplateProvider();
+
+    protected abstract void generateTests(ProjectStructure projectStructure) throws IOException;
+}

src/main/java/org/web3j/console/project/AbstractProjectBuilder.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2020 Web3 Labs Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package org.web3j.console.project;
+
+public abstract class AbstractProjectBuilder<T extends AbstractProjectBuilder<T>> {
+    private T builder;
+
+    protected String solidityImportPath;
+    protected boolean withWallet;
+    protected boolean withTests;
+    protected String projectName;
+    protected String packageName;
+    protected String rootDirectory;
+    protected boolean withSampleCode;
+    protected boolean withFatJar;
+
+    protected abstract T getBuilderInstance();
+
+    protected AbstractProjectBuilder() {
+        this.builder = getBuilderInstance();
+    }
+
+    public T withSolidityFile(final String solidityImportPath) {
+        builder.solidityImportPath = solidityImportPath;
+        return builder;
+    }
+
+    public T withWalletProvider(boolean withWalletProvider) {
+        builder.withWallet = withWalletProvider;
+        return this.builder;
+    }
+
+    public T withSampleCode(boolean withSampleCode) {
+        builder.withSampleCode = withSampleCode;
+        return this.builder;
+    }
+
+    public T withTests(boolean withTests) {
+        builder.withTests = withTests;
+        return this.builder;
+    }
+
+    public T withFatJar(boolean withFatJar) {
+        builder.withFatJar = withFatJar;
+        return this.builder;
+    }
+
+    public T withProjectName(String projectName) {
+        builder.projectName = projectName;
+        return this.builder;
+    }
+
+    public T withPackageName(String packageName) {
+        builder.packageName = packageName;
+        return this.builder;
+    }
+
+    public T withRootDirectory(String rootDirectory) {
+        builder.rootDirectory = rootDirectory;
+        return this.builder;
+    }
+}

src/main/java/org/web3j/console/project/InteractiveOptions.java

@@ -23,10 +23,10 @@
 import static org.web3j.codegen.Console.exitError;
 import static org.web3j.console.project.utils.ProjectUtils.deleteFolder;
 
-class InteractiveOptions {
+public class InteractiveOptions {
     static Scanner scanner = new Scanner(System.in);
 
-    static String getProjectName() {
+    public static String getProjectName() {
         print("Please enter the project name [Web3App]:");
         String projectName = getUserInput();
         if (projectName.trim().isEmpty()) {
@@ -38,7 +38,7 @@ static String getProjectName() {
         return projectName;
     }
 
-    static String getPackageName() {
+    public static String getPackageName() {
         print("Please enter the package name for your project [io.web3j]:");
         String packageName = getUserInput();
         if (packageName.trim().isEmpty()) {
@@ -50,7 +50,7 @@ static String getPackageName() {
         return packageName;
     }
 
-    static Optional<String> getProjectDestination(final String projectName) {
+    public static Optional<String> getProjectDestination(final String projectName) {
         print(
                 "Please enter the destination of your project ["
                         + System.getProperty("user.dir")
@@ -69,7 +69,7 @@ static Optional<String> getProjectDestination(final String projectName) {
         return projectDest.isEmpty() ? Optional.empty() : Optional.of(projectDest);
     }
 
-    static Optional<String> getGeneratedWrapperLocation() {
+    public static Optional<String> getGeneratedWrapperLocation() {
         print(
                 "Please enter the path of the generated contract wrappers ["
                         + String.join(
@@ -97,7 +97,7 @@ static Optional<String> getGeneratedWrapperLocation() {
                 : Optional.of(pathToTheWrappers);
     }
 
-    public static Optional<String> setGeneratedTestLocation() {
+    public static Optional<String> setGeneratedTestLocationJava() {
         print(
                 "Where would you like to save your tests ["
                         + String.join(
@@ -111,13 +111,27 @@ public static Optional<String> setGeneratedTestLocation() {
                 : Optional.of(outputPath);
     }
 
+    public static Optional<String> setGeneratedTestLocationKotlin() {
+        print(
+                "Where would you like to save your tests ["
+                        + String.join(
+                                separator, System.getProperty("user.dir"), "src", "test", "kotlin")
+                        + "]");
+        String outputPath = getUserInput();
+        return outputPath.isEmpty()
+                ? Optional.of(
+                        String.join(
+                                separator, System.getProperty("user.dir"), "src", "test", "kotlin"))
+                : Optional.of(outputPath);
+    }
+
     public static boolean userWantsTests() {
         print("Would you like to generate unit test for your solidity contracts [Y/n] ? ");
         String userAnswer = getUserInput();
         return userAnswer.trim().toLowerCase().equals("y") || userAnswer.trim().equals("");
     }
 
-    static String getSolidityProjectPath() {
+    public static String getSolidityProjectPath() {
         System.out.println("Please enter the path to your solidity file/folder [Required Field]: ");
         return getUserInput();
     }