Merge branch 'develop' of github.com:iurimatias/embark-framework into develop

Author: iurimatias

README.md

@@ -160,13 +160,18 @@ Solidity/Serpent files in the contracts directory will automatically be deployed
 Libraries and languages available
 ======
 
-Embark can build and deploy contracts coded in Solidity. It will make them available on the client side using EmbarkJS and Web3.js.
+Embark can build and deploy contracts coded in Solidity and now also in Vyper. It will make them available on the client side using EmbarkJS and Web3.js.
 
 Further documentation for these can be found below:
 
-* Smart Contracts: [Solidity](https://solidity.readthedocs.io/en/develop/) and [Serpent](https://github.com/ethereum/wiki/wiki/Serpent)
+* Smart Contracts:
+    * [Solidity](https://solidity.readthedocs.io/en/develop/)
+    * [Vyper](https://vyper.readthedocs.io/en/latest/index.html)
+    * [Serpent](https://github.com/ethereum/wiki/wiki/Serpent)
 * Client Side: [Web3.js](https://github.com/ethereum/wiki/wiki/JavaScript-API) and [EmbarkJS](#embarkjs)
 
+However, to use Vyper, you need to have Vyper installed on you computer beforehand. Meaning that doing `vyper contract.v.py` is possible.
+
 Using Contracts
 ======
 Embark will automatically take care of deployment for you and set all needed JS bindings. For example, the contract below:

lib/cmd.js

@@ -18,6 +18,7 @@ class Cmd {
     this.simulator();
     this.test();
     this.reset();
+    this.graph();
     this.upload();
     this.versionCmd();
     this.otherCommands();
@@ -179,6 +180,18 @@ class Cmd {
       });
   }
 
+  graph() {
+    program
+      .command('graph [environment]')
+      .description('generates documentation based on the smart contracts configured')
+      .action(function (env, options) {
+        embark.graph({
+          env: env || 'development',
+          logfile: options.logfile
+        });
+      });
+  }
+
   reset() {
     program
       .command('reset')
@@ -214,6 +227,7 @@ class Cmd {
         process.exit(0);
       });
   }
+  
 
 }
 

lib/cmds/graph.js

@@ -0,0 +1,110 @@
+const Viz = require('viz.js');
+const fs = require('fs');
+
+class GraphGenerator {
+    constructor(engine) {
+        this.engine = engine;
+    }
+
+    generate() {
+        let id = 0;
+        let contractString = "";
+        let relationshipString = "";
+        let idMapping = {};
+        let contractInheritance = {};
+
+        
+        for (let contract in this.engine.contractsManager.contracts) {
+            id++;
+
+            idMapping[contract] = id;
+
+            let contractLabel = "";
+
+            contractLabel += `${contract}`;
+            let tooltip = contract;
+
+            if(this.engine.contractsManager.contracts[contract].instanceOf !== undefined &&
+               this.engine.contractsManager.contracts[this.engine.contractsManager.contracts[contract].instanceOf] !== undefined){
+                contractInheritance[contract] = this.engine.contractsManager.contracts[contract].instanceOf;
+                contractLabel += ": " + this.engine.contractsManager.contracts[contract].instanceOf;
+                tooltip += " instance of " + this.engine.contractsManager.contracts[contract].instanceOf; 
+            } else {
+                contractLabel += "|";
+
+                for(let i = 0; i < this.engine.contractsManager.contracts[contract].abiDefinition.length; i++){
+                    switch(this.engine.contractsManager.contracts[contract].abiDefinition[i].type){
+                        case 'fallback': 
+                            contractLabel += "«fallback»()\\l";
+                            break;
+                            case 'constructor':
+                            contractLabel += "«constructor»(";
+                            this.engine.contractsManager.contracts[contract].abiDefinition[i].inputs.forEach(function(elem, index){
+                                contractLabel += (index == 0 ? "" : ", ") + elem.type;
+                            });
+                            contractLabel += ")\\l";
+                            break;
+                            case 'event':
+                            contractLabel += "«event»" + this.engine.contractsManager.contracts[contract].abiDefinition[i].name  + "(";
+                            this.engine.contractsManager.contracts[contract].abiDefinition[i].inputs.forEach(function(elem, index){
+                                contractLabel += (index == 0 ? "" : ", ") + elem.type;
+                            });
+                            contractLabel += ")\\l";
+                            break;
+                        default: break;
+                    }       
+                }
+
+                let fHashes = this.engine.contractsManager.contracts[contract].functionHashes;
+                if(fHashes != {} && fHashes != undefined){
+                    for(let method in this.engine.contractsManager.contracts[contract].functionHashes){
+                        contractLabel += method + '\\l';
+                    }
+                }
+            }
+
+            let others = '';
+            if(!this.engine.contractsManager.contracts[contract].deploy){
+                others = 'fontcolor="#c3c3c3", color="#a0a0a0"';
+                tooltip += " (not deployed)"; 
+            }
+
+            contractString += `${id}[label = "{${contractLabel}}", tooltip="${tooltip}", fillcolor=gray95, ${others}]\n`;
+
+        }
+
+        for (let c in this.engine.contractsManager.contractDependencies){
+            let contractDependencies = Array.from(new Set(this.engine.contractsManager.contractDependencies[c]));
+            contractDependencies.forEach(function(d){
+                if(idMapping[c] !== undefined && idMapping[d] !== undefined){
+                    relationshipString += `${idMapping[d]}->${idMapping[c]}[constraint=true, arrowtail=diamond, tooltip="${c} uses ${d}"]\n`;
+                }
+            });
+        }
+
+        for (let c in contractInheritance){
+            relationshipString += `${idMapping[contractInheritance[c]]}->${idMapping[c]}[tooltip="${c} instance of ${contractInheritance[c]}"]\n`;
+        }
+
+
+        let dot = `
+        digraph Contracts {
+            node[shape=record,style=filled]
+            edge[dir=back, arrowtail=empty]
+            ${contractString}
+            ${relationshipString}
+        }`;
+
+        let svg = Viz(dot);
+        
+        let filename = "diagram.svg";
+
+        fs.writeFileSync(filename, svg, (err) => {
+            if (err) throw err;
+        });
+
+
+    }
+}
+
+module.exports = GraphGenerator;

lib/contracts/compiler.js

@@ -7,9 +7,10 @@ class Compiler {
   }
 
   compile_contracts(contractFiles, cb) {
+    const self = this;
     let available_compilers = {};
 
-    let pluginCompilers = this.plugins.getPluginsProperty('compilers', 'compilers');
+    let pluginCompilers = self.plugins.getPluginsProperty('compilers', 'compilers');
     pluginCompilers.forEach(function (compilerObject) {
       available_compilers[compilerObject.extension] = compilerObject.cb;
     });
@@ -18,10 +19,13 @@ class Compiler {
 
     async.eachObject(available_compilers,
       function (extension, compiler, callback) {
-        // TODO: warn about files it doesn't know how to compile
         let matchingFiles = contractFiles.filter(function (file) {
           let fileMatch = file.filename.match(/\.[0-9a-z]+$/);
-          return (fileMatch && (fileMatch[0] === extension));
+          if (fileMatch && (fileMatch[0] === extension)) {
+            file.compiled = true;
+            return true;
+          }
+          return false;
         });
 
         compiler.call(compiler, matchingFiles || [], function (err, compileResult) {
@@ -30,6 +34,12 @@ class Compiler {
         });
       },
       function (err) {
+        contractFiles.forEach(file => {
+          if (!file.compiled) {
+              self.logger.warn(`${file.filename} doesn't have a compatible contract compiler. Maybe a plugin exists for it.`);
+          }
+        });
+
         cb(err, compiledObject);
       }
     );

lib/contracts/deploy.js

@@ -305,7 +305,8 @@ class Deploy {
         let contractObject = new self.web3.eth.Contract(contract.abiDefinition);
 
         try {
-          deployObject = contractObject.deploy({arguments: contractParams, data: "0x" + contractCode});
+          const dataCode = contractCode.startsWith('0x') ? contractCode : "0x" + contractCode;
+          deployObject = contractObject.deploy({arguments: contractParams, data: dataCode});
         } catch(e) {
           if (e.message.indexOf('Invalid number of parameters for "undefined"') >= 0) {
             return next(new Error("attempted to deploy " + contract.className + " without specifying parameters"));

lib/contracts/deploy_manager.js

@@ -17,6 +17,7 @@ class DeployManager {
     this.gasLimit = false;
     this.fatalErrors = false;
     this.deployOnlyOnConfig = false;
+    this.onlyCompile = options.onlyCompile !== undefined ? options.onlyCompile : false;
   }
 
   deployContracts(done) {
@@ -33,6 +34,13 @@ class DeployManager {
         self.contractsManager.deployOnlyOnConfig = self.deployOnlyOnConfig; // temporary, should refactor
         self.contractsManager.build(callback);
       },
+      function checkCompileOnly(contractsManager, callback){
+        if(self.onlyCompile){
+          self.events.emit('contractsDeployed', contractsManager);
+          return done();
+        } 
+        return callback(null, contractsManager);
+      },
       function checkWeb3IsConnected(contractsManager, callback) {
         if (!self.web3) {
           return callback(Error("no web3 instance found"));

lib/core/config.js

@@ -47,6 +47,7 @@ Config.prototype.loadConfigFiles = function(options) {
   this.loadPipelineConfigFile();
 
   this.loadContractsConfigFile();
+  this.loadExternalContractsFiles();
   this.loadWebServerConfigFile();
   this.loadChainTrackerFile();
   this.loadPluginContractFiles();
@@ -60,6 +61,7 @@ Config.prototype.reloadConfig = function() {
   this.loadContractsConfigFile();
   this.loadPipelineConfigFile();
   this.loadContractsConfigFile();
+  this.loadExternalContractsFiles();
   this.loadChainTrackerFile();
 };
 
@@ -140,6 +142,23 @@ Config.prototype.loadContractsConfigFile = function() {
   this.contractsConfig = this._mergeConfig(configFilePath, configObject, this.env);
 };
 
+Config.prototype.loadExternalContractsFiles = function() {
+  let contracts = this.contractsConfig.contracts;
+  for (let contractName in contracts) {
+    let contract = contracts[contractName];
+    if (!contract.file) {
+      continue;
+    }
+    if (fs.existsSync(contract.file)) {
+      this.contractsFiles.push(new File({filename: contract.file, type: "dapp_file", basedir: '', path: contract.file}));
+    } else if (fs.existsSync(path.join('./node_modules/', contract.file))) {
+      this.contractsFiles.push(new File({filename: path.join('./node_modules/', contract.file), type: "dapp_file", basedir: '', path: path.join('./node_modules/', contract.file)}));
+    } else {
+      this.logger.error("contract file not found: " + contract.file);
+    }
+  }
+};
+
 Config.prototype.loadStorageConfigFile = function() {
   var versions = utils.recursiveMerge({"ipfs-api": "17.2.4"}, this.embarkConfig.versions || {});
 

lib/core/engine.js

@@ -137,6 +137,9 @@ class Engine {
     this.registerModule('solidity', {
       contractDirectories: self.config.contractDirectories
     });
+    this.registerModule('vyper', {
+      contractDirectories: self.config.contractDirectories
+    });
 
     this.contractsManager = new ContractsManager({
       contractFiles: this.config.contractsFiles,
@@ -153,7 +156,8 @@ class Engine {
       logger: this.logger,
       plugins: this.plugins,
       events: this.events,
-      contractsManager: this.contractsManager
+      contractsManager: this.contractsManager,
+      onlyCompile: options.onlyCompile
     });
 
     this.events.on('file-event', function (fileType, _path) {

lib/index.js

@@ -194,6 +194,53 @@ class Embark {
     return new Test(options);
   }
 
+  graph(options) {
+    options.onlyCompile = true;
+    
+    let engine = new Engine({
+      env: options.env,
+      version: this.version,
+      embarkConfig: options.embarkConfig || 'embark.json',
+      logfile: options.logfile
+    });
+    engine.init();
+
+
+    async.parallel([
+     
+      function (callback) {
+        let pluginList = engine.plugins.listPlugins();
+        if (pluginList.length > 0) {
+          engine.logger.info("loaded plugins: " + pluginList.join(", "));
+        }
+
+        engine.startMonitor();
+        engine.startService("libraryManager");
+        engine.startService("pipeline");
+        engine.startService("codeGenerator");
+        engine.startService("deployment", {onlyCompile: true});
+
+        engine.deployManager.deployContracts(function (err) {
+          callback(err);
+        });
+      }
+    ], function (err, _result) {
+      if (err) {
+        engine.logger.error(err.message);
+        engine.logger.info(err.stack);
+      } else {
+
+        const GraphGenerator = require('./cmds/graph.js');
+        let graphGen = new GraphGenerator(engine);
+        graphGen.generate();
+
+        engine.logger.info("Done".underline);
+        process.exit();
+      }
+    });
+
+  }
+
   reset() {
     let resetCmd = require('./cmds/reset.js');
     resetCmd();

lib/modules/solidity/index.js

@@ -22,7 +22,8 @@ class Solidity {
                      let filename = file.filename;
 
                      for (let directory of self.contractDirectories) {
-                       filename = filename.replace(directory, '');
+                       let match = new RegExp("^" + directory);
+                       filename = filename.replace(match, '');
                      }
 
                      file.content(function(fileContent) {
@@ -48,7 +49,7 @@ class Solidity {
         });
       },
       function compileContracts(callback) {
-        self.logger.info("compiling contracts...");
+        self.logger.info("compiling solidity contracts...");
         let jsonObj =  {
           language: 'Solidity',
           sources: input,
@@ -75,7 +76,6 @@ class Solidity {
                 return callback(new Error("Solidity errors: " + output.errors[i].formattedMessage).message);
               }
             }
-            self.logger.warn(output.errors.join('\n'));
           }
           callback(null, output);
         });