diff --git a/.travis.yml b/.travis.yml
index 14abb83f61a29140e7a8d22b91461ebfcb8330c6..7f17ff9a58bf0c8e39f602053bc0a9679b4921bc 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -63,7 +63,6 @@ before_deploy:
- cd ../nw
- zip -qr ../nw.nwb *
- cd ../..
- - rm -Rf .git
- mv ucoin_release/duniter-desktop.nw duniter-x64/opt/duniter/
- mv ucoin_release/nw.nwb duniter-x64/opt/duniter/
- fakeroot dpkg-deb --build duniter-x64
diff --git a/app/lib/cfs.js b/app/lib/cfs.js
index 016ecf020cf5477fe74947825eb9490820e4d851..e7ed023a35297c9e1cc8ee4852d2f1a70c2b2be7 100644
--- a/app/lib/cfs.js
+++ b/app/lib/cfs.js
@@ -27,7 +27,7 @@ function CFSCore(rootPath, qfs, parent) {
* @returns {*|any|Q.Promise<void>} Promise of creation.
*/
function createDeletionFolder() {
- return deletionFolderPromise || (deletionFolderPromise = qfs.makeTree(path.join(rootPath, '.deleted')));
+ return deletionFolderPromise || (deletionFolderPromise = that.makeTree('.deleted'));
}
/**
@@ -154,7 +154,23 @@ function CFSCore(rootPath, qfs, parent) {
* Create a directory tree.
* @param treePath Tree path to create.
*/
- this.makeTree = (treePath) => qfs.makeTree(path.join(rootPath, treePath));
+ this.makeTree = (treePath) => co(function*(){
+ // Note: qfs.makeTree does not work on windows, so we implement it manually
+ try {
+ let normalized = path.normalize(treePath);
+ let folders = normalized.split(path.sep);
+ let folder = rootPath;
+ for (let i = 0, len = folders.length; i < len; i++) {
+ folder = folder ? path.join(folder, folders[i]) : folders[i];
+ let exists = yield qfs.exists(folder);
+ if (!exists) {
+ yield qfs.makeDirectory(folder);
+ }
+ }
+ } catch (e) {
+ if (e && e.code !== "EISDIR") throw e;
+ }
+ });
/**
* Write JSON object to given file.
diff --git a/app/lib/crypto.js b/app/lib/crypto.js
index 654f7c39cb831627bad54db3dfb4e71ddf7f2c93..41c828f9ba107db722b0b097c9eae7c0695f9772 100644
--- a/app/lib/crypto.js
+++ b/app/lib/crypto.js
@@ -1,7 +1,7 @@
"use strict";
var _ = require('underscore');
var nacl = require('tweetnacl');
-var scrypt = require('scrypt');
+var scrypt = require('scryptb');
var base58 = require('./base58');
var rawer = require('./rawer');
var naclBinding = require('naclb');
diff --git a/app/lib/dal/fileDAL.js b/app/lib/dal/fileDAL.js
index 5a80b6db48fb10e8f305798f9f7dae8420818a2f..ed195524de143599cbe1f5cc40191ff24c076dba 100644
--- a/app/lib/dal/fileDAL.js
+++ b/app/lib/dal/fileDAL.js
@@ -15,7 +15,7 @@ var ConfDAL = require('./fileDALs/confDAL');
var StatDAL = require('./fileDALs/statDAL');
var IndicatorsDAL = require('./fileDALs/IndicatorsDAL');
var CFSStorage = require('./fileDALs/AbstractCFS');
-var sqlite3 = require("sqlite3").verbose();
+var sqlite3 = require("sqlite3b").verbose();
var logger = require('../../lib/logger')('database');
const UCOIN_DB_NAME = 'ucoin';
diff --git a/appveyor.yml b/appveyor.yml
new file mode 100644
index 0000000000000000000000000000000000000000..caec30b72636a2a1dbdb1af2b367259e77c69cfc
--- /dev/null
+++ b/appveyor.yml
@@ -0,0 +1,87 @@
+environment:
+ matrix:
+ - nodejs_version: "5.8.0"
+
+platform:
+ - x64
+
+install:
+ - ps: Install-Product node $env:nodejs_version $env:platform
+ - node -v
+ - npm install -g npm
+ - npm install -g nw-gyp node-pre-gyp
+ - npm install
+
+test_script:
+ - npm test
+
+build: off
+
+after_test:
+ - choco install -y wget 7zip InnoSetup
+ - set PATH="C:\Program Files\7-Zip";"C:\Program Files (x86)\Inno Setup 5";%PATH%
+ # GUI Version
+ - set SRC=%cd%
+ - echo %SRC%
+ - copy misc\MSVSVersion.py %APPDATA%\npm\node_modules\nw-gyp\gyp\pylib\gyp\MSVSVersion.py
+ - set NW_VERSION=0.13.0-rc3
+ - set NW_RELEASE=v0.13.0-rc3
+ - echo %NW_RELEASE%
+ - cd node_modules/wotb
+ - npm install --build-from-source
+ - node-pre-gyp --runtime=node-webkit --target=%NW_VERSION% --msvs_version=2015 configure
+ - node-pre-gyp --runtime=node-webkit --target=%NW_VERSION% --msvs_version=2015 build
+ - copy %cd%\lib\binding\Release\node-webkit-%NW_RELEASE%-win32-x64\wotb.node %cd%\lib\binding\Release\node-v47-win32-x64\wotb.node /Y
+ - cd ../naclb
+ - npm install --build-from-source
+ - node-pre-gyp --runtime=node-webkit --target=%NW_VERSION% --msvs_version=2015 configure
+ - node-pre-gyp --runtime=node-webkit --target=%NW_VERSION% --msvs_version=2015 build
+ - copy %cd%\lib\binding\Release\node-webkit-%NW_RELEASE%-win32-x64\naclb.node %cd%\lib\binding\Release\node-v47-win32-x64\naclb.node /Y
+ - cd ../scryptb
+ - npm install --build-from-source
+ - node-pre-gyp --runtime=node-webkit --target=%NW_VERSION% --msvs_version=2015 configure
+ - node-pre-gyp --runtime=node-webkit --target=%NW_VERSION% --msvs_version=2015 build
+ - copy %cd%\lib\binding\Release\node-webkit-%NW_RELEASE%-win32-x64\scryptb.node %cd%\lib\binding\Release\node-v47-win32-x64\scryptb.node /Y
+ - cd ../sqlite3b
+ - npm install --build-from-source
+ - node-pre-gyp --runtime=node-webkit --target=%NW_VERSION% --msvs_version=2015 configure
+ - node-pre-gyp --runtime=node-webkit --target=%NW_VERSION% --msvs_version=2015 build
+ - copy %cd%\lib\binding\node-webkit-%NW_RELEASE%-win32-x64\node_sqlite3.node %cd%\lib\binding\node-v47-win32-x64\node_sqlite3.node /Y
+ - cd ../..
+ - npm prune --production
+ - cd ..
+ - mkdir ucoin_release
+ - set NW=nwjs-%NW_RELEASE%-win-x64
+ - echo %NW%
+ - set NW_GZ=%NW%.zip
+ - echo %NW_GZ%
+ - wget http://dl.nwjs.io/%NW_RELEASE%/%NW_GZ%
+ - 7z x %NW_GZ% 1> null
+ - move %NW% %cd%\ucoin_release\nw
+ - mkdir %cd%\ucoin_release\sources
+ - xcopy %SRC%\gui\* %cd%\ucoin_release\nw\ /s /e
+ - xcopy %SRC%\* %cd%\ucoin_release\sources\ /s /e
+ - rd /s /q %cd%\ucoin_release\sources\ui\package\node_modules
+ - rd /s /q %cd%\ucoin_release\sources\ui\package\bower_components
+ - 7z a -tzip duniter-win-x64.zip %cd%\ucoin_release\* 1> null
+ - move duniter-win-x64.zip %cd%\ucoin\duniter-%APPVEYOR_REPO_TAG_NAME%-windows-x64.zip
+ - iscc %cd%\ucoin_release\sources\duniter.iss /DROOT_PATH=%cd%\ucoin_release
+ - move %cd%\ucoin_release\Duniter.exe %cd%\ucoin\duniter-%APPVEYOR_REPO_TAG_NAME%-windows-x64.exe
+
+artifacts:
+ - path: duniter*.exe
+ name: DuniterEXE
+ - path: duniter*.zip
+ name: Duniter
+
+deploy:
+ release: v0.20.0a18
+ provider: GitHub
+ auth_token:
+ secure: Vp/M0r0i1yhGR2nhrPWEbTiDIF6r0cmwbNDFZUzdFe5clWxPXtuC0lgIpOQI78zt
+ artifact: /Duniter/
+ draft: true
+ prerelease: true
+ on:
+ branch: master
+ appveyor_repo_tag: true
diff --git a/duniter.iss b/duniter.iss
new file mode 100644
index 0000000000000000000000000000000000000000..d650679fbbe945c59c195d88697e6927824dab70
--- /dev/null
+++ b/duniter.iss
@@ -0,0 +1,61 @@
+#define MyAppName "Duniter"
+#define MyAppPublisher "Duniter team"
+#define MyAppURL "http://duniter.org"
+#define MyAppExeName "nw.exe"
+
+#if !Defined(ROOT_PATH)
+#define ROOT_PATH "."
+#endif
+
+#define MyAppSrc ROOT_PATH
+#define MyAppExe ROOT_PATH + "\nw\" + MyAppExeName
+#pragma message MyAppSrc
+
+#if !FileExists(MyAppExe)
+#error "Unable to find MyAppExe"
+#endif
+
+#define MyAppVerStr "v0.20.0a18"
+
+[Setup]
+AppName={#MyAppName}
+AppVersion={#MyAppVerStr}
+AppPublisher={#MyAppPublisher}
+AppPublisherURL={#MyAppURL}
+AppSupportURL={#MyAppURL}
+AppUpdatesURL={#MyAppURL}
+DefaultDirName={pf}\{#MyAppName}
+DisableDirPage=yes
+DefaultGroupName={#MyAppName}
+DisableProgramGroupPage=yes
+OutputDir={#ROOT_PATH}
+OutputBaseFilename={#MyAppName}
+Compression=lzma
+SolidCompression=yes
+UninstallDisplayIcon={app}\nw\{#MyAppExeName}
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+Name: "french"; MessagesFile: "compiler:Languages\French.isl"
+
+[Tasks]
+Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked
+
+[Files]
+Source: "{#MyAppSrc}\nw\*"; DestDir: "{app}\nw\"; Flags: ignoreversion recursesubdirs
+Source: "{#MyAppSrc}\sources\*"; DestDir: "{app}\sources\"; Flags: ignoreversion recursesubdirs
+
+[Icons]
+Name: "{group}\{#MyAppName}"; IconFilename: "{app}\nw\duniter.ico"; Filename: "{app}\nw\{#MyAppExeName}"
+Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}"
+Name: "{commondesktop}\{#MyAppName}"; IconFilename: "{app}\nw\duniter.ico"; Filename: "{app}\nw\{#MyAppExeName}"; Tasks: desktopicon
+
+[Run]
+Filename: "{app}\nw\{#MyAppExeName}"; Description: "{cm:LaunchProgram,{#StringChange(MyAppName, '&', '&&')}}"; Flags: nowait postinstall skipifsilent
+
+[Setup]
+; NOTE: The value of AppId uniquely identifies this application.
+; Do not use the same AppId value in installers for other applications.
+; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
+AppId={{E01B0960-74D2-8ACD-734E-8B3CB033B07F}
+LicenseFile="{#MyAppSrc}\sources\LICENSE"
diff --git a/gui/duniter.ico b/gui/duniter.ico
new file mode 100644
index 0000000000000000000000000000000000000000..dcf7bfc7e07b5caafc1bc2ba8470303a7578858c
Binary files /dev/null and b/gui/duniter.ico differ
diff --git a/gui/duniter.png b/gui/duniter.png
index e364a651a47c4faa6ae6a38b60ab8cd321b23324..e9565045f4110241c2cbaa4a7dd68c3786e58f93 100644
Binary files a/gui/duniter.png and b/gui/duniter.png differ
diff --git a/misc/MSVSVersion.py b/misc/MSVSVersion.py
new file mode 100644
index 0000000000000000000000000000000000000000..42c034b6ebc33e111fb063fc7904163a7289f11d
--- /dev/null
+++ b/misc/MSVSVersion.py
@@ -0,0 +1,429 @@
+# Copyright (c) 2013 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Handle version information related to Visual Stuio."""
+
+import errno
+import os
+import re
+import subprocess
+import sys
+import gyp
+import glob
+
+
+class VisualStudioVersion(object):
+ """Information regarding a version of Visual Studio."""
+
+ def __init__(self, short_name, description,
+ solution_version, project_version, flat_sln, uses_vcxproj,
+ path, sdk_based, default_toolset=None):
+ self.short_name = short_name
+ self.description = description
+ self.solution_version = solution_version
+ self.project_version = project_version
+ self.flat_sln = flat_sln
+ self.uses_vcxproj = uses_vcxproj
+ self.path = path
+ self.sdk_based = sdk_based
+ self.default_toolset = default_toolset
+
+ def ShortName(self):
+ return self.short_name
+
+ def Description(self):
+ """Get the full description of the version."""
+ return self.description
+
+ def SolutionVersion(self):
+ """Get the version number of the sln files."""
+ return self.solution_version
+
+ def ProjectVersion(self):
+ """Get the version number of the vcproj or vcxproj files."""
+ return self.project_version
+
+ def FlatSolution(self):
+ return self.flat_sln
+
+ def UsesVcxproj(self):
+ """Returns true if this version uses a vcxproj file."""
+ return self.uses_vcxproj
+
+ def ProjectExtension(self):
+ """Returns the file extension for the project."""
+ return self.uses_vcxproj and '.vcxproj' or '.vcproj'
+
+ def Path(self):
+ """Returns the path to Visual Studio installation."""
+ return self.path
+
+ def ToolPath(self, tool):
+ """Returns the path to a given compiler tool. """
+ return os.path.normpath(os.path.join(self.path, "VC/bin", tool))
+
+ def DefaultToolset(self):
+ """Returns the msbuild toolset version that will be used in the absence
+ of a user override."""
+ return self.default_toolset
+
+ def SetupScript(self, target_arch):
+ """Returns a command (with arguments) to be used to set up the
+ environment."""
+ # Check if we are running in the SDK command line environment and use
+ # the setup script from the SDK if so. |target_arch| should be either
+ # 'x86' or 'x64'.
+ assert target_arch in ('x86', 'x64')
+ sdk_dir = os.environ.get('WindowsSDKDir')
+ if self.sdk_based and sdk_dir:
+ return [os.path.normpath(os.path.join(sdk_dir, 'Bin/SetEnv.Cmd')),
+ '/' + target_arch]
+ else:
+ # We don't use VC/vcvarsall.bat for x86 because vcvarsall calls
+ # vcvars32, which it can only find if VS??COMNTOOLS is set, which it
+ # isn't always.
+ if target_arch == 'x86':
+ if self.short_name == '2013' and (
+ os.environ.get('PROCESSOR_ARCHITECTURE') == 'AMD64' or
+ os.environ.get('PROCESSOR_ARCHITEW6432') == 'AMD64'):
+ # VS2013 non-Express has a x64-x86 cross that we want to prefer.
+ return [os.path.normpath(
+ os.path.join(self.path, 'VC/vcvarsall.bat')), 'amd64_x86']
+ # Otherwise, the standard x86 compiler.
+ return [os.path.normpath(
+ os.path.join(self.path, 'Common7/Tools/vsvars32.bat'))]
+ else:
+ assert target_arch == 'x64'
+ arg = 'x86_amd64'
+ if (os.environ.get('PROCESSOR_ARCHITECTURE') == 'AMD64' or
+ os.environ.get('PROCESSOR_ARCHITEW6432') == 'AMD64'):
+ # Use the 64-on-64 compiler if we can.
+ arg = 'amd64'
+ return [os.path.normpath(
+ os.path.join(self.path, 'VC/vcvarsall.bat')), arg]
+
+
+def _RegistryQueryBase(sysdir, key, value):
+ """Use reg.exe to read a particular key.
+
+ While ideally we might use the win32 module, we would like gyp to be
+ python neutral, so for instance cygwin python lacks this module.
+
+ Arguments:
+ sysdir: The system subdirectory to attempt to launch reg.exe from.
+ key: The registry key to read from.
+ value: The particular value to read.
+ Return:
+ stdout from reg.exe, or None for failure.
+ """
+ # Skip if not on Windows or Python Win32 setup issue
+ if sys.platform not in ('win32', 'cygwin'):
+ return None
+ # Setup params to pass to and attempt to launch reg.exe
+ cmd = [os.path.join(os.environ.get('WINDIR', ''), sysdir, 'reg.exe'),
+ 'query', key]
+ if value:
+ cmd.extend(['/v', value])
+ p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ # Obtain the stdout from reg.exe, reading to the end so p.returncode is valid
+ # Note that the error text may be in [1] in some cases
+ text = p.communicate()[0]
+ # Check return code from reg.exe; officially 0==success and 1==error
+ if p.returncode:
+ return None
+ return text
+
+
+def _RegistryQuery(key, value=None):
+ """Use reg.exe to read a particular key through _RegistryQueryBase.
+
+ First tries to launch from %WinDir%\Sysnative to avoid WoW64 redirection. If
+ that fails, it falls back to System32. Sysnative is available on Vista and
+ up and available on Windows Server 2003 and XP through KB patch 942589. Note
+ that Sysnative will always fail if using 64-bit python due to it being a
+ virtual directory and System32 will work correctly in the first place.
+
+ KB 942589 - http://support.microsoft.com/kb/942589/en-us.
+
+ Arguments:
+ key: The registry key.
+ value: The particular registry value to read (optional).
+ Return:
+ stdout from reg.exe, or None for failure.
+ """
+ text = None
+ try:
+ text = _RegistryQueryBase('Sysnative', key, value)
+ except OSError, e:
+ if e.errno == errno.ENOENT:
+ text = _RegistryQueryBase('System32', key, value)
+ else:
+ raise
+ return text
+
+
+def _RegistryGetValue(key, value):
+ """Use reg.exe to obtain the value of a registry key.
+
+ Args:
+ key: The registry key.
+ value: The particular registry value to read.
+ Return:
+ contents of the registry key's value, or None on failure.
+ """
+ text = _RegistryQuery(key, value)
+ if not text:
+ return None
+ # Extract value.
+ match = re.search(r'REG_\w+\s+([^\r]+)\r\n', text)
+ if not match:
+ return None
+ return match.group(1)
+
+
+def _RegistryKeyExists(key):
+ """Use reg.exe to see if a key exists.
+
+ Args:
+ key: The registry key to check.
+ Return:
+ True if the key exists
+ """
+ if not _RegistryQuery(key):
+ return False
+ return True
+
+
+def _CreateVersion(name, path, sdk_based=False):
+ """Sets up MSVS project generation.
+
+ Setup is based off the GYP_MSVS_VERSION environment variable or whatever is
+ autodetected if GYP_MSVS_VERSION is not explicitly specified. If a version is
+ passed in that doesn't match a value in versions python will throw a error.
+ """
+ if path:
+ path = os.path.normpath(path)
+ versions = {
+ '2015': VisualStudioVersion('2015',
+ 'Visual Studio 2015',
+ solution_version='12.00',
+ project_version='14.0',
+ flat_sln=False,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based,
+ default_toolset='v140'),
+ '2015e': VisualStudioVersion('2015e',
+ 'Visual Studio 2015',
+ solution_version='12.00',
+ project_version='14.0',
+ flat_sln=True,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based,
+ default_toolset='v140'),
+ '2013': VisualStudioVersion('2013',
+ 'Visual Studio 2013',
+ solution_version='13.00',
+ project_version='12.0',
+ flat_sln=False,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based,
+ default_toolset='v120'),
+ '2013e': VisualStudioVersion('2013e',
+ 'Visual Studio 2013',
+ solution_version='13.00',
+ project_version='12.0',
+ flat_sln=True,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based,
+ default_toolset='v120'),
+ '2012': VisualStudioVersion('2012',
+ 'Visual Studio 2012',
+ solution_version='12.00',
+ project_version='4.0',
+ flat_sln=False,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based,
+ default_toolset='v110'),
+ '2012e': VisualStudioVersion('2012e',
+ 'Visual Studio 2012',
+ solution_version='12.00',
+ project_version='4.0',
+ flat_sln=True,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based,
+ default_toolset='v110'),
+ '2010': VisualStudioVersion('2010',
+ 'Visual Studio 2010',
+ solution_version='11.00',
+ project_version='4.0',
+ flat_sln=False,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based),
+ '2010e': VisualStudioVersion('2010e',
+ 'Visual C++ Express 2010',
+ solution_version='11.00',
+ project_version='4.0',
+ flat_sln=True,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based),
+ '2008': VisualStudioVersion('2008',
+ 'Visual Studio 2008',
+ solution_version='10.00',
+ project_version='9.00',
+ flat_sln=False,
+ uses_vcxproj=False,
+ path=path,
+ sdk_based=sdk_based),
+ '2008e': VisualStudioVersion('2008e',
+ 'Visual Studio 2008',
+ solution_version='10.00',
+ project_version='9.00',
+ flat_sln=True,
+ uses_vcxproj=False,
+ path=path,
+ sdk_based=sdk_based),
+ '2005': VisualStudioVersion('2005',
+ 'Visual Studio 2005',
+ solution_version='9.00',
+ project_version='8.00',
+ flat_sln=False,
+ uses_vcxproj=False,
+ path=path,
+ sdk_based=sdk_based),
+ '2005e': VisualStudioVersion('2005e',
+ 'Visual Studio 2005',
+ solution_version='9.00',
+ project_version='8.00',
+ flat_sln=True,
+ uses_vcxproj=False,
+ path=path,
+ sdk_based=sdk_based),
+ }
+ return versions[str(name)]
+
+
+def _ConvertToCygpath(path):
+ """Convert to cygwin path if we are using cygwin."""
+ if sys.platform == 'cygwin':
+ p = subprocess.Popen(['cygpath', path], stdout=subprocess.PIPE)
+ path = p.communicate()[0].strip()
+ return path
+
+
+def _DetectVisualStudioVersions(versions_to_check, force_express):
+ """Collect the list of installed visual studio versions.
+
+ Returns:
+ A list of visual studio versions installed in descending order of
+ usage preference.
+ Base this on the registry and a quick check if devenv.exe exists.
+ Only versions 8-10 are considered.
+ Possibilities are:
+ 2005(e) - Visual Studio 2005 (8)
+ 2008(e) - Visual Studio 2008 (9)
+ 2010(e) - Visual Studio 2010 (10)
+ 2012(e) - Visual Studio 2012 (11)
+ 2013(e) - Visual Studio 2013 (11)
+ 2015(e) - Visual Studio 2015 (14)
+ Where (e) is e for express editions of MSVS and blank otherwise.
+ """
+ version_to_year = {
+ '8.0': '2005',
+ '9.0': '2008',
+ '10.0': '2010',
+ '11.0': '2012',
+ '12.0': '2013',
+ '14.0': '2015',
+ }
+ versions = []
+ for version in versions_to_check:
+ # Old method of searching for which VS version is installed
+ # We don't use the 2010-encouraged-way because we also want to get the
+ # path to the binaries, which it doesn't offer.
+ keys = [r'HKLM\Software\Microsoft\VisualStudio\%s' % version,
+ r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\%s' % version,
+ r'HKLM\Software\Microsoft\VCExpress\%s' % version,
+ r'HKLM\Software\Wow6432Node\Microsoft\VCExpress\%s' % version]
+ for index in range(len(keys)):
+ path = _RegistryGetValue(keys[index], 'InstallDir')
+ if not path:
+ continue
+ path = _ConvertToCygpath(path)
+ # Check for full.
+ full_path = os.path.join(path, 'devenv.exe')
+ express_path = os.path.join(path, '*express.exe')
+ if not force_express and os.path.exists(full_path):
+ # Add this one.
+ versions.append(_CreateVersion(version_to_year[version],
+ os.path.join(path, '..', '..')))
+ # Check for express.
+ elif glob.glob(express_path):
+ # Add this one.
+ versions.append(_CreateVersion(version_to_year[version] + 'e',
+ os.path.join(path, '..', '..')))
+
+ # The old method above does not work when only SDK is installed.
+ keys = [r'HKLM\Software\Microsoft\VisualStudio\SxS\VC7',
+ r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\SxS\VC7']
+ for index in range(len(keys)):
+ path = _RegistryGetValue(keys[index], version)
+ if not path:
+ continue
+ path = _ConvertToCygpath(path)
+ versions.append(_CreateVersion(version_to_year[version] + 'e',
+ os.path.join(path, '..'), sdk_based=True))
+
+ return versions
+
+
+def SelectVisualStudioVersion(version='auto'):
+ """Select which version of Visual Studio projects to generate.
+
+ Arguments:
+ version: Hook to allow caller to force a particular version (vs auto).
+ Returns:
+ An object representing a visual studio project format version.
+ """
+ # In auto mode, check environment variable for override.
+ if version == 'auto':
+ version = os.environ.get('GYP_MSVS_VERSION', 'auto')
+ version_map = {
+ 'auto': ('14.0', '12.0', '10.0', '9.0', '8.0', '11.0'),
+ '2005': ('8.0',),
+ '2005e': ('8.0',),
+ '2008': ('9.0',),
+ '2008e': ('9.0',),
+ '2010': ('10.0',),
+ '2010e': ('10.0',),
+ '2012': ('11.0',),
+ '2012e': ('11.0',),
+ '2013': ('12.0',),
+ '2013e': ('12.0',),
+ '2015': ('14.0',),
+ '2015e': ('14.0',),
+ }
+ override_path = os.environ.get('GYP_MSVS_OVERRIDE_PATH')
+ if override_path:
+ msvs_version = os.environ.get('GYP_MSVS_VERSION')
+ if not msvs_version:
+ raise ValueError('GYP_MSVS_OVERRIDE_PATH requires GYP_MSVS_VERSION to be '
+ 'set to a particular version (e.g. 2010e).')
+ return _CreateVersion(msvs_version, override_path, sdk_based=True)
+ version = str(version)
+ versions = _DetectVisualStudioVersions(version_map[version], 'e' in version)
+ if not versions:
+ if version == 'auto':
+ # Default to 2005 if we couldn't find anything
+ return _CreateVersion('2005', None)
+ else:
+ return _CreateVersion(version, None)
+ return versions[0]
diff --git a/package.json b/package.json
index aa1a025f432c2dc9a28095974c190a79af7a9798..0654d1d088c47419a60220d6348404202081085d 100644
--- a/package.json
+++ b/package.json
@@ -16,7 +16,7 @@
"test": "mocha --growl --timeout 20000 test test/fast test/fast/block test/integration test/",
"start": "node bin/ucoind start",
"test-travis": "node ./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha --report lcovonly -- -R spec --timeout 20000 test test/fast test/fast/block test/integration test/",
- "postinstall": "mkdir -p ui && cd ui && npm pack ucoin-ui@0.1.2 && tar xzf ucoin-ui-0.1.2.tgz && cd package && npm install && cd .. && rm ucoin-ui-0.1.2.tgz"
+ "postinstall": "mkdir ui && cd ui && npm pack ucoin-ui@0.1.3 && tar xzf ucoin-ui-0.1.3.tgz && cd package && npm install && cd .. && rm ucoin-ui-0.1.3.tgz"
},
"repository": {
"type": "git",
@@ -46,28 +46,27 @@
"event-stream": "3.1.5",
"express": "4.13.4",
"express-cors": "0.0.3",
- "express-ws": "0.2.6",
"inquirer": "0.8.5",
"jison": "0.4.17",
"merkle": "0.4.0",
"moment": "2.6.0",
"morgan": "1.6.1",
"multimeter": "0.1.1",
- "naclb": "1.0.0",
+ "naclb": "1.2.9",
"nnupnp": "1.0.1",
"optimist": "0.6.1",
"q": "1.1.2",
"q-io": "1.13.2",
"request": "2.31.0",
- "scrypt": "5.4.1",
+ "scryptb": "6.0.4",
"sha1": "1.1.0",
- "sqlite3": "3.1.1",
+ "sqlite3b": "3.1.1",
"superagent": "1.4.0",
"tweetnacl": "0.14.1",
"underscore": "1.8.3",
- "vucoin": "0.29.1",
+ "vucoin": "0.30.1",
"winston": "2.1.1",
- "wotb": "0.3.2",
+ "wotb": "0.4.5",
"ws": "1.0.1"
},
"devDependencies": {