postnhost 0.0.0 → 0.1.0

data/app/controllers/postnhost/settings/site_scripts_controller.rb

@@ -0,0 +1,61 @@
+module Postnhost
+  class Settings::SiteScriptsController < ApplicationController
+    before_action :authenticate_user!
+    before_action :load_setting
+    before_action :set_active_section
+    before_action :load_site_script, only: %i[update destroy]
+
+    layout "postnhost/product"
+
+    def create
+      @site_script = @setting.site_scripts.build(site_script_params)
+
+      if @site_script.save
+        redirect_to edit_settings_path(section: "scripts")
+      else
+        @new_site_script = @site_script
+        render_edit_with_errors
+      end
+    end
+
+    def update
+      if @site_script.update(site_script_params)
+        redirect_to edit_settings_path(section: "scripts")
+      else
+        @site_scripts = @site_scripts.map do |site_script|
+          site_script.id == @site_script.id ? @site_script : site_script
+        end
+        render_edit_with_errors
+      end
+    end
+
+    def destroy
+      @site_script.destroy!
+      redirect_to edit_settings_path(section: "scripts")
+    end
+
+    private
+
+    def load_setting
+      @setting = Postnhost::Setting.current
+    end
+
+    def set_active_section
+      @active_section = "scripts"
+      @new_site_script = Postnhost::SiteScript.new(setting: @setting)
+      @site_scripts = @setting.site_scripts.order(:id)
+    end
+
+    def load_site_script
+      @site_script = @setting.site_scripts.find(params[:id])
+    end
+
+    def render_edit_with_errors
+      render "postnhost/settings/edit", status: :unprocessable_content
+    end
+
+    def site_script_params
+      params.require(:site_script).permit(:placement, :script)
+    end
+  end
+end

data/app/controllers/postnhost/settings_controller.rb

@@ -0,0 +1,63 @@
+module Postnhost
+  class SettingsController < ApplicationController
+    include Postnhost::Settings::I18nManageable
+    include Postnhost::Settings::NavigationManageable
+    include Postnhost::Settings::SchemaManageable
+
+    before_action :authenticate_user!
+    before_action :load_setting
+    before_action :set_active_section
+
+    layout "postnhost/product"
+
+    def edit
+      set_i18n_editor_state if @active_section == "i18n"
+      set_navigation_editor_state if @active_section == "navigation"
+      set_schema_editor_state if @active_section == "schema"
+      set_scripts_editor_state if @active_section == "scripts"
+    end
+
+    def update
+      if @active_section == "i18n"
+        update_i18n
+      elsif @active_section == "navigation"
+        update_navigation
+      elsif @active_section == "schema"
+        update_schema
+      elsif @setting.update(setting_params)
+        redirect_to edit_settings_path(section: @active_section), notice: "Settings were successfully updated."
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    private
+
+    def load_setting
+      @setting = Postnhost::Setting.current
+    end
+
+    def setting_params
+      params.require(:setting).permit(
+        :site_url,
+        :site_indexing,
+        :public_page_size,
+        :site_logo,
+        :og_image,
+        :timezone,
+        :author_pages_enabled,
+        :search_enabled,
+        :show_powered_by
+      )
+    end
+
+    def set_scripts_editor_state
+      @site_scripts = @setting.site_scripts.order(:id)
+      @new_site_script = Postnhost::SiteScript.new(setting: @setting)
+    end
+
+    def set_active_section
+      @active_section = params[:section].presence || "site"
+    end
+  end
+end

data/app/controllers/postnhost/sitemap_controller.rb

@@ -0,0 +1,17 @@
+module Postnhost
+  class SitemapController < ApplicationController
+    def show
+      sitemap_builder = Postnhost::SitemapBuilder.new(request:, site_url: current_setting.effective_site_url.presence || request.base_url)
+      sitemap_xml = Rails.cache.fetch(sitemap_builder.cache_key, expires_in: 1.hour) do
+        sitemap_builder.call
+      end
+
+      render xml: sitemap_xml
+    end
+
+    def stylesheet
+      path = Postnhost::Engine.root.join("app/assets/xsl/sitemap.xsl")
+      send_file path, type: "application/xslt+xml", disposition: "inline"
+    end
+  end
+end

data/app/controllers/postnhost/templates_controller.rb

@@ -0,0 +1,26 @@
+module Postnhost
+  class TemplatesController < ApplicationController
+    before_action :authenticate_user!
+    layout "postnhost/product"
+
+    def edit
+      @template = Postnhost::Template.current
+    end
+
+    def update
+      @template = Postnhost::Template.current
+
+      if @template.update(template_params)
+        redirect_to edit_template_path, notice: "Template settings were successfully updated."
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    private
+
+    def template_params
+      params.require(:template).permit(:name)
+    end
+  end
+end

