andromeda_cms 0.1.0-arm64-darwin

data/lib/andromeda/store.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "pathname"
+require "date"
+require "time"
+
+module Andromeda
+  # Reads and writes the `.andromeda/` build output: one JSON
+  # file per entry at `<build_path>/<collection>/<id>.json`, plus one
+  # `<build_path>/<collection>/_index.json` per collection holding just
+  # enough of every entry (`id`/`data`/`headings`/`digest`/`file_path`) to
+  # render a listing page without opening every entry's own file.
+  #
+  # This class only knows how to read/write that layout safely -- it has no
+  # opinion on *when* to convert or re-convert a source file. That decision
+  # (dev's mtime/digest check vs. production's read-only stance) is
+  # Andromeda::Pipeline's job; Store is the dumb, well-tested disk layer
+  # underneath it, deliberately kept ignorant of Parser/Renderer so it can be
+  # tested with plain Hashes instead of real content files.
+  class Store
+    # @param build_path [String] absolute, or relative to Rails.root (or the
+    #   current working directory outside Rails) -- same convention
+    #   `Andromeda::Entry.collection`'s `base:` uses for `resolve_base`.
+    def initialize(build_path: Andromeda.config.build_path)
+      @build_path = resolve_build_path(build_path)
+    end
+
+    # @return [String] absolute path to the build root.
+    attr_reader :build_path
+
+    # @param collection [Symbol, String]
+    # @param id [String]
+    # @return [Hash, nil] Symbol-keyed payload (see Pipeline#convert for the
+    #   shape), or nil if no file exists yet for this id.
+    # Used by `andromeda:clobber` (and by `assets:clobber`, which it hooks
+    # into) so a stale build can be thrown away wholesale.
+    def clobber!
+      FileUtils.rm_rf(@build_path)
+      @build_path
+    end
+
+    def read_entry(collection, id)
+      path = entry_path(collection, id)
+      return nil unless File.file?(path)
+
+      decode_entry(read_json(path))
+    rescue JSON::ParserError
+      # A reader can only ever observe a *complete* file (writes go through
+      # `atomic_write`'s write-then-rename), so a parse failure here means
+      # something outside this gem touched the file -- treat it the same as
+      # "not built yet" rather than raising out of a request.
+      nil
+    end
+
+    # @param collection [Symbol, String]
+    # @return [Array<Hash>, nil] the collection's `_index.json` contents, or
+    #   nil if it has never been written.
+    def read_index(collection)
+      path = index_path(collection)
+      return nil unless File.file?(path)
+
+      array = read_json(path)
+      array.map { |summary| decode_data_field(summary) }
+    rescue JSON::ParserError
+      nil
+    end
+
+    # Writes one entry's JSON and folds its summary into the collection's
+    # `_index.json`, without touching any other entry already in that index.
+    # Used by Pipeline's dev-mode "reconvert this one stale file" path, where
+    # scanning (let alone rewriting) the whole collection would be wasteful.
+    #
+    # @param payload [Hash] Symbol-keyed, as built by Pipeline#convert.
+    # @return [Hash] `payload`, unchanged, for chaining.
+    def write_entry(collection, id, payload)
+      atomic_write(entry_path(collection, id), dump_json(encode_entry(payload)))
+      merge_index_entry(collection, payload)
+      payload
+    end
+
+    # Overwrites an entire collection at once: every payload's own file, the
+    # `_index.json` built from exactly this set, and -- because this is the
+    # only place that ever sees "every currently-valid id" for a collection
+    # in one place -- deletes any leftover `<id>.json` that does not belong
+    # to one of `payloads` (a source file deleted since the last build,
+    # so its stale JSON is cleaned up).
+    #
+    # @param payloads [Array<Hash>]
+    # @return [Array<Hash>] `payloads`, unchanged.
+    def replace_collection!(collection, payloads)
+      dir = collection_dir(collection)
+      keep = payloads.to_h { |payload| [entry_path(collection, payload.fetch(:id)), true] }
+
+      with_index_lock(collection) do
+        prune_orphans(dir, collection, keep)
+        payloads.each { |payload| atomic_write(entry_path(collection, payload.fetch(:id)), dump_json(encode_entry(payload))) }
+        atomic_write(index_path(collection), dump_json(payloads.map { |payload| index_summary(payload) }))
+      end
+
+      payloads
+    end
+
+    # @param collection [Symbol, String]
+    # @param id [String]
+    # @return [String] absolute path, guaranteed to be inside `build_path`.
+    # @raise [Andromeda::Error] if `id` (e.g. a hand-written frontmatter
+    #   `slug:` -- Id.generate lets that win verbatim, unslugified) tries to
+    #   escape the collection's directory via `..` segments.
+    def entry_path(collection, id)
+      dir = collection_dir(collection)
+      path = File.expand_path(File.join(dir, "#{id}.json"))
+      guard_within!(path, dir, id)
+      path
+    end
+
+    # @param collection [Symbol, String]
+    # @return [String] absolute path to `<build_path>/<collection>/_index.json`.
+    def index_path(collection)
+      File.join(collection_dir(collection), "_index.json")
+    end
+
+    private
+
+    def resolve_build_path(build_path)
+      return File.expand_path(build_path) if Pathname.new(build_path).absolute?
+
+      File.expand_path(File.join(Andromeda.config.project_root, build_path))
+    end
+
+    def collection_dir(collection)
+      dir = File.expand_path(File.join(@build_path, collection.to_s))
+      guard_within!(dir, @build_path, collection)
+      dir
+    end
+
+    # Shared by both `collection_dir` (guards the collection name) and
+    # `entry_path` (guards the id): `path` must resolve to somewhere at or
+    # under `root`, checked via `expand_path` (which collapses `..`) rather
+    # than a string match on the raw value, so `id: "../../etc/passwd"`
+    # cannot write outside `build_path` no matter how it is spelled.
+    def guard_within!(path, root, offender)
+      root_with_separator = File.expand_path(root) + File::SEPARATOR
+      return if path == File.expand_path(root) || path.start_with?(root_with_separator)
+
+      raise Andromeda::Error, "#{offender.inspect} escapes the build directory (#{root})"
+    end
+
+    def prune_orphans(dir, collection, keep)
+      index = File.expand_path(index_path(collection))
+      Dir.glob(File.join(dir, "**", "*.json")).each do |file|
+        expanded = File.expand_path(file)
+        next if expanded == index
+        next if keep[expanded]
+
+        File.delete(expanded)
+      end
+    end
+
+    def merge_index_entry(collection, payload)
+      with_index_lock(collection) do
+        existing = read_json_array(index_path(collection))
+        id = payload.fetch(:id)
+        existing.reject! { |summary| summary[:id].to_s == id.to_s }
+        existing << index_summary(payload)
+        atomic_write(index_path(collection), dump_json(existing))
+      end
+    end
+
+    # Development converts on demand from whichever Puma thread or worker
+    # serves the request, so two entries of one collection can be written at
+    # the same moment. Each rewrites the whole index from what it read, and
+    # without this lock the later rename silently drops the earlier entry.
+    # `atomic_write` alone cannot help: it keeps readers from seeing a torn
+    # file, not writers from overwriting each other. A file lock rather than
+    # a Mutex, because the writers may be separate processes.
+    def with_index_lock(collection)
+      dir = collection_dir(collection)
+      FileUtils.mkdir_p(dir)
+      File.open(File.join(dir, ".index.lock"), File::RDWR | File::CREAT) do |lock|
+        lock.flock(File::LOCK_EX)
+        yield
+      end
+    end
+
+    # `data` is encoded the same way `encode_entry` encodes it for the
+    # entry's own file -- the index is read back through `decode_data_field`
+    # below, and both sides need to agree on the on-disk (tagged-Hash)
+    # representation for a `Date`/`Reference`/`Image` value to round-trip.
+    def index_summary(payload)
+      { id: payload.fetch(:id), data: self.class.encode(payload.fetch(:data)), headings: payload.fetch(:headings),
+        digest: payload.fetch(:digest), file_path: payload.fetch(:file_path) }
+    end
+
+    def read_json_array(path)
+      return [] unless File.file?(path)
+
+      read_json(path)
+    rescue JSON::ParserError
+      []
+    end
+
+    def read_json(path)
+      JSON.parse(File.read(path), symbolize_names: true)
+    end
+
+    def dump_json(object)
+      JSON.pretty_generate(object)
+    end
+
+    # Never writes `path` directly: the file is built up-front in a sibling
+    # temp file and only `File.rename`d into place once it is complete, so a
+    # concurrent reader (another request, or a build process crashing
+    # mid-write) can never observe a half-written file at `path` -- it either
+    # sees the previous complete version or the new complete version, never
+    # something in between.
+    def atomic_write(path, content)
+      dir = File.dirname(path)
+      FileUtils.mkdir_p(dir)
+      tmp = File.join(dir, ".#{File.basename(path)}.#{Process.pid}-#{Thread.current.object_id}-#{rand(1_000_000)}.tmp")
+      File.write(tmp, content)
+      File.rename(tmp, path)
+    rescue StandardError
+      File.delete(tmp) if tmp && File.exist?(tmp)
+      raise
+    end
+
+    def encode_entry(payload)
+      payload.merge(collection: payload[:collection].to_s, data: self.class.encode(payload[:data]))
+    end
+
+    def decode_entry(payload)
+      payload.merge(collection: payload[:collection]&.to_sym, data: self.class.decode(payload[:data]))
+    end
+
+    def decode_data_field(payload)
+      payload.merge(data: self.class.decode(payload[:data]))
+    end
+
+    class << self
+      # Frontmatter `data` can hold types JSON has no native representation
+      # for (`Date`, `Andromeda::Reference`, `Andromeda::Image`) --
+      # each is written as a small tagged Hash (`{__type:, ...}`) so `decode`
+      # can rebuild the exact same Ruby object on the way back out, keeping
+      # the store's round trip (`convert -> write -> read`) lossless for
+      # every type `Andromeda::Schema` can produce.
+      def encode(value)
+        case value
+        when Andromeda::Reference then { __type: :reference, collection: value.collection, id: value.id }
+        when Andromeda::Image then { __type: :image, path: value.path, relative_path: value.relative_path, asset: value.asset }
+        when DateTime then { __type: :datetime, value: value.iso8601 }
+        when Time then { __type: :time, value: value.iso8601 }
+        when Date then { __type: :date, value: value.iso8601 }
+        when Array then value.map { |element| encode(element) }
+        when Hash then value.transform_values { |element| encode(element) }
+        else value
+        end
+      end
+
+      def decode(value)
+        case value
+        when Hash
+          value.key?(:__type) ? decode_tagged(value) : value.transform_values { |element| decode(element) }
+        when Array
+          value.map { |element| decode(element) }
+        else
+          value
+        end
+      end
+
+      private
+
+      def decode_tagged(value)
+        case value[:__type].to_s
+        when "reference" then Andromeda::Reference.new(collection: value[:collection].to_sym, id: value[:id])
+        when "image" then Andromeda::Image.new(path: value[:path], relative_path: value[:relative_path], asset: value[:asset])
+        when "datetime" then DateTime.iso8601(value[:value])
+        when "time" then Time.iso8601(value[:value])
+        when "date" then Date.iso8601(value[:value])
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/andromeda/tasks/andromeda.rake

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+namespace :andromeda do
+  desc "Convert every content file into .andromeda/"
+  task build: :environment do
+    started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    begin
+      results = Andromeda::Pipeline.build_all
+    rescue Andromeda::BuildError => e
+      # Failing the task (rather than warning) is what keeps a broken deploy
+      # from shipping content that silently lost a page.
+      warn e.message
+      abort "andromeda:build failed"
+    end
+
+    entries = results.sum(&:converted)
+    elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round
+    puts "andromeda:build converted #{entries} entries in #{results.size} collection(s) (#{elapsed}ms)"
+  end
+
+  desc "Remove converted content"
+  task clobber: :environment do
+    Andromeda::Store.new.clobber!
+    puts "andromeda:clobber removed #{Andromeda.config.build_path}"
+  end
+
+  desc "Report content problems without writing anything (for CI)"
+  task check: :environment do
+    problems = Andromeda::Check.run
+
+    if problems.empty?
+      puts "andromeda:check found no problems"
+    else
+      problems.each { |problem| warn problem }
+      abort "andromeda:check found #{problems.size} problem(s)"
+    end
+  end
+
+  desc "Rewrite non-snake_case frontmatter keys in place"
+  task fix: :environment do
+    changes = Andromeda::Fix.run
+
+    if changes.empty?
+      puts "andromeda:fix found nothing to change"
+    else
+      changes.each { |change| puts change }
+      puts "andromeda:fix updated #{changes.size} file(s)"
+    end
+  end
+end
+
+# Mirrors how tailwindcss-rails attaches itself, so a deploy that already runs
+# assets:precompile (every Rails 8 Dockerfile does) needs no extra step.
+Rake::Task["assets:precompile"].enhance(["andromeda:build"]) if Rake::Task.task_defined?("assets:precompile")
+Rake::Task["assets:clobber"].enhance(["andromeda:clobber"]) if Rake::Task.task_defined?("assets:clobber")

