postnhost 0.0.0 → 0.1.1

data/lib/postnhost/settings/i18n_overrides.rb

@@ -0,0 +1,137 @@
+module Postnhost
+  module Settings
+    module I18nOverrides
+      module_function
+
+      CACHE_KEY = "postnhost/settings/i18n_overrides"
+      TRANSLATION_NAMESPACE = "postnhost."
+      TRANSLATION_CONTROL_KEYS = %i[default scope locale raise throw separator fallback format resolve object].freeze
+
+      def locale_keys(overrides, allowed_locales: nil)
+        locales = (all_locales + normalize_overrides(overrides).keys).uniq.sort
+        locales &= allowed_locales.map(&:to_s) unless allowed_locales.nil?
+        return locales unless locales.include?("en")
+
+        ["en"] + locales.reject { |locale| locale == "en" }
+      end
+
+      def editable_translations_for_locale(locale, overrides)
+        return {} if locale.blank?
+
+        locale_key = locale.to_s
+        base_translations = namespaced_translations(base_flat_translations(locale_key))
+        override_translations = namespaced_translations(normalize_overrides(overrides).fetch(locale_key, {}))
+        base_translations.merge(override_translations)
+      end
+
+      def merge_locale_overrides(current_overrides, locale, edited_translations)
+        locale_key = locale.to_s
+        normalized = normalize_overrides(current_overrides)
+        base = base_flat_translations(locale_key)
+
+        compacted = edited_translations.each_with_object({}) do |(key, value), result|
+          key_path = key.to_s
+          next unless key_path.start_with?(TRANSLATION_NAMESPACE)
+
+          text = value.to_s
+          next if text.blank?
+          next if base[key_path] == text
+
+          result[key_path] = text
+        end
+
+        normalized[locale_key] = compacted
+        normalized.delete(locale_key) if compacted.empty?
+        normalized
+      end
+
+      def lookup_override(key, locale: I18n.locale, scope: nil, separator: I18n.default_separator, overrides: nil)
+        keys = I18n.normalize_keys(locale, key, scope, separator)[1..]
+        return nil if keys.blank?
+
+        translation_key = keys.join(".")
+        return nil unless translation_key.start_with?(TRANSLATION_NAMESPACE)
+
+        source_overrides = overrides.nil? ? cached_overrides : normalize_overrides(overrides)
+        source_overrides.dig(locale.to_s, translation_key)
+      end
+
+      def interpolate(value, options)
+        return value unless value.is_a?(String)
+
+        interpolation_options = options.except(*TRANSLATION_CONTROL_KEYS)
+        return value if interpolation_options.blank?
+
+        value % interpolation_options.symbolize_keys
+      rescue KeyError
+        value
+      end
+
+      def cached_overrides
+        Rails.cache.fetch(CACHE_KEY) do
+          normalize_overrides(Postnhost::Setting.current.locale_overrides)
+        end
+      rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
+        {}
+      end
+
+      def clear_cache!
+        Rails.cache.delete(CACHE_KEY)
+      end
+
+      def all_locales
+        @all_locales ||= locale_file_paths.map { |path| File.basename(path, ".yml") }.uniq
+      end
+
+      def base_flat_translations(locale)
+        base_flat_translations_by_locale.fetch(locale.to_s, base_flat_translations_by_locale.fetch(I18n.default_locale.to_s, {}))
+      end
+
+      def base_flat_translations_by_locale
+        @base_flat_translations_by_locale ||= locale_file_paths.each_with_object({}) do |path, result|
+          locale = File.basename(path, ".yml")
+          document = YAML.safe_load_file(path, aliases: true) || {}
+          flattened = flatten_hash(normalize_hash(document[locale] || {}))
+          result[locale] = (result[locale] || {}).merge(flattened)
+        end.freeze
+      end
+
+      def locale_file_paths
+        engine_root = defined?(Postnhost::Engine) ? Postnhost::Engine.root : nil
+        return engine_root.glob("config/locales/*.yml") if engine_root
+
+        Rails.root.glob("config/locales/*.yml")
+      end
+
+      def normalize_overrides(overrides)
+        return {} unless overrides.is_a?(Hash)
+
+        overrides.each_with_object({}) do |(locale, translations), result|
+          next unless translations.is_a?(Hash)
+
+          result[locale.to_s] = normalize_hash(translations)
+        end
+      end
+
+      def normalize_hash(hash)
+        hash.deep_stringify_keys
+      end
+
+      def flatten_hash(hash, prefix = nil, result = {})
+        hash.each do |key, value|
+          path = [prefix, key.to_s].compact.join(".")
+          if value.is_a?(Hash)
+            flatten_hash(value, path, result)
+          else
+            result[path] = value.to_s
+          end
+        end
+        result
+      end
+
+      def namespaced_translations(translations)
+        translations.select { |key, _| key.to_s.start_with?(TRANSLATION_NAMESPACE) }
+      end
+    end
+  end
+end

