occams 1.0.0

data/lib/occams/content/tags/textarea.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Tag for text content that is going to be rendered using textarea
+#   {{ cms:textarea identifier }}
+#
+class Occams::Content::Tag::TextArea < Occams::Content::Tag::Fragment
+
+  def form_field(object_name, view, index)
+    name    = "#{object_name}[fragments_attributes][#{index}][content]"
+    options = { id: form_field_id, data: { "cms-cm-mode" => "text/html" } }
+    input   = view.send(:text_area_tag, name, content, options)
+
+    yield input
+  end
+
+end
+
+Occams::Content::Renderer.register_tag(
+  :textarea, Occams::Content::Tag::TextArea
+)

data/lib/occams/content/tags/wysiwyg.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Tag for text content that is going to be rendered using Redactor (default) in
+# the admin area
+#   {{ cms:wysiwyg identifier }}
+#
+#
+class Occams::Content::Tag::Wysiwyg < Occams::Content::Tag::Fragment
+
+  def form_field(object_name, view, index)
+    name    = "#{object_name}[fragments_attributes][#{index}][content]"
+    options = { id: form_field_id, data: { "cms-rich-text" => true } }
+    input   = view.send(:text_area_tag, name, content, options)
+    yield input
+  end
+
+end
+
+Occams::Content::Renderer.register_tag(
+  :wysiwyg, Occams::Content::Tag::Wysiwyg
+)

data/lib/occams/content.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Occams::Content
+  # ...
+end
+
+require_relative "content/renderer"
+require_relative "content/params_parser"
+require_relative "content/tag"
+require_relative "content/block"
+
+require_relative "content/tags/fragment"
+
+require_relative "content/tags/wysiwyg"
+require_relative "content/tags/text"
+require_relative "content/tags/textarea"
+require_relative "content/tags/markdown"
+require_relative "content/tags/datetime"
+require_relative "content/tags/date"
+require_relative "content/tags/number"
+require_relative "content/tags/checkbox"
+require_relative "content/tags/file"
+require_relative "content/tags/files"
+
+require_relative "content/tags/snippet"
+require_relative "content/tags/asset"
+require_relative "content/tags/file_link"
+require_relative "content/tags/page_file_link"
+require_relative "content/tags/helper"
+require_relative "content/tags/partial"
+require_relative "content/tags/template"

data/lib/occams/engine.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "occams"
+require "rails"
+require "rails-i18n"
+require "comfy_bootstrap_form"
+require "active_link_to"
+require "kramdown"
+require "jquery-rails"
+require "haml-rails"
+require "sassc-rails"
+
+module Occams
+  class Engine < ::Rails::Engine
+
+    initializer "occams.setup_assets" do
+      ::Occams::Engine.config.assets.precompile += %w[
+        occams/admin/cms/application.js
+        occams/admin/cms/application.css
+        occams/admin/cms/lib/redactor-font.eot
+      ]
+    end
+
+    config.to_prepare do
+      Dir.glob(Rails.root + "app/decorators/occams/*_decorator*.rb").each do |c|
+        require_dependency(c)
+      end
+    end
+
+  end
+end

data/lib/occams/error.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Occams
+
+  class Error < StandardError
+  end
+
+  class MissingSite < Occams::Error
+
+    def initialize(identifier)
+      super "Cannot find CMS Site with identifier: #{identifier}"
+    end
+
+  end
+
+  class MissingLayout < Occams::Error
+
+    def initialize(identifier)
+      super "Cannot find CMS Layout with identifier: #{identifier}"
+    end
+
+  end
+
+  class MissingPage < Occams::Error
+
+    def initialize(path)
+      super "Cannot find CMS Page at #{path}"
+    end
+
+  end
+
+end

