front-end: Introduce 'front-end' directory with source files for building the front-end

The top level with package.json is not included when installing with pip, and
'kallithea-cli front-end-build' and npm would thus fail.

Instead, introduce 'kallithea/front-end/'. It is under 'kallithea/' and is thus
included when doing pip install, but it is just a source directory and not
under "public". Most of the "less" stuff should probably move there. And
probably also most things that now are checked in under "public", so a fully
populated public front-end directory can be built anywhere, without write
access to the Python installation directory.

.hgignore

@@ -1,36 +1,37 b''
 syntax: glob
 *.pyc
 *.swp
 *.sqlite
 *.tox
 *.egg-info
 *.egg
 *.mo
 .eggs/
 tarballcache/
-node_modules/
 
 syntax: regexp
 ^rcextensions
 ^build
 ^dist/
 ^docs/build/
 ^docs/_build/
 ^data$
 ^sql_dumps/
 ^\.settings$
 ^\.project$
 ^\.pydevproject$
 ^\.coverage$
+^kallithea/front-end/node_modules$
+^kallithea/front-end/package-lock\.json$
 ^kallithea/public/css/style\.css(\.map)?$
 ^kallithea/public/css/pygments.css$
 ^theme\.less$
 ^kallithea\.db$
 ^test\.db$
 ^Kallithea\.egg-info$
 ^my\.ini$
 ^fabfile.py
 ^\.idea$
 ^\.cache$
 ^\.pytest_cache$
 /__pycache__$

MANIFEST.in

@@ -1,29 +1,29 b''
 include           .coveragerc
 include           Apache-License-2.0.txt
 include           CONTRIBUTORS
 include           COPYING
 include           Jenkinsfile
 include           LICENSE-MERGELY.html
 include           LICENSE.md
 include           MIT-Permissive-License.txt
 include           README.rst
 include           dev_requirements.txt
 include           development.ini
 include           pytest.ini
 include           requirements.txt
 include           tox.ini
-include           package.json
 recursive-include docs *
 recursive-include init.d *
 recursive-include kallithea/alembic *
 include           kallithea/bin/ldap_sync.conf
 include           kallithea/lib/paster_commands/template.ini.mako
+recursive-include kallithea/front-end *
 recursive-include kallithea/i18n *
 recursive-include kallithea/public *
 recursive-include kallithea/templates *
 recursive-include kallithea/tests/fixtures *
 recursive-include kallithea/tests/scripts *
 include           kallithea/tests/models/test_dump_html_mails.ref.html
 include           kallithea/tests/performance/test_vcs.py
 include           kallithea/tests/vcs/aconfig
 recursive-include scripts *

kallithea/bin/kallithea_cli_front_end.py

@@ -1,56 +1,58 b''
 # -*- coding: utf-8 -*-
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import click
 import kallithea.bin.kallithea_cli_base as cli_base
 
 import os
 import subprocess
 
 import kallithea
 
 @cli_base.register_command()
 @click.option('--install-deps/--no-install-deps', default=True,
         help='Skip installation of dependencies, via "npm".')
 @click.option('--generate/--no-generate', default=True,
         help='Skip generation of front-end files.')
 def front_end_build(install_deps, generate):
     """Build the front-end.
 
     Install required dependencies for the front-end and generate the necessary
     files.  This step is complementary to any 'pip install' step which only
     covers Python dependencies.
 
     The installation of front-end dependencies happens via the tool 'npm' which
     is expected to be installed already.
     """
-    rootdir = os.path.dirname(os.path.dirname(os.path.abspath(kallithea.__file__)))
+    front_end_dir = os.path.abspath(os.path.join(kallithea.__file__, '..', 'front-end'))
+    public_dir = os.path.abspath(os.path.join(kallithea.__file__, '..', 'public'))
 
     if install_deps:
         click.echo("Running 'npm install' to install front-end dependencies from package.json")
-        subprocess.check_call(['npm', 'install'], cwd=rootdir)
+        subprocess.check_call(['npm', 'install'], cwd=front_end_dir)
 
     if generate:
         click.echo("Generating CSS")
-        with open(os.path.join(rootdir, 'kallithea', 'public', 'css', 'pygments.css'), 'w') as f:
+        with open(os.path.join(public_dir, 'pygments.css'), 'w') as f:
             subprocess.check_call(['pygmentize',
                     '-S', 'default',
                     '-f', 'html',
                     '-a', '.code-highlight'],
                     stdout=f)
-        lesscpath = os.path.join(rootdir, 'node_modules', '.bin', 'lessc')
-        lesspath = os.path.join(rootdir, 'kallithea', 'public', 'less', 'main.less')
-        csspath = os.path.join(rootdir, 'kallithea', 'public', 'css', 'style.css')
+        lesscpath = os.path.join(front_end_dir, 'node_modules', '.bin', 'lessc')
+        lesspath = os.path.join(public_dir, 'less', 'main.less')
+        csspath = os.path.join(public_dir, 'css', 'style.css')
         subprocess.check_call([lesscpath, '--relative-urls', '--source-map',
-                '--source-map-less-inline', lesspath, csspath])
+                '--source-map-less-inline', lesspath, csspath],
+                cwd=front_end_dir)