plum-cms 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0c045923ca6053faa960068411e9c23cb65653738a29644caae57f592700eb0
-  data.tar.gz: 3bdab444dc9ca623c1207f9736e4a65d5e34b43a8a3d8d39bf1f67472884b0ac
+  metadata.gz: 277d5241551a05b136eebf29f83e6347c7fc15a9d600054c524a245ab18010b4
+  data.tar.gz: 336177aba310b7b33b4fddab22190b0ac3a1fec3ad330fb1c09552459ffc8def
 SHA512:
-  metadata.gz: 3b12a09d3b0af6237fd8fe397101d30e35aaa92fcc48279b140b1ab37fa1279c4cb8c6f234a190fc08078be6d534257677de5d7d774507bf42cc403de78e3b25
-  data.tar.gz: 83f896aa5c05d595d80b97ea9ca17b445dbb51d82ab7925efcbdd2f43f3a93ae4169e7072592255f5d57e6640a6dfc4886e3c2a2773cb01ded724bdd4bb8e1c6
+  metadata.gz: 8ad29dfd4e8927c9259276e8c3d0cd916eb3e3b2ae74327ee32f511c67db9779613190a637b92ef4903cc0f6d440d620a6212103fad74d268202007e54b9e84c
+  data.tar.gz: e01f9d033d20d606da90e74078155e5d825c727b89162b7e750eeac5c9f3aabc048a7c3c8c29ddb241ba7d3aa4a727458f1150b04475a898c44ba8a1d80f1316

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.2.1 — 2026-08-07
+
+### Added
+
+- Added versioned, checksum-verified site archives covering content schemas,
+  entries, relationships, taxonomies, navigation, globals, forms, settings,
+  revisions, and original asset files.
+- Added export/import and timestamped backup/restore Rake tasks with safe
+  new-site restoration and identifier remapping.
+- Reframed the roadmap around a production-readiness 0.3.0 milestone.
+
+### Fixed
+
+- Corrected the packaged Propshaft search path so engine Stimulus controllers
+  resolve under their `plum/` import-map namespace in external applications.
+- Upgraded Lexxy so pasted plain text preserves paragraph boundaries and
+  block formatting only changes the active paragraph.
+
 ## 0.2.0 — 2026-08-07
 
 ### Added

data/README.md

@@ -228,6 +228,21 @@ Pagination variables: `pagination.current_page`, `pagination.total_pages`,
 `/search?q=term` searches entry titles and slugs. Themes provide a
 `search.liquid` template with a search form and results.
 
+## Portability and backups
+
+Plum can move or recover an entire site—including assets and remapped content
+relationships—with versioned archives:
+
+```sh
+bin/rails plum:site:export ARCHIVE=site.plum.zip
+bin/rails plum:site:import ARCHIVE=site.plum.zip
+bin/rails plum:backup:create DIRECTORY=/var/backups/plum
+bin/rails plum:backup:restore ARCHIVE=/var/backups/plum/site.plum.zip
+```
+
+See [the portability guide](docs/portability.md) for archive guarantees and
+production backup guidance.
+
 ## Content API
 
 Published entries are available through a read-only, site-scoped JSON API:

data/app/services/plum/site_archive.rb

