railspress-engine 0.1.2 → 1.2.0

data/app/javascript/railspress/controllers/index.js

@@ -0,0 +1,37 @@
+/**
+ * RailsPress Stimulus Controllers
+ *
+ * Registers all RailsPress controllers with a Stimulus application.
+ *
+ * Usage in host app:
+ *
+ *   // In application.js or wherever you configure Stimulus
+ *   import { Application } from "@hotwired/stimulus"
+ *   import { registerRailspressControllers } from "railspress/controllers"
+ *
+ *   const application = Application.start()
+ *   registerRailspressControllers(application)
+ *
+ * Or register controllers individually:
+ *
+ *   import FocalPointController from "railspress/controllers/focal_point_controller"
+ *   application.register("railspress--focal-point", FocalPointController)
+ */
+
+import FocalPointController from "./focal_point_controller"
+import DropzoneController from "./dropzone_controller"
+import CropController from "./crop_controller"
+import ImageSectionController from "./image_section_controller"
+import CmsInlineEditorController from "./cms_inline_editor_controller"
+
+// Export individual controllers
+export { FocalPointController, DropzoneController, CropController, ImageSectionController, CmsInlineEditorController }
+
+// Export registration function for convenience
+export function registerRailspressControllers(application) {
+  application.register("railspress--focal-point", FocalPointController)
+  application.register("railspress--dropzone", DropzoneController)
+  application.register("railspress--crop", CropController)
+  application.register("rp-image-section", ImageSectionController)
+  application.register("rp--cms-inline-editor", CmsInlineEditorController)
+}

data/app/javascript/railspress/index.js

@@ -0,0 +1,62 @@
+/**
+ * RailsPress - Main Entry Point
+ *
+ * Import this file to auto-register all RailsPress Stimulus controllers.
+ *
+ * Usage (one line in your application.js):
+ *
+ *   import "railspress"
+ *
+ * That's it! Controllers are auto-registered using window.Stimulus.
+ *
+ * For manual registration (if you don't use window.Stimulus):
+ *
+ *   import { register } from "railspress"
+ *   import { application } from "./application"
+ *   register(application)
+ */
+
+// Lexxy rich text editor
+import "lexxy"
+
+// Import Turbo for Turbo Frames support
+import "@hotwired/turbo-rails"
+
+import FocalPointController from "railspress/controllers/focal_point_controller"
+import DropzoneController from "railspress/controllers/dropzone_controller"
+import CropController from "railspress/controllers/crop_controller"
+import ImageSectionController from "railspress/controllers/image_section_controller"
+import CmsInlineEditorController from "railspress/controllers/cms_inline_editor_controller"
+import ContentElementFormController from "railspress/controllers/content_element_form_controller"
+
+// Controller definitions with their identifiers
+const controllers = {
+  "railspress--focal-point": FocalPointController,
+  "railspress--dropzone": DropzoneController,
+  "railspress--crop": CropController,
+  "railspress--image-section": ImageSectionController,
+  "rp--cms-inline-editor": CmsInlineEditorController,
+  "railspress--content-element-form": ContentElementFormController
+}
+
+/**
+ * Register all RailsPress controllers with a Stimulus application.
+ * @param {Application} application - The Stimulus application instance
+ */
+export function register(application) {
+  for (const [identifier, controller] of Object.entries(controllers)) {
+    application.register(identifier, controller)
+  }
+}
+
+// Auto-register using window.Stimulus (set by host app's application.js)
+// This runs as a side-effect when you `import "railspress"`
+if (typeof window !== "undefined" && window.Stimulus) {
+  register(window.Stimulus)
+}
+
+// Export individual controllers for advanced use cases
+export { FocalPointController, DropzoneController, CropController, ImageSectionController, CmsInlineEditorController, ContentElementFormController }
+
+// Re-export the legacy function for backwards compatibility
+export { register as registerRailspressControllers }

data/app/jobs/railspress/export_posts_job.rb

@@ -0,0 +1,16 @@
+module Railspress
+  class ExportPostsJob < ApplicationJob
+    queue_as :default
+
+    def perform(export_id)
+      export = Export.find(export_id)
+
+      processor = PostExportProcessor.new(export: export)
+      processor.process!
+    rescue => e
+      export.add_error("Export failed: #{e.message}")
+      export.mark_failed!
+      raise
+    end
+  end
+end

