andromeda_cms 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0bf0f98d84d4c550f9767a856abdc93167d42cb183a737321db4ff195baa871
-  data.tar.gz: a54266f37539d9b89907bcc67c9011546c94299c7d29e30487ece2b887a2ae99
+  metadata.gz: fa08db7b74aca56bfdc4d9f07e16e0c0bea58955ee94b1ec949503c1a99450b9
+  data.tar.gz: e0f58387fd0f941d04287bcad45bad36d1cac7e4959e4c7cb37d242d06aeb0d1
 SHA512:
-  metadata.gz: 11abb00fcd58c65c95568093a399684110affa71e756cad1abd4e4ecdf83c3c22a2f9ef6b7628de05fc49eb2d93056b4fe7c116be2b3bd8eafbc92be2297124f
-  data.tar.gz: 5134eef7dbb6fe51deb56e9e7eddeb346a5982b81cb6de4e3ac9bf37ca57f00d0709e60dfe63da4197c5b931b3047ce242ee691d783e28983e620d2d70c8465f
+  metadata.gz: a560a7bfec8de8698fb1a3aee14443f4d7ed801944dc3552f98c027bbedc90746c7f151a639fc863e085db43eadce21357f59fca070f21a52ec7efabaa788dbb
+  data.tar.gz: 06f7ab5e0887284207fee9c51f083acc8abbb8ea488ad1e9d6dfab3df737fa97d11c5c06a094023f5759efbebc3ccb463b80a8097e939ed935a428a9b5f315e9

data/CHANGELOG.md

@@ -5,6 +5,53 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-09-29
+
+### Changed
+
+- The reader for an `:array` attribute declared `of: :reference` now resolves
+  each element to its entry, the way a single `:reference` reader already
+  did: `post.tags` returns the tag entries, in frontmatter order, and raises
+  `Andromeda::EntryNotFound` for an id with no entry. It used to return the
+  `Andromeda::Reference` pointers, which are still in `post.data[:tags]`.
+- `andromeda:build` and `andromeda:check` now fail on content that used to
+  pass and then broke when served. Run `andromeda:check` before upgrading a
+  deploy to see what needs fixing:
+  - a `:reference`, alone or in an array, whose id has no entry in the target
+    collection, or that names a collection nobody registered;
+  - an image in the body written as a bare path (`blog/posts/x.png`) that
+    Propshaft's load path cannot find. These used to fall back to a plain
+    `/assets/...` URL and 404 in production. Without Propshaft the path is
+    still used as written.
+- Declaring `:array` with `of: :reference` and no `collection:`, or with
+  `of: :enum` and no `values:`, now raises `ArgumentError` at definition time.
+
+### Fixed
+
+- An `:array` of `:reference` built its elements without the declared
+  `collection:`, so each `Andromeda::Reference` had a `nil` collection. The
+  first process worked; the next one to read `.andromeda/` failed with
+  `NoMethodError: undefined method 'to_sym' for nil`. `of: :enum` lost its
+  `values:` the same way and raised `NoMethodError` on any value.
+- An image in the body written as `./` or `../` with no file behind it was
+  treated as an asset pipeline path and rendered as a broken `/assets/./...`
+  URL. It now fails the build, as the documentation says, and so does a
+  relative path that leaves the project.
+- `andromeda:install` appended its ignore lines to the last line of a
+  `.gitignore` or `.dockerignore` that did not end with a newline, breaking
+  both that entry and `/.andromeda/`.
+
+## [0.1.2] - 2026-09-27
+
+### Fixed
+
+- `Entry#body` returned `nil` in production. Entries there are read from the
+  built index, which leaves bodies out, so anything using the raw Markdown --
+  a reading-time estimate, a Markdown export -- failed with `NoMethodError`.
+  The build now stores each entry's body in its own file (not the index), and
+  `Entry#body` reads it from there when needed, the same way `html` works.
+  Existing builds pick this up on the next `andromeda:build`.
+
 ## [0.1.1] - 2026-09-27
 
 ### Fixed
