railspress-engine 0.1.2 → 1.2.0

data/lib/railspress/entity.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Railspress
+  # Stores field configuration for a single entity
+  #
+  # Stores class name as string for Rails reloader compatibility.
+  # Class is resolved lazily via constantize on each access, ensuring
+  # fresh class reference after code reload in development.
+  class EntityConfig
+    attr_writer :label
+
+    def initialize(model_class_name)
+      @model_class_name = model_class_name.to_s
+      @field_definitions = {}
+      @label = nil # Resolved lazily from model_class if not set
+      @types_resolved = false
+    end
+
+    # Lazily resolve class - gets fresh class after Rails reload
+    def model_class
+      @model_class_name.constantize
+    end
+
+    def add_field(name, options = {})
+      # Store the explicit type or mark for lazy detection
+      explicit_type = options[:as]
+      @field_definitions[name.to_sym] = {
+        type: explicit_type,
+        options: options.except(:as),
+        needs_detection: explicit_type.nil?
+      }
+
+      # Auto-wire virtual attributes for array types
+      if explicit_type.in?([ :list, :lines ])
+        define_array_accessors(name, explicit_type)
+      end
+    end
+
+    # Access fields with resolved types (lazy resolution)
+    def fields
+      resolve_field_types! unless @types_resolved
+      @field_definitions
+    end
+
+    def route_key
+      model_class.model_name.plural
+    end
+
+    def param_key
+      model_class.model_name.param_key
+    end
+
+    def singular_label
+      (label || model_class.model_name.human.pluralize).singularize
+    end
+
+    def label
+      @label || model_class.model_name.human.pluralize
+    end
+
+    private
+
+    # Auto-generate virtual attributes for :list and :lines fields
+    # This eliminates the need for a separate ArrayFields concern
+    def define_array_accessors(name, type)
+      separator = type == :list ? ", " : "\n"
+      delimiter = type == :list ? "," : /\r?\n/
+      dedupe = type == :list
+
+      model_class.class_eval do
+        # Nil guard - always return array
+        define_method(name) do
+          super() || []
+        end
+
+        # Virtual getter: array → string
+        define_method("#{name}_list") do
+          send(name).join(separator)
+        end
+
+        # Virtual setter: string → array
+        define_method("#{name}_list=") do |value|
+          parsed = value.to_s.split(delimiter).map(&:strip).reject(&:blank?)
+          parsed = parsed.uniq if dedupe
+          send("#{name}=", parsed)
+        end
+      end
+    end
+
+    def resolve_field_types!
+      @field_definitions.each do |name, field|
+        if field[:needs_detection]
+          field[:type] = detect_type(name)
+          field.delete(:needs_detection)
+        end
+      end
+      @types_resolved = true
+    end
+
+    def detect_type(name)
+      name_str = name.to_s
+
+      # Check for ActionText rich text (has_one :rich_text_#{name} association)
+      if model_class.reflect_on_association(:"rich_text_#{name_str}")
+        return :rich_text
+      end
+
+      # Check for ActiveStorage attachments
+      if model_class.respond_to?(:reflect_on_all_attachments)
+        attachment = model_class.reflect_on_all_attachments.find do |a|
+          a.name.to_s == name_str
+        end
+        if attachment
+          # Check if this attachment has focal point support
+          if attachment.macro == :has_one_attached &&
+             model_class.respond_to?(:focal_point_attachments) &&
+             model_class.focal_point_attachments.include?(name)
+            return :focal_point_image
+          end
+          return attachment.macro == :has_many_attached ? :attachments : :attachment
+        end
+      end
+
+      # Check column type from schema
+      column = model_class.columns_hash[name_str]
+      return :string unless column
+
+      case column.type
+      when :text then :text
+      when :integer then :integer
+      when :boolean then :boolean
+      when :datetime then :datetime
+      when :date then :date
+      when :decimal, :float then :decimal
+      else :string
+      end
+    end
+  end
+
+  # Concern to include in host models for CMS management
+  module Entity
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_railspress_config, instance_writer: false
+      # Store class name (string) for Rails reloader compatibility
+      self._railspress_config = EntityConfig.new(self.name)
+
+      # Default scopes available to all entities
+      scope :ordered, -> { order(created_at: :desc) }
+      scope :recent, -> { ordered.limit(10) }
+    end
+
+    # Default pagination - can be overridden in model
+    PER_PAGE = 20
+
+    class_methods do
+      # Simple pagination for index views
+      def page(page_number)
+        page_number = [ page_number.to_i, 1 ].max
+        offset((page_number - 1) * per_page_count).limit(per_page_count)
+      end
+
+      # Allow models to override PER_PAGE
+      def per_page_count
+        const_defined?(:PER_PAGE, false) ? const_get(:PER_PAGE) : Railspress::Entity::PER_PAGE
+      end
+
+      # Declare which fields should appear in the CMS
+      #
+      # @example Simple field list (types auto-detected from schema)
+      #   railspress_fields :title, :description, :published
+      #
+      # @example With explicit type override
+      #   railspress_fields :body, as: :rich_text
+      #
+      # @example Hash syntax for multiple typed fields
+      #   railspress_fields title: :string, body: :rich_text
+      #
+      def railspress_fields(*names, **options)
+        # Handle positional args: railspress_fields :title, :description
+        if options[:as] && names.length == 1
+          # Single field with type: railspress_fields :body, as: :rich_text
+          _railspress_config.add_field(names.first, as: options[:as])
+        elsif names.any?
+          # Multiple fields, auto-detect types
+          names.each do |name|
+            _railspress_config.add_field(name)
+          end
+        end
+
+        # Handle hash syntax: railspress_fields title: :string, body: :rich_text
+        options.except(:as).each do |name, type|
+          _railspress_config.add_field(name, as: type)
+        end
+      end
+
+      # Set custom label for sidebar/headers
+      #
+      # @example
+      #   railspress_label "Client Projects"
+      #
+      def railspress_label(label)
+        _railspress_config.label = label
+      end
+
+      # Access the entity configuration
+      def railspress_config
+        _railspress_config
+      end
+
+      # Columns to display in the admin index table
+      #
+      # Override hierarchy:
+      # 1. Model overrides this method directly (full control)
+      # 2. Model defines RAILSPRESS_INDEX_COLUMNS constant
+      # 3. Auto-detect from Railspress.default_index_columns
+      #
+      # @example Override with constant
+      #   class Project < ApplicationRecord
+      #     include Railspress::Entity
+      #     RAILSPRESS_INDEX_COLUMNS = [:name, :client, :status, :created_at]
+      #   end
+      #
+      # @example Override with method (for dynamic logic)
+      #   def self.railspress_index_columns
+      #     [:name, :client, admin? ? :budget : nil, :created_at].compact
+      #   end
+      #
+      def railspress_index_columns
+        return self::RAILSPRESS_INDEX_COLUMNS if const_defined?(:RAILSPRESS_INDEX_COLUMNS, false)
+
+        Railspress.default_index_columns.select do |col|
+          new.respond_to?(col)
+        end
+      end
+    end
+  end
+end

