postnhost 0.0.0 → 0.1.0

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/version.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Postnhost
-  VERSION = "0.0.0"
+  VERSION = "0.1.0"
 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,96 @@
+require "json"
+
+# rubocop:disable-next Metrics/BlockLength
+namespace :postnhost do
+  namespace :tailwindcss do
+    def postnhost_tailwind_enabled?
+      Rails.root.join("postnhost.tailwind.config.js").exist? &&
+        Rails.root.join("app/assets/stylesheets/postnhost/host.tailwind.css").exist?
+    end
+
+    def tailwindcss_rails_compile_command(watch: false)
+      return unless Gem.loaded_specs.key?("tailwindcss-rails") || Gem.loaded_specs.key?("tailwindcss-ruby")
+
+      begin
+        require "tailwindcss/ruby"
+      rescue LoadError
+        return
+      end
+
+      executable = Tailwindcss::Ruby.executable
+      return if executable.blank?
+
+      command = [
+        executable,
+        "-i", Rails.root.join("app/assets/stylesheets/postnhost/host.tailwind.css").to_s,
+        "-o", Rails.root.join("app/assets/builds/postnhost/host.css").to_s,
+        "-c", Rails.root.join("postnhost.tailwind.config.js").to_s,
+        "--minify"
+      ]
+      command << "-w" if watch
+      command
+    end
+
+    def package_json_scripts
+      path = Rails.root.join("package.json")
+      return {} unless path.exist?
+
+      JSON.parse(File.read(path)).fetch("scripts", {})
+    rescue JSON::ParserError
+      {}
+    end
+
+    def npm_compile_command(watch: false)
+      script = watch ? "postnhost:tailwindcss:watch" : "postnhost:tailwindcss"
+      return unless package_json_scripts.key?(script)
+
+      ["yarn", script]
+    end
+
+    def postnhost_tailwind_command(watch: false)
+      tailwindcss_rails_compile_command(watch:) || npm_compile_command(watch:)
+    end
+
+    def print_missing_tailwind_runner_message
+      puts <<~MSG
+        [postnhost] No Tailwind runner found for host mode.
+        - Option 1: add the `tailwindcss-rails` gem to your host app.
+        - Option 2: add package.json script `postnhost:tailwindcss:watch` (and `postnhost:tailwindcss` for build).
+      MSG
+    end
+
+    desc "Build host Tailwind CSS for Postnhost overrides"
+    task build: :environment do
+      unless postnhost_tailwind_enabled?
+        puts "[postnhost] Skipping host Tailwind build (missing postnhost.tailwind.config.js or app/assets/stylesheets/postnhost/host.tailwind.css)"
+        next
+      end
+
+      command = postnhost_tailwind_command
+      unless command
+        print_missing_tailwind_runner_message
+        next
+      end
+
+      system(*command, exception: true)
+    end
+
+    desc "Watch host Tailwind CSS for Postnhost overrides"
+    task watch: :environment do
+      unless postnhost_tailwind_enabled?
+        puts "[postnhost] Missing host Tailwind files. Run: rails g postnhost:tailwindcss:install"
+        next
+      end
+
+      command = postnhost_tailwind_command(watch: true)
+      unless command
+        print_missing_tailwind_runner_message
+        next
+      end
+
+      system(*command, exception: true)
+    end
+  end
+end
+
+Rake::Task["assets:precompile"].enhance(["postnhost:tailwindcss:build"]) if Rake::Task.task_defined?("assets:precompile")