iron-cms 0.11.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4875e891f39ab409c8460006c443ceae03bef9cb9cbd48ea8a0b5603d090405
-  data.tar.gz: 4a45587b457c4aff648bc7d61d714485ac26682533cdb1c9016d00b27a1c6fab
+  metadata.gz: 6f8165107a118a6f3a8dcefe95984760653d8baf16f96653642382fc73ce8aca
+  data.tar.gz: 7143fd0c4f78a53e4b945f52005cc1f68e225674667f0f6a8bce8dcb8b77a02d
 SHA512:
-  metadata.gz: 9ddcc960d6c7572dcd8d459c883d522d1f25b5f33ef23f75cc7cd1a444e1192864078d2c573bf2f868858582a5316715008314dbe8be3f2acaf68d18f5a8ba6f
-  data.tar.gz: 299f14dad319f969252baef1b8cc09047b8c6e2a832cde32302c028b6f1dcb51ff562d49c760a3c071d77d654f5718772ef97e6c434c83beef6bd7bbffb0f725
+  metadata.gz: e09696ccbfb17bf2a82d515e7297f097a4a6fbdeb8a30626bf1cb1e44818ae9f55f260fa6b7e04acce6707d1d212305318cddf6db545f62d04b37d919191c73f
+  data.tar.gz: be54e07e53ca096cb56e66887eab33085f76545716a61dfa7976866303f224867d9766eceaa338a65ecd3182d5b2b7af2003226d98c52d64dd17a68b912cc7e3

data/README.md

@@ -96,37 +96,36 @@ For cases where you need a basic responsive image without format optimization:
 
 This generates a standard `<img>` with srcset but without modern format variants.
 
-### Testing
+### Development Seeding
 
-Iron provides test fixtures to populate your test database with CMS schema and content, eliminating the need to stub the SDK in your tests.
+Iron provides a seeding mechanism to snapshot and restore CMS schema and content, making it easy for teammates to get a consistent development database.
 
-#### Generating Fixtures
+#### Creating a seed
 
-Generate test fixtures from your development database (or production if you prefer):
+After setting up your content types and sample content via the admin UI:
 
 ```bash
-bin/rails iron:fixtures:generate
+bin/rails iron:seed:dump
 ```
 
-This creates two files in `test/fixtures/iron/`:
+This exports the full CMS state to `db/seeds/iron.zip`. Commit this file to your repository.
 
-- `schema.tar.gz` - Content types, field definitions, and block definitions
-- `content.tar.gz` - All entries and their field data
+#### Loading a seed
 
-Regenerate these fixtures whenever you make changes to your CMS schema or content that you want reflected in tests.
-
-#### Using Fixtures in Tests
-
-Load the fixtures in your `test/test_helper.rb`:
+Add this to your `db/seeds.rb`:
 
 ```ruby
-class ActiveSupport::TestCase
-  fixtures :all
-  Iron::TestFixtures.load
-end
+Iron::Seed.load
 ```
 
-The fixtures are loaded once at the start of your test suite. Rails' transactional tests provide test isolation by rolling back changes after each test.
+Then `rails db:prepare` (or `rails db:seed`) will automatically bootstrap the CMS when the database is empty. Loading is skipped if content types already exist.
+
+#### Admin credentials
+
+The seed creates a default admin user during loading. Configure via environment variables:
+
+- `IRON_SEED_EMAIL` (default: `admin@example.com`)
+- `IRON_SEED_PASSWORD` (default: `password`)
 
 ## System Requirements
 
@@ -178,8 +177,8 @@ bin/rails iron:install:migrations
 Configure the mailer sender address used for system emails (e.g. password resets):
 
 ```ruby
-# config/initializers/iron.rb
-Iron.mailer_sender = "hello@mysite.com"
+# config/environments/production.rb
+config.action_mailer.default_options = { from: "hello@mysite.com" }
 ```
 
 ## Architecture

data/app/assets/builds/iron.css

@@ -3429,6 +3429,9 @@
   .opacity-0 {
     opacity: 0%;
   }
+  .opacity-50 {
+    opacity: 50%;
+  }
   .shadow {
     --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);

data/app/controllers/concerns/iron/admin_locale.rb

@@ -8,7 +8,22 @@ module Iron
 
     private
       def set_admin_locale(&action)