data/lib/postnhost/settings/i18n_patch.rb

@@ -0,0 +1,18 @@
+module Postnhost
+  module Settings
+    module I18nPatch
+      def translate(locale, key, options = {})
+        separator = options[:separator] || I18n.default_separator
+        override = Postnhost::Settings::I18nOverrides.lookup_override(
+          key,
+          locale: locale,
+          scope: options[:scope],
+          separator: separator
+        )
+        return super if override.nil?
+
+        Postnhost::Settings::I18nOverrides.interpolate(override, options)
+      end
+    end
+  end
+end

data/lib/postnhost/tailwind_compiler.rb

@@ -0,0 +1,75 @@
+require "json"
+require "pathname"
+require "rubygems/version"
+
+module Postnhost
+  class TailwindCompiler
+    REQUIRED_MAJOR = 4
+
+    class MissingCompiler < StandardError; end
+    class IncompatibleVersion < StandardError; end
+
+    def initialize(root:, loaded_specs: Gem.loaded_specs)
+      @root = Pathname.new(root)
+      @loaded_specs = loaded_specs
+    end
+
+    def command(input_path:, output_path:, watch: false)
+      command = npm_command(input_path:, output_path:) || ruby_command(input_path:, output_path:)
+      raise MissingCompiler, missing_compiler_message unless command
+
+      command << "--watch" if watch
+      command
+    end
+
+    private
+
+    attr_reader :root, :loaded_specs
+
+    def ruby_command(input_path:, output_path:)
+      spec = loaded_specs["tailwindcss-ruby"]
+      return unless spec
+
+      validate_version!(spec.version, "tailwindcss-ruby")
+      require "tailwindcss/ruby"
+      executable = Tailwindcss::Ruby.executable
+      return if executable.to_s.empty?
+
+      [executable, "-i", input_path.to_s, "-o", output_path.to_s, "--minify"]
+    end
+
+    def npm_command(input_path:, output_path:)
+      executable = root.join("node_modules/.bin/tailwindcss")
+      return unless executable.file?
+
+      validate_package_version!("tailwindcss")
+      validate_package_version!("@tailwindcss/cli")
+
+      [executable.to_s, "-i", input_path.to_s, "-o", output_path.to_s, "--minify"]
+    end
+
+    def validate_package_version!(package_name)
+      package_path = root.join("node_modules", package_name, "package.json")
+      raise MissingCompiler, "[postnhost] Missing #{package_name}. Install Tailwind CSS 4 and @tailwindcss/cli 4." unless package_path.file?
+
+      version = JSON.parse(package_path.read).fetch("version")
+      validate_version!(version, package_name)
+    rescue JSON::ParserError, KeyError
+      raise MissingCompiler, "[postnhost] Cannot read the installed #{package_name} version."
+    end
+
+    def validate_version!(version, source)
+      return if Gem::Version.new(version.to_s).segments.first == REQUIRED_MAJOR
+
+      raise IncompatibleVersion,
+            "[postnhost] Host CSS requires Tailwind CSS 4; found #{source} #{version}."
+    end
+
+    def missing_compiler_message
+      <<~MESSAGE.strip
+        [postnhost] No Tailwind CSS 4 compiler found for host customization.
+        Add tailwindcss-ruby 4, or install tailwindcss 4 and @tailwindcss/cli 4.
+      MESSAGE
+    end
+  end
+end

data/lib/postnhost/tailwind_input.rb

