dk-tasklib 3.0.9__py3-none-any.whl

dktasklib/jstools.py

@@ -0,0 +1,320 @@
+import os
+import textwrap
+
+from dktasklib.wintask import task
+from invoke import Collection
+from dktasklib import runners
+from dktasklib.commands import Command
+from dktasklib.executables import requires
+from dktasklib.utils import cd, switch_extension
+from dktasklib.version import copy_to_version
+
+
+def ensure_package_json(ctx):
+    """Is this a node package?
+    """
+    package_json = os.path.join(ctx.pkg.root, 'package.json')
+    if not os.path.exists(package_json):
+        print("Missing package.json file, creating default version..")
+        with cd(ctx.pkg.root):
+            ctx.run("npm init -f")
+    else:
+        return True
+
+
+def ensure_babelrc(ctx):
+    """babel needs a .babelrc file to do any work.
+    """
+    babelrc = os.path.join(ctx.pkg.root, '.babelrc')
+    if not os.path.exists(babelrc):
+        print('Misssing %s (creating default version)' % babelrc)
+        with open(babelrc, 'w') as fp:
+            fp.write(textwrap.dedent("""
+            {
+              "presets": [
+                ["env", {
+                  "targets": {
+                    "browsers": [
+                      "last 2 versions",
+                      "IE >= 11"
+                    ],
+                    "useBuiltIns": true,
+                    "node": "current"
+                  }
+                }]
+              ],
+              "ignore": [
+                "node_modules"
+              ]
+            }
+            """))
+    else:
+        return True
+
+
+def ensure_node_modules(ctx):
+    """Has node init been called? (if not call it).
+    """
+    node_modules = os.path.join(ctx.pkg.root, 'node_modules')
+    if not os.path.exists(node_modules):
+        with cd(ctx.pkg.root):
+            ctx.run("npm install --no-color")
+    else:
+        return True
+
+
+def ensure_es2015(ctx):
+    if 'babel-preset-es2015' not in runners.run("npm ls --depth=0 babel-preset-es2015 --no-color"):
+        print("didn't find babel-preset-es2015, installing it..")
+        with cd(ctx.pkg.root):
+            ctx.run("npm install babel-preset-es2015 --save-dev")
+    else:
+        return True
+
+
+def ensure_preset_es2016(ctx):
+    if 'babel-preset-es2015' not in runners.run("npm ls --depth=0 babel-preset-es2016 --no-color"):
+        print("didn't find babel-preset-es2016, installing it..")
+        with cd(ctx.pkg.root):
+            ctx.run("npm install babel-preset-es2016 --save-dev")
+    else:
+        return True
+
+
+def ensure_preset_es2017(ctx):
+    if 'babel-preset-es2017' not in runners.run("npm ls --depth=0 babel-preset-es2017 --no-color"):
+        print("didn't find babel-preset-es2017, installing it..")
+        with cd(ctx.pkg.root):
+            ctx.run("npm install babel-preset-es2017 --save-dev")
+    else:
+        return True
+
+
+def ensure_preset_latest(ctx):
+    if 'babel-preset-env' not in runners.run("npm ls --depth=0 babel-preset-env --no-color"):
+        print("didn't find babel-preset-env, installing it..")
+        with cd(ctx.pkg.root):
+            ctx.run("npm install babel-preset-env --save-dev")
+    else:
+        return True
+
+
+def ensure_preset_babili(ctx):
+    if 'babel-preset-babili' not in runners.run("npm ls --depth=0 babel-preset-babili --no-color"):
+        print("didn't find babel-preset-babili, installing it..")
+        with cd(ctx.pkg.root):
+            ctx.run("npm install babel-preset-babili --save-dev")
+    else:
+        return True
+
+
+def ensure_babelify(ctx):
+    if 'babelify' not in runners.run("npm ls --depth=0 babelify --no-color"):
+        print("didn't find babelify, installing it..")
+        with cd(ctx.pkg.root):
+            ctx.run("npm install --save-dev babelify --no-color", echo=False, encoding='utf-8')
+    else:
+        return True
+
+
+def ensure_babel_minify(ctx):
+    nodepkgs = runners.run("npm ls --depth=0 babelify --no-color")
+    if 'babel-minify' not in nodepkgs and 'minify' not in nodepkgs:
+        print("didn't find babelify, installing it..")
+        with cd(ctx.pkg.root):
+            ctx.run("npm install --save-dev babelify --no-color", echo=False, encoding='utf-8')
+    else:
+        return True
+
+
+def version_js(ctx, fname, kind='pkg', force=False):
+    """Add version number to a .js file.
+    """
+    dst = copy_to_version(
+        ctx,
+        fname,
+        kind=kind,
+        force=force
+    )
+    return dst
+
+
+@requires('nodejs', 'npm', 'browserify')
+@task
+def browserify(ctx,
+               source, dest,
+               babelify=False,
+               require=(),
+               external=(),
+               entry=None):
+    """
+    Run ``browserify``
+
+    Args:
+        ctx (pyinvoke.Context):  context
+        source (str):            root source file
+        dest (str):              path/name of assembled file
+        babelify (Bool):         use babel transform
+        require (iterable):      A module name or file to bundle.require()
+                                 Optionally use a colon separator to set the target.
+        external:                Reference a file from another bundle. Files can be globs.
+        entry:
+
+    Returns:
+        None
+
+    """
+    print('ensure package.json:', ensure_package_json(ctx))
+    print('ensure node_modules:', ensure_node_modules(ctx))
+
+    options = ""  # no source maps
+    if babelify:
+        print('ensure babelify:', ensure_babelify(ctx))
+        print('ensure preset latest:', ensure_preset_latest(ctx))
+        options += ' -t babelify'
+        options += ' --presets env'
+    for r in require:
+        options += ' -r "%s"' % r
+    for e in external:
+        options += ' -x "%s"' % e
+    if entry:
+        options += ' -e "%s"' % entry
+    cmd = "browserify {source} -o {dest} {options}".format(**locals())
+    ctx.run(cmd)
+    with open(dest, 'rb') as fp:
+        txt = fp.read()
+    if b'\r\n' in txt:
+        with open(dest, 'wb') as fp:
+            fp.write(txt.replace(b'\r\n', b'\n'))
+    return dest
+
+
+babilicmd = Command('babili', '{src} {opts} -o {dst}',
+                    requirements=('nodejs', 'npm', 'babili'))
+
+
+@requires('nodejs', 'npm', 'babili')
+@task
+def babili(ctx, src, dst):
+    babilicmd(
+        ctx,
+        src=src,
+        dst=dst,
+    )
+    return dst
+
+
+# babel-minify is linked to minify
+babel_minifycmd = Command('babel-minify', '{src} {opts} -o {dst}',
+                          requirements=('nodejs', 'npm', 'babel-minify'))
+
+
+@requires('nodejs', 'npm', 'babel-minify')
+@task
+def babel_minify(ctx, src, dst):
+    """
+    dkjs/node_modules/.bin> babel-minify --help
+
+      Usage: minify index.js [options]
+
+      IO Options:
+        --out-file, -o          Output to a specific file
+        --out-dir, -d           Output to a specific directory
+
+      Transform Options:
+        --mangle                Context and scope aware variable renaming
+        --simplify              Simplifies code for minification by reducing statements into
+                                expressions
+        --booleans              Transform boolean literals into !0 for true and !1 for false
+        --builtIns              Minify standard built-in objects
+        --consecutiveAdds       Inlines consecutive property assignments, array pushes, etc.
+        --deadcode              Inlines bindings and tries to evaluate expressions.
+        --evaluate              Tries to evaluate expressions and inline the result. Deals
+                                with numbers and strings
+        --flipComparisons       Optimize code for repetition-based compression algorithms
+                                such as gzip.
+        --infinity              Minify Infinity to 1/0
+        --memberExpressions     Convert valid member expression property literals into plain
+                                identifiers
+        --mergeVars             Merge sibling variables into single variable declaration
+        --numericLiterals       Shortening of numeric literals via scientific notation
+        --propertyLiterals      Transform valid identifier property key literals into identifiers
+        --regexpConstructors    Change RegExp constructors into literals
+        --removeConsole         Removes all console.* calls
+        --removeDebugger        Removes all debugger statements
+        --removeUndefined       Removes rval's for variable assignments, return arguments from
+                                functions that evaluate to undefined
+        --replace               Replaces matching nodes in the tree with a given replacement node
+        --simplifyComparisons   Convert === and !== to == and != if their types are inferred
+                                to be the same
+        --typeConstructors      Minify constructors to equivalent version
+        --undefinedToVoid       Transforms undefined into void 0
+
+      Other Options:
+        --keepFnName            Preserve Function Name (useful for code depending on fn.name)
+        --keepClassName         Preserve Class Name (useful for code depending on c.name)
+        --keepFnArgs            Don't remove unused fn arguments (useful for code depending on fn.length)
+        --tdz                   Detect usages of variables in the Temporal Dead Zone
+
+      Nested Options:
+        To use nested options (plugin specfic options) simply use the pattern
+        --pluginName.featureName.
+
+        For example,
+        minify index.js --mangle.keepClassName --deadcode.keepFnArgs --outFile index.min.js
+    """
+
+    babel_minifycmd(
+        ctx,
+        src=src,
+        dst=dst,
+        keepFnName=True,
+        keepClassName=True,
+        mangle=False,
+        simplify=False,
+        builtIns=True,
+        deadcode=False,
+        evaluate=False
+    )
+    return dst
+
+
+uglifycmd = Command('uglifyjs', '{src} {opts} -o {dst}',
+                    requirements=('nodejs', 'npm', 'uglify'))
+
+
+@requires('nodejs', 'npm', 'uglify')
+@task
+def uglifyjs(ctx,
+             src, dst,
+             compress=True, mangle=True):
+    uglifycmd(
+        ctx,
+        src=src,
+        dst=dst,
+        compress=compress,
+        mangle=mangle
+    )
+    return dst
+
+
+@task(default=True)
+def buildjs(ctx, src, dst, force=False, **kw):
+    uglify = kw.pop('uglify', False)
+    if kw.pop('browserify', False):
+        dst = browserify(ctx, src, dst,
+                         babelify=kw.pop('babelify', src.endswith('.jsx')), **kw)
+
+    if uglify:
+        finaldst = switch_extension(dst, '.min.js')
+        dst = uglifyjs(ctx, dst, finaldst)
+        if force:
+            dst = copy_to_version(ctx, dst, force=force)
+
+    return dst
+
+
+ns = Collection(browserify, uglifyjs)
+ns.configure({
+    'static': 'static/{pkg.name}'
+})

