iron-cms 0.1.2 → 0.1.3

data/app/models/iron/block_definition.rb

@@ -4,6 +4,14 @@ module Iron
 
     has_many :field_definitions, -> { ranked }, as: :schemable, dependent: :destroy
 
+    has_and_belongs_to_many :referencing_field_definitions,
+      class_name: "::Iron::FieldDefinition",
+      foreign_key: "block_definition_id",
+      association_foreign_key: "field_definition_id",
+      join_table: "iron_block_definitions_field_definitions"
+
+    before_destroy { referencing_field_definitions.clear }
+
     validates :name, presence: true
     validates :handle, presence: true
   end

data/app/models/iron/content_type.rb

@@ -11,6 +11,14 @@ module Iron
 
     has_many :entries, -> { extending FieldQueryable }, dependent: :destroy
 
+    has_and_belongs_to_many :referencing_field_definitions,
+      class_name: "::Iron::FieldDefinition",
+      foreign_key: "content_type_id",
+      association_foreign_key: "field_definition_id",
+      join_table: "iron_content_types_field_definitions"
+
+    before_destroy { referencing_field_definitions.clear }
+
     class << self
       def classify_type(type)
         "Iron::ContentTypes::#{type}"

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

@@ -5,7 +5,7 @@ module Iron
 
     class_methods do
       def csv_headers
-        %w[parent_type parent_handle handle name type rank metadata supported_block_definitions]
+        %w[parent_type parent_handle handle name type rank metadata supported_block_definitions supported_content_types]
       end
 
       def csv_scope
@@ -22,15 +22,21 @@ module Iron
         type.demodulize.underscore,
         rank,
         metadata.to_json,
-        export_supported_block_definitions
+        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_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_importer/import_strategy.rb

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -11,16 +11,16 @@ module Iron
     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 = []
-
-      validate_mode!
+      @strategy = build_strategy(mode)
     end
 
     def import
-      return ImportResult.new(false, errors) unless valid?
-
       ActiveRecord::Base.transaction do
         Account.clear_schema! if mode == "replace"
 
@@ -31,205 +31,45 @@ module Iron
           return ImportResult.new(false, errors)
         end
 
-        import_block_definitions(archive["block_definitions.csv"])
-        import_content_types(archive["content_types.csv"])
-        import_field_definitions(archive["field_definitions.csv"])
-
-        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 valid?
-        validate_file_presence
-        errors.empty?
-      end
-
-      def validate_mode!
-        unless IMPORT_MODES.include?(mode)
-          raise ArgumentError, "Invalid import mode: #{mode}. Must be one of: #{IMPORT_MODES.join(', ')}"
-        end
-      end
-
-      def validate_file_presence
-        errors << "No file provided" unless file
-      end
-
-      def import_block_definitions(csv_content)
-        return unless csv_content
-
-        CSV.parse(csv_content, headers: true) do |row|
-          handle = row["handle"]
-          next unless handle.present?
-
-          case mode
-          when "merge"
-            block_def = BlockDefinition.find_or_initialize_by(handle: handle)
-            block_def.assign_attributes(
-              name: row["name"],
-              description: row["description"]
-            )
-            block_def.save!
-          when "replace"
-            BlockDefinition.create!(
-              handle: handle,
-              name: row["name"],
-              description: row["description"]
-            )
-          when "safe"
-            next if BlockDefinition.exists?(handle: handle)
-
-            BlockDefinition.create!(
-              handle: handle,
-              name: row["name"],
-              description: row["description"]
-            )
+        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
-      end
 
-      def import_content_types(csv_content)
-        return unless csv_content
-
-        CSV.parse(csv_content, headers: true) do |row|
-          handle = row["handle"]
-          next unless handle.present?
-
-          case mode
-          when "merge"
-            content_type = ContentType.find_or_initialize_by(handle: handle)
-            update_content_type(content_type, row)
-          when "replace"
-            content_type = build_content_type(row)
-            content_type.save!
-          when "safe"
-            next if ContentType.exists?(handle: handle)
-
-            content_type = build_content_type(row)
-            content_type.save!
+        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
-      end
-
-      def import_field_definitions(csv_content)
-        return unless csv_content
-
-        CSV.parse(csv_content, headers: true) do |row|
-          parent_type = row["parent_type"]
-          parent_handle = row["parent_handle"]
-          handle = row["handle"]
 
