iron-cms 0.1.0

data/app/helpers/iron/form_builder.rb

@@ -0,0 +1,43 @@
+module Iron
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    INPUT_FIELD_TYPES = %i[
+      text_field
+      password_field
+      email_field
+      number_field
+      tel_field
+      url_field
+      search_field
+      date_field
+      time_field
+      datetime_field
+      datetime_local_field
+      month_field
+      week_field
+      color_field
+    ].freeze
+
+    INPUT_FIELD_TYPES.each do |field_type|
+      define_method field_type do |method, options = {}|
+        if object&.errors&.[](method).present?
+          options[:class] = @template.tw(options[:class], "is-invalid")
+        end
+
+        super(method, options)
+      end
+    end
+
+    def error_for(method)
+      if object&.errors&.[](method)&.any?
+        @template.content_tag(:div, class: "text-red-500 text-sm font-medium mt-1") do
+          object.errors[method].join(", ")
+        end
+      end
+    end
+
+    def label(method, text = nil, options = {}, &block)
+      options[:class] = @template.tw("text-sm/6 font-medium", options[:class])
+      super(method, text, options, &block)
+    end
+  end
+end

data/app/helpers/iron/icons_helper.rb

@@ -0,0 +1,30 @@
+module Iron
+  module IconsHelper
+    SPRITE_PATH = "iron/icons/sprite.svg"
+
+    def available_icons
+      IconCatalog.all
+    end
+
+    # Examples
+    #   icon "heart"                       # => 24 px outline heart
+    #   icon "trash", class: "text-red-600 hover:text-red-700"
+    #
+    def icon(name, **attributes)
+      css_class     = attributes.delete(:class)
+      data_attrs    = { slot: "icon" }.merge!(attributes.delete(:data) || {})
+
+      tag.svg **attributes.merge(
+        class: tw(
+          "stroke-current size-5 fill-none stroke-2 [stroke-linecap:round] [stroke-linejoin:round]",
+          css_class
+        ),
+        data:  data_attrs,
+        viewBox: "0 0 24 24",
+        aria_hidden: "true"
+      ) do
+        tag.use href: "#{image_path(SPRITE_PATH)}##{name}"
+      end
+    end
+  end
+end

data/app/helpers/iron/image_helper.rb

@@ -0,0 +1,50 @@
+module Iron
+  module ImageHelper
+    IMAGE_BREAKPOINTS = [ 150, 320, 640, 1024, 1920 ].freeze
+
+    def iron_image_tag(attachment, sizes: "100vw", loading: "lazy", blur: true, **options)
+      return "" unless attachment&.attached?
+      return image_tag(attachment, **options) unless attachment.blob.variable?
+
+      image_options = options.merge(
+        srcset: generate_srcset(attachment),
+        sizes:,
+        loading:,
+        width: attachment.blob.metadata["width"],
+        height: attachment.blob.metadata["height"]
+      ).compact
+
+      if blur && attachment.blob.metadata["blur_data_uri"].present?
+        blur_style = "background-image: url('#{attachment.blob.metadata["blur_data_uri"]}'); background-size: cover; background-position: center;"
+        image_options[:style] = "#{blur_style} #{options[:style]}".strip
+      end
+
+      image_tag attachment.variant(resize_to_limit: [ IMAGE_BREAKPOINTS.third, nil ]), **image_options
+    end
+
+    def iron_picture_tag(attachment, sizes: "100vw", loading: "lazy", blur: true, **options)
+      return "" unless attachment&.attached?
+      return image_tag(attachment, **options) unless attachment.blob.variable?
+
+      content_tag :picture do
+        concat source_tag(attachment, :avif, sizes)
+        concat source_tag(attachment, :webp, sizes)
+        concat iron_image_tag(attachment, sizes: sizes, loading: loading, blur: blur, **options)
+      end
+    end
+
+    private
+
+      def source_tag(attachment, format, sizes)
+        tag.source type: "image/#{format}", srcset: generate_srcset(attachment, format:), sizes:
+      end
+
+      def generate_srcset(attachment, format: nil)
+        IMAGE_BREAKPOINTS.map { |w| "#{variant_url(attachment, w, format)} #{w}w" }.join(", ")
+      end
+
+      def variant_url(attachment, width, format = nil)
+        url_for(attachment.variant(resize_to_limit: [ width, nil ], format: format))
+      end
+  end
+end

data/app/javascript/iron/application.js

@@ -0,0 +1,6 @@
+// Configure your import map in config/importmap.rb. Read more: https://github.com/rails/importmap-rails
+import "@hotwired/turbo-rails";
+import "controllers";
+
+import "trix"
+import "@rails/actiontext"

data/app/javascript/iron/controllers/application.js

