How to use jsmin - 10 common examples

def load_json(string):
    return json.loads(jsmin.jsmin(string))

# upload ui html to target
        ssh.copy(html_local, html_target)

        # upload assets to the dataset
        webresources_local = opj(webui_local, 'assets')
        webresources_remote = opj(path, WEB_HTML_DIR)
        ssh('mkdir -p {}'.format(sh_quote(webresources_remote)))
        ssh.copy(webresources_local, webresources_remote, recursive=True)

        # minimize and upload js assets
        for js_file in glob(opj(webresources_local, 'js', '*.js')):
            with open(js_file) as asset:
                try:
                    from jsmin import jsmin
                    # jsmin = lambda x: x   # no minimization
                    minified = jsmin(asset.read())                      # minify asset
                except ImportError:
                    lgr.warning(
                        "Will not minify web interface javascript, no jsmin available")
                    minified = asset.read()                             # no minify available
                with make_tempfile(content=minified) as tempf:          # write minified to tempfile
                    js_name = js_file.split('/')[-1]
                    ssh.copy(tempf, opj(webresources_remote, 'assets', 'js', js_name))  # and upload js

        # explicitly make web+metadata dir of dataset world-readable, if shared set to 'all'
        mode = None
        if shared in (True, 'true', 'all', 'world', 'everybody'):
            mode = 'a+rX'
        elif shared == 'group':
            mode = 'g+rX'
        elif str(shared).startswith('0'):
            mode = shared

def JS2C(source, target, env):
  ids = []
  debugger_ids = []
  modules = []
  # Locate the macros file name.
  consts = []
  macros = []
  for s in source:
    if 'macros.py' == (os.path.split(str(s))[1]):
      (consts, macros) = ReadMacros(ReadLines(str(s)))
    else:
      modules.append(s)

  minifier = jsmin.JavaScriptMinifier()

  module_offset = 0
  all_sources = []
  for module in modules:
    filename = str(module)
    debugger = filename.endswith('-debugger.js')
    lines = ReadFile(filename)
    lines = ExpandConstants(lines, consts)
    lines = ExpandMacros(lines, macros)
    Validate(lines, filename)
    lines = minifier.JSMinify(lines)
    id = (os.path.split(filename)[1])[:-3]
    if debugger: id = id[:-9]
    raw_length = len(lines)
    if debugger:
      debugger_ids.append((id, raw_length, module_offset))

def JS2C(source, target, env):
  ids = []
  debugger_ids = []
  modules = []
  # Locate the macros file name.
  consts = []
  macros = []
  for s in source:
    if 'macros.py' == (os.path.split(str(s))[1]):
      (consts, macros) = ReadMacros(ReadLines(str(s)))
    else:
      modules.append(s)

  minifier = jsmin.JavaScriptMinifier()

  module_offset = 0
  all_sources = []
  for module in modules:
    filename = str(module)
    debugger = filename.endswith('-debugger.js')
    lines = ReadFile(filename)
    lines = ExpandConstants(lines, consts)
    lines = ExpandMacros(lines, macros)
    lines = RemoveCommentsAndTrailingWhitespace(lines)
    lines = ExpandInlineMacros(lines, filename)
    Validate(lines, filename)
    lines = minifier.JSMinify(lines)
    id = (os.path.split(filename)[1])[:-3]
    if debugger: id = id[:-9]
    raw_length = len(lines)

parser.print_usage()
        exit(-1)

    namespace = options.namespace
    headerPath = arguments[0]
    sourcePath = arguments[1]
    inputPaths = arguments[2:]

    headerFile = open(headerPath, 'w')
    print('namespace {0:s} {{'.format(namespace), file=headerFile)

    sourceFile = open(sourcePath, 'w')
    print('#include "{0:s}"'.format(os.path.basename(headerPath)), file=sourceFile)
    print('namespace {0:s} {{'.format(namespace), file=sourceFile)

    jsm = JavascriptMinify()

    for inputFileName in inputPaths:
        inputStream = io.FileIO(inputFileName)
        outputStream = StringIO()

        if not options.no_minify:
            jsm.minify(inputStream, outputStream)
            characters = outputStream.getvalue()
        else:
            characters = inputStream.read()

        size = len(characters)
        variableName = os.path.splitext(os.path.basename(inputFileName))[0]

        print('extern const char {0:s}JavaScript[{1:d}];'.format(variableName, size), file=headerFile)
        print('const char {0:s}JavaScript[{1:d}] = {{'.format(variableName, size), file=sourceFile)

