assemble/assemble
Assemble
Assemble is a static site generator and build pipeline system that compiles markdown, templates, and data into static HTML files. It functions as a markdown-to-HTML converter and a data format transformer capable of moving content between JSON, YAML, XML, PLIST, and CSV formats.
The project features a pipeline-based build process where users can define ordered sequences of data transformations and file processing steps. It includes project scaffolding tools to bootstrap directory structures and configuration files from predefined boilerplates.
The system manages content through collection-based filtering and hierarchical layout nesting, allowing pages to be organized by tags and categories. It supports pluggable template engines, customizable helper functions, and the injection of YAML front-matter metadata to control rendering logic.
The toolkit also provides utilities for compiling LESS stylesheets, managing site permalinks, and monitoring files for changes to trigger automated build tasks.
Features
- Markdown-HTML Content Converters - Transforms markdown content and YAML front matter into structured HTML for web pages.
- Static Site Generators - Transforms source files and templates into optimized static HTML documents for web deployment.
- Static Site Generators - Compiles markdown, templates, and data into a standalone set of static HTML files for websites and documentation.
- Build Pipelines - Provides a pipeline-based build process to execute ordered sequences of data transformations.
- Sequential Build Step Orchestration - Creates a pipeline of functions that execute in a specific order to process and transform data.
- YAML Processing - Processes data serialized in YAML format as an alternative to JSON for configurations and content.
- Category Organizations - Associates pages with categories and tags via front matter to group related content into collections.
- Collection-Based Content Filtering - Provides collection-based filtering to group source files by tags or categories for filtered retrieval during rendering.
- Markdown Transformation Pipelines - Utilizes a pipeline to convert structured Markdown source files into rendered HTML pages.
- HTML Document Wrapping - Wraps converted content into complete HTML documents with common structural elements like headers and footers.
- Markdown Renderers - Transforms Markdown text into HTML to simplify the authoring process for long-form documentation.
- Markdown to HTML Converters - Transforms Markdown plaintext markup into structured HTML for web display.
- Content Metadata Management - Implements YAML front-matter to manage page-level metadata such as titles, dates, and custom variables.
- Collection-Based Page Groupings - Iterates through groups of source files to inject metadata and content into a shared layout.
- Static Page Rendering - Pre-renders content into static HTML files during the build process to optimize load times.
- Static Site Build Systems - Triggers the full sequence of configured processing steps to generate final static HTML files.
- Template Partial Reuse - Includes reusable template snippets that can be embedded across multiple pages to maintain consistency.
- Multi-Format - Imports content from JSON files, YAML files, and front-matter to make values available to templates.
- Front-Matter Indexing - Implements front-matter indexing to extract YAML metadata from file headers for controlling rendering logic.
- Build Pipeline Orchestration - Defines and executes a sequence of data transformations and file processing steps to generate final project outputs.
- Template Helpers - Adds custom helper functions to perform complex data transformations and formatting during the build process.
- Stream Processing - Reads source files using glob patterns and pipes them through transformation sequences to a destination.
- Template-Based Page Generators - Generates multiple pages from a single template by iterating over data and file segments.
- Site Data Context Builders - Combines front matter, external data files, and global context to assemble a comprehensive data context for template rendering.
- Build and Task Automation - Defines named sequences of operations that can be executed individually or in groups to automate builds.
- Configuration File Loading - Reads JSON and YAML files to populate template variables and configuration settings during the rendering process.
- Template Variables - Provides user-defined variables in the root data context for global availability within templates.
- Template Variable Transformers - Provides filters for manipulating the value of variables during the rendering process to change their format.
- Build Stream Processing - Processes files as streams using globs and transformation pipes within the build context.
- Custom Helper Creation - Loads external logic files into the rendering engine to extend functionality via custom helpers.
- Template Helper Registrations - Adds custom filters and helper functions to the template engine for data transformation during rendering.
- Global Variable Injections - Injects custom data into the build task root context to make values available across all templates.
- Template Helpers - Integrates custom helper functions or external library helpers directly into the rendering pipeline.
- Template Inheritance Layouts - Implements template inheritance allowing child layouts to inherit common structural elements from a master parent.
- Page Layout Templates - Wraps rendered content in specified layout files to ensure consistent page structures.
- Page Layout Templates - Uses layouts, partials, and custom helpers to structure content and ensure consistent page design.
- Partial Templates - Links reusable template fragments to a project to be injected into larger pages.
- Content Collection Managers - Organizes templates into cached collections and assigns them roles as layouts, partials, or pages.
- Metadata and Script Injection - Exposes file path properties and YAML front-matter to templates to control rendering and content.
- Nested Layouts - Supports nested layouts that allow templates to inherit structural elements through a parent-child hierarchy.
- HTML Content Renderers - Generates HTML, JSON, XML, or CSS by processing content through pluggable templating engines.
- Template Data Injection - Injects structured data and associative arrays from file headers into the templating engine during rendering.
- UI Template Injection - Injects structured data from external JSON or YAML files into HTML view templates to generate dynamic content.
- Content Tag Filtering - Retrieves specific subsets of pages from collections based on assigned tags to create categorized lists.
- Documentation Site Templates - Creates project structures from pre-defined templates specifically tailored for documentation and wikis.
- Markdown to HTML Renderers - Wraps blocks of markdown text within HTML documents to ensure they are converted during the build process.
- Page Layout Configurations - Allows assigning layouts at global, target, or individual page levels to control rendering scope.
- Permalink Generators - Generates permanent, clean URIs for pages using configurable replacement patterns and date parsing.
- Dynamic Front-Matter Evaluation - Evaluates template variables within YAML front-matter to translate external values into page-specific data.
- Reusable Content Fragments - Embeds shared snippets of code and content into multiple pages to reduce duplication.
- Data Format Transformations - Converts files between JSON, YAML, XML, PLIST, and CSV formats using a transformation engine.
- Multi-Format Serializers - Converts and loads content between JSON, YAML, XML, and CSV formats to populate the template context.
- Taxonomy Page Generators - Automatically generates index pages listing all tags and categories used across the site.
- Project Boilerplates - Initializes projects using pre-configured boilerplates for sites, wikis, or documentation.
- Project Bootstrapping - Bootstraps new project folders with predefined templates, data, and themes.
- Project Scaffolding - Generates starting directory structures and configuration files using templates to accelerate setup.
- Project Scaffolding Templates - Generates directory structures and configuration files from pre-defined boilerplates to accelerate project initialization.
- Project Scaffolding Tools - Provides a utility for bootstrapping project structures and initializing directories from predefined boilerplates.
- Pluggable Template Renderers - Integrates external rendering libraries through a standardized interface to support multiple templating languages.
- Source File Watching - Monitors files for changes and automatically triggers defined build tasks.
- Build-Time File Exclusions - Uses metadata flags to determine if a file should be excluded from the final build.
- Template Engine Abstractions - Provides a common interface to plug in external templating libraries via initialization functions.
- Page Visibility Controls - Allows users to exclude specific pages from being rendered or accessible based on metadata flags.
- Front-Matter Metadata Managers - Uses a logic-capable templating engine to manage configuration, data files, and YAML front matter.
- Template Engine Integrations - Supports the integration of different templating languages to define how data is injected into layouts.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