dktasklib/lessc.py

@@ -0,0 +1,111 @@
+import os
+from dktasklib.wintask import task
+from .rule import BuildRule
+from .commands import Command
+from dkfileutils.changed import Directory
+from dkfileutils.path import Path
+from invoke import Collection
+from . import urlinliner
+from .concat import copy
+from .environment import env
+from .utils import fmt, switch_extension, message
+from .version import get_version
+from .upversion import UpdateTemplateVersion
+
+lessc = Command('lessc', '{opts} {src} {dst}',
+                requirements=('nodejs', 'npm', 'lessc'))
+
+
+BOOTSTRAP = Path(os.environ.get('SRV', '')) / 'ext' / 'bootstrap' / 'less'
+
+
+@task(
+    default=True,
+    name='build_less',
+    help={
+        'version': "one of pkg|hash|svn",
+    }
+)
+class LessRule(BuildRule):
+    """Build a ``.less`` file into a versioned and minified ``.css`` file.
+    """
+
+    bootstrap_src = BOOTSTRAP
+
+    def __init__(self, *args, **kw):
+        self.after = [UpdateTemplateVersion(
+            kw.pop('import_fname',
+                   '{pkg.source}/templates/{pkg.name}/{pkg.name}-css.html')
+        )]
+        super(LessRule.body, self).__init__(*args, **kw)
+
+    def __call__(self,
+                 src='{pkg.source}/less/{pkg.name}.less',
+                 dst='{pkg.source}/static/{pkg.name}/css/{pkg.name}-{version}.min.css',
+                 version='pkg',
+                 bootstrap=True,
+                 force=False,
+                 **kw):
+        c = env(self.ctx)
+        source = Path(fmt(src, c))
+        dest = Path(fmt(dst, c))
+
+        if not source.exists():
+            print("Missing source:", source, '(skipping)')
+            return
+
+        for fname in source.dirname().glob("*.inline"):
+            urlinliner.inline(self.ctx, fname)
+
+        if not force and not Directory(source.dirname()).changed(glob='**/*.less'):
+            print("No changes: {input_dir}/{glob}, add --force to build.".format(
+                input_dir=source.dirname(), glob='**/*.less'))
+            return
+
+        path = kw.pop('path', [])
+        if bootstrap:
+            path.append(self.bootstrap_src)
+
+        cssname = dest.relpath().format(version=get_version(self.ctx, source, version))
+        lessc(
+            self.ctx,
+            src=source.relpath(),
+            dst=cssname,
+            include_path=path,
+            strict_imports=True,
+            inline_urls=False,
+            autoprefix="last 4 versions",
+            clean_css="-b --s0",
+        )
+
+        with message("Creating copy without version number.."):
+            copy(  # create a copy without version number too..
+                self.ctx,
+                cssname,
+                Path(cssname).dirname() / switch_extension(source.basename(), '.css'),
+                force=True
+            )
+        return cssname
+
+
+ns = Collection('lessc', LessRule)
+ns.configure({
+    'force': False,
+    'pkg': {
+        'root': '<package-root-directory>',
+        'name': '<package-name>',
+        'source': '<source-dir>',
+        'version': '<version-string>',
+    },
+    'bootstrap': {
+        'src': os.path.join(os.environ.get('BOOTSTRAPSRC', ''), 'less'),
+    },
+    'lessc': {
+        'use_bootstrap': False,
+        'build_dir': 'build/css',
+        'input_dir': '{pkg.source}/less',
+        'input_fname': '{pkg.name}.less',
+        'output_dir': '{pkg.source}/static/{pkg.name}/css/',
+        'output_fname': '{pkg.name}.css',
+    }
+})

