iron-cms 0.1.0

data/db/migrate/20250427100754_create_iron_accounts.rb

@@ -0,0 +1,10 @@
+class CreateIronAccounts < ActiveRecord::Migration[8.0]
+  def change
+    create_table :iron_accounts do |t|
+      t.string :name, null: false
+      t.string :join_code, null: false
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20250427104020_add_role_to_iron_users.rb

@@ -0,0 +1,5 @@
+class AddRoleToIronUsers < ActiveRecord::Migration[8.0]
+  def change
+    add_column :iron_users, :role, :string, null: false, default: "member"
+  end
+end

data/db/migrate/20250428094923_add_default_iron_locale_to_iron_account.rb

@@ -0,0 +1,5 @@
+class AddDefaultIronLocaleToIronAccount < ActiveRecord::Migration[8.0]
+  def change
+    add_reference :iron_accounts, :default_locale, null: false, foreign_key: { to_table: :iron_locales }
+  end
+end

data/db/migrate/20250504144731_create_join_table_content_types_field_definitions.rb

@@ -0,0 +1,25 @@
+class CreateJoinTableContentTypesFieldDefinitions < ActiveRecord::Migration[8.0]
+  def change
+    # create_join_table :content_types, :field_definitions do |t|
+    #   # t.index [:content_type_id, :field_definition_id]
+    #   # t.index [:field_definition_id, :content_type_id]
+    # end
+    #
+    # create_table "iron_content_types_field_definitions", id: false, force: :cascade do |t|
+    #   t.integer "content_type_id", null: false
+    #   t.integer "field_definition_id", null: false
+    #   t.index [ "content_type_id", "field_definition_id" ], name: "idx_on_block_definition_id_field_definition_id_b671d92478", unique: true
+    #   t.index [ "content_type_id" ], name: "idx_on_block_definition_id_601f892a8c"
+    #   t.index [ "field_definition_id", "block_definition_id" ], name: "idx_on_field_definition_id_block_definition_id_be1c71c596", unique: true
+    #   t.index [ "field_definition_id" ], name: "idx_on_field_definition_id_d46765b01a"
+    # end
+
+    create_join_table :content_types, :field_definitions, table_name: :iron_content_types_field_definitions do |t|
+      t.index [ :content_type_id, :field_definition_id ], name: "idx_on_content_type_id_field_definition_id", unique: true
+      t.index [ :field_definition_id, :content_type_id ], name: "idx_on_field_definition_id_content_type_id", unique: true
+    end
+
+    add_foreign_key :iron_content_types_field_definitions, :iron_content_types, column: :content_type_id
+    add_foreign_key :iron_content_types_field_definitions, :iron_field_definitions, column: :field_definition_id
+  end
+end

data/db/migrate/20250505090716_add_title_field_definition_to_iron_content_types.rb

@@ -0,0 +1,5 @@
+class AddTitleFieldDefinitionToIronContentTypes < ActiveRecord::Migration[8.0]
+  def change
+    add_reference :iron_content_types, :title_field_definition, foreign_key: { to_table: :iron_field_definitions }
+  end
+end

data/db/migrate/20250512210352_create_iron_references.rb

@@ -0,0 +1,11 @@
+class CreateIronReferences < ActiveRecord::Migration[8.0]
+  def change
+    create_table :iron_references do |t|
+      t.references :entry, null: false, foreign_key: { to_table: :iron_entries }
+      t.references :list, null: false, foreign_key: { to_table: :iron_fields }
+      t.text :rank
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20250524220355_add_referenced_entry_id_to_iron_fields.rb

@@ -0,0 +1,5 @@
+class AddReferencedEntryIdToIronFields < ActiveRecord::Migration[8.0]
+  def change
+    add_reference :iron_fields, :referenced_entry, foreign_key: { to_table: :iron_entries }
+  end
+end

data/db/migrate/20250529211703_add_metadata_to_iron_field_definitions.rb

@@ -0,0 +1,5 @@
+class AddMetadataToIronFieldDefinitions < ActiveRecord::Migration[8.0]
+  def change
+    add_column :iron_field_definitions, :metadata, :jsonb, default: {}, null: false
+  end
+end

data/db/migrate/20250529211704_add_value_boolean_to_iron_fields.rb

@@ -0,0 +1,5 @@
+class AddValueBooleanToIronFields < ActiveRecord::Migration[8.0]
+  def change
+    add_column :iron_fields, :value_boolean, :boolean
+  end
+end

