iron-cms 0.5.2 → 0.7.0

data/app/models/iron/content_import/field_reconstructor.rb

@@ -1,276 +0,0 @@
-require "csv"
-
-module Iron
-  class ContentImport::FieldReconstructor
-      def initialize(content_type, registry, archive)
-        @content_type = content_type
-        @registry = registry
-        @archive = archive
-      end
-
-      def reconstruct_all(csv_data)
-        entry_snapshots = build_entry_snapshots(csv_data)
-
-        entry_snapshots.each do |entry_gid, snapshot|
-          reconstruct_entry(entry_gid, snapshot)
-        end
-      end
-
-      private
-
-        def build_entry_snapshots(csv_data)
-          snapshots = {}
-          return snapshots unless csv_data.present?
-
-          CSV.parse(csv_data, headers: true) do |row|
-            entry_key = row["entry_key"]
-            next if entry_key.blank?
-
-            snapshot = (snapshots[entry_key] ||= ContentImport::EntrySnapshot.new(entry_key))
-            populate_snapshot(snapshot, row)
-          end
-
-          snapshots
-        end
-
-        def populate_snapshot(snapshot, row)
-          path = row["path"]
-          return if path.blank?
-
-          if path == "/route"
-            snapshot.add_route(row["value"])
-          elsif path.start_with?("/fields/")
-            add_field_snapshot(snapshot, row)
-          end
-        end
-
-        def add_field_snapshot(snapshot, row)
-          locale_code = row["locale"]
-          return unless locale_code.present?
-
-          field_snapshot = ContentImport::FieldSnapshot.new(
-            locale_code: locale_code,
-            path: row["path"],
-            value: row["value"]
-          )
-          snapshot.add_field_snapshot(field_snapshot)
-        end
-
-        def reconstruct_entry(entry_gid, snapshot)
-          entry = @registry.find_entry(entry_gid)
-          return unless entry
-
-          update_entry_route(entry, snapshot.route) unless snapshot.route.nil?
-          reconstruct_entry_fields(entry, snapshot)
-        end
-
-        def update_entry_route(entry, route)
-          entry.update_columns(route: route)
-        end
-
-        def reconstruct_entry_fields(entry, snapshot)
-          snapshot.group_field_snapshots_by_locale.each do |locale_code, field_snapshots|
-            locale = Iron::Locale.find_by(code: locale_code)
-            next unless locale
-
-            reconstruct_fields_for_locale(entry, field_snapshots, locale)
-          end
-        end
-
-        def reconstruct_fields_for_locale(entry, field_snapshots, locale)
-          field_groups = field_snapshots
-            .select(&:field_path?)
-            .group_by(&:field_handle)
-
-          field_groups.each do |handle, snapshots|
-            definition = @content_type.field_definitions.find_by(handle: handle)
-            next unless definition
-
-            field = entry.find_or_build_field(definition, locale)
-            reconstruct_field(field, snapshots)
-          end
-        end
-
-        def reconstruct_field(field, snapshots)
-          case field
-          when Iron::Fields::TextField
-            field.value_string = snapshots.first.value
-          when Iron::Fields::TextArea
-            field.value_text = snapshots.first.value
-          when Iron::Fields::Number
-            field.value_decimal = snapshots.first.value.to_f if snapshots.first.value.present?
-          when Iron::Fields::Boolean
-            field.value_boolean = ActiveModel::Type::Boolean.new.cast(snapshots.first.value)
-          when Iron::Fields::Date
-            field.value_datetime = Time.zone.parse(snapshots.first.value) if snapshots.first.value.present?
-          when Iron::Fields::File
-            attach_file(field, snapshots.first.value)
-          when Iron::Fields::Reference
-            field.referenced_entry = @registry.find_entry(snapshots.first.value)
-          when Iron::Fields::RichTextArea
-            reconstruct_rich_text(field, snapshots)
-          when Iron::Fields::ReferenceList
-            reconstruct_reference_list(field, snapshots)
-          when Iron::Fields::Block
-            reconstruct_block(field, snapshots)
-          when Iron::Fields::BlockList
-            reconstruct_block_list(field, snapshots)
-          end
-
-          field.save!(validate: false)
-        rescue ArgumentError
-          # Handle date parsing errors
-          field.save!(validate: false)
-        end
-
-        def attach_file(field, blob_id)
-          return unless blob_id.present?
-
-          data = @archive["uploads/#{blob_id}"]
-          return unless data
-
-          field.file.attach(
-            io: StringIO.new(data),
-            filename: "imported-#{blob_id}",
-            content_type: "application/octet-stream"
-          )
-        end
-
-        def reconstruct_rich_text(field, snapshots)
-          html_snapshot = snapshots.find { |s| s.path.end_with?("/html") }
-
-          if html_snapshot&.value.present?
-            field.update!(rich_text: html_snapshot.value)
-          else
-            field.rich_text&.destroy
-          end
-        end
-
-        def reconstruct_reference_list(field, snapshots)
-          # Group snapshots by rank (the first segment after the field handle)
-          field.save!(validate: false) if field.new_record?
-
-          items = snapshots.filter_map do |snapshot|
-            segments = snapshot.field_segments
-            next if segments.length < 2
-
-            rank = segments.last
-            entry = @registry.find_entry(snapshot.value)
-            next unless entry
-
-            { rank:, entry: }
-          end
-
-          existing = field.references.index_by(&:rank)
-          kept_ids = []
-
-          items.each do |item|
-            reference = existing[item[:rank]] || field.references.build(rank: item[:rank])
-            reference.entry = item[:entry]
-            reference.save!
-            kept_ids << reference.id
-          end
-
-          field.references.where.not(id: kept_ids).destroy_all
-        end
-
-        def reconstruct_block(field, snapshots)
-          # Fields::Block IS the block - it doesn't have a separate block relation
-          # The field already has the block definition through field.definition
-
-          # Group snapshots by field handle
-          field_snapshots = snapshots.reject { |s| s.path.include?("/_block") }
-          reconstruct_block_fields(field, field_snapshots, field.locale)
-        end
-
-        def reconstruct_block_list(field, snapshots)
-          # Group snapshots by block rank
-          blocks_by_rank = {}
-
-          snapshots.each do |snapshot|
-            segments = snapshot.field_segments
-            next if segments.size < 2
-
-            rank = segments[1]
-            blocks_by_rank[rank] ||= []
-            blocks_by_rank[rank] << snapshot
-          end
-
-          # Clear all existing blocks first to avoid rank conflicts
-          field.blocks.destroy_all
-
-          blocks_by_rank.each do |rank, block_snapshots|
-            # Find block handle
-            block_snapshot = block_snapshots.find { |s| s.path.include?("/_block") }
-            block_handle = block_snapshot&.value
-            next unless block_handle
-
-            block_definition = Iron::BlockDefinition.find_by(handle: block_handle)
-            next unless block_definition
-
-            block = field.blocks.build(
-              rank: rank,
-              entry: field.entry,
-              locale: field.locale,
-              definition: block_definition
-            )
-
-            # Save the block first to establish it in the database
-            block.save!(validate: false)
-
-            # Then reconstruct its fields
-            field_snapshots = block_snapshots.reject { |s| s.path.include?("/_block") }
-            reconstruct_block_fields(block, field_snapshots, field.locale)
-          end
-        end
-
-        def reconstruct_block_fields(block, snapshots, locale)
-          # Group snapshots by field handle
-          field_groups = {}
-
-          snapshots.each do |snapshot|
-            field_handle = block_child_handle(block, snapshot)
-            next unless field_handle
-
-            field_groups[field_handle] ||= []
-            field_groups[field_handle] << snapshot
-          end
-
-          # Get the actual block definition
-          block_def = if block.respond_to?(:block_definition)
-            block.block_definition
-          else
-            block.definition
-          end
-
-          # Clear existing fields to avoid rank conflicts
-          block.fields.where(locale: locale).destroy_all
-
-          field_groups.each do |handle, field_snapshots|
-            definition = block_def.field_definitions.find_by(handle: handle)
-            next unless definition
-
-            field = block.fields.build(
-              type: definition.field_type,
-              entry: block.entry,
-              definition: definition,
-              locale: locale
-            )
-
-            reconstruct_field(field, field_snapshots)
-          end
-        end
-
-        def block_child_handle(block, snapshot)
-          relative_segments = snapshot.field_segments
-          block_path = block.send(:field_path)
-
-          if block_path.present?
-            block_segments = block_path.sub(%r{^/fields/}, "").split("/")
-            relative_segments = relative_segments.drop(block_segments.length)
-          end
-
-          relative_segments.first
-        end
-  end
-end

