gaco_cms 0.1.0

data/app/models/gaco_cms/application_record.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GacoCms
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    def cache_key_locale(*keys)
+      "#{cache_key_with_version}/#{I18n.locale}/#{keys.join('-')}"
+    end
+
+    def activestorage_url(file)
+      return '' unless file&.blob
+      return file.url.split('?').first if file.service.name == :amazon
+
+      Rails.application.routes.url_helpers.rails_blob_path(file, only_path: true)
+    end
+
+    class << self
+      alias attr_label human_attribute_name
+      def human_name(args = {})
+        model_name.human(args)
+      end
+    end
+  end
+end

data/app/models/gaco_cms/draft_record.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: simple_cms_draft_records
+#
+#  id          :integer          not null, primary key
+#  record_type :string
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+module GacoCms
+  class DraftRecord < ApplicationRecord
+    include GacoCms::FieldsAssignable
+  end
+end

data/app/models/gaco_cms/field.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: simple_cms_fields
+#
+#  id             :integer          not null, primary key
+#  data           :text
+#  def_value      :text
+#  description    :text
+#  key            :string
+#  kind           :string           default("text_field")
+#  position       :integer          default(0)
+#  repeat         :boolean          default(FALSE)
+#  required       :boolean          default(FALSE)
+#  title          :text
+#  translatable   :boolean          default(FALSE)
+#  created_at     :datetime         not null
+#  updated_at     :datetime         not null
+#  field_group_id :integer          not null
+#
+# Indexes
+#
+#  index_simple_cms_fields_on_field_group_id  (field_group_id)
+#
+# Foreign Keys
+#
+#  field_group_id  (field_group_id => simple_cms_field_groups.id)
+#
+
+module GacoCms
+  class Field < ApplicationRecord
+    include BuddyTranslatable
+    translatable :title, :description, :def_value
+
+    EXTRA_KINDS = GacoCms::Config.extra_fields
+    KINDS = %i[text_field text_area editor file page].concat(EXTRA_KINDS.keys)
+    enum kind: KINDS.map { |k| [k, k.to_s] }.to_h
+
+    belongs_to :field_group, optional: false
+    has_many :field_values, dependent: :destroy, inverse_of: :field
+    after_update_commit :update_values_key, if: :saved_change_to_key?
+
+    validates :key, uniqueness: { scope: :field_group_id }
+    scope :ordered, -> { order(position: :asc) }
+
+    def self.dropdown_data
+      KINDS.map do |key|
+        title = key.to_s.titleize
+        title = ApplicationHelper.translated_value_for(EXTRA_KINDS[key][:label]) if EXTRA_KINDS[key]
+        [title, key]
+      end
+    end
+
+    def default_value_tpl
+      return "/gaco_cms/admin/field_groups_renderer/default_value/#{kind}" if kind == 'page'
+
+      EXTRA_KINDS.dig(kind&.to_sym, :default_value_tpl)
+    end
+
+    def allow_translation?
+      return false if %w[page].include?(kind)
+
+      res = EXTRA_KINDS.dig(kind&.to_sym, :translatable)
+      res.nil? ? true : res
+    end
+
+    def tpl
+      EXTRA_KINDS.dig(kind&.to_sym, :tpl) || "/gaco_cms/admin/field_groups_renderer/fields/#{kind}"
+    end
+
+    private
+
+    def update_values_key
+      field_values.each { |v| v.update!(field_key: key) }
+    end
+  end
+end