data/db/migrate/20250531172837_add_type_to_iron_content_types.rb

@@ -0,0 +1,5 @@
+class AddTypeToIronContentTypes < ActiveRecord::Migration[8.0]
+  def change
+    add_column :iron_content_types, :type, :string, default: "Iron::ContentTypes::Collection", null: false
+  end
+end

data/db/migrate/20250601080146_add_icon_to_iron_content_types.rb

@@ -0,0 +1,5 @@
+class AddIconToIronContentTypes < ActiveRecord::Migration[8.0]
+  def change
+    add_column :iron_content_types, :icon, :string
+  end
+end

data/db/migrate/20250609091605_add_web_publishing_to_iron_content_types.rb

@@ -0,0 +1,7 @@
+class AddWebPublishingToIronContentTypes < ActiveRecord::Migration[8.0]
+  def change
+    add_column :iron_content_types, :web_publishing_enabled, :boolean, default: false
+    add_reference :iron_content_types, :web_page_title_field_definition, null: true, foreign_key: { to_table: :iron_field_definitions }
+    add_column :iron_content_types, :base_path, :string
+  end
+end

data/db/migrate/20250609091813_add_route_to_iron_entries.rb

@@ -0,0 +1,6 @@
+class AddRouteToIronEntries < ActiveRecord::Migration[8.0]
+  def change
+    add_column :iron_entries, :route, :string
+    add_index :iron_entries, [ :content_type_id, :route ], unique: true
+  end
+end

data/lib/generators/iron/pages/pages_generator.rb

@@ -0,0 +1,34 @@
+require "rails/generators"
+
+module Iron
+  module Generators
+    class PagesGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def create_controller
+        template "pages_controller.rb", "app/controllers/pages_controller.rb"
+      end
+
+      def create_views
+        template "show.html.erb", "app/views/pages/show.html.erb"
+      end
+
+      def add_routes
+        route "iron_pages"
+      end
+
+      def display_instructions
+        say "\n=== Iron CMS Pages Setup Complete ===\n", :green
+        say "The pages controller has been installed in your application.\n"
+        say "\nNext steps:"
+        say "1. Create custom views for your content types in app/views/templates/"
+        say "   For a content type with handle 'article', create:"
+        say "   - app/views/templates/article.html.erb"
+        say "\n2. The default view (app/views/pages/show.html.erb) will be used"
+        say "   for any content types without custom views."
+        say "\n3. The iron_entry_path helper is available from the Iron engine."
+        say "\n4. Remember to restart your Rails server after installation."
+      end
+    end
+  end
+end

data/lib/generators/iron/pages/templates/pages_controller.rb

@@ -0,0 +1,14 @@
+class PagesController < ApplicationController
+  include Iron::LocaleAware
+
+  def show
+    @content_type = Iron::ContentType.web_published.find_by_handle!(params[:content_type])
+    @entry = Iron::SDK.send(@content_type.handle).find(params[:route])
+
+    raise ActiveRecord::RecordNotFound unless @entry
+
+    render "templates/#{@content_type.handle}"
+  rescue ActionView::MissingTemplate
+    render "pages/show"
+  end
+end

data/lib/generators/iron/pages/templates/show.html.erb

@@ -0,0 +1,9 @@
+<h1><%%= @entry._metadata.web.title %></h1>
+
+<hr>
+
+<p>
+  This is the default Iron CMS view. To create a custom view for this content type, create:
+</p>
+
+<pre><code>app/views/templates/<%%= @content_type.handle %>.html.erb</code></pre>

data/lib/generators/iron/template/template_generator.rb

@@ -0,0 +1,35 @@
+require "rails/generators"
+
+module Iron
+  module Generators
+    class TemplateGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      argument :content_type_handle, type: :string, desc: "The handle of the content type"
+
+      def create_template_file
+        @content_type = Iron::ContentType.find_by!(handle: content_type_handle)
+        template "content_type.html.erb", "app/views/templates/#{content_type_handle}.html.erb"
+      end
+
+      def display_instructions
+        say "\n=== Template created for '#{content_type_name}' ===\n", :green
+        say "You can now customize the template at:"
+        say "  app/views/templates/#{content_type_handle}.html.erb"
+        say "\nAvailable variables in the template:"
+        say "  @entry - The current entry with all its fields"
+        say "  @content_type - The content type definition"
+      end
+
+      private
+
+        def content_type_name
+          @content_type.name
+        end
+
+        def content_type_fields
+          @content_type.fields
+        end
+    end
+  end
+end

