railspress-engine 0.1.2 → 1.2.0

data/app/models/railspress/focal_point.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Railspress
+  class FocalPoint < ApplicationRecord
+    belongs_to :record, polymorphic: true
+
+    validates :attachment_name, presence: true
+    validates :focal_x, :focal_y,
+              numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 1 }
+
+    validate :validate_overrides_structure
+
+    # Valid override types
+    VALID_OVERRIDE_TYPES = %w[focal crop upload].freeze
+
+    # Get focal point as hash
+    def to_point
+      { x: focal_x, y: focal_y }
+    end
+
+    # Get CSS object-position value
+    def to_css
+      "object-position: #{(focal_x * 100).round(1)}% #{(focal_y * 100).round(1)}%"
+    end
+
+    # Check if focal point differs from center
+    def offset_from_center?
+      (focal_x - 0.5).abs > 0.001 || (focal_y - 0.5).abs > 0.001
+    end
+
+    # Get override for specific context
+    def override_for(context)
+      overrides&.dig(context.to_s)&.with_indifferent_access
+    end
+
+    # Check if context has custom override (not using focal point)
+    def has_override?(context)
+      override = override_for(context)
+      override.present? && override[:type] != "focal"
+    end
+
+    # Set override for context
+    def set_override(context, data)
+      self.overrides = (overrides || {}).merge(context.to_s => data)
+    end
+
+    # Clear override for context (revert to focal point)
+    def clear_override(context)
+      set_override(context, { "type" => "focal" })
+    end
+
+    # Reset to center
+    def reset!
+      update!(focal_x: 0.5, focal_y: 0.5)
+    end
+
+    private
+
+    def validate_overrides_structure
+      return if overrides.blank?
+
+      overrides.each do |context, override|
+        next if override.blank?
+        unless VALID_OVERRIDE_TYPES.include?(override["type"])
+          errors.add(:overrides, "has invalid type for context #{context}")
+        end
+      end
+    end
+  end
+end

data/app/models/railspress/import.rb

