nix: updated to 18.03 nix packages

- dependencies: updated setuptools-scm to 2.1.0
- new strucutre
- cleanups and optimize of build chain

pkgs/README.rst

@@ -0,0 +1,55
+
+==============================
+ Generate the Nix expressions
+==============================
+
+Details can be found in the repository of `RhodeCode Enterprise CE`_ inside of
+the file `docs/contributing/dependencies.rst`.
+
+Start the environment as follows:
+
+.. code:: shell
+
+   nix-shell pkgs/shell-generate.nix
+
+
+
+Python dependencies
+===================
+
+.. code:: shell
+
+   pip2nix generate --licenses
+   # or
+   nix-shell pkgs/shell-generate.nix --command "pip2nix generate --licenses"
+
+
+NodeJS dependencies
+===================
+
+.. code:: shell
+
+   # switch to pkgs dir
+   pushd pkgs
+   node2nix --input ../package.json \
+            -o node-packages.nix \
+            -e node-env.nix \
+            -c node-default.nix \
+            -d --flatten --nodejs-6
+   popd
+
+
+
+Bower dependencies
+==================
+
+.. code:: shell
+
+   bower2nix bower.json pkgs/bower-packages.nix
+   # or
+   nix-shell pkgs/shell-generate.nix --command "bower2nix bower.json pkgs/bower-packages.nix"
+
+
+.. Links
+
+.. _RhodeCode Enterprise CE: https://code.rhodecode.com/rhodecode-enterprise-ce

pkgs/nix-common/pip2nix.nix

@@ -0,0 +1,17
+{ pkgs
+, pythonPackages
+}:
+
+rec {
+  pip2nix-src = pkgs.fetchzip {
+    url = https://github.com/johbo/pip2nix/archive/51e6fdae34d0e8ded9efeef7a8601730249687a6.tar.gz;
+    sha256 = "02a4jjgi7lsvf8mhrxsd56s9a3yg20081rl9bgc2m84w60v2gbz2";
+  };
+
+  pip2nix = import pip2nix-src {
+    inherit
+      pkgs
+      pythonPackages;
+  };
+
+}

pkgs/shell-generate.nix

@@ -0,0 +1,52
+{ pkgs ? (import <nixpkgs> {})
+, pythonPackages ? "python27Packages"
+}:
+
+with pkgs.lib;
+
+let _pythonPackages = pythonPackages; in
+let
+  pythonPackages = getAttr _pythonPackages pkgs;
+
+  pip2nix = import ./nix-common/pip2nix.nix {
+    inherit
+      pkgs
+      pythonPackages;
+  };
+
+in
+
+pkgs.stdenv.mkDerivation {
+  name = "pip2nix-generated";
+  buildInputs = [
+    # Allows to generate python packages
+    pip2nix.pip2nix
+    pythonPackages.pip-tools
+
+    # Allows to generate bower dependencies
+    pkgs.nodePackages.bower2nix
+
+    # Allows to generate node dependencies
+    pkgs.nodePackages.node2nix
+
+    # We need mysql_config to be around
+    pkgs.mysql
+
+    # We need postgresql to be around
+    pkgs.postgresql
+
+    # Curl is needed for pycurl
+    pkgs.curl
+  ];
+
+  shellHook = ''
+    runHook preShellHook
+    runHook postShellHook
+  '';
+
+  preShellHook = ''
+    echo "Starting Generate Shell"
+    # Custom prompt to distinguish from other dev envs.
+    export PS1="\n\[\033[1;32m\][Generate-shell:\w]$\[\033[0m\] "
+  '';
+}

bower.json

@@ -1,17 +1,17
 {
   "name": "rhodecode-elements",
   "description": "User interface for elements for rhodecode",
   "main": "index.html",
   "dependencies": {
     "webcomponentsjs": "^0.7.22",
     "polymer": "Polymer/polymer#^1.6.1",
     "paper-button": "PolymerElements/paper-button#^1.0.13",
     "paper-spinner": "PolymerElements/paper-spinner#^1.2.0",
     "paper-tooltip": "PolymerElements/paper-tooltip#^1.1.2",
     "paper-toast": "PolymerElements/paper-toast#^1.3.0",
     "paper-toggle-button": "PolymerElements/paper-toggle-button#^1.2.0",
-    "iron-ajax": "PolymerElements/iron-ajax#^1.4.3",
+    "iron-ajax": "PolymerElements/iron-ajax#^1.4.4",
     "iron-autogrow-textarea": "PolymerElements/iron-autogrow-textarea#^1.0.13",
     "iron-a11y-keys": "PolymerElements/iron-a11y-keys#^1.0.6"
   }
 }