if config['hashfilenames'] == True:
            filename['raw'] = '{0}-{1}.{2}'.format(bundlename, md5, 'js')
            filename['min'] = '{0}-{1}.{2}'.format(bundlename, md5, 'min.js')
            filename['gz'] = '{0}-{1}.{2}'.format(bundlename, md5, 'min.js.gz')
        else:
            filename['raw'] = '{0}.{1}'.format(bundlename, 'js')
            filename['min'] = '{0}.{1}'.format(bundlename, 'min.js')
            filename['gz'] = '{0}.{1}'.format(bundlename, 'min.js.gz')
        
        bundleinfo['javascript']['output'] = filename
        
        #Write the bundle file raw data
        writedata(configfile, config, config['output'], filename['raw'], rawdata)
        
        #Minify
        mindata = jsmin.jsmin(rawdata)
        writedata(configfile, config, config['output'], filename['min'], mindata)
        
        #Gzip
        gzdata = zlib.compress(mindata)
        writedata(configfile, config, config['output'], filename['gz'], gzdata)
        
        #Save the sizes
        bundleinfo['javascript']['size'] = {
            'raw':len(rawdata),
            'min':len(mindata),
            'gz':len(gzdata)
        }
        
    #Now CSS (same as above, but a little different)
    if bundledata['includes']['css']:
        logging.info('-Processing CSS')

def __minify_data(self, data):
        return jsmin.jsmin(str(data))

def CompressScript(lines, do_jsmin):
  # If we're not expecting this code to be user visible, we can run it through
  # a more aggressive minifier.
  if do_jsmin:
    return jsmin.jsmin(lines)

  # Remove stuff from the source that we don't want to appear when
  # people print the source code using Function.prototype.toString().
  # Note that we could easily compress the scripts mode but don't
  # since we want it to remain readable.
  #lines = re.sub('//.*\n', '\n', lines) # end-of-line comments
  #lines = re.sub(re.compile(r'/\*.*?\*/', re.DOTALL), '', lines) # comments.
  #lines = re.sub('\s+\n+', '\n', lines) # trailing whitespace
  return lines

import os
import re
import shutil

from csscompressor import compress as cssmin
from jsmin import jsmin

from .common import GrablibError, ProcessBase, logger

MINIFY_LOOKUP = [
    (r'.js$', jsmin),
    (r'.css$', cssmin),
]


class MinifyLibs(ProcessBase):
    """
    minify and concatenate js and css
    """

    def __init__(self, minify_info, **kwargs):
        """
        initialize MinifyLibs.
        :param minify_info: dict of: files to generate => list of regexes of files to generate it from
        :param sites: dict of names of sites to simplify similar urls, see examples.
        """
        super(MinifyLibs, self).__init__(**kwargs)

try:
        # packer or packer-io?
        binary = 'packer-io'
        if shutil.which(binary) == None:
            binary = 'packer'
            if shutil.which(binary) == None:
                print("packer not found. Install it: "
                      "https://www.packer.io/docs/install/index.html")
                return 254

        # run packer with relevant config minified
        configfile = os.path.join(DIRS.user_config_dir, 'config.js')
        with open(configfile, 'r') as config:
            f = create_cachefd('packer_var_file.json')
            f.write(jsmin(config.read()))
            f.close()

        flags = ['-var-file={}'.format(f.name)]

        packer_cache_dir = os.getenv('PACKER_CACHE_DIR', DIRS.user_cache_dir)
        special_env = {'PACKER_CACHE_DIR': packer_cache_dir}
        special_env['TMPDIR'] = DIRS.user_cache_dir
        if DEBUG:
            special_env['PACKER_LOG']  = '1'
            flags.append('-on-error=abort')

        if args.force:
            flags.append('-force')

        cmd = [binary, 'build']
        cmd.extend(flags)