comfy_middle_seat 3.2.0

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

@@ -0,0 +1,245 @@
+# 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, parent_id: parent.id).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_saved = begin
+          page.fragments_attributes = fragments_attributes
+          page.save
+        ensure
+          close_fragment_files(fragments_attributes)
+        end
+
+        if page_saved
+          message = "[CMS SEEDS] Imported Page \t #{page.full_path}"
+          ComfortableMediaSurfer.logger.info(message)
+
+          # defering target page linking
+          if target_page.present?
+            self.target_pages ||= {}
+            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_saved = begin
+          translation.fragments_attributes = fragments_attributes
+          translation.save
+        ensure
+          close_fragment_files(fragments_attributes)
+        end
+
+        if translation_saved
+          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").each do |filename|
+        file_handler = File.new(File.join(path, filename), 'rb')
+        attachment = {
+          io: file_handler,
+          filename: filename
+        }
+        files << attachment
+        attachment[: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]
+    rescue StandardError
+      close_files(files)
+      raise
+    end
+
+    def close_fragment_files(fragment_attributes)
+      fragment_attributes.each do |attributes|
+        close_files(attributes[:files])
+      end
+    end
+
+    def close_files(files)
+      Array(files).each do |file|
+        io = file[:io]
+        io.close unless io.closed?
+      end
+    end
+
+    def link_target_pages
+      return unless target_pages.present?
+
+      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

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::Snippet
+  class Exporter < ComfortableMediaSurfer::Seeds::Exporter
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, to, 'snippets/')
+    end
+
+    def export!
+      prepare_folder!(path)
+
+      site.snippets.each do |snippet|
+        attrs = {
+          'label' => snippet.label,
+          'categories' => snippet.categories.map(&:label),
+          'position' => snippet.position
+        }.to_yaml
+
+        data = []
+        data << { header: 'attributes', content: attrs }
+        data << { header: 'content', content: snippet.content }
+
+        snippet_path = File.join(path, "#{snippet.identifier}.html")
+        write_file_content(snippet_path, data)
+
+        message = "[CMS SEEDS] Exported Snippet \t #{snippet.identifier}"
+        ComfortableMediaSurfer.logger.info(message)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::Snippet
+  class Importer < ComfortableMediaSurfer::Seeds::Importer
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, from, 'snippets/')
+    end
+
+    def import!
+      Dir.glob("#{path}/*.html").each do |path|
+        identifier = File.basename(path, '.html')
+
+        # reading file content in, resulting in a hash
+        content_hash = parse_file_content(path)
+
+        # parsing attributes section
+        attributes_yaml = content_hash.delete('attributes')
+        attrs           = YAML.safe_load(attributes_yaml)
+
+        snippet = site.snippets.where(identifier: identifier).first_or_initialize
+
+        if fresh_seed?(snippet, path)
+          category_ids = category_names_to_ids(snippet, attrs.delete('categories'))
+
+          snippet.attributes = attrs.merge(
+            category_ids: category_ids,
+            content: content_hash['content']
+          )
+
+          if snippet.save
+            ComfortableMediaSurfer.logger.info("[CMS SEEDS] Imported Snippet \t #{snippet.identifier}")
+          else
+            ComfortableMediaSurfer.logger.warn("[CMS SEEDS] Failed to import Snippet \n#{snippet.errors.inspect}")
+          end
+        end
+
+        # Tracking what page from seeds we're working with. So we can remove pages
+        # that are no longer in seeds
+        seed_ids << snippet.id
+      end
+
+      # cleaning up
+      site.snippets.where('id NOT IN (?)', seed_ids).destroy_all
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds
+  SEED_CLASSES = %w[Layout Page Snippet File].freeze
+
+  class Error < StandardError; end
+
+  require 'mimemagic'
+
+  class Importer
+    attr_accessor :site,
+                  :path,
+                  :from,
+                  :to,
+                  :seed_ids
+
+    # `from` and `to` indicate site identifier and folder name
+    def initialize(from, to = from)
+      self.from         = from
+      self.to           = to
+      self.site         = Comfy::Cms::Site.where(identifier: to).first!
+      self.seed_ids     = []
+
+      return if ::File.exist?(path = ::File.join(ComfortableMediaSurfer.config.seeds_path, from))
+
+      raise Error, "Folder for import: '#{path}' is not found"
+    end
+
+    # if passed nil will use default seed classes
+    def import!(classes = nil)
+      classes ||= SEED_CLASSES
+      classes.each do |klass|
+        klass = "ComfortableMediaSurfer::Seeds::#{klass}::Importer"
+        klass.constantize.new(from, to).import!
+      end
+    end
+
+  private
+
+    # Splitting file content in sections delimited by headers that look like this:
+    #   [header]
+    #   some content
+    #   [header 2]
+    #   some more content
+    def parse_file_content(file_path)
+      text = ::File.read(file_path)
+      tokens = text.split(%r{^\[(.*?)\]\r?\n})
+      tokens.shift # first item should be blank
+      tokens.in_groups_of(2).to_h
+    end
+
+    def fresh_seed?(object, file_path)
+      object.new_record? || ::File.mtime(file_path) > object.updated_at
+    end
+
+    def category_names_to_ids(record, names)
+      [names].flatten.map do |name|
+        category = site.categories.find_or_create_by(
+          label: name,
+          categorized_type: record.class.to_s
+        )
+        category.id
+      end
+    end
+  end
+
+  class Exporter
+    attr_accessor :site,
+                  :path,
+                  :from,
+                  :to
+
+    def initialize(from, to = from)
+      self.from = from
+      self.to   = to
+      self.site = Comfy::Cms::Site.where(identifier: from).first!
+    end
+
+    # if passed nil will use default seed classes
+    def export!(classes = nil)
+      classes ||= SEED_CLASSES
+      classes.each do |klass|
+        klass = "ComfortableMediaSurfer::Seeds::#{klass}::Exporter"
+        klass.constantize.new(from, to).export!
+      end
+    end
+
+  private
+
+    # Writing to the seed file. Takes in file handler and array of hashes with
+    # `header` and `content` keys
+    def write_file_content(path, data)
+      ::File.open(::File.join(path), 'wb') do |f|
+        data.each do |item|
+          f.write("[#{item[:header]}]\n#{item[:content]}")
+          # adds a newline between items if not already there
+          # makes sure last item does not have a newline
+          if data.last != item && !item[:content].to_s.end_with?("\n")
+            f.write("\n")
+          end
+        end
+      end
+    end
+
+    def prepare_folder!(path)
+      FileUtils.rm_rf(path)
+      FileUtils.mkdir_p(path)
+    end
+  end
+end