-        I18n.with_locale(Current.user&.language || :en, &action)
+        I18n.with_locale(preferred_admin_language, &action)
+      end
+
+      def preferred_admin_language
+        Current.user&.language || browser_admin_language || "en"
+      end
+
+      def browser_admin_language
+        browser_language_tags.find { |tag| User::ADMIN_LANGUAGES.include?(tag) }
+      end
+
+      def browser_language_tags
+        request.accept_language.to_s.split(",").flat_map { |entry|
+          tag = entry.split(";").first.strip.downcase
+          [ tag, tag.split("-").first ]
+        }.reject(&:blank?).uniq
       end
   end
 end

data/app/controllers/concerns/iron/authentication.rb

@@ -33,7 +33,8 @@ module Iron
 
 
       def resume_session
-        Current.session ||= find_session_by_cookie
+        session = find_session_by_cookie
+        Current.session ||= session if session&.user&.active?
       end
 
       def find_session_by_cookie

data/app/controllers/iron/passwords_controller.rb

@@ -9,7 +9,7 @@ module Iron
     end
 
     def create
-      if user = User.find_by(email_address: params[:email_address])
+      if user = User.active.find_by(email_address: params[:email_address])
         Iron::PasswordsMailer.reset(user).deliver_later
       end
 
@@ -36,6 +36,7 @@ module Iron
 
       def set_user_by_token
         @user = User.find_by_password_reset_token!(params[:token])
+        redirect_to new_password_url, alert: t("iron.passwords.alerts.reset_link_invalid") unless @user.active?
       rescue ActiveSupport::MessageVerifier::InvalidSignature
         redirect_to new_password_url, alert: t("iron.passwords.alerts.reset_link_invalid")
       end

data/app/controllers/iron/sessions/transfers_controller.rb

@@ -9,7 +9,7 @@ module Iron
       end
 
       def update
-        if user = User.find_by_transfer_id(params[:id])
+        if (user = User.find_by_transfer_id(params[:id])) && user.active?
           start_new_session_for user
           redirect_to after_authentication_url
         else

data/app/controllers/iron/sessions_controller.rb

@@ -10,7 +10,7 @@ module Iron
     end
 
     def create
-      if user = User.authenticate_by(params.permit(:email_address, :password))
+      if user = User.active.authenticate_by(params.permit(:email_address, :password))
         start_new_session_for user
         redirect_to after_authentication_url
       else

data/app/controllers/iron/users/reactivations_controller.rb

@@ -0,0 +1,18 @@
+module Iron
+  module Users
+    class ReactivationsController < ApplicationController
+      before_action :set_user
+      before_action :ensure_can_administer
+
+      def update
+        @user.reactivate
+        redirect_to @user, notice: t("iron.users.notifications.reactivated")
+      end
+
+      private
+        def set_user
+          @user = User.find(params.expect(:user_id))
+        end
+    end
+  end
+end

data/app/controllers/iron/users/roles_controller.rb

@@ -14,7 +14,7 @@ module Iron
 
       private
         def set_user
-          @user = User.find(params.expect(:user_id))
+          @user = User.active.find(params.expect(:user_id))
         end
     end
   end

data/app/controllers/iron/users_controller.rb

@@ -8,7 +8,8 @@ module Iron
     before_action :ensure_can_administer, only: %i[ index destroy ]
 
     def index
-      @users = User.all
+      @users = User.active
+      @deactivated_users = User.where(active: false)
     end
 
     def new
@@ -19,7 +20,7 @@ module Iron
     end
 
     def create
-      @user = User.new(join_params)
+      @user = User.new(join_params.merge(language: preferred_admin_language))
       if @user.save
         start_new_session_for @user
         redirect_to root_url
@@ -31,8 +32,8 @@ module Iron
     end
 
     def destroy
-      if @user.destroy
-        redirect_back fallback_location: users_path, notice: t("iron.users.notifications.removed"), status: :see_other
+      if @user.deactivate
+        redirect_to users_path, notice: t("iron.users.notifications.removed"), status: :see_other
       else
         redirect_back fallback_location: users_path, alert: @user.errors.full_messages.to_sentence, status: :see_other
       end
@@ -40,7 +41,7 @@ module Iron
 
     private
       def set_user
-        @user = User.find(params.expect(:id))
+        @user = User.active.find(params.expect(:id))
       end
 
       def join_params

