iron-cms 0.1.0

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

@@ -0,0 +1,67 @@
+module Iron
+  class FieldDefinitions::File < FieldDefinition
+    FILE_TYPE_PRESETS = {
+      "images" => {
+        extensions: %w[jpg jpeg png gif webp svg heic],
+        mime_types: %w[image/jpeg image/png image/gif image/webp image/svg+xml image/heic]
+      },
+      "videos" => {
+        extensions: %w[mp4 mov avi webm],
+        mime_types: %w[video/mp4 video/quicktime video/x-msvideo video/webm]
+      },
+      "documents" => {
+        extensions: %w[pdf doc docx xls xlsx ppt pptx txt],
+        mime_types: %w[
+          application/pdf
+          application/msword
+          application/vnd.openxmlformats-officedocument.wordprocessingml.document
+          application/vnd.ms-excel
+          application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+          application/vnd.ms-powerpoint
+          application/vnd.openxmlformats-officedocument.presentationml.presentation
+          text/plain
+        ]
+      },
+      "audio" => {
+        extensions: %w[mp3 wav ogg m4a],
+        mime_types: %w[audio/mpeg audio/wav audio/ogg audio/mp4]
+      }
+    }.freeze
+
+    store_accessor :metadata, :file_scope, :selected_presets
+
+    def file_scope
+      super || "all"
+    end
+
+    def selected_presets
+      super || []
+    end
+
+    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
+    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
+    end
+
+    def validation_description
+      return "All file types accepted" if file_scope == "all"
+
+      "Accepted formats: #{accepted_extensions.join(', ')}" if accepted_extensions.present?
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Iron
+  class FieldDefinitions::Number < FieldDefinition
+    def value_column
+      :value_float
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Iron
+  class FieldDefinitions::Reference < FieldDefinition
+    has_and_belongs_to_many :supported_content_types,
+      class_name: "::Iron::ContentType",
+      foreign_key: "field_definition_id",
+      association_foreign_key: "content_type_id"
+  end
+end

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

@@ -0,0 +1,8 @@
+module Iron
+  class FieldDefinitions::ReferenceList < FieldDefinition
+    has_and_belongs_to_many :supported_content_types,
+      class_name: "::Iron::ContentType",
+      foreign_key: "field_definition_id",
+      association_foreign_key: "content_type_id"
+  end
+end

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

@@ -0,0 +1,4 @@
+module Iron
+  class FieldDefinitions::RichTextArea < FieldDefinition
+  end
+end

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

@@ -0,0 +1,7 @@
+module Iron
+  class FieldDefinitions::TextArea < FieldDefinition
+    def value_column
+      :value_text
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Iron
+  class FieldDefinitions::TextField < FieldDefinition
+    store_accessor :metadata, :allowed_values, :required
+
+    def allowed_values_text
+      Array(allowed_values).join("\n")
+    end
+
+    def allowed_values_text=(text)
+      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
+  end
+end

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

