develoz-rails 0.1.0

data/lib/generators/develoz/concerns/templates/spec/models/configuration_spec.rb.tt

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Configuration, type: :model do
+  let(:configurable_class) { stub_const("ConfigurationTarget", Struct.new(:id)) }
+
+  describe "validations" do
+    it "requires a key" do
+      configuration = described_class.new(value: {})
+
+      expect(configuration).not_to be_valid
+      expect(configuration.errors[:key]).to include("can't be blank")
+    end
+
+    it "requires the key to be unique within its configurable" do
+      target = configurable_class.new(1)
+      described_class.create!(key: "feature", value: true,
+                              configurable_type: target.class.name, configurable_id: target.id)
+      duplicate = described_class.new(key: "feature", value: false,
+                                      configurable_type: target.class.name, configurable_id: target.id)
+
+      expect(duplicate).not_to be_valid
+      expect(duplicate.errors[:key]).to include("has already been taken")
+    end
+
+    it "allows the same key for a different configurable" do
+      described_class.create!(key: "feature", value: true,
+                              configurable_type: "ConfigurationTarget", configurable_id: 1)
+      configuration = described_class.new(key: "feature", value: false,
+                                          configurable_type: "ConfigurationTarget", configurable_id: 2)
+
+      expect(configuration).to be_valid
+    end
+  end
+
+  describe "scopes" do
+    it "returns active configurations" do
+      active = described_class.create!(key: "active", value: true)
+      described_class.create!(key: "inactive", value: true, active: false)
+
+      expect(described_class.active).to contain_exactly(active)
+    end
+
+    it "separates global and individual configurations" do
+      global = described_class.create!(key: "global", value: true)
+      individual = described_class.create!(key: "individual", value: true,
+                                           configurable_type: "ConfigurationTarget", configurable_id: 1)
+      described_class.create!(key: "partial", value: true, configurable_type: "ConfigurationTarget")
+
+      expect(described_class.globals).to contain_exactly(global)
+      expect(described_class.individuals).to contain_exactly(individual)
+    end
+
+    it "finds configurations for an object" do
+      target = configurable_class.new(7)
+      matching = described_class.create!(key: "matching", value: true,
+                                         configurable_type: target.class.name, configurable_id: target.id)
+      described_class.create!(key: "other", value: true,
+                              configurable_type: target.class.name, configurable_id: 8)
+
+      expect(described_class.for_configurable(target)).to contain_exactly(matching)
+    end
+
+    it "finds configurations for a type and id hash" do
+      matching = described_class.create!(key: "matching", value: true,
+                                         configurable_type: "ConfigurationTarget", configurable_id: 7)
+
+      expect(described_class.for_configurable(type: "ConfigurationTarget", id: 7)).to contain_exactly(matching)
+    end
+
+    it "treats nil as the global configurable" do
+      global = described_class.create!(key: "global", value: true)
+      described_class.create!(key: "individual", value: true,
+                              configurable_type: "ConfigurationTarget", configurable_id: 7)
+
+      expect(described_class.for_configurable(nil)).to contain_exactly(global)
+    end
+
+    it "combines scoped and global configurations" do
+      target = configurable_class.new(7)
+      global = described_class.create!(key: "global", value: true)
+      scoped = described_class.create!(key: "scoped", value: true,
+                                       configurable_type: target.class.name, configurable_id: target.id)
+      described_class.create!(key: "other", value: true,
+                              configurable_type: target.class.name, configurable_id: 8)
+
+      expect(described_class.all_for(target)).to contain_exactly(global, scoped)
+    end
+
+    it "normalizes blank configurable values to nil" do
+      configuration = described_class.create!(key: "global", value: true,
+                                              configurable_type: "", configurable_id: "")
+
+      expect(configuration).to have_attributes(configurable_type: nil, configurable_id: nil)
+    end
+  end
+
+  describe ".global_value" do
+    it "returns top-level and nested global values" do
+      value = { "nested" => { "enabled" => "true" }, "label" => "plain" }
+      described_class.create!(key: "features", value: value)
+
+      expect(described_class.global_value("features")).to eq(value)
+      expect(described_class.global_value("features.nested.enabled")).to eq("true")
+    end
+
+    it "returns nil for a missing key or a path through a scalar" do
+      described_class.create!(key: "features", value: { "label" => "plain" })
+
+      expect(described_class.global_value("missing.path")).to be_nil
+      expect(described_class.global_value("features.label.enabled")).to be_nil
+    end
+  end
+
+  describe ".feature_enabled?" do
+    it "casts the global value to a boolean" do
+      described_class.create!(key: "enabled_feature", value: "true")
+      described_class.create!(key: "disabled_feature", value: "false")
+
+      expect(described_class.feature_enabled?("enabled_feature")).to be(true)
+      expect(described_class.feature_enabled?("disabled_feature")).to be(false)
+    end
+  end
+
+  describe "#json_value" do
+    it "parses assigned JSON" do
+      configuration = described_class.new(key: "json", value: {})
+
+      configuration.json_value = '{"enabled":true}'
+
+      expect(configuration.value).to eq("enabled" => true)
+    end
+
+    it "ignores a blank assignment" do
+      configuration = described_class.new(key: "json", value: { "unchanged" => true })
+
+      configuration.json_value = ""
+
+      expect(configuration.value).to eq("unchanged" => true)
+    end
+
+    it "returns pretty JSON for a value" do
+      configuration = described_class.new(key: "json", value: { "enabled" => true })
+
+      expect(JSON.parse(configuration.json_value)).to eq("enabled" => true)
+    end
+
+    it "returns nil without a value" do
+      expect(described_class.new(key: "json", value: nil).json_value).to be_nil
+    end
+  end
+
+  describe "#yaml_value" do
+    it "parses and validates assigned YAML" do
+      configuration = described_class.new(key: "yaml", value: {})
+
+      configuration.yaml_value = "enabled: true\n"
+
+      expect(configuration).to be_valid
+      expect(configuration.value).to eq("enabled" => true)
+      expect(configuration.yaml_value).to eq("enabled: true\n")
+    end
+
+    it "ignores a blank assignment" do
+      configuration = described_class.new(key: "yaml", value: { "unchanged" => true })
+
+      configuration.yaml_value = ""
+
+      expect(configuration.value).to eq("unchanged" => true)
+    end
+
+    it "reports invalid YAML" do
+      configuration = described_class.new(key: "yaml", value: {})
+
+      configuration.yaml_value = "enabled: ["
+
+      expect(configuration).not_to be_valid
+      expect(configuration.errors[:yaml_value].first).to start_with("is not valid YAML:")
+    end
+
+    it "serializes the stored value when no raw YAML is present" do
+      configuration = described_class.new(key: "yaml", value: { "enabled" => true })
+
+      expect(YAML.safe_load(configuration.yaml_value)).to eq("enabled" => true)
+    end
+
+    it "returns nil without a stored or raw value" do
+      expect(described_class.new(key: "yaml", value: nil).yaml_value).to be_nil
+    end
+  end
+
+  describe "#configurable_display_name" do
+    it "returns nil without a configurable id" do
+      configuration = described_class.new(configurable_type: "User", configurable_id: nil)
+
+      expect(configuration.configurable_display_name).to be_nil
+    end
+
+    it "returns the id for an unsupported configurable type" do
+      configuration = described_class.new(configurable_type: "Other", configurable_id: "7")
+
+      expect(configuration.configurable_display_name).to eq("7")
+    end
+
+    it "returns the configurable display name when the record exists" do
+      display_record = Struct.new(:display_name).new("Ada Lovelace")
+      user_class = stub_const("User", Class.new)
+      user_class.define_singleton_method(:find_by) { |id:| id == "7" ? display_record : nil }
+      configuration = described_class.new(configurable_type: "User", configurable_id: "7")
+
+      expect(configuration.configurable_display_name).to eq("Ada Lovelace")
+    end
+
+    it "falls back to the id when the record does not exist" do
+      user_class = stub_const("User", Class.new)
+      user_class.define_singleton_method(:find_by) { |id:| nil }
+      configuration = described_class.new(configurable_type: "User", configurable_id: "missing")
+
+      expect(configuration.configurable_display_name).to eq("missing")
+    end
+  end
+end