data/app/controllers/postnhost/users_controller.rb

@@ -0,0 +1,112 @@
+module Postnhost
+  class UsersController < ApplicationController
+    include Postnhost::Users::SchemaManageable
+
+    before_action :authenticate_user!
+    before_action :load_user, only: %i[edit update destroy schema_edit schema_update]
+    layout "postnhost/product"
+
+    def index
+      @users = Postnhost::User.order(:name, :email)
+    end
+
+    def new
+      @user = Postnhost::User.new
+    end
+
+    def edit; end
+
+    def schema_edit
+      set_user_schema_editor_state
+    end
+
+    def create
+      @user = Postnhost::User.new(user_params)
+
+      if @user.save
+        redirect_to users_path
+      else
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    def update
+      if @user.update(user_params)
+        redirect_to edit_user_path(@user), notice: "Author was successfully updated."
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    def schema_update
+      @schema_locale_keys = user_schema_locale_keys
+      locale_key = selected_user_schema_locale_key
+      merged_profile = @user.schema_profile_hash.merge(user_schema_profile_params)
+      merged_overrides = merge_user_schema_locale_overrides(
+        @user.schema_locale_overrides_hash,
+        locale_key,
+        user_schema_translation_params
+      )
+
+      if @user.update(schema_profile: merged_profile, schema_locale_overrides: merged_overrides)
+        redirect_to schema_edit_user_path(@user, locale: locale_key), notice: "Author schema was successfully updated."
+      else
+        set_user_schema_editor_state
+        @schema_profile_values = merged_profile
+        @schema_translation_entries = @schema_translation_entries.merge(user_schema_translation_params.stringify_keys)
+        render :schema_edit, status: :unprocessable_content
+      end
+    end
+
+    def destroy
+      if @user == current_user
+        redirect_to users_path, alert: "You cannot remove your own account while signed in."
+        return
+      end
+
+      if @user.pages.exists?
+        redirect_to users_path, alert: "Author cannot be removed while they own pages. Reassign or remove their pages first."
+        return
+      end
+
+      Postnhost::User.transaction do
+        Postnhost::Article.where(user_id: @user.id).update_all(user_id: nil, updated_at: Time.current)
+        @user.article_authors.delete_all
+        @user.destroy!
+      end
+
+      redirect_to users_path, notice: "Author was successfully removed. Their articles were kept."
+    end
+
+    private
+
+    def load_user
+      @user = Postnhost::User.find(params[:id])
+    end
+
+    def user_params
+      attrs = params.require(:user).permit(
+        :email,
+        :name,
+        :slug,
+        :position,
+        :bio,
+        :website_url,
+        :x_url,
+        :linkedin_url,
+        :threads_url,
+        :tiktok_url,
+        :youtube_url,
+        :facebook_url,
+        :instagram_url,
+        :bluesky_url,
+        :mastodon_url,
+        :avatar_file,
+        :password,
+        :password_confirmation
+      )
+      attrs = attrs.except(:password, :password_confirmation) if attrs[:password].blank?
+      attrs
+    end
+  end
+end

data/app/helpers/postnhost/application_helper.rb