data/lib/comfortable_media_surfer/version.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative '../comfy_middle_seat/version'

data/lib/comfortable_media_surfer/view_hooks.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# This mechanism is used by 3rd party plugins.
+# Normally you'd use partials from your own app
+module ComfortableMediaSurfer::ViewHooks
+  # Array of declared hooks
+  def self.hooks
+    @hooks ||= {}
+  end
+
+  # Renders hook content
+  def self.render(name, template, options = {})
+    out = ''
+    (hooks[name.to_sym] || []).each do |path|
+      out += template.render({ partial: path.first }.merge(options))
+    end
+    out.html_safe
+  end
+
+  # Will declare a partial that will be rendered for this hook
+  # Example:
+  # ComfortableMediaSurfer::ViewHooks.add(:navigation, 'shared/navigation')
+  def self.add(name, partial_path, position = 0)
+    hooks[name.to_sym] ||= []
+    hooks[name.to_sym] << [partial_path, position]
+    hooks[name.to_sym].sort_by!(&:last)
+  end
+
+  # Removing previously declared hook
+  def self.remove(name)
+    hooks.delete(name)
+  end
+end

data/lib/comfortable_media_surfer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Loading engine only if this is not a standalone installation
+unless defined? ComfortableMediaSurfer::Application
+  require_relative 'comfortable_media_surfer/engine'
+end
+
+require_relative 'comfortable_media_surfer/version'
+require_relative 'comfortable_media_surfer/error'
+require_relative 'comfortable_media_surfer/configuration'
+require_relative 'comfortable_media_surfer/routing'
+require_relative 'comfortable_media_surfer/access_control/admin_authentication'
+require_relative 'comfortable_media_surfer/access_control/admin_authorization'
+require_relative 'comfortable_media_surfer/access_control/public_authentication'
+require_relative 'comfortable_media_surfer/access_control/public_authorization'
+require_relative 'comfortable_media_surfer/render_methods'
+require_relative 'comfortable_media_surfer/view_hooks'
+require_relative 'comfortable_media_surfer/form_builder'
+require_relative 'comfortable_media_surfer/seeds'
+require_relative 'comfortable_media_surfer/seeds/layout/importer'
+require_relative 'comfortable_media_surfer/seeds/layout/exporter'
+require_relative 'comfortable_media_surfer/seeds/page/importer'
+require_relative 'comfortable_media_surfer/seeds/page/exporter'
+require_relative 'comfortable_media_surfer/seeds/snippet/importer'
+require_relative 'comfortable_media_surfer/seeds/snippet/exporter'
+require_relative 'comfortable_media_surfer/seeds/file/importer'
+require_relative 'comfortable_media_surfer/seeds/file/exporter'
+require_relative 'comfortable_media_surfer/content'
+require_relative 'comfortable_media_surfer/extensions'
+
+module ComfortableMediaSurfer
+  Version = ComfortableMediaSurfer::VERSION
+
+  class << self
+    attr_writer :logger
+
+    # Modify CMS configuration
+    # Example:
+    #   ComfortableMediaSurfer.configure do |config|
+    #     config.cms_title = 'ComfortableMediaSurfer'
+    #   end
+    def configure
+      yield configuration
+    end
+
+    # Accessor for ComfortableMediaSurfer::Configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
+    alias config configuration
+
+    def logger
+      @logger ||= Rails.logger
+    end
+  end
+end

data/lib/comfy_middle_seat/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer
+  VERSION = '3.2.0'
+end