data/app/jobs/railspress/import_posts_job.rb

@@ -0,0 +1,44 @@
+module Railspress
+  class ImportPostsJob < ApplicationJob
+    queue_as :default
+
+    def perform(import_id, file_paths)
+      import = Import.find(import_id)
+      paths = Array(file_paths)
+
+      import.mark_processing!
+
+      begin
+        paths.each do |file_path|
+          processor = PostImportProcessor.new(import: import, file_path: file_path)
+          processor.process_file(file_path)
+        end
+      ensure
+        finalize_import(import)
+        cleanup_uploaded_files(paths)
+      end
+    end
+
+    private
+
+    def finalize_import(import)
+      if import.error_count > 0 && import.success_count == 0
+        import.mark_failed!
+      else
+        import.mark_completed!
+      end
+    end
+
+    def cleanup_uploaded_files(file_paths)
+      tmp_dir = Rails.root.join("tmp").to_s
+
+      file_paths.each do |path|
+        # Only cleanup files in the tmp directory to avoid deleting source files
+        next unless path.start_with?(tmp_dir)
+        FileUtils.rm_f(path) if File.exist?(path)
+      end
+    rescue => e
+      Rails.logger.warn "Failed to cleanup uploaded import files: #{e.message}"
+    end
+  end
+end