data/lib/railspress/version.rb

@@ -1,3 +1,3 @@
 module Railspress
-  VERSION = "0.1.2"
+  VERSION = "1.2.0"
 end

data/lib/railspress.rb

@@ -1,25 +1,41 @@
 require "railspress/version"
 require "railspress/engine"
+require "railspress/entity"
 require "lexxy"
 
 module Railspress
+  class ConfigurationError < StandardError; end
+
   class Configuration
     attr_accessor :author_class_name,
                   :current_author_method,
                   :current_author_proc,
                   :author_scope,
-                  :author_display_method
+                  :author_display_method,
+                  :words_per_minute,
+                  :blog_path,
+                  :default_index_columns,
+                  :post_image_variants,
+                  :inline_editing_check
 
-    attr_reader :authors_enabled, :header_images_enabled
+    attr_reader :authors_enabled, :post_images_enabled, :focal_points_enabled, :cms_enabled, :image_contexts
 
     def initialize
       @authors_enabled = false
-      @header_images_enabled = false
+      @post_images_enabled = false
+      @focal_points_enabled = false
+      @cms_enabled = false
+      @image_contexts = default_image_contexts
+      @post_image_variants = {}
+      @inline_editing_check = nil
       @author_class_name = "User"
       @current_author_method = :current_user
       @current_author_proc = nil
       @author_scope = nil
       @author_display_method = :name