data/lib/occams/extensions/acts_as_tree.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Occams::ActsAsTree
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+
+    def cms_acts_as_tree(options = {})
+      configuration = {
+        foreign_key:    "parent_id",
+        order:          nil,
+        counter_cache:  nil,
+        dependent:      :destroy,
+        touch:          false
+      }
+      configuration.update(options) if options.is_a?(Hash)
+
+      belongs_to :parent,
+        optional:       true,
+        class_name:     name,
+        foreign_key:    configuration[:foreign_key],
+        counter_cache:  configuration[:counter_cache],
+        touch:          configuration[:touch]
+
+      has_many :children,
+        -> { order(configuration[:order]) },
+        class_name:   name,
+        foreign_key:  configuration[:foreign_key],
+        dependent:    configuration[:dependent]
+
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        include Occams::ActsAsTree::InstanceMethods
+
+        scope :roots, -> {
+          where("#{configuration[:foreign_key]} IS NULL").
+          order(#{configuration[:order].nil? ? 'nil' : %("#{configuration[:order]}")})
+        }
+
+        def self.root
+          roots.first
+        end
+
+        validates_each "#{configuration[:foreign_key]}" do |record, attr, value|
+          if value
+            if record.id == value
+              record.errors.add attr, "cannot be it's own id"
+            elsif record.descendants.map {|c| c.id}.include?(value)
+              record.errors.add attr, "cannot be a descendant's id"
+            end
+          end
+        end
+      RUBY
+    end
+
+  end
+
+  module InstanceMethods
+
+    # Returns list of ancestors, starting from parent until root.
+    #
+    #   subchild1.ancestors # => [child1, root]
+    def ancestors
+      node  = self
+      nodes = []
+      nodes << node = node.parent while node.parent
+      nodes
+    end
+
+    # Returns all children and children of children
+    def descendants
+      nodes = []
+      children.each do |c|
+        nodes << c
+        nodes << c.descendants
+      end
+      nodes.flatten
+    end
+
+    # Returns the root node of the tree.
+    def root
+      node = self
+      node = node.parent while node.parent
+      node
+    end
+
+    # Checks if this node is a root
+    def root?
+      !parent_id
+    end
+
+    # Returns all siblings of the current node.
+    #
+    #   subchild1.siblings # => [subchild2]
+    def siblings
+      self_and_siblings - [self]
+    end
+
+    # Returns all siblings and a reference to the current node.
+    #
+    #   subchild1.self_and_siblings # => [subchild1, subchild2]
+    def self_and_siblings
+      parent ? parent.children : self.class.roots
+    end
+
+    # BUG: https://github.com/rails/rails/issues/14369
+    # It's still a bug. Remove it to see failing test
+    def parent_id=(id)
+      self.parent = self.class.find_by(id: id)
+    end
+
+  end
+
+end
+
+ActiveSupport.on_load :active_record do
+  include Occams::ActsAsTree
+end

data/lib/occams/extensions/has_revisions.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Occams::HasRevisions
+
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  module ClassMethods
+
+    def cms_has_revisions_for(*fields)
+      include Occams::HasRevisions::InstanceMethods
+
+      attr_accessor :revision_data
+
+      has_many :revisions,
+        as:         :record,
+        dependent:  :destroy,
+        class_name: "Occams::Cms::Revision"
+
+      before_save :prepare_revision
+      after_save  :create_revision
+
+      define_method(:revision_fields) do
+        fields.collect(&:to_s)
+      end
+    end
+
+  end
+
+  module InstanceMethods
+
+    # Preparing revision data. A bit of a special thing to grab page blocks
+    def prepare_revision
+      return if new_record?
+      if (respond_to?(:fragments_attributes_changed) && fragments_attributes_changed) ||
+        !(changed & revision_fields).empty?
+        self.revision_data = revision_fields.each_with_object({}) do |field, c|
+          c[field] = send("#{field}_was")
+        end
+      end
+    end
+
+    # Revision is created only if relevant data changed
+    def create_revision
+      return unless revision_data
+
+      limit = Occams.config.revisions_limit.to_i
+
+      # creating revision
+      if limit != 0
+        revisions.create!(data: revision_data)
+      end
+
+      # blowing away old revisions
+      ids = [0] + revisions.order(created_at: :desc).limit(limit).pluck(:id)
+      revisions.where("id NOT IN (?)", ids).destroy_all
+    end
+
+    # Assigning whatever is found in revision data and attempting to save the object
+    def restore_from_revision(revision)
+      return unless revision.record == self
+      update!(revision.data)
+    end
+
+  end
+
+end
+
+ActiveSupport.on_load :active_record do
+  include Occams::HasRevisions
+end

data/lib/occams/form_builder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Occams::FormBuilder < ComfyBootstrapForm::FormBuilder
+
+  # Renders form input for a fragment
+  #
+  # @param [Occams::Cms::Page] record
+  # @param [Occams::Content::Tag] tag
+  # @param [Integer] index
+  def fragment_field(tag, index)
+    tag.form_field(object_name, @template, index) do |tag_input|
+      name = "#{object_name}[fragments_attributes][#{index}][identifier]"
+      identifer_input = @template.hidden_field_tag(name, tag.identifier, id: nil)
+
+      name  = "#{object_name}[fragments_attributes][#{index}][tag]"
+      value = tag.class.to_s.demodulize.underscore
+      tag_name_input = @template.hidden_field_tag(name, value, id: nil)
+
+      label = I18n.t("occams.cms.content.tag.#{tag.identifier}", default: tag.identifier.titleize)
+      renderable = tag.respond_to?(:renderable) ? tag.renderable : true
+
+      form_group bootstrap: { label: { text: label, for: tag.form_field_id, class: "renderable-#{renderable}" } } do
+        concat identifer_input
+        concat tag_name_input
+        concat tag_input
+      end
+    end
+  end
+
+  # Wrapper for form action that is sticking to the bottom of the viewport.
+  # Example:
+  #   = form.form_actions do
+  #     = form.submit
+  #
+  def form_actions
+    content_tag(:div, class: "form-actions row bg-light") do
+      content_tag(:div, class: "col-lg-8 offset-lg-2") do
+        content_tag(:div, class: "form-group row mb-0") do
+          content_tag(:div, class: "col-sm-10 offset-sm-2") do
+            yield
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/occams/render_methods.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Occams::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|
+      begin
+        render cms_page: request.path
+      rescue Occams::MissingPage, Occams::MissingSite
+        raise e
+      end
+    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))
+      unless (@cms_site = Occams::Cms::Site.find_by_identifier(site_identifier))
+        raise Occams::MissingSite, site_identifier
+      end
+    end
+
+    if (page_path = options.delete(:cms_page)) || (layout_identifier = options.delete(:cms_layout))
+      unless @cms_site ||= Occams::Cms::Site.find_site(request.host_with_port.downcase, request.fullpath)
+        raise Occams::MissingSite, "#{request.host.downcase}/#{request.fullpath}"
+      end
+    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 Occams::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 Occams::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 Occams::RenderMethods
+end