data/lib/comfy_middle_seat.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'comfortable_media_surfer'

data/lib/generators/comfy/cms/README

@@ -0,0 +1,21 @@
+    ____                 __            _        _     _      
+   / ___|___  _ __ ___  / _| ___  _ __| |_ __ _| |__ | | ___ 
+  | |   / _ \| '_ ` _ \| |_ / _ \| '__| __/ _` | '_ \| |/ _ \
+  | |__| (_) | | | | | |  _| (_) | |  | || (_| | |_) | |  __/
+   \____\___/|_| |_| |_|_|  \___/|_|   \__\__,_|_.__/|_|\___|
+  __  __          _ _         ____              __
+  |  \/  | ___  __| (_) __ _  / ___| _   _ _ __ / _| ___ _ __
+  | |\/| |/ _ \/ _` | |/ _` | \___ \| | | | '__| |_ / _ \ '__|
+  | |  | |  __/ (_| | | (_| |  ___) | |_| | |  |  _|  __/ |
+  |_|  |_|\___|\__,_|_|\__,_| |____/ \__,_|_|  |_|  \___|_|
+
+You are almost done.  Don't forget to:
+
+  [Optional] - If you want to store files in your CMS with ActiveStorage: `rails active_storage:install`
+  [Mandatory] - Create the tables in your database: `rails db:migrate`
+  [Mandatory] - Run `rails comfy:compile_assets`
+
+Then go to http://your-rails-app/admin to start adding content.
+
+Default username and password are: user / pass
+Change these defaults in config/initializers/comfortable_media_surfer.rb

data/lib/generators/comfy/cms/assets_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Comfy
+  module Generators
+    module Cms
+      class AssetsGenerator < Rails::Generators::Base
+        source_root File.expand_path(File.join(File.dirname(__FILE__), '../../../../app/assets'))
+
+        def generate_assets
+          directory 'javascripts/comfy/admin/cms', 'app/assets/javascripts/comfy/admin/cms'
+          directory 'stylesheets/comfy/admin/cms', 'app/assets/stylesheets/comfy/admin/cms'
+        end
+      end
+    end
+  end
+end

data/lib/generators/comfy/cms/cms_generator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'rails/generators/active_record'
+
+module Comfy
+  module Generators
+    class CmsGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      include Thor::Actions
+
+      source_root File.expand_path('../../../..', __dir__)
+
+      def generate_migration
+        %w[01_create_cms 02_add_markdown_to_snippets].each do |migration|
+          destination   = File.expand_path("db/migrate/#{migration}.rb", destination_root)
+          migration_dir = File.dirname(destination)
+          destination   = self.class.migration_exists?(migration_dir, migration)
+
+          if destination
+            puts "\e[0m\e[31mFound existing #{migration}.rb migration. Remove it if you want to regenerate.\e[0m"
+          else
+            migration_template "db/migrate/#{migration}.rb", "db/migrate/#{migration[3..]}.rb"
+          end
+        end
+      end
+
+      def generate_initializer
+        copy_file 'config/initializers/comfortable_media_surfer.rb',
+                  'config/initializers/comfortable_media_surfer.rb'
+      end
+
+      def generate_railties_order
+        application <<~RUBY
+          # Ensuring that ActiveStorage routes are loaded before Comfy's globbing
+          # route. Without this file serving routes are inaccessible.
+          config.railties_order = [ActiveStorage::Engine, :main_app, :all]
+        RUBY
+      end
+
+      def generate_routing
+        route_string = <<~RUBY
+          comfy_route :cms_admin, path: "/admin"
+          # Ensure that this route is defined last
+          comfy_route :cms, path: "/"
+        RUBY
+        route route_string
+      end
+
+      def generate_cms_seeds
+        directory 'db/cms_seeds', 'db/cms_seeds'
+      end
+
+      def generate_assets
+        copy_file 'app/assets/javascripts/comfy/admin/cms/custom.js',
+                  'app/assets/javascripts/comfy/admin/cms/custom.js'
+        copy_file 'app/assets/stylesheets/comfy/admin/cms/custom.sass',
+                  'app/assets/stylesheets/comfy/admin/cms/custom.sass'
+      end
+
+      def show_readme
+        readme 'lib/generators/comfy/cms/README'
+      end
+
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+    end
+  end
+end

data/lib/generators/comfy/cms/controllers_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Comfy
+  module Generators
+    module Cms
+      class ControllersGenerator < Rails::Generators::Base
+        source_root File.expand_path(File.join(File.dirname(__FILE__), '../../../../app/controllers'))
+
+        def generate_controllers
+          directory 'comfy', 'app/controllers/comfy'
+        end
+      end
+    end
+  end
+end

data/lib/generators/comfy/cms/models_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Comfy
+  module Generators
+    module Cms
+      class ModelsGenerator < Rails::Generators::Base
+        source_root File.expand_path(File.join(File.dirname(__FILE__), '../../../../app/models'))
+
+        def generate_models
+          directory 'comfy', 'app/models/comfy'
+        end
+      end
+    end
+  end
+end