def bake_js(source_dir="js5", dest_file="script5.js"):
	create_baked_directory()
	fn = os.path.join(os.path.dirname(__file__), "..", "static", "baked", str(get_build_number()), dest_file)
	if not os.path.exists(fn):
		js_content = ""
		for sfn in get_js_file_list(source_dir):
			jsfile = open(os.path.join(os.path.dirname(__file__), "..", sfn))
			js_content += minify(jsfile.read()) + "\n"
			jsfile.close()

		o = open(fn, "w")
		o.write(minify(js_content, mangle=True, mangle_toplevel=False))
		o.close()

    def build(cls, basepath, bundle_key, ext):
        bundle = {}

        # Iterate over files in bundle; determine last modified time and
        # assemble content
        last_mtime = 0
        contents = ""
        for path in ASSET_MANIFEST[bundle_key]:
            path = os.path.join(os.path.abspath(basepath),
                path[len('/static/'):])
            last_mtime = max(last_mtime, os.stat(path)[stat.ST_MTIME])
            contents += open(path, "rb").read() + "\n"

        if ext == "js":
            bundle["contents"] = slimit.minify(contents, mangle=True,
                mangle_toplevel=True)
        elif ext == "css":
            bundle["contents"] = cssmin.cssmin(contents)
        else:
            assert False

        bundle["sha1"] = hashlib.sha1(bundle["contents"]).hexdigest()
        bundle["last_modified"] = datetime.datetime.fromtimestamp(last_mtime)
        bundle["mime_type"] = "text/javascript" if ext == "js" else "text/css"

        StaticBuild._bundles[bundle_key] = bundle

    def minify_scripts():
        try:
            import slimit
            for fn in load_static_file_paths('ui/*.js'):
                if 'packages' in fn or not os.access(os.path.dirname(fn), os.W_OK):
                    return
                if fn.endswith('.min.js'):
                    continue
                min_fn = fn.replace('.js', '.min.js')
                if os.path.exists(min_fn) and os.path.getmtime(fn) <= os.path.getmtime(min_fn):
                    continue
                with codecs.open(fn, encoding='utf-8') as inf:
                    content = inf.read()
                    minified = slimit.minify(content, mangle=True, mangle_toplevel=True)
                    with codecs.open(min_fn, 'w', encoding='utf-8') as outf:
                        outf.write(minified)

            import csscompressor
            for fn in load_static_file_paths('ui/*.css'):
                if 'packages' in fn or not os.access(os.path.dirname(fn), os.W_OK):
                    return
                if fn.endswith('.min.css'):
                    continue
                min_fn = fn.replace('.css', '.min.css')
                if os.path.exists(min_fn) and os.path.getmtime(fn) <= os.path.getmtime(min_fn):
                    continue
                with codecs.open(fn, encoding='utf-8') as inf:
                    content = inf.read()
                    minified = csscompressor.compress(content)
                    with codecs.open(min_fn, 'w', encoding='utf-8') as outf:
                        outf.write(minified)
        except ImportError:
            pass

 def compressJs(self, s):
     """ Compress JS string. """
     jscompiler = config.get('global', 'jscompiler')
     if jscompiler == 'internal':
         from slimit import minify
         s = minify(s, mangle=False)
         
     else:
         tmp = open('/tmp/wctmp', 'w')
         tmp.write(s)
         tmp.close()
         
         cmd = jscompiler % {'input':'/tmp/wctmp', 'output':'/tmp/wctmpout'}
         proc = subprocess.Popen([cmd], 
             shell=True, 
             stdin=subprocess.PIPE, 
             stdout=subprocess.PIPE, 
             stderr=subprocess.PIPE)
         for line in proc.stdout.readlines():
             sys.stdout.write(line)
         for line in proc.stderr.readlines():
             sys.stdout.write(line)
         
         proc.wait()
         if proc.returncode != 0:
             exit(1)
             
         tmp = open('/tmp/wctmpout', 'r')
         s = tmp.read().strip()
         tmp.close()
         
     return s