dktasklib/manage.py

@@ -0,0 +1,71 @@
+import sys
+import os
+
+from dkfileutils.path import Path
+from dkfileutils.pfind import pfind
+from dkfileutils.changed import changed, Directory
+from dktasklib.wintask import task
+from invoke import run
+from .utils import cd, env, find_pymodule
+from .package import Package
+
+
+DEFAULT_SETTINGS_MODULE = 'settings'
+
+
+@task
+def manage(ctx, cmd, settings=None, manage_path=None, venv=None):
+    """Run manage.py with `settings` in a separate process.
+    """
+    settings = settings or DEFAULT_SETTINGS_MODULE
+    with env(DJANGO_SETTINGS_MODULE=settings, PYTHONWARNINGS='ignore'):
+        if manage_path is None:
+            settings_dir = find_pymodule(settings)
+            manage_path = Path(pfind(settings_dir, 'manage.py')).dirname()
+
+        with cd(manage_path):
+            call = "python manage.py {cmd}"
+            if venv:
+                call = "vex {venv} python manage.py {cmd} --traceback"
+
+            run(call.format(venv=venv, cmd=cmd))
+
+
+@task
+def collectstatic(ctx, settings=None, venv=None, clobber=False, force=False):
+    "Run collectstatic with settings from package.json ('django_settings_module')"
+    if not hasattr(ctx, 'pkg'):
+        ctx.pkg = Package()
+
+    if not (force or Directory(ctx.pkg.django_static).changed()):
+        print("Skipping collectstic: no changes to static dir.")
+        return
+
+    if not clobber:
+        # check that we don't overwrite versioned resources
+        changed_versioned_resources = False
+        static = Path(os.environ['SRV']) / 'data' / 'static'
+        for fname in ctx.pkg.django_static.glob(r'**/*\d+.min.*'):
+            pubname = static / fname.relpath(ctx.pkg.django_static)
+            if pubname.exists():
+                if pubname.open('rb').read() != fname.open('rb').read():
+                    changed_versioned_resources = True
+                    print()
+                    print("ERROR: versioned file has changes:")
+                    print("  contents of:      ", fname)
+                    print("  is different from:", pubname)
+                    print()
+        if changed_versioned_resources:
+            print("Exiting due to changes in versioned resources. "
+                  "You should probably revert the changes and create "
+                  "a new version.")
+            sys.exit(1)
+
+    try:
+        settings = settings or ctx.pkg.django_settings_module
+    except AttributeError:
+        settings = DEFAULT_SETTINGS_MODULE
+    print("using settings:", settings, 'venv:', venv)
+    manage(ctx, "collectstatic --noinput", settings=settings, venv=venv)
+    # record changes made by collectstatic
+    changed(ctx.pkg.django_static)