@@ -0,0 +1,9 @@
+import { Application } from "@hotwired/stimulus";
+
+const application = Application.start();
+
+// Configure Stimulus development experience
+application.debug = false;
+window.Stimulus = application;
+
+export { application };

data/app/javascript/iron/controllers/element_controller.js

@@ -0,0 +1,11 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  remove() {
+    this.element.remove();
+  }
+
+  focus() {
+    this.element.focus();
+  }
+}

data/app/javascript/iron/controllers/file_upload_controller.js

@@ -0,0 +1,18 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class FileUploadController extends Controller {
+  static targets = ["preview", "placeholder"];
+
+  preview(event) {
+    const file = event.target.files[0];
+    if (file) {
+      const previewUrl = URL.createObjectURL(file);
+      this.previewTarget.src = previewUrl;
+      if (this.hasPlaceholderTarget) {
+        this.placeholderTarget.classList.add("hidden");
+      }
+      this.previewTarget.classList.remove("hidden");
+    }
+  }
+}
+

data/app/javascript/iron/controllers/form_controller.js

@@ -0,0 +1,7 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  submit() {
+    this.element.requestSubmit();
+  }
+}

data/app/javascript/iron/controllers/handle_controller.js

@@ -0,0 +1,27 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  static targets = ["source", "destination"];
+  static values = { automatic: { type: Boolean, default: true } };
+
+  handleize() {
+    if (this.automaticValue) {
+      this.destinationTarget.value = handleize(this.sourceTarget.value);
+    }
+  }
+
+  edit(event) {
+    this.automaticValue = false;
+    const value = event.target.value;
+    if (value !== handleize(value)) {
+      this.destinationTarget.value = handleize(value);
+    }
+  }
+}
+
+function handleize(str) {
+  return str
+    .toLowerCase()
+    .replace(/[^a-z0-9\s_]/g, "")
+    .replace(/\s+/g, "_");
+}

data/app/javascript/iron/controllers/icon_picker_controller.js

@@ -0,0 +1,48 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["input", "preview", "label", "popover", "icon"]
+
+  connect() {
+    this.updateSelectedState()
+  }
+
+  select(event) {
+    const iconName = event.currentTarget.dataset.iconName
+    
+    this.inputTarget.value = iconName
+    this.previewTarget.innerHTML = event.currentTarget.innerHTML
+    this.labelTarget.textContent = iconName
+    this.updateSelectedState()
+    this.popoverTarget.hidePopover()
+    this.inputTarget.dispatchEvent(new Event('change', { bubbles: true }))
+  }
+
+  iconTargetConnected(target) {
+    const currentValue = this.inputTarget.value
+    if (target.dataset.iconName === currentValue) {
+      target.dataset.ui = "selected"
+    }
+  }
+
+  updateSelectedState() {
+    const currentValue = this.inputTarget.value
+    this.iconTargets.forEach(icon => {
+      if (icon.dataset.iconName === currentValue) {
+        icon.dataset.ui = "selected"
+      } else {
+        delete icon.dataset.ui
+      }
+    })
+  }
+
+  filter(event) {
+    const searchTerm = event.target.value.toLowerCase()
+    
+    this.iconTargets.forEach(iconButton => {
+      const iconName = iconButton.dataset.iconName
+      const matches = iconName.includes(searchTerm)
+      iconButton.style.display = matches ? '' : 'none'
+    })
+  }
+}

data/app/javascript/iron/controllers/index.js

@@ -0,0 +1,4 @@
+// Import and register all your controllers from the importmap via controllers/**/*_controller
+import { application } from "controllers/application";
+import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading";
+eagerLoadControllersFrom("controllers", application);

data/app/javascript/iron/controllers/sortable_list_controller.js

