ruby_cms 0.2.1.0 → 1.0.0

data/app/javascript/controllers/ruby_cms/visual_editor_controller.js

@@ -1,325 +0,0 @@
-import { Controller } from "@hotwired/stimulus"
-
-export default class extends Controller {
-  static targets = [
-    "modal",
-    "modalBody",
-    "previewFrame",
-    "contentType",
-    "contentInput",
-    "richContentInput",
-    "richTextContainer",
-    "textContainer",
-    "blockKey",
-    "charCount",
-    "lastUpdated",
-    "saveButton",
-    "toast",
-    "toastMessage"
-  ]
-
-  static values = {
-    currentPage: String
-  }
-
-  connect() {
-    this.currentContentBlockKey = null
-    this.currentContentBlockLocale = null
-    this.currentContentBlockId = null
-    this.currentBlockIndex = 0
-    this.editMode = false
-
-    // Listen for messages from iframe
-    this.boundHandleMessage = this.handleMessage.bind(this)
-    window.addEventListener("message", this.boundHandleMessage)
-
-    // Listen for Escape key globally when modal is open
-    this.boundHandleEscape = this.handleEscape.bind(this)
-
-    // Listen for iframe load
-    this.previewFrameTarget.addEventListener("load", () => {
-      console.log("Preview frame loaded")
-    })
-  }
-
-  disconnect() {
-    if (this.boundHandleMessage) {
-      window.removeEventListener("message", this.boundHandleMessage)
-    }
-    document.removeEventListener("keydown", this.boundHandleEscape)
-  }
-
-  handleMessage(event) {
-    // Only accept same-origin messages (iframe preview is same app)
-    if (event.origin !== window.location.origin) return
-
-    const { type, blockId, blockIndex, page } = event.data
-
-    if (type === "CONTENT_BLOCK_CLICKED") {
-      this.openBlockEditor(blockId, blockIndex)
-    }
-  }
-
-  async openBlockEditor(blockKey, blockIndex = 0) {
-    this.currentContentBlockKey = blockKey
-    this.currentBlockIndex = blockIndex
-    this.blockKeyTarget.textContent = blockKey
-
-    try {
-      const response = await fetch(`/admin/content_blocks?search=${encodeURIComponent(blockKey)}&format=json`, {
-        headers: { "Accept": "application/json" }
-      })
-      if (!response.ok) throw new Error("Failed to fetch content block")
-
-      const data = await response.json()
-      const blocks = data.content_blocks || []
-      const currentLocale = this.getCurrentLocale()
-      // Prefer block matching key and current locale; else first block with same key
-      const block = blocks.find(b => b.key === blockKey && (b.locale === currentLocale || !b.locale)) ||
-        blocks.find(b => b.key === blockKey) ||
-        (blocks[blockIndex]?.key === blockKey ? blocks[blockIndex] : null) ||
-        {}
-
-      this.currentContentBlockLocale = block.locale || currentLocale
-      this.currentContentBlockId = block.id || null
-      this.dispatch("block-loaded", { detail: { blockId: block.id } })
-
-      const contentType = String(block.content_type || "text").toLowerCase()
-      this.contentTypeTarget.value = contentType
-      this.changeContentType()
-
-      if (contentType === "rich_text") {
-        let html = String(block.rich_content != null ? block.rich_content : "").trim()
-        if (!html && block.content) {
-          const text = String(block.content).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;")
-          html = `<p>${text}</p>`
-        }
-        if (html && !html.trimStart().startsWith("<")) {
-          const escaped = html.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;")
-          html = `<p>${escaped}</p>`
-        }
-        this.richContentInputTarget.value = html || ""
-        this.lastUpdatedTarget.textContent = block.updated_at || "Never"
-        this.updateCharCount()
-
-        this.modalTarget.classList.remove("hidden")
-        document.addEventListener("keydown", this.boundHandleEscape)
-
-        const tryLoadHTML = (attempt = 0) => {
-          const editorEl = this.richTextContainerTarget.querySelector("trix-editor")
-          if (editorEl?.editor) {
-            editorEl.editor.loadHTML(html || "")
-            this.updateCharCount()
-            editorEl.focus?.()
-          } else if (attempt < 50) {
-            setTimeout(() => tryLoadHTML(attempt + 1), 80)
-          }
-        }
-        requestAnimationFrame(() => {
-          requestAnimationFrame(() => setTimeout(() => tryLoadHTML(), 120))
-        })
-      } else {
-        this.contentInputTarget.value = block.content || ""
-        this.lastUpdatedTarget.textContent = block.updated_at || "Never"
-        this.updateCharCount()
-        this.modalTarget.classList.remove("hidden")
-        document.addEventListener("keydown", this.boundHandleEscape)
-        setTimeout(() => this.contentInputTarget.focus(), 50)
-      }
-
-      this.sendMessageToPreview({
-        type: "HIGHLIGHT_BLOCK",
-        blockId: blockKey,
-        blockIndex: blockIndex
-      })
-    } catch (error) {
-      console.error("Error loading content block:", error)
-      alert("Failed to load content block")
-    }
-  }
-
-  closeModal() {
-    this.modalTarget.classList.add("hidden")
-    this.currentContentBlockKey = null
-    this.currentContentBlockLocale = null
-    this.currentContentBlockId = null
-    this.currentBlockIndex = 0
-
-    document.removeEventListener("keydown", this.boundHandleEscape)
-    this.sendMessageToPreview({ type: "CLEAR_HIGHLIGHT" })
-  }
-
-  handleEscape(event) {
-    // Only handle Escape if modal is visible
-    if (event.key === "Escape" && !this.modalTarget.classList.contains("hidden")) {
-      event.preventDefault()
-      event.stopPropagation()
-      this.closeModal()
-    }
-  }
-
-  changeContentType() {
-    const contentType = this.contentTypeTarget.value
-
-    if (contentType === "rich_text") {
-      this.textContainerTarget.style.display = "none"
-      this.richTextContainerTarget.classList.add("ruby_cms-visual-editor-modal__rich-text-container--visible")
-    } else {
-      this.textContainerTarget.style.display = "block"
-      this.richTextContainerTarget.classList.remove("ruby_cms-visual-editor-modal__rich-text-container--visible")
-    }
-
-    this.updateCharCount()
-  }
-
-  updateCharCount() {
-    const contentType = this.contentTypeTarget.value
-    let content = ""
-
-    if (contentType === "rich_text") {
-      const editor = this.richTextContainerTarget.querySelector("trix-editor")
-      if (editor && editor.editor) {
-        content = editor.editor.getDocument().toString()
-      }
-    } else {
-      content = this.contentInputTarget.value
-    }
-
-    this.charCountTarget.textContent = `${content.length} characters`
-  }
-
-  async saveContent(event) {
-    event.preventDefault()
-
-    if (!this.currentContentBlockKey) return
-
-    const contentType = this.contentTypeTarget.value
-    const payload = {
-      key: this.currentContentBlockKey,
-      content_type: contentType,
-      locale: this.currentContentBlockLocale || null
-    }
-
-    if (contentType === "rich_text") {
-      const editor = this.richTextContainerTarget.querySelector("trix-editor")
-      payload.rich_content = editor ? editor.value : ""
-    } else {
-      payload.content = this.contentInputTarget.value
-    }
-
-    try {
-      this.saveButtonTarget.disabled = true
-      this.saveButtonTarget.textContent = "Saving..."
-
-      const response = await fetch("/admin/visual_editor/quick_update", {
-        method: "PATCH",
-        headers: {
-          "Content-Type": "application/json",
-          "Accept": "application/json",
-          "X-CSRF-Token": document.querySelector('meta[name="csrf-token"]').content
-        },
-        body: JSON.stringify(payload)
-      })
-
-      const data = await response.json()
-
-      if (!response.ok || !data.success) {
-        throw new Error(data.message || "Failed to save")
-      }
-
-      // Update last updated time
-      this.lastUpdatedTarget.textContent = data.updated_at
-
-      // Update content in preview (same message format as app so page_preview_controller works)
-      const contentToDisplay = contentType === "rich_text"
-        ? (data.rich_content_html || data.content || "")
-        : (data.content || "")
-
-      this.sendMessageToPreview({
-        type: "content-updated",
-        key: this.currentContentBlockKey,
-        content: contentToDisplay,
-        blockIndex: this.currentBlockIndex ?? 0
-      })
-
-      // Close modal
-      this.closeModal()
-
-      // Show success toast
-      this.showToast(data.message || "Content updated successfully")
-
-    } catch (error) {
-      console.error("Error saving content:", error)
-      alert(error.message || "Failed to save content")
-    } finally {
-      this.saveButtonTarget.disabled = false
-      this.saveButtonTarget.textContent = "Save Changes"
-    }
-  }
-
-  handleKeydown(event) {
-    // Enter to submit (but Shift+Enter allows newline in textareas)
-    if (event.key === "Enter") {
-      const isTextarea = event.target.matches("textarea")
-      const isTrixEditor = event.target.matches("trix-editor") || event.target.closest("trix-editor")
-
-      // Allow Shift+Enter for newlines in textareas/trix
-      if ((isTextarea || isTrixEditor) && event.shiftKey) {
-        return // Let the default behavior happen (newline)
-      }
-
-      // Enter without Shift submits the form
-      if (!isTextarea && !isTrixEditor) {
-        // Enter outside textarea/trix submits
-        event.preventDefault()
-        this.saveContent(event)
-      } else if (!event.shiftKey) {
-        // Enter in textarea/trix without Shift submits
-        event.preventDefault()
-        this.saveContent(event)
-      }
-    }
-
-    // Ctrl/Cmd + Enter to save (alternative shortcut)
-    if ((event.ctrlKey || event.metaKey) && event.key === "Enter") {
-      event.preventDefault()
-      this.saveContent(event)
-    }
-  }
-
-  refreshPreview() {
-    const iframe = this.previewFrameTarget
-    iframe.src = iframe.src
-  }
-
-  sendMessageToPreview(message) {
-    const iframe = this.previewFrameTarget
-    if (iframe && iframe.contentWindow) {
-      iframe.contentWindow.postMessage(message, window.location.origin)
-    }
-  }
-
-  showToast(message) {
-    this.toastMessageTarget.textContent = message
-    this.toastTarget.classList.remove("hidden")
-
-    setTimeout(() => {
-      this.toastTarget.classList.add("hidden")
-    }, 3000)
-  }
-
-  getCurrentLocale() {
-    // Try to get locale from meta tag
-    const metaLocale = document.querySelector('meta[name="locale"]')
-    if (metaLocale) {
-      return metaLocale.content
-    }
-    // Try HTML lang attribute
-    const htmlLang = document.documentElement.lang
-    if (htmlLang) {
-      return htmlLang
-    }
-    // Fallback to default
-    return 'en'
-  }
-}

