iron-cms 0.1.0

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

@@ -0,0 +1,101 @@
+module Iron
+  module ContentType::FieldQueryable
+    def order_by_field(field_handle, direction = :asc)
+      content_type = proxy_association.owner
+      definition = content_type.field_definitions.find_by!(handle: field_handle)
+
+      table_alias = "order_field_for_#{field_handle}"
+      scope = joins("LEFT OUTER JOIN iron_fields AS #{table_alias} ON #{table_alias}.entry_id = iron_entries.id AND #{table_alias}.definition_id = #{definition.id}")
+      scope.order("#{table_alias}.#{definition.value_column}": direction)
+    end
+
+    def where_fields(conditions)
+      content_type = proxy_association.owner
+      scope = self
+      conditions.each do |handle, condition|
+        definition = content_type.field_definitions.find_by! handle: handle
+        field_scope = joins(:fields).where(iron_fields: { definition: })
+        field_scope = case condition
+        when Hash
+          apply_field_conditions(field_scope, definition.value_column, condition)
+        when Range
+          field_scope.where("iron_fields.#{definition.value_column} BETWEEN ? AND ?", condition)
+        when Array
+          field_scope.where("iron_fields.#{definition.value_column} IN (?)", condition)
+        else
+          field_scope.where("iron_fields.#{definition.value_column} = ?", condition)
+        end
+
+        scope = scope.merge(field_scope)
+      end
+
+      scope.distinct
+    end
+
+    def find_by_fields(conditions)
+      where_fields(conditions).first
+    end
+
+    def find_by_fields!(conditions)
+      record = find_by_fields(conditions)
+      raise ActiveRecord::RecordNotFound unless record.present?
+      record
+    end
+
+    def pluck_field(field_handle, distinct: false)
+      content_type = proxy_association.owner
+      definition = content_type.field_definitions.find_by! handle: field_handle
+
+      scope = definition.fields
+      scope = scope.distinct if distinct
+      scope.pluck(definition.value_column)
+    end
+
+    private
+
+      def apply_field_conditions(scope, column, conditions)
+        conditions.each do |op, value|
+          scope = case op.to_sym
+          when :eq
+            scope.where("iron_fields.#{column} = ?", value)
+          when :ne, :not
+            scope.where("iron_fields.#{column} != ?", value)
+          when :gt
+            scope.where("iron_fields.#{column} > ?", value)
+          when :gte
+            scope.where("iron_fields.#{column} >= ?", value)
+          when :lt
+            scope.where("iron_fields.#{column} < ?", value)
+          when :lte
+            scope.where("iron_fields.#{column} <= ?", value)
+          when :like
+            scope.where("iron_fields.#{column} LIKE ?", "%#{value}%")
+          when :not_like
+            scope.where("iron_fields.#{column} NOT LIKE ?", "%#{value}%")
+          when :starts_with
+            scope.where("iron_fields.#{column} LIKE ?", "#{value}%")
+          when :ends_with
+            scope.where("iron_fields.#{column} LIKE ?", "%#{value}")
+          when :in
+            scope.where("iron_fields.#{column} IN (?)", value)
+          when :not_in
+            scope.where("iron_fields.#{column} NOT IN (?)", value)
+          when :blank
+            if value
+              scope.where("iron_fields.#{column} IS NULL OR iron_fields.#{column} = ''")
+            else
+              scope.where("iron_fields.#{column} IS NOT NULL AND iron_fields.#{column} != ''")
+            end
+          when :present
+            if value
+              scope.where("iron_fields.#{column} IS NOT NULL AND iron_fields.#{column} != ''")
+            else
+              scope.where("iron_fields.#{column} IS NULL OR iron_fields.#{column} = ''")
+            end
+          else
+              raise ArgumentError, "Unknown operator: #{op}"
+          end
+        end
+      end
+  end
+end

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

@@ -0,0 +1,30 @@
+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/content_type/titlable.rb

