comfortable_media_surfer 3.0.0

data/lib/comfortable_media_surfer/render_methods.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::RenderMethods
+  def self.included(base)
+    # If application controller doesn't have template associated with it
+    # CMS will attempt to find one. This is so you don't have to explicitly
+    # call render cms_page: '/something'
+    base.rescue_from 'ActionView::MissingTemplate' do |e|
+      render cms_page: request.path
+    rescue ComfortableMediaSurfer::MissingPage, ComfortableMediaSurfer::MissingSite
+      raise e
+    end
+  end
+
+  # Now you can render cms_page simply by calling:
+  #   render cms_page: '/path/to/page'
+  # This way application controllers can use CMS content while populating
+  # instance variables that can be used in partials (that are included by
+  # by the cms page and/or layout)
+  #
+  # Or how about not worrying about setting up CMS pages and rendering
+  # application view using a CMS layout?
+  #   render cms_layout: 'layout_slug', cms_fragments: {
+  #     fragment_identifier_a: 'content text',
+  #     fragment_identifier_b: {template: 'path/to/template' },
+  #     fragment_identifier_c: {partial:  'path/to/partial' }
+  #   }
+  #
+  # This way you are populating page block content and rendering
+  # an instantialized CMS page.
+  #
+  # Site is loaded automatically based on the request. However you can force
+  # it by passing :cms_site parameter with site's slug. For example:
+  #   render cms_page: '/path/to/page', cms_site: 'default'
+  #
+  def render(options = {}, locals = {}, &block)
+    return super unless options.is_a?(Hash)
+
+    if (site_identifier = options.delete(:cms_site)) && !(@cms_site = Comfy::Cms::Site.find_by_identifier(site_identifier))
+      raise ComfortableMediaSurfer::MissingSite, site_identifier
+    end
+
+    if ((page_path = options.delete(:cms_page)) || (layout_identifier = options.delete(:cms_layout))) && !@cms_site ||= Comfy::Cms::Site.find_site(
+      request.host_with_port.downcase, request.fullpath
+    )
+      raise ComfortableMediaSurfer::MissingSite, "#{request.host.downcase}/#{request.fullpath}"
+    end
+
+    if page_path
+      render_cms_page(page_path, options, locals, &block)
+    elsif layout_identifier
+      render_cms_layout(layout_identifier, options, locals, &block)
+    else
+      super
+    end
+  end
+
+  def render_cms_page(path, options = {}, locals = {}, &block)
+    path.gsub!(%r{^/#{@cms_site.path}}, '') if @cms_site.path.present?
+
+    unless (@cms_page = @cms_site.pages.find_by_full_path(path))
+      raise ComfortableMediaSurfer::MissingPage, path
+    end
+
+    @cms_page.translate!
+
+    @cms_layout = @cms_page.layout
+    if (cms_fragments = options.delete(:cms_fragments)).present?
+      cms_fragments.each do |identifier, value|
+        content = value.is_a?(Hash) ? render_to_string(value.merge(layout: false)) : value.to_s
+        page_fragment = @cms_page.fragments.detect { |f| f.identifier == identifier.to_s } ||
+                        @cms_page.fragments.build(identifier: identifier.to_s)
+        page_fragment.content = content
+      end
+    end
+    cms_app_layout = @cms_layout.app_layout
+    options[:layout] ||= cms_app_layout.blank? ? nil : cms_app_layout
+    options[:inline] = @cms_page.render
+
+    render(options, locals, &block)
+  end
+
+  def render_cms_layout(identifier, options = {}, locals = {}, &block)
+    unless (@cms_layout = @cms_site.layouts.find_by_identifier(identifier))
+      raise ComfortableMediaSurfer::MissingLayout, identifier
+    end
+
+    cms_app_layout = @cms_layout.app_layout
+    cms_page = @cms_site.pages.build(layout: @cms_layout)
+    cms_fragments =
+      options.delete(:cms_fragments) || { content: render_to_string({ layout: false }.merge(options)) }
+
+    cms_fragments.each do |frag_identifier, value|
+      content = value.is_a?(Hash) ? render_to_string(value.merge(layout: false)) : value.to_s
+      cms_page.fragments.build(identifier: frag_identifier.to_s, content: content)
+    end
+    options[:layout] ||= cms_app_layout.blank? ? nil : cms_app_layout
+    options[:inline] = cms_page.render
+
+    render(options, locals, &block)
+  end
+end
+
+ActiveSupport.on_load :action_controller_base do
+  include ComfortableMediaSurfer::RenderMethods
+end

data/lib/comfortable_media_surfer/routing.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Routing
+  class ActionDispatch::Routing::Mapper
+    def comfy_route_cms_admin(path: 'admin')
+      scope module: :comfy, as: :comfy do
+        scope module: :admin do
+          namespace :cms, as: :admin_cms, path: path, except: :show do
+            get '/', to: 'base#jump'
+
+            concern :with_revisions do |options|
+              resources :revisions, options.merge(only: %i[index show]) do
+                patch :revert, on: :member
+              end
+            end
+
+            concern :with_reorder do
+              put :reorder, on: :collection
+            end
+
+            concern :with_form_fragments do
+              get :form_fragments, on: :member
+            end
+
+            resources :sites do
+              resources :pages do
+                concerns :with_reorder
+                concerns :with_form_fragments
+                concerns :with_revisions, controller: 'revisions/page'
+
+                get :toggle_branch, on: :member
+
+                resources :translations, except: [:index] do
+                  concerns :with_form_fragments
+                  concerns :with_revisions, controller: 'revisions/translation'
+                end
+              end
+
+              resources :files, concerns: [:with_reorder]
+
+              resources :layouts do
+                concerns :with_reorder
+                concerns :with_revisions, controller: 'revisions/layout'
+              end
+
+              resources :snippets do
+                concerns :with_reorder
+                concerns :with_revisions, controller: 'revisions/snippet'
+              end
+
+              resources :categories
+            end
+          end
+        end
+      end
+    end
+  end
+
+  class ActionDispatch::Routing::Mapper
+    def comfy_route_cms(options = {})
+      ComfortableMediaSurfer.configuration.public_cms_path = options[:path]
+
+      scope module: :comfy, as: :comfy do
+        namespace :cms, path: options[:path] do
+          get 'cms-css/:site_id/:identifier(/:cache_buster)' => 'assets#render_css', as: 'render_css'
+          get 'cms-js/:site_id/:identifier(/:cache_buster)'  => 'assets#render_js',  as: 'render_js'
+
+          get '(*cms_path)' => 'content#show', as: 'render_page', action: '/:format'
+        end
+      end
+    end
+  end
+
+  class ActionDispatch::Routing::Mapper
+    def comfy_route(identifier, options = {})
+      send("comfy_route_#{identifier}", **options)
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds/file/exporter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::File
+  class Exporter < ComfortableMediaSurfer::Seeds::Exporter
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, to, 'files/')
+    end
+
+    def export!
+      prepare_folder!(path)
+
+      site.files.each do |file|
+        file_path = File.join(path, file.attachment.filename.to_s)
+
+        # writing attributes
+        ::File.write(::File.join(path, "_#{file.attachment.filename}.yml"), {
+          'label' => file.label,
+          'description' => file.description,
+          'categories' => file.categories.map(&:label)
+        }.to_yaml)
+
+        # writing content
+        begin
+          ::File.binwrite(::File.join(path, ::File.basename(file_path)), file.attachment.download)
+        rescue Errno::ENOENT, OpenURI::HTTPError
+          message = "[CMS SEEDS] No physical File \t #{file.attachment.filename}"
+          ComfortableMediaSurfer.logger.warn(message)
+          next
+        end
+
+        message = "[CMS SEEDS] Exported File \t #{file.attachment.filename}"
+        ComfortableMediaSurfer.logger.info(message)
+      end
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds/file/importer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::File
+  class Importer < ComfortableMediaSurfer::Seeds::Importer
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, from, 'files/')
+    end
+
+    def import!
+      Dir["#{path}[^_]*"].each do |file_path|
+        filename = ::File.basename(file_path)
+
+        file = site.files.with_attached_attachment
+          .where('active_storage_blobs.filename' => filename).references(:blob).first ||
+               site.files.new
+
+        # We need to track actual file and its attributes
+        fresh_file = false
+
+        if File.exist?(attrs_path = File.join(path, "_#{filename}.yml")) && fresh_seed?(file, attrs_path)
+          fresh_file = true
+
+          attrs = YAML.safe_load_file(attrs_path)
+          category_ids = category_names_to_ids(file, attrs.delete('categories'))
+          file.attributes = attrs.merge(
+            category_ids: category_ids
+          )
+        end
+
+        if fresh_seed?(file, file_path)
+          fresh_file = true
+
+          file_handler = File.open(file_path)
+          file.file = {
+            io: file_handler,
+            filename: filename,
+            content_type: MimeMagic.by_magic(file_handler)
+          }
+        end
+
+        if fresh_file
+          if file.save
+            message = "[CMS SEEDS] Imported File \t #{file_path}"
+            ComfortableMediaSurfer.logger.info(message)
+          else
+            message = "[CMS SEEDS] Failed to import File \n#{file.errors.inspect}"
+            ComfortableMediaSurfer.logger.warn(message)
+          end
+        end
+
+        seed_ids << file.id
+      end
+
+      # cleaning up
+      site.files.where('id NOT IN (?)', seed_ids).destroy_all
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds/layout/exporter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::Layout
+  class Exporter < ComfortableMediaSurfer::Seeds::Exporter
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, to, 'layouts/')
+    end
+
+    def export!
+      prepare_folder!(path)
+
+      site.layouts.each do |layout|
+        layout_path = File.join(path, layout.ancestors.reverse.collect(&:identifier), layout.identifier)
+        FileUtils.mkdir_p(layout_path)
+
+        path = ::File.join(layout_path, 'content.html')
+        data = []
+
+        attrs = {
+          'label' => layout.label,
+          'app_layout' => layout.app_layout,
+          'position' => layout.position
+        }.to_yaml
+
+        data << { header: 'attributes',  content: attrs }
+        data << { header: 'content',     content: layout.content }
+        data << { header: 'js',          content: layout.js }
+        data << { header: 'css',         content: layout.css }
+
+        write_file_content(path, data)
+
+        message = "[CMS SEEDS] Exported Layout \t #{layout.identifier}"
+        ComfortableMediaSurfer.logger.info(message)
+      end
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds/layout/importer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::Layout
+  class Importer < ComfortableMediaSurfer::Seeds::Importer
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, from, 'layouts/')
+    end
+
+    def import!(path = self.path, parent = nil)
+      Dir["#{path}*/"].each do |layout_path|
+        import_layout(layout_path, parent)
+      end
+
+      # cleaning up
+      site.layouts.where('id NOT IN (?)', seed_ids).destroy_all
+    end
+
+  private
+
+    def import_layout(path, parent)
+      identifier = path.split('/').last
+
+      # reading file content in, resulting in a hash
+      content_path = File.join(path, 'content.html')
+      content_hash = parse_file_content(content_path)
+
+      # parsing attributes section
+      attributes_yaml = content_hash.delete('attributes')
+      attrs           = YAML.safe_load(attributes_yaml)
+
+      layout = site.layouts.where(identifier: identifier).first_or_initialize
+      layout.parent = parent
+
+      if fresh_seed?(layout, content_path)
+        layout.attributes = attrs.merge(
+          app_layout: attrs['app_layout'] || parent.try(:app_layout),
+          content: content_hash['content'],
+          js: content_hash['js'],
+          css: content_hash['css']
+        )
+
+        if layout.save
+          message = "[CMS SEEDS] Imported Layout \t #{layout.identifier}"
+          ComfortableMediaSurfer.logger.info(message)
+        else
+          message = "[CMS SEEDS] Failed to import Layout \n#{layout.errors.inspect}"
+          ComfortableMediaSurfer.logger.warn(message)
+        end
+      end
+
+      seed_ids << layout.id
+
+      # importing child layouts (if there are any)
+      Dir["#{path}*/"].each do |layout_path|
+        import_layout(layout_path, layout)
+      end
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds/page/exporter.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::Page
+  class Exporter < ComfortableMediaSurfer::Seeds::Exporter
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, to, 'pages/')
+    end
+
+    def export!
+      prepare_folder!(path)
+
+      site.pages.each do |page|
+        page.slug = 'index' if page.slug.blank?
+        page_path = File.join(path, page.ancestors.reverse.map { |p| p.slug.blank? ? 'index' : p.slug }, page.slug)
+        FileUtils.mkdir_p(page_path)
+
+        path = ::File.join(page_path, 'content.html')
+        data = []
+
+        attrs = {
+          'label' => page.label,
+          'layout' => page.layout.try(:identifier),
+          'target_page' => page.target_page.try(:full_path),
+          'categories' => page.categories.map(&:label),
+          'is_published' => page.is_published,
+          'position' => page.position
+        }.to_yaml
+
+        data << { header: 'attributes', content: attrs }
+        data += fragments_data(page, page_path)
+
+        write_file_content(path, data)
+
+        message = "[CMS SEEDS] Exported Page \t #{page.full_path}"
+        ComfortableMediaSurfer.logger.info(message)
+
+        export_translations(page, page_path)
+      end
+    end
+
+  private
+
+    def export_translations(page, page_path)
+      page.translations.each do |translation|
+        path = ::File.join(page_path, "content.#{translation.locale}.html")
+        data = []
+
+        attrs = {
+          'label' => translation.label,
+          'layout' => translation.layout.try(:identifier),
+          'is_published' => page.is_published
+        }.to_yaml
+
+        data << { header: 'attributes', content: attrs }
+        data += fragments_data(translation, page_path)
+
+        write_file_content(path, data)
+
+        message = "[CMS SEEDS] Exported Translation \t #{translation.locale}"
+        ComfortableMediaSurfer.logger.info(message)
+      end
+    end
+
+    # Collecting fragment data and writing attachment files to disk
+    def fragments_data(record, page_path)
+      record.fragments.collect do |frag|
+        header = "#{frag.tag} #{frag.identifier}"
+        content =
+          case frag.tag
+          when 'datetime', 'date'
+            frag.datetime
+          when 'checkbox'
+            frag.boolean
+          when 'file', 'files'
+            frag.attachments.map do |attachment|
+              ::File.binwrite(::File.join(page_path, attachment.filename.to_s), attachment.download)
+              attachment.filename
+            end.join("\n")
+          else
+            frag.content
+          end
+
+        { header: header, content: content }
+      end
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds/page/importer.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::Page
+  class Importer < ComfortableMediaSurfer::Seeds::Importer
+    # tracking target page linking. Since we might be linking to something that
+    # doesn't exist yet, we'll defer linking to the end of import
+    attr_accessor :target_pages
+
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, from, 'pages/')
+    end
+
+    def import!
+      import_page(File.join(path, 'index/'), nil)
+
+      link_target_pages
+
+      # Remove pages not found in seeds
+      site.pages.where('id NOT IN (?)', seed_ids).destroy_all
+    end
+
+  private
+
+    # Recursive function that will be called for each child page (subfolder)
+    def import_page(path, parent)
+      slug = path.split('/').last
+
+      # setting page record
+      page =
+        if parent.present?
+          child = site.pages.where(slug: slug).first_or_initialize
+          child.parent = parent
+          child
+        else
+          site.pages.root || site.pages.new(slug: slug)
+        end
+
+      content_path = File.join(path, 'content.html')
+
+      # If file is newer than page record we'll process it
+      if fresh_seed?(page, content_path)
+
+        # reading file content in, resulting in a hash
+        fragments_hash  = parse_file_content(content_path)
+
+        # parsing attributes section
+        attributes_yaml = fragments_hash.delete('attributes')
+        attrs           = YAML.safe_load(attributes_yaml)
+
+        # applying attributes
+        layout = site.layouts.find_by(identifier: attrs.delete('layout')) || parent.try(:layout)
+        category_ids    = category_names_to_ids(page, attrs.delete('categories'))
+        target_page     = attrs.delete('target_page')
+
+        page.attributes = attrs.merge(
+          layout: layout,
+          category_ids: category_ids
+        )
+
+        # applying fragments
+        old_frag_identifiers = page.fragments.pluck(:identifier)
+
+        new_frag_identifiers, fragments_attributes =
+          construct_fragments_attributes(fragments_hash, page, path)
+        page.fragments_attributes = fragments_attributes
+
+        if page.save
+          message = "[CMS SEEDS] Imported Page \t #{page.full_path}"
+          ComfortableMediaSurfer.logger.info(message)
+
+          # defering target page linking
+          if target_page.present?
+            self.target_pages ||= {}
+            self.target_pages[page.id] = target_page
+          end
+
+          # cleaning up old fragments
+          page.fragments.where(identifier: old_frag_identifiers - new_frag_identifiers).destroy_all
+
+        else
+          message = "[CMS SEEDS] Failed to import Page \n#{page.errors.inspect}"
+          ComfortableMediaSurfer.logger.warn(message)
+        end
+      end
+
+      import_translations(path, page)
+
+      # Tracking what page from seeds we're working with. So we can remove pages
+      # that are no longer in seeds
+      seed_ids << page.id
+
+      # importing child pages (if there are any)
+      Dir["#{path}*/"].each do |page_path|
+        import_page(page_path, page)
+      end
+    end
+
+    # Importing translations for given page. They look like `content.locale.html`
+    def import_translations(path, page)
+      old_translations = page.translations.pluck(:locale)
+      new_translations = []
+
+      Dir["#{path}content.*.html"].each do |file_path|
+        locale = File.basename(file_path).match(%r{content\.(\w+)\.html})[1]
+        new_translations << locale
+
+        translation = page.translations.where(locale: locale).first_or_initialize
+
+        next unless fresh_seed?(translation, file_path)
+
+        # reading file content in, resulting in a hash
+        fragments_hash  = parse_file_content(file_path)
+
+        # parsing attributes section
+        attributes_yaml = fragments_hash.delete('attributes')
+        attrs           = YAML.safe_load(attributes_yaml)
+
+        # applying attributes
+        layout = site.layouts.find_by(identifier: attrs.delete('layout')) || page.try(:layout)
+        translation.attributes = attrs.merge(
+          layout: layout
+        )
+
+        # applying fragments
+        old_frag_identifiers = translation.fragments.pluck(:identifier)
+
+        new_frag_identifiers, fragments_attributes =
+          construct_fragments_attributes(fragments_hash, translation, path)
+        translation.fragments_attributes = fragments_attributes
+
+        if translation.save
+          message = "[CMS SEEDS] Imported Translation \t #{locale}"
+          ComfortableMediaSurfer.logger.info(message)
+
+          # cleaning up old fragments
+          frags_to_remove = old_frag_identifiers - new_frag_identifiers
+          translation.fragments.where(identifier: frags_to_remove).destroy_all
+
+        else
+          message = "[CMS SEEDS] Failed to import Translation \n#{locale}"
+          ComfortableMediaSurfer.logger.warn(message)
+        end
+      end
+
+      # Cleaning up removed translations
+      translations_to_remove = old_translations - new_translations
+      page.translations.where(locale: translations_to_remove).destroy_all
+    end
+
+    # Constructing frag attributes hash that can be assigned to page or translation
+    # also returning list of frag identifiers so we can destroy old ones
+    def construct_fragments_attributes(hash, record, path)
+      frag_identifiers = []
+      frag_attributes = hash.collect do |frag_header, frag_content|
+        tag, identifier = frag_header.split
+        frag_hash = {
+          identifier: identifier,
+          tag: tag
+        }
+
+        # tracking fragments that need removing later
+        frag_identifiers << identifier
+
+        # based on tag we need to cram content in proper place and proper format
+        case tag
+        when 'date', 'datetime'
+          frag_hash[:datetime] = frag_content
+        when 'checkbox'
+          frag_hash[:boolean] = frag_content
+        when 'file', 'files'
+          files, file_ids_destroy = files_content(record, identifier, path, frag_content)
+          frag_hash[:files]            = files
+          frag_hash[:file_ids_destroy] = file_ids_destroy
+        else
+          frag_hash[:content] = frag_content
+        end
+
+        frag_hash
+      end
+
+      [frag_identifiers, frag_attributes]
+    end
+
+    # Preparing fragment attachments. Returns hashes with file data for
+    # ActiveStorage and a list of ids of old attachements to destroy
+    def files_content(record, identifier, path, frag_content)
+      # preparing attachments
+      files = frag_content.split("\n").collect do |filename|
+        file_handler = File.open(File.join(path, filename))
+        {
+          io: file_handler,
+          filename: filename,
+          content_type: MimeMagic.by_magic(file_handler)
+        }
+      end
+
+      # ensuring that old attachments get removed
+      ids_destroy = []
+      if (frag = record.fragments.find_by(identifier: identifier))
+        ids_destroy = frag.attachments.pluck(:id)
+      end
+
+      [files, ids_destroy]
+    end
+
+    def link_target_pages
+      return unless self.target_pages.present?
+
+      self.target_pages.each do |page_id, target|
+        if (target = site.pages.find_by(full_path: target))
+          @site.pages.find(page_id).update_column(:target_page_id, target.id)
+        end
+      end
+    end
+  end
+end