data/app/models/concerns/railspress/has_focal_point.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module Railspress::HasFocalPoint
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Unified DSL for declaring an image attachment with focal point support
+    #
+    # One call that handles everything:
+    # - has_one_attached with variant configuration
+    # - has_focal_point for focal point editing
+    # - railspress_fields registration (if Railspress::Entity included)
+    #
+    # @param attachment_name [Symbol] Name of the attachment
+    # @yield [attachable] Optional block for ActiveStorage variant configuration
+    #
+    # @example Simple usage (no variants)
+    #   focal_point_image :cover_image
+    #
+    # @example With variants
+    #   focal_point_image :header_image do |attachable|
+    #     attachable.variant :hero, resize_to_fill: [2100, 900, { crop: :centre }]
+    #     attachable.variant :card, resize_to_fill: [800, 500, { crop: :centre }]
+    #     attachable.variant :thumb, resize_to_fill: [400, 250, { crop: :centre }]
+    #     attachable.variant :og, resize_to_fill: [1200, 630, { crop: :centre }]
+    #   end
+    #
+    def focal_point_image(attachment_name, &block)
+      # Declare the ActiveStorage attachment with optional variant block
+      has_one_attached attachment_name, &block
+
+      # Add focal point support
+      has_focal_point attachment_name
+
+      # Auto-register with Railspress entity system if available
+      if respond_to?(:railspress_fields)
+        railspress_fields attachment_name, as: :focal_point_image
+      end
+    end
+
+    # Declare focal point support for an attachment
+    #
+    # Creates a polymorphic association to Railspress::FocalPoint.
+    # No migration needed on the host model - data stored in railspress_focal_points table.
+    #
+    # @param attachment_name [Symbol] Name of the ActiveStorage attachment
+    #
+    # @example
+    #   class Post < ApplicationRecord
+    #     has_one_attached :header_image
+    #     has_focal_point :header_image
+    #   end
+    #
+    #   class Project < ApplicationRecord
+    #     include Railspress::HasFocalPoint
+    #     has_one_attached :cover_image
+    #     has_focal_point :cover_image
+    #   end
+    #
+    def has_focal_point(attachment_name)
+      association_name = :"#{attachment_name}_focal_point"
+
+      # Define the has_one association for this attachment's focal point
+      has_one association_name,
+              -> { where(attachment_name: attachment_name.to_s) },
+              as: :record,
+              class_name: "Railspress::FocalPoint",
+              dependent: :destroy,
+              autosave: true
+
+      # Accept nested attributes for form integration
+      accepts_nested_attributes_for association_name
+
+      # Override the association reader to auto-build if nil
+      define_method(association_name) do
+        super() || send(:"build_#{association_name}", attachment_name: attachment_name.to_s)
+      end
+
+      # Auto-create focal point when image is attached
+      after_commit :"ensure_#{attachment_name}_focal_point"
+
+      define_method(:"ensure_#{attachment_name}_focal_point") do
+        attachment = send(attachment_name)
+        return unless attachment.attached?
+
+        # Use the raw association to avoid auto-build, check if persisted
+        existing = Railspress::FocalPoint.find_by(
+          record_type: self.class.name,
+          record_id: id,
+          attachment_name: attachment_name.to_s
+        )
+        return if existing
+
+        Railspress::FocalPoint.create!(
+          record: self,
+          attachment_name: attachment_name.to_s,
+          focal_x: 0.5,
+          focal_y: 0.5
+        )
+      end
+
+      # Store attachment name for lookup
+      @focal_point_attachments ||= []
+      @focal_point_attachments << attachment_name
+    end
+
+    def focal_point_attachments
+      @focal_point_attachments || []
+    end
+  end
+
+  # Get focal point as hash
+  #
+  # @param attachment_name [Symbol] Attachment name
+  # @return [Hash] { x: Float, y: Float }
+  #
+  def focal_point(attachment_name = default_focal_attachment)
+    fp = send(:"#{attachment_name}_focal_point")
+    fp.to_point
+  end
+
+  # Get CSS object-position value
+  #
+  # @param attachment_name [Symbol] Attachment name
+  # @return [String] CSS property value
+  #
+  def focal_point_css(attachment_name = default_focal_attachment)
+    fp = send(:"#{attachment_name}_focal_point")
+    fp.to_css
+  end
+
+  # Check if focal point differs from center
+  #
+  def has_focal_point?(attachment_name = default_focal_attachment)
+    fp = send(:"#{attachment_name}_focal_point")
+    fp.offset_from_center?
+  end
+
+  # Get override for specific context
+  #
+  # @param context [Symbol, String] Context name (e.g., :hero, :card)
+  # @param attachment_name [Symbol] Attachment name
+  # @return [Hash, nil] Override data or nil
+  #
+  def image_override(context, attachment_name = default_focal_attachment)
+    fp = send(:"#{attachment_name}_focal_point")
+    fp.override_for(context)
+  end
+
+  # Check if context has custom override (not using focal point)
+  #
+  def has_image_override?(context, attachment_name = default_focal_attachment)
+    fp = send(:"#{attachment_name}_focal_point")
+    fp.has_override?(context)
+  end
+
+  # Set override for context
+  #
+  def set_image_override(context, data, attachment_name = default_focal_attachment)
+    fp = send(:"#{attachment_name}_focal_point")
+    fp.set_override(context, data)
+  end
+
+  # Clear override for context (revert to focal point)
+  #
+  def clear_image_override(context, attachment_name = default_focal_attachment)
+    fp = send(:"#{attachment_name}_focal_point")
+    fp.clear_override(context)
+  end
+
+  # Get the appropriate image for a context
+  #
+  # Returns the original attachment or a custom uploaded blob.
+  # Host apps use this with standard Rails image_tag:
+  #
+  #   <%= image_tag @post.image_for(:hero), style: @post.image_css_for(:hero) %>
+  #
+  # @param context [Symbol, String] Context name (e.g., :hero, :card)
+  # @param attachment_name [Symbol] Attachment name
+  # @return [ActiveStorage::Attached, ActiveStorage::Blob] The image to display
+  #
+  def image_for(context, attachment_name = default_focal_attachment)
+    override = image_override(context, attachment_name)
+
+    if override&.dig(:type) == "upload" && override[:blob_signed_id].present?
+      begin
+        ActiveStorage::Blob.find_signed!(override[:blob_signed_id])
+      rescue ActiveSupport::MessageVerifier::InvalidSignature, ActiveRecord::RecordNotFound
+        send(attachment_name) # Fallback to original if blob not found
+      end
+    else
+      send(attachment_name)
+    end
+  end
+
+  # Get CSS for displaying image in a context
+  #
+  # Returns object-position CSS for focal point or crop region.
+  # Host apps use this with standard Rails image_tag:
+  #
+  #   <%= image_tag @post.image_for(:hero), style: @post.image_css_for(:hero) %>
+  #
+  # @param context [Symbol, String] Context name (e.g., :hero, :card)
+  # @param attachment_name [Symbol] Attachment name
+  # @return [String] CSS property value(s)
+  #
+  def image_css_for(context, attachment_name = default_focal_attachment)
+    override = image_override(context, attachment_name)
+
+    case override&.dig(:type)
+    when "crop"
+      # Custom crop region - calculate center of crop for object-position
+      region = override[:region]&.with_indifferent_access
+      if region
+        x_offset = (region[:x].to_f + region[:width].to_f / 2) * 100
+        y_offset = (region[:y].to_f + region[:height].to_f / 2) * 100
+        "object-position: #{x_offset.round(1)}% #{y_offset.round(1)}%"
+      else
+        focal_point_css(attachment_name)
+      end
+    when "upload"
+      # Custom upload - center it (no focal point data for uploaded images)
+      "object-position: 50% 50%"
+    else
+      # Default: use focal point
+      focal_point_css(attachment_name)
+    end
+  end
+
+  # Reset focal point to center
+  #
+  def reset_focal_point!(attachment_name = default_focal_attachment)
+    fp = send(:"#{attachment_name}_focal_point")
+    fp.reset!
+  end
+
+  private
+
+  def default_focal_attachment
+    self.class.focal_point_attachments.first || :header_image
+  end
+end

