pressroom 0.1.0

data/config/locales/transliteration.ru.yml

@@ -0,0 +1,70 @@
+ru:
+  i18n:
+    transliterate:
+      rule:
+        а: "a"
+        б: "b"
+        в: "v"
+        г: "g"
+        д: "d"
+        е: "e"
+        ё: "e"
+        ж: "zh"
+        з: "z"
+        и: "i"
+        й: "i"
+        к: "k"
+        л: "l"
+        м: "m"
+        н: "n"
+        о: "o"
+        п: "p"
+        р: "r"
+        с: "s"
+        т: "t"
+        у: "u"
+        ф: "f"
+        х: "h"
+        ц: "ts"
+        ч: "ch"
+        ш: "sh"
+        щ: "sch"
+        ъ: ""
+        ы: "y"
+        ь: ""
+        э: "e"
+        ю: "yu"
+        я: "ya"
+        А: "A"
+        Б: "B"
+        В: "V"
+        Г: "G"
+        Д: "D"
+        Е: "E"
+        Ё: "E"
+        Ж: "Zh"
+        З: "Z"
+        И: "I"
+        Й: "I"
+        К: "K"
+        Л: "L"
+        М: "M"
+        Н: "N"
+        О: "O"
+        П: "P"
+        Р: "R"
+        С: "S"
+        Т: "T"
+        У: "U"
+        Ф: "F"
+        Х: "H"
+        Ц: "Ts"
+        Ч: "Ch"
+        Ш: "Sh"
+        Щ: "Sch"
+        Ъ: ""
+        Ы: "Y"
+        Ь: ""
+        Э: "E"
+        Ю: "Yu"
+        Я: "Ya"

data/config/locales/transliteration.uk.yml

@@ -0,0 +1,70 @@
+uk:
+  i18n:
+    transliterate:
+      rule:
+        а: "a"
+        б: "b"
+        в: "v"
+        г: "h"
+        ґ: "g"
+        д: "d"
+        е: "e"
+        є: "ie"
+        ж: "zh"
+        з: "z"
+        и: "y"
+        і: "i"
+        ї: "i"
+        й: "i"
+        к: "k"
+        л: "l"
+        м: "m"
+        н: "n"
+        о: "o"
+        п: "p"
+        р: "r"
+        с: "s"
+        т: "t"
+        у: "u"
+        ф: "f"
+        х: "kh"
+        ц: "ts"
+        ч: "ch"
+        ш: "sh"
+        щ: "shch"
+        ь: ""
+        ю: "iu"
+        я: "ia"
+        А: "A"
+        Б: "B"
+        В: "V"
+        Г: "H"
+        Ґ: "G"
+        Д: "D"
+        Е: "E"
+        Є: "Ie"
+        Ж: "Zh"
+        З: "Z"
+        И: "Y"
+        І: "I"
+        Ї: "I"
+        Й: "I"
+        К: "K"
+        Л: "L"
+        М: "M"
+        Н: "N"
+        О: "O"
+        П: "P"
+        Р: "R"
+        С: "S"
+        Т: "T"
+        У: "U"
+        Ф: "F"
+        Х: "Kh"
+        Ц: "Ts"
+        Ч: "Ch"
+        Ш: "Sh"
+        Щ: "Shch"
+        Ь: ""
+        Ю: "Iu"
+        Я: "Ia"

data/config/routes.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+Pressroom::Engine.routes.draw do
+  resources :posts, except: :show do
+    member do
+      patch :publish
+      patch :unpublish
+    end
+  end
+
+  resources :categories, except: :show
+  resources :tags, only: %i[index edit update destroy]
+
+  resource :upload, only: :create
+
+  root to: "posts#index"
+end

data/db/migrate/20260821000001_create_pressroom_posts.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class CreatePressroomPosts < ActiveRecord::Migration[7.2]
+  def change
+    create_table :pressroom_posts do |t|
+      t.string :title, null: false
+      t.string :slug, null: false
+
+      # jsonb where it exists, text elsewhere; the model declares
+      # attribute :content, :json so both behave identically in Ruby.
+      if postgres?
+        t.jsonb :content, null: false, default: {}
+      else
+        t.text :content
+      end
+
+      t.text :plain_text
+      t.text :excerpt
+      t.string :status, null: false, default: "draft"
+      t.datetime :published_at
+
+      # No foreign key: the author class is configurable, so the target
+      # table is unknown at migration time.
+      t.bigint :author_id
+      t.bigint :category_id
+
+      t.timestamps
+    end
+
+    add_index :pressroom_posts, :slug, unique: true
+    add_index :pressroom_posts, :status
+    add_index :pressroom_posts, :published_at
+    add_index :pressroom_posts, :author_id
+    add_index :pressroom_posts, :category_id
+  end
+
+  private
+
+  def postgres?
+    connection.adapter_name.match?(/postg/i)
+  end
+end