@@ -0,0 +1,32 @@
+require "pathname"
+
+module Postnhost
+  class TailwindInput
+    SOURCE_PATTERN = /@source\s+"([^"]+)";/
+
+    class << self
+      def build(engine_source:, host_source:)
+        [
+          expand_sources(engine_source),
+          expand_sources(host_source)
+        ].join("\n\n")
+      end
+
+      private
+
+      def expand_sources(path)
+        source_path = Pathname.new(path)
+
+        source_path.read.gsub(SOURCE_PATTERN) do
+          relative_source = Regexp.last_match(1)
+          absolute_source = source_path.dirname.join(relative_source).expand_path
+          %(@source "#{css_path(absolute_source)}";)
+        end
+      end
+
+      def css_path(path)
+        Pathname.new(path).expand_path.to_s.tr("\\", "/").gsub('"', '\\"')
+      end
+    end
+  end
+end

data/lib/postnhost/version.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Postnhost
-  VERSION = "0.0.0"
+  VERSION = "0.1.1"
 end

data/lib/postnhost.rb

@@ -1,8 +1,31 @@
-# frozen_string_literal: true
+require "bcrypt"
+require "carrierwave"
+require "carrierwave-aws"
+require "nokogiri"
+require "openai"
+require "pagy"
+require "paper_trail"
+require "ruby-vips"
 
 require_relative "postnhost/version"
+require_relative "postnhost/configuration"
+require_relative "postnhost/settings/i18n_overrides"
+require_relative "postnhost/sample_data"
+require_relative "postnhost/settings/i18n_patch"
+require_relative "postnhost/engine" if defined?(Rails::Engine)
 
 module Postnhost
-  class Error < StandardError; end
-  # Your code goes here...
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration) if block_given?
+    configuration
+  end
+
+  def self.config
+    configuration || configure
+  end
 end

data/lib/tasks/postnhost_snapshots.rake

@@ -0,0 +1,77 @@
+# rubocop:disable-next Metrics/BlockLength
+namespace :postnhost do
+  namespace :snapshots do
+    desc "Audit snapshots for hard-cutover integrity"
+    task audit: :environment do
+      errors = []
+      check = lambda do |snapshot, label|
+        version = snapshot.paper_trail_version
+        errors << "#{label}: missing paper-trail version" unless version
+        errors << "#{label}: language is missing" unless snapshot.language
+        expected_type = {
+          Postnhost::Snapshot::Article => "Postnhost::Article",
+          Postnhost::Snapshot::Page => "Postnhost::Page",
+          Postnhost::Snapshot::ArticleVariant => "Postnhost::ArticleVariant",
+          Postnhost::Snapshot::PageVariant => "Postnhost::PageVariant"
+        }.fetch(snapshot.class)
+        expected_id = case snapshot
+                      when Postnhost::Snapshot::Article
+                        snapshot.article_id
+                      when Postnhost::Snapshot::Page
+                        snapshot.page_id
+                      when Postnhost::Snapshot::ArticleVariant
+                        snapshot.article_variant_id
+                      when Postnhost::Snapshot::PageVariant
+                        snapshot.page_variant_id
+                      end
+
+        if version
+          errors << "#{label}: version item_type mismatch (#{version.item_type})" unless version.item_type == expected_type
+          errors << "#{label}: version item_id mismatch (#{version.item_id})" unless version.item_id == expected_id
+        end
+      rescue StandardError => e
+        errors << "#{label}: #{e.message}"
+      end
+
+      Postnhost::Snapshot::Article.includes(:article, :language, :paper_trail_version).find_each do |snapshot|
+        check.call(snapshot, "Snapshot::Article #{snapshot.id}")
+        errors << "Snapshot::Article #{snapshot.id}: article missing" unless snapshot.article
+        if snapshot.cover_image_identifier.present?
+          image = Postnhost::PublishedCoverImage.new(article_id: snapshot.article_id, identifier: snapshot.cover_image_identifier)
+          errors << "Snapshot::Article #{snapshot.id}: cover image #{snapshot.cover_image_identifier} is missing" unless image.send(:uploader).file&.exists?
+        end
+      end
+
+      Postnhost::Snapshot::Page.includes(:page, :language, :paper_trail_version).find_each do |snapshot|
+        check.call(snapshot, "Snapshot::Page #{snapshot.id}")
+        errors << "Snapshot::Page #{snapshot.id}: page missing" unless snapshot.page
+      end
+
+      Postnhost::Snapshot::ArticleVariant.includes(:article_variant, :language, :paper_trail_version).find_each do |snapshot|
+        check.call(snapshot, "Snapshot::ArticleVariant #{snapshot.id}")
+        errors << "Snapshot::ArticleVariant #{snapshot.id}: article missing" unless snapshot.article
+        errors << "Snapshot::ArticleVariant #{snapshot.id}: article_variant missing" unless snapshot.article_variant
+      end
+
+      Postnhost::Snapshot::PageVariant.includes(:page_variant, :language, :paper_trail_version).find_each do |snapshot|
+        check.call(snapshot, "Snapshot::PageVariant #{snapshot.id}")
+        errors << "Snapshot::PageVariant #{snapshot.id}: page missing" unless snapshot.page
+        errors << "Snapshot::PageVariant #{snapshot.id}: page_variant missing" unless snapshot.page_variant
+      end
+
+      article_slugs = Postnhost::Snapshot::Article.pluck(:slug)
+      page_slugs = Postnhost::Snapshot::Page.pluck(:slug)
+      (article_slugs & page_slugs).each { |slug| errors << "Published article/page slug collision: #{slug}" }
+
+      default_languages = Postnhost::Language.where(default: true).count
+      errors << "Expected exactly one default language, found #{default_languages}" unless default_languages == 1
+
+      if errors.none?
+        puts "Snapshot audit passed."
+      else
+        warn errors.map { |error| "- #{error}" }.join("\n")
+        abort "Snapshot audit failed with #{errors.count} error(s)."
+      end
+    end
+  end
+end