data/app/models/gaco_cms/field_group.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: simple_cms_field_groups
+#
+#  id          :integer          not null, primary key
+#  description :text
+#  key         :string
+#  position    :integer          default(0)
+#  record_type :string
+#  repeat      :boolean          default(FALSE)
+#  title       :text
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#  record_id   :integer
+#  template    :text             default('')
+#
+# Indexes
+#
+#  index_simple_cms_field_groups_on_record  (record_type,record_id)
+#
+
+module GacoCms
+  class FieldGroup < ApplicationRecord
+    include UnionScope
+    include BuddyTranslatable
+    translatable :title, :description
+
+    belongs_to :record, polymorphic: true
+    has_many :fields, -> { ordered }, dependent: :destroy
+
+    scope :ordered, -> { order(position: :asc) }
+    accepts_nested_attributes_for :fields, allow_destroy: true
+
+    def available_records
+      map_data = ->(item) { [item.title, "#{item.class.name}/#{item.id}"] }
+      {
+        Page.human_name(count: 2) => GacoCms::Page.title_ordered.select(:title, :id).map(&map_data),
+        'All Pages Under' => PageType.title_ordered.select(:title, :id).map(&map_data),
+        Theme.human_name(count: 2) => GacoCms::Theme.ordered.map(&map_data)
+      }
+    end
+
+    def selected_record
+      "#{record_type}/#{record_id}"
+    end
+
+    def record_label
+      return "All pages under \"#{record.title}\"" if record_type.include?('PageType')
+
+      "#{record.class.human_name} => \"#{record.title}\""
+    end
+  end
+end

data/app/models/gaco_cms/field_value.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: simple_cms_field_values
+#
+#  id          :integer          not null, primary key
+#  field_key   :string
+#  group_no    :integer          default(0)
+#  position    :integer          default(0)
+#  record_type :string
+#  value       :text
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#  field_id    :integer          not null
+#  record_id   :integer
+#
+# Indexes
+#
+#  index_simple_cms_field_values_on_field_id  (field_id)
+#  index_simple_cms_field_values_on_record    (record_type,record_id)
+#
+# Foreign Keys
+#
+#  field_id  (field_id => simple_cms_fields.id)
+#
+
+module GacoCms
+  class FieldValue < ApplicationRecord
+    include BuddyTranslatable
+    translatable :value
+
+    belongs_to :record, polymorphic: true, touch: true
+    belongs_to :field, optional: false
+    before_validation :retrieve_field_key, unless: :field_key
+    validates :field_key, presence: true
+    validates :record, presence: true
+
+    scope :for_group, ->(group) { joins(:field).merge(GacoCms::Field.where(field_group_id: group.id)) }
+    scope :ordered, -> { order(position: :asc) }
+    delegate :translatable, :repeat, :required, :kind, :def_value, :def_value_data, to: :field
+
+    def self.group_nos_for(group)
+      for_group(group).pluck(:group_no).uniq.sort
+    end
+
+    def self.all_or_new_for(field, group_no)
+      items = where(field: field).where(group_no: group_no)
+      items.any? ? items.ordered : [items.new]
+    end
+
+    def self.grouped
+      groups = reorder(group_no: :asc).pluck('distinct(group_no)')
+      groups.map do |g_no|
+        where(group_no: g_no).ordered
+      end
+    end
+
+    def value_for_input
+      @value_for_input ||= begin
+        return new_record? ? def_value : value unless translatable
+
+        new_record? ? def_value_data.to_json : value_data.to_json
+      end
+    end
+
+    def the_value
+      ShortcodeParser.call(value, record)
+    end
+
+    private
+
+    def retrieve_field_key
+      self.field_key = field.key
+    end
+  end
+end

data/app/models/gaco_cms/media_file.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: simple_cms_media_files
+#
+#  id         :integer          not null, primary key
+#  name       :string
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+module GacoCms
+  class MediaFile < ApplicationRecord
+    has_one_attached :file # TODO: if image, then create a thumb version 100x100
+    validates :file, presence: true
+
+    def url
+      activestorage_url(file)
+    end
+  end
+end

