alchemy_cms 6.1.10 → 7.0.0.pre.a

data/db/migrate/20220514072456_restrict_on_delete_page_id_foreign_key_from_alchemy_nodes.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-class RestrictOnDeletePageIdForeignKeyFromAlchemyNodes < ActiveRecord::Migration[6.0]
-  def up
-    remove_foreign_key :alchemy_nodes, :alchemy_pages
-    add_foreign_key :alchemy_nodes, :alchemy_pages, column: :page_id, on_delete: :restrict
-  end
-
-  def down
-    remove_foreign_key :alchemy_nodes, :alchemy_pages
-    add_foreign_key :alchemy_nodes, :alchemy_pages, column: :page_id, on_delete: :cascade
-  end
-end

data/db/migrate/20220622130905_add_playsinline_to_alchemy_essence_videos.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class AddPlaysinlineToAlchemyEssenceVideos < ActiveRecord::Migration[6.0]
-  def change
-    return if column_exists?(:alchemy_essence_videos, :playsinline)
-
-    add_column :alchemy_essence_videos, :playsinline, :boolean, default: false, null: false
-  end
-end

data/lib/alchemy/essence.rb

@@ -1,250 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record"
-
-module Alchemy #:nodoc:
-  module Essence #:nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    # Delivers various methods we need for Essences in Alchemy.
-    #
-    # To turn a model into an essence call acts_as_essence inside your model and you will get:
-    #   * validations
-    #   * several getters (ie: page, element, content, ingredient, preview_text)
-    #
-    module ClassMethods
-      # Turn any active record model into an essence by calling this class method
-      #
-      # @option options [String || Symbol] ingredient_column ('body')
-      #   specifies the column name you use for storing the content in the database (default: +body+)
-      # @option options [String || Symbol] validate_column (ingredient_column)
-      #   The column the the validations run against.
-      # @option options [String || Symbol] preview_text_column (ingredient_column)
-      #   Specify the column for the preview_text method.
-      # @deprecated
-      def acts_as_essence(options = {})
-        if !DEPRECATED_ESSENCE_CLASSES.include?(name)
-          Alchemy::Deprecation.warn "Please create a custom Alchemy::Ingredient for #{name} instead"
-        end
-
-        register_as_essence_association!
-
-        configuration = {
-          ingredient_column: "body",
-        }.update(options)
-
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          attr_writer :validation_errors
-          include Alchemy::Essence::InstanceMethods
-
-          validate :validate_ingredient, on: :update, if: -> { validations.any? }
-
-          has_one :content, as: :essence, class_name: "Alchemy::Content", inverse_of: :essence
-          has_one :element, through: :content, class_name: "Alchemy::Element"
-          has_one :page,    through: :element, class_name: "Alchemy::Page"
-
-          scope :available,    -> { joins(:element).merge(Alchemy::Element.published) }
-          scope :from_element, ->(name) { joins(:element).where(Element.table_name => { name: name }) }
-
-          delegate :restricted?, to: :page,    allow_nil: true
-          delegate :public?,     to: :element, allow_nil: true
-
-          after_update :touch_element
-
-          def acts_as_essence_class
-            #{name}
-          end
-
-          def ingredient_column
-            '#{configuration[:ingredient_column]}'
-          end
-
-          def validation_column
-            '#{configuration[:validate_column] || configuration[:ingredient_column]}'
-          end
-
-          def preview_text_column
-            '#{configuration[:preview_text_column] || configuration[:ingredient_column]}'
-          end
-        RUBY
-
-        if configuration[:belongs_to]
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            belongs_to :ingredient_association, **#{configuration[:belongs_to]}
-
-            alias_method :#{configuration[:ingredient_column]}, :ingredient_association
-            alias_method :#{configuration[:ingredient_column]}=, :ingredient_association=
-          RUBY
-        end
-      end
-
-      private
-
-      # Register the current class as has_many association on +Alchemy::Page+ and +Alchemy::Element+ models
-      def register_as_essence_association!
-        klass_name = model_name.to_s
-        arguments = [:has_many, klass_name.demodulize.tableize.to_sym]
-        kwargs = { through: :contents, source: :essence, source_type: klass_name }
-        %w(Page Element).each { |k| "Alchemy::#{k}".constantize.send(*arguments, **kwargs) }
-      end
-    end
-
-    module InstanceMethods
-      # Essence Validations:
-      #
-      # Essence validations can be set inside the config/elements.yml file.
-      #
-      # Supported validations are:
-      #
-      # * presence
-      # * uniqueness
-      # * format
-      #
-      # format needs to come with a regex or a predefined matcher string as its value.
-      # There are already predefined format matchers listed in the config/alchemy/config.yml file.
-      # It is also possible to add own format matchers there.
-      #
-      # Example of format matchers in config/alchemy/config.yml:
-      #
-      # format_matchers:
-      #   email: !ruby/regexp '/\A[^@\s]+@([^@\s]+\.)+[^@\s]+\z/'
-      #   url:   !ruby/regexp '/\A[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?\z/ix'
-      #   ssl:   !ruby/regexp '/https:\/\/[\S]+/'
-      #
-      # Example of an element definition with essence validations:
-      #
-      #   - name: person
-      #     contents:
-      #     - name: name
-      #       type: EssenceText
-      #       validate: [presence]
-      #     - name: email
-      #       type: EssenceText
-      #       validate: [format: 'email']
-      #     - name: homepage
-      #       type: EssenceText
-      #       validate: [format: !ruby/regexp '^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$']
-      #
-      # Example of an element definition with chained validations.
-      #
-      #   - name: person
-      #     contents:
-      #     - name: name
-      #       type: EssenceText
-      #       validate: [presence, uniqueness, format: 'name']
-      #
-      def validate_ingredient
-        validations.each do |validation|
-          if validation.respond_to?(:keys)
-            validation.map do |key, value|
-              send("validate_#{key}", value)
-            end
-          else
-            send("validate_#{validation}")
-          end
-        end
-      end
-
-      def validations
-        @validations ||= definition.present? ? definition["validate"] || [] : []
-      end
-
-      def validation_errors
-        @validation_errors ||= []
-      end
-
-      def validate_presence(validate = true)
-        if validate && ingredient.blank?
-          errors.add(ingredient_column, :blank)
-          validation_errors << :blank
-        end
-      end
-
-      def validate_uniqueness(validate = true)
-        return if !validate || !public?
-
-        if duplicates.any?
-          errors.add(ingredient_column, :taken)
-          validation_errors << :taken
-        end
-      end
-
-      def validate_format(format)
-        matcher = Config.get("format_matchers")[format] || format
-        if ingredient.to_s.match(Regexp.new(matcher)).nil?
-          errors.add(ingredient_column, :invalid)
-          validation_errors << :invalid
-        end
-      end
-
-      def duplicates
-        acts_as_essence_class
-          .available
-          .from_element(element.name)
-          .where(ingredient_column.to_s => ingredient)
-          .where.not(id: id)
-      end
-
-      # Returns the value stored from the database column that is configured as ingredient column.
-      def ingredient
-        if respond_to?(ingredient_column)
-          send(ingredient_column)
-        end
-      end
-
-      # Sets the value stored in the database column that is configured as ingredient column.
-      def ingredient=(value)
-        if respond_to?(ingredient_setter_method)
-          send(ingredient_setter_method, value)
-        end
-      end
-
-      # Returns the setter method for ingredient column
-      def ingredient_setter_method
-        ingredient_column.to_s + "="
-      end
-
-      # Essence definition from config/elements.yml
-      def definition
-        return {} if element.nil? || element.content_definitions.nil?
-
-        element.content_definitions.detect { |c| c["name"] == content.name } || {}
-      end
-
-      # Touches element. Called after save.
-      def touch_element
-        element&.touch
-      end
-
-      # Returns the first x (default 30) characters of ingredient for the Element#preview_text method.
-      #
-      def preview_text(maxlength = 30)
-        send(preview_text_column).to_s[0..maxlength - 1]
-      end
-
-      def open_link_in_new_window?
-        respond_to?(:link_target) && link_target == "blank"
-      end
-
-      def partial_name
-        self.class.name.split("::").last.underscore
-      end
-
-      def acts_as_essence?
-        acts_as_essence_class.present?
-      end
-
-      def to_partial_path
-        "alchemy/essences/#{partial_name}_view"
-      end
-
-      def has_tinymce?
-        false
-      end
-    end
-  end
-end
-
-ActiveRecord::Base.include(Alchemy::Essence)