def handle_javascript(js_data, mangle=True, mangle_toplevel=True):
    """
    压缩混淆js
    :param js_data: js字符串
    :return:
    """
    return minify(js_data, mangle=mangle, mangle_toplevel=mangle_toplevel)

    def run(self):
        """Execute command"""
        if not slimit:
            print("You need `slimit' module to minify JavaScript files")
            return

        for root, _, files in os.walk("kiroku/data/js"):
            for fname in files:
                if ".min." in fname:
                    continue

                fname = os.path.join(root, fname)
                minified = None
                new_name, ext = os.path.splitext(fname)
                new_name = os.path.join(new_name + ".min" + ext)

                with open(fname) as fobj:
                    minified = slimit.minify(fobj.read(), mangle=True)

                if minified:
                    with open(new_name, "w") as fobj:
                        fobj.write(minified)
                    # append minified file path without leading 'kiroku/'
                    new_name = new_name[7:]
                    self.distribution.package_data['kiroku'].append(new_name)

 def minify_string(self, string, outfile=None, *, path=None):
     from slimit import minify
     result = minify(string, mangle=True)
     if outfile:
         open(outfile, 'w').write(result)
     else:
         return result

def minicite(js_names, do_wrap, do_minify):
    '''Concatenate, wrap, and minify project JavaScript files.'''
    
    # Read code
    js_files = [open(js_name).read() for js_name in js_names]
    
    # Concatenate code
    js = '\n\n'.join(js_files)

    # Optionally wrap code
    # Note: Wrapper file must contain %s for interpolation
    if do_wrap:

        # Read wrapper
        with open('js-util/wrapper.js') as wrap_file:
            wrap = wrap_file.read()
        
        # Wrap code
        js = wrap % js

    # Optionally minify code
    if do_minify:
        js = slimit.minify(js, mangle=True)
    
    # Return code
    return js

def wrap_mini(paths, basename='pdp', debug=True):
    '''
    :param paths: list of paths to JavaScript files that are to be minified
    :type paths: list of strings
    :param basename: a prefix to prepend to the minified filename. The
                     minified filename will be {basename}-min-{pdp_version}.js
    :type basename: string
    :param debug: If set to True, no minification takes place and the input
                  `paths` are returned as is.
    :type debug: bool
    :returns: list of strings -- the strings is a filesystem path to the
              minified version of the file. If debug is set to True, the return
              value will be equal to the input `paths`.
    '''
    if debug:
        return paths
    else:
        d = resource_filename('pdp', 'static')
        version = get_distribution('pdp').version
        s = ''
        for path in paths:
            with open(os.path.join(d, path), 'r') as f:
                s += f.read()
        smin = minify(s, mangle=True, mangle_toplevel=False)
        outname = '{basename}-min-{version}.js'.format(**locals())
        outpath = os.path.join(d, outname)
        with open(outpath, 'w') as f:
            f.write(smin)
        return [outname]

    def _build_javascript(self):
        js_name = self._config['js_name'] + '.js'
        source = os.path.join(self._cwd, 'src', js_name)
        dest = os.path.join(self._config['build_path'], js_name)

        if not os.path.exists(source):
            source = os.path.join(self._cwd, 'src', 'application.js')
            if not os.path.exists(source):
                return

        try:
            self._js_string = self._concat_javascript(source)
        except:
            raise

        if os.path.exists(dest):
            try:
                os.remove(dest)
            except:
                raise RemoveFileError('Could not delete the existing javascript application file.')

        try:
            f = open(dest, 'w+')
        except:
            raise FileNotWritableError('Could not write the javascript file.')

        if self._config['minify_js']:
            self._js_string = minify(self._js_string, mangle=True, mangle_toplevel=True)

        f.write(self._js_string)
        f.close()

    def _minify(self, data, type, paths=[]):
        sep = ''

        # figure out how to minify something
        if type == 'javascript':
            sep = ';'

            # use envoy to run the custom command if it's supplied
            custom = self.config.get('js_minifier')
            if custom is not None:
                minify = lambda x: envoy.run(custom, data=x).std_out

            # otherwise use slimit
            else:
                options = self.config.get(
                  'js_minifier_options', {'mangle': True}
                )

                minify = lambda x: slimit.minify(x, **options)

        elif type == 'css':
            # only one option for css right now
            minify = cssmin.cssmin

        def real_minify(path, contents):
            if '.min' in path:
                return contents

            return minify(contents)

        minified = sep.join(
          [real_minify(path, contents) for path, contents in zip(paths, data)]
        )

        return minified

