iron-cms 0.5.2 → 0.7.0

data/app/models/iron/schema_importer/import_strategy.rb

@@ -1,59 +0,0 @@
-module Iron
-  class SchemaImporter::ImportStrategy
-    def import_block_definition(row)
-      raise NotImplementedError
-    end
-
-    def import_content_type(row)
-      raise NotImplementedError
-    end
-
-    def import_field_definition(row)
-      raise NotImplementedError
-    end
-
-    protected
-
-      def find_parent(parent_type, parent_handle)
-        case parent_type
-        when "content_type"
-          ContentType.find_by(handle: parent_handle)
-        when "block"
-          BlockDefinition.find_by(handle: parent_handle)
-        end
-      end
-
-      def content_type_class(type)
-        case type
-        when "single" then ContentTypes::Single
-        when "collection" then ContentTypes::Collection
-        else
-          raise "Invalid content type: #{type}. Must be 'single' or 'collection'"
-        end
-      end
-
-      def field_definition_class(type)
-        "Iron::FieldDefinitions::#{type.camelize}".constantize
-      end
-
-      def parse_metadata(metadata_string)
-        return {} if metadata_string.blank?
-
-        JSON.parse(metadata_string)
-      rescue JSON::ParserError
-        {}
-      end
-
-      def parse_supported_block_definitions(supported_handles_string)
-        return BlockDefinition.none unless supported_handles_string.present?
-
-        BlockDefinition.where(handle: supported_handles_string.split("|"))
-      end
-
-      def parse_supported_content_types(supported_handles_string)
-        return ContentType.none unless supported_handles_string.present?
-
-        ContentType.where(handle: supported_handles_string.split("|"))
-      end
-  end
-end

data/app/models/iron/schema_importer/merge_strategy.rb

@@ -1,52 +0,0 @@
-module Iron
-  class SchemaImporter::MergeStrategy < SchemaImporter::ImportStrategy
-    def import_block_definition(row)
-      definition = BlockDefinition.find_or_initialize_by(handle: row["handle"])
-      definition.update!(
-        name: row["name"],
-        description: row["description"]
-      )
-    end
-
-    def import_content_type(row)
-      content_type = ContentType.find_or_initialize_by(handle: row["handle"])
-
-      content_type = content_type.becomes!(content_type_class(row["type"]))
-      content_type.update!(
-        name: row["name"],
-        description: row["description"],
-        icon: row["icon"],
-        web_publishing_enabled: row["web_publishing_enabled"] == "true",
-        base_path: row["base_path"]
-      )
-    end
-
-    def import_field_definition(row)
-      raise "Field type is required" unless row["type"].present?
-      return unless row["parent_type"].present? && row["parent_handle"].present? && row["handle"].present?
-
-      parent = find_parent(row["parent_type"], row["parent_handle"])
-      return unless parent
-
-      field_def = parent.field_definitions.find_or_initialize_by(handle: row["handle"])
-      field_def = field_def.becomes!(field_definition_class(row["type"]))
-
-      attributes = {
-        name: row["name"],
-        rank: row["rank"],
-        metadata: parse_metadata(row["metadata"])
-      }
-
-      if field_def.is_a?(FieldDefinitions::Block) || field_def.is_a?(FieldDefinitions::BlockList)
-        attributes[:supported_block_definition_ids] = parse_supported_block_definitions(row["supported_block_definitions"]).pluck(:id)
-      end
-
-      if field_def.is_a?(FieldDefinitions::Reference) || field_def.is_a?(FieldDefinitions::ReferenceList)
-        attributes[:supported_content_type_ids] = parse_supported_content_types(row["supported_content_types"]).pluck(:id)
-      end
-
-      field_def.assign_attributes(attributes)
-      field_def.save!
-    end
-  end
-end

data/app/models/iron/schema_importer/replace_strategy.rb