data/db/migrate/20260821000002_create_pressroom_taxonomy.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class CreatePressroomTaxonomy < ActiveRecord::Migration[7.2]
+  def change
+    create_table :pressroom_categories do |t|
+      t.string :name, null: false
+      t.string :slug, null: false
+      t.bigint :parent_id
+      t.text :description
+      t.timestamps
+    end
+
+    add_index :pressroom_categories, :slug, unique: true
+    add_index :pressroom_categories, :parent_id
+
+    create_table :pressroom_tags do |t|
+      t.string :name, null: false
+      t.string :slug, null: false
+      t.timestamps
+    end
+
+    add_index :pressroom_tags, :slug, unique: true
+
+    create_table :pressroom_taggings do |t|
+      t.bigint :post_id, null: false
+      t.bigint :tag_id, null: false
+      t.timestamps
+    end
+
+    add_index :pressroom_taggings, %i[post_id tag_id], unique: true
+    add_index :pressroom_taggings, :tag_id
+  end
+end

data/lib/pressroom/blocks/definition.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "rails-html-sanitizer"
+
+module Pressroom
+  module Blocks
+    # One registered block type: how it is edited, rendered, and indexed.
+    #
+    # The reader/writer methods double as the registration DSL, so
+    # +b.partial "x"+ sets the value and +definition.partial+ reads it.
+    class Definition
+      FULL_SANITIZER = Rails::HTML4::FullSanitizer.new
+
+      attr_reader :type
+
+      def initialize(type)
+        @type = type.to_s
+        @schema = Schema.build
+        @tool = nil
+        @tool_config = {}
+        @partial = nil
+        @searchable = nil
+      end
+
+      def tool(name = nil, **config)
+        if name
+          @tool = name.to_s
+          @tool_config = config
+        end
+
+        @tool ||= default_tool_name
+      end
+
+      def tool_config
+        tool # ensure the default is materialized
+        @tool_config
+      end
+
+      def schema(&block)
+        @schema = Schema.build(&block) if block
+        @schema
+      end
+
+      def partial(path = nil)
+        @partial = path.to_s if path
+        @partial
+      end
+
+      def searchable(&block)
+        @searchable = block if block
+        @searchable
+      end
+
+      # Plain text for the host application's search index.
+      def text_for(data)
+        return @searchable.call(data).to_s if @searchable
+
+        default_text_for(data)
+      end
+
+      def validate!
+        return if @partial
+
+        raise Pressroom::Error, "block #{type.inspect} must declare a partial"
+      end
+
+      private
+
+      def default_tool_name
+        type.split("_").map { |part| part[0].to_s.upcase + part[1..].to_s }.join
+      end
+
+      def default_text_for(data)
+        parts = @schema.fields.each_value.flat_map do |field|
+          value = data[field.name]
+
+          case field.type
+          when :string, :html then [value]
+          when :array then Array(value)
+          when :tree then flatten_tree(value)
+          else []
+          end
+        end
+
+        parts.filter_map { |part| strip_tags(part) }.reject(&:empty?).join(" ")
+      end
+
+      def flatten_tree(items)
+        Array(items).flat_map do |item|
+          next [] unless item.is_a?(Hash)
+
+          [item["content"]] + flatten_tree(item["items"])
+        end
+      end
+
+      def strip_tags(value)
+        return nil if value.nil?
+
+        FULL_SANITIZER.sanitize(value.to_s).to_s.strip
+      end
+    end
+  end
+end