data/app/models/concerns/railspress/soft_deletable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Railspress
+  module SoftDeletable
+    extend ActiveSupport::Concern
+
+    included do
+      scope :active, -> { where(deleted_at: nil) }
+    end
+
+    def deleted?
+      deleted_at.present?
+    end
+
+    def soft_delete
+      update(deleted_at: Time.current)
+    end
+
+    def restore
+      update(deleted_at: nil)
+    end
+  end
+end

data/app/models/concerns/railspress/taggable.rb

@@ -0,0 +1,23 @@
+module Railspress
+  module Taggable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :taggings,
+               as: :taggable,
+               class_name: "Railspress::Tagging",
+               dependent: :destroy
+      has_many :tags,
+               through: :taggings,
+               class_name: "Railspress::Tag"
+    end
+
+    def tag_list
+      tags.pluck(:name).join(", ")
+    end
+
+    def tag_list=(csv_string)
+      self.tags = Railspress::Tag.from_csv(csv_string)
+    end
+  end
+end

data/app/models/railspress/content_element.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Railspress
+  class ContentElement < ApplicationRecord
+    include Railspress::SoftDeletable
+    include Railspress::HasFocalPoint
+
+    belongs_to :content_group
+    has_many :content_element_versions, dependent: :destroy
+    has_one_attached :image
+    has_focal_point :image
+
+    enum :content_type, { text: 0, image: 1 }
+
+    validates :name, presence: true,
+                     uniqueness: { scope: :content_group_id, conditions: -> { active } }
+    validates :content_type, presence: true
+    validates :text_content, presence: true, if: :text?
+    validate :content_type_unchanged, on: :update
+
+    after_save :create_version, if: :should_create_version?
+
+    scope :ordered, -> { order(position: :asc, created_at: :desc) }
+    scope :required, -> { where(required: true) }
+    scope :recent, -> { order(updated_at: :desc) }
+    scope :by_group, ->(content_group) { where(content_group: content_group) }
+    scope :by_content_type, ->(type) { where(content_type: type) }
+
+    def author
+      return nil unless author_id.present? && Railspress.authors_enabled?
+      Railspress.author_class.find_by(id: author_id)
+    end
+
+    def author=(user)
+      self.author_id = user&.id
+    end
+
+    def value
+      if text?
+        text_content
+      elsif image? && image.attached?
+        Rails.application.routes.url_helpers.rails_blob_url(image, only_path: true)
+      end
+    end
+
+    def versions
+      content_element_versions.ordered
+    end
+
+    def current_version
+      content_element_versions.ordered.first
+    end
+
+    def previous_version
+      content_element_versions.ordered.second
+    end
+
+    def version_count
+      content_element_versions.count
+    end
+
+    def soft_delete
+      if required?
+        errors.add(:base, "Cannot delete a required content element")
+        false
+      else
+        super
+      end
+    end
+
+    def restore_to_version(version_number)
+      version = content_element_versions.find_by(version_number: version_number)
+      return false unless version
+
+      update(text_content: version.text_content)
+    end
+
+    private
+
+    def content_type_unchanged
+      if content_type_changed?
+        errors.add(:content_type, "cannot be changed after creation")
+      end
+    end
+
+    def should_create_version?
+      return false unless persisted?
+      return false unless saved_changes.present?
+
+      saved_change_to_text_content?
+    end
+
+    def create_version
+      next_version_number = content_element_versions.maximum(:version_number).to_i + 1
+
+      content_element_versions.create!(
+        author_id: author_id,
+        text_content: text_content_before_last_save || text_content,
+        version_number: next_version_number
+      )
+    end
+  end
+end