data/lib/generators/iron/template/templates/content_type.html.erb

@@ -0,0 +1,5 @@
+<h1><%%= @entry.attributes._metadata.web.title %></h1>
+
+<p>
+  Edit this template in <code>app/views/templates/<%= content_type_handle %>.html.erb</code>
+</p>

data/lib/iron/cva.rb

@@ -0,0 +1,69 @@
+module Iron
+  module Cva
+    class VariantBuilder
+      def initialize(base_classes: "", variants: {}, defaults: {}, compound_variants: [], required: [])
+        @base_classes = base_classes.split(" ")
+        @variants = normalize_keys(variants)
+        @defaults = normalize_keys(defaults)
+        @compound_variants = compound_variants.map { |cv| normalize_keys(cv) }
+        @required = required.map(&:to_sym)
+      end
+
+      def call(options = {})
+        options = normalize_keys(options)
+        additional_classes = options.delete(:class)&.split(" ") || []
+        classes = @base_classes.dup
+
+        # Apply default variants
+        options = @defaults.merge(options)
+
+        # Apply variants
+        @variants.each do |variant_name, variant_options|
+          if value = options[variant_name]
+            # Convert the value to symbol if the variant options use symbol keys
+            value = value.to_sym if variant_options.keys.first.is_a?(Symbol)
+            if variant_classes = variant_options[value]
+              classes.concat(variant_classes.split(" "))
+            end
+          end
+        end
+
+        # Apply compound variants
+        @compound_variants.each do |compound|
+          conditions = compound.except(:class)
+          matches = conditions.all? do |key, expected_value|
+            actual_value = options[key]
+            # Convert values to the same type for comparison
+            if expected_value.is_a?(Symbol)
+              actual_value = actual_value.to_sym if actual_value
+            elsif expected_value.is_a?(String)
+              actual_value = actual_value.to_s if actual_value
+            end
+            actual_value == expected_value
+          end
+
+          if matches && compound[:class]
+            classes.concat(compound[:class].split(" "))
+          end
+        end
+
+        # Validate required variants
+        @required.each do |required_variant|
+          unless options.key?(required_variant)
+            raise ArgumentError, "Missing required variant: #{required_variant}"
+          end
+        end
+
+        result = classes.uniq
+        result.concat(additional_classes)
+        result.join(" ")
+      end
+
+      private
+
+      def normalize_keys(hash)
+        hash.transform_keys(&:to_sym)
+      end
+    end
+  end
+end

data/lib/iron/engine.rb

@@ -0,0 +1,42 @@
+require "importmap-rails"
+require "turbo-rails"
+require "stimulus-rails"
+require "active_storage/engine"
+require "action_text/engine"
+require "bcrypt"
+require "ostruct"
+require "iron/lexorank"
+require "iron/sdk"
+require "iron/routing"
+require "iron/image_analyzer"
+
+module Iron
+  class Engine < ::Rails::Engine
+    isolate_namespace Iron
+
+    initializer "iron.setup", before: "importmap" do |app|
+      app.config.assets.paths.unshift(root.join("vendor/javascript"))
+      app.config.assets.paths << root.join("app/javascript")
+      app.config.importmap.paths << root.join("config/importmap.rb")
+      app.config.importmap.cache_sweepers << root.join("app/javascript")
+
+      app.config.assets.precompile += %w[iron_manifest]
+    end
+
+    initializer "iron.routing" do
+      ActionDispatch::Routing::Mapper.include Iron::Routing
+    end
+
+    initializer "iron.active_storage_analyzers" do |app|
+      app.config.active_storage.analyzers.prepend Iron::ImageAnalyzer
+    end
+
+    config.to_prepare do
+      ActionView::Base.include(Module.new do
+        def attachment_url(attachment, **options)
+          attachment.url(**options)
+        end
+      end)
+    end
+  end
+end

data/lib/iron/image_analyzer.rb

@@ -0,0 +1,26 @@
+module Iron
+  class ImageAnalyzer < ActiveStorage::Analyzer::ImageAnalyzer::Vips
+    def metadata
+      download_blob_to_tempfile do |file|
+        super.merge(blur_data_uri: generate_blur_placeholder(file))
+      end
+    end
+
+    private
+
+      def generate_blur_placeholder(file)
+        processed = ImageProcessing::Vips
+          .source(file)
+          .resize_to_limit(20, nil)
+          .gaussblur(2)
+          .convert("jpg")
+          .saver(quality: 20, strip: true)
+          .call
+
+        image_data = File.read(processed.path)
+        "data:image/jpeg;base64,#{Base64.strict_encode64(image_data)}"
+      ensure
+        processed&.close if processed.respond_to?(:close)
+      end
+  end
+end

