not_pressed-core 0.1.0

data/app/models/not_pressed/page.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class Page < ActiveRecord::Base
+    self.table_name = "not_pressed_pages"
+
+    belongs_to :parent, class_name: "NotPressed::Page", optional: true, inverse_of: :children
+    has_many :children, class_name: "NotPressed::Page", foreign_key: :parent_id,
+                        dependent: :destroy, inverse_of: :parent
+    has_many :content_blocks, class_name: "NotPressed::ContentBlock",
+                              dependent: :destroy, inverse_of: :page
+    has_many :page_versions, class_name: "NotPressed::PageVersion",
+                              dependent: :destroy
+    belongs_to :category, class_name: "NotPressed::Category", optional: true, inverse_of: :pages
+    has_many :taggings, class_name: "NotPressed::Tagging", foreign_key: :page_id,
+                        dependent: :destroy, inverse_of: :page
+    has_many :tags, through: :taggings
+
+    attr_accessor :skip_versioning, :page_password
+
+    # Hook system callbacks
+    after_create { NotPressed::Hooks.fire(:after_page_create, self) }
+    before_save :fire_before_page_hooks
+    after_save :fire_after_page_hooks
+    after_destroy { NotPressed::Hooks.fire(:after_page_destroy, self) }
+
+    enum :status, { draft: 0, published: 1, archived: 2, scheduled: 3 }
+    enum :visibility, { public_page: 0, unlisted: 1, password_protected: 2 }, prefix: :visibility
+
+    validates :title, presence: true
+    validates :content_type, inclusion: { in: ->(_) { NotPressed::ContentTypeRegistry.names } }
+    validates :slug, presence: true,
+                     uniqueness: true,
+                     format: { with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/, message: "must be lowercase alphanumeric with hyphens" }
+    validates :scheduled_at, presence: true, if: :scheduled?
+    validates :layout, inclusion: { in: ->(_) { NotPressed.configuration.available_layouts } }, allow_nil: true
+    validates :password_digest, presence: true, if: :visibility_password_protected?
+    validate :scheduled_at_must_be_future, if: :scheduled?
+    validate :scheduled_at_must_be_nil_unless_scheduled
+
+    before_validation :generate_slug, on: :create
+    before_validation :hash_page_password
+    before_save :set_published_at
+    after_save :create_version_snapshot, unless: :skip_versioning
+    after_save :invalidate_navigation_cache
+    after_destroy :invalidate_navigation_cache
+
+    scope :of_type, ->(type) { where(content_type: type) }
+    scope :roots, -> { where(parent_id: nil) }
+    scope :ordered, -> { order(position: :asc) }
+    scope :visible, -> { where(status: :published) }
+    scope :publicly_accessible, -> { where(visibility: [:public_page, :unlisted]) }
+    scope :needs_publishing, -> { where(status: :scheduled).where("scheduled_at <= ?", Time.current) }
+    scope :blog_posts, -> { of_type("blog_post") }
+
+    def authenticate_page_password(password)
+      return false if password_digest.blank?
+
+      salt, stored_hash = password_digest.split(":", 2)
+      Digest::SHA256.hexdigest("#{salt}:#{password}") == stored_hash
+    end
+
+    def meta_title_or_title
+      meta_title.presence || title
+    end
+
+    def effective_canonical_url(request)
+      canonical_url.presence || request.original_url
+    end
+
+    def meta_robots_tag
+      return meta_robots if meta_robots.present?
+      return "noindex" if draft? || archived?
+
+      nil
+    end
+
+    def self.publish_scheduled!
+      needs_publishing.find_each do |page|
+        page.update!(status: :published, scheduled_at: nil)
+      end
+    end
+
+    private
+
+    def fire_before_page_hooks
+      NotPressed::Hooks.fire(:before_page_save, self)
+      if status_changed? && published?
+        @_publishing = true
+        NotPressed::Hooks.fire(:before_page_publish, self)
+      else
+        @_publishing = false
+      end
+    end
+
+    def fire_after_page_hooks
+      NotPressed::Hooks.fire(:after_page_save, self)
+      if @_publishing
+        NotPressed::Hooks.fire(:after_page_publish, self)
+        @_publishing = false
+      end
+    end
+
+    def hash_page_password
+      if page_password.present?
+        salt = SecureRandom.hex(16)
+        hash = Digest::SHA256.hexdigest("#{salt}:#{page_password}")
+        self.password_digest = "#{salt}:#{hash}"
+      end
+    end
+
+    def set_published_at
+      if status_changed? && published?
+        self.published_at ||= Time.current
+      elsif status_changed? && status_was == "published"
+        self.published_at = nil
+      end
+    end
+
+    def create_version_snapshot
+      event = if previously_new_record?
+                "created"
+              elsif saved_change_to_status?
+                status
+              elsif saved_change_to_title? || saved_change_to_slug?
+                "updated"
+              else
+                return
+              end
+
+      snapshot = {
+        title: title,
+        slug: slug,
+        status: status,
+        meta_description: meta_description,
+        content_type: content_type,
+        published_at: published_at,
+        blocks: content_blocks.ordered.map { |b| { block_type: b.block_type, content: b.content, position: b.position } }
+      }
+
+      page_versions.create!(
+        version_number: (page_versions.maximum(:version_number).to_i + 1),
+        snapshot: snapshot,
+        event: event
+      )
+    end
+
+    def invalidate_navigation_cache
+      NotPressed.invalidate_navigation!
+    end
+
+    def generate_slug
+      return if slug.present?
+      return if title.blank?
+
+      base_slug = title.encode("UTF-8").parameterize
+      candidate = base_slug
+      counter = 2
+
+      while self.class.where(slug: candidate).exists?
+        candidate = "#{base_slug}-#{counter}"
+        counter += 1
+      end
+
+      self.slug = candidate
+    end
+
+    def scheduled_at_must_be_future
+      return if scheduled_at.blank?
+
+      if scheduled_at <= Time.current
+        errors.add(:scheduled_at, "must be in the future")
+      end
+    end
+
+    def scheduled_at_must_be_nil_unless_scheduled
+      return if scheduled? || scheduled_at.blank?
+
+      errors.add(:scheduled_at, "must be blank unless status is scheduled")
+    end
+  end
+end

