iron-cms 0.1.0

data/app/controllers/iron/first_runs_controller.rb

@@ -0,0 +1,29 @@
+module Iron
+  class FirstRunsController < ApplicationController
+    layout "iron/authentication"
+
+    allow_unauthenticated_access
+
+    before_action :prevent_running_after_setup
+
+    def show
+      @user = User.new
+    end
+
+    def create
+      user = FirstRun.create!(user_params)
+      start_new_session_for user
+
+      redirect_to root_url
+    end
+
+    private
+      def prevent_running_after_setup
+        redirect_to root_url if User.any?
+      end
+
+      def user_params
+        params.require(:user).permit(:email_address, :password)
+      end
+  end
+end

data/app/controllers/iron/home_controller.rb

@@ -0,0 +1,6 @@
+module Iron
+  class HomeController < ApplicationController
+    def show
+    end
+  end
+end

data/app/controllers/iron/icons_controller.rb

@@ -0,0 +1,10 @@
+module Iron
+  class IconsController < ApplicationController
+    def index
+      @selected = params[:selected]
+      @icons = IconCatalog.all
+
+      render layout: false
+    end
+  end
+end

data/app/controllers/iron/locales_controller.rb

@@ -0,0 +1,52 @@
+module Iron
+  class LocalesController < ApplicationController
+    before_action :set_locale, only: %i[ edit update destroy ]
+    before_action :ensure_can_administer
+
+    def index
+      @locales = Locale.all
+    end
+
+    def new
+      @locale = Locale.new
+    end
+
+    def edit
+    end
+
+    def create
+      @locale = Locale.new(locale_params)
+
+      if @locale.save
+        redirect_to locales_path, notice: "Locale was successfully created."
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def update
+      if @locale.update(locale_params)
+        redirect_to locales_path, notice: "Locale was successfully updated.", status: :see_other
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      if @locale.destroy
+        redirect_to locales_path, notice: "Locale was successfully destroyed.", status: :see_other
+      else
+        redirect_back fallback_location: locales_path, alert: @locale.errors.full_messages.to_sentence, status: :see_other
+      end
+    end
+
+    private
+      def set_locale
+        @locale = Locale.find(params.expect(:id))
+      end
+
+      def locale_params
+        params.expect(locale: [ :code, :name ])
+      end
+  end
+end

data/app/controllers/iron/passwords_controller.rb

@@ -0,0 +1,36 @@
+module Iron
+  class PasswordsController < ApplicationController
+    layout "iron/authentication"
+    allow_unauthenticated_access
+    before_action :set_user_by_token, only: %i[ edit update ]
+
+    def new
+    end
+
+    def create
+      if user = User.find_by(email_address: params[:email_address])
+        PasswordsMailer.reset(user).deliver_later
+      end
+
+      redirect_to new_session_url, notice: "Password reset instructions sent (if user with that email address exists)."
+    end
+
+    def edit
+    end
+
+    def update
+      if @user.update(params.permit(:password, :password_confirmation))
+        redirect_to new_session_url, notice: "Password has been reset."
+      else
+        redirect_to edit_password_url(params[:token]), alert: "Passwords did not match."
+      end
+    end
+
+    private
+      def set_user_by_token
+        @user = User.find_by_password_reset_token!(params[:token])
+      rescue ActiveSupport::MessageVerifier::InvalidSignature
+        redirect_to new_password_url, alert: "Password reset link is invalid or has expired."
+      end
+  end
+end

data/app/controllers/iron/references_controller.rb

@@ -0,0 +1,11 @@
+module Iron
+  class ReferencesController < ApplicationController
+    def new
+      @form_field_name = params[:form_field_name]
+      @reference_list_dom_id = params[:reference_list_dom_id]
+
+      @entry = Entry.find(params[:entry_id])
+      @reference = Reference.build(entry: @entry)
+    end
+  end
+end

data/app/controllers/iron/schemas_controller.rb

@@ -0,0 +1,32 @@
+module Iron
+  class SchemasController < ApplicationController
+    def export
+      send_data SchemaExporter.export,
+        filename: "iron-schema-#{Date.current}.tar",
+        type: "application/x-tar",
+        disposition: "attachment"
+    end
+
+    def new
+      @import_modes = SchemaImporter::IMPORT_MODES
+    end
+
+    def import
+      file = params[:schema_file]
+      mode = params[:import_mode]
+
+      unless file.present?
+        redirect_to schema_path, alert: "Please select a file to import"
+        return
+      end
+
+      result = SchemaImporter.import(file, mode:)
+
+      if result.success?
+        redirect_to content_types_path, notice: "Schema imported successfully"
+      else
+        redirect_to schema_path, alert: result.errors.join(". ")
+      end
+    end
+  end
+end