data/app/models/railspress/content_element_version.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Railspress
+  class ContentElementVersion < ApplicationRecord
+    belongs_to :content_element
+    has_one_attached :image_version
+
+    validates :content_element, presence: true
+    validates :version_number, presence: true, uniqueness: { scope: :content_element_id }
+
+    scope :ordered, -> { order(version_number: :desc) }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def author
+      return nil unless author_id.present? && Railspress.authors_enabled?
+      Railspress.author_class.find_by(id: author_id)
+    end
+
+    def changes_from_previous
+      previous = content_element.content_element_versions
+                                .where("version_number < ?", version_number)
+                                .order(version_number: :desc)
+                                .first
+
+      return {} unless previous
+
+      changes = {}
+      changes[:text_content] = [ previous.text_content, text_content ] if text_content != previous.text_content
+      changes.compact
+    end
+  end
+end

data/app/models/railspress/content_group.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Railspress
+  class ContentGroup < ApplicationRecord
+    include Railspress::SoftDeletable
+
+    has_many :content_elements, dependent: :destroy
+
+    validates :name, presence: true, uniqueness: true
+
+    scope :ordered, -> { order(created_at: :desc) }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def author
+      return nil unless author_id.present? && Railspress.authors_enabled?
+      Railspress.author_class.find_by(id: author_id)
+    end
+
+    def author=(user)
+      self.author_id = user&.id
+    end
+
+    def element_count
+      content_elements.active.count
+    end
+
+    def soft_delete
+      if content_elements.active.where(required: true).exists?
+        errors.add(:base, "Cannot delete group containing required content elements")
+        false
+      else
+        transaction do
+          content_elements.each(&:soft_delete)
+          update!(deleted_at: Time.current)
+        end
+      end
+    end
+  end
+end

data/app/models/railspress/export.rb

@@ -0,0 +1,67 @@
+module Railspress
+  class Export < ApplicationRecord
+    STATUSES = %w[pending processing completed failed].freeze
+    EXPORT_TYPES = %w[posts].freeze
+
+    has_one_attached :file
+
+    validates :export_type, presence: true, inclusion: { in: EXPORT_TYPES }
+    validates :status, presence: true, inclusion: { in: STATUSES }
+
+    scope :by_type, ->(type) { where(export_type: type) }
+    scope :recent, -> { order(created_at: :desc).limit(10) }
+    scope :pending, -> { where(status: "pending") }
+    scope :processing, -> { where(status: "processing") }
+    scope :completed, -> { where(status: "completed") }
+    scope :failed, -> { where(status: "failed") }
+
+    def pending?
+      status == "pending"
+    end
+
+    def processing?
+      status == "processing"
+    end
+
+    def completed?
+      status == "completed"
+    end
+
+    def failed?
+      status == "failed"
+    end
+
+    def mark_processing!
+      update!(status: "processing")
+    end
+
+    def mark_completed!
+      update!(status: "completed")
+    end
+
+    def mark_failed!
+      update!(status: "failed")
+    end
+
+    def add_error(message)
+      errors_array = parsed_errors
+      errors_array << message
+      update!(error_messages: errors_array.to_json, error_count: errors_array.size)
+    end
+
+    def increment_success!
+      increment!(:success_count)
+    end
+
+    def increment_total!
+      increment!(:total_count)
+    end
+
+    def parsed_errors
+      return [] if error_messages.blank?
+      JSON.parse(error_messages)
+    rescue JSON::ParserError
+      []
+    end
+  end
+end