data/app/models/iron/content_import/field_snapshot.rb

@@ -1,33 +0,0 @@
-module Iron
-  class ContentImport::FieldSnapshot
-      attr_reader :locale_code, :path, :value
-
-      def initialize(locale_code:, path:, value:)
-        @locale_code = locale_code
-        @path = path
-        @value = value
-      end
-
-      def field_handle
-        return nil unless field_path?
-
-        segments[0]
-      end
-
-      def field_segments
-        return [] unless field_path?
-
-        segments
-      end
-
-      def field_path?
-        @path&.start_with?("/fields/")
-      end
-
-      private
-
-        def segments
-          @segments ||= @path.sub(%r{^/fields/}, "").split("/")
-        end
-  end
-end

data/app/models/iron/content_import/registry.rb

@@ -1,32 +0,0 @@
-module Iron
-  class ContentImport::Registry
-      def initialize
-        @entries_by_original_gid = {}
-      end
-
-      def register_entry(original_gid, entry)
-        @entries_by_original_gid[original_gid] = entry
-        @entries_by_original_gid[entry.to_gid.to_s] = entry
-      end
-
-      def find_entry(gid_string)
-        return nil if gid_string.blank?
-
-        cached_entry = @entries_by_original_gid[gid_string]
-        return cached_entry if cached_entry
-
-        locate_existing_entry(gid_string)
-      end
-
-      private
-
-        def locate_existing_entry(gid_string)
-          entry = ::GlobalID::Locator.locate(gid_string)
-          return nil unless entry.is_a?(Iron::Entry)
-
-          @entries_by_original_gid[gid_string] = entry
-        rescue ActiveRecord::RecordNotFound
-          nil
-        end
-  end
-end