@@ -0,0 +1,367 @@
+require "json"
+require "zip"
+require "digest"
+require "tempfile"
+
+module Plum
+  module SiteArchive
+    FORMAT = "plum-site"
+    VERSION = 1
+
+    class Error < StandardError; end
+    class InvalidArchive < Error; end
+
+    module_function
+
+    def dump(site:, path:)
+      Exporter.new(site).write(path)
+    end
+
+    def load(path:, name: nil, domain: nil)
+      Importer.new(path).import(name: name, domain: domain)
+    end
+
+    class Exporter
+      def initialize(site)
+        @site = site
+      end
+
+      def write(path)
+        destination = Pathname(path).expand_path
+        destination.dirname.mkpath
+        FileUtils.rm_f(destination)
+
+        Zip::File.open(destination, create: true) do |zip|
+          zip.get_output_stream("manifest.json") { |stream| stream.write(JSON.pretty_generate(manifest)) }
+          site.assets.with_attached_file.find_each do |asset|
+            next unless asset.file.attached?
+
+            zip.get_output_stream(asset_path(asset)) do |stream|
+              asset.file.blob.open { |file| IO.copy_stream(file, stream) }
+            end
+          end
+        end
+        destination
+      end
+
+      private
+
+      attr_reader :site
+
+      def manifest
+        {
+          "format" => FORMAT,
+          "format_version" => VERSION,
+          "plum_version" => Plum::VERSION,
+          "exported_at" => Time.current.iso8601,
+          "site" => record(site, %w[id name domain theme_name settings theme_settings custom_css]),
+          "site_setting" => site.site_setting && record(site.site_setting, site_setting_fields),
+          "content_types" => records(site.content_types, %w[id name handle singleton blueprint icon]),
+          "fieldsets" => records(site.fieldsets, %w[id name handle fields]),
+          "taxonomies" => records(site.taxonomies, %w[id name handle slug]),
+          "terms" => records(site.terms, %w[id taxonomy_id name slug position]),
+          "assets" => site.assets.with_attached_file.order(:id).map { |asset| asset_record(asset) },
+          "entries" => site.entries.order(:id).map { |entry| entry_record(entry) },
+          "entry_revisions" => revision_records,
+          "globals" => records(site.globals, %w[id name handle data]),
+          "nav_menus" => records(site.nav_menus, %w[id name handle]),
+          "nav_items" => records(site.nav_items.unscoped.where(site: site), %w[id nav_menu_id parent_id entry_id label url position]),
+          "form_definitions" => records(site.form_definitions, %w[id name handle fields notification_email]),
+          "form_submissions" => records(site.form_submissions, %w[id form_definition_id data created_at updated_at])
+        }.compact
+      end
+
+      def site_setting_fields
+        %w[name tagline logo favicon seo_title seo_description theme_name primary_color support_email]
+      end
+
+      def entry_record(entry)
+        record(entry, %w[id content_type_id title slug status data published_at author_name author_email author_gid locale origin_id]).merge(
+          "term_ids" => entry.term_ids
+        )
+      end
+
+      def revision_records
+        site.entries.includes(:revisions).flat_map do |entry|
+          entry.revisions.order(:id).map do |revision|
+            record(revision, %w[id entry_id editor_name editor_email editor_gid snapshot created_at updated_at])
+          end
+        end
+      end
+
+      def asset_record(asset)
+        record(asset, %w[id alt_text caption folder focal_x focal_y]).merge(
+          "filename" => asset.filename,
+          "content_type" => asset.content_type,
+          "byte_size" => asset.file.byte_size,
+          "checksum" => asset.file.blob.checksum,
+          "path" => asset_path(asset)
+        )
+      end
+
+      def asset_path(asset)
+        "assets/#{asset.id}/#{asset.filename.gsub(/[^A-Za-z0-9._-]/, "_")}"
+      end
+
+      def records(scope, fields)
+        scope.order(:id).map { |item| record(item, fields) }
+      end
+
+      def record(item, fields)
+        item.attributes.slice(*fields)
+      end
+    end
+
+    class Importer
+      def initialize(path)
+        @path = Pathname(path).expand_path
+        @maps = Hash.new { |hash, key| hash[key] = {} }
+        @uploaded_blobs = []
+      end
+
+      def import(name: nil, domain: nil)
+        raise InvalidArchive, "Archive does not exist: #{path}" unless path.file?
+
+        Zip::File.open(path) do |zip|
+          @zip = zip
+          @data = parse_manifest(zip)
+          validate_manifest!
+          ActiveRecord::Base.transaction { import_site(name:, domain:) }
+        end
+      rescue StandardError => error
+        cleanup_uploaded_files
+        raise unless error.is_a?(Zip::Error) || error.is_a?(JSON::ParserError)
+
+        raise InvalidArchive, error.message
+      ensure
+        @zip = nil
+      end
+
+      private
+
+      attr_reader :path, :data, :maps, :zip
+
+      def parse_manifest(zip_file)
+        entry = zip_file.find_entry("manifest.json")
+        raise InvalidArchive, "Archive is missing manifest.json" unless entry
+
+        JSON.parse(entry.get_input_stream.read)
+      end
+
+      def validate_manifest!
+        raise InvalidArchive, "Not a Plum site archive" unless data["format"] == FORMAT
+        raise InvalidArchive, "Unsupported archive version #{data['format_version'].inspect}" unless data["format_version"] == VERSION
+        raise InvalidArchive, "Archive is missing site data" unless data["site"].is_a?(Hash)
+      end
+
+      def import_site(name:, domain:)
+        source = data.fetch("site")
+        @site = Site.create!(
+          name: name.presence || source.fetch("name"),
+          domain: domain.nil? ? source["domain"] : domain,
+          theme_name: source["theme_name"],
+          settings: source["settings"] || {},
+          theme_settings: source["theme_settings"] || {},
+          custom_css: source["custom_css"],
+          skip_defaults: true
+        )
+        maps[:sites][source["id"]] = @site.id
+
+        import_simple(:content_types, ContentType, %w[name handle singleton blueprint icon])
+        import_simple(:fieldsets, Fieldset, %w[name handle fields])
+        import_simple(:taxonomies, Taxonomy, %w[name handle slug])
+        import_terms
+        import_assets
+        import_entries
+        import_entry_links
+        import_globals
+        import_navigation
+        import_forms
+        import_site_setting
+        @site
+      end
+
+      def import_simple(key, model, fields)
+        Array(data[key.to_s]).each do |source|
+          item = model.create!(source.slice(*fields).merge("site_id" => @site.id))
+          maps[key][source["id"]] = item.id
+        end
+      end
+
+      def import_terms
+        Array(data["terms"]).each do |source|
+          term = Term.create!(source.slice("name", "slug", "position").merge(
+            "site_id" => @site.id,
+            "taxonomy_id" => mapped!(:taxonomies, source["taxonomy_id"])
+          ))
+          maps[:terms][source["id"]] = term.id
+        end
+      end
+
+      def import_assets
+        Array(data["assets"]).each do |source|
+          archive_entry = zip.find_entry(source.fetch("path"))
+          raise InvalidArchive, "Archive is missing asset #{source['path']}" unless archive_entry
+
+          asset = import_asset(source, archive_entry)
+          maps[:assets][source["id"]] = asset.id
+        end
+      end
+
+      def import_asset(source, archive_entry)
+        Tempfile.create([ "plum-asset", File.extname(source.fetch("filename")) ], binmode: true) do |file|
+          digest = Digest::MD5.new
+          bytes = 0
+          input = archive_entry.get_input_stream
+          while (chunk = input.read(64 * 1024))
+            file.write(chunk)
+            digest.update(chunk)
+            bytes += chunk.bytesize
+          end
+          expected_checksum = source["checksum"].to_s
+          actual_checksum = [ digest.digest ].pack("m0")
+          raise InvalidArchive, "Asset #{source['path']} has an invalid size" if source["byte_size"].present? && bytes != source["byte_size"].to_i
+          raise InvalidArchive, "Asset #{source['path']} failed its checksum" if expected_checksum.present? && actual_checksum != expected_checksum
+
+          file.rewind
+          asset = Asset.new(source.slice("alt_text", "caption", "folder", "focal_x", "focal_y").merge("site_id" => @site.id))
+          blob = ActiveStorage::Blob.create_and_upload!(
+            io: file,
+            filename: source.fetch("filename"),
+            content_type: source["content_type"]
+          )
+          @uploaded_blobs << blob
+          asset.file.attach(blob)
+          asset.save!
+          asset
+        end
+      end
+
+      def import_entries
+        Array(data["entries"]).each do |source|
+          entry = Entry.create!(source.slice("title", "slug", "status", "data", "published_at", "author_name", "author_email", "author_gid", "locale").merge(
+            "site_id" => @site.id,
+            "content_type_id" => mapped!(:content_types, source["content_type_id"])
+          ))
+          maps[:entries][source["id"]] = entry.id
+        end
+      end
+
+      def import_entry_links
+        entries_by_id = Array(data["entries"]).index_by { |item| item["id"] }
+        entries_by_id.each do |old_id, source|
+          entry = Entry.find(mapped!(:entries, old_id))
+          fields = entry.content_type.fields
+          entry.update_columns(
+            data: remap_field_values(source["data"] || {}, fields),
+            origin_id: mapped(:entries, source["origin_id"]),
+            updated_at: Time.current
+          )
+          entry.term_ids = Array(source["term_ids"]).filter_map { |id| mapped(:terms, id) }
+        end
+
+        Array(data["entry_revisions"]).each do |source|
+          snapshot = source["snapshot"].to_h.deep_dup
+          entry = Entry.find(mapped!(:entries, source["entry_id"]))
+          snapshot["data"] = remap_field_values(snapshot["data"] || {}, entry.content_type.fields)
+          snapshot["term_ids"] = Array(snapshot["term_ids"]).filter_map { |id| mapped(:terms, id) }
+          EntryRevision.create!(source.slice("editor_name", "editor_email", "editor_gid", "created_at", "updated_at").merge(
+            "site_id" => @site.id, "entry_id" => entry.id, "snapshot" => snapshot
+          ))
+        end
+      end
+
+      def remap_field_values(values, fields)
+        result = values.to_h.deep_dup
+        Array(fields).each do |field|
+          handle = field["handle"].to_s
+          value = result[handle]
+          result[handle] = case field["type"]
+          when "image" then mapped(:assets, value)
+          when "images" then Array(value).filter_map { |id| mapped(:assets, id) }
+          when "relationship"
+            field["multiple"] ? Array(value).filter_map { |id| mapped(:entries, id) } : mapped(:entries, value)
+          when "group" then remap_field_values(value || {}, field["fields"])
+          when "repeater" then Array(value).map { |row| remap_field_values(row, field["fields"]) }
+          when "blocks" then remap_blocks(value)
+          else value
+          end
+        end
+        result
+      end
+
+      def remap_blocks(value)
+        library = BlockLibrary.new(@site.theme)
+        Array(value).map do |block|
+          restored = block.to_h.deep_dup
+          definition = library.definition(restored["type"])
+          restored["fields"] = remap_field_values(restored["fields"] || {}, definition&.dig("fields") || [])
+          restored
+        end
+      end
+
+      def import_globals
+        Array(data["globals"]).each do |source|
+          Global.create!(source.slice("name", "handle", "data").merge("site_id" => @site.id))
+        end
+      end
+
+      def import_navigation
+        import_simple(:nav_menus, NavMenu, %w[name handle])
+        pending = Array(data["nav_items"]).sort_by { |item| item["parent_id"].present? ? 1 : 0 }
+        until pending.empty?
+          imported = pending.reject! do |source|
+            next false if source["parent_id"].present? && mapped(:nav_items, source["parent_id"]).blank?
+
+            item = NavItem.create!(source.slice("label", "url", "position").merge(
+              "site_id" => @site.id,
+              "nav_menu_id" => mapped!(:nav_menus, source["nav_menu_id"]),
+              "parent_id" => mapped(:nav_items, source["parent_id"]),
+              "entry_id" => mapped(:entries, source["entry_id"])
+            ))
+            maps[:nav_items][source["id"]] = item.id
+            true
+          end
+          raise InvalidArchive, "Navigation contains an invalid parent cycle" unless imported
+        end
+      end
+
+      def import_forms
+        import_simple(:form_definitions, FormDefinition, %w[name handle fields notification_email])
+        Array(data["form_submissions"]).each do |source|
+          submission = FormSubmission.new(source.slice("data", "created_at", "updated_at").merge(
+            "site_id" => @site.id,
+            "form_definition_id" => mapped!(:form_definitions, source["form_definition_id"])
+          ))
+          submission.save!(validate: false)
+        end
+      end
+
+      def import_site_setting
+        source = data["site_setting"]
+        return SiteSetting.instance(@site) unless source
+
+        attributes = source.except("id")
+        attributes["logo"] = mapped(:assets, source["logo"].to_i)&.to_s if source["logo"].present?
+        attributes["favicon"] = mapped(:assets, source["favicon"].to_i)&.to_s if source["favicon"].present?
+        SiteSetting.create!(attributes.merge("site_id" => @site.id))
+      end
+
+      def mapped(type, old_id)
+        return if old_id.blank?
+
+        maps[type][old_id] || maps[type][old_id.to_i]
+      end
+
+      def mapped!(type, old_id)
+        mapped(type, old_id) || raise(InvalidArchive, "Missing #{type.to_s.singularize} reference #{old_id.inspect}")
+      end
+
+      def cleanup_uploaded_files
+        @uploaded_blobs.each { |blob| blob.service.delete(blob.key) }
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/docs/portability.md