@@ -38,5 +85,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Generators: `andromeda:install`, `andromeda:collection`,
   `andromeda:component` and `andromeda:import_astro`.
 
+[0.2.0]: https://github.com/AndromedaCMS/andromeda_cms/releases/tag/v0.2.0
+[0.1.2]: https://github.com/AndromedaCMS/andromeda_cms/releases/tag/v0.1.2
 [0.1.1]: https://github.com/AndromedaCMS/andromeda_cms/releases/tag/v0.1.1
 [0.1.0]: https://github.com/AndromedaCMS/andromeda_cms/releases/tag/v0.1.0

data/README.md

@@ -2,6 +2,8 @@
 
 Astro-compatible content collections for Ruby on Rails.
 
+https://github.com/user-attachments/assets/7bde3b4f-7bdb-49f9-9646-cd981846a451
+
 [Documentation](https://www.andromedacms.dev/docs) · [Changelog](CHANGELOG.md)
 
 Copy the `.md` and `.mdx` files from an [Astro](https://astro.build) project

data/lib/andromeda/assets.rb

@@ -72,6 +72,28 @@ module Andromeda
       File.join("/assets", logical_path)
     end
 
+    # Whether the asset pipeline can serve `logical_path`. `url_for` falls
+    # back to a plain /assets path for anything it cannot find, so without
+    # this check a typo only shows up as a 404 in production.
+    #
+    # @return [Boolean, nil] nil when there is no Propshaft load path to ask
+    #   (no asset pipeline, or Sprockets), so callers can skip the check.
+    def exists?(logical_path)
+      load_path = pipeline_load_path
+      return nil if load_path.nil?
+
+      !load_path.find(logical_path).nil?
+    end
+
+    def pipeline_load_path
+      return nil unless defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+
+      assets = ::Rails.application.assets
+      assets.respond_to?(:load_path) && assets.load_path.respond_to?(:find) ? assets.load_path : nil
+    rescue StandardError
+      nil
+    end
+
     def logical_path(source, content_root:)
       source = File.expand_path(source)
       root = File.expand_path(content_root)

data/lib/andromeda/check.rb

@@ -15,18 +15,20 @@ module Andromeda
     # @return [Array<String>] human-readable problems; empty when content is healthy.
     def run(entry_classes = Andromeda::Pipeline.default_entry_classes)
       problems = []
+      loaded = {}
 
       entry_classes.each do |entry_class|
         entries = load_entries(entry_class, problems)
         next if entries.nil?
 
+        loaded[entry_class] = entries
         entries.each do |entry|
           problems.concat(frontmatter_style_problems(entry))
           problems.concat(conversion_problems(entry))
         end
       end
 
-      problems
+      problems.concat(Andromeda::References.problems(loaded))
     end
 
     def load_entries(entry_class, problems)

data/lib/andromeda/entry.rb

@@ -58,7 +58,8 @@ module Andromeda
       # stored `Andromeda::Reference` to the actual target entry (lazily,
       # via the registry) rather than returning the pointer itself --
       # `post.data[:author]` still holds the raw Reference for callers that
-      # want it.
+      # want it. An `:array` of `:reference` resolves each element the same
+      # way, so `post.tags` returns the tag entries.
       #
       # @see Andromeda::Schema#attribute for the full parameter list.
       def attribute(name, type, **options)
@@ -67,6 +68,8 @@ module Andromeda
 
         if type == :reference
           define_method(attr_name) { resolve_reference(attr_name) }
+        elsif type == :array && options[:of] == :reference
+          define_method(attr_name) { resolve_references(attr_name) }
         else
           define_method(attr_name) { data[attr_name] }
         end
@@ -230,9 +233,6 @@ module Andromeda
     # @return [Hash] Symbol-keyed validated frontmatter (may also carry
     #   String keys for unrecognized frontmatter -- see Schema::Result).
     attr_reader :data
-    # @return [String] raw Markdown/MDX body, frontmatter stripped but with
-    #   original line numbers preserved (Andromeda::Frontmatter#parse).
-    attr_reader :body
     # @return [String] absolute path to the source file.
     attr_reader :file_path
     # @return [String] SHA-256 of the whole source file, for cache keys.
@@ -262,6 +262,20 @@ module Andromeda
       converted[:html]
     end
 
+    # The raw Markdown/MDX body, frontmatter stripped but with original line
+    # numbers preserved (Andromeda::Frontmatter#parse). Entries loaded from
+    # source carry it already; in production they come from the index, which
+    # leaves bodies out, so it is read from the entry's built file the same
+    # way `html` is.
+    #
+    # @return [String, nil] nil only for a build made before bodies were
+    #   stored (andromeda_cms < 0.1.2); rebuilding fixes it.
+    # @raise [Andromeda::BuildMissing] in production, if this entry has
+    #   never been built.
+    def body
+      @body || converted[:body]
+    end
+
     # @return [Array<Hash>] `{depth:, slug:, text:}` per heading, in
     #   document order (Andromeda::Renderer::Result#headings).
     # @raise [Andromeda::BuildMissing] in production, if this entry has
@@ -302,5 +316,12 @@ module Andromeda
       # referencing an entry never forces every other collection to load.
       Andromeda.get_entry(reference.collection, reference.id)
     end
+
+    # @param attr_name [Symbol] an `:array` attribute declared `of: :reference`.
+    # @return [Array<Andromeda::Entry>] in the order the frontmatter lists them.
+    # @raise [Andromeda::EntryNotFound] for the first id with no entry.
+    def resolve_references(attr_name)
+      Array(data[attr_name]).map { |reference| Andromeda.get_entry(reference.collection, reference.id) }
+    end
   end
 end

data/lib/andromeda/pipeline.rb

@@ -22,7 +22,11 @@ module Andromeda
     #   components, syntax errors) -- collected rather than raised
     #   individually, so a build reports everything in one pass (same
     #   principle as Andromeda::LoaderError).
-    BuildResult = Struct.new(:collection, :converted, :errors, keyword_init: true) do
+    #
+    # `entries` holds what was read from source (nil when the collection
+    # failed to load), so `.build_all` can check references across
+    # collections without reading every file a second time.
+    BuildResult = Struct.new(:collection, :converted, :errors, :entries, keyword_init: true) do
       def success? = errors.empty?
     end
 
@@ -49,7 +53,7 @@ module Andromeda
     #   `data`/`body`/`digest`/`file_path` all come straight from the
     #   source file, not from a previous build).
     # @return [Hash] the stored payload (Symbol-keyed: `id`, `collection`,
-    #   `data`, `html`, `headings`, `digest`, `file_path`).
+    #   `data`, `html`, `headings`, `body`, `digest`, `file_path`).
     # @raise [Andromeda::SyntaxError, Andromeda::ParserError,
     #   Andromeda::Renderer::MissingComponentError] on a bad file; callers
     #   that want every problem across a whole collection reported together
@@ -69,6 +73,10 @@ module Andromeda
         data: publish_data_images(entry),
         html: result.html,
         headings: result.headings,
+        # Kept so `Entry#body` works in production, where entries come from
+        # the index and the source file is never read. The index itself
+        # leaves it out (Store#index_summary), so listings stay small.
+        body: entry.body,
         digest: entry.digest,
         render_key: render_key,
         file_path: entry.file_path
@@ -190,7 +198,7 @@ module Andromeda
       end
 
       @store.replace_collection!(entry_class.collection_name, payloads)
-      BuildResult.new(collection: entry_class.collection_name, converted: payloads.size, errors: errors)
+      BuildResult.new(collection: entry_class.collection_name, converted: payloads.size, errors: errors, entries: entries)
     end
 
     # Converts every registered collection, reporting every problem found
@@ -205,10 +213,13 @@ module Andromeda
     #   `Andromeda::Store.new`'s own `Andromeda.config.build_path` default.
     # @return [Array<BuildResult>] one per collection, on success.
     # @raise [Andromeda::BuildError] listing every problem found, across
-    #   every collection, if any entry failed to convert.
+    #   every collection, if any entry failed to convert or references an
+    #   entry that does not exist.
     def self.build_all(entry_classes = default_entry_classes, store: Andromeda::Store.new)
       results = entry_classes.map { |entry_class| new(store: store).build_collection(entry_class) }
       errors = results.flat_map(&:errors)
+      loaded = entry_classes.zip(results).filter_map { |entry_class, result| [entry_class, result.entries] if result.entries }
+      errors.concat(Andromeda::References.problems(loaded.to_h))
       raise Andromeda::BuildError, errors unless errors.empty?
 
       results
@@ -266,7 +277,7 @@ module Andromeda
       content_root = File.dirname(entry.file_path)
       base_dir = Andromeda::Registry[entry.collection]&.base_dir || content_root
 
-      lambda do |url, _node|
+      lambda do |url, node|
         # Absolute URLs point at something already being served -- a file in
         # `public/`, another host, or an inline data URI -- so they are left
         # exactly as the author wrote them.
@@ -278,10 +289,27 @@ module Andromeda
           next Andromeda::Assets.marker_for(logical) if logical
         end
 
-        # Not a file next to the content: treat it as a logical asset path so
+        # `./` and `../` can only mean "relative to this file", so falling
+        # back to the asset pipeline would just turn a typo into a silent 404.
+        # Containment is checked first so a crafted path never learns whether
+        # something outside the project exists.
+        start = (node && node[:position] || {})[:start] || {}
+        location = start[:line] ? "#{start[:line]}:#{start[:column]}: " : ""
+        if url.start_with?("./", "../")
+          inside = Andromeda::Assets.logical_path(source, content_root: base_dir)
+          reason = inside ? "does not exist" : "resolves outside the project"
+          raise Andromeda::Error, "#{location}image #{url.inspect} #{reason}"
+        end
+
+        # A bare path is not a file next to the content: treat it as a logical asset path so
         # images the application already ships (`app/assets/images/logo.png`,
         # written as `logo.png`) resolve through the asset pipeline and get
-        # their digest, instead of 404ing in production.
+        # their digest, instead of 404ing in production. Without Propshaft
+        # there is nothing to ask, so the path is trusted as written.
+        if Andromeda::Assets.exists?(url) == false
+          raise Andromeda::Error, "#{location}image #{url.inspect} is not in the asset pipeline"
+        end
+
         Andromeda::Assets.marker_for(url)
       end
     end

data/lib/andromeda/references.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Andromeda
+  # Checks that every `:reference` attribute -- on its own or as the
+  # elements of an `:array` -- names an entry that actually exists.
+  #
+  # Entries resolve references lazily (Entry#resolve_reference), so without
+  # this a typo in an id only surfaces when a page asks for the target. It
+  # needs every target collection loaded, which is why only the whole-site
+  # build (Pipeline.build_all) and Andromeda::Check run it.
+  module References
+    module_function
+
+    # @param entries_by_class [Hash{Class => Array<Andromeda::Entry>}]
+    #   entries already loaded, reused as reference targets. A target
+    #   collection missing from here is loaded from source.
+    # @return [Array<String>] human-readable problems; empty when every
+    #   reference resolves.
+    def problems(entries_by_class)
+      ids = Hash.new { |cache, name| cache[name] = ids_for(name, entries_by_class) }
+
+      entries_by_class.flat_map do |entry_class, entries|
+        attributes = reference_attributes(entry_class)
+        next [] if attributes.empty?
+
+        entries.flat_map do |entry|
+          attributes.flat_map do |attr|
+            references_in(entry.data[attr.name]).filter_map do |reference|
+              problem_for(reference, ids[reference.collection])&.then do |message|
+                "[#{entry_class.collection_name}] #{entry.file_path}: #{attr.name}: #{message}"
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def reference_attributes(entry_class)
+      entry_class.schema.attributes.values.select do |attr|
+        attr.type == :reference || (attr.type == :array && attr.of == :reference)
+      end
+    end
+
+    # `Array(value)` would splat a single Reference (a Struct) into its
+    # fields, so the two shapes are told apart explicitly.
+    def references_in(value)
+      (value.is_a?(Array) ? value : [value]).grep(Andromeda::Reference)
+    end
+
+    def problem_for(reference, known)
+      return "unknown collection #{reference.collection.inspect}" if known == :unknown
+      # The target collection failed to load; that failure is reported on
+      # its own, and every reference into it would only repeat it.
+      return nil if known.nil?
+      return nil if known.include?(reference.id.to_s)
+
+      "no #{reference.collection.inspect} entry with id #{reference.id.to_s.inspect}"
+    end
+
+    def ids_for(name, entries_by_class)
+      entry_class = Andromeda::Registry[name]
+      return :unknown if entry_class.nil?
+
+      entries = entries_by_class.fetch(entry_class) { entry_class.source_entries }
+      entries.map(&:id).to_set
+    rescue Andromeda::LoaderError
+      nil
+    end
+  end
+end

data/lib/andromeda/schema.rb

@@ -108,6 +108,12 @@ module Andromeda
       end
       raise ArgumentError, "#{name}: :enum requires values:" if type == :enum && (values.nil? || values.empty?)
       raise ArgumentError, "#{name}: :reference requires collection:" if type == :reference && collection.nil?
+      if type == :array && of == :reference && collection.nil?
+        raise ArgumentError, "#{name}: :array of :reference requires collection:"
+      end
+      if type == :array && of == :enum && (values.nil? || values.empty?)
+        raise ArgumentError, "#{name}: :array of :enum requires values:"
+      end
       if type == :array && of && !TYPES.include?(of)
         raise ArgumentError, "#{name}: unknown element type #{of.inspect} for of:"
       end
@@ -291,7 +297,9 @@ module Andromeda
       return [nil, "#{value.inspect} is not an array"] unless value.is_a?(Array)
       return [value, nil] unless attr.of
 
-      element_attr = Attribute.new(name: attr.name, type: attr.of)
+      # `values:` and `collection:` describe the elements, not the array, so
+      # they have to travel with the element type.
+      element_attr = Attribute.new(name: attr.name, type: attr.of, values: attr.values, collection: attr.collection)
       errors = []
       elements = value.each_with_index.map do |element, index|
         coerced, error = coerce(element_attr, element, entry_path: entry_path, content_root: content_root)

data/lib/andromeda/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Andromeda
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/andromeda_cms.rb

@@ -19,6 +19,7 @@ require_relative "andromeda/loader"
 require_relative "andromeda/entry"
 require_relative "andromeda/store"
 require_relative "andromeda/pipeline"
+require_relative "andromeda/references"
 
 module Andromeda
   # The native extension is built per Ruby minor version, so prefer the

data/lib/generators/andromeda/install/install_generator.rb

@@ -70,7 +70,11 @@ module Andromeda
           return
         end
 
-        append_to_file filename, "#{missing.join("\n")}\n"
+        # Without this, a file whose last line has no newline gets the first
+        # ignore line glued onto it, breaking both entries.
+        content = File.read(path)
+        separator = content.empty? || content.end_with?("\n") ? "" : "\n"
+        append_to_file filename, "#{separator}#{missing.join("\n")}\n"
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: andromeda_cms
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - LIMHAUS Inc.
@@ -105,6 +105,7 @@ files:
 - lib/andromeda/parser.rb
 - lib/andromeda/pipeline.rb
 - lib/andromeda/railtie.rb
+- lib/andromeda/references.rb
 - lib/andromeda/registry.rb
 - lib/andromeda/relation.rb
 - lib/andromeda/renderer.rb