maglevcms 1.0.0.rc1

data/app/services/maglev/app_container.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Maglev
+  class AppContainer
+    include Injectable
+
+    dependency :config do
+      Maglev.config
+    end
+
+    # hold the Rails request context
+    dependency :context
+
+    dependency :fetch_site,                 class: Maglev::FetchSite, depends_on: %i[config context]
+    dependency :fetch_theme,                class: Maglev::FetchTheme, depends_on: %i[fetch_site context]
+    dependency :fetch_theme_layout,         class: Maglev::FetchThemeLayout, depends_on: %i[fetch_theme]
+    dependency :fetch_style,                class: Maglev::FetchStyle
+    dependency :fetch_sections_path,        class: Maglev::FetchSectionsPath, depends_on: :fetch_theme
+    dependency :fetch_section_screenshot_path, class: Maglev::FetchSectionScreenshotPath,
+                                               depends_on: :fetch_sections_path
+    dependency :fetch_section_screenshot_url, class: Maglev::FetchSectionScreenshotUrl,
+                                              depends_on: :fetch_section_screenshot_path
+
+    dependency :fetch_collection_items, class: Maglev::FetchCollectionItems, depends_on: %i[fetch_site config]
+    dependency :fetch_static_pages, class: Maglev::FetchStaticPages, depends_on: %i[config]
+    dependency :search_pages, class: Maglev::SearchPages, depends_on: %i[fetch_site fetch_static_pages]
+
+    dependency :get_base_url,               class: Maglev::GetBaseUrl, depends_on: %i[context fetch_site]
+    dependency :extract_locale,             class: Maglev::ExtractLocale
+
+    dependency :persist_section_screenshot, class: Maglev::PersistSectionScreenshot,
+                                            depends_on: %i[fetch_theme fetch_section_screenshot_path]
+
+    dependency :fetch_page,                 class: Maglev::FetchPage, depends_on: :fetch_site
+    dependency :get_page_fullpath,          class: Maglev::GetPageFullpath, depends_on: %i[fetch_site get_base_url]
+    dependency :get_page_sections,          class: Maglev::GetPageSections,
+                                            depends_on: %i[fetch_site fetch_theme
+                                                           fetch_static_pages
+                                                           fetch_collection_items get_page_fullpath]
+    dependency :get_page_section_names,     class: Maglev::GetPageSectionNames, depends_on: :fetch_theme
+    dependency :clone_page,                 class: Maglev::ClonePage, depends_on: :fetch_site
+    dependency :persist_page,               class: Maglev::PersistPage, depends_on: %i[fetch_theme]
+
+    def call
+      self
+    end
+  end
+end

data/app/services/maglev/change_site_locales.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Change the locales of a site.
+  # The new locales are an array of maps with 2 required keys: :name & :prefix.
+  class ChangeSiteLocales
+    include Injectable
+
+    argument :site
+    argument :locales
+
+    def call
+      return if locales.blank?
+
+      if default_locale_changed? && !all_paths_translated?
+        raise 'The translations for the new default locale are incomplete'
+      end
+
+      site.update(locales: locales)
+    end
+
+    protected
+
+    def new_default_locale_prefix
+      locales.first.prefix.to_sym
+    end
+
+    def default_locale_changed?
+      new_default_locale_prefix != site.default_locale_prefix
+    end
+
+    def all_paths_translated?
+      Maglev::PagePath.where(locale: site.default_locale_prefix).count ==
+        Maglev::PagePath.where(locale: new_default_locale_prefix).count
+    end
+  end
+end

