ruby_cms 0.2.1.1 → 1.0.1

data/lib/ruby_cms/manifest_data.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "ruby_cms/manifest"
+
+module RubyCms
+  def self.manifest
+    @manifest ||= Manifest.build do
+      module_def :core, base: true do
+        description "Admin shell: dashboard, layout, nav, settings"
+        files %w[
+          admin.html.erb
+          views/layouts/admin/**/*
+          views/shared/_maintenance_banner.html.erb
+          views/admin/shared/**/*
+          views/admin/dashboard/**/*
+          views/admin/settings/**/*
+          helpers/**/*
+          javascript/**/*
+          components/**/*
+          assets/**/*
+          config/locales/**/*
+          config/initializers/admin.rb
+          config/initializers/admin_dashboard.rb
+          config/initializers/pagy.rb
+          config/initializers/ruby_cms_core.rb
+          config/initializers/ruby_cms_custom_settings.rb
+          lib/**/*
+          models/concerns/**/*
+          models/permittable.rb
+          models/preference.rb
+          controllers/admin/application_controller.rb
+          controllers/admin/dashboard_controller.rb
+          controllers/admin/locale_controller.rb
+          controllers/admin/settings_controller.rb
+          controllers/admin/notifications_controller.rb
+          controllers/concerns/**/*
+          controllers/errors_controller.rb
+          services/admin/**/*
+        ]
+        routes "routes/core.rb"
+        nav "nav/core.rb"
+        permissions %i[manage_admin]
+        migrations %w[
+          create_ruby_cms_preferences add_category_to_ruby_cms_preferences
+          add_discarded_at_to_cms_tables use_unprefixed_cms_tables
+        ]
+      end
+
+      module_def :auth, base: true do
+        description "Sign-in wiring + user invitations"
+        files %w[
+          models/invitation.rb
+          controllers/admin/invitations_controller.rb
+        ]
+        routes "routes/auth.rb"
+        permissions %i[manage_permissions]
+        migrations %w[create_invitations]
+      end
+
+      module_def :permissions, base: true do
+        description "Roles & permission management"
+        files %w[
+          models/permission.rb models/user_permission.rb
+          controllers/admin/permissions_controller.rb
+          controllers/admin/user_permissions_controller.rb
+          views/admin/permissions/**/* views/admin/user_permissions/**/*
+        ]
+        routes "routes/permissions.rb"
+        nav "nav/permissions.rb"
+        permissions %i[manage_permissions]
+        migrations %w[
+          create_ruby_cms_permissions create_ruby_cms_user_permissions
+          add_indexes_to_ruby_cms_tables
+        ]
+      end
+
+      module_def :users, base: true do
+        description "User management"
+        files %w[controllers/admin/users_controller.rb views/admin/users/**/*]
+        routes "routes/users.rb"
+        nav "nav/users.rb"
+        permissions %i[manage_permissions]
+      end
+
+      module_def :content_blocks, base: true do
+        description "Editable content blocks with versions"
+        files %w[
+          models/content_block.rb models/content_block_version.rb
+          controllers/admin/content_blocks_controller.rb
+          controllers/admin/content_block_versions_controller.rb
+          views/admin/content_blocks/**/* views/admin/content_block_versions/**/*
+        ]
+        routes "routes/content_blocks.rb"
+        nav "nav/content_blocks.rb"
+        permissions %i[manage_content_blocks]
+        migrations %w[
+          create_ruby_cms_content_blocks add_locale_to_ruby_cms_content_blocks
+          create_content_block_versions
+        ]
+      end
+
+      module_def :visual_editor, base: true do
+        description "In-page visual content editor"
+        files %w[controllers/admin/visual_editor_controller.rb views/admin/visual_editor/**/*]
+        routes "routes/visual_editor.rb"
+        nav "nav/visual_editor.rb"
+        permissions %i[manage_content_blocks]
+      end
+
+      module_def :analytics, base: false do
+        description "Visitor & page analytics (Ahoy)"
+        files %w[
+          services/analytics/**/* services/analytics_service.rb
+          controllers/admin/analytics_controller.rb views/admin/analytics/**/*
+        ]
+        routes "routes/analytics.rb"
+        nav "nav/analytics.rb"
+        permissions %i[manage_analytics]
+        migrations %w[
+          add_analytics_indices add_ruby_cms_analytics_fields_to_ahoy_events
+          add_analytics_performance_indexes backfill_security_fields_in_ahoy_events
+        ]
+        gems "ahoy_matey" => "~> 5.2"
+      end
+
+      module_def :media, base: false do
+        description "Media library & uploads"
+        files %w[
+          models/media_asset.rb controllers/admin/media_assets_controller.rb
+          views/admin/media_assets/**/*
+          javascript/controllers/admin/media_selection_controller.js
+          javascript/controllers/admin/media_uploader_controller.js
+        ]
+        routes "routes/media.rb"
+        nav "nav/media.rb"
+        permissions %i[manage_media]
+        migrations %w[create_media_assets]
+      end
+
+      module_def :redirects, base: false do
+        description "URL redirect management"
+        files %w[models/redirect.rb controllers/admin/redirects_controller.rb views/admin/redirects/**/*]
+        routes "routes/redirects.rb"
+        nav "nav/redirects.rb"
+        permissions %i[manage_redirects]
+        migrations %w[create_redirects]
+        gems "csv" => nil # CSV import/export; csv is a bundled gem on Ruby 3.4+
+      end
+
+      module_def :audit_log, base: false do
+        description "Audit trail of admin actions"
+        files %w[
+          models/audit_log_entry.rb controllers/admin/audit_log_entries_controller.rb
+          views/admin/audit_log_entries/**/* services/audit_log.rb
+        ]
+        routes "routes/audit_log.rb"
+        nav "nav/audit_log.rb"
+        permissions %i[manage_audit_log]
+        migrations %w[create_audit_log_entries]
+      end
+
+      module_def :trash, base: false do
+        description "Soft-delete recycle bin"
+        files %w[controllers/admin/trash_controller.rb views/admin/trash/**/*]
+        routes "routes/trash.rb"
+        nav "nav/trash.rb"
+        permissions %i[manage_admin]
+      end
+
+      module_def :security, base: false, depends_on: %i[analytics] do
+        description "Visitor errors, IP/email blocklist, security dashboard"
+        files %w[
+          models/ip_blocklist.rb models/email_blocklist.rb models/visitor_error.rb
+          controllers/admin/security_controller.rb controllers/admin/visitor_errors_controller.rb
+          views/admin/security/**/* views/admin/visitor_errors/**/*
+          services/security_service.rb services/security_tracker.rb
+        ]
+        routes "routes/security.rb"
+        nav "nav/security.rb"
+        permissions %i[manage_security manage_visitor_errors]
+        migrations %w[
+          create_email_blocklists create_ip_blocklists create_ruby_cms_visitor_errors
+          add_referer_and_query_to_ruby_cms_visitor_errors
+          add_state_to_visitor_errors add_discarded_at_to_visitor_errors
+        ]
+      end
+
+      module_def :system_health, base: false do
+        description "System health checks & status"
+        files %w[controllers/admin/system_health_controller.rb views/admin/system_health/**/*]
+        routes "routes/system_health.rb"
+        nav "nav/system_health.rb"
+        permissions %i[manage_system_health]
+      end
+
+      module_def :passkeys, base: false, depends_on: %i[auth] do
+        description "Passkey / WebAuthn passwordless login"
+        files %w[
+          models/passkey_credential.rb
+          controllers/admin/passkey_registrations_controller.rb
+          controllers/admin/passkey_credentials_controller.rb
+          controllers/passkey_sessions_controller.rb
+          controllers/concerns/sudo_mode.rb
+          views/admin/passkey_registrations/**/*
+          views/admin/passkey_credentials/**/*
+          javascript/controllers/webauthn_controller.js
+          config/initializers/webauthn.rb
+        ]
+        routes "routes/passkeys.rb"
+        permissions %i[manage_admin]
+        migrations %w[
+          create_passkey_credentials add_webauthn_id_to_users
+          add_authenticated_at_to_sessions
+        ]
+        gems "webauthn" => "~> 3.1"
+      end
+
+      module_def :commands, base: false do
+        description "Run whitelisted maintenance commands"
+        files %w[
+          models/command_run.rb controllers/admin/commands_controller.rb
+          views/admin/commands/**/* services/command_runner.rb
+          javascript/controllers/admin/commands_controller.js
+          javascript/controllers/admin/admin_commands_controller.js
+        ]
+        routes "routes/commands.rb"
+        nav "nav/commands.rb"
+        permissions %i[manage_admin]
+        migrations %w[create_command_runs]
+      end
+    end
+  end
+end