data/lib/iron/lexorank/exceptions.rb

@@ -0,0 +1,4 @@
+module Iron::Lexorank::Exceptions
+  class InvalidRankError < StandardError
+  end
+end

data/lib/iron/lexorank/rankable.rb

@@ -0,0 +1,185 @@
+module Iron
+  module Lexorank
+    LONG_RANK_SIZE = 10
+    module Rankable
+      module HasRank
+        attr_reader :rank_column, :rank_scoped_by, :has_rank_applied
+
+        def has_rank(column: :rank, scoped_by: nil)
+          self.class_variable_set("@@rank_column", column)
+          cattr_reader :rank_column, instance_reader: false
+
+          self.class_variable_set("@@rank_scoped_by", grab_column(scoped_by))
+          cattr_reader :rank_scoped_by, instance_reader: false
+
+          @has_rank_applied = true
+
+          scope :ranked, ->(direction: :asc) { where.not("#{column}": nil).order("#{column}": direction) }
+
+          after_save_commit :request_rank_rebalance, if: -> {
+            rank.present? && rank.length > Lexorank::LONG_RANK_SIZE
+          }
+
+          include InstanceMethods
+          extend ClassMethods
+        end
+
+        private
+
+        def grab_column(column)
+          return unless column
+
+          if association = reflect_on_association(column)
+            if association.options[:polymorphic]
+              [ association.foreign_type.to_sym, association.foreign_key.to_sym ]
+            else
+              association.foreign_key.to_sym
+            end
+          else
+            column
+          end
+        end
+      end
+
+      module ClassMethods
+        include Iron::Lexorank::Utils
+
+        def rebalance(rank_scope = nil)
+          if rank_scope.present?
+            if rank_scoped_by.is_a?(Array)
+              type_column, id_column = rank_scoped_by
+              ranked_scoped_items = ranked.where(
+                "#{type_column}": rank_scope.first,
+                "#{id_column}": rank_scope.second
+              )
+            else
+              ranked_scoped_items = ranked.where("#{rank_scoped_by}": rank_scope)
+            end
+
+            interval = optimal_rank_numeric_interval_for(ranked_scoped_items.count)
+
+            self.transaction do
+              ranked_scoped_items.each.with_index(1) do |item, index|
+                item.rank = to_rank(interval * index) + "-rebalancing"
+                item.save!
+              end
+
+              ranked_scoped_items.each do |item|
+                item.rank = item.rank.gsub("-rebalancing", "")
+                item.save!
+              end
+            end
+          else
+            raise "Not implemented yet"
+          end
+        end
+      end
+
+      module InstanceMethods
+        include Iron::Lexorank::Utils
+
+        def move_to(position)
+          # exceptions:
+          #   move to the beginning (aka move to position 0)
+          #   move to end (aka position = collection.size - 1)
+          # when moving to the end of the collection the offset and limit statement automatically handles
+          # that 'after' is nil which is the same like [collection.last, nil]
+          before, after =
+            if position.zero?
+              [ nil, scoped_collection.first ]
+            else
+              scoped_collection.where.not(id: id).offset(position - 1).limit(2)
+            end
+
+          rank =
+            if self == after && send(rank_column).present?
+              send(rank_column)
+            else
+              value_between(before&.send(rank_column), after&.send(rank_column))
+            end
+
+          send("#{rank_column}=", rank)
+        end
+
+        def move_to!(position)
+          move_to(position)
+          save
+        end
+
+        def move_to_top
+          after = scoped_collection.first
+          rank = value_between(nil, after&.send(rank_column))
+          send("#{rank_column}=", rank)
+        end
+
+        def move_to_top!
+          move_to_top
+          save
+        end
+
+        def move_to_bottom
+          before = scoped_collection.last
+          rank = value_between(before&.send(rank_column), nil)
+          send("#{rank_column}=", rank)
+        end
+
+        def move_to_bottom!
+          move_to_bottom
+          save
+        end
+
+        def no_rank?
+          !send(rank_column)
+        end
+
+        private
+
+          def rank_column
+            self.class.rank_column
+          end
+
+          def rank_scoped_by
+            self.class.rank_scoped_by
+          end
+
+          def scoped_collection
+            collection = base_class.ranked
+            if rank_scoped_by.present?
+              if rank_scoped_by.is_a?(Array)
+                type_column, id_column = rank_scoped_by
+                collection = collection.where(
+                  "#{type_column}": send(type_column),
+                  "#{id_column}": send(id_column)
+                )
+              else
+                collection = collection.where("#{rank_scoped_by}": send(rank_scoped_by))
+              end
+            end
+            collection
+          end
+
+          def base_class
+            if self.class.has_rank_applied
+              self.class
+            else
+              self.class.base_class
+            end
+          end
+
+          def request_rank_rebalance
+            if rank_scoped_by.is_a?(Array)
+              type_column, id_column = rank_scoped_by
+              rank_scope = [ send(type_column), send(id_column) ]
+            else
+              rank_scope = send(rank_scoped_by)
+            end
+            Iron::Lexorank::RebalanceRankJob.perform_later(base_class.name, rank_scope)
+          end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load :active_record do
+  extend Iron::Lexorank::Rankable::HasRank
+end