@@ -0,0 +1,13 @@
+module Iron
+  module ContentType::Titlable
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :title_field_definition, class_name: "Iron::FieldDefinition", optional: true
+    end
+
+    def titlable_definitions
+      field_definitions.where(type: [ Iron::FieldDefinitions::TextField ])
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Iron
+  module ContentType::WebPublishable
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :web_page_title_field_definition, class_name: "FieldDefinition", optional: true
+
+      validates :base_path, format: { with: /\A[a-z0-9\-\/]*\z/, message: "can only contain lowercase letters, numbers, hyphens and slashes" }, allow_blank: true
+
+      scope :web_published, -> { where(web_publishing_enabled: true) }
+
+      after_save :generate_entries_routes, if: -> { saved_change_to_web_publishing_enabled? && web_publishing_enabled? }
+      after_save :reload_routes!, if: :should_reload_routes?
+      after_destroy :reload_routes!, if: :web_publishing_enabled?
+    end
+
+    def path_for(entry)
+      return nil unless web_publishing_enabled?
+
+      path_parts = []
+      path_parts << base_path if base_path.present?
+      path_parts << entry.route
+
+      "/" + path_parts.compact.join("/")
+    end
+
+    def index_entry
+      entries.find_by(route: "")
+    end
+
+    private
+
+      def generate_entries_routes
+        GenerateEntryRoutesJob.perform_later(self)
+      end
+
+      def should_reload_routes?
+        saved_change_to_web_publishing_enabled? ||
+        saved_change_to_base_path? ||
+        (web_publishing_enabled? && saved_change_to_handle?)
+      end
+
+      def reload_routes!
+        Rails.application.reload_routes!
+      end
+  end
+end

data/app/models/iron/content_type.rb

@@ -0,0 +1,39 @@
+module Iron
+  class ContentType < ApplicationRecord
+    include Titlable, WebPublishable, Portable
+
+    TYPES = %w[Single Collection].freeze
+
+    validates :name, presence: true
+    validates :handle, presence: true
+
+    has_many :field_definitions, -> { ranked }, as: :schemable, dependent: :destroy
+
+    has_many :entries, -> { extending FieldQueryable }, dependent: :destroy
+
+    class << self
+      def classify_type(type)
+        "Iron::ContentTypes::#{type}"
+      end
+
+      def inherited(subclass)
+        super
+        def subclass.model_name
+          superclass.model_name
+        end
+      end
+    end
+
+    def humanized_type
+      type.demodulize
+    end
+
+    def single?
+      is_a?(ContentTypes::Single)
+    end
+
+    def collection?
+      is_a?(ContentTypes::Collection)
+    end
+  end
+end

data/app/models/iron/content_types/collection.rb

@@ -0,0 +1,6 @@
+module Iron
+  module ContentTypes
+    class Collection < ContentType
+    end
+  end
+end

data/app/models/iron/content_types/single.rb

@@ -0,0 +1,9 @@
+module Iron
+  module ContentTypes
+    class Single < ContentType
+      def entry
+        entries.first || entries.build
+      end
+    end
+  end
+end

data/app/models/iron/current.rb