data/app/models/gaco_cms/page.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: simple_cms_pages
+#
+#  id           :integer          not null, primary key
+#  content      :text
+#  key          :text
+#  photo_url    :text
+#  summary      :text
+#  template     :text
+#  title        :text
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#  page_type_id :integer          not null
+#
+# Indexes
+#
+#  index_simple_cms_pages_on_page_type_id  (page_type_id)
+#
+# Foreign Keys
+#
+#  page_type_id  (page_type_id => simple_cms_page_types.id)
+#
+
+require 'byebug'
+module GacoCms
+  class Page < ApplicationRecord
+    include BuddyTranslatable
+    include GacoCms::FieldsAssignable
+    translatable :key, :title, :summary, :content
+
+    belongs_to :page_type
+    scope :title_ordered, -> { order(title: :asc) }
+
+    def self.by_key(key)
+      where_key_with(key).take
+    end
+
+    # TODO: deprecated
+    def all_field_groups
+      FieldGroup.union_scope(field_groups, page_type.field_groups)
+    end
+
+    def the_content(cache: true)
+      callback = proc do
+        tpl = template.presence || page_type.template.to_s
+        tpl = "[page_content]#{tpl}" unless tpl.include?('[page_content]')
+        ShortcodeParser.call(tpl, self).to_s
+      end
+      return callback.call unless cache
+
+      Rails.cache.fetch(cache_key_locale(:the_content), expires_at: Time.current.end_of_day, &callback)
+    end
+  end
+end

data/app/models/gaco_cms/page_type.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: simple_cms_page_types
+#
+#  id         :integer          not null, primary key
+#  key        :string
+#  template   :text             default("")
+#  title      :text
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+# Indexes
+#
+#  index_simple_cms_page_types_on_key  (key)
+#
+
+module GacoCms
+  class PageType < ApplicationRecord
+    include BuddyTranslatable
+    translatable :title
+
+    has_many :pages, dependent: :destroy
+    has_many :field_groups, -> { ordered }, as: :record, inverse_of: :record, dependent: :destroy
+    after_update_commit :touch_pages
+    accepts_nested_attributes_for :field_groups, allow_destroy: true
+
+    scope :title_ordered, -> { order(title: :asc) }
+
+    private
+
+    # reset pages cached values
+    def touch_pages
+      pages.find_each(&:touch)
+    end
+  end
+end

data/app/models/gaco_cms/theme.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: simple_cms_themes
+#
+#  id         :integer          not null, primary key
+#  active     :boolean          default(FALSE)
+#  key        :string           not null
+#  title      :string           not null
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+module GacoCms
+  class Theme < ApplicationRecord
+    include GacoCms::FieldsAssignable
+
+    validates :key, presence: true
+    validates :title, presence: true, uniqueness: true
+
+    scope :ordered, -> { order(title: :asc) }
+
+    def self.current
+      find_by(active: true)
+    end
+  end
+end

data/app/services/gaco_cms/application_service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GacoCms
+  class ApplicationService
+    def initialize(*args); end
+
+    class << self
+      # @see #initialize
+      def call(*args, **kwargs)
+        new(*args, **kwargs).call
+      end
+
+      # Code style definition for Sidekiq delay method
+      # @!method delay(settings = {})
+      #   @param [Hash] settings
+      #   @return [self] returns itself
+    end
+
+    private
+
+    #
+    # @param [String] message
+    # @param [:info|:warn|:error] mode
+    #
+    def log(message, mode: :info)
+      Rails.logger.send(mode, "#{self.class.name} => #{message}")
+    end
+
+    def print_error(error)
+      log("Failed with #{error.message}. #{error.backtrace[0..10]}")
+    end
+  end
+end