data/app/models/not_pressed/page_version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class PageVersion < ActiveRecord::Base
+    self.table_name = "not_pressed_page_versions"
+
+    belongs_to :page, class_name: "NotPressed::Page"
+
+    validates :version_number, presence: true
+    validates :snapshot, presence: true
+    validates :event, presence: true
+
+    scope :ordered, -> { order(version_number: :desc) }
+  end
+end

data/app/models/not_pressed/setting.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class Setting < ActiveRecord::Base
+    self.table_name = "not_pressed_settings"
+
+    validates :key, presence: true, uniqueness: true
+
+    def self.get(key)
+      find_by(key: key)&.value
+    end
+
+    def self.set(key, value)
+      record = find_or_initialize_by(key: key)
+      record.value = value
+      record.save!
+      record
+    end
+  end
+end

data/app/models/not_pressed/tag.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class Tag < ActiveRecord::Base
+    self.table_name = "not_pressed_tags"
+
+    include NotPressed::Sluggable
+
+    has_many :taggings, class_name: "NotPressed::Tagging", foreign_key: :tag_id,
+                        dependent: :destroy, inverse_of: :tag
+    has_many :pages, through: :taggings
+
+    validates :name, presence: true, uniqueness: true
+  end
+end

data/app/models/not_pressed/tagging.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class Tagging < ActiveRecord::Base
+    self.table_name = "not_pressed_taggings"
+
+    belongs_to :tag, class_name: "NotPressed::Tag", inverse_of: :taggings
+    belongs_to :page, class_name: "NotPressed::Page", inverse_of: :taggings
+
+    validates :tag_id, uniqueness: { scope: :page_id }
+  end
+end