default.nix

@@ -1,243 +1,258
 # Nix environment for the community edition
 #
-# This shall be as lean as possible, just producing the Enterprise
+# This shall be as lean as possible, just producing the enterprise-ce
 # derivation. For advanced tweaks to pimp up the development environment we use
 # "shell.nix" so that it does not have to clutter this file.
+#
+# Configuration, set values in "~/.nixpkgs/config.nix".
+# example
+#  {
+#    # Thoughts on how to configure the dev environment
+#    rc = {
+#      codeInternalUrl = "https://usr:[e-mail]";
+#      sources = {
+#        rhodecode-vcsserver = "/home/user/work/rhodecode-vcsserver";
+#        rhodecode-enterprise-ce = "/home/user/work/rhodecode-enterprise-ce";
+#        rhodecode-enterprise-ee = "/home/user/work/rhodecode-enterprise-ee";
+#      };
+#    };
+#  }
 
 args@
 { pythonPackages ? "python27Packages"
 , pythonExternalOverrides ? self: super: {}
-, doCheck ? true
+, doCheck ? false
 , ...
 }:
 
 let
-
   # Use nixpkgs from args or import them. We use this indirect approach
   # through args to be able to use the name `pkgs` for our customized packages.
   # Otherwise we will end up with an infinite recursion.
-  nixpkgs = args.pkgs or (import <nixpkgs> { });
+  pkgs = args.pkgs or (import <nixpkgs> { });
 
-  # johbo: Interim bridge which allows us to build with the upcoming
-  # nixos.16.09 branch (unstable at the moment of writing this note) and the
-  # current stable nixos-16.03.
-  backwardsCompatibleFetchgit = { ... }@args:
-    let
-      origSources = nixpkgs.fetchgit args;
-    in
-    nixpkgs.lib.overrideDerivation origSources (oldAttrs: {
-      NIX_PREFETCH_GIT_CHECKOUT_HOOK = ''
-        find $out -name '.git*' -print0 | xargs -0 rm -rf
-      '';
-    });
-
-  # Create a customized version of nixpkgs which should be used throughout the
-  # rest of this file.
-  pkgs = nixpkgs.overridePackages (self: super: {
-    fetchgit = backwardsCompatibleFetchgit;
-  });
+  # Works with the new python-packages, still can fallback to the old
+  # variant.
+  basePythonPackagesUnfix = basePythonPackages.__unfix__ or (
+    self: basePythonPackages.override (a: { inherit self; }));
 
   # Evaluates to the last segment of a file system path.
   basename = path: with pkgs.lib; last (splitString "/" path);
 
   # source code filter used as arugment to builtins.filterSource.
   src-filter = path: type: with pkgs.lib;
     let
       ext = last (splitString "." path);
     in
       !builtins.elem (basename path) [
-        ".git" ".hg" "__pycache__" ".eggs"
+        ".git" ".hg" "__pycache__" ".eggs" ".idea" ".dev"
         "bower_components" "node_modules"
         "build" "data" "result" "tmp"] &&
       !builtins.elem ext ["egg-info" "pyc"] &&
       # TODO: johbo: This check is wrong, since "path" contains an absolute path,
       # it would still be good to restore it since we want to ignore "result-*".
       !hasPrefix "result" path;
 
-  basePythonPackages = with builtins; if isAttrs pythonPackages
-    then pythonPackages
-    else getAttr pythonPackages pkgs;
+  sources =
+    let
+      inherit (pkgs.lib) all isString attrValues;
+      sourcesConfig = pkgs.config.rc.sources or {};
+    in
+      # Ensure that sources are configured as strings. Using a path
+      # would result in a copy into the nix store.
+      assert all isString (attrValues sourcesConfig);
+      sourcesConfig;
 
