def generate_code(**kw): resource_to_name = {} resources = [] for name, resource in compat.iteritems(kw): resource_to_name[(resource.library, resource.relpath)] = name resources.append(resource) # libraries with the same name are the same libraries libraries = {} for resource in resources: libraries[resource.library.name] = resource.library for mode_name, mode_resource in compat.iteritems(resource.modes): libraries[mode_resource.library.name] = mode_resource.library libraries = sorted(compat.itervalues(libraries), key=lambda library: library.name) result = [] # import on top result.append("from fanstatic import Library, Resource") result.append("") result.append("# This code is auto-generated and not PEP8 compliant") result.append("") # define libraries for library in libraries: result.append("%s = Library('%s', '%s')" % (library.name, library.name, library.rootpath)) result.append("") # sort resources in the order we want them to be resources = sort_resources_topological(resources) # now generate resource code for resource in resources: s = "%s = Resource(%s, '%s'" % (resource_to_name[ (resource.library, resource.relpath)], resource.library.name, resource.relpath) if resource.depends: depends_s = ', depends=[%s]' % ', '.join([ resource_to_name[(d.library, d.relpath)] for d in resource.depends ]) s += depends_s if resource.supersedes: supersedes_s = ', supersedes=[%s]' % ', '.join([ resource_to_name[(i.library, i.relpath)] for i in resource.supersedes ]) s += supersedes_s if resource.modes: items = [] for mode_name, mode in compat.iteritems(resource.modes): items.append( (mode_name, generate_inline_resource(mode, resource))) items = sorted(items) modes_s = ', %s' % ', '.join( ["%s=%s" % (name, mode) for (name, mode) in items]) s += modes_s s += ')' result.append(s) return '\n'.join(result)
def generate_code(**kw): resource_to_name = {} resources = [] for name, resource in compat.iteritems(kw): resource_to_name[(resource.library, resource.relpath)] = name resources.append(resource) # libraries with the same name are the same libraries libraries = {} for resource in resources: libraries[resource.library.name] = resource.library for mode_name, mode_resource in compat.iteritems(resource.modes): libraries[mode_resource.library.name] = mode_resource.library libraries = sorted(compat.itervalues(libraries), key=lambda library: library.name) result = [] # import on top result.append("from fanstatic import Library, Resource") result.append("") result.append("# This code is auto-generated and not PEP8 compliant") result.append("") # define libraries for library in libraries: result.append("%s = Library('%s', '%s')" % (library.name, library.name, library.rootpath)) result.append("") # sort resources in the order we want them to be resources = sort_resources_topological(resources) # now generate resource code for resource in resources: s = "%s = Resource(%s, '%s'" % ( resource_to_name[(resource.library, resource.relpath)], resource.library.name, resource.relpath) if resource.depends: depends_s = ', depends=[%s]' % ', '.join( [resource_to_name[(d.library, d.relpath)] for d in resource.depends]) s += depends_s if resource.supersedes: supersedes_s = ', supersedes=[%s]' % ', '.join( [resource_to_name[(i.library, i.relpath)] for i in resource.supersedes]) s += supersedes_s if resource.modes: items = [] for mode_name, mode in compat.iteritems(resource.modes): items.append((mode_name, generate_inline_resource(mode, resource))) items = sorted(items) modes_s = ', %s' % ', '.join(["%s=%s" % (name, mode) for (name, mode) in items]) s += modes_s s += ')' result.append(s) return '\n'.join(result)
def __init__(self, slot, resource): self.library = resource.library self.relpath = resource.relpath self.dirname, self.filename = resource.dirname, resource.filename self.bottom = resource.bottom self.dont_bundle = resource.dont_bundle if slot.ext != resource.ext: raise SlotError( "slot requires extension %s but filled with resource " "with extension %s" % (slot.ext, resource.ext) ) self.ext = resource.ext self.order = resource.order self.renderer = resource.renderer self.dependency_nr = slot.dependency_nr self.modes = {} for key, resource in compat.iteritems(resource.modes): self.modes[key] = FilledSlot(slot, resource) if not resource.depends.issubset(slot.depends): raise SlotError( "slot filled in with resource that has dependencies that " "are not a strict subset of dependencies of slot" )
def __init__(self, slot, resource): self.filledby = resource self.library = resource.library self.relpath = resource.relpath self.dirname, self.filename = resource.dirname, resource.filename self.bottom = resource.bottom self.rollups = resource.rollups self.dont_bundle = resource.dont_bundle if slot.ext != resource.ext: raise SlotError( "slot requires extension %s but filled with resource " "with extension %s" % (slot.ext, resource.ext)) self.ext = resource.ext self.order = resource.order self.renderer = resource.renderer self.dependency_nr = slot.dependency_nr self.modes = {} for key, resource in compat.iteritems(resource.modes): self.modes[key] = FilledSlot(slot, resource) if not resource.depends.issubset(slot.depends): raise SlotError( "slot filled in with resource that has dependencies that " "are not a strict subset of dependencies of slot")
def convert_config(config): result = {} for key, value in compat.iteritems(config): if key in BOOL_CONFIG: result[key] = asbool(value) else: result[key] = value return result
def __init__( self, library, relpath, depends=None, supersedes=None, bottom=False, renderer=None, debug=None, dont_bundle=False, minified=None, ): self.library = library fullpath = os.path.normpath(os.path.join(library.path, relpath)) if _resource_file_existence_checking and not os.path.exists(fullpath): raise UnknownResourceError("Resource file does not exist: %s" % fullpath) self.relpath = relpath self.dirname, self.filename = os.path.split(relpath) if self.dirname and not self.dirname.endswith("/"): self.dirname += "/" self.bottom = bottom self.dont_bundle = dont_bundle self.ext = os.path.splitext(self.relpath)[1] if renderer is None: # No custom, ad-hoc renderer for this Resource, so lookup # the default renderer by resource filename extension. if self.ext not in inclusion_renderers: raise UnknownResourceExtensionError( "Unknown resource extension %s for resource: %s" % (self.ext, repr(self)) ) self.order, self.renderer = inclusion_renderers[self.ext] else: # Use the custom renderer. self.renderer = renderer # If we do not know about the filename extension inclusion # order, we render the resource after all others. self.order, _ = inclusion_renderers.get(self.ext, (compat.maxsize, None)) assert not isinstance(depends, compat.basestring) self.depends = set() if depends is not None: # Normalize groups into the underlying resources... depends = normalize_groups(depends) # ...before updating the set of dependencies of this resource. self.depends.update(depends) self.resources = set([self]) for depend in self.depends: self.resources.update(depend.resources) # Check for library dependency cycles. self.library.check_dependency_cycle(self) # generate an internal number for sorting the resource # on dependency within the library self.init_dependency_nr() self.modes = {} for mode_name, argument in [(DEBUG, debug), (MINIFIED, minified)]: if argument is None: continue elif isinstance(argument, compat.basestring): mode_resource = Resource( library, argument, bottom=bottom, renderer=renderer, depends=depends, dont_bundle=dont_bundle ) else: # The dependencies of a mode resource should be the same # or a subset of the dependencies this mode replaces. if len(argument.depends - self.depends) > 0: raise ModeResourceDependencyError mode_resource = argument mode_resource.dependency_nr = self.dependency_nr self.modes[mode_name] = mode_resource assert not isinstance(supersedes, compat.basestring) self.supersedes = supersedes or [] self.rollups = [] # create a reference to the superseder in the superseded resource for resource in self.supersedes: resource.rollups.append(self) # also create a reference to the superseding mode in the superseded # mode # XXX what if mode is full-fledged resource which lists # supersedes itself? for mode_name, mode in compat.iteritems(self.modes): for resource in self.supersedes: superseded_mode = resource.mode(mode_name) # if there is no such mode, let's skip it if superseded_mode is resource: continue mode.supersedes.append(superseded_mode) superseded_mode.rollups.append(mode) # Register ourself with the Library. self.library.register(self)
def __init__(self, library, relpath, depends=None, supersedes=None, bottom=False, renderer=None, debug=None, dont_bundle=False, minified=None): self.library = library fullpath = os.path.normpath(os.path.join(library.path, relpath)) if _resource_file_existence_checking and not os.path.exists(fullpath): raise UnknownResourceError("Resource file does not exist: %s" % fullpath) self.relpath = relpath self.dirname, self.filename = os.path.split(relpath) if self.dirname and not self.dirname.endswith('/'): self.dirname += '/' self.bottom = bottom self.dont_bundle = dont_bundle self.ext = os.path.splitext(self.relpath)[1] if renderer is None: # No custom, ad-hoc renderer for this Resource, so lookup # the default renderer by resource filename extension. if self.ext not in inclusion_renderers: raise UnknownResourceExtensionError( "Unknown resource extension %s for resource: %s" % (self.ext, repr(self))) self.order, self.renderer = inclusion_renderers[self.ext] else: # Use the custom renderer. self.renderer = renderer # If we do not know about the filename extension inclusion # order, we render the resource after all others. self.order, _ = inclusion_renderers.get(self.ext, (compat.maxsize, None)) assert not isinstance(depends, compat.basestring) self.depends = set() if depends is not None: # Normalize groups into the underlying resources... depends = normalize_groups(depends) # ...before updating the set of dependencies of this resource. self.depends.update(depends) self.resources = set([self]) for depend in self.depends: self.resources.update(depend.resources) # Check for library dependency cycles. self.library.check_dependency_cycle(self) # generate an internal number for sorting the resource # on dependency within the library self.init_dependency_nr() self.modes = {} for mode_name, argument in [(DEBUG, debug), (MINIFIED, minified)]: if argument is None: continue elif isinstance(argument, compat.basestring): mode_resource = Resource(library, argument, bottom=bottom, renderer=renderer, depends=depends, dont_bundle=dont_bundle) else: # The dependencies of a mode resource should be the same # or a subset of the dependencies this mode replaces. if len(argument.depends - self.depends) > 0: raise ModeResourceDependencyError mode_resource = argument mode_resource.dependency_nr = self.dependency_nr self.modes[mode_name] = mode_resource assert not isinstance(supersedes, compat.basestring) self.supersedes = supersedes or [] self.rollups = [] # create a reference to the superseder in the superseded resource for resource in self.supersedes: resource.rollups.append(self) # also create a reference to the superseding mode in the superseded # mode # XXX what if mode is full-fledged resource which lists # supersedes itself? for mode_name, mode in compat.iteritems(self.modes): for resource in self.supersedes: superseded_mode = resource.mode(mode_name) # if there is no such mode, let's skip it if superseded_mode is resource: continue mode.supersedes.append(superseded_mode) superseded_mode.rollups.append(mode) # Register ourself with the Library. self.library.register(self)