data/app/services/maglev/clone_page.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Clone a page in all the locales.
+  # The service also makes sure that
+  # the path of the cloned page will be unique.
+  class ClonePage
+    include Injectable
+
+    argument :page
+
+    def call
+      return nil unless page.persisted?
+
+      create_page!
+    end
+
+    protected
+
+    def create_page!
+      Maglev::Page.new(cloned_attributes).tap do |cloned_page|
+        cloned_page.disable_spawn_redirection
+        clone_paths(cloned_page)
+        cloned_page.save!
+      end
+    end
+
+    private
+
+    def cloned_attributes
+      {
+        title_translations: clone_title,
+        seo_title_translations: page.seo_title_translations,
+        meta_description_translations: page.meta_description_translations,
+        og_title_translations: page.og_title_translations,
+        og_description_translations: page.og_description_translations,
+        og_image_url_translations: page.og_image_url_translations,
+        sections_translations: page.sections_translations
+      }
+    end
+
+    def clone_title
+      page.title_translations.transform_values do |title|
+        ::I18n.t('activerecord.attributes.maglev/page.cloned_title', title: title)
+      end
+    end
+
+    def clone_paths(cloned_page)
+      code = generate_clone_code(4)
+      page.path_hash.each do |locale, path|
+        Maglev::I18n.with_locale(locale) do
+          cloned_page.path = "#{path}-#{code}"
+        end
+      end
+    end
+
+    def generate_clone_code(number)
+      charset = Array('A'..'Z') + Array('a'..'z')
+      Array.new(number) { charset.sample }.join
+    end
+  end
+end

data/app/services/maglev/extract_locale.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Extract the locale from the current HTTP request
+  # and set the Translatable.current_locale accordingly
+  class ExtractLocale
+    include Injectable
+
+    argument :params
+    argument :locales
+
+    def call
+      locale, path = extract_locale
+
+      Maglev::I18n.current_locale = locale
+
+      params[:path] = path
+
+      [path, locale]
+    end
+
+    protected
+
+    def extract_locale
+      segments = params[:path].split('/')
+
+      return [default_locale, params[:path]] unless locales.include?(segments[0]&.to_sym)
+
+      [segments.shift, segments.empty? ? 'index' : segments.join('/')]
+    end
+
+    def default_locale
+      locales.first
+    end
+  end
+end

data/app/services/maglev/fetch_collection_items.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Find item(s) from a collection defined in the Maglev config file.
+  # If the id is specified, then look for an item, it not, look for all the items
+  # matching a keyword.
+  class FetchCollectionItems
+    include Injectable
+
+    dependency :config
+    dependency :fetch_site
+
+    argument :collection_id
+    argument :id, default: nil
+    argument :keyword, default: nil
+    argument :max_items, default: 10
+
+    def call
+      if id
+        fetch_item
+      else
+        fetch_items
+      end
+    end
+
+    private
+
+    def fetch_items
+      fetch_original_items.map do |original_item|
+        build_item(original_item)
+      end
+    end
+
+    def fetch_item
+      build_item(
+        fetch_original_items.find_by(id: id)
+      )
+    end
+
+    def fetch_original_items
+      return default_fetch_original_items unless fetch_method_name
+
+      model_class.public_send(fetch_method_name,
+                              site: fetch_site.call,
+                              keyword: keyword,
+                              max_items: max_items)
+    end
+
+    def default_fetch_original_items
+      model_class
+        .where(keyword.present? ? model_class.arel_table[label_field].matches("%#{keyword}%") : nil)
+        .limit(max_items)
+        .order(label_field)
+    end
+
+    def model_class
+      collection[:model].constantize
+    end
+
+    def label_field
+      collection.dig(:fields, :label)&.to_sym
+    end
+
+    def image_field
+      collection.dig(:fields, :image)&.to_sym
+    end
+
+    def item_label(item)
+      item[label_field]
+    end
+
+    def item_image(item)
+      image_field && item.respond_to?(image_field) ? item.public_send(image_field) : nil
+    end
+
+    def fetch_method_name
+      collection[:fetch_method_name]
+    end
+
+    def collection
+      config.collections[collection_id.to_sym]
+    end
+
+    def build_item(original_item)
+      return nil unless original_item
+
+      Item.new(
+        original_item.id,
+        item_label(original_item),
+        item_image(original_item),
+        original_item
+      )
+    end
+
+    Item = Struct.new(:id, :label, :image_url, :source)
+  end
+end