data/lib/alchemy/tasks/usage.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Alchemy
-  module Tasks
-    module Usage
-      extend self
-
-      def elements_count_by_name
-        res = Alchemy::Element.all
-          .select("name, COUNT(*) AS count")
-          .group(:name)
-          .order("count DESC, name ASC")
-          .map { |e| {"name" => e.name, "count" => e.count} }
-        Alchemy::Element.definitions.map do |definition|
-          count = res.find { |r| r["name"] == definition["name"] }&.fetch("count") || 0
-          definition["count"] = count
-          definition
-        end.sort_by { |r| -1 * r["count"] }
-      end
-
-      def pages_count_by_type
-        res = Alchemy::Page.all
-          .select("page_layout, COUNT(*) AS count")
-          .group(:page_layout)
-          .order("count DESC, page_layout ASC")
-          .map { |p| {"page_layout" => p.page_layout, "count" => p.count} }
-        Alchemy::PageLayout.all.reject { |page_layout| res.map { |p| p["page_layout"] }.include? page_layout["name"] }.sort_by { |d| d["name"] }.each do |page_layout|
-          res << {"page_layout" => page_layout["name"], "count" => 0}
-        end
-        res
-      end
-    end
-  end
-end

data/lib/alchemy/test_support/essence_shared_examples.rb