data/lib/pressroom/blocks/registry.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pressroom
+  module Blocks
+    # Ordered collection of block definitions.
+    #
+    # Registration order matters: it is the order tools appear in the
+    # editor's toolbar.
+    class Registry
+      include Enumerable
+
+      def initialize
+        @definitions = {}
+      end
+
+      def register(type, &block)
+        key = type.to_s
+
+        if @definitions.key?(key)
+          raise Pressroom::Error, "block #{key.inspect} is already registered"
+        end
+
+        definition = Definition.new(key)
+        block&.call(definition)
+        definition.validate!
+
+        @definitions[key] = definition
+      end
+
+      def fetch(type)
+        @definitions[type.to_s]
+      end
+      alias [] fetch
+
+      def key?(type)
+        @definitions.key?(type.to_s)
+      end
+
+      def types
+        @definitions.keys
+      end
+
+      def each(&block)
+        @definitions.each_value(&block)
+      end
+
+      def delete(type)
+        @definitions.delete(type.to_s)
+      end
+
+      def clear!
+        @definitions = {}
+      end
+    end
+  end
+end

data/lib/pressroom/blocks/renderer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/output_safety"
+
+module Pressroom
+  module Blocks
+    # Walks a stored document and renders each block through its partial.
+    #
+    # The +strategy+ is injected rather than read from configuration so this
+    # layer stays independent of the engine. Callers pass
+    # Pressroom.config.resolved_unknown_block_strategy.
+    class Renderer
+      STRATEGIES = %i[raise skip].freeze
+
+      def initialize(registry:, sanitizer:, strategy: :raise, logger: nil)
+        @registry = registry
+        @sanitizer = sanitizer
+        @strategy = strategy
+        @logger = logger
+      end
+
+      def render(document, view_context)
+        blocks_of(document)
+          .filter_map { |block| render_block(block, view_context) }
+          .join
+          .html_safe
+      end
+
+      def blocks_of(document)
+        case document
+        when Array then document.select { |item| item.is_a?(Hash) }
+        when Hash  then Array(document["blocks"] || document[:blocks])
+                          .select { |item| item.is_a?(Hash) }
+        else []
+        end
+      end
+
+      private
+
+      def render_block(block, view_context)
+        type = (block["type"] || block[:type]).to_s
+        definition = @registry.fetch(type)
+        return unknown(type) unless definition
+
+        data = safe_data(definition, block["data"] || block[:data])
+        view_context.render(partial: definition.partial,
+                            locals: { data: data, block: block })
+      rescue Pressroom::UnknownBlockError
+        raise
+      rescue StandardError => e
+        raise e if @strategy == :raise
+
+        log("pressroom: failed to render block #{type.inspect}: #{e.message}")
+        nil
+      end
+
+      def safe_data(definition, raw)
+        data, errors = definition.schema.coerce(raw)
+
+        if errors.any?
+          message = "pressroom: invalid data for block #{definition.type.inspect}: " \
+                    "#{errors.join(', ')}"
+          raise Pressroom::Error, message if @strategy == :raise
+
+          log(message)
+        end
+
+        # The schema owns sanitization dispatch: only it knows whether a
+        # field is a flat string, an array, a nested object or a tree.
+        definition.schema.sanitize(data, @sanitizer)
+      end
+
+      def unknown(type)
+        if @strategy == :raise
+          raise Pressroom::UnknownBlockError,
+                "no block registered for type #{type.inspect}"
+        end
+
+        log("pressroom: skipping unknown block type #{type.inspect}")
+        nil
+      end
+
+      # Accepts a real Rails logger or anything that appends, which keeps
+      # this layer free of a Rails.logger dependency and keeps the unit
+      # tests able to pass a plain Array.
+      def log(message)
+        if @logger.respond_to?(:warn)
+          @logger.warn(message)
+        elsif @logger.respond_to?(:<<)
+          @logger << message
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/pressroom/blocks/sanitizer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "rails-html-sanitizer"
+require "active_support/core_ext/string/output_safety"
+
+module Pressroom
+  module Blocks
+    # Allow-list sanitizer applied to every field the schema marks as +html+.
+    #
+    # This is the single trust boundary between editor output and rendered
+    # pages. Everything else is escaped by ERB.
+    class Sanitizer
+      def self.backend_class
+        if Rails::HTML::Sanitizer.respond_to?(:html5_support?) &&
+           Rails::HTML::Sanitizer.html5_support?
+          Rails::HTML5::SafeListSanitizer
+        else
+          Rails::HTML4::SafeListSanitizer
+        end
+      end
+
+      def initialize(tags:, attributes:)
+        @tags = tags
+        @attributes = attributes
+        @backend = self.class.backend_class.new
+      end
+
+      def sanitize(value)
+        return "".html_safe if value.nil?
+
+        @backend.sanitize(value.to_s, tags: @tags, attributes: @attributes)
+                .to_s.html_safe
+      end
+    end
+  end
+end