data/app/models/concerns/content_block/searchable.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-# DHH-style concern for search behavior.
-# Extracts search and filtering logic to a reusable module.
-#
-# @example
-#   ContentBlock.search_by_term("welcome")
-module ContentBlock::Searchable # rubocop:disable Style/ClassAndModuleChildren
-  extend ActiveSupport::Concern
-
-  included do
-    # Search content blocks by key or title.
-    # @param term [String] The search term
-    # @return [ActiveRecord::Relation]
-    scope :search_by_term, lambda {|term|
-      return all if term.blank?
-
-      search_pattern = "%#{term.to_s.downcase}%"
-      where("LOWER(key) LIKE ? OR LOWER(title) LIKE ?", search_pattern, search_pattern)
-    }
-  end
-end

data/app/models/ruby_cms/content_block.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  # Backwards-compatible shim: keep RubyCms::ContentBlock working,
-  # but the canonical model is the top-level ::ContentBlock.
-  class ContentBlock < ::ContentBlock
-  end
-end

data/app/models/ruby_cms/permission.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  class Permission < ::ApplicationRecord
-    self.table_name = "permissions"
-
-    has_many :user_permissions, dependent: :destroy, class_name: "RubyCms::UserPermission"
-    has_many :users, through: :user_permissions
-
-    validates :key, presence: true, uniqueness: true
-
-    DEFAULT_KEYS = RubyCms::DEFAULT_PERMISSION_KEYS
-
-    class << self
-      def ensure_defaults!
-        all_keys.each do |k|
-          find_or_create_by!(key: k) {|p| p.name = k.titleize }
-        end
-      end
-
-      def all_keys
-        (DEFAULT_KEYS + RubyCms.extra_permission_keys.map(&:to_s)).uniq.freeze
-      end
-
-      def templates
-        RubyCms.permission_templates
-      end
-
-      def register_keys(*keys)
-        RubyCms.register_permission_keys(*keys)
-      end
-
-      def register_template(name, label:, keys:, description: nil)
-        RubyCms.register_permission_template(name, label:, keys:, description:)
-      end
-
-      def apply_template!(user, template_name)
-        tmpl = templates[template_name.to_sym]
-        raise ArgumentError, "Unknown template: #{template_name}" unless tmpl
-
-        ensure_defaults!
-        perms = where(key: tmpl[:keys])
-        perms.each do |perm|
-          RubyCms::UserPermission.find_or_create_by!(user: user, permission: perm)
-        end
-      end
-
-      def matching_templates(user)
-        user_keys = RubyCms::UserPermission.where(user:)
-                                           .joins(:permission)
-                                           .pluck("permissions.key")
-        templates.select {|_, tmpl| (tmpl[:keys] - user_keys).empty? }
-                 .keys
-      end
-    end
-  end
-end