@@ -0,0 +1,40 @@
+# Site export, import, backup, and restore
+
+Plum 0.3 archives are versioned ZIP files containing a JSON manifest and the
+original bytes of every attached asset. The manifest carries schemas, entries,
+relationships, translations, taxonomies, navigation, globals, forms, fieldsets,
+settings, revisions, and submissions. Import remaps database identifiers so an
+archive can be restored into a different database without collisions.
+
+## Export and import
+
+```sh
+bin/rails plum:site:export ARCHIVE=/safe/location/site.plum.zip SITE_ID=1
+bin/rails plum:site:import ARCHIVE=/safe/location/site.plum.zip NAME="Imported site" DOMAIN=example.com
+```
+
+`SITE_ID` is optional when exporting and defaults to the first site. `NAME` and
+`DOMAIN` are optional import overrides. Import always creates a new site; it
+never overwrites an existing site.
+
+## Backup and restore
+
+```sh
+bin/rails plum:backup:create SITE_ID=1 DIRECTORY=/var/backups/plum
+bin/rails plum:backup:restore ARCHIVE=/var/backups/plum/plum-site-1-TIMESTAMP.plum.zip
+```
+
+The backup task writes a timestamped archive. Restore uses the same safe,
+new-site import path. Assets are checked against their recorded byte size and
+checksum before the database transaction commits. Missing, corrupt, or
+unsupported archives fail without leaving a partially imported site.
+
+Backups must be copied off the application host and tested regularly. An archive
+does not include application code, environment secrets, users, or the host
+database outside the selected Plum site.
+
+## Archive compatibility
+
+The manifest currently uses format version `1`. Plum rejects archive versions
+it does not understand instead of guessing. Future format changes will either
+remain readable or ship an explicit migration path.