-  buildBowerComponents =
-    pkgs.buildBowerComponents or
-    (import ./pkgs/backport-16.03-build-bower-components.nix { inherit pkgs; });
-
-  sources = pkgs.config.rc.sources or {};
-  version = builtins.readFile ./rhodecode/VERSION;
+  version = builtins.readFile "${rhodecode-enterprise-ce-src}/rhodecode/VERSION";
   rhodecode-enterprise-ce-src = builtins.filterSource src-filter ./.;
 
+  buildBowerComponents = pkgs.buildBowerComponents;
   nodeEnv = import ./pkgs/node-default.nix {
     inherit pkgs;
   };
   nodeDependencies = nodeEnv.shell.nodeDependencies;
 
   bowerComponents = buildBowerComponents {
     name = "enterprise-ce-${version}";
     generated = ./pkgs/bower-packages.nix;
     src = rhodecode-enterprise-ce-src;
   };
 
-  pythonGeneratedPackages = self: basePythonPackages.override (a: {
-    inherit self;
-  })
-  // (scopedImport {
-    self = self;
-    super = basePythonPackages;
-    inherit pkgs;
-    inherit (pkgs) fetchurl fetchgit;
-  } ./pkgs/python-packages.nix);
+  rhodecode-testdata-src = sources.rhodecode-testdata or (
+    pkgs.fetchhg {
+      url = "https://code.rhodecode.com/upstream/rc_testdata";
+      rev = "v0.10.0";
+      sha256 = "0zn9swwvx4vgw4qn8q3ri26vvzgrxn15x6xnjrysi1bwmz01qjl0";
+  });
 