dktasklib/npm.py

@@ -0,0 +1,19 @@
+import subprocess
+
+from dktasklib.executables import exe
+
+
+def npm(cmdline):
+    npm_exe = exe.find('npm', requires=['nodejs'])      # noqa
+    return subprocess.check_output("npm " + cmdline, shell=True).decode('u8')
+
+
+def global_package(pkgname):
+    """Check if an npm package is installed globally.
+    """
+    try:
+        # this is the 'correct' way, but it's increadably slow (4+ secs)
+        npm('ls -g --depth 0 ' + pkgname)
+        return True
+    except subprocess.CalledProcessError:
+        return False

dktasklib/package/__init__.py

@@ -0,0 +1,31 @@
+from dktasklib.wintask import task
+from .package_interface import Package
+from ..utils import format_table, Column
+
+
+@task
+def package(ctx):
+    """Print detected package directories.
+    """
+    pkg = ctx.pkg if hasattr(ctx, 'pkg') else Package()
+
+    def row(attribute, value, description=''):
+        return dict(attribute=attribute, value=value, description=description)
+
+    print("The dk-tasklib Package object thinks your code has the following layout:")
+
+    print(format_table(
+        [
+            row('package_name', pkg.package_name, '(repo/pip-installable name)'),
+            row('name', pkg.name, '(importable name)'),
+            row('root', pkg.root, '(wc)'),
+            row('source', pkg.source, '(source directory)'),
+            row('source_js', pkg.source_js, '(js source directory)'),
+            row('source_less', pkg.source_less, '(less source directory)'),
+            row('docs', pkg.docs, '(docs directory)'),
+            row('django?', 'yes' if pkg.is_django() else 'no', '(django?)'),
+        ],
+        Column(field='attribute'),
+        Column(field='value'),
+        Column(field='description'),
+    ))