data/app/models/ruby_cms/permittable.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  module Permittable
-    extend ActiveSupport::Concern
-
-    # Check if the user has a permission. record: reserved for future record-scoped permissions.
-    # Default-deny: unknown permission key = forbidden. Permission lookups are cached per-request.
-    def can?(permission_key, record: nil)
-      return bootstrap_allowed?(permission_key) if bootstrap?
-
-      k = permission_key.to_s
-      return false unless RubyCms::Permission.exists?(key: k)
-
-      cms_permission_keys_cached.include?(k) ||
-        record&.can_edit?(self)
-    end
-
-    def bootstrap?
-      RubyCms::Permission.none?
-    end
-
-    def bootstrap_allowed?(permission_key)
-      return false unless Rails.application.config.ruby_cms.bootstrap_admin_with_role
-      return false unless respond_to?(:admin?) && admin?
-
-      permission_key.to_s == "manage_admin"
-    end
-
-    # Per-request cache of this user's permission keys. Never rely on client-side checks.
-    def cms_permission_keys_cached
-      @cms_permission_keys_cached ||=
-        RubyCms::UserPermission.where(user: self)
-                               .joins(:permission).pluck("permissions.key")
-    end
-  end
-end

data/app/models/ruby_cms/preference.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  # Stores configuration preferences for the CMS admin interface.
-  # Preferences are key-value pairs with optional type casting.
-  class Preference < ::ApplicationRecord
-    self.table_name = "preferences"
-
-    VALUE_TYPES = %w[string integer boolean json].freeze
-
-    validates :key, presence: true, uniqueness: true
-    validates :value_type, inclusion: { in: VALUE_TYPES }
-
-    def self.get(key, default: nil)
-      pref = find_by(key: key.to_s)
-      return default if pref.nil?
-
-      pref.typed_value
-    end
-
-    def self.set(key, value)
-      pref = find_or_initialize_by(key: key.to_s)
-      pref.assign_value(value)
-      pref.save!
-      pref.typed_value
-    end
-
-    def self.all_as_hash
-      all.to_h {|pref| [pref.key.to_sym, pref.typed_value] }
-    end
-
-    def self.ensure_defaults!
-      defaults.each do |key, config|
-        next if exists?(key: key.to_s)
-
-        create!(
-          key: key.to_s,
-          value: serialize_seed_value(config[:value], config[:type]),
-          value_type: config[:type],
-          description: config[:description],
-          category: config[:category] || "general"
-        )
-      end
-    end
-
-    def self.by_category
-      all.group_by(&:category)
-    end
-
-    def self.defaults
-      RubyCms::SettingsRegistry.defaults_hash
-    end
-
-    def typed_value
-      case value_type
-      when "integer" then value.to_i
-      when "boolean" then boolean_cast(value)
-      when "json" then parse_json_value(value)
-      else value
-      end
-    rescue JSON::ParserError, TypeError
-      value.to_s
-    end
-
-    def assign_value(new_value)
-      self.value_type ||= detect_type(new_value)
-      self.value = serialize_value(new_value)
-    end
-
-    class << self
-      private
-
-      def serialize_seed_value(val, type)
-        case type.to_s
-        when "json"
-          val.to_json
-        when "boolean"
-          ActiveModel::Type::Boolean.new.cast(val).to_s
-        else
-          val.to_s
-        end
-      end
-    end
-
-    private
-
-    def boolean_cast(val)
-      ActiveModel::Type::Boolean.new.cast(val)
-    end
-
-    def parse_json_value(val)
-      JSON.parse(val.to_s)
-    end
-
-    def detect_type(val)
-      case val
-      when Integer then "integer"
-      when TrueClass, FalseClass then "boolean"
-      when Hash, Array then "json"
-      else "string"
-      end
-    end
-
-    def serialize_value(val)
-      case val
-      when Hash, Array then val.to_json
-      else val.to_s
-      end
-    end
-  end
-end