data/lib/ruby_cms/migration_installer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module RubyCms
+  # Copies the migrations a module set needs into the app's db/migrate.
+  #
+  # The gem ships migrations with fixed historical timestamps. Some depend on tables
+  # created by install-time generators (ahoy, action_text) whose freshly generated
+  # migrations have LATER timestamps — so copying the gem files verbatim would run
+  # them before those tables exist. To guarantee correct order, copied migrations are
+  # RE-STAMPED with versions strictly greater than every migration already in the app,
+  # preserving the gem's own relative order. Migrations already present (matched by
+  # basename, ignoring the timestamp) are skipped.
+  class MigrationInstaller
+    def initialize(templates_root:, app_root:)
+      @src_dir = Pathname.new(templates_root).join("db/migrate")
+      @dest_dir = Pathname.new(app_root).join("db/migrate")
+    end
+
+    def install(modules)
+      return [] unless @src_dir.directory?
+
+      wanted = modules.flat_map(&:migrations).uniq
+      FileUtils.mkdir_p(@dest_dir)
+      existing = @dest_dir.children.map {|p| basename_without_timestamp(p.basename.to_s) }
+
+      version = max_existing_version
+      copied = []
+      sources(wanted, existing).each do |src|
+        version += 1
+        base = basename_without_timestamp(src.basename.to_s)
+        dest = @dest_dir.join("#{version}_#{base}.rb")
+        FileUtils.cp(src, dest)
+        copied << dest.basename.to_s
+      end
+      copied
+    end
+
+    private
+
+    # Gem migrations to copy, in the gem's own timestamp order (their intended order),
+    # filtered to the wanted basenames and excluding ones already in the app.
+    def sources(wanted, existing)
+      @src_dir.children.sort.select do |src|
+        base = basename_without_timestamp(src.basename.to_s)
+        wanted.include?(base) && !existing.include?(base)
+      end
+    end
+
+    # Highest numeric version prefix among migrations already in the app (0 if none).
+    def max_existing_version
+      @dest_dir.children.filter_map do |p|
+        m = p.basename.to_s.match(/\A(\d+)_/)
+        m && m[1].to_i
+      end.max || 0
+    end
+
+    def basename_without_timestamp(filename)
+      filename.sub(/\A\d+_/, "").delete_suffix(".rb")
+    end
+  end
+end