@@ -1,51 +0,0 @@
-module Iron
-  class SchemaImporter::ReplaceStrategy < SchemaImporter::ImportStrategy
-    def import_block_definition(row)
-      BlockDefinition.create!(
-        handle: row["handle"],
-        name: row["name"],
-        description: row["description"]
-      )
-    end
-
-    def import_content_type(row)
-      content_type_class(row["type"]).create!(
-        handle: row["handle"],
-        name: row["name"],
-        description: row["description"],
-        icon: row["icon"],
-        web_publishing_enabled: row["web_publishing_enabled"] == "true",
-        base_path: row["base_path"]
-      )
-    end
-
-    def import_field_definition(row)
-      raise "Field type is required" unless row["type"].present?
-      return unless row["parent_type"].present? && row["parent_handle"].present? && row["handle"].present?
-
-      parent = find_parent(row["parent_type"], row["parent_handle"])
-      return unless parent
-
-      parent.field_definitions.find_by(handle: row["handle"])&.destroy!
-
-      klass = field_definition_class(row["type"])
-      attributes = {
-        schemable: parent,
-        handle: row["handle"],
-        name: row["name"],
-        rank: row["rank"],
-        metadata: parse_metadata(row["metadata"])
-      }
-
-      if klass <= FieldDefinitions::Block || klass <= FieldDefinitions::BlockList
-        attributes[:supported_block_definition_ids] = parse_supported_block_definitions(row["supported_block_definitions"]).pluck(:id)
-      end
-
-      if klass <= FieldDefinitions::Reference || klass <= FieldDefinitions::ReferenceList
-        attributes[:supported_content_type_ids] = parse_supported_content_types(row["supported_content_types"]).pluck(:id)
-      end
-
-      klass.create!(attributes)
-    end
-  end
-end

data/app/models/iron/schema_importer/safe_strategy.rb

@@ -1,55 +0,0 @@
-module Iron
-  class SchemaImporter::SafeStrategy < SchemaImporter::ImportStrategy
-    def import_block_definition(row)
-      return if BlockDefinition.exists?(handle: row["handle"])
-
-      BlockDefinition.create!(
-        handle: row["handle"],
-        name: row["name"],
-        description: row["description"]
-      )
-    end
-
-    def import_content_type(row)
-      return if ContentType.exists?(handle: row["handle"])
-
-      content_type_class(row["type"]).create!(
-        handle: row["handle"],
-        name: row["name"],
-        description: row["description"],
-        icon: row["icon"],
-        web_publishing_enabled: row["web_publishing_enabled"] == "true",
-        base_path: row["base_path"]
-      )
-    end
-
-    def import_field_definition(row)
-      raise "Field type is required" unless row["type"].present?
-      return unless row["parent_type"].present? && row["parent_handle"].present? && row["handle"].present?
-
-      parent = find_parent(row["parent_type"], row["parent_handle"])
-      return unless parent
-
-      return if parent.field_definitions.exists?(handle: row["handle"])
-
-      klass = field_definition_class(row["type"])
-      attributes = {
-        schemable: parent,
-        handle: row["handle"],
-        name: row["name"],
-        rank: row["rank"],
-        metadata: parse_metadata(row["metadata"])
-      }
-
-      if klass <= FieldDefinitions::Block || klass <= FieldDefinitions::BlockList
-        attributes[:supported_block_definition_ids] = parse_supported_block_definitions(row["supported_block_definitions"]).pluck(:id)
-      end
-
-      if klass <= FieldDefinitions::Reference || klass <= FieldDefinitions::ReferenceList
-        attributes[:supported_content_type_ids] = parse_supported_content_types(row["supported_content_types"]).pluck(:id)
-      end
-
-      klass.create!(attributes)
-    end
-  end
-end

data/app/models/iron/schema_importer.rb