@@ -0,0 +1,125 @@
+import { Controller } from "@hotwired/stimulus";
+import { Lexorank } from "lib/lexorank";
+
+export default class extends Controller {
+  static targets = ["item", "handle", "rank"];
+
+  handleTargetConnected(handle) {
+    handle.addEventListener("pointerdown", this.#onHandleTapStart);
+    handle.addEventListener("pointerup", this.#onHandleTapEnd)
+  }
+
+  handleTargetDisconnected(handle) {
+    handle.removeEventListener("pointerdown", this.#onHandleTapStart);
+    handle.removeEventListener("pointerup", this.#onHandleTapEnd)
+  }
+
+  rankTargetConnected(rank) {
+    if (!rank.value) {
+      const item = this.itemTargets.find(i => i.contains(rank));
+      this.updateRank(item);
+    }
+  }
+
+  onDragStart = (event) => {
+    this.draggedEl = event.currentTarget;
+    event.dataTransfer.effectAllowed = "move";
+    event.dataTransfer.setData("text/plain", "");
+    requestAnimationFrame(() => {
+      this.draggedEl.classList.add("dragging");
+    });
+    event.stopPropagation();
+  }
+
+  onDragEnd = () => {
+    this.draggedEl.classList.remove("dragging");
+    this.updateRank(this.draggedEl);
+    this.draggedEl = null;
+
+    this.#disableDraggableBehaviour();
+  }
+
+  onDragOver = (event) => {
+    event.preventDefault();
+    const overIndex = this.itemTargets.findIndex(t => t.contains(event.target));
+    const overTarget = this.itemTargets[overIndex];
+    if (!overTarget || overTarget === this.draggedEl) return;
+
+    const firstRects = new Map(this.itemTargets.map(el => [el, el.getBoundingClientRect()]));
+
+    const shouldInsertBefore = this.draggedEl.getBoundingClientRect().top > overTarget.getBoundingClientRect().top;
+    this.element.insertBefore(this.draggedEl, shouldInsertBefore ? overTarget : this.itemTargets[overIndex + 1] ?? null);
+
+    this.itemTargets.forEach(el => {
+      const dy = firstRects.get(el).top - el.getBoundingClientRect().top;
+      if (dy) {
+        el.style.transition = "none";
+        el.style.transform = `translateY(${dy}px)`;
+        requestAnimationFrame(() => {
+          el.style.transition = "transform 150ms ease";
+          el.style.transform = "";
+        });
+      }
+    });
+  }
+
+  updateRank(item) {
+    const idx = this.itemTargets.indexOf(item);
+    const prevRank = idx > 0 ? this.#rankFor(this.itemTargets[idx - 1]) : undefined;
+    const nextRank = idx < this.itemTargets.length - 1 ? this.#rankFor(this.itemTargets[idx + 1]) : undefined;
+    const newRank = Lexorank.between(prevRank, nextRank);
+    this.#setRank(item, newRank);
+  }
+
+  // Private
+
+  #onHandleTapStart = () => {
+    this.#enableDraggableBehaviour();
+  }
+
+  #onHandleTapEnd = () => {
+    this.#disableDraggableBehaviour();
+  }
+
+  #enableDraggableBehaviour = () => {
+    this.element.addEventListener("dragover", this.onDragOver);
+    this.itemTargets.forEach(this.#enableItemDraggableBehaviour);
+  }
+
+  #disableDraggableBehaviour = () => {
+    this.element.removeEventListener("dragover", this.onDragOver);
+    this.itemTargets.forEach(this.#disableItemDraggableBehaviour);
+  };
+
+  #enableItemDraggableBehaviour = (item) => {
+    item.setAttribute("draggable", "true");
+    item.addEventListener("dragstart", this.onDragStart);
+    item.addEventListener("dragend", this.onDragEnd);
+  }
+
+  #disableItemDraggableBehaviour = (item) => {
+    item.removeAttribute("draggable");
+    item.removeEventListener("dragstart", this.onDragStart);
+    item.removeEventListener("dragend", this.onDragEnd);
+  }
+
+  #rankFor(item) {
+    return this.#findRankInputForItem(item)?.value;
+  }
+
+  #setRank(item, value) {
+    const input = this.#findRankInputForItem(item);
+    if (input && input.value != value) {
+      input.value = value;
+      input.dispatchEvent(
+        new Event("change", { bubbles: true, cancelable: true })
+      );
+    }
+  }
+
+  #findRankInputForItem(item) {
+    const input = this.rankTargets.find(r => item.contains(r));
+    if (input == null) console.warn("Item is missing a rank input target", item);
+    return input;
+  }
+}

data/app/javascript/iron/controllers/toggle_controller.js

@@ -0,0 +1,14 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  static values = { selector: String };
+
+  toggle(event) {
+    const isChecked = event.target.checked;
+    const targets = document.querySelectorAll(this.selectorValue);
+    
+    targets.forEach(target => {
+      target.dataset.ui = isChecked ? "visible" : "hidden";
+    });
+  }
+}

data/app/javascript/iron/controllers/trix_controller.js

@@ -0,0 +1,19 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  connect() {
+    this.element.addEventListener("turbo:before-morph-attribute", this.#preventMorphing);
+    this.element.addEventListener("turbo:before-morph-element", this.#preventMorphing);
+  }
+
+  // Private
+
+  #preventMorphing = (event) => {
+    const { target } = event;
+
+    if (target.tagName == "TRIX-EDITOR" || target.tagName == "TRIX-TOOLBAR") {
+      event.preventDefault();
+    }
+  }
+}
+

data/app/javascript/iron/lib/lexorank.js