data/app/controllers/iron/sessions_controller.rb

@@ -0,0 +1,32 @@
+module Iron
+  class SessionsController < ApplicationController
+    layout "iron/authentication"
+    allow_unauthenticated_access only: %i[ new create ]
+    rate_limit to: 10, within: 3.minutes, only: :create, with: -> { redirect_to sign_in_url, alert: "Try again later." }
+
+    before_action :ensure_user_exists, only: :new
+
+    def new
+    end
+
+    def create
+      if user = User.authenticate_by(params.permit(:email_address, :password))
+        start_new_session_for user
+        redirect_to after_authentication_url
+      else
+        redirect_to sign_in_url, alert: "Try another email address or password."
+      end
+    end
+
+    def destroy
+      terminate_session
+      redirect_to sign_in_url
+    end
+
+    private
+
+      def ensure_user_exists
+        redirect_to first_run_url if User.none?
+      end
+  end
+end

data/app/controllers/iron/settings_controller.rb

@@ -0,0 +1,23 @@
+module Iron
+  class SettingsController < ApplicationController
+    before_action :ensure_can_administer
+
+    def show
+      @account = Current.account
+      @locales = Locale.all
+    end
+
+    def update
+      if Current.account.update(account_params)
+        redirect_back fallback_location: settings_path, notice: "Settings updated successfully."
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    private
+      def account_params
+        params.require(:account).permit(:name, :default_locale_id)
+      end
+  end
+end

data/app/controllers/iron/users_controller.rb

@@ -0,0 +1,66 @@
+module Iron
+  class UsersController < ApplicationController
+    layout "iron/authentication", only: %i[ new create ]
+    require_unauthenticated_access only: %i[ new create ]
+
+    before_action :set_user, only: %i[ show update destroy ]
+    before_action :verify_join_code, only: %i[ new create ]
+    before_action :ensure_can_administer, except: %i[ new create ]
+
+    def index
+      @users = User.all
+    end
+
+    def new
+      @user = User.new
+    end
+
+    def show
+    end
+
+     def create
+      @user = User.new(join_params)
+      if @user.save
+        start_new_session_for @user
+        redirect_to root_url
+      else
+        render :new, status: :unprocessable_entity
+      end
+    rescue ActiveRecord::RecordNotUnique
+      redirect_to sign_in_url(email_address: join_params[:email_address])
+    end
+
+    def update
+      if @user.update(update_params)
+        redirect_back fallback_location: users_path, notice: "User was successfully updated.", status: :see_other
+      else
+        redirect_back fallback_location: users_path, alert: @user.errors.full_messages.to_sentence, status: :see_other
+      end
+    end
+
+    def destroy
+      if @user.destroy
+        redirect_back fallback_location: users_path, notice: "User was successfully removed.", status: :see_other
+      else
+        redirect_back fallback_location: users_path, alert: @user.errors.full_messages.to_sentence, status: :see_other
+      end
+    end
+
+    private
+      def set_user
+        @user = User.find(params.expect(:id))
+      end
+
+      def join_params
+        params.expect(user: [ :email_address, :password, :password_confirmation ])
+      end
+
+      def update_params
+        params.expect(user: [ :email_address, :role ])
+      end
+
+      def verify_join_code
+        head :not_found if Current.account.join_code != params[:join_code]
+      end
+  end
+end

data/app/helpers/iron/application_helper.rb

@@ -0,0 +1,25 @@
+require "tailwind_merge"
+module Iron
+  module ApplicationHelper
+    include IconsHelper, AvatarHelper, ButtonsHelper, EntriesHelper, ContentTypesHelper
+    include Components::DropdownHelper, Components::BadgeHelper
+
+    def tw(*classes)
+      TailwindMerge::Merger.new.merge(classes.reject(&:blank?).compact.join(" "))
+    end
+
+    def cva(base_classes = "", options = {})
+      Cva::VariantBuilder.new(
+        base_classes: base_classes,
+        variants: options[:variants] || {},
+        defaults: options[:defaults] || {},
+        compound_variants: options[:compound_variants] || [],
+        required: options[:required] || []
+      )
+    end
+
+    def unique_id
+      rand(10000000..100000000)
+    end
+  end
+end

