occams 1.0.0

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Occams::Seeds::Layout
+  class Exporter < Occams::Seeds::Exporter
+
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(Occams.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}"
+        Occams.logger.info(message)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Occams::Seeds::Layout
+  class Importer < Occams::Seeds::Importer
+
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(Occams.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}"
+          Occams.logger.info(message)
+        else
+          message = "[CMS SEEDS] Failed to import Layout \n#{layout.errors.inspect}"
+          Occams.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/occams/seeds/page/exporter.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Occams::Seeds::Page
+  class Exporter < Occams::Seeds::Exporter
+
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(Occams.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}"
+        Occams.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}"
+        Occams.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.open(::File.join(page_path, attachment.filename.to_s), "wb") do |f|
+                f.write(attachment.download)
+              end
+              attachment.filename
+            end.join("\n")
+          else
+            frag.content
+          end
+
+        { header: header, content: content }
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Occams::Seeds::Page
+  class Importer < Occams::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(Occams.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}"
+          Occams.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}"
+          Occams.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}"
+          Occams.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}"
+          Occams.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

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Occams::Seeds::Snippet
+  class Exporter < Occams::Seeds::Exporter
+
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(Occams.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}"
+        Occams.logger.info(message)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Occams::Seeds::Snippet
+  class Importer < Occams::Seeds::Importer
+
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(Occams.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
+            message = "[CMS SEEDS] Imported Snippet \t #{snippet.identifier}"
+            Occams.logger.info(message)
+          else
+            message = "[CMS SEEDS] Failed to import Snippet \n#{snippet.errors.inspect}"
+            Occams.logger.warn(message)
+          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/occams/seeds.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Occams::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         = Occams::Cms::Site.where(identifier: to).first!
+      self.seed_ids     = []
+
+      unless ::File.exist?(path = ::File.join(Occams.config.seeds_path, from))
+        raise Error, "Folder for import: '#{path}' is not found"
+      end
+    end
+
+    # if passed nil will use default seed classes
+    def import!(classes = nil)
+      classes ||= SEED_CLASSES
+      classes.each do |klass|
+        klass = "Occams::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).each_with_object({}) do |pair, h|
+        h[pair[0]] = pair[1]
+      end
+    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 = Occams::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 = "Occams::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/occams/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Occams
+
+  VERSION = "1.0.0"
+
+end

data/lib/occams/view_hooks.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# This mechanism is used by 3rd party plugins.
+# Normally you'd use partials from your own app
+module Occams::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:
+  # Occams::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