+      @words_per_minute = 200
+      @blog_path = "/blog"
+      @default_index_columns = [ :id, :title, :name, :created_at ]
     end
 
     # Declarative setter: config.enable_authors
@@ -27,9 +43,137 @@ module Railspress
       @authors_enabled = true
     end
 
-    # Declarative setter: config.enable_header_images
-    def enable_header_images
-      @header_images_enabled = true
+    # Declarative setter: config.enable_post_images
+    def enable_post_images
+      @post_images_enabled = true
+    end
+
+    # Declarative setter: config.enable_focal_points
+    def enable_focal_points
+      @focal_points_enabled = true
+    end
+
+    # Declarative setter: config.enable_cms
+    def enable_cms
+      @cms_enabled = true
+    end
+
+    # Validate configuration after the configure block completes.
+    # This keeps the configure block order-independent.
+    def validate!
+      if @inline_editing_check && !@cms_enabled
+        raise Railspress::ConfigurationError,
+          "Inline editing requires CMS. Add `config.enable_cms` to your initializer."
+      end
+    end
+
+    # Set custom image contexts
+    def image_contexts=(contexts)
+      @image_contexts = contexts.transform_keys(&:to_sym)
+    end
+
+    # Add a single image context
+    def add_image_context(name, aspect:, label: nil, sizes: [])
+      @image_contexts[name.to_sym] = {
+        aspect: aspect,
+        label: label || name.to_s.humanize,
+        sizes: sizes
+      }
+    end
+
+    # Remove an image context
+    def remove_image_context(name)
+      @image_contexts.delete(name.to_sym)
+    end
+
+    # Register a host model as a CMS-managed entity
+    #
+    # Accepts class, string, or symbol. String/symbol registration is preferred
+    # for Rails reloader compatibility in development.
+    #
+    # Registration is deferred until first access - this allows registration
+    # in initializers before models are loaded by Zeitwerk.
+    #
+    # @param identifier [Class, String, Symbol] The model to register
+    # @param options [Hash] Optional configuration
+    # @option options [String] :label Custom sidebar/header label
+    #
+    # @example String registration (preferred)
+    #   config.register_entity "Project"
+    #   config.register_entity "Portfolio", label: "Work Samples"
+    #
+    # @example Symbol registration
+    #   config.register_entity :project
+    #   config.register_entity :admin_portfolio, label: "Work Samples"
+    #
+    # @example Class registration (works but may have stale refs after reload)
+    #   config.register_entity Project
+    #
+    def register_entity(identifier, options = {})
+      # Normalize to class name string
+      class_name = case identifier
+      when String then identifier
+      when Symbol then identifier.to_s.camelize
+      when Class  then identifier.name
+      else
+                     raise ArgumentError, "Expected String, Symbol, or Class, got #{identifier.class}"
+      end
+
+      # Compute route_key from class name (e.g., "Project" -> "projects")
+      route_key = class_name.underscore.pluralize
+
+      # Store just the class name and options - resolved fresh on each access
+      entity_registrations[route_key] = { class_name: class_name, options: options }
+    end
+
+    # Entity registrations: route_key => { class_name:, options: }
+    # We store class names (strings), not config objects, so Rails reloading works
+    def entity_registrations
+      @entity_registrations ||= {}
+    end
+
+    # Get all registered entities - resolves fresh on each call
+    def registered_entities
+      result = {}
+      entity_registrations.each do |route_key, registration|
+        config = resolve_entity(registration[:class_name], registration[:options])
+        result[route_key] = config if config
+      end
+      result
+    end
+
+    # Find entity config by route key - resolves fresh on each call
+    def entity_for(route_key)
+      registration = entity_registrations[route_key.to_s]
+      return nil unless registration
+
+      resolve_entity(registration[:class_name], registration[:options])
+    end
+
+    # Check if an entity is registered
+    def entity_registered?(route_key)
+      entity_registrations.key?(route_key.to_s)
+    end
+
+    private
+
+    def default_image_contexts
+      {
+        hero:  { aspect: [ 16, 9 ], label: "Hero", sizes: [ 1920, 1280 ] },
+        card:  { aspect: [ 4, 3 ], label: "Card", sizes: [ 800, 400 ] },
+        thumb: { aspect: [ 1, 1 ], label: "Thumbnail", sizes: [ 200 ] }
+      }
+    end
+
+    def resolve_entity(class_name, options)
+      klass = class_name.constantize
+      unless klass.included_modules.include?(Railspress::Entity)
+        raise ArgumentError, "#{class_name} must include Railspress::Entity"
+      end
+
+      config = klass.railspress_config
+      config.label = options[:label] if options[:label]
+      config
     end
   end
 