dktasklib/package/package_interface.py

@@ -0,0 +1,103 @@
+import json
+from configparser import RawConfigParser
+
+import invoke
+from dkfileutils.pfind import pfind as _pfind
+from dkfileutils.path import Path
+# from dkfileutils.changed import Directory
+from invoke.config import Config
+from dkpkg import Package as DKPKGPackage
+
+
+def pfind(path, *fnames):
+    res = _pfind(path, *fnames)
+    return Path(res) if res is not None else None
+
+
+class Package(DKPKGPackage):
+    overridables = DKPKGPackage.KEYS | {'version'}
+
+    def overrides(self, **res):
+        setup_py = pfind('.', 'setup.py')
+        if setup_py:
+            root = setup_py.dirname()
+            with root.abspath().cd():
+                res['version'] = self.ctx.run(
+                    'python setup.py --version',
+                    hide=True
+                ).stdout.strip()
+
+        res.update(self._read_dkbuild_ini())
+
+        package_json = pfind('.', 'package.json')
+        if package_json:
+            with open(package_json, 'r') as fp:
+                pj = json.load(fp)
+                for k, v in pj.items():
+                    if k in Package.overridables:
+                        res[k] = v
+
+        return res
+
+    def _read_dkbuild_ini(self):
+        dkbuild_ini = pfind('.', 'dkbuild.ini')
+        if not dkbuild_ini:
+            return {}
+        cp = RawConfigParser()
+        cp.read(dkbuild_ini)
+        return dict((k, v) for k, v in cp.items('dkbuild')
+                    if k in Package.overridables)
+
+    def __init__(self, ctx=None):
+        self.ctx = ctx or invoke.Context()
+        pkgdir = pfind('.',
+                       'setup.py',
+                       'dkbuild.ini',
+                       'package.json')
+        if pkgdir is None:
+            raise IOError("Didn't find setup.py|dkbuild.ini|package.json in "
+                          "any parent directory up to, and including root.")
+        root = pkgdir.dirname()
+        ispkg = 'setup.py' in root
+        overrides = self.overrides() if ispkg else self.overrides(source=root)
+        super().__init__(root, **overrides)
+
+    def vcs(self):
+        """Return the name of the version control system handling this package.
+        """
+        if (self.root / '.svn').exists():
+            return 'svn'
+        elif (self.root / '.git').exists():
+            return 'git'
+        elif (self.root / '.hg').exists():
+            return 'hg'
+        else:
+            return ''
+
+    # invoke'ism?
+    def config(self):  # pragma: nocover
+        cfg = Config(dict(iter(self)))
+        cfg.name = self.name
+        cfg.root = self.root
+        cfg.source = self.source
+        cfg.docs = self.docs
+        cfg.django_static = self.django_static
+        return cfg
+
+    def __repr__(self):
+        return self.__class__.__name__
+
+    def __getitem__(self, key):
+        try:
+            return getattr(self, key)
+        except AttributeError as e:
+            raise KeyError(str(e))
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def __iter__(self):
+        return iter([])