baked_file_system_mounter

0.6.011 versions

github.com/crystal-china/baked_file_system_mounter

assemble files in assets folder into executable binary use `backed_file_system` at compile time, \ then mount it to new file system folder at runtime.

3 stars
1 dependent
License: MIT

Nothing has been indexed for 0.6.0 yet. The tag is recorded, its shard.yml has not been read, so the manifest and dependency list below are empty because they are unknown rather than because they are absent.

Installation

# Add this to your shard.yml
dependencies:
  baked_file_system_mounter:
    github: crystal-china/baked_file_system_mounter
    version: ~> 0.6.0

Then run:

shards install

shard.yml

No shard.yml has been indexed for 0.6.0. You can read it on the repository.

Dependencies

Unknown: the shard.yml for this version has not been read yet.

README

This README is the one indexed from the repository at its latest ref, not from the tag for this version.

baked_file_system_mounter

Assemble files and directories into an executable binary using baked_file_system at compile time, then mount them onto a new file system at runtime.

Let us assume there are assets folders like this:

PROJECT_ROOT/
  src/assets/
  └── materialize
	  ├── css
	  │   └── materialize.min.css
	  └── js
		  └── materialize.min.js

What we want is:

  1. Assemble assets files in src/assets folder into binary when build.
  2. Then binary into /foo directory on target host, running it will extract assets from binary.

Look like this:

/foo/
  public/
  └── materialize
	  ├── css
	  │   └── materialize.min.css
	  └── js
		  └── materialize.min.js
3 directories, 2 files

With following configuration:

require "baked_file_system_mounter"

BakedFileSystemMounter.assemble(
  {
    "src/assets" => "public",
  }
)

{% if flag?(:release) %}
  BakedFileSystemMounter::Storage.mount
{% end %}

Then you can use those assets both in development (src/assets/materialize) and production (public/materialize), like this:

<html>
  <head>
    <link rel="stylesheet" href="/materialize/css/materialize.min.css" />
  </head>
  <body>
      <%= yield_content "footer" %>
  </body>
</html>

Installation

  1. Add the dependency to your shard.yml:

    dependencies:
  baked_file_system_mounter:
    github: crystal-china/baked_file_system_mounter

  2. Run shards install

Usage

assemble accepts either a Hash or an Array.

Use a Hash when you want to map a source path to a different target path. Source paths may point to either a directory or a single file. Relative source paths are resolved from the compile-time working directory (pwd).

assemble supports string literals and string constants in the mapping. String interpolation and other macro expressions are not supported.

require "baked_file_system_mounter"

BakedFileSystemMounter.assemble(
  {
    "src/assets" => "public",
    "db" => "db",
  }
)

if APP_ENV == "production"
  # Mount files in `src/assets` into `public` and files in `db` into `db`.
  # Target folders will be created if they do not exist.
  BakedFileSystemMounter::Storage.mount
end

String constants are also supported:

ASSETS_DIR = "src/assets"
PUBLIC_DIR = "public"

BakedFileSystemMounter.assemble(
  {
    ASSETS_DIR => PUBLIC_DIR,
  }
)

Single file

You can also bake a single file to an exact target path:

BakedFileSystemMounter.assemble(
  {
    "public/bun-manifest.json" => "public/bun-manifest.json",
  }
)

Directory + file

Directories and files can be mixed in a single assemble call:

BakedFileSystemMounter.assemble(
  {
    "public/assets" => "public/assets",
    "public/bun-manifest.json" => "public/bun-manifest.json",
    "markdowns" => "markdowns",
  }
)

Array shorthand

You can pass an Array as argument too. In this case it uses PWD as the default source and target path for each entry.

BakedFileSystemMounter.assemble(["public", "db"])

# It's same as:

# BakedFileSystemMounter.assemble(
#   {
#     "public" => "public",
#     "db" => "db"
#   }
# )

if APP_ENV == "production" 
  BakedFileSystemMounter::Storage.mount
end

Absolute target path

It can be used to mount assets outside the current directory, for example into /tmp:

BakedFileSystemMounter.assemble(
  {
    "sounds" => "/tmp/sounds",
  }
)

if APP_ENV == "production" 
  BakedFileSystemMounter::Storage.mount
end

Absolute source directory

The source path can also be an absolute directory path:

BakedFileSystemMounter.assemble(
  {
    "/opt/my_app/assets" => "public/assets",
  }
)

Absolute source file

Absolute source paths also work for single files:

BakedFileSystemMounter.assemble(
  {
    "/opt/my_app/bun-manifest.json" => "public/bun-manifest.json",
  }
)

Development

TODO: Write development instructions here

Contributing

  1. Fork it (https://github.com/crystal-china/baked_file_system_mounter/fork)
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create a new Pull Request

Contributors

Documentation

Read the API docs

Built from the current release. The first visit to a release nobody has asked for starts its build.

Links

This release

Version
0.6.0
Tagged
Jun 7, 2026
Commit
22ef4ac757c6
Indexed
not yet

Dependents

Repository

github.com/crystal-china/baked_file_system_mounter

Metadata

Created
Aug 12, 2026
Updated
Aug 15, 2026
Synced
Aug 15, 2026
Versions
11