data/lib/ruby_cms/nav_assembler.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module RubyCms
+  # Generates config/initializers/admin_nav.rb from selected modules' nav fragments,
+  # wrapped once in a to_prepare block. Overwrites — regenerated on each install/add
+  # so it always reflects the installed module set.
+  class NavAssembler
+    HEADER = "# RubyCMS sidebar navigation - generated by ruby_cms. Safe to edit."
+
+    def initialize(templates_root:, app_root:)
+      @templates_root = Pathname.new(templates_root)
+      @dest = Pathname.new(app_root).join("config/initializers/admin_nav.rb")
+    end
+
+    def write(modules)
+      fragments = modules.filter_map do |mod|
+        next unless mod.nav
+
+        path = @templates_root.join(mod.nav)
+        path.exist? ? strip_header(path.read(encoding: "UTF-8")).chomp : nil
+      end
+
+      body = indent(fragments.join("\n\n"), 2)
+      FileUtils.mkdir_p(@dest.dirname)
+      @dest.write("# frozen_string_literal: true\n\n#{HEADER}\nRails.application.config.to_prepare do\n#{body}\nend\n",
+                  encoding: "UTF-8")
+    end
+
+    private
+
+    def strip_header(text)
+      text.sub(/\A# frozen_string_literal: true\n+/, "")
+    end
+
+    def indent(text, spaces)
+      pad = " " * spaces
+      text.split("\n").map {|l| l.empty? ? l : "#{pad}#{l}" }.join("\n")
+    end
+  end
+end

data/lib/ruby_cms/passkey_wiring.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module RubyCms
+  # Patches the host app's User model for passkey support:
+  #   * `has_many :passkey_credentials, dependent: :destroy`
+  #   * `before_create :assign_webauthn_id`
+  #   * private `assign_webauthn_id` method
+  # Runs only when the passkeys module is installed. Idempotent.
+  class PasskeyWiring
+    ASSOCIATION  = "  has_many :passkey_credentials, dependent: :destroy"
+    CALLBACK     = "  before_create :assign_webauthn_id"
+    PRIVATE_METHOD = <<~RUBY
+      \n  private\n
+        def assign_webauthn_id
+          self.webauthn_id ||= SecureRandom.base64(32)
+        end
+    RUBY
+
+    def initialize(app_root:)
+      @path = Pathname.new(app_root).join("app/models/user.rb")
+    end
+
+    def apply! # rubocop:disable Naming/PredicateMethod
+      return false unless @path.exist?
+
+      content = @path.read
+      return false if content.include?("passkey_credentials")
+      return false unless content =~ /class User .*\n/
+
+      patched = content.sub(/(class User .*\n)/) do
+        "#{::Regexp.last_match(1)}#{ASSOCIATION}\n#{CALLBACK}\n"
+      end
+      patched = patched.sub(/(\nend\z|\nend\n\z)/) do
+        "#{PRIVATE_METHOD}#{::Regexp.last_match(1)}"
+      end
+      @path.write(patched)
+      true
+    end
+  end
+end

data/lib/ruby_cms/path_map.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyCms
+  # Converts between gem template-relative paths and host-app-relative paths.
+  module PathMap
+    KEEP_PREFIXES = %w[config/ db/ lib/].freeze
+    ADMIN_LAYOUT_TEMPLATE = "admin.html.erb"
+    ADMIN_LAYOUT_APP = "app/views/layouts/admin.html.erb"
+
+    module_function
+
+    def to_app(template_relative)
+      return ADMIN_LAYOUT_APP if template_relative == ADMIN_LAYOUT_TEMPLATE
+      return template_relative if KEEP_PREFIXES.any? {|p| template_relative.start_with?(p) }
+
+      "app/#{template_relative}"
+    end
+
+    def to_template(app_relative)
+      return ADMIN_LAYOUT_TEMPLATE if app_relative == ADMIN_LAYOUT_APP
+      return app_relative if KEEP_PREFIXES.any? {|p| app_relative.start_with?(p) }
+
+      app_relative.delete_prefix("app/")
+    end
+  end
+end

data/lib/ruby_cms/routes_assembler.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module RubyCms
+  # Regenerates the RubyCMS-managed routes (the admin namespace plus any top-level
+  # public route fragments) between marker comments in config/routes.rb. Idempotent
+  # and additive: re-running with a larger module set replaces the managed block with
+  # the full current set, so `install --add` correctly adds new modules' routes.
+  #
+  # Public fragments are sibling files named "<routes>.public.rb" and are emitted
+  # OUTSIDE the admin namespace; the core module's public fragment (the catch-all 404)
+  # is forced last.
+  class RoutesAssembler
+    BEGIN_MARKER = "# >>> ruby_cms managed routes (regenerated by ruby_cms; do not edit inside)"
+    END_MARKER = "# <<< ruby_cms managed routes"
+    REPLACE_PATTERN =
+      /^[ \t]*#{Regexp.escape(BEGIN_MARKER)}.*?#{Regexp.escape(END_MARKER)}[ \t]*\n/m
+
+    def initialize(templates_root:, app_root:)
+      @templates_root = Pathname.new(templates_root)
+      @routes_path = Pathname.new(app_root).join("config/routes.rb")
+    end
+
+    def inject(modules)
+      return unless @routes_path.exist?
+
+      block = build_block(modules)
+      content = @routes_path.read
+      content = ensure_root(content)
+      content = if content.include?(BEGIN_MARKER)
+                  replace_block(content, block)
+                else
+                  insert_before_final_end(content, block)
+                end
+      @routes_path.write(content)
+    end
+
+    private
+
+    # A fresh app has no root route, so the auth flow's `root_url` fallback is undefined.
+    # Add a root pointing at /admin only when the app declares none of its own.
+    def ensure_root(content)
+      return content if content.match?(/^\s*root\b/)
+
+      content.sub(/(\.routes\.draw do\n)/) { "#{::Regexp.last_match(1)}  root to: redirect(\"/admin\")\n" }
+    end
+
+    def build_block(modules)
+      namespaced = read_fragments(modules.filter_map(&:routes))
+      body = indent(namespaced.join("\n\n"), 4)
+      inner = "  namespace :admin do\n#{body}\n  end\n"
+
+      public_lines = read_fragments(public_paths(modules))
+      inner = "#{inner}\n#{indent(public_lines.join("\n\n"), 2)}\n" unless public_lines.empty?
+
+      "  #{BEGIN_MARKER}\n#{inner}  #{END_MARKER}\n"
+    end
+
+    def replace_block(content, block)
+      content.sub(REPLACE_PATTERN, block)
+    end
+
+    def insert_before_final_end(content, block)
+      unless content.match?(/\nend\s*\z/)
+        raise ArgumentError,
+              "config/routes.rb does not end with a top-level `end`; cannot inject RubyCMS routes safely."
+      end
+
+      content.sub(/(\nend\s*)\z/, "\n#{block}\\1")
+    end
+
+    # Public fragment paths in injection order; the core catch-all goes last.
+    def public_paths(modules)
+      pairs = modules.filter_map do |mod|
+        next unless mod.routes
+
+        candidate = mod.routes.sub(/\.rb\z/, ".public.rb")
+        @templates_root.join(candidate).exist? ? [mod, candidate] : nil
+      end
+      pairs.sort_by {|mod, _| mod.key == :core ? 1 : 0 }.map {|_, path| path }
+    end
+
+    def read_fragments(rel_paths)
+      rel_paths.filter_map do |frag|
+        path = @templates_root.join(frag)
+        next unless path.exist?
+
+        strip_header(path.read).chomp
+      end
+    end
+
+    # Remove a leading `# frozen_string_literal: true` magic comment + blank lines.
+    def strip_header(text)
+      text.sub(/\A# frozen_string_literal: true\n+/, "")
+    end
+
+    def indent(text, spaces)
+      pad = " " * spaces
+      text.split("\n").map {|l| l.empty? ? l : "#{pad}#{l}" }.join("\n")
+    end
+  end
+end

data/lib/ruby_cms/syncer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require "ruby_cms/path_map"
+require "ruby_cms/lockfile"
+require "ruby_cms/excludes"
+
+module RubyCms
+  # Pushes gem-owned files from a host app back into the gem's templates dir.
+  # Only files declared in the manifest are touched (app-specific files ignored).
+  #
+  # By default sync only UPDATES files the gem already ships. Manifest globs such
+  # as `helpers/**/*` also match app-specific files (a public-site helper, a
+  # marketing Stimulus controller) that the gem does not own — absorbing those
+  # would pollute the gem. New files are skipped and reported; pass include_new
+  # to deliberately pull them in (e.g. when genuinely adding a file to the gem).
+  class Syncer
+    Result = Struct.new(:changed, :unchanged, :skipped_new, :excluded, keyword_init: true)
+
+    def initialize(manifest:, source_root:, templates_root:)
+      @manifest = manifest
+      @source_root = Pathname.new(source_root)
+      @templates_root = Pathname.new(templates_root)
+    end
+
+    def sync(dry_run: false, include_new: false)
+      changed = []
+      unchanged = []
+      skipped_new = []
+      excluded = []
+      host_excludes = Lockfile.new(@source_root).excludes
+
+      template_paths.each do |template_rel|
+        app_rel = PathMap.to_app(template_rel)
+        if Excludes.excluded?(app_rel, host_excludes)
+          excluded << app_rel
+          next
+        end
+
+        src = @source_root.join(app_rel)
+        next unless src.file?
+
+        dest = @templates_root.join(template_rel)
+        unless dest.exist? || include_new
+          skipped_new << template_rel
+          next
+        end
+
+        if dest.exist? && dest.binread == src.binread
+          unchanged << template_rel
+          next
+        end
+
+        changed << template_rel
+        next if dry_run
+
+        FileUtils.mkdir_p(dest.dirname)
+        dest.binwrite(src.binread)
+      end
+
+      Result.new(changed:, unchanged:, skipped_new:, excluded:)
+    end
+
+    private
+
+    # Expand manifest globs against the source app, return template-relative paths.
+    def template_paths
+      @manifest.all_files.flat_map do |template_glob|
+        if template_glob.include?("*")
+          app_glob = PathMap.to_app(template_glob)
+          @source_root.glob(app_glob).select(&:file?).map do |abs|
+            PathMap.to_template(abs.relative_path_from(@source_root).to_s)
+          end
+        else
+          [template_glob]
+        end
+      end.uniq
+    end
+  end
+end

data/lib/ruby_cms/updater.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require "ruby_cms/path_map"
+require "ruby_cms/lockfile"
+require "ruby_cms/excludes"
+
+module RubyCms
+  # Pulls new versions of gem-owned files into a host app, scoped to the modules
+  # recorded in the app's lockfile. Changed-files-only (content compare).
+  # Files matching the host's excludes (gem defaults + .ruby_cms.yml `exclude:`)
+  # are never overwritten.
+  class Updater
+    Result = Struct.new(:changed, :unchanged, :excluded, keyword_init: true)
+
+    def initialize(manifest:, templates_root:, app_root:)
+      @manifest = manifest
+      @templates_root = Pathname.new(templates_root)
+      @app_root = Pathname.new(app_root)
+    end
+
+    def update(dry_run: false, only: nil)
+      keys = installed_keys
+      keys &= Array(only).map(&:to_sym) if only
+      modules = keys.filter_map {|k| @manifest[k] }
+      host_excludes = Lockfile.new(@app_root).excludes
+
+      changed = []
+      unchanged = []
+      excluded = []
+      template_paths(modules).each do |template_rel|
+        src = @templates_root.join(template_rel)
+        next unless src.file?
+
+        app_rel = PathMap.to_app(template_rel)
+        if Excludes.excluded?(app_rel, host_excludes)
+          excluded << app_rel
+          next
+        end
+
+        dest = @app_root.join(app_rel)
+        if dest.exist? && dest.binread == src.binread
+          unchanged << app_rel
+          next
+        end
+
+        changed << app_rel
+        next if dry_run
+
+        FileUtils.mkdir_p(dest.dirname)
+        dest.binwrite(src.binread)
+      end
+
+      Result.new(changed:, unchanged:, excluded:)
+    end
+
+    private
+
+    def installed_keys
+      lock = Lockfile.new(@app_root).modules
+      lock.empty? ? @manifest.base_modules.map(&:key) : lock
+    end
+
+    def template_paths(modules)
+      modules.flat_map(&:files).uniq.flat_map do |glob|
+        if glob.include?("*")
+          @templates_root.glob(glob).select(&:file?)
+                         .map {|abs| abs.relative_path_from(@templates_root).to_s }
+        else
+          [glob]
+        end
+      end.uniq
+    end
+  end
+end

data/lib/ruby_cms/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyCms
-  VERSION = "0.2.1.1"
+  VERSION = "1.0.1"
 end