def minify_sources(sources, ext, fs_root=''):
import cssutils
if 'js' in ext:
js_minify = JavascriptMinify()
minified_sources = []
for source in sources:
# generate full path to source
no_ext_source = os.path.splitext(source)[0]
full_source = os.path.join(fs_root, (no_ext_source + ext).lstrip('/'))
# generate minified source path
full_source = os.path.join(fs_root, (source).lstrip('/'))
no_ext_full_source = os.path.splitext(full_source)[0]
minified = no_ext_full_source + ext
f_minified_source = open(minified, 'w')
# minify js source (read stream is auto-closed inside)
if 'js' in ext:
js_minify.minify(open(full_source, 'r'), f_minified_source)
# minify css source
if 'css' in ext:
serializer = get_serializer()
sheet = cssutils.parseFile(full_source)
sheet.setSerializer(serializer)
cssutils.ser.prefs.useMinified()
f_minified_source.write(sheet.cssText)
f_minified_source.close()
minified_sources.append(no_ext_source + ext)
return minified_sources
def run(self):
self.mkpath(self.build_dir)
outfiles = []
updated_files = []
# consider replacing this with a better utility
jsm = JavascriptMinify()
for f in self.web_files:
inf = convert_path(f)
outf = os.path.join(self.build_dir, f)
self.mkpath(os.path.dirname(outf))
if self.compress:
log.info("minifying %s -> %s" % (f, outf))
input = open(inf, 'r')
output = open(outf, 'wb')
if f.endswith('.js'):
# eat the first line (JSLint directive)
input.readline()
# copy 5 lines of the header
for l in range(6):
output.write(input.readline())
if f.endswith('.js'):
jsm.minify(input, output)
elif f.endswith('.css'):
output.write(cssmin(input.read()))
input.close()
output.close()
else:
self.copy_file(inf, outf)
self.outfiles.append(outf)
# build a regular expression to substitute the HTML files
regex = ';'.join([
's/{{%s}}/%s/' % (re.escape(k), re.escape(v[self.compress]))
for k, v in self.html_subst.iteritems()
])
regex += ';s/{{VERSION}}/%s/' % (re.escape(self.version))
for f in self.html_files:
inf = convert_path(f)
outf = os.path.join(self.build_dir, os.path.basename(f))
log.info("substituting %s -> %s" % (f, outf))
output = open(outf, 'wb')
# use sed, because I like sed
subprocess.check_call(['sed', regex, inf], stdout=output)
output.close()
self.outfiles.append(outf)
def open(self):
output = BytesIO()
minify = JavascriptMinify(self._file.open(),
output,
quote_chars="'\"`")
minify.minify()
output.seek(0)
if not self._verify_command:
return output
input_source = self._file.open().read()
output_source = output.getvalue()
with NamedTemporaryFile() as fh1, NamedTemporaryFile() as fh2:
fh1.write(input_source)
fh2.write(output_source)
fh1.flush()
fh2.flush()
try:
args = list(self._verify_command)
args.extend([fh1.name, fh2.name])
subprocess.check_output(args, stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
errors.warn('JS minification verification failed for %s:' %
(getattr(self._file, 'path', '<unknown>')))
# Prefix each line with "Warning:" so mozharness doesn't
# think these error messages are real errors.
for line in e.output.splitlines():
errors.warn(line)
return self._file.open()
return output
def minify_sources(sources, ext, fs_root=''):
import cssutils
if 'js' in ext:
js_minify = JavascriptMinify()
minified_sources = []
for source in sources:
# generate full path to source
no_ext_source = os.path.splitext(source)[0]
full_source = os.path.join(fs_root, (no_ext_source + ext).lstrip('/'))
# generate minified source path
full_source = os.path.join(fs_root, (source).lstrip('/'))
no_ext_full_source = os.path.splitext(full_source)[0]
minified = no_ext_full_source + ext
f_minified_source = open(minified, 'w')
# minify js source (read stream is auto-closed inside)
if 'js' in ext:
js_minify.minify(open(full_source, 'r'), f_minified_source)
# minify css source
if 'css' in ext:
serializer = get_serializer()
sheet = cssutils.parseFile(full_source)
sheet.setSerializer(serializer)
cssutils.ser.prefs.useMinified()
f_minified_source.write(sheet.cssText)
f_minified_source.close()
minified_sources.append(no_ext_source + ext)
return minified_sources
def open(self):
output = BytesIO()
minify = JavascriptMinify(self._file.open(), output, quote_chars="'\"`")
minify.minify()
output.seek(0)
if not self._verify_command:
return output
input_source = self._file.open().read()
output_source = output.getvalue()
with NamedTemporaryFile() as fh1, NamedTemporaryFile() as fh2:
fh1.write(input_source)
fh2.write(output_source)
fh1.flush()
fh2.flush()
try:
args = list(self._verify_command)
args.extend([fh1.name, fh2.name])
subprocess.check_output(args, stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
errors.warn('JS minification verification failed for %s:' %
(getattr(self._file, 'path', '<unknown>')))
# Prefix each line with "Warning:" so mozharness doesn't
# think these error messages are real errors.
for line in e.output.splitlines():
errors.warn(line)
return self._file.open()
return output
def main():
parser = OptionParser(
usage="usage: %prog [options] header source [input [input...]]")
parser.add_option('--no-minify',
action='store_true',
help='Do not run the input files through jsmin')
parser.add_option('-n', '--namespace', help='Namespace to use')
(options, arguments) = parser.parse_args()
if not options.namespace:
print 'Error: must provide a namespace'
parser.print_usage()
exit(-1)
if len(arguments) < 3:
print 'Error: must provide at least 3 arguments'
parser.print_usage()
exit(-1)
namespace = options.namespace
headerPath = arguments[0]
sourcePath = arguments[1]
inputPaths = arguments[2:]
headerFile = open(headerPath, 'w')
print >> headerFile, 'namespace {0:s} {{'.format(namespace)
sourceFile = open(sourcePath, 'w')
print >> sourceFile, '#include "{0:s}"'.format(
os.path.basename(headerPath))
print >> sourceFile, 'namespace {0:s} {{'.format(namespace)
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 >> headerFile, 'extern const char {0:s}JavaScript[{1:d}];'.format(
variableName, size)
print >> sourceFile, 'const char {0:s}JavaScript[{1:d}] = {{'.format(
variableName, size)
codepoints = map(ord, characters)
for codepointChunk in chunk(codepoints, 16):
print >> sourceFile, ' {0:s},'.format(','.join(
map(stringifyCodepoint, codepointChunk)))
print >> sourceFile, '};'
print >> headerFile, '}} // namespace {0:s}'.format(namespace)
print >> sourceFile, '}} // namespace {0:s}'.format(namespace)
def minify(filename):
"""Given a filename, handle minifying it as -min.js"""
if not is_min(filename):
new_filename = re.sub(".js$", "-min.js", filename)
with open(filename) as shrink_me:
with open(new_filename, 'w') as tobemin:
jsm = JavascriptMinify()
jsm.minify(shrink_me, tobemin)
def minify(filename):
"""Given a filename, handle minifying it as -min.js"""
if not is_min(filename):
new_filename = re.sub(".js$", "-min.js", filename)
with open(filename) as shrink_me:
with open(new_filename, 'w') as tobemin:
jsm = JavascriptMinify()
jsm.minify(shrink_me, tobemin)
def compileString(code, minify=True): code = ElementMacro.fromCode(code) code = UriOfMacro.fromCode(code) code = Javascript.fromCode(code) if minify: jsm = JavascriptMinify() out = StringIO() jsm.minify(StringIO(code), out) code = out.getvalue() return code.strip()
def main():
parser = OptionParser(usage="usage: %prog [options] header source [input [input...]]")
parser.add_option('--no-minify', action='store_true', help='Do not run the input files through jsmin')
parser.add_option('-n', '--namespace', help='Namespace to use')
(options, arguments) = parser.parse_args()
if not options.namespace:
print('Error: must provide a namespace')
parser.print_usage()
exit(-1)
if len(arguments) < 3:
print('Error: must provide at least 3 arguments')
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)
codepoints = list(map(ord, characters))
for codepointChunk in chunk(codepoints, 16):
print(' {0:s},'.format(','.join(map(stringifyCodepoint, codepointChunk))), file=sourceFile)
print('};', file=sourceFile)
print('}} // namespace {0:s}'.format(namespace), file=headerFile)
print('}} // namespace {0:s}'.format(namespace), file=sourceFile)
def write_minify(cls, source, dest):
from pecan import conf
redis = redis_connector()
buff = StringIO.StringIO()
JavascriptMinify().minify(source, buff)
redis = redis_connector()
redis.set(dest.replace(conf.app.static_root, ''), buff.getvalue())
def get_js_minified(self, codestr):
ins = StringIO(codestr)
outs = StringIO()
JavascriptMinify().minify(ins, outs)
min_js = outs.getvalue()
if len(min_js) > 0 and min_js[0] == '\n':
min_js = min_js[1:]
return re.sub(r'(\n|\r)+', '', min_js)
def minify_js(file_path, src):
"""Returns a minified version of the given JavaScript source string."""
in_str = StringIO(src)
out_str = StringIO()
JavascriptMinify().minify(in_str, out_str)
src = out_str.getvalue()
in_str.close()
out_str.close()
return src
def open(self):
output = six.StringIO()
minify = JavascriptMinify(codecs.getreader("utf-8")(self._file.open()),
output,
quote_chars="'\"`")
minify.minify()
output.seek(0)
output_source = six.ensure_binary(output.getvalue())
output = BytesIO(output_source)
if not self._verify_command:
return output
input_source = self._file.open().read()
with NamedTemporaryFile("wb+") as fh1, NamedTemporaryFile(
"wb+") as fh2:
fh1.write(input_source)
fh2.write(output_source)
fh1.flush()
fh2.flush()
try:
args = list(self._verify_command)
args.extend([fh1.name, fh2.name])
subprocess.check_output(args,
stderr=subprocess.STDOUT,
universal_newlines=True)
except subprocess.CalledProcessError as e:
errors.warn("JS minification verification failed for %s:" %
(getattr(self._file, "path", "<unknown>")))
# Prefix each line with "Warning:" so mozharness doesn't
# think these error messages are real errors.
for line in e.output.splitlines():
errors.warn(line)
return self._file.open()
return output
def get_minified_js_str(self, js):
ins = StringIO(js)
outs = StringIO()
JavascriptMinify().minify(ins, outs)
min_js = outs.getvalue()
if len(min_js) > 0 and min_js[0] == '\n':
min_js = min_js[1:]
min_js = re.sub(r'(\n|\r)+', '', min_js)
return min_js
def on_minifier_js_activate(self, action):
doc = self._window.get_active_document()
if not doc:
return
doctxt = doc.get_text(doc.get_iter_at_line(0), doc.get_end_iter())
ins = StringIO(doctxt)
outs = StringIO()
JavascriptMinify().minify(ins, outs)
min_js = outs.getvalue()
if len(min_js) > 0 and min_js[0] == '\n':
min_js = min_js[1:]
min_js = re.sub(r'(\n|\r)+', '', min_js)
self.handle_new_output("Minified JS Copied to CLipboard", min_js)
def write_minify(cls, source, dest):
dest = open(dest, 'w')
JavascriptMinify().minify(source, dest)
dest.close()
if __name__ == '__main__':
import sys, os
if len(sys.argv) != 3:
print "Usage: gen-tiall.py <path to tiall.js> <dir of source js>"
sys.exit(1)
tiall_js = sys.argv[1]
src_dir = sys.argv[2]
tilist_file = os.path.join(src_dir, "tilist.txt")
l = open(tilist_file, "r")
sources = []
for n in l:
n = n.strip()
if len(n) > 0:
sources.append(os.path.join(src_dir,n))
l.close()
print "Dest: %s" % (tiall_js)
outf = open(tiall_js, "w+")
for f in sources:
inf = open(f,"r")
print "Minifying: %s" % (f)
jsm = JavascriptMinify()
jsm.minify(inf, outf)
outf.close()
def apply(self, _in, out):
JavascriptMinify().minify(_in, out)
# Copyright (c) 2013 Dave St.Germain
#·
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#·
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#·
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
import sys, os, glob
from jsmin import JavascriptMinify
for f in sys.argv[1:]:
with open(f, 'r') as js:
minifier = JavascriptMinify(js, sys.stdout)
minifier.minify()
sys.stdout.write('\n')