data/app/models/ruby_cms/user_permission.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  class UserPermission < ::ApplicationRecord
-    self.table_name = "user_permissions"
-
-    belongs_to :user, class_name: "User", optional: false
-    belongs_to :permission, class_name: "RubyCms::Permission"
-
-    validates :user_id, uniqueness: { scope: :permission_id }
-  end
-end

data/app/models/ruby_cms/visitor_error.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-
-module RubyCms
-  class VisitorError < ::ApplicationRecord
-    self.table_name = "visitor_errors"
-
-    scope :recent, -> { order(created_at: :desc) }
-    scope :unresolved, -> { where(resolved: false) }
-    scope :by_page, ->(path) { where(request_path: path) }
-    scope :today, -> { where(created_at: Date.current.beginning_of_day..) }
-
-    def self.log_error(exception, request)
-      create!(
-        **base_request_attrs(request),
-        **exception_attrs(exception),
-        request_params: sanitize_params(request.params)
-      )
-    rescue StandardError => e
-      Rails.logger.error "Failed to log visitor error: #{e.message}"
-    end
-
-    # Log routing errors (404s) from catch-all route.
-    # Called by RubyCms::ErrorsController#not_found
-    def self.log_routing_error(request)
-      return if Rails.env.development?
-      return if request.path.start_with?("/admin")
-
-      create!(
-        **base_request_attrs(request),
-        error_class: "ActionController::RoutingError",
-        error_message: routing_error_message(request),
-        backtrace: nil,
-        request_params: nil
-      )
-    rescue StandardError => e
-      Rails.logger.error "Failed to log routing error: #{e.message}"
-    end
-
-    # Returns the code path: backtrace for exceptions, or synthetic path for routing errors
-    def codepath
-      if backtrace.present?
-        backtrace
-      elsif error_class == "ActionController::RoutingError"
-        <<~TEXT.strip
-          Request → Router (no matching route) → RubyCms::ErrorsController#not_found
-          (Routing errors don't generate stack traces; the request never reached a controller action.)
-        TEXT
-      else
-        "No stack trace available."
-      end
-    end
-
-    def browser_info
-      return "Unknown" if user_agent.blank?
-
-      case user_agent
-      when /Chrome/ then "Chrome"
-      when /Firefox/ then "Firefox"
-      when /Safari(?!.*Chrome)/ then "Safari"
-      when /Edge/ then "Edge"
-      else "Other"
-      end
-    end
-
-    class << self
-      private
-
-      def sanitize_params(params)
-        return nil unless params
-
-        h = params.respond_to?(:to_unsafe_h) ? params.to_unsafe_h : params.to_h
-        filtered = h.except("password", "password_confirmation", "authenticity_token")
-        filtered.to_json.truncate(500)
-      end
-
-      def base_request_attrs(request)
-        {
-          request_path: request.path,
-          request_method: request.request_method,
-          ip_address: request.remote_ip,
-          user_agent: request.user_agent,
-          session_id: safe_session_id(request),
-          referer: request.referer.presence&.truncate(500),
-          query_string: request.query_string.presence&.truncate(500)
-        }
-      end
-
-      def exception_attrs(exception)
-        {
-          error_class: exception.class.name,
-          error_message: exception.message,
-          backtrace: exception.backtrace&.first(10)&.join("\n")
-        }
-      end
-
-      def routing_error_message(request)
-        "No route matches [#{request.request_method}] \"#{request.path}\""
-      end
-
-      def safe_session_id(request)
-        request.session.id
-      rescue StandardError
-        nil
-      end
-    end
-  end
-end