iron-cms 0.17.2 → 0.18.0

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

@@ -0,0 +1,40 @@
+module Iron
+  module FieldDefinition::Validatable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :supported_validations, instance_writer: false, default: [].freeze
+
+      validate :declared_validations_are_well_formed
+    end
+
+    class_methods do
+      def supports_validations(*keys)
+        keys = keys.map(&:to_s)
+        self.supported_validations = keys.freeze
+        store_accessor :metadata, *keys
+
+        keys.each do |key|
+          kind = FieldDefinition::Validations::RULES.fetch(key).fetch(:kind)
+          define_method(key) { FieldDefinition::Validations.cast(kind, super()) }
+          define_method("#{key}=") { |value| super(FieldDefinition::Validations.cast(kind, value)) }
+        end
+      end
+    end
+
+    def required?
+      ActiveModel::Type::Boolean.new.cast(metadata&.dig("required")) || false
+    end
+
+    def metadata=(config)
+      super(FieldDefinition::Validations.cast_rules(config))
+    end
+
+    private
+      def declared_validations_are_well_formed
+        FieldDefinition::Validations.violations(type_handle, metadata).each do |violation|
+          errors.add(violation.attribute, violation.message)
+        end
+      end
+  end
+end

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

@@ -0,0 +1,175 @@
+module Iron
+  module FieldDefinition::Validations
+    Violation = Data.define(:attribute, :message)
+
+    RULES = {
+      "required" => { kind: :boolean },
+      "allowed_values" => { kind: :string_list },
+      "min_length" => { kind: :positive_integer, ceiling: "max_length" },
+      "max_length" => { kind: :positive_integer },
+      "min" => { kind: :number, ceiling: "max" },
+      "max" => { kind: :number },
+      "file_scope" => { kind: :file_scope },
+      "selected_presets" => { kind: :preset_list }
+    }.freeze
+
+    class << self
+      def keys_for(type_handle)
+        FieldDefinition.classify_type(type_handle).constantize.supported_validations
+      end
+
+      def violations(type_handle, metadata)
+        return [ Violation.new(attribute: :metadata, message: "must be an object") ] unless metadata.nil? || metadata.is_a?(Hash)
+
+        rules = (metadata || {}).transform_keys(&:to_s).slice(*RULES.keys).reject { |_key, value| absent?(value) }
+        return [] if rules.empty?
+
+        allowed = keys_for(type_handle)
+        return [ Violation.new(attribute: :metadata, message: "type #{type_handle} supports no validations") ] if allowed.empty?
+
+        rules.flat_map { |key, value| rule_violations(type_handle, allowed, key, value) } + bound_violations(rules, allowed)
+      end
+
+      def cast_rules(config)
+        return config unless config.is_a?(Hash)
+
+        config.each_with_object({}) do |(key, value), typed|
+          key = key.to_s
+          rule = RULES[key]
+          typed[key] = rule ? cast(rule.fetch(:kind), value) : value
+        end
+      end
+
+      def cast(kind, value)
+        return nil if value.nil?
+
+        case kind
+        when :boolean then cast_boolean(value)
+        when :positive_integer then cast_positive_integer(value)
+        when :number then cast_number(value)
+        when :string_list then cast_string_list(value)
+        when :file_scope then cast_file_scope(value)
+        when :preset_list then cast_preset_list(value)
+        end
+      end
+
+      private
+        # Blank rules read as absent: existing databases store allowed_values: [] for blank textareas.
+        def absent?(value)
+          value.nil? || (value.respond_to?(:empty?) && value.empty?)
+        end
+
+        def rule_violations(type_handle, allowed, key, value)
+          unless allowed.include?(key)
+            return [ Violation.new(attribute: :metadata, message: %(unknown validation "#{key}" for #{type_handle} (valid: #{allowed.join(', ')}))) ]
+          end
+
+          value_violations(key, value)
+        end
+
+        def value_violations(key, value)
+          case RULES.fetch(key).fetch(:kind)
+          when :boolean
+            [ Violation.new(attribute: key.to_sym, message: "must be true or false") ] unless value == true || value == false
+          when :positive_integer
+            [ Violation.new(attribute: key.to_sym, message: "must be a positive integer (omit the key instead of 0)") ] unless positive_integer?(value)
+          when :number
+            [ Violation.new(attribute: key.to_sym, message: "must be a number") ] unless value.is_a?(Numeric)
+          when :string_list
+            [ Violation.new(attribute: key.to_sym, message: "must be a non-empty array of distinct, non-blank strings") ] unless clean_string_list?(value)
+          when :file_scope
+            [ Violation.new(attribute: key.to_sym, message: %(must be "all" or "specific")) ] unless %w[all specific].include?(value)
+          when :preset_list
+            preset_list_violations(key, value)
+          end || []
+        end
+
+        def preset_list_violations(key, value)
+          unless value.is_a?(Array) && value.all? { |item| item.is_a?(String) }
+            return [ Violation.new(attribute: key.to_sym, message: "must be an array of file type presets (#{preset_keys.join(', ')})") ]
+          end
+
+          (value.uniq - preset_keys).map do |unknown|
+            Violation.new(attribute: key.to_sym, message: %(contains unknown file type "#{unknown}" (valid: #{preset_keys.join(', ')})))
+          end
+        end
+
+        def bound_violations(rules, allowed)
+          RULES.filter_map do |floor_key, rule|
+            ceiling_key = rule[:ceiling]
+            next unless ceiling_key && allowed.include?(floor_key)
+
+            floor, ceiling = rules[floor_key], rules[ceiling_key]
+            next unless comparable?(rule.fetch(:kind), floor) && comparable?(rule.fetch(:kind), ceiling)
+            next unless floor > ceiling
+
+            Violation.new(attribute: floor_key.to_sym, message: "(#{floor}) cannot exceed #{ceiling_key} (#{ceiling})")
+          end
+        end
+
+        def comparable?(kind, value)
+          kind == :positive_integer ? positive_integer?(value) : value.is_a?(Numeric)
+        end
+
+        def positive_integer?(value)
+          value.is_a?(Integer) && value >= 1
+        end
+
+        def clean_string_list?(value)
+          value.is_a?(Array) && value.any? &&
+            value.all? { |item| item.is_a?(String) && !item.empty? && item == item.strip } &&
+            value.uniq.size == value.size
+        end
+
+        def cast_boolean(value)
+          case value.to_s
+          when "" then nil
+          when "0", "f", "F", "false", "FALSE", "False", "off", "OFF" then false
+          when "1", "t", "T", "true", "TRUE", "True", "on", "ON" then true
+          else value
+          end
+        end
+
+        def cast_positive_integer(value)
+          case value
+          when Integer then value
+          when Float then value % 1 == 0 ? value.to_i : value
+          when String then value.strip.empty? ? nil : (Integer(value, exception: false) || value)
+          else value
+          end
+        end
+
+        def cast_number(value)
+          case value
+          when Numeric then value.to_f
+          when String then value.strip.empty? ? nil : (Float(value, exception: false) || value)
+          else value
+          end
+        end
+
+        def cast_string_list(value)
+          return value unless value.is_a?(Array) && value.all? { |item| item.is_a?(String) }
+
+          value.map(&:strip).reject(&:empty?).presence
+        end
+
+        def cast_file_scope(value)
+          scope = value.is_a?(Symbol) ? value.to_s : value
+          scope.is_a?(String) && scope.strip.empty? ? nil : scope
+        end
+
+        def cast_preset_list(value)
+          return value unless value.is_a?(Array) && value.all? { |item| item.is_a?(String) }
+
+          members = value.map(&:strip).reject(&:empty?)
+          return value unless (members - preset_keys).empty?
+
+          preset_keys & members
+        end
+
+        def preset_keys
+          FieldDefinitions::File::FILE_TYPE_PRESETS.keys
+        end
+    end
+  end
+end

data/app/models/iron/field_definition.rb

@@ -1,6 +1,6 @@
 module Iron
   class FieldDefinition < ApplicationRecord
-    include Ranked, Searchable, Exportable, Importable
+    include Ranked, Searchable, Validatable, Exportable, Importable, Schema::AutoDumpable
 
     TYPES = %w[text_field text_area rich_text_area number file boolean date block block_list reference_list reference].freeze
 

data/app/models/iron/field_definitions/date.rb

@@ -1,5 +1,7 @@
 module Iron
   class FieldDefinitions::Date < FieldDefinition
+    supports_validations :required
+
     def value_column
       :value_datetime
     end

data/app/models/iron/field_definitions/file.rb

@@ -28,7 +28,7 @@ module Iron
       }
     }.freeze
 
-    store_accessor :metadata, :file_scope, :selected_presets
+    supports_validations :required, :file_scope, :selected_presets
 
     def file_scope
       super || "all"
@@ -41,21 +41,13 @@ module Iron
     def accepted_extensions
       return nil if file_scope == "all"
 
-      extensions = []
-      selected_presets.each do |preset|
-        extensions.concat(FILE_TYPE_PRESETS[preset][:extensions]) if FILE_TYPE_PRESETS[preset]
-      end
-      extensions.uniq
+      selected_presets.flat_map { |preset| FILE_TYPE_PRESETS.dig(preset, :extensions) || [] }.uniq
     end
 
     def accepted_mime_types
       return nil if file_scope == "all"
 
-      mime_types = []
-      selected_presets.each do |preset|
-        mime_types.concat(FILE_TYPE_PRESETS[preset][:mime_types]) if FILE_TYPE_PRESETS[preset]
-      end
-      mime_types.uniq
+      selected_presets.flat_map { |preset| FILE_TYPE_PRESETS.dig(preset, :mime_types) || [] }.uniq
     end
 
     def validation_description

data/app/models/iron/field_definitions/number.rb

@@ -1,5 +1,7 @@
 module Iron
   class FieldDefinitions::Number < FieldDefinition
+    supports_validations :required, :min, :max
+
     def value_column
       :value_float
     end

data/app/models/iron/field_definitions/reference.rb

@@ -1,5 +1,7 @@
 module Iron
   class FieldDefinitions::Reference < FieldDefinition
+    supports_validations :required
+
     has_and_belongs_to_many :supported_content_types,
       class_name: "::Iron::ContentType",
       foreign_key: "field_definition_id",

data/app/models/iron/field_definitions/rich_text_area.rb

@@ -1,4 +1,5 @@
 module Iron
   class FieldDefinitions::RichTextArea < FieldDefinition
+    supports_validations :required
   end
 end

data/app/models/iron/field_definitions/text_area.rb

@@ -1,5 +1,7 @@
 module Iron
   class FieldDefinitions::TextArea < FieldDefinition
+    supports_validations :required, :min_length, :max_length
+
     def value_column
       :value_text
     end

data/app/models/iron/field_definitions/text_field.rb

@@ -1,6 +1,6 @@
 module Iron
   class FieldDefinitions::TextField < FieldDefinition
-    store_accessor :metadata, :allowed_values, :required
+    supports_validations :required, :allowed_values, :min_length, :max_length
 
     def allowed_values_text
       Array(allowed_values).join("\n")
@@ -10,14 +10,6 @@ module Iron
       self.allowed_values = text.to_s.lines.map(&:strip).reject(&:blank?)
     end
 
-    def required
-      ActiveModel::Type::Boolean.new.cast(super)
-    end
-
-    def required=(value)
-      super(ActiveModel::Type::Boolean.new.cast(value))
-    end
-
     def value_column
       :value_string
     end

data/app/models/iron/fields/block.rb

@@ -22,7 +22,11 @@ module Iron
 
       block_definition.field_definitions.each do |nested_def|
         raw = Field.content_fetch(value, nested_def.handle)
-        next if raw == CONTENT_MISSING
+
+        if raw == CONTENT_MISSING
+          fields.build(type: nested_def.field_type, entry: entry, definition: nested_def) if nested_def.required?
+          next
+        end
 
         field = fields.build(type: nested_def.field_type, entry: entry, definition: nested_def)
         field.content_value = raw

data/app/models/iron/fields/block_list.rb

@@ -32,7 +32,11 @@ module Iron
 
         block_def.field_definitions.each do |nested_def|
           raw = Field.content_fetch(block_data, nested_def.handle)
-          next if raw == CONTENT_MISSING
+
+          if raw == CONTENT_MISSING
+            block.fields.build(type: nested_def.field_type, entry: entry, definition: nested_def) if nested_def.required?
+            next
+          end
 
           field = block.fields.build(type: nested_def.field_type, entry: entry, definition: nested_def)
           field.content_value = raw

data/app/models/iron/fields/date.rb

@@ -1,16 +1,20 @@
 module Iron
   class Fields::Date < Field
+    TIME_DESIGNATOR = /[Tt ]/
+
     def content_value=(value)
       @content_errors = nil
       if value.blank?
         self.value_datetime = nil
       else
-        self.value_datetime = Time.iso8601(value.to_s)
+        self.value_datetime = parse_iso8601(value.to_s)
       end
     rescue ArgumentError
-      add_content_error("must be a valid ISO8601 datetime")
+      add_content_error("must be a valid ISO8601 date or datetime")
     end
 
+    def filled? = !value_datetime.nil?
+
     def value
       value_datetime
     end
@@ -18,5 +22,18 @@ module Iron
     def export_value
       { type: "date", value: value_datetime&.iso8601 }
     end
+
+    private
+
+      # A failed parse of a string with a time designator is a malformed
+      # datetime, not a date-only value — re-raise rather than letting the
+      # date fallback silently drop its time part.
+      def parse_iso8601(value)
+        Time.iso8601(value)
+      rescue ArgumentError
+        raise if value.match?(TIME_DESIGNATOR)
+
+        ::Date.iso8601(value).in_time_zone
+      end
   end
 end

data/app/models/iron/fields/file.rb

@@ -8,6 +8,8 @@ module Iron
       @content_errors = nil
       if value.nil?
         self.file = nil
+      elsif !value.is_a?(String)
+        add_content_error("must be an upload token (signed id)")
       elsif value.present?
         self.file = ActiveStorage::Blob.find_signed!(value)
       end
@@ -15,6 +17,8 @@ module Iron
       add_content_error("has an invalid upload token")
     end
 
+    def filled? = file.attached?
+
     def value
       file.attached? ? file : nil
     end
@@ -42,9 +46,7 @@ module Iron
       end
 
       def definition_restricts_file_type?
-        file.attached? &&
-        definition.file_scope == "specific" &&
-        definition.accepted_mime_types.present?
+        file.attached? && definition.accepted_mime_types.present?
       end
 
       def file_type_matches_restrictions

data/app/models/iron/fields/number.rb

@@ -1,9 +1,19 @@
 module Iron
   class Fields::Number < Field
+    validate :value_within_bounds
+
     def content_value=(value)
-      self.value_float = value
+      @content_errors = nil
+
+      if value.nil? || value.is_a?(Numeric) || numeric_string?(value)
+        self.value_float = value
+      else
+        add_content_error("must be a number")
+      end
     end
 
+    def filled? = !value_float.nil?
+
     def value
       value_float
     end
@@ -11,5 +21,22 @@ module Iron
     def export_value
       { type: "number", value: value_float }
     end
+
+    private
+
+      def value_within_bounds
+        return if value_float.nil?
+
+        errors.add(:base, :greater_than_or_equal_to, count: displayed_bound(definition.min)) if definition.min && value_float < definition.min
+        errors.add(:base, :less_than_or_equal_to, count: displayed_bound(definition.max)) if definition.max && value_float > definition.max
+      end
+
+      def numeric_string?(value)
+        value.is_a?(String) && !Float(value, exception: false).nil?
+      end
+
+      def displayed_bound(bound)
+        bound % 1 == 0 ? bound.to_i : bound
+      end
   end
 end

data/app/models/iron/fields/reference.rb

@@ -21,6 +21,8 @@ module Iron
       end
     end
 
+    def filled? = referenced_entry_id.present?
+
     def value
       if referenced_entry.present?
         OpenStruct.new(

data/app/models/iron/fields/rich_text_area.rb

@@ -8,6 +8,8 @@ module Iron
       self.rich_text = value
     end
 
+    def filled? = rich_text&.body.present?
+
     def searchable_text
       rich_text&.to_plain_text
     end

data/app/models/iron/fields/text_area.rb

@@ -1,9 +1,13 @@
 module Iron
   class Fields::TextArea < Field
+    include LengthConstrained
+
     def content_value=(value)
       self.value_text = value
     end
 
+    def filled? = value_text.present?
+
     def searchable_text
       value
     end

data/app/models/iron/fields/text_field.rb

@@ -1,11 +1,15 @@
 module Iron
   class Fields::TextField < Field
-    validate :validate_required_field
+    include LengthConstrained
+
+    validate :value_is_an_allowed_value
 
     def content_value=(value)
       self.value_string = value
     end
 
+    def filled? = value_string.present?
+
     def searchable_text
       value
     end
@@ -20,11 +24,11 @@ module Iron
 
     private
 
-      def validate_required_field
-        return unless definition.required
+      def value_is_an_allowed_value
+        return if value_string.blank? || definition.allowed_values.blank?
 
-        if value_string.blank?
-          errors.add(:base, :blank)
+        unless definition.allowed_values.include?(value_string)
+          errors.add(:base, "must be one of: #{definition.allowed_values.join(', ')}")
         end
       end
   end

data/app/models/iron/importer.rb

@@ -39,16 +39,7 @@ module Iron
       def import_schema(zip)
         return unless zip.find_entry("schema.json")
 
-        schema = read_schema(zip)
-
-        ActiveRecord::Base.transaction do
-          import_locales(schema[:locales] || [])
-          import_block_definitions(schema[:block_definitions] || [])
-          populate_block_field_definitions(schema[:block_definitions] || [])
-          import_content_types(schema[:content_types] || [])
-          resolve_content_type_references(schema[:content_types] || [])
-          restore_default_locale(schema[:default_locale])
-        end
+        Schema.import(read_schema(zip))
       end
 
       def import_content(zip, files_dir)
@@ -163,49 +154,5 @@ module Iron
       def parse_json(content)
         JSON.parse(content, symbolize_names: true)
       end
-
-      def import_locales(locales)
-        locales.each do |attrs|
-          Locale.find_or_create_by!(code: attrs[:code]) do |locale|
-            locale.name = attrs[:name]
-          end
-        end
-      end
-
-      def restore_default_locale(locale_code)
-        return unless locale_code
-
-        locale = Locale.find_by(code: locale_code)
-        Current.account.update!(default_locale: locale) if locale
-      end
-
-      def import_block_definitions(definitions)
-        definitions.each { |attrs| BlockDefinition.import_from_attributes(attrs) }
-      end
-
-      def populate_block_field_definitions(definitions)
-        definitions.each { |attrs| BlockDefinition.populate_field_definitions(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
-        end
-      end
   end
 end

data/app/models/iron/locale.rb

@@ -1,5 +1,7 @@
 module Iron
   class Locale < ApplicationRecord
+    include Schema::AutoDumpable
+
     validates :code, presence: true
     validates :name, presence: true
 

data/app/models/iron/schema/auto_dumpable.rb

@@ -0,0 +1,26 @@
+module Iron
+  module Schema::AutoDumpable
+    extend ActiveSupport::Concern
+
+    included do
+      after_save :note_iron_schema_change
+      after_destroy :note_iron_schema_change
+      after_commit :auto_dump_iron_schema
+      after_rollback :forget_iron_schema_change
+    end
+
+    private
+
+      def note_iron_schema_change
+        Iron::Schema.note_change
+      end
+
+      def auto_dump_iron_schema
+        Iron::Schema.auto_dump
+      end
+
+      def forget_iron_schema_change
+        Iron::Schema.forget_change
+      end
+  end
+end