Merge pull request #113 from nomiclabs/config-export-and-refactor

Config export and refactor

.gitignore

@@ -74,4 +74,10 @@ dist/
 
 # Code coverage artifacts
 coverage
-.nyc_output
+.nyc_output
+
+# Generated config-export files
+config.d.ts
+config.d.ts.map
+config.js
+config.js.map

config.ts

@@ -0,0 +1,2 @@
+export * from "./dist/src/core/config/config-env";
+export { BuidlerConfig } from "./dist/src/types";

package.json

@@ -27,8 +27,8 @@
     "fix": "prettier --write 'src/**/*.{js,ts}' 'test/**/*.{js,ts}' && tslint --fix --config tslint.json --project tsconfig.json",
     "lint": "tslint --config tslint.json --project tsconfig.json",
     "test": "nyc mocha",
-    "build": "tsc",
-    "watch": "tsc -w"
+    "build": "tsc && tsc --sourceMap --declarationMap --declaration config.ts",
+    "watch": "npm run build && tsc -w"
   },
   "devDependencies": {
     "@types/chai": "^4.1.7",

src/builtin-tasks/clean.ts

@@ -1,6 +1,6 @@
-import tasks from "../core/importable-tasks-dsl";
+import { task } from "../core/config/config-env";
 
-tasks.task(
+task(
   "clean",
   "Clears the cache and deletes all artifacts",
   async (_, { config }) => {

src/builtin-tasks/compile.ts

@@ -1,7 +1,7 @@
 import path from "path";
 
+import { internalTask, task } from "../core/config/config-env";
 import { BuidlerError, ERRORS } from "../core/errors";
-import tasks from "../core/importable-tasks-dsl";
 import { Compiler } from "../solidity/compiler";
 import { DependencyGraph } from "../solidity/dependencyGraph";
 import { Resolver } from "../solidity/resolver";
@@ -22,34 +22,31 @@ function getCompiler(config: BuidlerConfig) {
   );
 }
 
-tasks.internalTask("builtin:get-file-paths", async (_, { config }) => {
+internalTask("builtin:get-file-paths", async (_, { config }) => {
   return glob(path.join(config.paths.sources, "**/*.sol"));
 });
 
-tasks.internalTask("builtin:get-resolved-files", async (_, { config, run }) => {
+internalTask("builtin:get-resolved-files", async (_, { config, run }) => {
   const resolver = new Resolver(config.paths.root);
   const paths = await run("builtin:get-file-paths");
   return Promise.all(
     paths.map((p: string) => resolver.resolveProjectSourceFile(p))
   );
 });
 
-tasks.internalTask(
-  "builtin:get-dependency-graph",
-  async (_, { config, run }) => {
-    const resolver = new Resolver(config.paths.root);
-    const localFiles = await run("builtin:get-resolved-files");
-    return DependencyGraph.createFromResolvedFiles(resolver, localFiles);
-  }
-);
+internalTask("builtin:get-dependency-graph", async (_, { config, run }) => {
+  const resolver = new Resolver(config.paths.root);
+  const localFiles = await run("builtin:get-resolved-files");
+  return DependencyGraph.createFromResolvedFiles(resolver, localFiles);
+});
 
-tasks.internalTask("builtin:get-compiler-input", async (_, { config, run }) => {
+internalTask("builtin:get-compiler-input", async (_, { config, run }) => {
   const compiler = getCompiler(config);
   const dependencyGraph = await run("builtin:get-dependency-graph");
   return compiler.getInputFromDependencyGraph(dependencyGraph);
 });
 
-tasks.internalTask("builtin:compile", async (_, { config, run }) => {
+internalTask("builtin:compile", async (_, { config, run }) => {
   const compiler = getCompiler(config);
   const input = await run("builtin:get-compiler-input");
 
@@ -80,7 +77,7 @@ tasks.internalTask("builtin:compile", async (_, { config, run }) => {
   return output;
 });
 
-tasks.internalTask("builtin:build-artifacts", async (_, { config, run }) => {
+internalTask("builtin:build-artifacts", async (_, { config, run }) => {
   if (
     await areArtifactsCached(
       config.paths.sources,
@@ -137,7 +134,7 @@ tasks.internalTask("builtin:build-artifacts", async (_, { config, run }) => {
   }
 });
 
-tasks.task(
+task(
   "compile",
   "Compiles the whole project, building all artifacts",
   async (__, { run }) => run("builtin:build-artifacts")

src/builtin-tasks/console.ts

@@ -1,7 +1,6 @@
-import tasks from "../core/importable-tasks-dsl";
+import { task } from "../core/config/config-env";
 
-tasks
-  .task("console", "Opens a buidler console")
+task("console", "Opens a buidler console")
   .addFlag("noCompile", "Don't compile before running this task")
   .setAction(async ({ noCompile }: { noCompile: boolean }, { config, run }) => {
     const path = await import("path");

src/builtin-tasks/flatten.ts

@@ -1,7 +1,7 @@
 import { BuidlerError, ERRORS } from "../core/errors";
 import { getPackageJson } from "../util/packageInfo";
 
-import tasks from "../core/importable-tasks-dsl";
+import { internalTask, task } from "../core/config/config-env";
 import { DependencyGraph } from "../solidity/dependencyGraph";
 import { ResolvedFile } from "../solidity/resolver";
 import { ResolvedFilesMap } from "../types";
@@ -49,7 +49,7 @@ function getFileWithoutPragmaNorImports(resolvedFile: ResolvedFile) {
     .trim();
 }
 
-tasks.internalTask(
+internalTask(
   "builtin:get-flattened-sources",
   "Returns all contracts and their dependencies flattened",
   async (_, { config, run }) => {
@@ -72,7 +72,7 @@ tasks.internalTask(
   }
 );
 
-tasks.task(
+task(
   "flatten",
   "Flattens all the contract and their dependencies",
   async (_, { config, run }) => {

src/builtin-tasks/help.ts

@@ -1,15 +1,14 @@
 import { HelpPrinter } from "../cli/HelpPrinter";
-import tasksDsl from "../core/importable-tasks-dsl";
+import { task } from "../core/config/config-env";
 import { BUIDLER_PARAM_DEFINITIONS } from "../core/params/buidler-params";
 import { getPackageJson } from "../util/packageInfo";
 
-tasksDsl
-  .task("help", "Prints this message")
+task("help", "Prints this message")
   .addOptionalPositionalParam(
     "task",
     "An optional task to print more info about"
   )
-  .setAction(async ({ task }: { task?: string }, { tasks }) => {
+  .setAction(async ({ task: taskName }: { task?: string }, { tasks }) => {
     const packageJson = await getPackageJson();
 
     const helpPrinter = new HelpPrinter(
@@ -19,8 +18,8 @@ tasksDsl
       tasks
     );
 
-    if (task !== undefined) {
-      helpPrinter.printTaskHelp(task);
+    if (taskName !== undefined) {
+      helpPrinter.printTaskHelp(taskName);
       return;
     }
 

src/builtin-tasks/run.ts

@@ -1,12 +1,11 @@
+import { internalTask, task } from "../core/config/config-env";
 import { BuidlerError, ERRORS } from "../core/errors";
-import tasks from "../core/importable-tasks-dsl";
 
-tasks.internalTask("builtin:setup-run-environment", async () => {
+internalTask("builtin:setup-run-environment", async () => {
   // this task is only here in case someone wants to override it.
 });
 
-tasks
-  .task("run", "Runs an user-defined script after compiling the project")
+task("run", "Runs an user-defined script after compiling the project")
   .addPositionalParam(
     "script",
     "A js file to be run within buidler's environment"

src/builtin-tasks/test.ts

@@ -1,11 +1,10 @@
 import path from "path";
 import util from "util";
 
-import tasks from "../core/importable-tasks-dsl";
+import { internalTask, task } from "../core/config/config-env";
 import { glob } from "../util/glob";
 
-tasks
-  .internalTask("builtin:get-test-files")
+internalTask("builtin:get-test-files")
   .addOptionalVariadicPositionalParam(
     "testFiles",
     "An optional list of files to test",
@@ -19,28 +18,24 @@ tasks
     return testFiles;
   });
 
-tasks.internalTask(
-  "builtin:setup-test-environment",
-  async (_, { config, web3 }) => {
-    const { assert } = await import("chai");
-    const getAccounts = web3.eth.getAccounts.bind(web3.eth);
+internalTask("builtin:setup-test-environment", async (_, { config, web3 }) => {
+  const { assert } = await import("chai");
+  const getAccounts = web3.eth.getAccounts.bind(web3.eth);
 
-    const globalAsAny = global as any;
-    globalAsAny.accounts = await util.promisify(getAccounts)();
-    globalAsAny.assert = assert;
+  const globalAsAny = global as any;
+  globalAsAny.accounts = await util.promisify(getAccounts)();
+  globalAsAny.assert = assert;
 
-    globalAsAny.contract = (
-      description: string,
-      definition: ((accounts: string) => any)
-    ) =>
-      describe(description, () => {
-        definition(globalAsAny.accounts);
-      });
-  }
-);
+  globalAsAny.contract = (
+    description: string,
+    definition: ((accounts: string) => any)
+  ) =>
+    describe(description, () => {
+      definition(globalAsAny.accounts);
+    });
+});
 
-tasks
-  .internalTask("builtin:run-mocha-tests")
+internalTask("builtin:run-mocha-tests")
   .addOptionalVariadicPositionalParam(
     "testFiles",
     "An optional list of files to test",
@@ -58,8 +53,7 @@ tasks
     });
   });
 
-tasks
-  .task("test", "Runs mocha tests")
+task("test", "Runs mocha tests")
   .addOptionalVariadicPositionalParam(
     "testFiles",
     "An optional list of files to test",

src/cli/ArgumentsParser.ts

@@ -4,10 +4,10 @@ import {
   BuidlerParamDefinitons
 } from "../core/params/buidler-params";
 import {
-  ITaskDefinition,
   ParamDefinition,
-  ParamDefinitionsMap
-} from "../core/tasks/TaskDefinition";
+  ParamDefinitionsMap,
+  TaskDefinition
+} from "../core/tasks/task-definitions";
 import { TaskArguments } from "../types";
 import { unsafeObjectKeys } from "../util/unsafe";
 
@@ -99,22 +99,22 @@ export class ArgumentsParser {
     };
   }
 
-  public parseTaskArguments(taskDefintion: ITaskDefinition, rawCLAs: string[]) {
+  public parseTaskArguments(taskDefinition: TaskDefinition, rawCLAs: string[]) {
     const {
       paramArguments,
       rawPositionalArguments
-    } = this._parseTaskParamArguments(taskDefintion, rawCLAs);
+    } = this._parseTaskParamArguments(taskDefinition, rawCLAs);
 
     const positionalArguments = this._parsePositionalParamArgs(
       rawPositionalArguments,
-      taskDefintion.positionalParamDefinitions
+      taskDefinition.positionalParamDefinitions
     );
 
     return { ...paramArguments, ...positionalArguments };
   }
 
   public _parseTaskParamArguments(
-    taskDefintion: ITaskDefinition,
+    taskDefintion: TaskDefinition,
     rawCLAs: string[]
   ) {
     const paramArguments = {};
@@ -163,7 +163,7 @@ export class ArgumentsParser {
   }
 
   public _addTaskDefaultArguments(
-    taskDefintion: ITaskDefinition,
+    taskDefintion: TaskDefinition,
     taskArguments: TaskArguments
   ) {
     for (const paramName of Object.keys(taskDefintion.paramDefinitions)) {

src/cli/HelpPrinter.ts

@@ -1,10 +1,9 @@
 import { BuidlerError, ERRORS } from "../core/errors";
 import { BuidlerParamDefinitons } from "../core/params/buidler-params";
 import {
-  ITaskDefinition,
   ParamDefinition,
   ParamDefinitionsMap
-} from "../core/tasks/TaskDefinition";
+} from "../core/tasks/task-definitions";
 import { TasksMap } from "../types";
 
 import { ArgumentsParser } from "./ArgumentsParser";

src/cli/cli.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import "source-map-support/register";
 
-import { getConfig } from "../core/config";
+import { getConfig } from "../core/config/config";
 import { BuidlerError, ERRORS } from "../core/errors";
 import { BUIDLER_PARAM_DEFINITIONS } from "../core/params/buidler-params";
 import { getEnvBuidlerArguments } from "../core/params/env-variables";

src/core/config/config-env.ts

@@ -0,0 +1,57 @@
+import { ActionType, TaskArguments } from "../../types";
+import * as argumentTypes from "../params/argumentTypes";
+import { ConfigurableTaskDefinition } from "../tasks/task-definitions";
+
+import dsl from "./tasks-dsl-instance";
+
+export function task<ArgsT extends TaskArguments>(
+  name: string,
+  description?: string,
+  action?: ActionType<ArgsT>
+): ConfigurableTaskDefinition;
+export function task<ArgsT extends TaskArguments>(
+  name: string,
+  action: ActionType<ArgsT>
+): ConfigurableTaskDefinition;
+export function task<ArgsT extends TaskArguments>(
+  name: string,
+  descriptionOrAction?: string | ActionType<ArgsT>,
+  action?: ActionType<ArgsT>
+): ConfigurableTaskDefinition {
+  if (descriptionOrAction === undefined) {
+    return dsl.task(name);
+  }
+
+  if (typeof descriptionOrAction !== "string") {
+    return dsl.task(name, descriptionOrAction);
+  }
+
+  return dsl.task(name, descriptionOrAction, action);
+}
+
+export function internalTask<ArgsT extends TaskArguments>(
+  name: string,
+  description?: string,
+  action?: ActionType<ArgsT>
+): ConfigurableTaskDefinition;
+export function internalTask<ArgsT extends TaskArguments>(
+  name: string,
+  action: ActionType<ArgsT>
+): ConfigurableTaskDefinition;
+export function internalTask<ArgsT extends TaskArguments>(
+  name: string,
+  descriptionOrAction?: string | ActionType<ArgsT>,
+  action?: ActionType<ArgsT>
+): ConfigurableTaskDefinition {
+  if (descriptionOrAction === undefined) {
+    return dsl.internalTask(name);
+  }
+
+  if (typeof descriptionOrAction !== "string") {
+    return dsl.internalTask(name, descriptionOrAction);
+  }
+
+  return dsl.internalTask(name, descriptionOrAction, action);
+}
+
+export const types = argumentTypes;