data/app/services/maglev/fetch_page.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Retrieve a page from a path and a locale
+  # (previously extracted by the ExtractLocale service)
+  class FetchPage
+    include Injectable
+
+    argument :path
+    argument :locale
+    argument :default_locale
+    argument :fallback_to_default_locale, default: false
+
+    def call
+      page = fetch_page(path, locale)
+      page = fetch_page(path, default_locale) if !page && fallback_to_default_locale
+      page
+    end
+
+    protected
+
+    def fetch_page(path, locale)
+      Maglev::Page.by_path(path || 'index', locale).first
+    end
+  end
+end

data/app/services/maglev/fetch_section_screenshot_path.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Maglev
+  class FetchSectionScreenshotPath
+    include Injectable
+
+    dependency :fetch_sections_path
+    argument :theme, default: nil
+    argument :section
+    argument :absolute, default: false
+
+    def call
+      path = "#{fetch_sections_path.call(theme: theme)}/#{section.category}/#{section.id}.jpg"
+      absolute ? "#{Rails.root}/public/#{path}" : "/#{path}"
+    end
+  end
+end

data/app/services/maglev/fetch_section_screenshot_url.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Maglev
+  class FetchSectionScreenshotUrl
+    include Injectable
+
+    dependency :fetch_section_screenshot_path
+    argument :section
+
+    def call
+      fetch_section_screenshot_path.call(section: section) + "?#{section.screenshot_timestamp}"
+    end
+  end
+end

data/app/services/maglev/fetch_sections_path.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Maglev
+  class FetchSectionsPath
+    include Injectable
+
+    argument :theme, default: nil
+
+    def call
+      'theme'
+    end
+  end
+end

data/app/services/maglev/fetch_site.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Fetch the site and set up the Translatable available locales
+  class FetchSite
+    include Injectable
+
+    def call
+      Maglev::Site.first.tap do |site|
+        change_default_locales(site)
+      end
+    end
+
+    private
+
+    def change_default_locales(site)
+      Maglev::I18n.available_locales = site.locale_prefixes
+    end
+  end
+end

data/app/services/maglev/fetch_static_pages.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Editors might want to create a link to a non Maglev powered page of the site.
+  class FetchStaticPages
+    include Injectable
+
+    dependency :config
+
+    def call
+      return [] if config.static_pages.blank?
+
+      build_static_pages
+    end
+
+    protected
+
+    def build_static_pages
+      @build_static_pages ||= config.static_pages.map do |raw_attributes|
+        build_static_page(raw_attributes.symbolize_keys)
+      end
+    end
+
+    def build_static_page(attributes)
+      Maglev::StaticPage.new(
+        id: fetch_id(attributes),
+        title_translations: fetch_attribute(attributes, :title),
+        path_translations: fetch_path_attribute(attributes),
+        seo_title_translations: {},
+        meta_description_translations: {},
+        og_title_translations: {},
+        og_description_translations: {},
+        og_image_url_translations: {}
+      )
+    end
+
+    def fetch_id(attributes)
+      Digest::MD5.hexdigest(fetch_path_attribute(attributes).to_json)
+    end
+
+    def fetch_path_attribute(attributes)
+      fetch_attribute(attributes, :path)
+    end
+
+    def fetch_attribute(attributes, name)
+      value = attributes[name]
+      return {} if value.blank?
+
+      value.is_a?(Hash) ? value.stringify_keys : { default_locale => value }
+    end
+
+    def default_locale
+      (config.default_site_locales&.first&.prefix || Maglev::I18n.current_locale).to_s
+    end
+  end
+end

data/app/services/maglev/fetch_style.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Fetch the style of a site. Use default values from the theme if needed.
+  class FetchStyle
+    include Injectable
+
+    argument :site
+    argument :theme
+
+    def call
+      Maglev::Site::StyleValue::Store.new(
+        build_style_value_list
+      )
+    end
+
+    protected
+
+    def build_style_value_list
+      theme.style_settings.map do |setting|
+        build_style_value(setting)
+      end
+    end
+
+    def build_style_value(setting)
+      Maglev::Site::StyleValue.new(
+        setting.id,
+        setting.type,
+        custom_value(setting)
+      )
+    end
+
+    def custom_value(setting)
+      value = site.style.find { |local_value| local_value['id'] == setting.id }
+      value && value['type'] == setting.type ? value['value'] : setting.default
+    end
+  end
+end