@@ -1,271 +0,0 @@
-# frozen_string_literal: true
-
-require "shoulda-matchers"
-
-RSpec.shared_examples_for "an essence" do
-  let(:element) { Alchemy::Element.new }
-  let(:content) { Alchemy::Content.new(name: "foo") }
-  let(:content_definition) { { "name" => "foo" } }
-
-  it "touches the element after save" do
-    element = FactoryBot.create(:alchemy_element)
-    content = FactoryBot.create(:alchemy_content, element: element, essence: essence, essence_type: essence.class.name)
-
-    element.update_column(:updated_at, 3.days.ago)
-    content.essence.update(essence.ingredient_column.to_sym => ingredient_value)
-
-    element.reload
-    expect(element.updated_at).to be_within(3.seconds).of(Time.current)
-  end
-
-  it "should have correct partial path" do
-    underscored_essence = essence.class.name.demodulize.underscore
-    expect(essence.to_partial_path).to eq("alchemy/essences/#{underscored_essence}_view")
-  end
-
-  describe "#definition" do
-    subject { essence.definition }
-
-    context "without element" do
-      it { is_expected.to eq({}) }
-    end
-
-    context "with element" do
-      before do
-        expect(essence).to receive(:element).at_least(:once).and_return(element)
-      end
-
-      context "but without content definitions" do
-        it { is_expected.to eq({}) }
-      end
-
-      context "and content definitions" do
-        before do
-          allow(essence).to receive(:content).and_return(content)
-        end
-
-        context "containing the content name" do
-          before do
-            expect(element).to receive(:content_definitions).at_least(:once).and_return([content_definition])
-          end
-
-          it "returns the content definition" do
-            is_expected.to eq(content_definition)
-          end
-        end
-
-        context "not containing the content name" do
-          before do
-            expect(element).to receive(:content_definitions).at_least(:once).and_return([])
-          end
-
-          it { is_expected.to eq({}) }
-        end
-      end
-    end
-  end
-
-  describe "#ingredient=" do
-    it "should set the value to ingredient column" do
-      essence.ingredient = ingredient_value
-      expect(essence.ingredient).to eq ingredient_value
-    end
-  end
-
-  describe "validations" do
-    context "without essence definition in elements.yml" do
-      it "should return an empty array" do
-        allow(essence).to receive(:definition).and_return nil
-        expect(essence.validations).to eq([])
-      end
-    end
-
-    context "without validations defined in essence definition in elements.yml" do
-      it "should return an empty array" do
-        allow(essence).to receive(:definition).and_return({ name: "test", type: "EssenceText" })
-        expect(essence.validations).to eq([])
-      end
-    end
-
-    describe "presence" do
-      context "with string given as validation type" do
-        before do
-          allow(essence).to receive(:definition).and_return({ "validate" => ["presence"] })
-        end
-
-        context "when the ingredient column is empty" do
-          before do
-            essence.update(essence.ingredient_column.to_sym => nil)
-          end
-
-          it "should not be valid" do
-            expect(essence).to_not be_valid
-          end
-        end
-
-        context "when the ingredient column is not nil" do
-          before do
-            essence.update(essence.ingredient_column.to_sym => ingredient_value)
-          end
-
-          it "should be valid" do
-            expect(essence).to be_valid
-          end
-        end
-      end
-
-      context "with hash given as validation type" do
-        context "where the value is true" do
-          before do
-            allow(essence).to receive(:definition).and_return({ "validate" => [{ "presence" => true }] })
-          end
-
-          context "when the ingredient column is empty" do
-            before do
-              essence.update(essence.ingredient_column.to_sym => nil)
-            end
-
-            it "should not be valid" do
-              expect(essence).to_not be_valid
-            end
-          end
-
-          context "when the ingredient column is not nil" do
-            before do
-              essence.update(essence.ingredient_column.to_sym => ingredient_value)
-            end
-
-            it "should be valid" do
-              expect(essence).to be_valid
-            end
-          end
-        end
-
-        context "where the value is false" do
-          before do
-            allow(essence).to receive(:definition).and_return({ "validate" => [{ "presence" => false }] })
-          end
-
-          it "should be valid" do
-            expect(essence).to be_valid
-          end
-        end
-      end
-    end
-
-    describe "uniqueness" do
-      before do
-        allow(essence).to receive(:element).and_return(FactoryBot.create(:alchemy_element))
-        essence.update(essence.ingredient_column.to_sym => ingredient_value)
-      end
-
-      context "with string given as validation type" do
-        before do
-          expect(essence).to receive(:definition).at_least(:once).and_return({ "validate" => ["uniqueness"] })
-        end
-
-        context "when a duplicate exists" do
-          before do
-            allow(essence).to receive(:duplicates).and_return([essence.dup])
-          end
-
-          it "should not be valid" do
-            expect(essence).to_not be_valid
-          end
-
-          context "when validated essence is not public" do
-            before do
-              expect(essence).to receive(:public?).and_return(false)
-            end
-
-            it "should be valid" do
-              expect(essence).to be_valid
-            end
-          end
-        end
-
-        context "when no duplicate exists" do
-          before do
-            expect(essence).to receive(:duplicates).and_return([])
-          end
-
-          it "should be valid" do
-            expect(essence).to be_valid
-          end
-        end
-      end
-
-      context "with hash given as validation type" do
-        context "where the value is true" do
-          before do
-            expect(essence).to receive(:definition).at_least(:once).and_return({ "validate" => [{ "uniqueness" => true }] })
-          end
-
-          context "when a duplicate exists" do
-            before do
-              allow(essence).to receive(:duplicates).and_return([essence.dup])
-            end
-
-            it "should not be valid" do
-              expect(essence).to_not be_valid
-            end
-
-            context "when validated essence is not public" do
-              before do
-                expect(essence).to receive(:public?).and_return(false)
-              end
-
-              it "should be valid" do
-                expect(essence).to be_valid
-              end
-            end
-          end
-
-          context "when no duplicate exists" do
-            before do
-              expect(essence).to receive(:duplicates).and_return([])
-            end
-
-            it "should be valid" do
-              expect(essence).to be_valid
-            end
-          end
-        end
-
-        context "where the value is false" do
-          before do
-            allow(essence).to receive(:definition).and_return({ "validate" => [{ "uniqueness" => false }] })
-          end
-
-          it "should be valid" do
-            expect(essence).to be_valid
-          end
-        end
-      end
-    end
-
-    describe "#acts_as_essence?" do
-      it "should return true" do
-        expect(essence.acts_as_essence?).to be_truthy
-      end
-    end
-  end
-
-  context "delegations" do
-    it { should delegate_method(:restricted?).to(:page) }
-    it { should delegate_method(:public?).to(:element) }
-  end
-
-  describe "essence relations" do
-    let(:page) { FactoryBot.create(:alchemy_page, :restricted) }
-    let(:element) { FactoryBot.create(:alchemy_element) }
-
-    it "registers itself on page as essence relation" do
-      expect(page.respond_to?(essence.class.model_name.route_key)).to be(true)
-    end
-
-    it "registers itself on element as essence relation" do
-      expect(element.respond_to?(essence.class.model_name.route_key)).to be(true)
-    end
-  end
-end

