maglevcms 1.0.0.rc1

data/app/models/maglev/page.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Maglev
+  class Page < ApplicationRecord
+    ## concerns ##
+    include Maglev::Translatable
+    include Maglev::SectionsConcern
+    include Maglev::Page::PathConcern
+    include Maglev::Page::SearchConcern
+
+    ## translations ##
+    translates :title, presence: true
+    translates :sections
+    translates :seo_title, :meta_description
+    translates :og_title, :og_description, :og_image_url
+
+    ## scopes ##
+    scope :home, ->(locale = nil) { by_path('index', locale) }
+    scope :visible, -> { where(visible: true) }
+    scope :by_id_or_path, lambda { |id_or_path, locale = nil|
+                            joins(:paths).where(id: id_or_path).or(core_by_path(id_or_path, locale))
+                          }
+    scope :by_path, ->(path, locale = nil) { core_by_path(path, locale).joins(:paths) }
+    scope :core_by_path, lambda { |path, locale = nil|
+                           where(paths: { locale: locale || Maglev::I18n.current_locale, value: path })
+                         }
+
+    ## methods ##
+
+    def index?
+      path == 'index'
+    end
+
+    def static?
+      false
+    end
+  end
+end

data/app/models/maglev/page_path.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Maglev
+  class PagePath < ApplicationRecord
+    ## associations ##
+    belongs_to :page, class_name: 'Maglev::Page', foreign_key: 'maglev_page_id', inverse_of: :paths
+
+    ## scopes ##
+    scope :canonical, -> { where(canonical: true) }
+    scope :not_canonical, -> { where(canonical: false) }
+    scope :by_value, ->(value, locale = nil) { where(value: value, locale: locale || Maglev::I18n.current_locale) }
+
+    ## validations ##
+    validates :value, presence: true, exclusion: { in: Maglev.config.reserved_paths }
+    validates :value, uniqueness: { scope: %i[locale canonical] }, if: :canonical?
+    validates :canonical, uniqueness: { scope: %i[locale maglev_page_id] }, if: :canonical?
+
+    ## callbacks ##
+    after_initialize -> { self.locale ||= Maglev::I18n.current_locale }
+    before_validation :clean_value!
+
+    ## methods ##
+
+    ## class methods ##
+
+    def self.build_hash(page_id = nil)
+      query = page_id ? where(maglev_page_id: page_id) : all
+      query.canonical.pluck(:locale, :value).to_h
+    end
+
+    private
+
+    def clean_value!
+      return if value.blank?
+
+      self.value = clean_value
+    end
+
+    def clean_value
+      value
+        .strip
+        .gsub(%r{(^/|/$)}, '')
+        .gsub(%r{//+/}, '/')
+    end
+  end
+end

data/app/models/maglev/section/block.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+class Maglev::Section::Block
+  ## concerns ##
+  include ActiveModel::Model
+
+  ## attributes ##
+  attr_accessor :name, :type, :settings, :root, :accept, :limit
+
+  ## validation ##
+  validates :name, :type, presence: true
+  validates :settings, 'maglev/collection': true
+
+  ## methods
+
+  def root?
+    !!root
+  end
+
+  ## class methods ##
+
+  def self.build(hash)
+    attributes = hash.slice('name', 'type', 'accept', 'root', 'limit')
+    attributes['root'] = true if attributes['root'].nil?
+    attributes['limit'] = -1 if attributes['limit'].nil?
+
+    new(
+      attributes.merge(
+        settings: Maglev::Section::Setting.build_many(hash['settings'])
+      )
+    )
+  end
+
+  def self.build_many(list)
+    return [] if list.blank?
+
+    list.map { |hash| build(hash) }
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/section/content_concern.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+module Maglev::Section::ContentConcern
+  def build_default_content
+    {
+      id: SecureRandom.urlsafe_base64(8),
+      type: id,
+      settings: build_default_settings_content,
+      blocks: build_default_blocks_content
+    }
+  end
+
+  private
+
+  def build_default_settings_content(source = nil, custom_settings = nil)
+    return fallback_build_default_settings_content unless sample
+
+    (custom_settings || settings).map do |definition|
+      source ||= sample[:settings]
+      value = definition.build_default_content(source[definition.id.to_sym])
+      { id: definition.id, value: value }
+    end
+  end
+
+  def build_default_blocks_content
+    return fallback_build_default_blocks_content unless sample
+
+    blocks_content = {}
+
+    sample[:blocks]&.each do |block|
+      build_default_block_content(block, blocks_content, nil)
+    end
+
+    blocks_content.values.compact
+  end
+
+  def build_default_block_content(block, memo, parent_id = nil)
+    content = core_build_default_block_content(block, parent_id)
+    return unless content
+
+    memo[content[:id]] = content
+
+    (block[:children] || []).each do |child_block|
+      build_default_block_content(child_block, memo, content[:id])
+    end
+  end
+
+  def core_build_default_block_content(block, parent_id = nil)
+    settings = blocks.find { |bd| bd.type == block[:type] }&.settings
+    return unless settings
+
+    content = {
+      id: SecureRandom.urlsafe_base64(8),
+      type: block[:type],
+      settings: build_default_settings_content(block[:settings], settings)
+    }
+
+    content[:parent_id] = parent_id if parent_id
+
+    content
+  end
+
+  def fallback_build_default_settings_content(custom_settings = nil)
+    (custom_settings || settings).map do |definition|
+      { id: definition.id, value: definition.build_default_content }
+    end
+  end
+
+  def fallback_build_default_blocks_content
+    return [] if blocks.blank?
+
+    blocks.map do |block|
+      3.times.to_a.map do
+        {
+          type: block.type,
+          settings: fallback_build_default_settings_content(block.settings)
+        }
+      end
+    end.flatten
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/section/setting.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+class Maglev::Section::Setting
+  ## concerns ##
+  include ActiveModel::Model
+
+  ## attributes ##
+  attr_accessor :id, :label, :type, :default, :options
+
+  ## validations ##
+  validates :id, :label, :type, :default, 'maglev/presence': true
+  validates :type, inclusion: { in: %w[text image checkbox link color select collection_item icon] }
+
+  ## methods ##
+
+  # NOTE: any modification to that method must be reflected to the JS editor
+  def build_default_content(custom_default = nil)
+    default = custom_default.nil? ? self.default : custom_default
+    case type.to_sym
+    when :image then build_default_image_content(default)
+    when :link then build_default_link_content(default)
+    when :checkbox then build_default_checkbox_content(default)
+    else
+      default || label
+    end
+  end
+
+  def build_default_image_content(default)
+    default.is_a?(String) ? { url: default } : default || {}
+  end
+
+  def build_default_link_content(default)
+    default.is_a?(String) ? { link_type: 'url', href: default } : { link_type: 'url', href: '#' }.merge(default)
+  end
+
+  def build_default_checkbox_content(default)
+    default.presence || false
+  end
+
+  ## class methods ##
+  def self.build(hash)
+    attributes = hash.slice('id', 'label', 'type', 'default')
+    options = hash.except('id', 'label', 'type', 'default')
+
+    new(attributes.merge(options: options))
+  end
+
+  def self.build_many(list)
+    list.map { |hash| build(hash) }
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/section.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Maglev
+  class Section
+    include ActiveModel::Model
+    include ActiveModel::Serializers::JSON
+    include ::Maglev::Section::ContentConcern
+
+    HASH_ATTRIBUTES = %w[id theme name site_scoped singleton viewport_fixed_position insert_button max_width_pane
+                         insert_at category blocks_label blocks_presentation sample screenshot_timestamp].freeze
+
+    ## attributes ##
+    attr_accessor :id, :theme, :name, :category,
+                  :site_scoped, :singleton, :viewport_fixed_position,
+                  :insert_button, :insert_at, :max_width_pane,
+                  :settings, :blocks, :blocks_label, :blocks_presentation,
+                  :sample, :screenshot_timestamp
+
+    ## validations ##
+    validates :id, :theme, :name, :category, presence: true
+    validates :settings, 'maglev/collection': true
+    validates :blocks, 'maglev/collection': true
+
+    ## methods ##
+
+    def site_scoped?
+      !!site_scoped
+    end
+
+    def singleton?
+      !!singleton
+    end
+
+    def viewport_fixed_position?
+      !!viewport_fixed_position?
+    end
+
+    ## class methods ##
+    def self.build(hash)
+      attributes = prepare_attributes(hash)
+
+      new(
+        attributes.merge(
+          settings: ::Maglev::Section::Setting.build_many(hash['settings']),
+          blocks: ::Maglev::Section::Block.build_many(hash['blocks'])
+        )
+      )
+    end
+
+    def self.prepare_attributes(hash)
+      attributes = hash.slice(*HASH_ATTRIBUTES)
+
+      %w[site_scoped singleton viewport_fixed_position max_width_pane].each do |name|
+        attributes[name] = false if attributes[name].nil?
+      end
+
+      attributes['insert_button'] = true if attributes['insert_button'].nil?
+
+      attributes
+    end
+
+    class Store
+      extend Forwardable
+      def_delegators :@array, :all, :first, :last, :count, :each, :each_with_index, :map, :group_by
+
+      attr_reader :array
+
+      def initialize(array)
+        @array = array
+      end
+
+      def find(id)
+        @array.find { |section| section.id == id }
+      end
+
+      def grouped_by_category
+        @array.group_by(&:category)
+      end
+
+      def as_json(**_options)
+        @array.as_json
+      end
+    end
+  end
+end

data/app/models/maglev/site/locale.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+class Maglev::Site::Locale
+  ## concerns ##
+  include ActiveModel::Model
+
+  ## attributes ##
+  attr_accessor :label, :prefix
+
+  ## validations ##
+  validates :label, :prefix, 'maglev/presence': true
+
+  ## methods ##
+  def as_json(_options = nil)
+    { label: label, prefix: prefix }
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/site/locales_concern.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+module Maglev::Site::LocalesConcern
+  extend ActiveSupport::Concern
+
+  included do
+    ## serializers ##
+    serialize :locales, LocalesSerializer
+
+    ## validation ##
+    validates :locales, 'maglev/collection': true, length: { minimum: 1 }
+  end
+
+  def default_locale
+    locales.first
+  end
+
+  def default_locale_prefix
+    default_locale.prefix.to_sym
+  end
+
+  def locale_prefixes
+    locales.map { |locale| locale.prefix.to_sym }
+  end
+
+  class LocalesSerializer
+    def self.dump(array)
+      (array || []).map(&:as_json)
+    end
+
+    def self.load(array)
+      (array || []).map { |attributes| Maglev::Site::Locale.new(**attributes.symbolize_keys) }
+    end
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/site/style_value.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+class Maglev::Site::StyleValue
+  ## attributes ##
+  attr_accessor :id, :value, :type
+
+  def initialize(id, type, value)
+    @id = id
+    @type = type
+    @value = value
+  end
+
+  class Store
+    extend Forwardable
+    def_delegators :@array, :all, :first, :last, :count, :each, :each_with_index, :map, :group_by
+
+    attr_reader :array
+
+    def initialize(array)
+      @array = array
+    end
+
+    def method_missing(method_name, *_args)
+      setting = array.find { |local_setting| local_setting.id == method_name.to_s }
+      if setting
+        setting.value
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      Rails.logger.debug 'yeasss!!!'
+      array.map(&:id).include?(method_name.to_s) || super
+    end
+
+    def as_json(**_options)
+      @array.as_json
+    end
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/site.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Maglev
+  class Site < ApplicationRecord
+    ## concerns ##
+    include Maglev::Site::LocalesConcern
+    include Maglev::SectionsConcern
+    include Maglev::Translatable
+
+    ## translations ##
+    translates :sections
+
+    ## validations ##
+    validates :name, presence: true
+
+    ## methods ##
+    def api_attributes
+      %i[id name]
+    end
+
+    def find_section(type)
+      sections&.find { |section| section['type'] == type }
+    end
+  end
+end

data/app/models/maglev/static_page.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Mimic the Page model
+  class StaticPage
+    ## concerns ##
+    include ActiveModel::Model
+    include Maglev::Translatable
+
+    ## attributes ##
+    attr_accessor :id, :title_translations, :path_translations,
+                  :seo_title_translations, :meta_description_translations,
+                  :og_title_translations, :og_description_translations, :og_image_url_translations
+
+    ## translations ##
+    translates :title, :path, :seo_title, :meta_description, :og_title, :og_description, :og_image_url
+
+    ## methods ##
+
+    def visible
+      true
+    end
+
+    def static?
+      true
+    end
+
+    def sections
+      []
+    end
+
+    def path_hash
+      path_translations
+    end
+
+    def lock_version
+      0
+    end
+  end
+end

data/app/models/maglev/theme/section_category.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+class Maglev::Theme::SectionCategory
+  ## concerns ##
+  include ActiveModel::Model
+
+  ## attributes ##
+  attr_accessor :name, :id
+
+  ## class methods ##
+
+  def self.build(hash)
+    attributes = hash.slice('name', 'id')
+    attributes['id'] ||= attributes['name'].parameterize(separator: '_')
+    new(attributes)
+  end
+
+  def self.build_many(list)
+    (list || []).map { |hash| build(hash) }
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/theme/style_setting.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+class Maglev::Theme::StyleSetting
+  ## concerns ##
+  include ActiveModel::Model
+
+  ## attributes ##
+  attr_accessor :id, :label, :type, :default, :options
+
+  ## validations ##
+  validates :id, :label, :type, :default, 'maglev/presence': true
+  validates :type, inclusion: { in: %w[text color select checkbox] }
+
+  ## methods ##
+
+  # NOTE: any modification to that method must be reflected to the JS editor
+  def build_default_content(custom_default = nil)
+    default = custom_default || self.default
+    case type.to_sym
+    when :checkbox then build_default_checkbox_content(default)
+    else
+      default || label
+    end
+  end
+
+  def build_default_checkbox_content(default)
+    !default.nil?
+  end
+
+  ## class methods ##
+  def self.build(hash)
+    attributes = hash.slice('id', 'label', 'type', 'default')
+    options = hash.except('id', 'label', 'type', 'default')
+
+    new(attributes.merge(options: options))
+  end
+
+  def self.build_many(list)
+    list.map { |hash| build(hash) }
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/theme.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Maglev
+  class Theme
+    ## concerns ##
+    include ActiveModel::Model
+
+    ## attributes ##
+    attr_accessor :id, :name, :description, :section_categories, :sections, :style_settings, :pages, :icons
+
+    ## validations ##
+    validates :id, :name, presence: true
+
+    ## methods ##
+  end
+end

data/app/services/concerns/maglev/get_page_sections/transform_collection_item_concern.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+module Maglev::GetPageSections::TransformCollectionItemConcern
+  def transform_collection_item_content_setting(content, setting)
+    item_id = content.dig('value', 'id')
+    return if item_id.blank?
+
+    item = fetch_collection_items.call(
+      collection_id: setting.options[:collection_id],
+      id: item_id
+    )
+
+    content['value']['label'] = item.label
+    content['value']['item'] = item.source
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/app/services/concerns/maglev/get_page_sections/transform_link_concern.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+module Maglev::GetPageSections::TransformLinkConcern
+  def transform_link_content_setting(content, _setting)
+    return unless content['value'].is_a?(Hash) && %w[page static_page].include?(content.dig('value', 'link_type'))
+
+    content['value'] = replace_href_in_link(content['value'])
+  end
+
+  def replace_href_in_link(link)
+    path = get_fullpath_from_link(link)
+
+    if path
+      anchor = link['section_id']
+      link['href'] = anchor.present? ? "#{path}#section-#{anchor}" : path
+    end
+
+    link
+  end
+
+  def get_fullpath_from_link(link)
+    is_static_page = link['link_type'] == 'static_page'
+    page_id = link['link_id']
+
+    # since the static pages don't have a preview version, we need the raw url
+    if is_static_page
+      page = fetch_static_pages.call.find { |static_page| static_page.id == page_id }
+      page&.path
+    else
+      get_page_fullpath.call(page: page_id, locale: locale)
+    end
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/app/services/concerns/maglev/get_page_sections/transform_text_concern.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+module Maglev::GetPageSections::TransformTextConcern
+  def transform_text_content_setting(content, setting)
+    return unless setting.options['html']
+
+    content['value'] = replace_links_in_text(content['value'])
+  end
+
+  def replace_links_in_text(text)
+    text.gsub(/<a([^>]+)>/) do |tag|
+      link_type_matches = tag.match(/maglev-link-type="([^"]+)"/)
+      link_id_matches = tag.match(/maglev-link-id="([^"]+)"/)
+      section_id_matches = tag.match(/maglev-section-id="([^"]+)"/)
+      path = find_link_page_path(link_type_matches, link_id_matches, section_id_matches)
+
+      tag.gsub!(/href="([^"]+)"/, "href=\"#{path}\"") if path
+
+      tag
+    end
+  end
+
+  def find_link_page_path(link_type_matches, link_id_matches, section_id_matches)
+    return unless link_type_matches && link_id_matches
+
+    # rubocop:disable Style/StringHashKeys
+    link = { 'link_type' => link_type_matches[1], 'link_id' => link_id_matches[1] }
+    # rubocop:enable Style/StringHashKeys
+
+    return unless %w[page static_page].include?(link['link_type'])
+
+    link['section_id'] = section_id_matches[1] if section_id_matches
+
+    replace_href_in_link(link)['href']
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren