not_pressed-core 0.1.0

data/lib/generators/not_pressed/plugin/plugin_generator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module NotPressed
+  module Generators
+    class PluginGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      argument :plugin_name, type: :string, desc: "Name of the plugin (snake_case)"
+
+      desc "Generate a NotPressed plugin scaffold"
+
+      def create_plugin_file
+        template "plugin.rb.tt",
+                 "app/plugins/not_pressed/#{plugin_name}_plugin.rb"
+      end
+
+      def show_instructions
+        say ""
+        say "NotPressed plugin '#{plugin_name}' created!", :green
+        say ""
+        say "Next steps:"
+        say "  1. Edit app/plugins/not_pressed/#{plugin_name}_plugin.rb"
+        say "  2. Uncomment and customize the hook, block_type, and settings examples"
+        say "  3. The plugin will be auto-discovered and enabled on app boot"
+        say ""
+      end
+
+      private
+
+      def class_name
+        plugin_name.camelize
+      end
+    end
+  end
+end

data/lib/generators/not_pressed/plugin/templates/plugin.rb.tt

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class <%= class_name %>Plugin < NotPressed::Plugin
+  name "<%= plugin_name %>"
+  version "0.1.0"
+  description "TODO: Describe what <%= plugin_name %> does"
+
+  # Hook into CMS events:
+  # on(:page_before_save) { |page| ... }
+  # on(:page_after_save) { |page| ... }
+
+  # Register custom block types:
+  # block_type :my_block, label: "My Block"
+
+  # Define plugin settings:
+  # settings do
+  #   string :api_key, label: "API Key", required: true
+  #   boolean :enabled, label: "Enabled", default: true
+  # end
+
+  # Declare dependencies on other plugins:
+  # depends_on "other_plugin"
+end

data/lib/not_pressed/admin/authentication.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Admin
+    module Authentication
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :current_admin_user, :admin_user_signed_in?
+      end
+
+      private
+
+      def authenticate_admin!
+        auth = NotPressed.configuration.admin_authentication
+        case auth
+        when Proc
+          instance_exec(&auth)
+        when Symbol, String
+          send(auth)
+        when nil
+          # No authentication configured — allow access
+        end
+      rescue NoMethodError => e
+        raise unless e.message.include?(auth.to_s)
+
+        redirect_to NotPressed.configuration.admin_unauthorized_redirect,
+                    alert: "Authentication required"
+      end
+
+      def current_admin_user
+        user_method = NotPressed.configuration.admin_current_user
+        case user_method
+        when Proc
+          instance_exec(&user_method)
+        when Symbol, String
+          send(user_method)
+        when nil
+          nil
+        end
+      end
+
+      def admin_user_signed_in?
+        current_admin_user.present?
+      end
+    end
+  end
+end