data/docs/roadmap.md

@@ -1,76 +1,79 @@
 # Roadmap
 
-Plum's roadmap is organized by outcomes rather than promised dates. Items move
-as the product is exercised in real applications and the Rails community gives
-feedback.
-
-## Now: Make Plum Real and Adoptable
-
-The current milestone is to build and publish the Plum marketing and
-documentation site as a standalone Rails application powered by Plum and
-SQLite.
-
-### Product foundation
-
-- Publish a clear vision, product principles, and supported use cases.
-- Build `plumcms.org` with Plum as an external dependency.
-- Define a portable production layout for the SQLite database, uploaded assets,
-  and mutable site data.
-- Package the site as an ONCE-compatible Docker application.
-- Exercise installation, initialization, health checks, upgrades, backup, and
-  restore on a real VM.
-- Keep SQLite and PostgreSQL verification in CI.
-
-### Documentation
-
-- Document installation and the first editable page.
-- Document sites, content types, fields, entries, and publishing.
-- Document blocks, assets, relationships, taxonomies, navigation, globals, and
-  forms.
-- Document Liquid themes and host content sources.
-- Document embedded authentication, authorization, tenancy, and routing.
-- Document standalone SQLite and embedded PostgreSQL deployments.
-- Publish configuration, troubleshooting, and upgrade references.
-
-### Distribution
-
-- Publish the `plum` gem.
-- State supported Ruby and Rails versions.
-- Establish semantic versioning and an upgrade policy.
-- Test fresh external installations and upgrades in CI.
-- Provide a production-ready container contract and example application.
-
-## Next: Editorial Confidence and Portability
-
-Once the public site proves the basic workflow, focus on the features editors
-and agencies need to trust Plum in production.
-
-- Draft preview.
-- Revisions and rollback.
-- Scheduled publishing.
-- Multi-entry relationships.
-- Reusable blocks and sections.
-- Content, schema, and asset export/import.
-- Document hierarchy, tables of contents, and site search.
-- SEO metadata, canonical URLs, sitemaps, feeds, and redirect management.
-- Stronger asset organization and image editing.
-- Form spam protection and improved submission workflows.
-- Tested backup and restore commands.
+Plum's roadmap is organized by outcomes rather than promised dates. Priorities
+move as the product is exercised in real Rails applications.
 