data/lib/tasks/postnhost_tasks.rake

@@ -0,0 +1,71 @@
+require "fileutils"
+
+require "postnhost/css_build"
+require "postnhost/tailwind_compiler"
+require "postnhost/tailwind_input"
+
+# rubocop:disable-next Metrics/BlockLength
+namespace :postnhost do
+  namespace :tailwindcss do
+    def postnhost_tailwind_enabled?
+      Rails.root.join("app/assets/stylesheets/postnhost/host.tailwind.css").exist?
+    end
+
+    def host_tailwind_paths
+      {
+        input: Rails.root.join("tmp/postnhost/host.tailwind.css"),
+        unscoped: Rails.root.join("app/assets/builds/postnhost/application.unscoped.css"),
+        output: Rails.root.join("app/assets/builds/postnhost/application.css")
+      }
+    end
+
+    def write_host_tailwind_input(path)
+      engine_source = Postnhost::Engine.root.join("app/assets/stylesheets/application.tailwind.css")
+      host_source = Rails.root.join("app/assets/stylesheets/postnhost/host.tailwind.css")
+
+      FileUtils.mkdir_p(path.dirname)
+      path.write(Postnhost::TailwindInput.build(engine_source:, host_source:))
+    end
+
+    def build_host_tailwind(watch: false)
+      paths = host_tailwind_paths
+      write_host_tailwind_input(paths[:input])
+      command = Postnhost::TailwindCompiler.new(root: Rails.root).command(
+        input_path: paths[:input],
+        output_path: paths[:unscoped],
+        watch:
+      )
+
+      Postnhost::CssBuild.run(
+        command:,
+        unscoped_path: paths[:unscoped],
+        output_path: paths[:output],
+        watch:
+      )
+    ensure
+      FileUtils.rm_f(paths&.dig(:input))
+    end
+
+    desc "Build host Tailwind CSS for PostnHost overrides"
+    task build: :environment do
+      unless postnhost_tailwind_enabled?
+        puts "[postnhost] Skipping host Tailwind build (missing app/assets/stylesheets/postnhost/host.tailwind.css)"
+        next
+      end
+
+      build_host_tailwind
+    end
+
+    desc "Watch host Tailwind CSS for PostnHost overrides"
+    task watch: :environment do
+      unless postnhost_tailwind_enabled?
+        puts "[postnhost] Missing host Tailwind files. Run: bin/rails g postnhost:tailwindcss:install"
+        next
+      end
+
+      build_host_tailwind(watch: true)
+    end
+  end
+end
+
+Rake::Task["assets:precompile"].enhance(["postnhost:tailwindcss:build"]) if Rake::Task.task_defined?("assets:precompile")