data/lib/not_pressed/admin/menu_registry.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Admin
+    # Manages the admin sidebar menu items.
+    #
+    # Supports multiple sections (e.g., +:main+, +:settings+) and positional
+    # ordering. Built-in items are protected from {.reset!}.
+    module MenuRegistry
+      class << self
+        # Adds a menu item to the admin sidebar.
+        #
+        # @param label [String] display text
+        # @param path [Symbol, String] route helper name or URL path
+        # @param icon [String, nil] icon identifier
+        # @param section [Symbol] menu section (default +:main+)
+        # @param position [Integer] sort order, lower values appear first (default 100)
+        # @param built_in [Boolean] if true, protected from {.reset!} (default false)
+        # @return [void]
+        def register(label, path:, icon: nil, section: :main, position: 100, built_in: false)
+          items_store << {
+            label: label,
+            path: path,
+            icon: icon,
+            section: section,
+            position: position,
+            built_in: built_in
+          }
+        end
+
+        # Returns menu items for a section, sorted by position.
+        #
+        # @param section [Symbol] the section to filter by (default +:main+)
+        # @return [Array<Hash>] sorted menu item hashes
+        def items(section: :main)
+          items_store
+            .select { |item| item[:section] == section }
+            .sort_by { |item| item[:position] }
+        end
+
+        # Removes all non-built-in menu items.
+        #
+        # @return [void]
+        def reset!
+          items_store.reject! { |item| !item[:built_in] }
+        end
+
+        # Removes a menu item matching the given label and path.
+        #
+        # @param label [String] menu item label
+        # @param path [Symbol, String] menu item path
+        # @return [void]
+        def unregister(label, path:)
+          items_store.reject! { |item| item[:label] == label && item[:path] == path }
+        end
+
+        # Removes all menu items including built-ins.
+        #
+        # @return [void]
+        def clear_all!
+          @items = []
+        end
+
+        # Registers the default built-in menu items.
+        #
+        # Idempotent: only executes once unless {.reset_built_ins_flag!} is called.
+        #
+        # @return [void]
+        def register_built_ins!
+          return if @built_ins_registered
+
+          register "Dashboard",     path: :admin_root_path,               section: :main, position: 0,  built_in: true
+          register "Pages",         path: :admin_pages_path,              section: :main, position: 10, built_in: true
+          register "Forms",         path: :admin_forms_path,              section: :main, position: 20, built_in: true
+          register "Categories",    path: :admin_categories_path,         section: :main, position: 25, built_in: true
+          register "Tags",          path: :admin_tags_path,               section: :main, position: 26, built_in: true
+          register "Media Library", path: :admin_media_attachments_path,  section: :main, position: 30, built_in: true
+          register "Code Injection", path: :code_injection_admin_settings_path, section: :settings, position: 0, built_in: true
+          register "Themes",         path: :admin_themes_path,                 section: :settings, position: 5,  built_in: true
+          register "Plugins",        path: :admin_plugins_path,                section: :settings, position: 10, built_in: true
+
+          @built_ins_registered = true
+        end
+
+        # Resets the idempotency guard so {.register_built_ins!} can run again.
+        #
+        # @return [void]
+        def reset_built_ins_flag!
+          @built_ins_registered = false
+        end
+
+        private
+
+        def items_store
+          @items ||= []
+        end
+      end
+    end
+  end
+end

data/lib/not_pressed/configuration.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module NotPressed
+  # Stores all engine-wide settings. Created automatically by {NotPressed.configuration}.
+  #
+  # Configure via the block form:
+  #   NotPressed.configure do |config|
+  #     config.site_name = "My Blog"
+  #     config.per_page = 10
+  #   end
+  class Configuration
+    # @return [String] URL path prefix for admin routes (default: "not_pressed")
+    # @return [String] site display name (default: "My Site")
+    # @return [Integer] pagination size (default: 25)
+    # @return [Boolean] whether to auto-discover navigable routes (default: true)
+    # @return [Boolean] whether to cache navigation trees (default: true)
+    # @return [Proc, nil] authentication callback for admin access
+    # @return [Proc, nil] callback returning the current admin user
+    # @return [String] redirect path when admin auth fails (default: "/")
+    # @return [Array<String>] available layout names (default: ["default"])
+    # @return [String] separator between page title and site name in SEO tags (default: " | ")
+    # @return [String, nil] custom robots.txt content
+    # @return [String, nil] HTML code injected into every page head
+    # @return [String, nil] HTML code injected into every page body
+    # @return [String] name of the default theme (default: "Starter")
+    attr_accessor :admin_path, :site_name, :per_page,
+                  :auto_discover_navigation, :cache_navigation,
+                  :admin_authentication, :admin_current_user,
+                  :admin_unauthorized_redirect, :available_layouts,
+                  :seo_title_separator, :robots_txt,
+                  :global_head_code, :global_body_code, :default_theme
+
+    # @return [Hash{String => Navigation::Menu}] DSL-defined navigation menus (read-only)
+    attr_reader :menus
+
+    def initialize
+      @admin_path = "not_pressed"
+      @site_name = "My Site"
+      @per_page = 25
+      @auto_discover_navigation = true
+      @cache_navigation = true
+      @menus = {}
+      @admin_authentication = nil
+      @admin_current_user = nil
+      @admin_unauthorized_redirect = "/"
+      @available_layouts = ["default"]
+      @seo_title_separator = " | "
+      @robots_txt = nil
+      @global_head_code = nil
+      @global_body_code = nil
+      @default_theme = "Starter"
+    end
+
+    # Defines a navigation menu using the {Navigation::Menu} DSL.
+    #
+    # @param name [Symbol, String] menu identifier
+    # @yield DSL block passed to {Navigation::Menu.build}
+    # @return [Navigation::Menu]
+    def menu(name, &block)
+      @menus[name.to_s] = Navigation::Menu.build(name.to_s, &block)
+    end
+
+    # Returns the union of configured layouts and any layouts defined by the active theme.
+    #
+    # @return [Array<String>] all available layout names
+    def effective_layouts
+      layouts = @available_layouts.dup
+      theme = NotPressed::ThemeRegistry.active
+      if theme
+        theme.theme_layouts.each do |tl|
+          layouts << tl[:name].to_s unless layouts.include?(tl[:name].to_s)
+        end
+      end
+      layouts
+    end
+  end
+end