data/lib/alchemy/test_support/factories/content_factory.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-FactoryBot.define do
-  factory :alchemy_content, class: "Alchemy::Content" do
-    name { "text" }
-    essence_type { "Alchemy::EssenceText" }
-    association :essence, factory: :alchemy_essence_text
-    association :element, factory: :alchemy_element
-
-    trait :essence_file do
-      essence_type { "Alchemy::EssenceFile" }
-      association :essence, factory: :alchemy_essence_file
-    end
-
-    trait :essence_picture do
-      essence_type { "Alchemy::EssencePicture" }
-      association :essence, factory: :alchemy_essence_picture
-    end
-  end
-end

data/lib/alchemy/test_support/factories/essence_audio_factory.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-FactoryBot.define do
-  factory :alchemy_essence_audio, class: "Alchemy::EssenceAudio" do
-    attachment factory: :alchemy_attachment
-  end
-end

data/lib/alchemy/test_support/factories/essence_file_factory.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-FactoryBot.define do
-  factory :alchemy_essence_file, class: "Alchemy::EssenceFile" do
-    attachment factory: :alchemy_attachment
-  end
-end

data/lib/alchemy/test_support/factories/essence_page_factory.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-FactoryBot.define do
-  factory :alchemy_essence_page, class: "Alchemy::EssencePage" do
-    page factory: :alchemy_page
-  end
-end

