fanstatic_resources.py

import os.path
import sys
import logging
import ConfigParser

from fanstatic import Library, Resource, Group, get_library_registry
import fanstatic.core as core

# This imports patches fanstatic
import ckan.lib.fanstatic_extensions as fanstatic_extensions

from ckan.include.rjsmin import jsmin
from ckan.include.rcssmin import cssmin

log = logging.getLogger(__name__)


def create_library(name, path, depend_base=True):
    ''' Creates a fanstatic library `name` with the contents of a
    directory `path` using resource.config if found. Files are minified
    if needed. '''

    def get_resource(lib_name, resource_name):
        ''' Attempt to get the resource from the current lib or if not try
        assume it is a fully qualified resource name. '''
        try:
            res = getattr(module, '%s/%s' % (lib_name, resource_name))
        except AttributeError:
            res = getattr(module, '%s' % resource_name)
        return res

    def min_path(path):
        ''' return the .min filename eg moo.js -> moo.min.js '''
        if path.endswith('.js'):
            return path[:-3] + '.min.js'
        if path.endswith('.css'):
            return path[:-4] + '.min.css'

    def minify(filename, resource_path, min_function):
        ''' Minify file path using min_function. '''
        # if the minified file was modified after the source file we can
        # assume that it is up-to-date
        path = os.path.join(resource_path, filename)
        path_min = min_path(path)
        op = os.path
        if op.exists(path_min) and op.getmtime(path) < op.getmtime(path_min):
            return
        source = open(path, 'r').read()
        f = open(path_min, 'w')
        f.write(min_function(source))
        f.close()
        log.debug('minified %s' % path)

    def create_resource(path, lib_name, count, inline=False):
        ''' create the fanstatic Resource '''
        renderer = None
        kw = {}
        if not inline:
            # resource_name is name of the file without the .js/.css
            rel_path, filename = os.path.split(path)
            filename = os.path.join(rel_path, filename)
            path_min = min_path(os.path.join(resource_path, filename))
            if os.path.exists(path_min):
                kw['minified'] = min_path(filename)
            if filename.endswith('.js'):
                renderer = core.render_js
                if path not in force_top:
                    kw['bottom'] = True
            if filename.endswith('.css'):
                renderer = core.render_css
            core.set_resource_file_existence_checking(True)
        else:
            # This doesn't exist so stop fanstatic checking the filesystem
            core.set_resource_file_existence_checking(False)
        dependencies = []
        if path in depends:
            for dependency in depends[path]:
                dependencies.append(get_resource(name, dependency))
        if depend_base:
            dependencies.append(getattr(module, 'base/main'))
        if dependencies:
            kw['depends'] = dependencies
        if path in dont_bundle:
            kw['dont_bundle'] = True
        # IE conditionals
        condition = None
        other_browsers = False
        if path in IE_conditionals:
            other_browsers = ('others' in IE_conditionals[path])
            condition = IE_conditionals[path][0]
        if inline or condition:
            kw['renderer'] = fanstatic_extensions.CkanCustomRenderer(
                                        condition=condition,
                                        script=inline,
                                        renderer=renderer,
                                        other_browsers=other_browsers)
        resource = Resource(library, path, **kw)

        # Add our customised ordering
        if path in custom_render_order:
            resource.order = custom_render_order[path]
        resource.custom_order = count
        # Update the attributes of the minified version of the resource to
        # that of the parents as fanstatic does not pass these on.
        update_attributes = ['custom_order', 'order', 'bottom', 'depends',
                             'dont_bundle', 'renderer']
        if 'minified' in resource.modes:
            min_res = resource.modes['minified']
            for attribute in update_attributes:
                setattr(min_res, attribute, getattr(resource, attribute))

        # add the resource to this module
        fanstatic_name = '%s/%s' % (lib_name, path)
        log.debug('create resource %s' % fanstatic_name)
        setattr(module, fanstatic_name, resource)
        return resource

    resource_path = os.path.join(os.path.dirname(__file__), path)
    library = Library(name, path)
    module = sys.modules[__name__]

    # config options
    order = []
    dont_bundle = []
    force_top = []
    depends = {}
    groups = {}
    IE_conditionals = {}
    custom_render_order = {}
    inline_scripts = {}

    # parse the resource.config file if it exists
    config_path = os.path.join(resource_path, 'resource.config')
    if os.path.exists(config_path):
        config = ConfigParser.RawConfigParser()
        config.read(config_path)

        if config.has_option('main', 'order'):
            order = config.get('main', 'order').split()
        if config.has_option('main', 'dont_bundle'):
            dont_bundle = config.get('main', 'dont_bundle').split()
        if config.has_option('main', 'force_top'):
            force_top = config.get('main', 'force_top').split()

        if config.has_section('depends'):
            items = config.items('depends')
            depends = dict((n, v.split()) for (n, v) in items)
        if config.has_section('groups'):
            items = config.items('groups')
            groups = dict((n, v.split()) for (n, v) in items)
        if config.has_section('custom render order'):
            items = config.items('custom render order')
            custom_render_order = dict((n, int(v)) for (n, v) in items)
        if config.has_section('inline scripts'):
            items = config.items('inline scripts')
            inline_scripts = dict((n, v) for (n, v) in items)
        if config.has_section('IE conditional'):
            items = config.items('IE conditional')
            for (n, v) in items:
                files = v.split()
                for f in files:
                    if f not in IE_conditionals:
                        IE_conditionals[f] = []
                    IE_conditionals[f].append(n)

    # add dependencies for resources in groups
    for group in groups:
        if group in depends:
            for resource in groups[group]:
                if resource not in depends:
                    depends[resource] = []
                for dep in depends[group]:
                    if dep not in depends[resource]:
                        depends[resource].append(dep)

    # process each .js/.css file found
    resource_list = []
    for dirname, dirnames, filenames in os.walk(resource_path):
        for f in filenames:
            rel_path = dirname[len(path):]
            if rel_path:
                rel_path = rel_path[1:]
            filepath = os.path.join(rel_path, f)
            if f.endswith('.js') and not f.endswith('.min.js'):
                minify(f, dirname, jsmin)
                resource_list.append(filepath)
            if f.endswith('.css') and not f.endswith('.min.css'):
                minify(f, dirname, cssmin)
                resource_list.append(filepath)

    # if groups are defined make sure the order supplied there is honored
    for group in groups:
        for resource in groups[group]:
            if resource not in order:
                # make sure any dependencies are met when we get to creating
                # the resource
                if resource in depends:
                    for dep in depends[resource]:
                        if dep not in order:
                            order.append(dep)
                order.append(resource)

    # add inline scripts
    for inline in inline_scripts:
        resource_list.append(inline)

    # order resource_list so that resources are created in the correct order
    for resource_name in reversed(order):
        if resource_name in resource_list:
            resource_list.remove(resource_name)
            resource_list.insert(0, resource_name)

    # create the resources and keep them ordered as we define them.
    count = 0
    for resource_name in resource_list:
        if resource_name in inline_scripts:
            inline = inline_scripts[resource_name].strip()
        else:
            inline = None
        create_resource(resource_name, name, count, inline=inline)
        count += 1

    # add groups
    for group_name in groups:
        members = []
        for member in groups[group_name]:
            fanstatic_name = '%s/%s' % (name, member)
            members.append(getattr(module, fanstatic_name))
        group = Group(members)
        fanstatic_name = '%s/%s' % (name, group_name)
        setattr(module, fanstatic_name, group)

    # finally add the library to this module
    setattr(module, name, library)
    # add to fanstatic
    registry = get_library_registry()
    registry.add(library)

base_path = os.path.abspath(os.path.join(os.path.dirname(__file__),
                                         '..', 'public', 'base'))

create_library('vendor', os.path.join(base_path, 'vendor'), depend_base=False)

create_library('datapreview', os.path.join(base_path, 'datapreview'),
               depend_base=False)

create_library('base', os.path.join(base_path, 'javascript'),
               depend_base=False)

create_library('css', os.path.join(base_path, 'css'), depend_base=False)