-          next unless parent_type.present? && parent_handle.present? && handle.present?
-
-          parent = find_parent(parent_type, parent_handle)
-          next unless parent
-
-          case mode
-          when "merge"
-            field_def = parent.field_definitions.find_or_initialize_by(handle: handle)
-            update_field_definition(field_def, row)
-          when "replace"
-            field_def = build_field_definition(parent, row)
-            field_def.save!
-          when "safe"
-            next if parent.field_definitions.exists?(handle: handle)
-
-            field_def = build_field_definition(parent, row)
-            field_def.save!
+        if archive["field_definitions.csv"]
+          CSV.parse(archive["field_definitions.csv"], headers: true) do |row|
+            @strategy.import_field_definition(row)
           end
         end
-      end
-
-      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 build_content_type(row)
-        klass = case row["type"]
-        when "single" then ContentTypes::Single
-        when "collection" then ContentTypes::Collection
-        else ContentType
-        end
-
-        klass.new(
-          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 update_content_type(content_type, row)
-        content_type.assign_attributes(
-          name: row["name"],
-          description: row["description"],
-          icon: row["icon"],
-          web_publishing_enabled: row["web_publishing_enabled"] == "true",
-          base_path: row["base_path"]
-        )
-
-        # Update type if changed
-        if row["type"] && content_type.type != "Iron::ContentTypes::#{row['type'].camelize}"
-          content_type.type = "Iron::ContentTypes::#{row['type'].camelize}"
-        end
-
-        content_type.save!
-      end
-
-      def build_field_definition(parent, row)
-        klass = "Iron::FieldDefinitions::#{row['type'].camelize}".constantize
 
-        field_def = klass.new(
-          schemable: parent,
-          handle: row["handle"],
-          name: row["name"],
-          rank: row["rank"],
-          metadata: parse_metadata(row["metadata"])
-        )
-
-        # Set supported block definitions before saving
-        set_supported_block_definitions(field_def, row["supported_block_definitions"])
+        update_content_type_references(archive["content_types.csv"])
 
-        field_def
+        ImportResult.new(true, [])
       end
+    rescue StandardError => e
+      errors << "Import failed: #{e.message}"
+      ImportResult.new(false, errors)
+    end
 
-      def update_field_definition(field_def, row)
-        field_def.assign_attributes(
-          name: row["name"],
-          rank: row["rank"],
-          metadata: parse_metadata(row["metadata"])
-        )
+    private
 
-        # Update type if changed
-        if row["type"] && field_def.type != "Iron::FieldDefinitions::#{row['type'].camelize}"
-          field_def.type = "Iron::FieldDefinitions::#{row['type'].camelize}"
+      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
-
-        # Set supported block definitions before saving
-        set_supported_block_definitions(field_def, row["supported_block_definitions"])
-
-        field_def.save!
-      end
-
-      def parse_metadata(metadata_string)
-        return {} if metadata_string.blank?
-
-        JSON.parse(metadata_string)
-      rescue JSON::ParserError
-        {}
       end
 
       def update_content_type_references(content_types_csv)
@@ -252,16 +92,6 @@ module Iron
         end
       end
 
-      def set_supported_block_definitions(field_def, supported_handles_string)
-        return unless supported_handles_string.present?
-        return unless field_def.respond_to?(:supported_block_definitions)
-
-        handles = supported_handles_string.split("|")
-        block_definitions = BlockDefinition.where(handle: handles)
-
-        field_def.supported_block_definitions = block_definitions
-      end
-
       class ImportResult
         attr_reader :errors
 

data/lib/iron/version.rb

@@ -1,3 +1,3 @@
 module Iron
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/iron-cms.rb

@@ -1 +1 @@
-require "iron"
+require "iron"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iron-cms
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Massimo De Marchi
@@ -291,6 +291,10 @@ files:
 - app/models/iron/schema_archive.rb
 - app/models/iron/schema_exporter.rb
 - app/models/iron/schema_importer.rb
+- app/models/iron/schema_importer/import_strategy.rb
+- app/models/iron/schema_importer/merge_strategy.rb
+- app/models/iron/schema_importer/replace_strategy.rb
+- app/models/iron/schema_importer/safe_strategy.rb
 - app/models/iron/session.rb
 - app/models/iron/user.rb
 - app/models/iron/user/role.rb