data/app/mailers/iron/application_mailer.rb

@@ -1,6 +1,5 @@
 module Iron
   class ApplicationMailer < ActionMailer::Base
-    default from: -> { Iron.mailer_sender }
     layout "mailer"
   end
 end

data/app/models/iron/account/export.rb

@@ -17,70 +17,12 @@ module Iron
       def perform
         raise ArgumentError, "Nothing selected to export" unless include_schema? || include_content?
 
-        zipfile = generate_zip
-        file.attach(
-          io: File.open(zipfile.path),
-          filename: "iron-export-#{id}.zip",
-          content_type: "application/zip"
-        )
+        zipfile = Tempfile.new([ "export", ".zip" ])
+        Exporter.new(zipfile.path, include_schema: include_schema?, include_content: include_content?).export
+        file.attach(io: File.open(zipfile.path), filename: "iron-export-#{id}.zip", content_type: "application/zip")
       ensure
         zipfile&.close
         zipfile&.unlink
       end
-
-      def generate_zip
-        Tempfile.new([ "export", ".zip" ]).tap do |tempfile|
-          Zip::File.open(tempfile.path, create: true) do |zip|
-            add_schema_to_zip(zip) if include_schema?
-            add_content_to_zip(zip) if include_content?
-          end
-        end
-      end
-
-      def add_schema_to_zip(zip)
-        zip.get_output_stream("schema.json") { |f| f.write(export_schema_json) }
-      end
-
-      def add_content_to_zip(zip)
-        exportable_entries.find_each do |entry|
-          path = "entries/#{entry.content_type.handle}/#{entry.id}.json"
-          zip.get_output_stream(path) { |f| f.write(entry.export_json) }
-
-          entry.export_attachments.each do |attachment|
-            zip.get_output_stream("files/#{attachment[:path]}", compression_method: Zip::Entry::STORED) do |f|
-              attachment[:blob].download { |chunk| f.write(chunk) }
-            end
-          rescue ActiveStorage::FileNotFoundError
-            # Skip missing files
-          end
-        end
-      end
-
-      def export_schema_json
-        JSON.pretty_generate(
-          version: "1.0",
-          exported_at: Time.current.iso8601,
-          block_definitions: export_block_definitions,
-          content_types: export_content_types
-        )
-      end
-
-      def export_block_definitions
-        BlockDefinition
-          .includes(:field_definitions)
-          .order(:handle)
-          .map(&:export_attributes)
-      end
-
-      def export_content_types
-        ContentType
-          .includes(:title_field_definition, :web_page_title_field_definition, :field_definitions)
-          .order(:handle)
-          .map(&:export_attributes)
-      end
-
-      def exportable_entries
-        Entry.includes(:content_type, :creator, fields: [ :locale, :definition ])
-      end
   end
 end

data/app/models/iron/account/import.rb

@@ -18,190 +18,12 @@ module Iron
       def perform
         raise ArgumentError, "Nothing selected to import" unless include_schema? || include_content?
 
-        import_from_zip
-      end
-
-      def import_from_zip
         Tempfile.create([ "import", ".zip" ]) do |tempfile|
           tempfile.binmode
           tempfile.write(file.download)
           tempfile.rewind
 