data/app/models/iron/content_import/session.rb

@@ -1,89 +0,0 @@
-require "csv"
-
-module Iron
-  class ContentImport::Session
-      attr_reader :errors
-
-      def initialize(archive)
-        raise ArgumentError, "Missing import archive" unless archive.present?
-
-        @archive = archive
-        @errors = []
-        @registry = ContentImport::Registry.new
-      end
-
-      def run
-        ActiveRecord::Base.transaction do
-          prepare_entries
-          reconstruct_entries
-
-          Result.new(success: true)
-        end
-      rescue StandardError => e
-        warn e.full_message
-        @errors << "Import failed: #{e.message}"
-        Result.new(success: false, errors: @errors)
-      end
-
-      private
-
-        def prepare_entries
-          content_manifests.each do |content_type, csv_data|
-            entry_builder = ContentImport::EntryBuilder.new(content_type, @registry)
-            entry_builder.ensure_entries_exist(csv_data)
-          end
-        end
-
-        def reconstruct_entries
-          content_manifests.each do |content_type, csv_data|
-            reconstructor = ContentImport::FieldReconstructor.new(content_type, @registry, @archive)
-            reconstructor.reconstruct_all(csv_data)
-          end
-        end
-
-        def content_manifests
-          @content_manifests ||= build_content_manifests
-        end
-
-        def build_content_manifests
-          @archive.file_paths
-            .select { |path| content_manifest?(path) }
-            .sort
-            .filter_map do |path|
-              content_type = find_content_type(path)
-
-              unless content_type
-                @errors << "Unknown content type '#{extract_handle(path)}' in archive"
-                next
-              end
-
-              [ content_type, @archive[path] ]
-            end
-        end
-
-        def content_manifest?(path)
-          path.start_with?("content/") && path.end_with?(".csv")
-        end
-
-        def extract_handle(path)
-          ::File.basename(path, ".csv")
-        end
-
-        def find_content_type(path)
-          Iron::ContentType.find_by(handle: extract_handle(path))
-        end
-
-      class Result
-        attr_reader :errors
-
-        def initialize(success:, errors: [])
-          @success = success
-          @errors = errors
-        end
-
-        def success?
-          @success
-        end
-      end
-  end
-end

data/app/models/iron/content_import.rb

@@ -1,15 +0,0 @@
-module Iron
-  class ContentImport
-    def self.import(archive)
-      new(archive).import
-    end
-
-    def initialize(archive)
-      @archive = archive
-    end
-
-    def import
-      Session.new(@archive).run
-    end
-  end
-end

data/app/models/iron/content_type/portable.rb

@@ -1,30 +0,0 @@
-module Iron
-  module ContentType::Portable
-      extend ActiveSupport::Concern
-      include ::Iron::CsvSerializable
-
-    class_methods do
-      def csv_headers
-        %w[handle name type description icon title_field_handle web_publishing_enabled web_page_title_field_handle base_path]
-      end
-
-      def csv_scope
-        includes(:title_field_definition, :web_page_title_field_definition)
-      end
-    end
-
-    def to_csv_row
-      [
-        handle,
-        name,
-        type.demodulize.underscore,
-        description,
-        icon,
-        title_field_definition&.handle,
-        web_publishing_enabled,
-        web_page_title_field_definition&.handle,
-        base_path
-      ]
-    end
-  end
-end

data/app/models/iron/entry/portable.rb

@@ -1,35 +0,0 @@
-module Iron
-  class Entry
-    module Portable
-      extend ActiveSupport::Concern
-
-      def to_csv_rows
-        rows = []
-
-        rows.concat(entry_attribute_rows)
-
-        fields.where(parent_type: nil).includes(:locale, :definition).each do |field|
-          rows.concat(field.to_csv_rows)
-        end
-
-        rows
-      end
-
-      private
-
-        def entry_attribute_rows
-          rows = []
-
-          rows << csv_row("/created_at", "date", created_at.iso8601)
-          rows << csv_row("/updated_at", "date", updated_at.iso8601)
-          rows << csv_row("/route", "text", route) unless route.nil?
-
-          rows
-        end
-
-        def csv_row(path, type, value)
-          [ to_gid, nil, path, type, value ]
-        end
-    end
-  end
-end