@@ -0,0 +1,40 @@
+module Iron
+  class Fields::Block < Field
+    has_many :fields, as: :parent, inverse_of: :parent, dependent: :destroy
+    accepts_nested_attributes_for :fields, allow_destroy: true
+
+    has_rank scoped_by: :parent
+
+    def block_list
+      parent.is_a?(Iron::Fields::BlockList) ? parent : nil
+    end
+
+    def find_or_build_field(definition)
+      fields.find { |f| f.definition == definition } || fields.build(type: definition.field_type, entry:, definition: definition, locale:)
+    end
+
+    def value
+      locale = Iron::Current.locale || Iron::Locale.default
+
+      block_definition = if definition.is_a?(Iron::FieldDefinitions::Block)
+        definition.supported_block_definition
+      else
+        definition
+      end
+
+      result = OpenStruct.new(id: id, _type: block_definition.handle)
+
+      block_definition.field_definitions.each do |field_definition|
+        field = fields.find do |f|
+          f.definition_id == field_definition.id &&
+          f.definition_type == field_definition.class.base_class.to_s &&
+          f.locale_id == locale.id
+        end
+
+        result[field_definition.handle] = field&.value
+      end
+
+      result
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Iron
+  class Fields::BlockList < Field
+    has_many :blocks, -> { ranked }, as: :parent, inverse_of: :parent, dependent: :destroy do
+      def build_for(block_definition)
+        block_list = proxy_association.owner
+        build(entry: block_list.entry, definition: block_definition, locale: block_list.locale)
+      end
+    end
+
+    accepts_nested_attributes_for :blocks, allow_destroy: true
+
+    def value
+      blocks.map(&:value)
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Iron
+  class Fields::Boolean < Field
+    def value
+      value_boolean
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Iron
+  class Fields::Date < Field
+    def value
+      value_datetime
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Iron
+  class Fields::File < Field
+    has_one_attached :file
+
+    validate :file_type_matches_restrictions, if: :definition_restricts_file_type?
+
+    def value
+      file.attached? ? file : nil
+    end
+
+    def image?
+      file.attached? && file.blob.content_type&.start_with?("image/")
+    end
+
+    private
+
+      def definition_restricts_file_type?
+        file.attached? &&
+        definition.file_scope == "specific" &&
+        definition.accepted_mime_types.present?
+      end
+
+      def file_type_matches_restrictions
+        unless file.content_type.in? definition.accepted_mime_types
+          errors.add(:base, "must be one of the accepted formats: #{definition.accepted_extensions.join(', ')}")
+        end
+      end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Iron
+  class Fields::Number < Field
+    def value
+      value_float
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Iron
+  class Fields::Reference < Field
+    belongs_to :referenced_entry, class_name: "Iron::Entry", optional: true
+
+    def value
+      if referenced_entry.present?
+        OpenStruct.new(
+          id: referenced_entry_id,
+          _type: referenced_entry.content_type.handle
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Iron
+  class Fields::ReferenceList < Field
+    has_many :references, -> { ranked }, foreign_key: :list_id, dependent: :destroy, class_name: "Iron::Reference", inverse_of: "list"
+    has_many :entries, through: :references
+
+    accepts_nested_attributes_for :references, allow_destroy: true
+
+    def value
+      references.map do |reference|
+        OpenStruct.new(
+          id: reference.entry_id,
+          _type: reference.entry.content_type.handle
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Iron
+  class Fields::RichTextArea < Field
+    has_rich_text :rich_text
+
+    def value
+      rich_text&.to_s
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Iron
+  class Fields::TextArea < Field
+    def value
+      value_text
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Iron
+  class Fields::TextField < Field
+    validate :validate_required_field
+
+    def value
+      value_string
+    end
+
+    private
+
+      def validate_required_field
+        return unless definition.required
+
+        if value_string.blank?
+          errors.add(:base, :blank)
+        end
+      end
+  end
+end

data/app/models/iron/first_run.rb

@@ -0,0 +1,13 @@
+module Iron
+  class FirstRun
+    ACCOUNT_NAME = "Iron"
+
+    def self.create!(user_params)
+      english_locale = Locale.create!(code: "en", name: "English")
+
+      account = Account.create!(name: ACCOUNT_NAME, default_locale: english_locale)
+
+      User.create!(user_params.merge(role: :administrator))
+    end
+  end
+end

data/app/models/iron/icon_catalog.rb

@@ -0,0 +1,45 @@
+module Iron
+  class IconCatalog
+    class << self
+      def all
+        @cached_icons ||= parse_sprite_icons
+      end
+
+      def clear_cache!
+        @cached_icons = nil
+      end
+
+      def refresh!
+        clear_cache!
+        all
+      end
+
+      def include?(icon_name)
+        all.include?(icon_name.to_s)
+      end
+
+      def cache_key
+        raise "Icon sprite file not found at #{sprite_file_path}" unless File.exist?(sprite_file_path)
+
+        mtime = File.mtime(sprite_file_path).to_i
+        "iron/icon_catalog/#{mtime}"
+      end
+
+      private
+
+        def parse_sprite_icons
+          return [] unless File.exist?(sprite_file_path)
+
+          sprite_content = File.read(sprite_file_path)
+          sprite_content.scan(/id="([^"]+)"/).flatten.sort
+        rescue => e
+          Rails.logger.warn "Failed to parse icon sprite: #{e.message}"
+          []
+        end
+
+        def sprite_file_path
+          Iron::Engine.root.join("app", "assets", "images", "iron", "icons", "sprite.svg")
+        end
+    end
+  end
+end

data/app/models/iron/locale.rb

@@ -0,0 +1,30 @@
+module Iron
+  class Locale < ApplicationRecord
+    validates :code, presence: true
+    validates :name, presence: true
+
+    before_destroy :ensure_not_default_locale
+
+    def self.detect(request)
+      locale_param = request.params[:locale]
+      Locale.find_by(code: locale_param) if locale_param.present?
+    end
+
+    def self.default
+      Account.first&.default_locale
+    end
+
+    def default?
+      self == Locale.default
+    end
+
+    private
+
+      def ensure_not_default_locale
+        if default?
+          errors.add(:base, "Cannot delete locale while it is set as default for an account")
+          throw :abort
+        end
+      end
+  end
+end

data/app/models/iron/reference.rb

@@ -0,0 +1,8 @@
+module Iron
+  class Reference < ApplicationRecord
+    belongs_to :entry
+    belongs_to :list, class_name: "Iron::Fields::ReferenceList", inverse_of: "references"
+
+    has_rank scoped_by: :list_id
+  end
+end

data/app/models/iron/schema_archive.rb

@@ -0,0 +1,71 @@
+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
+            end
+          end
+        end
+      rescue StandardError => e
+        @errors << "Failed to extract tar archive: #{e.message}"
+      end
+  end
+end

data/app/models/iron/schema_exporter.rb

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