@@ -1,108 +0,0 @@
-require "csv"
-
-module Iron
-  class SchemaImporter
-    IMPORT_MODES = %w[merge replace safe].freeze
-
-    attr_reader :file, :mode, :errors
-
-    def self.import(file, mode: "merge")
-      new(file, mode:).import
-    end
-
-    def initialize(file, mode: "merge")
-      raise ArgumentError, "Missing import file" unless file.present?
-      raise ArgumentError, "Invalid import mode: #{mode}. Must be one of: #{IMPORT_MODES.join(', ')}" unless IMPORT_MODES.include?(mode)
-
-      @file = file
-      @mode = mode.to_s
-      @errors = []
-      @strategy = build_strategy(mode)
-    end
-
-    def import
-      ActiveRecord::Base.transaction do
-        Account.clear_schema! if mode == "replace"
-
-        archive = SchemaArchive.from_file(file)
-
-        unless archive.valid?
-          errors.concat(archive.errors)
-          return ImportResult.new(false, errors)
-        end
-
-        if archive["block_definitions.csv"]
-          CSV.parse(archive["block_definitions.csv"], headers: true) do |row|
-            next unless row["handle"].present?
-            @strategy.import_block_definition(row)
-          end
-        end
-
-        if archive["content_types.csv"]
-          CSV.parse(archive["content_types.csv"], headers: true) do |row|
-            next unless row["handle"].present?
-            @strategy.import_content_type(row)
-          end
-        end
-
-        if archive["field_definitions.csv"]
-          CSV.parse(archive["field_definitions.csv"], headers: true) do |row|
-            @strategy.import_field_definition(row)
-          end
-        end
-
-        update_content_type_references(archive["content_types.csv"])
-
-        ImportResult.new(true, [])
-      end
-    rescue StandardError => e
-      errors << "Import failed: #{e.message}"
-      ImportResult.new(false, errors)
-    end
-
-    private
-
-      def build_strategy(mode)
-        case mode.to_s
-        when "merge" then SchemaImporter::MergeStrategy.new
-        when "replace" then SchemaImporter::ReplaceStrategy.new
-        when "safe" then SchemaImporter::SafeStrategy.new
-        else
-          raise ArgumentError, "Invalid import mode: #{mode}"
-        end
-      end
-
-      def update_content_type_references(content_types_csv)
-        return unless content_types_csv
-
-        CSV.parse(content_types_csv, headers: true) do |row|
-          handle = row["handle"]
-          content_type = ContentType.find_by(handle: handle)
-          next unless content_type
-
-          if row["title_field_handle"].present?
-            title_field = content_type.field_definitions.find_by(handle: row["title_field_handle"])
-            content_type.update!(title_field_definition: title_field) if title_field
-          end
-
-          if row["web_page_title_field_handle"].present?
-            page_title_field = content_type.field_definitions.find_by(handle: row["web_page_title_field_handle"])
-            content_type.update!(web_page_title_field_definition: page_title_field) if page_title_field
-          end
-        end
-      end
-
-      class ImportResult
-        attr_reader :errors
-
-        def initialize(success, errors)
-          @success = success
-          @errors = errors
-        end
-
-        def success?
-          @success
-        end
-      end
-  end
-end

data/app/views/iron/contents/new.html.erb

@@ -1,34 +0,0 @@
-<% content_for :title, "Import Content" %>
-
-<div class="">
-  <%= back_button_to "Settings", settings_path %>
-  <h1 class="page-title">Import Content</h1>
-  <p class="mt-2 text-sm text-stone-500">Upload a content archive exported from another Iron instance.</p>
-
-  <%= form_with url: import_content_path, multipart: true, class: "mt-8 max-w-2xl", data: { turbo: false } do |form| %>
-    <div class="field-group">
-      <div class="field">
-        <%= form.label :content_file, "Content Archive" %>
-        <div>
-          <%= form.file_field :content_file,
-              accept: ".tar",
-              required: true,
-              class: "input" %>
-          <p class="mt-2 text-sm text-stone-500">Select a .tar file exported using Iron's content export.</p>
-        </div>
-      </div>
-
-      <div class="field">
-        <label class="text-sm font-medium text-stone-700">Import behaviour</label>
-        <p class="text-sm text-stone-500 mt-1">
-          Entries with matching IDs and instance tokens are updated. Other records are created.
-        </p>
-      </div>
-    </div>
-
-    <div class="mt-6 flex items-center gap-x-3">
-      <%= form.submit "Import Content", class: "button-primary" %>
-      <%= link_to "Cancel", settings_path, class: "button-secondary" %>
-    </div>
-  <% end %>
-</div>