-          Zip::File.open(tempfile.path) do |zip|
-            @zip = zip
-            @files_dir = extract_files_to_temp_dir(zip)
-
-            import_schema_from_zip if include_schema?
-            import_content_from_zip if include_content?
-          ensure
-            FileUtils.rm_rf(@files_dir) if @files_dir
-          end
-        end
-      end
-
-      def extract_files_to_temp_dir(zip)
-        dir = Dir.mktmpdir("iron-import")
-        zip.glob("files/**/*").each do |entry|
-          next if entry.directory?
-
-          path = File.join(dir, entry.name.sub("files/", ""))
-          FileUtils.mkdir_p(File.dirname(path))
-          entry.extract(path)
-        end
-        dir
-      end
-
-      def import_schema_from_zip
-        return unless @zip.find_entry("schema.json")
-
-        schema_json = @zip.read("schema.json")
-        schema = parse_json(schema_json)
-        raise ArgumentError, "Invalid schema JSON format" unless schema
-
-        ActiveRecord::Base.transaction do
-          import_block_definitions(schema[:block_definitions] || [])
-          import_content_types(schema[:content_types] || [])
-          resolve_content_type_references(schema[:content_types] || [])
-        end
-      end
-
-      def import_content_from_zip
-        ActiveRecord::Base.transaction do
-          id_mapping = {}
-          entries_data = []
-
-          # First pass: read all entry files and create entries
-          @zip.glob("entries/**/*.json").each do |zip_entry|
-            attrs = parse_json(zip_entry.get_input_stream.read)
-            next unless attrs
-
-            entries_data << attrs
-            entry = Entry.import_from_attributes(attrs, @files_dir)
-            id_mapping[attrs[:id]] = entry if entry
-          end
-
-          # Second pass: resolve references
-          resolve_references(entries_data, id_mapping)
-        end
-      end
-
-      def resolve_references(entries_data, id_mapping)
-        entries_data.each do |attrs|
-          entry = id_mapping[attrs[:id]]
-          next unless entry
-
-          (attrs[:fields] || {}).each do |locale_code, field_data|
-            locale = Locale.find_by(code: locale_code.to_s)
-            next unless locale
-
-            resolve_references_in_fields(entry, locale, field_data, id_mapping)
-          end
-        end
-      end
-
-      def resolve_references_in_fields(entry, locale, fields_data, id_mapping, parent: nil)
-        fields_data.each do |handle, value_data|
-          next unless value_data.is_a?(Hash)
-
-          case value_data[:type]
-          when "reference"
-            resolve_reference_field(entry, locale, handle.to_s, value_data[:value], id_mapping, parent: parent)
-          when "reference_list"
-            resolve_reference_list_field(entry, locale, handle.to_s, value_data[:value], id_mapping, parent: parent)
-          when "block"
-            resolve_references_in_block(entry, locale, handle.to_s, value_data, id_mapping, parent: parent)
-          when "block_list"
-            resolve_references_in_block_list(entry, locale, handle.to_s, value_data, id_mapping, parent: parent)
-          end
-        end
-      end
-
-      def resolve_references_in_block(entry, locale, handle, value_data, id_mapping, parent: nil)
-        block_field = find_field(entry, locale, handle, parent)
-        return unless block_field
-
-        resolve_references_in_fields(entry, locale, value_data[:fields] || {}, id_mapping, parent: block_field)
-      end
-
-      def resolve_references_in_block_list(entry, locale, handle, value_data, id_mapping, parent: nil)
-        block_list_field = find_field(entry, locale, handle, parent)
-        return unless block_list_field
-
-        # Reload blocks and get them in rank order (matching import order)
-        ordered_blocks = block_list_field.blocks.reload.sort_by(&:rank)
-
-        (value_data[:value] || []).each_with_index do |block_data, index|
-          block = ordered_blocks[index]
-          next unless block
-
-          resolve_references_in_fields(entry, locale, block_data[:fields] || {}, id_mapping, parent: block)
-        end
-      end
-
-      def find_field(entry, locale, handle, parent)
-        # Reload associations to get freshly persisted fields from the first pass
-        fields = parent&.fields&.reload || entry.fields.reload
-        definition_scope = parent.is_a?(Fields::Block) ? parent.block_definition.field_definitions : entry.content_type.field_definitions
-        definition = definition_scope.find_by(handle: handle)
-        return unless definition
-
-        fields.find { |f| f.definition_id == definition.id && f.locale_id == locale.id }
-      end
-
-      def resolve_reference_field(entry, locale, handle, old_entry_id, id_mapping, parent: nil)
-        return unless old_entry_id
-
-        referenced_entry = id_mapping[old_entry_id]
-        return unless referenced_entry
-
-        field = find_field(entry, locale, handle, parent)
-        return unless field
-
-        field.update!(referenced_entry: referenced_entry)
-      end
-
-      def resolve_reference_list_field(entry, locale, handle, old_entry_ids, id_mapping, parent: nil)
-        return unless old_entry_ids.is_a?(Array)
-
-        field = find_field(entry, locale, handle, parent)
-        return unless field
-
-        old_entry_ids.each_with_index do |old_id, index|
-          referenced_entry = id_mapping[old_id]
-          next unless referenced_entry
-
-          field.references.create!(entry: referenced_entry, rank: index)
-        end
-      end
-
-      def parse_json(content)
-        JSON.parse(content, symbolize_names: true)
-      rescue JSON::ParserError
-        nil
-      end
-
-      def import_block_definitions(definitions)
-        definitions.each { |attrs| BlockDefinition.import_from_attributes(attrs) }
-      end
-
-      def import_content_types(definitions)
-        definitions.each { |attrs| ContentType.import_from_attributes(attrs) }
-      end
-
-      def resolve_content_type_references(definitions)
-        definitions.each do |attrs|
-          content_type = ContentType.find_by(handle: attrs[:handle])
-          next unless content_type
-
-          if attrs[:title_field_handle].present?
-            field = content_type.field_definitions.find_by(handle: attrs[:title_field_handle])
-            content_type.update!(title_field_definition: field) if field
-          end
-
-          if attrs[:web_page_title_field_handle].present?
-            field = content_type.field_definitions.find_by(handle: attrs[:web_page_title_field_handle])
-            content_type.update!(web_page_title_field_definition: field) if field
-          end
+          Importer.new(tempfile.path, include_schema: include_schema?, include_content: include_content?).import
         end
       end
   end