def build_asset( destdir, asset ):

	target = os.path.join( destdir, assets.assets[ asset ][ 'output' ] )

	destination = open( target, 'wb' )

	for jsname in assets.assets[ asset ]['order']:

		isMax = False

		try:
			fname = assets.assets[ asset ][ 'min_files' ][ jsname ]
		except KeyError, ke:
			fname = assets.assets[ asset ][ 'max_files' ][ jsname ]
			isMax = True


		newname = os.path.join( os.path.dirname( os.path.realpath( __file__ ) ), 'static', fname )

		f = open( newname, 'rb')
		if isMax is True:
			print 'minifying and concatenating ' + fname
			destination.write(
				minify( f.read(), mangle = True, mangle_toplevel = False )
			)
		else:
			print 'concatenating ' + fname
			destination.write( f.read() )

		f.close()

def run():
	minified = ""
	for currentFile in files:
		minified += minify(open('../static/js/' + currentFile).read(), mangle=True, mangle_toplevel=True)
		minified += '\n'
	minFile = open('../static/js/main.js', 'w')
	minFile.write(minified)
	minFile.close()

    def _compress(self):
        output = []

        for src in self.includes:
            with open('www/%s' % src) as f:
                output.append(minify(f.read()))

        return '\n'.join(output)

def minify_file(file_debug, file_minified):
    try:
        return minify_closure(file_debug, file_minified)
    except NameError:
        with open(file_minified, 'w') as file_out:
            with open(file_debug, 'r') as file_in:
                file_out.write(minify(file_in.read()))
                return True

def new_campaign():
  if request.method == 'GET':
    return render_template('/campaign/new_campaign.html')

  if request.method == 'POST':
    try:
      file  = request.files['kernel']
      kernel_src      = minify(file.read())
    except SyntaxError:
      flash('Invalid kernel file syntax.', 'danger');
      return render_template('/campaign/new_campaign.html')

    file = request.files['static_dataset']
    static_dataset_src = file.read()

    try:
      file = request.files['dataset_generator']
      dataset_gen_src = minify(file.read())
    except SyntaxError:
      flash('Invalid dataset generator file syntax.', 'danger');
      return render_template('/campaign/new_campaign.html')

    campaign = {}
    campaign['user_id'] = current_user_id()
    campaign['kernel']  = kernel_src
    campaign['title']   = request.form['campaign_title']
    campaign['static_dataset'] = static_dataset_src
    campaign['dataset_gen'] = dataset_gen_src

    try:
      new_campaign = CampaignController.add(campaign)
    except CampaignController.ValidationError as e:
      flash(e.message, 'danger')
      return render_template('/campaign/new_campaign.html')

    # Generating the datasets may return an error.
    # If it does, we want to show this to the user
    returncode, error = generate_datasets(new_campaign)

    if (returncode == 0):
      return redirect(url_for('campaign_routes.all_campaigns'), code=303)
    else:
      CampaignController.real_delete(new_campaign.id)

      flash(error, 'danger')
      return render_template('/campaign/new_campaign.html')

def get_project_js(project_dir, compress):
	"""Returns the project's custom script, possibly minified, if it exists."""
	try:
		with open(os.path.join(project_dir, "project.js"), "r") as f:
			js = f.read()
			return js if not compress else minify(js)
	except:
		return ""

    def _compress(self):
        output = []

        for src in self.includes:
            with codecs.open(self._get_path(src), encoding='utf-8') as f:
                output.append(minify(f.read()))

        return '\n'.join(output)

def do_slimit(input_file, output_file, mangle):
    """
    Minify js using slimit
    """
    with open(output_file, mode='wb') as out:
        out.write(
            minify(open(input_file, mode='rb').read(), mangle=mangle)
        )

    def minify(self, content):
        try:
            minify = self._minify
        except AttributeError:
            from slimit import minify
            self._minify = minify
            minify = self._minify

        return minify(content)