@@ -0,0 +1,65 @@
+module Railspress
+  class Import < ApplicationRecord
+    STATUSES = %w[pending processing completed failed].freeze
+    IMPORT_TYPES = %w[posts].freeze
+
+    validates :import_type, presence: true, inclusion: { in: IMPORT_TYPES }
+    validates :status, presence: true, inclusion: { in: STATUSES }
+
+    scope :by_type, ->(type) { where(import_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

data/app/models/railspress/post.rb

@@ -1,5 +1,28 @@
 module Railspress
   class Post < ApplicationRecord
+    include Railspress::Entity
+    include Railspress::Taggable
+    include Railspress::HasFocalPoint
+
+    # === Entity Field Declarations ===
+    # These fields use the Entity system for type detection and config introspection.
+    # Post is NOT registered as an entity (it keeps its dedicated controller/views).
+    railspress_fields :title, :slug, :excerpt
+    railspress_fields :meta_title, :meta_description
+    railspress_fields :content                        # auto-detects :rich_text
+    railspress_fields :header_image, as: :attachment
+    railspress_fields :published_at, :reading_time
+
+    # Fields NOT declared above (Entity doesn't support these types yet):
+    # - category_id (belongs_to association)
+    # - status (enum)
+    # - author_id (configurable polymorphic)
+    # - tags (has_many through)
+    # See .ai/FUTURE_ENTITY.md for planned Entity enhancements
+
+    railspress_label "Posts"
+
+    # === Associations ===
     belongs_to :category, optional: true
     # Author association - only functional when Railspress.authors_enabled?
     # The author class is configured via Railspress.configure { |c| c.author_class_name = "User" }
@@ -11,37 +34,97 @@ module Railspress
     def author=(user)
       self.author_id = user&.id
     end
-    has_many :post_tags, dependent: :destroy
-    has_many :tags, through: :post_tags
-
     has_rich_text :content
-    has_one_attached :header_image
+    has_one_attached :header_image do |attachable|
+      # Apply configured variants from host app's initializer
+      # e.g., config.post_image_variants = { hero: { resize_to_fill: [1920, 1080] } }
+      # WebP format is automatically applied for web optimization
+      Railspress.post_image_variants.each do |name, options|
+        attachable.variant name, **options.merge(format: :webp)
+      end
+    end
+    has_focal_point :header_image
 
     # Virtual attribute for removing header image via checkbox
     attr_accessor :remove_header_image
     before_save :purge_header_image, if: -> { remove_header_image == "1" }
 
-    enum :status, { draft: 0, published: 1 }, default: :draft
+    enum :status, { draft: 0, published: 1 }, default: :draft, scopes: false
+
+    # Predicate: post is scheduled for future publication
+    def scheduled?
+      published_at.present? && published_at > Time.current
+    end
+
+    # Predicate: post is live (published_at in past or present)
+    def live?
+      published_at.present? && published_at <= Time.current
+    end
+
+    # Returns the status to display in UI (accounts for scheduled state)
+    def display_status
+      return "scheduled" if published? && scheduled?
+      status
+    end
 
     validates :title, presence: true
     validates :slug, presence: true, uniqueness: true
 
     before_validation :generate_slug, if: -> { slug.blank? && title.present? }
     before_save :set_published_at
+    before_save :set_reading_time, if: -> { reading_time.blank? && content.present? }
 
-    scope :ordered, -> { order(created_at: :desc) }
-    scope :recent, -> { ordered.limit(10) }
-    scope :published, -> { where(status: :published).where.not(published_at: nil) }
+    # Generic scopes (ordered, recent) and pagination (page) provided by Entity concern
+    # Post-specific scopes below:
+    scope :published, -> { where(status: :published).where(published_at: ..Time.current) }
     scope :drafts, -> { where(status: :draft) }
+    scope :scheduled, -> { where(status: :published).where("published_at > ?", Time.current) }
+    scope :live, -> { published }  # Alias for semantic clarity
     scope :by_author, ->(author) { where(author_id: author.id) }
+    scope :search, ->(query) { where("title ILIKE ?", "%#{query}%") if query.present? }
+    scope :by_category, ->(category_id) { where(category_id: category_id) if category_id.present? }
+    scope :by_status, ->(status) {
+      case status.to_s
+      when "scheduled" then scheduled
+      when "published" then published
+      when "draft" then drafts
+      else all
+      end
+    }
+    scope :sorted_by, ->(column, direction) {
+      direction = direction.to_s.downcase == "desc" ? :desc : :asc
+      dir_sql = direction == :desc ? "DESC" : "ASC"
+      case column.to_s
+      when "title"
+        order(title: direction)
+      when "category"
+        left_joins(:category).order(Arel.sql("railspress_categories.name #{dir_sql} NULLS LAST"))
+      when "status"
+        order(status: direction)
+      when "reading_time"
+        order(reading_time: direction)
+      when "published_at"
+        order(Arel.sql("published_at #{dir_sql} NULLS LAST"))
+      when "created_at"
+        order(created_at: direction)
+      else
+        order(created_at: :desc)
+      end
+    }
+
+    # Calculate reading time from content word count
+    def calculate_reading_time
+      return 1 unless content.present?
 
-    # Accepts CSV string and syncs tags
-    def tag_list=(csv_string)
-      self.tags = Tag.from_csv(csv_string)
+      words_per_minute = Railspress.words_per_minute
+      word_count = content.to_plain_text.split(/\s+/).count
+      minutes = (word_count.to_f / words_per_minute).ceil
+      [ minutes, 1 ].max
     end
 
-    def tag_list
-      tags.pluck(:name).join(", ")
+    # Display reading time with fallback to calculated value
+    def reading_time_display
+      reading_time.presence || calculate_reading_time
     end
 
     private
@@ -60,11 +143,15 @@ module Railspress
     end
 
     def set_published_at
+      # Only auto-set if publishing and no date was manually provided
       if published? && published_at.nil?
         self.published_at = Time.current
-      elsif draft?
-        self.published_at = nil
       end
+      # Note: We no longer clear published_at for drafts - allow scheduling
+    end
+
+    def set_reading_time
+      self.reading_time = calculate_reading_time
     end
 
     def purge_header_image

data/app/models/railspress/post_export_processor.rb

@@ -0,0 +1,162 @@
+require "zip"
+require "fileutils"
+
+module Railspress
+  class PostExportProcessor
+    attr_reader :export, :errors, :export_dir
+
+    def initialize(export:)
+      @export = export
+      @errors = []
+      @export_dir = nil
+    end
+
+    def process!
+      export.mark_processing!
+
+      setup_export_directory
+      export_all_posts
+      create_zip_file
+
+      if export.error_count > 0 && export.success_count == 0
+        export.mark_failed!
+      else
+        export.mark_completed!
+      end
+    ensure
+      cleanup_export_directory
+    end
+
+    private
+
+    def setup_export_directory
+      @export_dir = Rails.root.join("tmp", "exports", "#{export.id}_#{Time.current.to_i}")
+      FileUtils.mkdir_p(@export_dir)
+      FileUtils.mkdir_p(File.join(@export_dir, "images"))
+    end
+
+    def cleanup_export_directory
+      return unless @export_dir && Dir.exist?(@export_dir)
+      FileUtils.rm_rf(@export_dir)
+    rescue => e
+      Rails.logger.warn "Failed to cleanup export tmp files: #{e.message}"
+    end
+
+    def export_all_posts
+      Post.find_each do |post|
+        export.increment_total!
+        export_post(post)
+      end
+    end
+
+    def export_post(post)
+      filename = generate_filename(post)
+      filepath = File.join(@export_dir, filename)
+
+      frontmatter = build_frontmatter(post)
+      content = extract_content(post)
+
+      markdown = generate_markdown(frontmatter, content)
+      File.write(filepath, markdown)
+
+      export_header_image(post) if post.header_image.attached?
+
+      export.increment_success!
+    rescue => e
+      export.add_error("#{post.title}: #{e.message}")
+    end
+
+    def generate_filename(post)
+      slug = post.slug.presence || post.title.parameterize
+      "#{slug}.md"
+    end
+
+    def build_frontmatter(post)
+      fm = {
+        "title" => post.title,
+        "slug" => post.slug,
+        "status" => post.status
+      }
+
+      fm["published_at"] = post.published_at.to_date.to_s if post.published_at.present?
+      fm["category"] = post.category.name if post.category.present?
+      fm["tags"] = post.tags.pluck(:name).join(", ") if post.tags.any?
+      fm["meta_title"] = post.meta_title if post.meta_title.present?
+      fm["meta_description"] = post.meta_description if post.meta_description.present?
+
+      if Railspress.authors_enabled? && post.respond_to?(:author) && post.author.present?
+        display_method = Railspress.author_display_method
+        fm["author"] = post.author.public_send(display_method)
+      end
+
+      if post.header_image.attached?
+        fm["header_image"] = "images/#{post.slug}.#{header_image_extension(post)}"
+      end
+
+      fm
+    end
+
+    def header_image_extension(post)
+      post.header_image.filename.extension.downcase
+    end
+
+    def extract_content(post)
+      return "" unless post.content.present?
+
+      # ActionText stores HTML, we'll keep it as-is since redcarpet doesn't reverse
+      # Most markdown parsers handle inline HTML fine
+      post.content.body.to_html
+    end
+
+    def generate_markdown(frontmatter, content)
+      yaml = frontmatter.to_yaml
+      "#{yaml}---\n\n#{content}"
+    end
+
+    def export_header_image(post)
+      return unless post.header_image.attached?
+
+      extension = header_image_extension(post)
+      image_filename = "#{post.slug}.#{extension}"
+      image_path = File.join(@export_dir, "images", image_filename)
+
+      File.open(image_path, "wb") do |file|
+        file.write(post.header_image.download)
+      end
+    rescue => e
+      Rails.logger.warn "Failed to export header image for #{post.slug}: #{e.message}"
+    end
+
+    def create_zip_file
+      timestamp = Time.current.strftime("%Y%m%d_%H%M%S")
+      zip_filename = "posts_export_#{timestamp}.zip"
+      zip_path = Rails.root.join("tmp", zip_filename)
+
+      Zip::File.open(zip_path, create: true) do |zipfile|
+        add_directory_to_zip(zipfile, @export_dir, "")
+      end
+
+      # Attach the zip to the export record
+      export.file.attach(
+        io: File.open(zip_path),
+        filename: zip_filename,
+        content_type: "application/zip"
+      )
+
+      export.update!(filename: zip_filename)
+
+      # Clean up the temp zip file
+      FileUtils.rm_f(zip_path)
+    end
+
+    def add_directory_to_zip(zipfile, dir, prefix)
+      Dir.glob(File.join(dir, "**", "*")).each do |file|
+        next if File.directory?(file)
+
+        relative_path = file.sub("#{dir}/", "")
+        entry_name = prefix.present? ? File.join(prefix, relative_path) : relative_path
+        zipfile.add(entry_name, file)
+      end
+    end
+  end
+end