data/lib/not_pressed/content_type.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class ContentType
+    attr_reader :name, :label, :icon, :description, :allowed_blocks, :has_slug, :has_parent, :custom_fields
+
+    def initialize(name:, label:, icon: nil, description: nil, allowed_blocks: nil, has_slug: true, has_parent: true, custom_fields: [])
+      @name = name.to_s
+      @label = label
+      @icon = icon
+      @description = description
+      @allowed_blocks = allowed_blocks
+      @has_slug = has_slug
+      @has_parent = has_parent
+      @custom_fields = custom_fields
+      freeze
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/lib/not_pressed/content_type_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class ContentTypeBuilder
+    FieldDefinition = Struct.new(:key, :type, :label, :required, :default, keyword_init: true)
+
+    def initialize(name)
+      @name = name
+      @options = {}
+      @fields = []
+    end
+
+    def label(val)
+      @options[:label] = val
+    end
+
+    def icon(val)
+      @options[:icon] = val
+    end
+
+    def description(val)
+      @options[:description] = val
+    end
+
+    def allowed_blocks(*types)
+      @options[:allowed_blocks] = types.map(&:to_s)
+    end
+
+    def has_slug(val)
+      @options[:has_slug] = val
+    end
+
+    def has_parent(val)
+      @options[:has_parent] = val
+    end
+
+    def field(key, type, **options)
+      @fields << FieldDefinition.new(
+        key: key,
+        type: type,
+        label: options[:label],
+        required: options.fetch(:required, false),
+        default: options[:default]
+      )
+    end
+
+    def register!
+      ContentTypeRegistry.register(@name, **@options, custom_fields: @fields)
+    end
+  end
+end

data/lib/not_pressed/content_type_registry.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class ContentTypeRegistry
+    class NotFound < StandardError; end
+
+    class << self
+      def registry
+        @registry ||= {}
+      end
+
+      def register(name, **options)
+        type = ContentType.new(name: name, **options)
+        registry[type.name] = type
+      end
+
+      def find(name)
+        registry[name.to_s] || raise(NotFound, "Content type '#{name}' not found")
+      end
+
+      def all
+        registry.values
+      end
+
+      def names
+        registry.keys
+      end
+
+      def reset!
+        @registry = {}
+        register_defaults
+      end
+
+      private
+
+      def register_defaults
+        register("page", label: "Page", icon: "file-text", description: "A standard content page")
+        register("blog_post", label: "Blog Post", icon: "pen-line", description: "A blog post entry")
+        register("gallery", label: "Gallery", icon: "images", description: "An image gallery page")
+      end
+    end
+
+    register_defaults
+  end
+end