data/lib/generators/develoz/database/database_generator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "develoz"
+
+module Develoz
+  module Generators
+    class DatabaseGenerator < Develoz::Generators::Base
+      def self.source_root
+        File.expand_path("templates", __dir__)
+      end
+
+      def add_database_gems
+        add_gem "pg"
+        add_gem "pg_search"
+      end
+
+      def create_database_config
+        template "config/database.yml.tt", "config/database.yml"
+      end
+
+      def create_pg_search_initializer
+        template "config/initializers/pg_search.rb.tt", "config/initializers/pg_search.rb"
+      end
+
+      def create_pg_extensions_migration
+        return if migration_exists?("create_pg_extensions")
+
+        template "db/migrate/create_pg_extensions.rb.tt",
+                 "db/migrate/#{next_migration_timestamp}_create_pg_extensions.rb"
+      end
+
+      def ensure_postgres_tool_version
+        tool_versions = ".tool-versions"
+        path = File.join(destination_root, tool_versions)
+
+        if File.exist?(path)
+          inject_once(into: tool_versions, content: "postgres 18")
+        else
+          create_file(tool_versions, "postgres 18\n")
+        end
+      end
+    end
+  end
+end

data/lib/generators/develoz/database/templates/config/database.yml.tt

@@ -0,0 +1,53 @@
+# PostgreSQL 18+ configuration.
+# Requires PostgreSQL 18 or newer.
+default: &default
+  adapter: postgresql
+  encoding: unicode
+  pool: <%%= ENV.fetch("DATABASE_POOL", 10) %>
+  host: <%%= ENV.fetch("DATABASE_HOST", "localhost") %>
+  port: <%%= ENV.fetch("DATABASE_PORT", 5432) %>
+  username: <%%= ENV.fetch("DATABASE_USER", "postgres") %>
+  password: <%%= ENV.fetch("DATABASE_PASSWORD", "") %>
+
+development:
+  primary:
+    <<: *default
+    database: <%= app_name %>_development
+  queue:
+    <<: *default
+    database: <%= app_name %>_queue_development
+  cache:
+    <<: *default
+    database: <%= app_name %>_cache_development
+  cable:
+    <<: *default
+    database: <%= app_name %>_cable_development
+
+test:
+  primary:
+    <<: *default
+    database: <%= app_name %>_test<%%= ENV.fetch("TEST_ENV_NUMBER", "") %>
+  queue:
+    <<: *default
+    database: <%= app_name %>_queue_test<%= ENV.fetch("TEST_ENV_NUMBER", "") %>
+  cache:
+    <<: *default
+    database: <%= app_name %>_cache_test<%= ENV.fetch("TEST_ENV_NUMBER", "") %>
+  cable:
+    <<: *default
+    database: <%= app_name %>_cable_test<%= ENV.fetch("TEST_ENV_NUMBER", "") %>
+
+production:
+  primary:
+    <<: *default
+    url: <%%= ENV.fetch("DATABASE_URL", "") %>
+    database: <%= app_name %>_production
+  queue:
+    <<: *default
+    database: <%= app_name %>_queue_production
+  cache:
+    <<: *default
+    database: <%= app_name %>_cache_production
+  cable:
+    <<: *default
+    database: <%= app_name %>_cable_production