data/app/plugins/not_pressed/analytics_plugin.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class AnalyticsPlugin < Plugin
+    name "Analytics"
+    version "1.0.0"
+    description "Add analytics tracking to your site"
+    author "NotPressed"
+
+    settings do
+      string :tracking_id, label: "Tracking ID", required: true
+      select :provider, label: "Provider", options: %w[google_analytics plausible umami], default: "google_analytics"
+      boolean :anonymize_ip, label: "Anonymize IP", default: true
+    end
+
+    def activate!
+      plugin_instance = self
+
+      @page_content_filter = proc do |html, _page|
+        plugin_instance.inject_analytics(html)
+      end
+
+      @after_publish_hook = proc do |page|
+        Rails.logger.info "[Analytics] Page published: #{page.respond_to?(:title) ? page.title : page}"
+      end
+
+      NotPressed::Hooks.register_filter(:page_content, &@page_content_filter)
+      NotPressed::Hooks.register(:after_page_publish, &@after_publish_hook)
+
+      self.class.plugin_block_types.each do |bt|
+        NotPressed::ContentBlock.register_type(bt[:name].to_s)
+      end
+      self.class.plugin_admin_menus.each do |menu|
+        NotPressed::Admin::MenuRegistry.register(
+          menu[:label],
+          path: menu[:path],
+          icon: menu[:icon],
+          section: :main,
+          position: 100
+        )
+      end
+
+      @active = true
+    end
+
+    def deactivate!
+      NotPressed::Hooks.unregister_filter(:page_content, @page_content_filter) if @page_content_filter
+      NotPressed::Hooks.unregister(:after_page_publish, @after_publish_hook) if @after_publish_hook
+
+      self.class.plugin_block_types.each do |bt|
+        NotPressed::ContentBlock.custom_types.delete(bt[:name].to_s)
+      end
+      self.class.plugin_admin_menus.each do |menu|
+        NotPressed::Admin::MenuRegistry.unregister(menu[:label], path: menu[:path])
+      end
+
+      @active = false
+    end
+
+    def inject_analytics(html)
+      tracking_id = get_setting(:tracking_id)
+      return html if tracking_id.nil? || tracking_id.to_s.strip.empty?
+
+      provider = get_setting(:provider) || "google_analytics"
+      script = analytics_script(provider, tracking_id)
+      "#{html}#{script}"
+    end
+
+    private
+
+    def analytics_script(provider, tracking_id)
+      case provider.to_s
+      when "google_analytics"
+        google_analytics_script(tracking_id)
+      when "plausible"
+        plausible_script(tracking_id)
+      when "umami"
+        umami_script(tracking_id)
+      else
+        ""
+      end
+    end
+
+    def google_analytics_script(tracking_id)
+      anonymize = get_setting(:anonymize_ip)
+      anonymize_config = anonymize.to_s == "true" ? ", { 'anonymize_ip': true }" : ""
+      <<~HTML
+        <script async src="https://www.googletagmanager.com/gtag/js?id=#{ERB::Util.html_escape(tracking_id)}"></script>
+        <script>
+          window.dataLayer = window.dataLayer || [];
+          function gtag(){dataLayer.push(arguments);}
+          gtag('js', new Date());
+          gtag('config', '#{ERB::Util.html_escape(tracking_id)}'#{anonymize_config});
+        </script>
+      HTML
+    end
+
+    def plausible_script(tracking_id)
+      %(<script defer data-domain="#{ERB::Util.html_escape(tracking_id)}" src="https://plausible.io/js/script.js"></script>\n)
+    end
+
+    def umami_script(tracking_id)
+      %(<script async src="https://analytics.umami.is/script.js" data-website-id="#{ERB::Util.html_escape(tracking_id)}"></script>\n)
+    end
+  end
+end

data/app/plugins/not_pressed/callout_block_plugin.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class CalloutBlockPlugin < Plugin
+    name "Callout Block"
+    version "1.0.0"
+    description "Adds a styled callout/alert block type"
+    author "NotPressed"
+
+    block_type :callout, label: "Callout", icon: "megaphone"
+
+    STYLES = %w[info warning success danger].freeze
+
+    DEFAULT_CONTENT = { "title" => "", "text" => "", "style" => "info" }.freeze
+
+    CALLOUT_RENDERER = lambda do |content, _block|
+      style = STYLES.include?(content["style"].to_s) ? content["style"].to_s : "info"
+      title = ERB::Util.html_escape(content["title"].to_s)
+      text = ERB::Util.html_escape(content["text"].to_s)
+
+      <<~HTML.strip
+        <div class="np-content-callout np-callout-#{style}">
+          <div class="np-callout-title">#{title}</div>
+          <div class="np-callout-text">#{text}</div>
+        </div>
+      HTML
+    end
+
+    def activate!
+      super
+
+      NotPressed::Rendering::RendererRegistry.register("callout", CALLOUT_RENDERER)
+      NotPressed::Rendering::RendererRegistry.register_editor("callout", "not_pressed/admin/content_blocks/editors/callout")
+      NotPressed::Rendering::RendererRegistry.register_default_content("callout", DEFAULT_CONTENT.dup)
+    end
+
+    def deactivate!
+      super
+
+      NotPressed::Rendering::RendererRegistry.unregister("callout")
+    end
+  end
+end

data/app/themes/not_pressed/starter_theme.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class NotPressed::StarterTheme < NotPressed::Theme
+  name "Starter"
+  version "1.0.0"
+  description "A clean, minimal theme for NotPressed. Responsive layouts with customizable colors."
+  author "NotPressed"
+
+  layout :default, label: "Default", primary: true
+  layout :full_width, label: "Full Width"
+  layout :sidebar, label: "With Sidebar"
+
+  stylesheet "not_pressed/themes/starter.css"
+  templates_path File.expand_path("../../../views/themes/starter", __dir__)
+
+  color_scheme do
+    color :primary, "#4f46e5", label: "Primary"
+    color :secondary, "#7c3aed", label: "Secondary"
+    color :background, "#ffffff", label: "Background"
+    color :surface, "#f8fafc", label: "Surface"
+    color :text, "#1e293b", label: "Text"
+    color :text_muted, "#64748b", label: "Muted Text"
+    color :accent, "#06b6d4", label: "Accent"
+    color :border, "#e2e8f0", label: "Border"
+  end
+end