data/lib/alchemy/test_support/factories/essence_picture_factory.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-FactoryBot.define do
-  factory :alchemy_essence_picture, class: "Alchemy::EssencePicture" do
-    picture factory: :alchemy_picture
-
-    trait :with_content do
-      association :content, factory: :alchemy_content
-    end
-  end
-end

data/lib/alchemy/test_support/factories/essence_text_factory.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-FactoryBot.define do
-  factory :alchemy_essence_text, class: "Alchemy::EssenceText" do
-    body { "This is a headline" }
-  end
-end

data/lib/alchemy/test_support/factories/essence_video_factory.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-FactoryBot.define do
-  factory :alchemy_essence_video, class: "Alchemy::EssenceVideo" do
-    attachment factory: :alchemy_attachment
-  end
-end

data/lib/alchemy/upgrader/five_point_zero.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "tasks/harden_gutentag_migrations"
-
-module Alchemy
-  class Upgrader::FivePointZero < Upgrader
-    class << self
-      def install_gutentag_migrations
-        desc "Install Gutentag migrations"
-        Rake::Task["gutentag:install:migrations"].invoke
-        Alchemy::Upgrader::Tasks::HardenGutentagMigrations.new.patch_migrations
-        Rake::Task["db:migrate"].invoke
-      end
-
-      def remove_layout_roots
-        desc "Remove layout root pages"
-        layout_roots = Alchemy::Page.where(layoutpage: true).where("name LIKE 'Layoutroot for%'")
-        if layout_roots.size.positive?
-          log "Removing #{layout_roots.size} layout root pages."
-          layout_roots.delete_all
-          Alchemy::Page.where(layoutpage: true).update_all(parent_id: nil)
-          log "Done.", :success
-        else
-          log "No layout root pages found.", :skip
-        end
-      end
-
-      def remove_root_page
-        desc "Remove root page"
-        root_page = Alchemy::Page.find_by(parent_id: nil, name: "Root")
-        if root_page
-          Alchemy::Page.where(parent_id: root_page.id).update_all(parent_id: nil)
-          root_page.delete
-          log "Done.", :success
-        else
-          log "Root page not found.", :skip
-        end
-      end
-    end
-  end
-end