-## Later: The Rails Content Ecosystem
+## Shipped: Plum 0.2.0 — Authoring Foundation
 
-After installation and production operation are dependable, make Plum easier to
-adopt repeatedly and extend publicly.
+Plum 0.2.0 established the practical authoring surface:
 
-- A thin `plum` CLI for new sites, diagnostics, themes, export/import, upgrades,
-  and packaging.
-- Starter applications for common content-site use cases.
-- A documented extension contract for fields, blocks, and content sources.
-- A collection of high-quality open themes and blocks.
+- a visual blueprint builder with 21 field types, reusable fieldsets, nested
+  structures, validation, field widths, sections, and conditions;
+- assets with single and multiple image fields, metadata, focal points, and
+  responsive variants;
+- relationships, taxonomies, navigation, globals, forms, and Liquid themes;
+- drafts, scheduled publishing, immutable revisions, and rollback;
+- localized entries, locale-aware public routes, and a live-only content API;
+- registry-backed custom field types and packaged Tailwind control-panel styles.
+
+See [the Statamic parity matrix](statamic-parity.md) for the supported surface.
+
+## Now: Plum 0.3.0 — Production Readiness
+
+The 0.3.0 milestone makes Plum safe to adopt, move, recover, and operate outside
+its development repository.
+
+### 1. Portability and recovery
+
+- Versioned site export/import covering schemas, entries, relationships,
+  taxonomies, navigation, globals, forms, settings, and assets.
+- Tested backup and restore commands with integrity checks and clear failure
+  behavior.
+- A documented archive format that remains readable across compatible releases.
+
+### 2. Real-world installation
+
+- Build `plumcms.org` as a standalone Rails application using the released gem.
+- Test fresh external installations and 0.2.x upgrades in CI.
+- Publish a production Docker contract and SQLite deployment example.
+- Exercise health checks, upgrades, persistence, backup, and restore on a VM.
+
+### 3. Publishing and discovery
+
+- SEO metadata, canonical URLs, redirects, XML sitemaps, and feeds.
+- Document hierarchy, breadcrumbs, generated tables of contents, and site search.
+- Secure, shareable preview links for draft and scheduled content.
+
+### 4. Editorial operations
+
+- Asset folders, search, replacement, cropping, and richer transformations.
+- Granular editorial roles, approvals, and publish permissions.
+- Form spam protection and improved submission review/export workflows.
+
+### 5. Documentation
+
+- Complete installation and first-page guides.
+- Document every supported field and content primitive.
+- Document standalone SQLite and embedded PostgreSQL operation.
+- Publish configuration, troubleshooting, extension, upgrade, backup, and
+  restore references.
+
+## Next: Plum 0.4.0 — Repeatable Adoption
+
+- A thin `plum` CLI for diagnostics, export/import, backup/restore, upgrades,
+  themes, and packaging.
+- Starter applications for common publishing use cases.
 - Theme scaffolding, validation, packaging, and distribution tools.