data/app/models/iron/block_definition/importable.rb

@@ -4,21 +4,15 @@ module Iron
 
     class_methods do
       def import_from_attributes(attrs)
-        block_def = find_or_initialize_by(handle: attrs[:handle])
-        block_def.update!(
-          name: attrs[:name],
-          description: attrs[:description]
-        )
-
-        import_field_definitions(block_def, attrs[:field_definitions] || [])
-
-        block_def
+        find_or_initialize_by(handle: attrs[:handle]).tap do |block_def|
+          block_def.update!(name: attrs[:name], description: attrs[:description])
+        end
       end
 
-      private
+      def populate_field_definitions(attrs)
+        block_def = find_by!(handle: attrs[:handle])
 
-      def import_field_definitions(block_def, field_attrs_list)
-        field_attrs_list.each do |field_attrs|
+        (attrs[:field_definitions] || []).each do |field_attrs|
           FieldDefinition.import_from_attributes(field_attrs, schemable: block_def)
         end
       end

data/app/models/iron/exporter.rb

@@ -0,0 +1,75 @@
+module Iron
+  class Exporter
+    def initialize(path, include_schema: true, include_content: true)
+      @path = path.to_s
+      @include_schema = include_schema
+      @include_content = include_content
+    end
+
+    def export
+      Zip::File.open(path, create: true) do |zip|
+        write_schema(zip) if schema?
+        write_entries(zip) if content?
+      end
+    end
+
+    private
+
+      attr_reader :path
+
+      def schema?  = @include_schema
+      def content? = @include_content
+
+      def write_schema(zip)
+        zip.get_output_stream("schema.json") { |f| f.write(schema_json) }
+      end
+
+      def write_entries(zip)
+        exportable_entries.find_each do |entry|
+          path = "entries/#{entry.content_type.handle}/#{entry.id}.json"
+          zip.get_output_stream(path) { |f| f.write(entry.export_json) }
+
+          entry.export_attachments.each do |attachment|
+            zip.get_output_stream("files/#{attachment[:path]}", compression_method: Zip::Entry::STORED) do |f|
+              attachment[:blob].download { |chunk| f.write(chunk) }
+            end
+          rescue ActiveStorage::FileNotFoundError
+            # Skip missing files
+          end
+        end
+      end
+
+      def schema_json
+        JSON.pretty_generate(
+          version: "1.0",
+          exported_at: Time.current.iso8601,
+          default_locale: Current.account&.default_locale&.code,
+          locales: export_locales,
+          block_definitions: export_block_definitions,
+          content_types: export_content_types
+        )
+      end
+
+      def export_locales
+        Locale.order(:code).map { |l| { code: l.code, name: l.name } }
+      end
+
+      def export_block_definitions
+        BlockDefinition
+          .includes(:field_definitions)
+          .order(:handle)
+          .map(&:export_attributes)
+      end
+
+      def export_content_types
+        ContentType
+          .includes(:title_field_definition, :web_page_title_field_definition, :field_definitions)
+          .order(:handle)
+          .map(&:export_attributes)
+      end
+
+      def exportable_entries
+        Entry.includes(:content_type, :creator, fields: [ :locale, :definition ])
+      end
+  end
+end