@@ -0,0 +1,247 @@
+module Postnhost
+  module ApplicationHelper
+    AUTHOR_SOCIAL_FIELDS = [
+      { field: :website_url, label: "Website", icon: "external-link" },
+      { field: :x_url, label: "X", icon: "x" },
+      { field: :linkedin_url, label: "LinkedIn", icon: "linkedin" },
+      { field: :facebook_url, label: "Facebook", icon: "facebook" },
+      { field: :youtube_url, label: "YouTube", icon: "youtube" },
+      { field: :instagram_url, label: "Instagram", icon: "instagram" },
+      { field: :threads_url, label: "Threads", icon: "threads" },
+      { field: :tiktok_url, label: "TikTok", icon: "tiktok" },
+      { field: :mastodon_url, label: "Mastodon", icon: "mastodon" },
+      { field: :bluesky_url, label: "Bluesky", icon: "bluesky" }
+    ].freeze
+
+    def postnhost_stylesheet_assets
+      assets = ["postnhost/application"]
+      assets << "postnhost/host" if postnhost_host_tailwind_enabled?
+      assets
+    end
+
+    def postnhost_host_tailwind_enabled?
+      Rails.root.join("postnhost.tailwind.config.js").exist? &&
+        Rails.root.join("app/assets/stylesheets/postnhost/host.tailwind.css").exist?
+    end
+
+    def postnhost_openai_api_key_configured?
+      Postnhost.config.openai_api_key.present?
+    end
+
+    def postnhost_public_locale_file_present_for?(html_lang)
+      locale = html_lang.to_s.strip
+      return true if locale.blank?
+
+      Postnhost::Engine.root.join("config/locales/#{locale}.yml").exist? ||
+        Rails.root.join("config/locales/#{locale}.yml").exist?
+    end
+
+    def flash_class(level)
+      case level.to_sym
+      when :notice then "bg-blue-50 border border-blue-200 text-blue-800  rounded-2xl"
+      when :success then "bg-green-50 border border-green-200 text-green-800  rounded-2xl"
+      when :error then "bg-red-50 border border-red-200 text-red-800  rounded-2xl"
+      when :alert then "bg-yellow-50 border border-yellow-200 text-yellow-800  rounded-2xl"
+      when :payment_required then "hidden"
+      else "bg-gray-50 border border-gray-200 text-gray-800  rounded-2xl"
+      end
+    end
+
+    def admin_datetime(value, format: "%B %d, %Y at %l:%M %p %Z")
+      return if value.blank?
+
+      l(value, format:)
+    end
+
+    def admin_datetime_local_value(value)
+      return if value.blank?
+
+      l(value, format: "%Y-%m-%dT%H:%M")
+    end
+
+    # Author helpers rely on the CMS user profile only.
+    def author_name(user = nil)
+      user ||= current_user if respond_to?(:current_user)
+      return unless user.respond_to?(:name)
+
+      user.name.presence
+    end
+
+    def author_avatar(user = nil)
+      user ||= current_user if respond_to?(:current_user)
+      return unless user.respond_to?(:avatar_file) && user.avatar_file?
+
+      user.avatar_file.url
+    end
+
+    def author_initials(user = nil)
+      name = author_name(user)
+      return if name.blank?
+
+      name.split.map(&:first).join.upcase[0, 2]
+    end
+
+    def author_pages_enabled?
+      return @author_pages_enabled if defined?(@author_pages_enabled)
+
+      @author_pages_enabled = current_setting.author_pages_enabled?
+    end
+
+    delegate :search_enabled?, to: :current_setting
+
+    def article_authors(article)
+      article = article_record_for_author_data(article)
+      return [] unless article
+
+      authors = article_author_records(article).map(&:user)
+      authors.select { |author| author_name(author).present? }
+    end
+
+    def article_authors_cache_key(article)
+      article = article_record_for_author_data(article)
+      return [] unless article.respond_to?(:article_authors) || article.respond_to?(:article_snapshot_authors)
+
+      [
+        "author_pages_enabled",
+        author_pages_enabled?,
+        *article_author_records(article).map do |article_author|
+          author = article_author.user
+          [
+            article_author.user_id,
+            article_author.position,
+            article_author.updated_at&.to_i,
+            author&.updated_at&.to_i
+          ]
+        end
+      ]
+    end
+
+    def article_author_label(author)
+      author&.position.presence || t("postnhost.public.blog.author_label")
+    end
+
+    def author_social_links(author)
+      return [] unless author
+
+      AUTHOR_SOCIAL_FIELDS.filter_map do |social|
+        url = normalize_external_url(author.public_send(social[:field]))
+        next unless url
+
+        social.merge(url:)
+      end
+    end
+
+    # Language switcher helpers
+    def current_path_without_locale
+      base_path = request.path_info.to_s
+      base_path = "/" if base_path.blank?
+
+      locale = params[:locale].presence
+      stripped_path = locale.present? ? base_path.sub(%r{\A/#{Regexp.escape(locale)}(?=/|$)}, "") : base_path
+
+      stripped_path.presence || "/"
+    end
+
+    def localized_path(language)
+      base_path = current_path_without_locale
+      base_path = "/" if base_path.empty?
+
+      locale_path = if language.default
+                      base_path
+                    else
+                      base_path == "/" ? "/#{language.html_lang}" : "/#{language.html_lang}#{base_path}"
+                    end
+
+      "#{request.script_name}#{locale_path}"
+    end
+
+    # Language-aware navigation helpers for public pages
+    def language_root_path(language)
+      return root_path unless language
+
+      if language.default
+        root_path
+      else
+        localized_root_path(locale: language.html_lang)
+      end
+    end
+
+    def language_category_path(category_slug, language)
+      return public_category_path(category_slug) unless language
+
+      if language.default
+        public_category_path(category_slug)
+      else
+        localized_public_category_path(language.html_lang, category_slug)
+      end
+    end
+
+    def language_author_path(author_slug, language)
+      return unless author_pages_enabled?
+      return public_author_path(author_slug) unless language
+
+      if language.default
+        public_author_path(author_slug)
+      else
+        localized_public_author_path(language.html_lang, author_slug)
+      end
+    end
+
+    def language_author_url(author_slug, language)
+      return unless author_pages_enabled?
+      return public_author_url(author_slug) unless language
+
+      if language.default
+        public_author_url(author_slug)
+      else
+        localized_public_author_url(language.html_lang, author_slug)
+      end
+    end
+
+    def article_record_for_author_data(record)
+      return unless record
+
+      case record
+      when Postnhost::Snapshot::ArticleVariant
+        record.article_snapshot
+      when Postnhost::ArticleVariant
+        record.article
+      else
+        record
+      end
+    end
+
+    def article_author_records(article)
+      association_name = article.is_a?(Postnhost::Snapshot::Article) ? :article_snapshot_authors : :article_authors
+      return [] unless article.respond_to?(association_name)
+
+      @article_author_records_cache ||= {}
+      cache_key = [article.class.name, article.id || article.object_id]
+      return @article_author_records_cache[cache_key] if @article_author_records_cache.key?(cache_key)
+
+      records = if article.association(association_name).loaded?
+                  article.public_send(association_name).to_a
+                else
+                  article.public_send(association_name).order(:position).to_a
+                end
+
+      ActiveRecord::Associations::Preloader.new(records:, associations: :user).call if records.any?
+
+      @article_author_records_cache[cache_key] = records
+    end
+
+    def normalize_external_url(value)
+      raw_url = value.to_s.strip
+      return if raw_url.blank?
+
+      normalized_url = raw_url.match?(%r{\Ahttps?://}i) ? raw_url : "https://#{raw_url}"
+      uri = URI.parse(normalized_url)
+      return if uri.host.blank?
+      return if uri.userinfo.present?
+
+      normalized_url
+    rescue URI::InvalidURIError
+      nil
+    end
+  end
+end

data/app/helpers/postnhost/article_helper.rb

@@ -0,0 +1,41 @@
+require "rouge"
+
+module Postnhost
+  module ArticleHelper
+    def render_article_content(content)
+      # Add <br> to empty <p> tags to match editor behavior
+      content = content&.gsub("<p></p>", "<p><br></p>")
+      content = content&.gsub(%r{<p>\s*</p>}, "<p><br></p>")
+
+      sanitized_content = sanitize(
+        content,
+        tags: %w[p h1 h2 h3 h4 h5 h6 strong em u s sup sub mark code pre span blockquote ul ol li a img table colgroup col thead tbody tr th td br
+                 hr div iframe],
+        attributes: %w[href src alt class style target rel width height colspan rowspan frameborder allow allowfullscreen title]
+      )
+
+      highlight_code_blocks(sanitized_content)
+    end
+
+    def article_excerpt(article)
+      article.custom_excerpt.presence || article.auto_excerpt.presence
+    end
+
+    private
+
+    def highlight_code_blocks(content)
+      fragment = Nokogiri::HTML5.fragment(content)
+      formatter = Rouge::Formatters::HTML.new
+
+      fragment.css("pre > code[class]").each do |code_block|
+        language = code_block["class"].to_s.split.filter_map { |class_name| class_name.delete_prefix("language-") if class_name.start_with?("language-") }.first
+        lexer = Rouge::Lexer.find(language)&.new
+        next unless lexer
+
+        code_block.inner_html = formatter.format(lexer.lex(code_block.text))
+      end
+
+      fragment.to_html.html_safe
+    end
+  end
+end

data/app/helpers/postnhost/category_helper.rb

@@ -0,0 +1,52 @@
+module Postnhost
+  module CategoryHelper
+    def category_articles
+      @article_snapshots || @article_variant_snapshots || []
+    end
+
+    def top_pick_articles
+      @top_pick_article_snapshots || @top_pick_article_variant_snapshots || []
+    end
+
+    def localized_category_name(category, language)
+      return category.name if language.nil? || language.default?
+
+      category_variant_for_language(category, language)&.name || category.name
+    end
+
+    def localized_category_meta_description(category, language)
+      return category.meta_description if language.nil? || language.default?
+
+      category_variant_for_language(category, language)&.meta_description || category.meta_description
+    end
+
+    def category_article(item)
+      item.is_a?(Postnhost::Snapshot::ArticleVariant) ? item.article_snapshot : item
+    end
+
+    def category_article_author_user(item)
+      @category_article_author_cache ||= {}
+      cache_key = [item.class.name, item.id || item.object_id]
+      return @category_article_author_cache[cache_key] if @category_article_author_cache.key?(cache_key)
+
+      @category_article_author_cache[cache_key] = article_authors(category_article(item)).first
+    end
+
+    def category_article_url(item)
+      snapshot = category_article(item)
+      return public_article_path(snapshot.slug) if item.is_a?(Postnhost::Snapshot::Article)
+
+      localized_public_article_path(@current_language.html_lang, snapshot.slug)
+    end
+
+    private
+
+    def category_variant_for_language(category, language)
+      if category.association(:category_variants).loaded?
+        category.category_variants.find { |v| v.language_id == language.id }
+      else
+        category.category_variants.find_by(language: language)
+      end
+    end
+  end
+end