+- A collection of high-quality open themes and blocks.
 - Importers for common CMS and structured-data formats.
-- Optional content APIs for applications that genuinely need them.
+- Addon discovery and a documented compatibility contract.
+
+## Later: The Rails Content Ecosystem
+
+- Translation-service integrations and richer localization workflows.
+- Agency-oriented multisite operations and reusable project recipes.
 - Community examples, case studies, talks, and contribution programs.
+- Broader content APIs where real applications demonstrate the need.
 
 ## Plum 1.0
 
@@ -92,7 +95,6 @@ It requires:
 
 ## Not on the Near-Term Roadmap
 
-Plum is not currently trying to become a general-purpose admin framework, a
-freeform visual design tool, an ecommerce platform, or a hosted headless CMS.
-Those products solve different problems. Plum's focus is managed content that
-belongs inside Rails.
+Plum is not trying to become a general-purpose admin framework, a freeform
+visual design tool, an ecommerce platform, or a hosted headless CMS. Plum's
+focus is managed content that belongs inside Rails.

data/lib/plum/engine.rb

@@ -8,7 +8,9 @@ module Plum
 
     initializer "plum.assets" do |app|
       app.config.assets.paths << root.join("app/assets/javascripts")
-      app.config.assets.paths << root.join("app/javascript/controllers/plum")
+      # Importmap exposes these files as `plum/*`, so Propshaft must resolve
+      # them relative to the parent controllers directory.
+      app.config.assets.paths << root.join("app/javascript/controllers")
       app.config.assets.paths << root.join("vendor/javascript")
 
       lexxy_spec = Gem.loaded_specs["lexxy"]