data/app/helpers/iron/avatar_helper.rb

@@ -0,0 +1,35 @@
+module Iron
+  module AvatarHelper
+    def avatar(user, options = {})
+      variant = options.delete(:variant) || "circle"
+      alt = options.delete(:alt) || ""
+      css_class = tw(
+        options.delete(:class),
+        # Basic layout
+        "inline-grid shrink-0 align-middle [--avatar-radius:20%] [--ring-opacity:20%] *:col-start-1 *:row-start-1",
+        "outline outline-1 -outline-offset-1 outline-black/(--ring-opacity) dark:outline-white/(--ring-opacity)",
+        # Add the correct border radius
+        variant == "square" ? "rounded-(--avatar-radius) *:rounded-(--avatar-radius)" : "rounded-full *:rounded-full"
+      )
+
+      tag.span class: css_class, data: { slot: "avatar" } do
+        tag.svg class: "size-full select-none fill-current p-[5%] text-[48px] font-medium uppercase",
+          viewbox: "0 0 100 100",
+          "aria-hidden": alt.present? ? nil : true do
+          safe_join([
+            alt.present? ? tag.title(alt) : nil,
+            tag.text(
+              user.initials,
+              x: "50%",
+              y: "50%",
+              "alignment-baseline": "middle",
+              "dominant-baseline": "middle",
+              "text-anchor": "middle",
+              dy: ".125em",
+            )
+          ])
+        end
+      end
+    end
+  end
+end

data/app/helpers/iron/block_helper.rb

@@ -0,0 +1,4 @@
+module Iron
+  module BlockHelper
+  end
+end

data/app/helpers/iron/buttons_helper.rb

@@ -0,0 +1,14 @@
+module Iron::ButtonsHelper
+  def back_button_to(title, url, options = {}, &)
+    link_to url,
+      class: tw(
+        "inline-flex items-center gap-2 text-sm/6 text-stone-500 dark:text-stone-400",
+        options.delete(:class)
+      ) do
+      safe_join([
+        icon("chevron-left", class: "size-4"),
+        tag.span(title)
+      ])
+    end
+  end
+end

data/app/helpers/iron/components/badge_helper.rb