data/lib/generators/develoz/database/templates/config/initializers/pg_search.rb.tt

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# PgSearch is included in models via the searchable concern (see T15).
+# This initializer is reserved for future global PgSearch configuration.
+# https://github.com/Casecommons/pg_search

data/lib/generators/develoz/database/templates/db/migrate/create_pg_extensions.rb.tt

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class CreatePgExtensions < ActiveRecord::Migration[8.0]
+  def up
+    execute "CREATE EXTENSION IF NOT EXISTS pg_trgm"
+    execute "CREATE EXTENSION IF NOT EXISTS unaccent"
+  end
+
+  def down
+    execute "DROP EXTENSION IF EXISTS unaccent"
+    execute "DROP EXTENSION IF EXISTS pg_trgm"
+  end
+end

data/lib/generators/develoz/db_backup/db_backup_generator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "develoz"
+
+module Develoz
+  module Generators
+    class DbBackupGenerator < Develoz::Generators::Base
+      def self.source_root
+        File.expand_path("templates", __dir__)
+      end
+
+      class_option :docker, type: :boolean, default: false
+
+      def create_backup_script
+        template "bin_db_backup.tt", "bin/db-backup"
+        chmod "bin/db-backup", 0o755
+      end
+
+      def create_backup_rake
+        template "backup_rake.tt", "lib/tasks/backup.rake"
+      end
+
+      def inject_compose_service
+        return unless options[:docker]
+
+        inject_once(
+          into: "docker-compose.yml",
+          after: /^services:\n/,
+          marker: "# db-backup service (develoz:db_backup)",
+          content: compose_service_content
+        )
+      end
+
+      def ensure_backups_gitignored
+        ensure_gitignore("/backups/")
+      end
+
+      private
+
+      def compose_service_content
+        template_path = File.join(self.class.source_root, "compose_service.tt")
+        raw = File.read(template_path)
+        ERB.new(raw, trim_mode: "-").result(binding)
+      end
+    end
+  end
+end

