def _setup_env(app='', debug=True, cache=True): """Setup the webassets environment.""" if app: app_path = path.join('..', '..', app, 'static') env = Environment(path.join(INPUT_FILES, '..', '..', 'skel', 'assets'), path.join(BASE_LOCATION, '..')) else: app_path = path.join('..', 'static') env = Environment(path.join(INPUT_FILES, '..', '..', 'skel', 'assets'), path.join(BASE_LOCATION)) # We use underscore's templates by default. env.config['JST_COMPILER'] = '_.template' if debug: env.config['CLOSURE_COMPRESSOR_OPTIMIZATION'] = 'WHITESPACE_ONLY' env.manifest = False else: env.config[ 'CLOSURE_COMPRESSOR_OPTIMIZATION'] = 'ADVANCED_OPTIMIZATIONS' env.debug = False env.cache = cache #javascript _bundle_skel(app_path, env, debug) #css _bundle_3rd_party_css(app_path, env, debug) #images _bundle_images(app, env, is_skel=True) return env
def test_url_and_directory(self): """The url and directory options are a bit special, because they are so essential. """ # An environment can be constructed without given url or directory. env = Environment() # But then accessing them will fail, and with it most operations. assert_raises(EnvironmentError, getattr, env, 'url') assert_raises(EnvironmentError, getattr, env, 'directory') # Test constructing the environment with values for url and directory env = Environment('foo', 'bar') assert env.directory == 'foo' assert env.url == 'bar'
def create_assets_env(generator): """Define the assets environment and pass it to the generator.""" theme_static_dir = generator.settings['THEME_STATIC_DIR'] assets_src = os.path.join(generator.output_path, theme_static_dir) generator.env.assets_environment = Environment(assets_src, theme_static_dir) if 'ASSET_CONFIG' in generator.settings: for item in generator.settings['ASSET_CONFIG']: generator.env.assets_environment.config[item[0]] = item[1] if 'ASSET_BUNDLES' in generator.settings: for name, args, kwargs in generator.settings['ASSET_BUNDLES']: generator.env.assets_environment.register(name, *args, **kwargs) if logging.getLevelName(logger.getEffectiveLevel()) == "DEBUG": generator.env.assets_environment.debug = True if 'ASSET_SOURCE_PATHS' in generator.settings: # the default load path gets overridden if additional paths are # specified, add it back generator.env.assets_environment.append_path(assets_src) for path in generator.settings['ASSET_SOURCE_PATHS']: full_path = os.path.join(generator.theme, path) generator.env.assets_environment.append_path(full_path)
def compileJavascript(): environment = Environment('vendor/bootstrap/js/', 'javascript') output = '../../../codemitts/resources/static/javascript/bootstrap.js' bootstrap_javascript_bundle = Bundle('*', output=output) environment.register('bootstrap_javascript_bundle', bootstrap_javascript_bundle) environment['bootstrap_javascript_bundle'].urls()
def webassets_init(): global env static_path = get_webassets_path() public = config.get(u'ckan.base_public_folder') public_folder = os.path.abspath( os.path.join(os.path.dirname(__file__), u'..', public)) base_path = os.path.join(public_folder, u'base') env = Environment() env.directory = static_path env.debug = asbool(config.get(u'debug', False)) env.url = u'/webassets/' add_public_path(base_path, u'/base/') logger.debug(u'Base path {0}'.format(base_path)) create_library(u'vendor', os.path.join(base_path, u'vendor')) create_library(u'base', os.path.join(base_path, u'javascript')) create_library(u'datapreview', os.path.join(base_path, u'datapreview')) create_library(u'css', os.path.join(base_path, u'css'))
def main(): log = logging.getLogger('webassets') log.addHandler(logging.StreamHandler()) log.setLevel(logging.DEBUG) call(["coffee", "-c", "src/tambur.coffee"]) call(["coffee", "-c", "src/tambur_publisher.coffee"]) env = Environment('.', '/static') jsonjs = Bundle( 'deps/json2.js', filters='yui_js', output='out/json2.min.js') sockjs = Bundle( 'deps/web_socket.js', filters='yui_js', output='out/web_socket.min.js') tamburjs = Bundle( 'deps/swfobject.js', 'src/tambur.js', output='out/tambur.js') tamburminjs = Bundle( 'deps/swfobject.js', 'src/tambur.js', filters='yui_js', output='out/tambur.min.js') publishjs = Bundle( 'deps/sha1.js', 'deps/oauth.js', 'src/tambur_publisher.js', output='out/tambur_pub.js') publishminjs = Bundle( 'deps/sha1.js', 'deps/oauth.js', 'src/tambur_publisher.js', filters='yui_js', output='out/tambur_pub.min.js') env.register('tambur.js', tamburjs) env.register('tambur.min.js', tamburminjs) env.register('tambur_pub.js', publishjs) env.register('tambur_pub.min.js', publishminjs) env.register('json2.js', jsonjs) env.register('web_socket.js', sockjs) cmdenv = CommandLineEnvironment(env, log) cmdenv.build()
def _setup_env(debug=True, cache=True): """Setup the webassets environment.""" env = Environment(INPUT_FILES, OUTPUT_FILES) # We use underscore's templates by default. env.config['JST_COMPILER'] = '_.template' if debug: env.config['CLOSURE_COMPRESSOR_OPTIMIZATION'] = 'WHITESPACE_ONLY' env.manifest = False else: env.config[ 'CLOSURE_COMPRESSOR_OPTIMIZATION'] = 'ADVANCED_OPTIMIZATIONS' env.debug = False env.cache = cache #javascript _bundle_app_jsts(env, debug) _bundle_app_coffee(env, debug) _bundle_3rd_party_js(env, debug) #css _bundle_app_less(env, debug) _bundle_3rd_party_css(env, debug) #images _bundle_images(env) return env
def run(self): from webassets import Bundle from webassets import Environment from webassets.script import CommandLineEnvironment css = Bundle('curious/src/css/app.css', output='curious/dist/curious.css') js = Bundle('curious/src/js/*.js', output='curious/dist/curious.js') jsm = Bundle('curious/src/js/*.js', filters='jsmin', output='curious/dist/curious.min.js') jst = Bundle('curious/src/html/*.html', filters='jst', output='curious/dist/curious_jst.js') assets_env = Environment('./curious/static') assets_env.cache = self.cache_dir assets_env.register('css', css) assets_env.register('js', js) assets_env.register('jsmin', jsm) assets_env.register('jst', jst) log = logging.getLogger('webassets') log.addHandler(logging.StreamHandler()) log.setLevel(logging.DEBUG) cmdenv = CommandLineEnvironment(assets_env, log) cmdenv.build()
def create_assets_env(generator): """Define the assets environment and pass it to the generator.""" theme_static_dir = generator.settings["THEME_STATIC_DIR"] assets_destination = os.path.join(generator.output_path, theme_static_dir) generator.env.assets_environment = Environment(assets_destination, theme_static_dir) if "ASSET_CONFIG" in generator.settings: for item in generator.settings["ASSET_CONFIG"]: generator.env.assets_environment.config[item[0]] = item[1] if "ASSET_BUNDLES" in generator.settings: for name, args, kwargs in generator.settings["ASSET_BUNDLES"]: generator.env.assets_environment.register(name, *args, **kwargs) if "ASSET_DEBUG" in generator.settings: generator.env.assets_environment.debug = generator.settings[ "ASSET_DEBUG"] elif logging.getLevelName(logger.getEffectiveLevel()) == "DEBUG": generator.env.assets_environment.debug = True for path in generator.settings[ "THEME_STATIC_PATHS"] + generator.settings.get( "ASSET_SOURCE_PATHS", []): full_path = os.path.join(generator.theme, path) generator.env.assets_environment.append_path(full_path)
def make_webassets_env_from_config(self, options, config): settings = {} settings.update(options) settings.update( coerce_config( config, 'webassets.', { 'debug': asbool, 'auto_build': asbool, 'manifest': self.string_or_bool, 'url_expire': asbool, 'cache': self.string_or_bool, 'load_path': aslist })) static_files_path = config['paths']['static_files'] asset_dir = settings.pop('base_dir', static_files_path) asset_url = settings.pop('base_url', '/') if not asset_url.startswith('/'): if urlparse(asset_url).scheme == '': asset_url = '/' + asset_url assets_env = Environment(asset_dir, asset_url, **settings) bundles = self.options.get('bundles', {}) for name, value in bundles.items(): if isinstance(value, Bundle): assets_env.register(name, value) else: # If it's not a bundle consider it a loader assets_env.register(value.load_bundles()) return assets_env
def test_initial_values_override_defaults(self): """[Bug] If a dict of initial values are passed to the environment, they override any defaults the environment might want to set. """ env = Environment(None, None, debug='foo') assert env.debug == 'foo'
def test_options(self): """Test option declaration. """ class TestFilter(Filter): options = { 'attr1': 'ATTR1', 'attr2': ('secondattr', 'ATTR2'), 'attr3': (False, 'ATTR3'), 'attr4': ('attr4', False), } # Test __init__ arguments assert TestFilter(attr1='foo').attr1 == 'foo' assert TestFilter(secondattr='foo').attr2 == 'foo' assert_raises(TypeError, TestFilter, attr3='foo') assert TestFilter(attr4='foo').attr4 == 'foo' # Test config vars env = Environment(None, None) env.config['attr1'] = 'bar' env.config['attr4'] = 'bar' f = TestFilter() f.env = env f.setup() assert f.attr1 == 'bar' assert f.attr4 is None # Was configured to not support env
def get_assets_bottom_js_env(self, code_path, output_path): """ The directory structure of assets is: output_path static css js """ output_path = os.path.join(output_path, 'static') assets_env = Environment(output_path, '/static', debug=self.args.debug) assets_env.config['compass_config'] = { 'additional_import_paths': [os.path.join(code_path, 'scss-mixins')], #'sass_options': "cache: False", ??? i can't get it. 'http_path': "/static", } bottom_js_list = [] if "bottom_js" in self.config.data: bottom_js_list = self.config.data["bottom_js"] if bottom_js_list and len(bottom_js_list): bottom_js = Bundle(*bottom_js_list, filters='rjsmin', output='bottom.js') assets_env.register('bottom_js', bottom_js) return assets_env
def get_assets_css_env(self, code_path, output_path): """ The directory structure of assets is: output_path static css js """ output_path = os.path.join(output_path, 'static') assets_env = Environment(output_path, '/static', debug=self.args.debug) assets_env.config['compass_config'] = { 'additional_import_paths': [os.path.join(code_path, 'scss-mixins')], #'sass_options': "cache: False", ??? i can't get it. 'http_path': "/static", } css_list = [] scss_list = [] if "css_or_scss" in self.config.data: for filename in self.config.data["css_or_scss"]: if self.args.verbose: print('Adding filename: %s' % (filename)) ext = os.path.splitext(filename)[1] if ext == '.scss': scss_list.append(filename) elif ext == '.css': css_list.append(filename) else: raise Exception( 'Bad extension: is %s instead of css/scss' % ext) if len(css_list) or len(scss_list): css_bundle = Bundle(*css_list) scss_bundle = [] for scss_file in scss_list: if self.args.verbose: print('Processing filename: %s' % (scss_file)) try: xxx = Bundle( scss_file, filters='compass', output=scss_file + '.css', ) scss_bundle.append(xxx) except Exception as error: print("ERROR processing filename '%s': %s" % (scss_file, error)) css = Bundle(css_bundle, *scss_bundle, filters='cssutils,cssrewrite', output='packed.css') assets_env.register('css', css) return assets_env
def setup(self): self.dir_created = tempfile.mkdtemp() self.m = Environment(self.dir_created, '') # Unless we explicitly test it, we don't want to use the cache # during testing. self.m.cache = False # Some generic files to be used by simple tests self.create_files(self.default_files)
def create_assets_env(generator): """Define the assets environment and pass it to the generator.""" assets_url = 'theme/' assets_src = os.path.join(generator.output_path, 'theme') generator.env.assets_environment = Environment(assets_src, assets_url) logger = logging.getLogger(__name__) if logging.getLevelName(logger.getEffectiveLevel()) == "DEBUG": generator.env.assets_environment.debug = True
def includeme(config): """pyramid include. declare the add_thumb_view""" here = os.path.dirname(__file__) settings = config.registry.settings config_dir = settings.get('garasu_webassets.config', '{}/configs'.format(here)) LOG.debug(config_dir) # config_dir = AssetResolver(None).resolve(config_dir).abspath() asset_dir = settings.get('garasu_webassets.assets', '{}/assets'.format(here)) LOG.debug(asset_dir) # asset_dir = AssetResolver(None).resolve(asset_dir).abspath() env = Environment(directory=asset_dir, url=settings['garasu_webassets.url']) env.manifest = settings['garasu_webassets.manifest'] env.debug = asbool(settings['garasu_webassets.debug']) env.cache = asbool(settings['garasu_webassets.cache']) env.auto_build = asbool(settings['garasu_webassets.auto_build']) def text(value): if type(value) is six.binary_type: return value.decode('utf-8') else: return value def yaml_stream(fname, mode): if path.exists(fname): return open(fname, mode) raise FileNotFoundError fin = fileinput.input('/'.join([config_dir, settings['garasu_webassets.bundles']]), openhook=yaml_stream) with closing(fin): lines = [text(line).rstrip() for line in fin] stream_yaml = six.StringIO('\n'.join(lines)) loader = YAMLLoader(stream_yaml) result = loader.load_bundles() env.register(result) # for item in env: # LOG.debug(item.output) # path_file = '/'.join([public_dir, item.output]) # src_file = '/'.join([asset_dir, item.output]) # shutil.copy(src_file, path_file) def _get_assets(request, *args, **kwargs): bundle = Bundle(*args, **kwargs) with bundle.bind(env): urls = bundle.urls() return urls config.add_request_method(_get_assets, 'web_assets') def _get_assets_env(request): return env config.add_request_method(_get_assets_env, 'web_env', reify=True)
def get_template_namespace(self): _ = super(BaseHandler, self).get_template_namespace() self.assets = Environment( os.path.join(os.path.dirname(__file__), '../static'), '/static') css_all = Bundle('css/bootstrap.min.css', 'css/material.min.css', Bundle('css/schoolcms.css', 'css/dropdown.css', filters='cssmin'), 'outdatedbrowser/outdatedbrowser.min.css', output='dict/plugin.min.css') js_all = Bundle(Bundle('outdatedbrowser/outdatedbrowser.min.js', 'react-0.13.2/react-with-addons.min.js', 'js/jquery-2.1.3.min.js', 'js/bootstrap.min.js', 'js/react-bootstrap.min.js', 'js/react-mini-router.min.js', 'js/marked.min.js', 'js/material.min.js', 'js/isMobile.min.js', 'js/moment-with-locales.min.js', 'js/dropdown.js', filters='jsmin'), Bundle('schoolcms/init.jsx', 'schoolcms/mixin/*.jsx', 'schoolcms/component/*.jsx', 'schoolcms/page/*.jsx', filters=('react', 'jsmin')), output='dict/plugin.min.js') self.assets.register('css_all', css_all) self.assets.register('js_all', js_all) _['css_urls'] = self.assets['css_all'].urls() _['js_urls'] = self.assets['js_all'].urls() _['system_name'] = options.system_name _['SERVER_DEBUG'] = options.server_debug _['ip'] = self.request.remote_ip _['system_version'] = system_version _['_host'] = self.request.host _['_protocol'] = self.request.protocol if self.current_user: groups = GroupList.get_user_groups(self.current_user.key, self.sql_session) else: groups = [] _['current_user'] = self.current_user.to_dict( ) if self.current_user else None _['current_groups'] = groups # Call this to set the cookie self.xsrf_token return _
def test_jinja2_config(self): app_config = self.basic_valid_app_config.copy() dict_loader = DictLoader({}) app_config.update({"jinja2": {"loader": dict_loader, "use_webassets": True}}) webassets_env = Environment("/tmp", "/") webassets_env.register("js", "dummy.js", "dummy2.js", output="dummy.js") config = BlueberryPyConfiguration(app_config=app_config, webassets_env=webassets_env) self.assertEqual(config.jinja2_config, {"loader": dict_loader})
def test_use_webassets(self): app_config = self.basic_valid_app_config.copy() app_config.update({"jinja2": {"use_webassets": True, "loader": DictLoader({})}}) self.assertRaisesRegexp(BlueberryPyNotConfiguredError, "Webassets configuration not found.", callable_obj=BlueberryPyConfiguration, app_config=app_config) webassets_env = Environment("/tmp", "/") self.assertRaisesRegexp(BlueberryPyNotConfiguredError, "No bundles found in webassets env.", callable_obj=BlueberryPyConfiguration, app_config=app_config, webassets_env=webassets_env) webassets_env = Environment("/tmp", "/") webassets_env.register("js", "dummy.js", "dummy2.js", output="dummy.js") config = BlueberryPyConfiguration(app_config=app_config, webassets_env=webassets_env) self.assertTrue(config.use_webassets)
def gen_static(): # Setup a logger log = logging.getLogger('webassets') log.addHandler(logging.StreamHandler()) log.setLevel(logging.DEBUG) assets_env = Environment() assets_env.directory = "static/" assets_env.debug = True assets_env.register(bundles) cmdenv = CommandLineEnvironment(assets_env, log) # This would also work cmdenv.build()
def test_append_load_path(self): env = Environment() assert env.load_path == [] env.append_path('foo', '/foo') assert env.load_path == ['foo'] assert env.url_mapping == {'foo': '/foo'} # Works without path env.append_path('bar') assert env.load_path == ['foo', 'bar'] assert env.url_mapping == {'foo': '/foo'}
def setUp(self): res = dirname(__file__)+'/resources/' self.env = Environment(dirname(__file__)+"/out", '/media-prefix') self.env.cache = False self.env.manifest = False self.env.append_path(res+"assets", "/") self.env.append_path(res+"vendor", "/vendors") self.env.append_path(res, None) self.env.config["compass_bin"] = "/home/arkus/.gem/ruby/1.9.1/bin/compass" self.env.config["vendor_path"] = "vendor"
def create_assets_env(generator): """Define the assets environment and pass it to the generator.""" assets_url = 'theme/' assets_src = os.path.join(generator.output_path, 'theme') generator.env.assets_environment = Environment(assets_src, assets_url) if 'ASSET_CONFIG' in generator.settings: for item in generator.settings['ASSET_CONFIG']: generator.env.assets_environment.config[item[0]] = item[1] if logging.getLevelName(logger.getEffectiveLevel()) == "DEBUG": generator.env.assets_environment.debug = True
def load_environment(self): """Load an ``Environment`` instance defined in the YAML file. Expects the following format:: directory: ../static url: /media debug: True updater: timestamp bundles: bundle-name: filters: sass,cssutils output: cache/default.css contents: - css/jquery.ui.calendar.css - css/jquery.ui.slider.css """ f, filename = self._open() try: obj = self.yaml.load(f) or {} # construct the environment if not 'url' in obj or not 'directory' in obj: raise LoaderError('"url" and "directory" must be defined') directory = obj['directory'] if filename: # If we know the location of the file, make sure that the # paths included are considered relative to the file location. directory = path.normpath( path.join(path.dirname(filename), directory)) env = Environment(directory, obj['url']) # load environment settings for setting in ( 'debug', 'cache', 'updater', 'expire', ): if setting in obj: setattr(env, setting, obj[setting]) # load bundles bundles = self._get_bundles(obj.get('bundles', {})) for name, bundle in bundles.iteritems(): env.register(name, bundle) return env finally: f.close()
def test_getconfig_os_env_types(self): """Test type conversion for values read from the environment. """ m = Environment(None, None) f = Filter() f.set_environment(m) get_config = f.get_config with os_environ_sandbox(): os.environ['foo'] = 'one,two\,three' assert get_config(env='foo', type=list) == ['one', 'two,three'] # Make sure the split is not applied to env config values m.config['foo'] = 'one,two\,three' assert get_config(setting='foo', type=list) == 'one,two\,three'
def scss_compile(static_path): webassets = Environment() webassets.directory = static_path webassets.url = static_path webassets.register('css_all', css_all) #webassets.manifest = 'cache' if not app.debug else False webassets.manifest = False webassets.cache = False webassets.debug = False log = logging.getLogger('webassets') log.addHandler(logging.StreamHandler()) log.setLevel(logging.DEBUG) cmdenv = CommandLineEnvironment(webassets, log) # This would also work cmdenv.build()
def _setup_assets(self): config = Config.getInstance() url_base_path = urlparse(config.getBaseURL()).path output_dir = os.path.join(config.getHtdocsDir(), 'static', 'assets', 'plugins', self.name) output_url = '{}/static/assets/plugins/{}'.format( url_base_path, self.name) static_dir = os.path.join(self.root_path, 'static') static_url = '{}/static/plugins/{}'.format(url_base_path, self.name) self.assets = Environment(output_dir, output_url, debug=config.getDebug()) self.assets.append_path(output_dir, output_url) self.assets.append_path(static_dir, static_url) configure_pyscss(self.assets) self.register_assets()
def __init__(self, rh): config = Config.getInstance() self._rh = rh self._locTZ = "" self._asset_env = Environment(config.getHtdocsDir(), '/') # This is done in order to avoid the problem sending the error report because the DB is not connected. if DBMgr.getInstance().isConnected(): info = HelperMaKaCInfo.getMaKaCInfoInstance() self._asset_env.debug = info.isDebugActive() # register existing assets assets.register_all_js(self._asset_env) #store page specific CSS and JS self._extraCSS = [] self._extraJS = []
def main(): my_env = Environment(directory='static', url='/static') # # The js for every pge all_js = Bundle( Bundle(*vendor_js), Bundle('coffee/common.coffee', filters='coffeescript'), # filters='jsmin', output='all.js') my_env.register('all_js', all_js) # # Per-page coffee page_bundles = [] for file in os.listdir(os.path.join(os.path.abspath('.'), 'static/coffee')): if file.endswith('.coffee') and not file.startswith( '#') and file != 'common.coffee': bundle_name = file.split('.')[0] bundle = Bundle(os.path.join('coffee', file), filters='coffeescript', output='%s.js' % bundle_name) my_env.register(bundle_name, bundle) page_bundles.append(bundle_name) # # CSS for every page all_css = Bundle( Bundle(*vendor_css # filters='cssmin' ), output='all.css') my_env.register('all_css', all_css) for js_url in my_env['all_js'].urls(): print(js_url) for css_url in my_env['all_css'].urls(): print(css_url) for page_bundle in page_bundles: for url in my_env[page_bundle].urls(): print(url)