@@ -0,0 +1,70 @@
+module Iron
+  module Components::BadgeHelper
+    def badge_class(**options)
+      @badge_variants ||= cva(
+        # Base classes
+        "inline-flex items-center gap-x-1.5 rounded-md px-1.5 py-0.5 text-sm/5 font-medium sm:text-xs/5 forced-colors:outline",
+        variants: {
+          color: {
+            red: "bg-red-500/15 text-red-700 group-hover:bg-red-500/25 dark:bg-red-500/10 dark:text-red-400 dark:group-hover:bg-red-500/20",
+            orange: "bg-orange-500/15 text-orange-700 group-hover:bg-orange-500/25 dark:bg-orange-500/10 dark:text-orange-400 dark:group-hover:bg-orange-500/20",
+            amber: "bg-amber-400/20 text-amber-700 group-hover:bg-amber-400/30 dark:bg-amber-400/10 dark:text-amber-400 dark:group-hover:bg-amber-400/15",
+            yellow: "bg-yellow-400/20 text-yellow-700 group-hover:bg-yellow-400/30 dark:bg-yellow-400/10 dark:text-yellow-300 dark:group-hover:bg-yellow-400/15",
+            lime: "bg-lime-400/20 text-lime-700 group-hover:bg-lime-400/30 dark:bg-lime-400/10 dark:text-lime-300 dark:group-hover:bg-lime-400/15",
+            green: "bg-green-500/15 text-green-700 group-hover:bg-green-500/25 dark:bg-green-500/10 dark:text-green-400 dark:group-hover:bg-green-500/20",
+            emerald: "bg-emerald-500/15 text-emerald-700 group-hover:bg-emerald-500/25 dark:bg-emerald-500/10 dark:text-emerald-400 dark:group-hover:bg-emerald-500/20",
+            teal: "bg-teal-500/15 text-teal-700 group-hover:bg-teal-500/25 dark:bg-teal-500/10 dark:text-teal-300 dark:group-hover:bg-teal-500/20",
+            cyan: "bg-cyan-400/20 text-cyan-700 group-hover:bg-cyan-400/30 dark:bg-cyan-400/10 dark:text-cyan-300 dark:group-hover:bg-cyan-400/15",
+            sky: "bg-sky-500/15 text-sky-700 group-hover:bg-sky-500/25 dark:bg-sky-500/10 dark:text-sky-300 dark:group-hover:bg-sky-500/20",
+            blue: "bg-blue-500/15 text-blue-700 group-hover:bg-blue-500/25 dark:text-blue-400 dark:group-hover:bg-blue-500/25",
+            indigo: "bg-indigo-500/15 text-indigo-700 group-hover:bg-indigo-500/25 dark:text-indigo-400 dark:group-hover:bg-indigo-500/20",
+            violet: "bg-violet-500/15 text-violet-700 group-hover:bg-violet-500/25 dark:text-violet-400 dark:group-hover:bg-violet-500/20",
+            purple: "bg-purple-500/15 text-purple-700 group-hover:bg-purple-500/25 dark:text-purple-400 dark:group-hover:bg-purple-500/20",
+            fuchsia: "bg-fuchsia-400/15 text-fuchsia-700 group-hover:bg-fuchsia-400/25 dark:bg-fuchsia-400/10 dark:text-fuchsia-400 dark:group-hover:bg-fuchsia-400/20",
+            pink: "bg-pink-400/15 text-pink-700 group-hover:bg-pink-400/25 dark:bg-pink-400/10 dark:text-pink-400 dark:group-hover:bg-pink-400/20",
+            rose: "bg-rose-400/15 text-rose-700 group-hover:bg-rose-400/25 dark:bg-rose-400/10 dark:text-rose-400 dark:group-hover:bg-rose-400/20",
+            stone: "bg-stone-600/10 text-stone-700 group-hover:bg-stone-600/20 dark:bg-white/5 dark:text-stone-400 dark:group-hover:bg-white/10"
+          }
+        },
+        defaults: {
+          color: :stone
+        }
+      )
+      @badge_variants.call(options)
+    end
+
+    def badge(content = nil, **options, &block)
+      css_class = options.delete(:class)
+
+      tag.span class: tw(
+        badge_class(**options),
+        css_class
+      ), **options do
+        block_given? ? capture(&block) : content
+      end
+    end
+
+    def badge_button_to(content = nil, url = nil, **options, &block)
+      css_class = options.delete(:class)
+
+      base_class = tw(
+        "group relative inline-flex rounded-md focus:outline-hidden focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-500",
+        css_class
+      )
+
+      if url.nil?
+        button_tag class: base_class, **options do
+          tag.div class: "btn-touch-target" do
+            badge(content || capture(&block), **options)
+          end
+        end
+      else
+        link_to url, class: base_class, **options do
+          tag.div class: "btn-touch-target" do
+            badge(content || capture(&block), **options)
+          end
+        end
+      end
+    end
+  end
+end

data/app/helpers/iron/components/dropdown_helper.rb