data/lib/occams/routes/cms.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class ActionDispatch::Routing::Mapper
+
+  def occams_route_cms(options = {})
+    Occams.configuration.public_cms_path = options[:path]
+
+    scope module: :occams, as: :occams 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

data/lib/occams/routes/cms_admin.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class ActionDispatch::Routing::Mapper
+
+  def occams_route_cms_admin(path: "admin")
+    scope module: :occams, as: :occams 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

data/lib/occams/routing.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "routes/cms_admin"
+require_relative "routes/cms"
+
+class ActionDispatch::Routing::Mapper
+
+  def occams_route(identifier, options = {})
+    send("occams_route_#{identifier}", **options)
+  end
+
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Occams::Seeds::File
+  class Exporter < Occams::Seeds::Exporter
+
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(Occams.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.open(::File.join(path, "_#{file.attachment.filename}.yml"), "w") do |f|
+          f.write({
+            "label"       => file.label,
+            "description" => file.description,
+            "categories"  => file.categories.map(&:label)
+          }.to_yaml)
+        end
+
+        # writing content
+        begin
+          ::File.open(::File.join(path, ::File.basename(file_path)), "wb") do |f|
+            f.write(file.attachment.download)
+          end
+        rescue Errno::ENOENT, OpenURI::HTTPError
+          message = "[CMS SEEDS] No physical File \t #{file.attachment.filename}"
+          Occams.logger.warn(message)
+          next
+        end
+
+        message = "[CMS SEEDS] Exported File \t #{file.attachment.filename}"
+        Occams.logger.info(message)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Occams::Seeds::File
+  class Importer < Occams::Seeds::Importer
+
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(Occams.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"))
+          if fresh_seed?(file, attrs_path)
+            fresh_file = true
+
+            attrs = YAML.safe_load(File.read(attrs_path))
+            category_ids = category_names_to_ids(file, attrs.delete("categories"))
+            file.attributes = attrs.merge(
+              category_ids: category_ids
+            )
+          end
+        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}"
+            Occams.logger.info(message)
+          else
+            message = "[CMS SEEDS] Failed to import File \n#{file.errors.inspect}"
+            Occams.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