@@ -0,0 +1,51 @@
+const MIN_RANK_VALUE = "0";
+const MAX_RANK_VALUE = "z";
+
+export class Lexorank {
+  static between(before, after) {
+    const _before = before || MIN_RANK_VALUE;
+    const _after = after || MAX_RANK_VALUE;
+    let result = '';
+    let index = 0;
+    let found = false;
+
+    while (!found) {
+      const prev_char = _before[index] || MIN_RANK_VALUE;
+      const after_char = _after[index] || MAX_RANK_VALUE;
+      if (prev_char === after_char) {
+        result += prev_char;
+        index++;
+      } else {
+        const mid_char = character_between(prev_char, after_char);
+        if (mid_char === prev_char || mid_char === after_char) {
+          result += prev_char;
+          index++;
+        } else {
+          result += mid_char;
+          found = true;
+        }
+      }
+    }
+    return result;
+  }
+}
+
+/**
+  * @param {String} prev A single character
+  * @param {String} after A single character
+  * @returns {String} A character that sits between prev and after
+  */
+function character_between(prev, after) {
+  let middle_ascii = Math.round((ascii(prev) + ascii(after)) / 2);
+  return String.fromCharCode(middle_ascii);
+}
+
+/**
+  * @param {String} char A single character
+  * @returns {Number} The ascii value of char
+  */
+function ascii(char) {
+  return char.charCodeAt(0);
+}
+
+window.Lexorank = Lexorank;

data/app/jobs/iron/application_job.rb

@@ -0,0 +1,4 @@
+module Iron
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/iron/generate_entry_routes_job.rb

@@ -0,0 +1,15 @@
+module Iron
+  class GenerateEntryRoutesJob < ApplicationJob
+    queue_as :default
+
+    def perform(content_type = nil)
+      if content_type
+        content_type.entries.where(route: nil).find_each(&:save) if content_type.web_publishing_enabled?
+      else
+        ContentType.web_published.find_each do |ct|
+          ct.entries.where(route: nil).find_each(&:save)
+        end
+      end
+    end
+  end
+end

data/app/mailers/iron/application_mailer.rb

@@ -0,0 +1,6 @@
+module Iron
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/mailers/passwords_mailer.rb

@@ -0,0 +1,6 @@
+class PasswordsMailer < ApplicationMailer
+  def reset(user)
+    @user = user
+    mail subject: "Reset your password", to: user.email_address
+  end
+end

data/app/models/concerns/iron/csv_serializable.rb

@@ -0,0 +1,28 @@
+module Iron
+  module CsvSerializable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def to_csv
+        CSV.generate do |csv|
+          csv << csv_headers
+          csv_scope.find_each do |record|
+            csv << record.to_csv_row
+          end
+        end
+      end
+
+      def csv_headers
+        raise NotImplementedError, "#{name} must implement csv_headers"
+      end
+
+      def csv_scope
+        all
+      end
+    end
+
+    def to_csv_row
+      raise NotImplementedError, "#{self.class.name} must implement to_csv_row"
+    end
+  end
+end

data/app/models/iron/account/joinable.rb

@@ -0,0 +1,16 @@
+module Iron::Account::Joinable
+  extend ActiveSupport::Concern
+
+  included do
+    before_create { self.join_code = generate_join_code }
+  end
+
+  def reset_join_code
+    update! join_code: generate_join_code
+  end
+
+  private
+    def generate_join_code
+      SecureRandom.alphanumeric(12).scan(/.{4}/).join("-")
+    end
+end

data/app/models/iron/account.rb

@@ -0,0 +1,13 @@
+module Iron
+  class Account < ApplicationRecord
+    include Joinable
+
+    belongs_to :default_locale, class_name: "Iron::Locale"
+
+    def self.clear_schema!
+      FieldDefinition.destroy_all
+      ContentType.destroy_all
+      BlockDefinition.destroy_all
+    end
+  end
+end

data/app/models/iron/application_record.rb

@@ -0,0 +1,5 @@
+module Iron
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

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

@@ -0,0 +1,20 @@
+module Iron
+  module BlockDefinition::Portable
+      extend ActiveSupport::Concern
+      include ::Iron::CsvSerializable
+
+    class_methods do
+      def csv_headers
+        %w[handle name description]
+      end
+    end
+
+    def to_csv_row
+      [
+        handle,
+        name,
+        description
+      ]
+    end
+  end
+end

data/app/models/iron/block_definition.rb

@@ -0,0 +1,10 @@
+module Iron
+  class BlockDefinition < ApplicationRecord
+    include Portable
+
+    has_many :field_definitions, -> { ranked }, as: :schemable, dependent: :destroy
+
+    validates :name, presence: true
+    validates :handle, presence: true
+  end
+end