@@ -0,0 +1,12 @@
+module Iron
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :session
+    delegate :user, to: :session, allow_nil: true
+
+    attribute :locale
+
+    def account
+      Account.first
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# ActiveStorage file attachments in deeply nested associations don't properly prevent parent records
+# from saving when validation fails. This is a Rails quirk where attachment validations don't bubble
+# up through nested attributes. This concern recursively checks all nested fields for validation
+# errors and prevents the Entry from saving if any file validations fail.
+
+module Iron
+  class Entry
+    module DeepValidation
+      extend ActiveSupport::Concern
+
+      included do
+        validate :all_fields_are_valid
+      end
+
+      private
+
+        def all_fields_are_valid
+          any_invalid = false
+          walk = lambda do |field|
+            any_invalid ||= field.invalid?
+            if field.is_a?(Iron::Fields::BlockList)
+              field.blocks.each { |b| b.fields.each { |f| walk.call(f) } }
+            elsif field.is_a?(Iron::Fields::Block)
+              field.fields.each { |f| walk.call(f) }
+            end
+          end
+          fields.select { |f| f.parent.nil? }.each { |f| walk.call(f) }
+          errors.add(:base, "One or more fields are invalid") if any_invalid
+        end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Iron
+  module Entry::Presentable
+    extend ActiveSupport::Concern
+
+    def attributes
+      locale = Iron::Current.locale || Iron::Locale.default
+
+      Rails.cache.fetch("#{cache_key_with_version}/#{locale.code}/attributes") do
+        result = OpenStruct.new(id: id)
+
+        result._metadata = OpenStruct.new(
+          locale: locale,
+          web: OpenStruct.new(
+            title: web_title,
+            path: path
+          )
+        )
+
+        content_type.field_definitions.each do |field_definition|
+          field = find_field_for_presentation(field_definition, locale)
+          result[field_definition.handle] = field&.value
+        end
+
+        result
+      end
+    end
+
+    private
+
+
+      def find_field_for_presentation(field_definition, locale)
+        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 &&
+          f.parent.nil?
+        end
+      end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Iron
+  module Entry::Schemable
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :content_type
+
+      scope :with_content_type, ->(types) {
+        ids = Array(types).map do |ct|
+          ct.is_a?(Iron::ContentType) ? ct.id : ct
+        end
+        where(content_type_id: ids)
+      }
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Iron
+  module Entry::Titlable
+    extend ActiveSupport::Concern
+
+    included do
+      scope :search_by_title, ->(query, locale = nil) {
+        locale ||= Iron::Locale.default
+
+        joins(:fields)
+          .joins(:content_type)
+          .where("iron_content_types.title_field_definition_id = iron_fields.definition_id")
+          .where("iron_fields.locale_id = ?", locale.id)
+          .where("iron_fields.value_string LIKE ?", "%#{query}%")
+      }
+    end
+
+    def title
+      return default_title if title_field.blank?
+
+      title_field.value.presence || default_title
+    end
+
+    private
+
+      def title_field
+        return nil unless content_type.title_field_definition.present?
+
+        @title_field ||= fields.find_by(definition: content_type.title_field_definition)
+      end
+
+      def default_title
+        "#{content_type.name} #{id}"
+      end
+  end
+end

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

@@ -0,0 +1,85 @@
+module Iron
+  module Entry::WebPublishable
+    extend ActiveSupport::Concern
+
+    included do
+      before_validation :generate_route, if: :should_generate_route?
+      before_validation :normalize_route
+
+      validates :route, uniqueness: { scope: :content_type_id, allow_blank: true }, if: :route_required?
+      validates :route, format: { with: /\A[a-z0-9\-\/]*\z/, message: "can only contain lowercase letters, numbers, hyphens and slashes" }, allow_blank: true
+      validate :index_route_uniqueness, if: :use_as_index
+    end
+
+    def use_as_index=(value)
+      if ActiveModel::Type::Boolean.new.cast(value)
+        self.route = ""
+      elsif route.blank?
+        self.route = nil
+      end
+    end
+
+    def use_as_index
+      route == ""
+    end
+
+    def web_title
+      return nil unless content_type.web_page_title_field_definition
+
+      title_field = fields.find_by(
+        definition: content_type.web_page_title_field_definition,
+        locale: Iron::Locale.default
+      ) || fields.detect { |f|
+        f.definition_id == content_type.web_page_title_field_definition_id &&
+        f.locale == Iron::Locale.default
+      }
+
+      title_field&.value
+    end
+
+    def path
+      content_type.path_for(self) if content_type.web_publishing_enabled?
+    end
+
+    private
+
+      def should_generate_route?
+        content_type.web_publishing_enabled? && route.nil?
+      end
+
+      def route_required?
+        content_type.web_publishing_enabled?
+      end
+
+      def generate_route
+        return unless web_title.present?
+
+        base_handle = web_title.parameterize
+        handle = base_handle
+        counter = 1
+
+        while Entry.where(content_type: content_type, route: handle).where.not(id: id).exists?
+          handle = "#{base_handle}-#{counter}"
+          counter += 1
+        end
+
+        self.route = handle
+      end
+
+      def normalize_route
+        return if route.blank?
+
+        self.route = route.downcase
+          .gsub(/[^a-z0-9\-\/]+/, "-")  # Replace non-allowed chars with hyphens
+          .gsub(/\-+/, "-")              # Replace multiple hyphens with single hyphen
+          .gsub(/\A[\-\/]+|[\-\/]+\z/, "")  # Remove leading/trailing hyphens and slashes
+      end
+
+
+      def index_route_uniqueness
+        if content_type.index_entry && content_type.index_entry.id != id
+          errors.add(:use_as_index, "is already taken - another entry is already set as the index page")
+        end
+      end
+  end
+end

data/app/models/iron/entry.rb