data/lib/generators/develoz/db_backup/templates/backup_rake.tt

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+namespace :backup do
+  desc "Create a gzipped PostgreSQL backup in ./backups (DATABASE_URL, BACKUP_RETENTION_DAYS)"
+  task create: :environment do
+    require "open3"
+
+    retention_days = ENV.fetch("BACKUP_RETENTION_DAYS", "7").to_i
+    backup_dir = Rails.root.join("backups")
+    FileUtils.mkdir_p(backup_dir)
+
+    timestamp = Time.current.strftime("%Y%m%d_%H%M%S")
+    backup_file = backup_dir.join("db_#{timestamp}.sql.gz")
+
+    puts "Creating backup: #{backup_file}"
+
+    Open3.popen3("pg_dump", ENV.fetch("DATABASE_URL")) do |_, stdout, _, wait|
+      Zlib::GzipWriter.open(backup_file) do |gz|
+        gz.write(stdout.read)
+      end
+      raise "pg_dump failed" unless wait.value.success?
+    end
+
+    puts "Backup created: #{backup_file}"
+
+    prune(backup_dir, retention_days)
+  end
+
+  desc "Prune backups older than BACKUP_RETENTION_DAYS (default: 7)"
+  task prune: :environment do
+    retention_days = ENV.fetch("BACKUP_RETENTION_DAYS", "7").to_i
+    prune(Rails.root.join("backups"), retention_days)
+  end
+
+  def prune(backup_dir, retention_days)
+    cutoff = retention_days.days.ago
+    removed = 0
+
+    Dir.glob(backup_dir.join("db_*.sql.gz")).each do |file|
+      next unless File.mtime(file) < cutoff
+
+      File.delete(file)
+      removed += 1
+    end
+
+    puts "Pruned #{removed} backup(s) older than #{retention_days} days."
+  end
+end

data/lib/generators/develoz/db_backup/templates/bin_db_backup.tt

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# bin/db-backup - PostgreSQL backup with retention
+# Usage: bin/db-backup
+# Env: DATABASE_URL, BACKUP_RETENTION_DAYS (default: 7)
+
+RETENTION_DAYS="${BACKUP_RETENTION_DAYS:-7}"
+BACKUP_DIR="${BACKUP_DIR:-./backups}"
+TIMESTAMP="$(date +%Y%m%d_%H%M%S)"
+BACKUP_FILE="${BACKUP_DIR}/db_${TIMESTAMP}.sql.gz"
+
+mkdir -p "${BACKUP_DIR}"
+
+echo "Creating backup: ${BACKUP_FILE}"
+
+pg_dump "${DATABASE_URL}" | gzip > "${BACKUP_FILE}"
+
+echo "Backup created: ${BACKUP_FILE}"
+
+echo "Pruning backups older than ${RETENTION_DAYS} days..."
+find "${BACKUP_DIR}" -name "db_*.sql.gz" -type f -mtime "+${RETENTION_DAYS}" -delete
+
+echo "Done. Current backups:"
+ls -1 "${BACKUP_DIR}"/db_*.sql.gz 2>/dev/null || echo "  (none)"

data/lib/generators/develoz/db_backup/templates/compose_service.tt

@@ -0,0 +1,14 @@
+  # db-backup service (develoz:db_backup)
+  db-backup:
+    image: postgres:18
+    environment:
+      DATABASE_URL: ${DATABASE_URL:-postgres://postgres:postgres@postgres:5432/<%= app_name %>_development}
+      BACKUP_RETENTION_DAYS: ${BACKUP_RETENTION_DAYS:-7}
+    volumes:
+      - ./backups:/backups
+      - postgres_data:/var/lib/postgresql/data:ro
+    entrypoint: ["/bin/sh", "-c"]
+    command: ["while true; do bin/db-backup; sleep 21600; done"]
+    depends_on:
+      postgres:
+        condition: service_healthy

data/lib/generators/develoz/doc_specs/doc_specs_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "develoz"
+
+module Develoz
+  module Generators
+    class DocSpecsGenerator < Develoz::Generators::Base
+      def self.source_root
+        File.expand_path("templates", __dir__)
+      end
+
+      def create_generate_docs_script
+        template "bin/generate-docs.tt", "bin/generate-docs"
+        dest = File.join(destination_root, "bin/generate-docs")
+        File.chmod(0o755, dest)
+      end
+
+      def create_doc_screenshot_helper
+        template "spec/support/doc_screenshot_helper.rb.tt",
+                 "spec/support/doc_screenshot_helper.rb"
+      end
+
+      def create_docs_check_rake_task
+        template "lib/tasks/docs_check.rake.tt", "lib/tasks/docs_check.rake"
+      end
+
+      def create_example_system_spec
+        template "spec/system/example_doc_spec.rb.tt",
+                 "spec/system/example_doc_spec.rb"
+      end
+    end
+  end
+end