data/lib/not_pressed/engine.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class Engine < ::Rails::Engine
+    isolate_namespace NotPressed
+
+    config.generators do |g|
+      g.orm :active_record
+      g.test_framework :rspec
+    end
+
+    initializer "not_pressed.mime_types" do
+      Mime::Type.register "text/vnd.turbo-stream.html", :turbo_stream unless Mime::Type.lookup_by_extension(:turbo_stream)
+    end
+
+    initializer "not_pressed.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.precompile += %w[not_pressed/application.css not_pressed/admin.css not_pressed/themes/starter.css not_pressed/gallery.css not_pressed/lightbox.js]
+      end
+    end
+
+    initializer "not_pressed.active_storage_check" do
+      unless defined?(ActiveStorage)
+        Rails.logger.warn(
+          "NotPressed: Active Storage is not loaded. " \
+          "Media attachments require Active Storage. " \
+          "Add `require \"active_storage/engine\"` to your application.rb."
+        )
+      end
+    end
+
+    initializer "not_pressed.gallery_block" do
+      config.after_initialize do
+        NotPressed::ContentBlock.register_type("gallery")
+
+        gallery_renderer = lambda do |content, _block|
+        images = content["images"] || []
+        columns = content["columns"].to_i
+        columns = 3 unless (2..4).cover?(columns)
+
+        if images.empty?
+          return %(<div class="np-content-gallery" data-columns="#{columns}"></div>)
+        end
+
+        items_html = images.map do |img|
+          media_id = img["media_id"]
+          caption = ERB::Util.html_escape(img["caption"].to_s)
+          url = ""
+
+          if media_id.present?
+            media = NotPressed::MediaAttachment.find_by(id: media_id)
+            if media&.file&.attached?
+              url = Rails.application.routes.url_helpers.rails_blob_path(media.file, disposition: "inline", only_path: true)
+            end
+          end
+
+          item_html = %(<div class="np-gallery-item">)
+          item_html += %(<img src="#{ERB::Util.html_escape(url)}" alt="#{caption}" loading="lazy">) unless url.empty?
+          item_html += %(<div class="np-gallery-caption">#{caption}</div>) unless caption.empty?
+          item_html += %(</div>)
+          item_html
+        end.join("\n")
+
+        %(<div class="np-content-gallery" data-columns="#{columns}" style="--np-gallery-columns: #{columns};">#{items_html}</div>)
+      end
+
+        NotPressed::Rendering::RendererRegistry.register("gallery", gallery_renderer)
+        NotPressed::Rendering::RendererRegistry.register_editor("gallery", "not_pressed/admin/content_blocks/editors/gallery")
+        NotPressed::Rendering::RendererRegistry.register_default_content("gallery", { "images" => [], "columns" => 3 })
+      end
+    end
+
+    initializer "not_pressed.admin_menu" do
+      NotPressed::Admin::MenuRegistry.register_built_ins!
+    end
+
+    initializer "not_pressed.theme_autoload", before: :set_autoload_paths do |app|
+      # Engine's own themes
+      engine_themes = root.join("app", "themes")
+      if engine_themes.exist?
+        app.config.autoload_paths << engine_themes.to_s
+      end
+
+      # Host app themes
+      themes_path = app.root.join("app", "themes")
+      if themes_path.exist?
+        app.config.autoload_paths << themes_path.to_s
+      end
+    end
+
+    initializer "not_pressed.plugin_autoload" do |app|
+      plugins_path = app.root.join("app", "plugins")
+      if plugins_path.exist?
+        app.config.autoload_paths << plugins_path.to_s
+      end
+    end
+
+    initializer "not_pressed.themes" do
+      config.after_initialize do
+        # Discover and register all Theme subclasses
+        NotPressed::Theme.subclasses.each do |klass|
+          next unless klass.plugin_name
+          next if NotPressed::ThemeRegistry.available.include?(klass.plugin_name)
+          NotPressed::ThemeRegistry.register(klass)
+        end
+
+        # Auto-activate default theme if none active
+        default_theme = NotPressed.configuration.default_theme
+        if default_theme && NotPressed::ThemeRegistry.active.nil?
+          begin
+            NotPressed::ThemeRegistry.activate(default_theme)
+          rescue NotPressed::ThemeRegistry::NotFound
+            # Default theme not available, no action needed
+          end
+        end
+      end
+    end
+
+    initializer "not_pressed.plugins" do
+      config.after_initialize do
+        NotPressed::PluginManager.discover
+        NotPressed::PluginManager.enable_all
+      end
+    end
+
+    initializer "not_pressed.append_migrations" do |app|
+      config.paths["db/migrate"].expanded.each do |expanded_path|
+        app.config.paths["db/migrate"] << expanded_path unless app.config.paths["db/migrate"].include?(expanded_path)
+      end
+    end
+  end
+end