data/app/views/iron/schemas/new.html.erb

@@ -1,57 +0,0 @@
-<% content_for :title, "Import Schema" %>
-
-<div class="">
-  <%= back_button_to "Content Types", content_types_path %>
-  <h1 class="page-title">Import Schema</h1>
-  <p class="mt-2 text-sm text-stone-500">Upload a schema tar file to import content types, fields, and blocks.</p>
-
-  <%= form_with url: import_schema_path, multipart: true, class: "mt-8 max-w-2xl", data: { turbo: false } do |form| %>
-    <div class="field-group">
-      <div class="field">
-        <%= form.label :schema_file, "Schema File" %>
-        <div>
-          <%= form.file_field :schema_file, 
-              accept: ".tar",
-              required: true,
-              class: "input" %>
-          <p class="mt-2 text-sm text-stone-500">Select a .tar file exported from Iron CMS</p>
-        </div>
-      </div>
-
-      <div class="field">
-        <%= form.label :import_mode, "Import Mode" %>
-        <div class="space-y-4">
-          <% @import_modes.each do |mode| %>
-            <div class="flex items-start">
-              <div class="flex h-6 items-center">
-                <%= form.radio_button :import_mode, mode, 
-                    checked: mode == "merge",
-                    class: "h-4 w-4 border-stone-300 text-blue-600 focus:ring-blue-600" %>
-              </div>
-              <div class="ml-3">
-                <%= form.label "import_mode_#{mode}", class: "text-sm font-medium text-stone-700" do %>
-                  <%= mode.capitalize %>
-                <% end %>
-                <p class="text-sm text-stone-500">
-                  <% case mode %>
-                  <% when "merge" %>
-                    Add new items and update existing ones by handle
-                  <% when "replace" %>
-                    Clear existing schema and import fresh (destructive)
-                  <% when "safe" %>
-                    Only add new items, skip existing handles
-                  <% end %>
-                </p>
-              </div>
-            </div>
-          <% end %>
-        </div>
-      </div>
-    </div>
-
-    <div class="mt-6 flex items-center gap-x-3">
-      <%= form.submit "Import Schema", class: "button-primary" %>
-      <%= link_to "Cancel", content_types_path, class: "button-secondary" %>
-    </div>
-  <% end %>
-</div>

data/lib/iron/test_fixtures.rb

@@ -1,50 +0,0 @@
-require "stringio"
-
-module Iron
-  module TestFixtures
-    class << self
-      def load
-        return if @loaded
-
-        fixture_path = Rails.root.join("test/fixtures/iron")
-        schema_file = fixture_path.join("schema.tar.gz")
-        content_file = fixture_path.join("content.tar.gz")
-
-        if schema_file.exist?
-          load_schema(schema_file)
-        else
-          Rails.logger.warn "Iron test fixture not found: #{schema_file}"
-        end
-
-        if content_file.exist?
-          load_content(content_file)
-        else
-          Rails.logger.warn "Iron test fixture not found: #{content_file}"
-        end
-
-        @loaded = true
-      end
-
-      private
-
-        def load_schema(file_path)
-          File.open(file_path, "rb") do |file|
-            result = SchemaImporter.import(file, mode: "merge")
-            unless result.success?
-              raise "Failed to load Iron schema fixtures: #{result.errors.join(', ')}"
-            end
-          end
-        end
-
-        def load_content(file_path)
-          File.open(file_path, "rb") do |file|
-            archive = Archive.from_file(file)
-            result = ContentImport.import(archive)
-            unless result.success?
-              raise "Failed to load Iron content fixtures: #{result.errors.join(', ')}"
-            end
-          end
-        end
-    end
-  end
-end