data/app/services/gaco_cms/shortcode_parser.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module GacoCms
+  class ShortcodeParser < ApplicationService # rubocop:disable Metrics/ClassLength
+    attr_reader :content, :record, :ignored_shortcodes
+
+    def initialize(content, record, ignore: [])
+      @content = content
+      @record = record
+      @ignored_shortcodes = Array(ignore)
+      super
+    end
+
+    def call
+      counter = 0
+      loop do
+        detected = @content.scan(/#{shortcodes_regex}/).to_a
+        break if detected.empty?
+        break log("Too many levels detected, skipping after #{counter} levels", mode: :error) if counter > 5
+
+        detected.each { |item| @content = replace_shortcode(item) }
+        counter += 1
+      end
+      @content
+    end
+
+    private
+
+    def shortcodes # rubocop:disable Metrics/MethodLength
+      pp_sample = '<img src="[page_field key=\'photo\']"/> Or [page_field key=\'photo\' page_id=10 group_no=1]'
+      pif_sample = '[page_img_field key="photo"] Or [page_img_field key="photo" page_id=10 style="width: 100%"]'
+      pmf_sample = '[page_field_multiple key="thumbnail" content="<li><img src=\'{field_yield}\' /></li>" '\
+                    'wrapper="<ul>{yield}</ul>"] Or [page_field_multiple key="thumbnail" page_id=10 content=...'
+      pgf_sample = '[page_grouped_fields keys="name,photo" wrapper="<ul>{yield}</ul>" content="<li>{name_yield}: '\
+                   '{photo_yield}</li>"] Or [page_grouped_fields keys="name,photo" page_id=10 content=...'
+      tf_sample = '<img src="[theme_field key=\'photo\'] or [theme_field key=\'photo\' group_no=1]" />'
+      pf_sample = '[page_photo] or [page_photo page_id=10 style=".."]'
+      pg_sample = '[page_group key="my_key"] or [page_group key="my_key" page_id=10 wrapper="<div class=\'row\'>{yield}</div>"]'
+      {
+        page_content: { render: method(:page_content_parser), sample: '[page_content] or [page_content page_id=10]' },
+        page_title: { render: method(:page_title_parser), sample: '[page_title] or [page_title page_id=10]' },
+        page_photo: { render: method(:page_photo_parser), sample: pp_sample },
+        page_field: { render: method(:page_field_parser), sample: pf_sample },
+        page_img_field: { render: method(:page_img_field_parser), sample: pif_sample },
+        page_field_multiple: { render: method(:page_field_multiple_parser), sample: pmf_sample },
+        # page_fields: { render: method(:page_fields_parser), sample:  },
+        page_grouped_fields: { render: method(:page_grouped_fields_parser), sample: pgf_sample },
+        page_url: { render: method(:page_url_parser), sample: '[page_url] or [page_url page_id=10]' },
+        page_group: { render: method(:page_group_parser), sample: pg_sample },
+        theme_field: { render: method(:theme_field_parser), sample: tf_sample },
+        theme_img_field: { render: method(:theme_img_field_parser), sample: '[theme_img_field key="my_img"]' }
+      }.except(*ignored_shortcodes)
+    end
+
+    def shortcodes_regex
+      "(\\[(#{shortcodes.keys.join('|')})((\s)((?!\\]).)*|)\\])"
+    end
+
+    # @param item [Array[shortcode, code, attrs]]
+    def replace_shortcode(item)
+      shortcode, code, attrs = item
+      attrs = parse_shortcode_attrs(attrs)
+      shortcode, shortcode_content = shortcode_content_for(shortcode, code)
+      args = { shortcode: shortcode, code: code, shortcode_content: shortcode_content }
+      content.sub(shortcode, parse_shortcode(code, attrs, args).to_s)
+    end
+
+    def shortcode_content_for(shortcode, code)
+      close_code = "[/#{code}]"
+      return [shortcode, nil] unless content.include?(close_code)
+
+      shortcode_bk = shortcode
+      tmp_content = content[content.index(shortcode)..]
+      shortcode = tmp_content[0..(tmp_content.index(close_code) + close_code.size - 1)]
+      [shortcode, shortcode.sub(shortcode_bk, '').sub(close_code, '')]
+    end
+
+    # determine the content to replace instead the shortcode
+    def parse_shortcode(code, attrs, args = {})
+      renderer = shortcodes[code.to_sym][:render]
+      if renderer.is_a?(String)
+        params = { attributes: attrs, args: args }
+        ActionController::Base.new.render_to_string template: renderer, locals: params, formats: [:html]
+      else
+        shortcodes[code.to_sym][:render].call(attrs, args)
+      end
+    end
+
+    # parse the attributes of a shortcode
+    def parse_shortcode_attrs(text)
+      return {} if text.blank?
+
+      res = {}
+      regex = /(\w+)\s*=\s*"([^"]*)"(?:\s|$)|(\w+)\s*=\s*\'([^\']*)\'(?:\s|$)|(\w+)\s*=\s*([^\s\'"]+)(?:\s|$)|"([^"]*)"(?:\s|$)|(\S+)(?:\s|$)/ # rubocop:disable Style/RedundantRegexpEscape, Layout/LineLength
+      text.scan(regex).each do |item|
+        item.each_with_index do |c, index|
+          break res[c] = item[index + 1] if c.present?
+        end
+      end
+      res
+    end
+
+    def img_tag_for(url, attrs)
+      attrs = attrs.slice('style', 'alt')
+      props = attrs.map { |k, v| "#{k}=\"#{v}\"" }.join(' ')
+      "<img src='#{url}' #{props} />"
+    end
+
+    def replace_field_wrapper(attrs, content)
+      return content unless attrs.key?('wrapper')
+
+      attrs['wrapper'].to_s.sub('{yield}', content).gsub('&lt;', '<').gsub('&gt;', '>')
+    end
+
+    ############################
+    def calc_context(context, attrs, klass: Page)
+      return context if context
+      return Page.where_key_with(attrs['page_key']).take if attrs['page_key'].present?
+
+      attrs['page_id'].present? ? klass.find_by(id: attrs['page_id']) : record
+    end
+
+    def page_field_parser(attrs, _args, context = nil)
+      context = calc_context(context, attrs)
+      return '--PageNotFound--' unless context
+
+      context.the_value(attrs['key'])
+    end
+
+    def page_field_multiple_parser(attrs, _args, context = nil)
+      context = calc_context(context, attrs)
+      return '--PageNotFound--' unless context
+
+      res = context.the_values(attrs['key']).map do |val|
+        attrs['content'].to_s.gsub('{field_yield}', val)
+      end.join
+      replace_field_wrapper(attrs, res)
+    end
+
+    def page_img_field_parser(attrs, _args, context = nil)
+      context = calc_context(context, attrs)
+      return '--PageNotFound--' unless context
+
+      src = context.the_value(attrs['key'])
+      img_tag_for(src, attrs)
+    end
+
+    def page_grouped_fields_parser(attrs, _args, context = nil)
+      context = calc_context(context, attrs)
+      return '--PageNotFound--' unless context
+
+      keys = attrs['keys'].to_s.split(',')
+      context.the_grouped_values(*keys).map do |fields|
+        content = attrs['content'].to_s
+        keys.each do |key|
+          content = content.gsub("{#{key}_yield}", fields[key])
+        end
+        replace_field_wrapper(attrs, content)
+      end.join
+    end
+
+    def page_content_parser(attrs, _args)
+      context = calc_context(nil, attrs)
+      return '--PageNotFound--' unless context
+
+      context.content
+    end
+
+    def page_photo_parser(attrs, _args)
+      context = calc_context(nil, attrs)
+      return '--PageNotFound--' unless context
+
+      img_tag_for(context.photo_url, attrs)
+    end
+
+    def page_title_parser(attrs, _args)
+      context = calc_context(nil, attrs)
+      return '--PageNotFound--' unless context
+
+      context.title
+    end
+
+    def page_url_parser(attrs, _args)
+      context = calc_context(nil, attrs)
+      return '--PageNotFound--' unless context
+
+      ApplicationHelper.page_url_for(context.id)
+    end
+
+    # TODO: add missing test cases
+    def page_group_parser(attrs, _args)
+      context = calc_context(nil, attrs)
+      return '--PageNotFound--' unless context
+
+      group = context.field_groups.find_by(key: attrs['key'])
+      return '--GroupNotFound--' unless group
+
+      keys = group.fields.pluck(:key)
+      result = context.the_grouped_values(*keys).map do |fields|
+        content = group.template.to_s
+        keys.each do |key|
+          content = content.gsub("{#{key}_yield}", fields[key])
+        end
+        content
+      end.join
+      replace_field_wrapper(attrs, result)
+    end
+
+    def theme_field_parser(attrs, args)
+      page_field_parser(attrs, args, Theme.current)
+    end
+
+    def theme_img_field_parser(attrs, args)
+      page_img_field_parser(attrs, args, Theme.current)
+    end
+  end
+end