-  pythonOverrides = import ./pkgs/python-packages-overrides.nix {
-    inherit
-      basePythonPackages
-      pkgs;
+  rhodecode-testdata = import "${rhodecode-testdata-src}/default.nix" {
+  inherit
+    doCheck
+    pkgs
+    pythonPackages;
   };
 
   pythonLocalOverrides = self: super: {
     rhodecode-enterprise-ce =
       let
         linkNodeAndBowerPackages = ''
-          echo "Export RhodeCode CE path"
           export RHODECODE_CE_PATH=${rhodecode-enterprise-ce-src}
-          echo "Link node packages"
+
+          echo "[BEGIN]: Link node packages"
           rm -fr node_modules
           mkdir node_modules
           # johbo: Linking individual packages allows us to run "npm install"
           # inside of a shell to try things out. Re-entering the shell will
           # restore a clean environment.
           ln -s ${nodeDependencies}/lib/node_modules/* node_modules/
+          echo "[DONE]: Link node packages"
 
-          echo "DONE: Link node packages"
-
-          echo "Link bower packages"
+          echo "[BEGIN]: Link bower packages"
           rm -fr bower_components
           mkdir bower_components
+          ln -s ${bowerComponents}/bower_components/* bower_components/
+          echo "[DONE]: Link bower packages"
+        '';
 
-          ln -s ${bowerComponents}/bower_components/* bower_components/
-          echo "DONE: Link bower packages"
-        '';
+        releaseName = "RhodeCodeEnterpriseCE-${version}";
       in super.rhodecode-enterprise-ce.override (attrs: {
-
       inherit
         doCheck
         version;
+
       name = "rhodecode-enterprise-ce-${version}";
-      releaseName = "RhodeCodeEnterpriseCE-${version}";
+      releaseName = releaseName;
       src = rhodecode-enterprise-ce-src;
       dontStrip = true; # prevent strip, we don't need it.
 
-      buildInputs =
-        attrs.buildInputs ++
-        (with self; [
-          pkgs.nodePackages.bower
-          pkgs.nodePackages.grunt-cli
-          pkgs.subversion
-          rhodecode-testdata
-        ]);
-
-      #TODO: either move this into overrides, OR use the new machanics from
-      # pip2nix and requiremtn.txt file
-      propagatedBuildInputs = attrs.propagatedBuildInputs ++ (with self; [
-        rhodecode-tools
-      ]);
-
-      # TODO: johbo: Make a nicer way to expose the parts. Maybe
-      # pkgs/default.nix?
+      # expose following attributed outside
       passthru = {
         inherit
+          rhodecode-testdata
           bowerComponents
           linkNodeAndBowerPackages
           myPythonPackagesUnfix
-          pythonLocalOverrides;
+          pythonLocalOverrides
+          pythonCommunityOverrides;
+
         pythonPackages = self;
       };
 
+      buildInputs =
+        attrs.buildInputs or [] ++ [
+          rhodecode-testdata
+          pkgs.nodePackages.bower
+          pkgs.nodePackages.grunt-cli
+        ];
+
+      #NOTE: option to inject additional propagatedBuildInputs
+      propagatedBuildInputs =
+        attrs.propagatedBuildInputs or [] ++ [
+
+        ];
+
       LC_ALL = "en_US.UTF-8";
       LOCALE_ARCHIVE =
-        if pkgs.stdenv ? glibc
+        if pkgs.stdenv.isLinux
         then "${pkgs.glibcLocales}/lib/locale/locale-archive"
         else "";
 
+      # Add bin directory to path so that tests can find 'rhodecode'.
       preCheck = ''
         export PATH="$out/bin:$PATH"
       '';
 
+      # custom check phase for testing
+      checkPhase = ''
+        runHook preCheck
+        PYTHONHASHSEED=random py.test -vv -p no:sugar -r xw --cov-config=.coveragerc --cov=rhodecode --cov-report=term-missing rhodecode
+        runHook postCheck
+      '';
+
       postCheck = ''
-        rm -rf $out/lib/${self.python.libPrefix}/site-packages/pytest_pylons
+        echo "Cleanup of rhodecode/tests"
         rm -rf $out/lib/${self.python.libPrefix}/site-packages/rhodecode/tests
       '';
 
-      preBuild = linkNodeAndBowerPackages + ''
+      preBuild = ''
+
+        echo "Building frontend assets"
+        ${linkNodeAndBowerPackages}
         grunt
         rm -fr node_modules
       '';
 
       postInstall = ''
-        echo "Writing meta information for rccontrol to nix-support/rccontrol"
+        echo "Writing enterprise-ce meta information for rccontrol to nix-support/rccontrol"
         mkdir -p $out/nix-support/rccontrol
         cp -v rhodecode/VERSION $out/nix-support/rccontrol/version
-        echo "DONE: Meta information for rccontrol written"
+        echo "[DONE]: enterprise-ce meta information for rccontrol written"
+
+        mkdir -p $out/etc
+        cp configs/production.ini $out/etc
+        echo "[DONE]: saved enterprise-ce production.ini into $out/etc"
 
         # python based programs need to be wrapped
-        #ln -s ${self.python}/bin/* $out/bin/
+        mkdir -p $out/bin
+        # rhodecode-tools
+        ln -s ${self.rhodecode-tools}/bin/rhodecode-* $out/bin/
+
+        # required binaries from dependencies
+        #ln -s ${self.python}/bin/python $out/bin
         ln -s ${self.pyramid}/bin/* $out/bin/
         ln -s ${self.gunicorn}/bin/gunicorn $out/bin/
         ln -s ${self.supervisor}/bin/supervisor* $out/bin/
         ln -s ${self.pastescript}/bin/paster $out/bin/
         ln -s ${self.channelstream}/bin/channelstream $out/bin/
         ln -s ${self.celery}/bin/celery $out/bin/
+        echo "[DONE]: created symlinks into $out/bin"
 
-        # rhodecode-tools
-        ln -s ${self.rhodecode-tools}/bin/rhodecode-* $out/bin/
-
-        # note that condition should be restricted when adding further tools
         for file in $out/bin/*;
         do
           wrapProgram $file \
-              --prefix PATH : $PATH \
-              --prefix PYTHONPATH : $PYTHONPATH \
-              --set PYTHONHASHSEED random
+            --prefix PATH : $PATH \
+            --prefix PYTHONPATH : $PYTHONPATH \
+            --set PYTHONHASHSEED random
         done
 
-        mkdir $out/etc
-        cp configs/production.ini $out/etc
+        echo "[DONE]: enterprise-ce binary wrapping"
 
-
-        # TODO: johbo: Make part of ac-tests
         if [ ! -f rhodecode/public/js/scripts.js ]; then
           echo "Missing scripts.js"
           exit 1
         fi
         if [ ! -f rhodecode/public/css/style.css ]; then
           echo "Missing style.css"
           exit 1
         fi
       '';
-
     });
 
-    rhodecode-testdata = import "${rhodecode-testdata-src}/default.nix" {
-    inherit
-      doCheck
-      pkgs
-      pythonPackages;
-    };
-
   };
 
-  rhodecode-testdata-src = sources.rhodecode-testdata or (
-    pkgs.fetchhg {
-      url = "https://code.rhodecode.com/upstream/rc_testdata";
-      rev = "v0.10.0";
-      sha256 = "0zn9swwvx4vgw4qn8q3ri26vvzgrxn15x6xnjrysi1bwmz01qjl0";
-  });
+  basePythonPackages = with builtins;
+    if isAttrs pythonPackages then
+      pythonPackages
+    else
+      getAttr pythonPackages pkgs;
+
+  pythonGeneratedPackages = import ./pkgs/python-packages.nix {
+    inherit pkgs;
+    inherit (pkgs) fetchurl fetchgit fetchhg;
+  };
+
+  pythonCommunityOverrides = import ./pkgs/python-packages-overrides.nix {
+    inherit pkgs basePythonPackages;
+  };
 
   # Apply all overrides and fix the final package set
   myPythonPackagesUnfix = with pkgs.lib;
     (extends pythonExternalOverrides
     (extends pythonLocalOverrides
-    (extends pythonOverrides
-             pythonGeneratedPackages)));
+    (extends pythonCommunityOverrides
+    (extends pythonGeneratedPackages
+             basePythonPackagesUnfix))));
+
   myPythonPackages = (pkgs.lib.fix myPythonPackagesUnfix);
 
 in myPythonPackages.rhodecode-enterprise-ce

docs/contributing/dev-setup.rst

@@ -1,226 +1,226
 .. _dev-setup:
 
 ===================
  Development setup
 ===================
 
 
 RhodeCode Enterprise runs inside a Nix managed environment. This ensures build
 environment dependencies are correctly declared and installed during setup.
 It also enables atomic upgrades, rollbacks, and multiple instances of RhodeCode
 Enterprise running with isolation.
 
 To set up RhodeCode Enterprise inside the Nix environment, use the following steps:
 
 
 
 Setup Nix Package Manager
 -------------------------
 
 To install the Nix Package Manager, please run::
 
    $ curl https://nixos.org/nix/install | sh
 
 or go to https://nixos.org/nix/ and follow the installation instructions.
 Once this is correctly set up on your system, you should be able to use the
 following commands:
 
 * `nix-env`
 
 * `nix-shell`
 
 
 .. tip::
 
    Update your channels frequently by running ``nix-channel --update``.
 
 .. note::
 
    To uninstall nix run the following:
 
     remove the . "$HOME/.nix-profile/etc/profile.d/nix.sh" line in your ~/.profile or ~/.bash_profile
     rm -rf $HOME/{.nix-channels,.nix-defexpr,.nix-profile,.config/nixpkgs}
     sudo rm -rf /nix
 
 Switch nix to the latest STABLE channel
 ---------------------------------------
 
 run::
 
-   nix-channel --add https://nixos.org/channels/nixos-16.03 nixpkgs
+   nix-channel --add https://nixos.org/channels/nixos-18.03 nixpkgs
 
 Followed by::
 
    nix-channel --update
 
 
 Install required binaries
 -------------------------
 
 We need some handy tools first.
 
 run::
 
     nix-env -i nix-prefetch-hg
     nix-env -i nix-prefetch-git
 
 
 Clone the required repositories
 -------------------------------
 
 After Nix is set up, clone the RhodeCode Enterprise Community Edition and
 RhodeCode VCSServer repositories into the same directory.
 RhodeCode currently is using Mercurial Version Control System, please make sure
 you have it installed before continuing.
 
 To obtain the required sources, use the following commands::
 
     mkdir rhodecode-develop && cd rhodecode-develop
     hg clone https://code.rhodecode.com/rhodecode-enterprise-ce
     hg clone https://code.rhodecode.com/rhodecode-vcsserver
 
 .. note::
 
    If you cannot clone the repository, please contact us via [e-mail]
 
 
 Install some required libraries
 -------------------------------
 
 There are some required drivers and dev libraries that we need to install to
 test RhodeCode under different types of databases. For example in Ubuntu we
 need to install the following.
 
 required libraries::
 
     sudo apt-get install libapr1-dev libaprutil1-dev
     sudo apt-get install libsvn-dev
     sudo apt-get install mysql-server libmysqlclient-dev
     sudo apt-get install postgresql postgresql-contrib libpq-dev
     sudo apt-get install libcurl4-openssl-dev
 
 
 Enter the Development Shell
 ---------------------------
 
 The final step is to start the development shells. To do this, run the
 following command from inside the cloned repository::
 
    #first, the vcsserver
    cd ~/rhodecode-vcsserver
    nix-shell
 
    # then enterprise sources
    cd ~/rhodecode-enterprise-ce
    nix-shell
 
 .. note::
 
    On the first run, this will take a while to download and optionally compile
    a few things. The following runs will be faster. The development shell works
    fine on both MacOS and Linux platforms.
 
 
 Create config.nix for development
 ---------------------------------
 
 In order to run proper tests and setup linking across projects, a config.nix
 file needs to be setup::
 
     # create config
     mkdir -p ~/.nixpkgs
     touch ~/.nixpkgs/config.nix
 
     # put the below content into the ~/.nixpkgs/config.nix file
     # adjusts, the path to where you cloned your repositories.
 
     {
       rc = {
        sources = {
         rhodecode-vcsserver = "/home/dev/rhodecode-vcsserver";
         rhodecode-enterprise-ce = "/home/dev/rhodecode-enterprise-ce";
         rhodecode-enterprise-ee = "/home/dev/rhodecode-enterprise-ee";
        };
       };
     }
 
 
 
 Creating a Development Configuration
 ------------------------------------
 
 To create a development environment for RhodeCode Enterprise,
 use the following steps:
 
 1. Create a copy of vcsserver config:
     `cp ~/rhodecode-vcsserver/configs/development.ini ~/rhodecode-vcsserver/configs/dev.ini`
 2. Create a copy of rhodocode config:
     `cp ~/rhodecode-enterprise-ce/configs/development.ini ~/rhodecode-enterprise-ce/configs/dev.ini`
 3. Adjust the configuration settings to your needs if needed.
 
 .. note::
 
   It is recommended to use the name `dev.ini` since it's included in .hgignore file.
 
 
 Setup the Development Database
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 To create a development database, use the following example. This is a one
 time operation executed from the nix-shell of rhodecode-enterprise-ce sources ::
 
     rc-setup-app dev.ini \
         --user=admin --password=secret \
         --email=[e-mail] \
         --repos=~/my_dev_repos
 
 
 Compile CSS and JavaScript
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 To use the application's frontend and prepare it for production deployment,
 you will need to compile the CSS and JavaScript with Grunt.
 This is easily done from within the nix-shell using the following command::
 
     grunt
 
 When developing new features you will need to recompile following any
 changes made to the CSS or JavaScript files when developing the code::
 
     grunt watch
 
 This prepares the development (with comments/whitespace) versions of files.
 
 Start the Development Servers
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 From the rhodecode-vcsserver directory, start the development server in another
 nix-shell, using the following command::
 
       pserve configs/dev.ini
 
 In the adjacent nix-shell which you created for your development server, you may
 now start CE with the following command::
 
 
       pserve --reload configs/dev.ini
 
 .. note::
 
   `--reload` flag will automatically reload the server when source file changes.
 
 
 Run the Environment Tests
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Please make sure that the tests are passing to verify that your environment is
 set up correctly. RhodeCode uses py.test to run tests.
 While your instance is running, start a new nix-shell and simply run
 ``make test`` to run the basic test suite.
 
 
 Need Help?
 ^^^^^^^^^^
 
 Join us on Slack via https://rhodecode.com/join or post questions in our
 Community Portal at https://community.rhodecode.com

package.json

@@ -1,25 +1,32
 {
   "name": "rhodecode-enterprise",
-  "version": "0.0.1",
+  "version": "1.0.0",
+  "private": true,
+  "description" : "RhodeCode JS packaged",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "repository" : {
+    "type" : "hg",
+    "url" : "https://code.rhodecode.com/rhodecode-enterprise-ce"
+  },
   "devDependencies": {
     "grunt": "^0.4.5",
     "grunt-contrib-copy": "^1.0.0",
     "grunt-contrib-concat": "^0.5.1",