data/app/models/iron/field/portable.rb

@@ -1,33 +0,0 @@
-module Iron
-  class Field
-    module Portable
-      extend ActiveSupport::Concern
-
-      def to_csv_rows
-        [ csv_row(field_path, csv_type, csv_value) ]
-      end
-
-      def field_path
-        if parent.is_a?(Fields::Block)
-          "#{parent.field_path}/#{definition.handle}"
-        elsif parent.is_a?(Fields::BlockList)
-          "#{parent.field_path}/#{rank}"
-        else
-          "/fields/#{definition.handle}"
-        end
-      end
-
-      def csv_row(path, type, value = nil)
-        [ entry.to_gid, locale&.code, path, type, value ]
-      end
-
-        def csv_type
-          raise NotImplementedError, "#{self.class} must implement csv_type"
-        end
-
-        def csv_value
-          raise NotImplementedError, "#{self.class} must implement csv_value"
-        end
-    end
-  end
-end

data/app/models/iron/field_definition/portable.rb

@@ -1,42 +0,0 @@
-module Iron
-  module FieldDefinition::Portable
-      extend ActiveSupport::Concern
-      include ::Iron::CsvSerializable
-
-    class_methods do
-      def csv_headers
-        %w[parent_type parent_handle handle name type rank metadata supported_block_definitions supported_content_types]
-      end
-
-      def csv_scope
-        includes(:schemable)
-      end
-    end
-
-    def to_csv_row
-      [
-        schemable_type == "Iron::ContentType" ? "content_type" : "block",
-        schemable.handle,
-        handle,
-        name,
-        type.demodulize.underscore,
-        rank,
-        metadata.to_json,
-        export_supported_block_definitions,
-        export_supported_content_types
-      ]
-    end
-
-    private
-
-      def export_supported_block_definitions
-        return nil unless respond_to?(:supported_block_definitions)
-        supported_block_definitions.pluck(:handle).join("|")
-      end
-
-      def export_supported_content_types
-        return nil unless respond_to?(:supported_content_types)
-        supported_content_types.pluck(:handle).join("|")
-      end
-  end
-end

data/app/models/iron/schema_archive.rb

@@ -1,71 +0,0 @@
-require "csv"
-require "rubygems/package"
-require "stringio"
-
-module Iron
-  class SchemaArchive
-    REQUIRED_FILES = %w[content_types.csv block_definitions.csv field_definitions.csv].freeze
-
-    attr_reader :errors
-
-    def self.from_file(file)
-      new(file.read)
-    end
-
-    def initialize(tar_content = nil)
-      @tar_content = tar_content
-      @csv_files = {}
-      @errors = []
-      extract_files if tar_content
-    end
-
-    def valid?
-      return false if @tar_content.nil?
-
-      missing_files = REQUIRED_FILES - @csv_files.keys
-      if missing_files.any?
-        @errors << "Missing required files: #{missing_files.join(', ')}"
-      end
-
-      @errors.empty?
-    end
-
-    def [](filename)
-      @csv_files[filename]
-    end
-
-    def add_file(filename, csv_content)
-      @csv_files[filename] = csv_content
-    end
-
-    def to_tar
-      tarfile = StringIO.new
-
-      Gem::Package::TarWriter.new(tarfile) do |tar|
-        @csv_files.each do |filename, content|
-          tar.add_file_simple(filename, 0644, content.bytesize) do |io|
-            io.write(content)
-          end
-        end
-      end
-
-      tarfile.string
-    end
-
-    private
-
-      def extract_files
-        tar_io = StringIO.new(@tar_content)
-
-        Gem::Package::TarReader.new(tar_io) do |tar|
-          tar.each do |entry|
-            if entry.file? && entry.full_name.end_with?(".csv")
-              @csv_files[entry.full_name] = entry.read.force_encoding("UTF-8")
-            end
-          end
-        end
-      rescue StandardError => e
-        @errors << "Failed to extract tar archive: #{e.message}"
-      end
-  end
-end

data/app/models/iron/schema_exporter.rb

@@ -1,15 +0,0 @@
-module Iron
-  class SchemaExporter
-    def self.export
-      new.export
-    end
-
-    def export
-      archive = SchemaArchive.new
-      archive.add_file("content_types.csv", ContentType.to_csv)
-      archive.add_file("block_definitions.csv", BlockDefinition.to_csv)
-      archive.add_file("field_definitions.csv", FieldDefinition.to_csv)
-      archive.to_tar
-    end
-  end
-end