@@ -40,6 +184,7 @@ module Railspress
 
     def configure
       yield(configuration)
+      configuration.validate!
     end
 
     def reset_configuration!
@@ -51,8 +196,20 @@ module Railspress
       configuration.authors_enabled
     end
 
-    def header_images_enabled?
-      configuration.header_images_enabled
+    def post_images_enabled?
+      configuration.post_images_enabled
+    end
+
+    def focal_points_enabled?
+      configuration.focal_points_enabled
+    end
+
+    def cms_enabled?
+      configuration.cms_enabled
+    end
+
+    def image_contexts
+      configuration.image_contexts
     end
 
     def author_class
@@ -81,5 +238,38 @@ module Railspress
     def current_author_proc
       configuration.current_author_proc
     end
+
+    def words_per_minute
+      configuration.words_per_minute
+    end
+
+    def blog_path
+      configuration.blog_path
+    end
+
+    def default_index_columns
+      configuration.default_index_columns
+    end
+
+    def post_image_variants
+      configuration.post_image_variants
+    end
+
+    def inline_editing_check
+      configuration.inline_editing_check
+    end
+
+    # Entity registry convenience accessors
+    def registered_entities
+      configuration.registered_entities
+    end
+
+    def entity_for(route_key)
+      configuration.entity_for(route_key)
+    end
+
+    def entity_registered?(route_key)
+      configuration.entity_registered?(route_key)
+    end
   end
 end

data/lib/tasks/railspress_tasks.rake

@@ -1,4 +1,49 @@
-# desc "Explaining what the task does"
-# task :railspress do
-#   # Task goes here
-# end
+namespace :railspress do
+  desc "Migrate post_tags to polymorphic taggings table (one-time migration)"
+  task migrate_tags: :environment do
+    puts "Starting tag migration from post_tags to taggings..."
+
+    # Check if PostTag table exists
+    unless ActiveRecord::Base.connection.table_exists?(:railspress_post_tags)
+      puts "No post_tags table found. Nothing to migrate."
+      next
+    end
+
+    old_count = ActiveRecord::Base.connection.select_value("SELECT COUNT(*) FROM railspress_post_tags").to_i
+
+    if old_count == 0
+      puts "No post_tags to migrate. Done!"
+      next
+    end
+
+    puts "Found #{old_count} post_tags to migrate"
+
+    ActiveRecord::Base.transaction do
+      # Use raw SQL to avoid dependency on PostTag model
+      results = ActiveRecord::Base.connection.select_all(
+        "SELECT post_id, tag_id FROM railspress_post_tags"
+      )
+
+      results.each do |row|
+        Railspress::Tagging.find_or_create_by!(
+          tag_id: row["tag_id"],
+          taggable_type: "Railspress::Post",
+          taggable_id: row["post_id"]
+        )
+      end
+
+      new_count = Railspress::Tagging.where(taggable_type: "Railspress::Post").count
+
+      if new_count != old_count
+        raise "Count mismatch! Expected #{old_count}, got #{new_count}. Rolling back."
+      end
+
+      puts "Successfully migrated #{new_count} taggings"
+    end
+
+    puts "\nMigration complete!"
+    puts "You can now safely drop the post_tags table."
+    puts "Run the drop migration or execute:"
+    puts "  rails generate migration DropRailspressPostTags"
+  end
+end