data/lib/andromeda/version.rb

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

data/lib/andromeda_cms.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "andromeda/version"
+require_relative "andromeda/errors"
+require_relative "andromeda/configuration"
+require_relative "andromeda/assets"
+require_relative "andromeda/helpers"
+require_relative "andromeda/fix"
+require_relative "andromeda/check"
+require_relative "andromeda/frontmatter"
+require_relative "andromeda/schema"
+require_relative "andromeda/slugger"
+require_relative "andromeda/renderer"
+require_relative "andromeda/components"
+require_relative "andromeda/id"
+require_relative "andromeda/relation"
+require_relative "andromeda/registry"
+require_relative "andromeda/loader"
+require_relative "andromeda/entry"
+require_relative "andromeda/store"
+require_relative "andromeda/pipeline"
+
+module Andromeda
+  # The native extension is built per Ruby minor version, so prefer the
+  # version-specific build when the packaged gem ships several of them.
+  begin
+    RUBY_VERSION =~ /(\d+\.\d+)/
+    require_relative "andromeda_cms/#{Regexp.last_match(1)}/andromeda_cms"
+  rescue LoadError
+    require_relative "andromeda_cms/andromeda_cms"
+  end
+
+  # Ruby wrapper around the native module the require above just defined;
+  # must load after it since it reopens Andromeda::Parser.
+  require_relative "andromeda/parser"
+end
+
+# Loaded last so the Railtie can reference everything above it. The guard is
+# on `Rails` itself, not `Rails::Railtie`: an application requires this gem
+# before Rails has finished pulling in the railtie machinery.
+require_relative "andromeda/railtie" if defined?(::Rails)

data/lib/generators/andromeda/collection/USAGE

@@ -0,0 +1,25 @@
+Description:
+    Generates everything a new content collection needs: an entry class
+    under app/models/content (or your configured entry_namespace), a
+    controller, index/show views, a route, and a starter content file with
+    frontmatter matching the declared attributes.
+
+    NAME is the collection as it appears under app/content/, and is used
+    as-is for the controller, views, route and content directory. The entry
+    class file/constant is the singular of NAME.
+
+    Field types: string (default) / date / datetime / boolean / integer /
+    array / image / reference. `field:reference:other_collection` names the
+    referenced collection explicitly; without it, the field name is
+    pluralized as a guess.
+
+Example:
+    rails generate andromeda:collection posts title:string pub_date:date draft:boolean
+
+    This creates:
+        app/models/content/post.rb
+        app/controllers/posts_controller.rb
+        app/views/posts/index.html.erb
+        app/views/posts/show.html.erb
+        app/content/posts/hello-world.md
+        config/routes.rb -- adds `resources :posts, only: %i[index show], param: :slug`

data/lib/generators/andromeda/collection/collection_generator.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require "andromeda_cms"
+require "active_support/core_ext/string/inflections"
+
+module Andromeda
+  module Generators
+    # `rails g andromeda:collection NAME [field:type ...]` --
+    # everything a new collection needs: the entry class, a
+    # plain Rails controller/views, a route, and a starter content file.
+    #
+    # `NAME` names the collection exactly as it will appear under
+    # `app/content/` and is used as-is for the controller/views/route/
+    # content directory (the controller follows the URL, not the
+    # content namespace). Only the entry *class* is singularized, matching
+    # `app/models/content/post.rb` for a `posts` collection.
+    #
+    # All file content is built directly (rather than via `.tt` ERB
+    # templates) since every piece of it -- the namespace nesting, the
+    # attribute list, which attribute doubles as a title -- depends on
+    # generator input in a way a static template can't express cleanly.
+    class CollectionGenerator < Rails::Generators::NamedBase
+      # Deliberately named `fields`, not `attributes`: Rails::Generators::
+      # NamedBase auto-detects an `attributes` argument (`respond_to?
+      # (:attributes)`) and rewrites it into GeneratedAttribute objects
+      # using its own `field:type:index` syntax (`index` meaning a DB
+      # index), which collides with our `field:type:collection` syntax for
+      # :reference attributes.
+      argument :fields, type: :array, default: [], banner: "field:type field:type"
+
+      # Schema types (schema.rb's TYPES) that make sense to request from the
+      # command line; anything else -- or no `:type` at all -- defaults to
+      # :string, the same fallback Rails' own generators use.
+      TYPE_ALIASES = {
+        "string" => :string,
+        "date" => :date,
+        "datetime" => :datetime,
+        "boolean" => :boolean,
+        "bool" => :boolean,
+        "integer" => :integer,
+        "int" => :integer,
+        "array" => :array,
+        "image" => :image,
+        "reference" => :reference
+      }.freeze
+
+      def create_model
+        create_file model_path, model_content
+      end
+
+      def create_controller
+        create_file "app/controllers/#{collection_name}_controller.rb", controller_content
+      end
+
+      def create_views
+        create_file "app/views/#{collection_name}/index.html.erb", index_view_content
+        create_file "app/views/#{collection_name}/show.html.erb", show_view_content
+      end
+
+      # Only appends the route when it is not already there, so running the
+      # generator twice (e.g. after adding a field) never duplicates it --
+      # Thor's own `route` action always appends unconditionally.
+      def add_route
+        routes_path = File.join(destination_root, "config/routes.rb")
+
+        if File.exist?(routes_path) && File.read(routes_path).include?(route_line)
+          say_status :identical, "config/routes.rb (route already present)", :blue
+        else
+          route route_line
+        end
+      end
+
+      def create_starter_content
+        parsed_attributes.each do |attr|
+          next unless attr[:type] == :image
+
+          # A schema :image attribute is validated by checking the file
+          # actually exists (Schema#coerce_image) -- an empty placeholder
+          # satisfies that check without requiring a real asset.
+          create_file "app/content/#{collection_name}/#{attr[:name]}#{IMAGE_EXTENSION}", ""
+        end
+        create_file "app/content/#{collection_name}/hello-world.md", starter_content
+      end
+
+      private
+
+      IMAGE_EXTENSION = ".png"
+
+      # The collection name exactly as given, underscored -- this is what
+      # the route, controller, views and content directory all use.
+      def collection_name
+        @collection_name ||= name.underscore
+      end
+
+      def singular_name
+        @singular_name ||= collection_name.singularize
+      end
+
+      def namespace_modules
+        @namespace_modules ||= Andromeda.config.entry_namespace.split("::")
+      end
+
+      def class_basename
+        singular_name.camelize
+      end
+
+      def full_class_name
+        (namespace_modules + [class_basename]).join("::")
+      end
+
+      def route_line
+        "resources :#{collection_name}, only: %i[index show], param: :slug"
+      end
+
+      def parsed_attributes
+        @parsed_attributes ||= fields.map { |raw| parse_attribute(raw) }
+      end
+
+      def parse_attribute(raw)
+        field, type_str, extra = raw.split(":", 3)
+        type = TYPE_ALIASES.fetch(type_str.to_s, :string)
+        { name: field.underscore, type: type, extra: extra }
+      end
+
+      def attribute_declaration(attr)
+        case attr[:type]
+        when :boolean
+          "attribute :#{attr[:name]}, :boolean, default: false"
+        when :array
+          "attribute :#{attr[:name]}, :array, of: :string, default: []"
+        when :reference
+          target = (attr[:extra] || attr[:name].pluralize).to_sym
+          "attribute :#{attr[:name]}, :reference, collection: :#{target}"
+        else
+          "attribute :#{attr[:name]}, :#{attr[:type]}"
+        end
+      end
+
+      def model_path
+        File.join(Andromeda.config.entry_class_path, "#{singular_name}.rb")
+      end
+
+      def model_content
+        indent = "  " * namespace_modules.size
+        lines = ["# frozen_string_literal: true", ""]
+        namespace_modules.each_with_index { |mod, i| lines << "#{"  " * i}module #{mod}" }
+        lines << "#{indent}class #{class_basename} < Andromeda::Entry"
+        lines << "#{indent}  collection :#{collection_name}, base: \"app/content/#{collection_name}\", " \
+                 "pattern: \"**/*.{md,mdx}\""
+        unless parsed_attributes.empty?
+          lines << ""
+          parsed_attributes.each { |attr| lines << "#{indent}  #{attribute_declaration(attr)}" }
+        end
+        lines << ""
+        lines << "#{indent}  # scope :published, -> { where(draft: false) }"
+        lines << "#{indent}end"
+        namespace_modules.size.downto(1) { |i| lines << "#{"  " * (i - 1)}end" }
+        "#{lines.join("\n")}\n"
+      end
+
+      def controller_content
+        order_attribute = parsed_attributes.find { |attr| %i[date datetime].include?(attr[:type]) }
+        listing = if order_attribute
+                    "#{full_class_name}.all.order(#{order_attribute[:name]}: :desc)"
+                  else
+                    "#{full_class_name}.all"
+                  end
+
+        <<~RUBY
+          # frozen_string_literal: true
+
+          class #{collection_name.camelize}Controller < ApplicationController
+            def index
+              @entries = #{listing}
+            end
+
+            def show
+              @entry = #{full_class_name}.find(params[:slug])
+            end
+          end
+        RUBY
+      end
+
+      # Best-effort attribute to display as an entry's title: the first
+      # declared :string attribute, or `id` when none was declared.
+      def title_method
+        title_attribute = parsed_attributes.find { |attr| attr[:type] == :string }
+        title_attribute ? title_attribute[:name] : "id"
+      end
+
+      def index_view_content
+        <<~ERB
+          <h1><%= "#{collection_name.humanize}" %></h1>
+          <ul>
+            <% @entries.each do |entry| %>
+              <li><%= link_to entry.#{title_method}, #{collection_name}_path(entry.id) %></li>
+            <% end %>
+          </ul>
+        ERB
+      end
+
+      def show_view_content
+        <<~ERB
+          <article>
+            <h1><%= @entry.#{title_method} %></h1>
+            <%= andromeda_content @entry %>
+          </article>
+        ERB
+      end
+
+      def starter_content
+        frontmatter_lines = parsed_attributes.filter_map { |attr| starter_frontmatter_line(attr) }
+
+        <<~MARKDOWN
+          ---
+          #{frontmatter_lines.join("\n")}
+          ---
+
+          ## Getting started
+
+          Edit this file, or delete it and add your own content.
+        MARKDOWN
+      end
+
+      def starter_frontmatter_line(attr)
+        case attr[:type]
+        when :string then "#{attr[:name]}: Hello World"
+        when :date then "#{attr[:name]}: #{Date.today.iso8601}"
+        when :datetime then "#{attr[:name]}: #{Time.now.utc.iso8601}"
+        when :boolean then "#{attr[:name]}: false"
+        when :integer then "#{attr[:name]}: 1"
+        when :array then "#{attr[:name]}: [example]"
+        when :image then "#{attr[:name]}: #{attr[:name]}#{IMAGE_EXTENSION}"
+        when :reference then "#{attr[:name]}: example"
+        end
+      end
+    end
+  end
+end

data/lib/generators/andromeda/component/USAGE

@@ -0,0 +1,15 @@
+Description:
+    Generates a partial for an MDX component under
+    app/views/content_components/, matching the naming convention
+    Andromeda::Components resolves tags with: `Callout` -> _callout.html.erb.
+
+    NAME must be a single CamelCase or underscored word (no namespaces, no
+    dots) -- MDX component tags are a single JSX identifier.
+
+    Each PROP becomes an optional local (`local_assigns[:prop]`); the tag's
+    children are always available as `content`.
+
+Example:
+    rails generate andromeda:component Callout type title
+
+    Creates app/views/content_components/_callout.html.erb.