data/lib/iron/lexorank/rebalance_rank_job.rb

@@ -0,0 +1,10 @@
+module Iron::Lexorank
+  class RebalanceRankJob < ActiveJob::Base
+    queue_as :default
+
+    def perform(model_name, rank_scope)
+      model_class = model_name.constantize
+      model_class.rebalance(rank_scope)
+    end
+  end
+end

data/lib/iron/lexorank/utils.rb

@@ -0,0 +1,77 @@
+module Iron::Lexorank::Utils
+  MIN_CHAR = "0"
+  MAX_CHAR = "z"
+  BASE = MAX_CHAR.ord - MIN_CHAR.ord + 1
+
+  def value_between(before_, after_)
+    before = before_ || MIN_CHAR
+    after = after_ || MAX_CHAR
+
+    rank = ""
+
+    (before.length + after.length).times do |i|
+      prev_char = get_char(before, i, MIN_CHAR)
+      after_char = get_char(after, i, MAX_CHAR)
+
+      if prev_char == after_char
+        rank += prev_char
+        next
+      end
+
+      mid_char = mid(prev_char, after_char)
+      if mid_char == prev_char || mid_char == after_char
+        rank += prev_char
+        next
+      end
+
+      rank += mid_char
+      break
+    end
+
+    # Problem: If we try to get a rank before the character '0' or after 'z' the algorithm would return the same char
+    # This first of all breaks a possible unique constraint and of course makes no sense when ordering the items.
+    #
+    # Thoughts: I think this issue will never happen with the Lexorank::Rankable module
+    # Why? Let's look at '0' as a rank:
+    # Because the algorithm always chooses the char in between two other chars, '0' can only happen when before is nil and after is '1'
+    # In this case the algorithm will return '0U' though. This means there will never be an item with rank '0' which is why this condition
+    # should never equal to true.
+    #
+    # Please report if you have another opinion about that or if you reached the exception! (of course you can force it by using `value_between(nil, '0')`)
+    if rank >= after
+      raise Lexorank::Exceptions::InvalidRankError,
+        "This rank should not be achievable using the Lexorank::Rankable module! " \
+        "The supplied ranks were #{before_.inspect} and #{after_.inspect}."
+    end
+    rank
+  end
+
+  def mid(prev, after)
+    middle_ascii = ((prev.ord + after.ord) / 2).round
+    middle_ascii.chr
+  end
+
+  def get_char(string, index, default_char)
+    index >= string.length ? default_char : string[index]
+  end
+
+  def to_rank(number)
+    return MIN_CHAR if number.zero?
+
+    result = ""
+    while number > 0
+      remainder = number % BASE
+      number /= BASE
+      result = (MIN_CHAR.ord + remainder).chr + result
+    end
+    result
+  end
+
+  def optimal_rank_numeric_interval_for(items_count)
+    i = 1
+    while items_count >= BASE ** i
+      i += 1
+    end
+    (BASE ** i) / (items_count + 1)
+  end
+end

data/lib/iron/lexorank.rb

@@ -0,0 +1,7 @@
+module Iron::Lexorank
+end
+
+require "iron/lexorank/exceptions"
+require "iron/lexorank/utils"
+require "iron/lexorank/rankable"
+require "iron/lexorank/rebalance_rank_job"