data/app/services/maglev/fetch_theme.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Fetch the current theme
+  class FetchTheme
+    include Injectable
+
+    def call
+      Maglev.local_themes.first
+    end
+  end
+end

data/app/services/maglev/fetch_theme_layout.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Return the path of the layout folder
+  class FetchThemeLayout
+    include Injectable
+
+    dependency :fetch_theme
+
+    def call
+      'theme/layout'
+    end
+  end
+end

data/app/services/maglev/generate_site.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Generate site and its pages in the locales defined by the config file.
+  class GenerateSite
+    include Injectable
+
+    dependency(:config) { Maglev.config }
+    dependency :setup_pages, class: Maglev::SetupPages
+
+    argument :theme
+
+    def call
+      raise 'A Maglev Site already exists' if Maglev::Site.first
+
+      Maglev::Site.transaction do
+        Maglev::Site.create(name: 'Default', locales: config.default_site_locales).tap do |site|
+          Maglev::I18n.available_locales = site.locale_prefixes
+          Maglev::I18n.with_locale(site.default_locale_prefix) do
+            setup_pages.call(site: site, theme: theme) if site.errors.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/maglev/get_base_url.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Get the url used to build the URLs of the pages.
+  # In the preview mode, we need the maglev root path.
+  class GetBaseUrl
+    include Injectable
+
+    dependency :context
+    dependency :fetch_site
+
+    argument :preview_mode, default: nil
+
+    def call
+      preview_mode? ? site_preview_path : live_url
+    end
+
+    private
+
+    def preview_mode?
+      preview_mode.nil? ? context.rendering_mode == :editor : preview_mode
+    end
+
+    def site_preview_path
+      context.controller.site_preview_path
+    end
+
+    def live_url
+      nil
+    end
+  end
+end

data/app/services/maglev/get_page_fullpath.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Get the full path of a page (locale + path).
+  # It relies on the GetBaseUrl service to get the base url.
+  class GetPageFullpath
+    include Injectable
+
+    dependency :fetch_site
+    dependency :get_base_url
+
+    argument :page, default: nil
+    argument :path, default: nil
+    argument :preview_mode, default: nil
+    argument :locale
+
+    def call
+      base_url = get_base_url.call(preview_mode: preview_mode)
+      safe_path = path || fetch_path
+
+      return unless safe_path
+
+      build_fullpath(base_url, safe_path)
+    end
+
+    protected
+
+    def fetch_path
+      paths = if page.respond_to?(:path_translations)
+                # static pages already have all the translated paths
+                page.path_translations.stringify_keys
+              else
+                # we need to request the DB to get the paths in all the locales
+                fetch_paths
+              end
+
+      paths[locale.to_s] || paths[default_locale.to_s]
+    end
+
+    def fetch_paths
+      page_id = page.respond_to?(:path) ? page.id : page
+      Maglev::PagePath.build_hash(page_id)
+    end
+
+    def build_fullpath(base_url, path)
+      fullpath = [base_url]
+      fullpath.push(locale) unless same_as_default_locale?
+      fullpath.push(path) unless path == 'index' # for SEO purpose)
+      fullpath.push(nil) if fullpath == [nil] # avoid "" as the fullpath
+      fullpath.join('/')
+    end
+
+    def site
+      @site ||= fetch_site.call
+    end
+
+    def same_as_default_locale?
+      locale.to_s == default_locale.to_s
+    end
+
+    def default_locale
+      site.default_locale.prefix
+    end
+  end
+end

data/app/services/maglev/get_page_section_names.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Maglev
+  # Get an array of maps including the id and name of each page section.
+  class GetPageSectionNames
+    include Injectable
+
+    dependency :fetch_theme
+
+    argument :page
+
+    def call
+      (page.sections || []).map do |section|
+        definition = theme.sections.find(section['type'])
+        { id: section['id'], name: definition.name }
+      end
+    end
+
+    protected
+
+    def theme
+      fetch_theme.call
+    end
+  end
+end