@@ -0,0 +1,16 @@
+module Iron
+  class Entry < ApplicationRecord
+    include Titlable, Schemable, WebPublishable, Presentable, DeepValidation
+
+    belongs_to :creator, class_name: "Iron::User", default: -> { Current.user }
+    has_many :fields, inverse_of: :entry, dependent: :destroy
+
+    accepts_nested_attributes_for :fields, allow_destroy: true
+
+    def find_or_build_field(definition, locale)
+      field = fields.find { |f| f.definition == definition && f.locale == locale } ||
+              fields.build(type: definition.field_type, definition:, locale:)
+      field
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Iron
+  module Field::BelongsToEntry
+    extend ActiveSupport::Concern
+
+    included do
+      after_save :ensure_entry
+
+      belongs_to :entry, inverse_of: :fields, optional: true, touch: true
+    end
+
+    private
+
+      def ensure_entry
+        return if entry_id.present?
+
+        current_parent = parent
+
+        while current_parent.present?
+          if current_parent.entry_id.present?
+            update_column(:entry_id, current_parent.entry_id)
+            break
+          end
+          current_parent = current_parent.parent
+        end
+
+        raise "Field must be bound to an entry" unless entry_id.present?
+      end
+  end
+end

data/app/models/iron/field.rb

@@ -0,0 +1,20 @@
+module Iron
+  class Field < ApplicationRecord
+    include BelongsToEntry
+
+    TYPES = %w[text_field text_area rich_text_area number file boolean date block block_list reference_list reference].freeze
+
+    belongs_to :definition, polymorphic: true
+    belongs_to :locale
+    belongs_to :parent, polymorphic: true, optional: true, touch: true
+
+
+    def type_handle
+      type.demodulize.underscore
+    end
+
+    def value
+      raise "Field type '#{type}' value method not supported"
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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]
+      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
+      ]
+    end
+
+    private
+
+    def export_supported_block_definitions
+      return nil unless respond_to?(:supported_block_definitions)
+      supported_block_definitions.pluck(:handle).join("|")
+    end
+  end
+end

data/app/models/iron/field_definition.rb

@@ -0,0 +1,42 @@
+module Iron
+  class FieldDefinition < ApplicationRecord
+    include Portable
+
+    TYPES = %w[text_field text_area rich_text_area number file boolean date block block_list reference_list reference].freeze
+
+    belongs_to :schemable, polymorphic: true
+
+    has_rank scoped_by: :schemable
+    before_create :move_to_bottom
+
+    has_many :fields, as: :definition, inverse_of: :definition, dependent: :destroy
+
+    has_one :titlable_content_type, class_name: "Iron::ContentType", inverse_of: :title_field_definition, dependent: :nullify
+    has_one :web_publishable_content_type, class_name: "Iron::ContentType", foreign_key: :web_page_title_field_definition_id, inverse_of: :web_page_title_field_definition, dependent: :nullify
+
+    validates :name, presence: true
+    validates :handle, presence: true
+
+    class << self
+      def classify_type(type)
+        "Iron::FieldDefinitions::#{type.classify}"
+      end
+    end
+
+    def humanized_type
+      type.demodulize.humanize
+    end
+
+    def type_handle
+      type.demodulize.underscore
+    end
+
+    def field_type
+      "Iron::Fields::#{type.demodulize}"
+    end
+
+    def value_column
+      raise "value_column not implemented by '#{type}'"
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Iron
+  class FieldDefinitions::Block < FieldDefinition
+    has_and_belongs_to_many :supported_block_definitions,
+      class_name: "::Iron::BlockDefinition",
+      foreign_key: "field_definition_id",
+      association_foreign_key: "block_definition_id"
+
+    validate :validate_exactly_one_supported_block_definition
+
+    def supported_block_definition
+      supported_block_definitions.first
+    end
+
+    def supported_block_definition_id
+      supported_block_definition&.id
+    end
+
+    private
+      def validate_exactly_one_supported_block_definition
+        errors.add(:supported_block_definitions, "must have exactly one supported block definition") unless supported_block_definitions.size == 1
+      end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Iron
+  class FieldDefinitions::BlockList < FieldDefinition
+    has_and_belongs_to_many :supported_block_definitions,
+      class_name: "::Iron::BlockDefinition",
+      foreign_key: "field_definition_id",
+      association_foreign_key: "block_definition_id"
+  end
+end

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

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

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

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