@@ -0,0 +1,161 @@
+# module Iron
+#   module Components::DropdownHelper
+#     def dropdown_divider
+#       tag.div role: "separator", class: "col-span-full mx-3.5 my-1 h-px border-0 bg-stone-950/5 sm:mx-3 dark:bg-white/10 forced-colors:bg-[CanvasText]"
+#     end
+#   end
+# end
+
+module Iron
+  module Components::DropdownHelper
+    # Main dropdown container
+    def dropdown_menu(options = {}, &block)
+      # Initialize storage for different parts of the dropdown
+      @dropdown_id = options[:id] || "dropdown-#{SecureRandom.hex(4)}"
+      @dropdown_trigger = nil
+      @dropdown_content = nil
+
+      # Capture the nested content
+      capture(&block)
+
+      # Build the complete dropdown
+      content_tag(:div, class: options[:class]) do
+        safe_join([
+          @dropdown_trigger,
+          @dropdown_content
+        ].compact)
+      end
+    end
+
+    # Button that toggles the dropdown
+    def dropdown_menu_trigger(options = {}, &block)
+      css_class = options.delete(:class)
+      trigger_content = capture(&block)
+
+      @dropdown_trigger = content_tag(:button,
+        trigger_content,
+        id: "#{@dropdown_id}-trigger",
+        popovertarget: @dropdown_id,
+        class: tw("inline-flex items-center justify-center gap-2", css_class),
+        style: "anchor-name: --#{@dropdown_id}-trigger;",
+        **options
+      )
+
+      nil # Return nil to avoid content being rendered twice
+    end
+
+    def dropdown_menu_content(options = {}, &block)
+      css_class = options.delete(:class)
+      width = options[:width] || "16rem"
+      align = options[:align] || "end"  # Default to end alignment
+      side = options[:side]
+
+      positioning = "position-anchor: --#{@dropdown_id}-trigger;"
+
+      # Add alignment to positioning
+      positioning += " position-align: #{align};" if align.present?
+
+      # Add side to positioning if provided
+      positioning += " position-side: #{side};" if side.present?
+
+      content = capture(&block)
+
+      @dropdown_content = content_tag(:div,
+        content,
+        id: @dropdown_id,
+        popover: "",
+        class: tw("dropdown", css_class),
+        style: "#{positioning} --popover-width: #{width};",
+        **options
+      )
+
+      nil # Return nil to avoid content being rendered twice
+    end
+
+    # Individual dropdown menu item
+    def dropdown_menu_item(*args, &block)
+      options = args.extract_options!
+
+      # Determine what the remaining args are
+      text = args[0]
+      url = args[1]
+
+      # Extract common options
+      css_class = options.delete(:class)
+      icon_name = options.delete(:icon)
+      method = options.delete(:method)
+
+      item_content = if block_given?
+        capture(&block)
+      elsif icon_name.present?
+        safe_join([
+          icon(icon_name, variant: :micro, data: { slot: "icon" }),
+          content_tag(:div, text, data: { slot: "label" })
+        ])
+      else
+        text
+      end
+
+      if url.nil? && method.present?
+        # Button form
+        button_tag(item_content,
+          type: "button",
+          class: tw("dropdown-item w-full text-left", css_class),
+          **options
+        )
+      elsif method.present?
+        # Button_to form
+        button_to(url.to_s,
+          method: method,
+          class: tw("dropdown-item w-full", css_class),
+          **options
+        ) { item_content }
+      elsif url.present?
+        # Link form
+        link_to(url.to_s,
+          class: tw("dropdown-item", css_class),
+          **options
+        ) { item_content }
+      else
+        # Plain item
+        content_tag(:div, item_content,
+          class: tw("dropdown-item", css_class),
+          **options
+        )
+      end
+    end
+
+    # Label for dropdown sections
+    def dropdown_menu_label(text = nil, options = {}, &block)
+      css_class = options.delete(:class)
+
+      content = block_given? ? capture(&block) : text
+
+      content_tag(:div, content,
+        class: tw("px-3.5 py-2 text-sm font-semibold text-stone-950 dark:text-white sm:px-3", css_class),
+        **options
+      )
+    end
+
+    # Divider between dropdown items
+    def dropdown_menu_separator(options = {})
+      css_class = options.delete(:class)
+
+      content_tag(:div, nil,
+        role: "separator",
+        class: tw("dropdown-divider", css_class),
+        **options
+      )
+    end
+
+    # Group of related dropdown items
+    def dropdown_menu_group(options = {}, &block)
+      css_class = options.delete(:class)
+
+      content_tag(:div, capture(&block),
+        class: tw("p-1", css_class),
+        **options
+      )
+    end
+  end
+end

data/app/helpers/iron/content_types_helper.rb

@@ -0,0 +1,11 @@
+module Iron
+  module ContentTypesHelper
+    def content_type_sidebar_url(content_type)
+      if content_type.single?
+        entry_content_type_path(content_type)
+      else
+        content_type_entries_path(content_type)
+      end
+    end
+  end
+end

data/app/helpers/iron/entries_helper.rb

@@ -0,0 +1,13 @@
+module Iron::EntriesHelper
+  def entry_fields_for(field, prefix, &)
+    fields_for "#{prefix}[fields_attributes][#{field.id || unique_id}]", field, &
+  end
+
+  def current_content_page?(content_type)
+    request.path.start_with?(content_type_entries_path(content_type)) || (
+      controller_name == "entries" &&
+      %w[show edit].include?(action_name) &&
+      Iron::Entry.find(params[:id]).content_type == content_type
+    )
+  end
+end

data/app/helpers/iron/field_definitions_helper.rb

@@ -0,0 +1,5 @@
+module Iron::FieldDefinitionsHelper
+  def field_definition_type_options
+    Iron::FieldDefinition::TYPES.map { |type| [ type.humanize, type ] }
+  end
+end