data/lib/plum/version.rb

@@ -1,6 +1,6 @@
 module Plum
   module Version
-    STRING = "0.2.0"
+    STRING = "0.2.1"
   end
 
   VERSION = Version::STRING

data/lib/tasks/plum_portability.rake

@@ -0,0 +1,37 @@
+namespace :plum do
+  namespace :site do
+    desc "Export a complete Plum site archive (SITE_ID or first site; ARCHIVE required)"
+    task export: :environment do
+      path = ENV.fetch("ARCHIVE") { abort "ARCHIVE is required" }
+      site = ENV["SITE_ID"].present? ? Plum::Site.find(ENV["SITE_ID"]) : Plum::Site.first
+      abort "No Plum site exists" unless site
+
+      archive = Plum::SiteArchive.dump(site: site, path: path)
+      puts "Exported #{site.name} to #{archive}"
+    end
+
+    desc "Import a Plum site archive as a new site (ARCHIVE required; NAME and DOMAIN optional)"
+    task import: :environment do
+      path = ENV.fetch("ARCHIVE") { abort "ARCHIVE is required" }
+      site = Plum::SiteArchive.load(path: path, name: ENV["NAME"], domain: ENV["DOMAIN"])
+      puts "Imported #{site.name} as site #{site.id}"
+    end
+  end
+
+  namespace :backup do
+    desc "Create a timestamped Plum site backup (SITE_ID optional; DIRECTORY defaults to backups/plum)"
+    task create: :environment do
+      site = ENV["SITE_ID"].present? ? Plum::Site.find(ENV["SITE_ID"]) : Plum::Site.first
+      abort "No Plum site exists" unless site
+      directory = Rails.root.join(ENV.fetch("DIRECTORY", "backups/plum"))
+      filename = "plum-site-#{site.id}-#{Time.current.utc.strftime('%Y%m%d%H%M%S')}.plum.zip"
+      archive = Plum::SiteArchive.dump(site: site, path: directory.join(filename))
+      puts "Backed up #{site.name} to #{archive}"
+    end
+
+    desc "Restore a Plum backup as a new site (ARCHIVE required; NAME and DOMAIN optional)"
+    task restore: :environment do
+      Rake::Task["plum:site:import"].invoke
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plum-cms
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Ben Simmons
@@ -167,14 +167,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: image_processing
   requirement: !ruby/object:Gem::Requirement
@@ -276,6 +276,7 @@ files:
 - app/services/plum/liquid_context.rb
 - app/services/plum/liquid_filters.rb
 - app/services/plum/liquid_renderer.rb
+- app/services/plum/site_archive.rb
 - app/services/plum/theme.rb
 - app/services/plum/theme_asset_path.rb
 - app/services/plum/theme_package_installer.rb
@@ -383,6 +384,7 @@ files:
 - db/engine_migrate/20260807160000_add_localization_to_plum_entries.rb
 - docs/blueprint-fields.md
 - docs/extensions.md
+- docs/portability.md
 - docs/product-principles.md
 - docs/roadmap.md
 - docs/site/homepage.md
@@ -399,6 +401,7 @@ files:
 - lib/plum/engine.rb
 - lib/plum/liquid_tags/form_tag.rb
 - lib/plum/version.rb
+- lib/tasks/plum_portability.rake
 - lib/tasks/plum_styles.rake
 - vendor/javascript/lexxy.js
 homepage: https://plumcms.org