alchemy_cms 5.2.1 → 6.0.0.b1

data/lib/alchemy/essence.rb

@@ -59,10 +59,9 @@ module Alchemy #:nodoc:
           scope :from_element, ->(name) { joins(:element).where(Element.table_name => { name: name }) }
 
           delegate :restricted?, to: :page,    allow_nil: true
-          delegate :trashed?,    to: :element, allow_nil: true
           delegate :public?,     to: :element, allow_nil: true
 
-          after_save :touch_element
+          after_update :touch_element
 
           def acts_as_essence_class
             #{name}

data/lib/alchemy/hints.rb

@@ -35,21 +35,25 @@ module Alchemy
     # @return String
     #
     def hint
-      hint = definition["hint"]
+      hint = definition[:hint]
       if hint == true
-        Alchemy.t(name, scope: hint_translation_scope)
+        Alchemy.t(hint_translation_attribute, scope: hint_translation_scope)
       else
         hint
       end
     end
 
-    # Returns true if the element has a hint
+    # Returns true if the element has a hint defined
     def has_hint?
-      hint.present?
+      !!definition[:hint]
     end
 
     private
 
+    def hint_translation_attribute
+      name
+    end
+
     def hint_translation_scope
       "#{self.class.model_name.to_s.demodulize.downcase}_hints"
     end

data/lib/alchemy/page_layout.rb

@@ -63,19 +63,6 @@ module Alchemy
         mapped_layouts_for_select(selectable_layouts(language_id, only_layoutpages))
       end
 
-      # Returns page layouts including given layout ready for Rails' select form helper.
-      #
-      def layouts_with_own_for_select(page_layout_name, language_id, only_layoutpages = false)
-        layouts = selectable_layouts(language_id, only_layoutpages)
-        if layouts.detect { |l| l["name"] == page_layout_name }.nil?
-          @map_array = [[human_layout_name(page_layout_name), page_layout_name]]
-        else
-          @map_array = []
-        end
-        mapped_layouts_for_select(layouts)
-      end
-      deprecate :layouts_with_own_for_select, deprecator: Alchemy::Deprecation
-
       # Returns all layouts that can be used for creating a new page.
       #
       # It removes all layouts from available layouts that are unique and already taken and that are marked as hide.

data/lib/alchemy/permissions.rb

@@ -36,14 +36,13 @@ module Alchemy
     module GuestUser
       def alchemy_guest_user_rules
         can([:show, :download], Alchemy::Attachment) { |a| !a.restricted? }
-        can :see, Alchemy::Page, restricted: false
 
         can :read, Alchemy::Content, Alchemy::Content.available.not_restricted do |c|
-          c.public? && !c.restricted? && !c.trashed?
+          c.public? && !c.restricted?
         end
 
         can :read, Alchemy::Element, Alchemy::Element.available.not_restricted do |e|
-          e.public? && !e.restricted? && !e.trashed?
+          e.public? && !e.restricted?
         end
 
         can :read, Alchemy::Page, Alchemy::Page.published.not_restricted do |p|
@@ -64,14 +63,13 @@ module Alchemy
 
         # Resources
         can [:show, :download], Alchemy::Attachment
-        can :see, Alchemy::Page, restricted: true
 
         can :read, Alchemy::Content, Alchemy::Content.available do |c|
-          c.public? && !c.trashed?
+          c.public?
         end
 
         can :read, Alchemy::Element, Alchemy::Element.available do |e|
-          e.public? && !e.trashed?
+          e.public?
         end
 
         can :read, Alchemy::Page, Alchemy::Page.published do |p|
@@ -103,24 +101,27 @@ module Alchemy
         ]
 
         # Controller actions
-        can :leave,                 :alchemy_admin
-        can [:info, :help],         :alchemy_admin_dashboard
-        can :manage,                :alchemy_admin_clipboard
-        can :index,                 :trash
-        can :edit,                  :alchemy_admin_layoutpages
-        can :tree,                  :alchemy_admin_pages
+        can :leave, :alchemy_admin
+        can [:info, :help], :alchemy_admin_dashboard
+        can :manage, :alchemy_admin_clipboard
+        can :edit, :alchemy_admin_layoutpages
+        can :tree, :alchemy_admin_pages
 
         # Resources
-        can [:read, :download],     Alchemy::Attachment
-        can :manage,                Alchemy::Content
-        can :manage,                Alchemy::Element
-        can :manage,                Alchemy::EssenceFile
-        can :manage,                Alchemy::EssencePicture
-        can :manage,                Alchemy::LegacyPageUrl
-        can :manage,                Alchemy::Node
-        can :read,                  Alchemy::Picture
+        can [:read, :download], Alchemy::Attachment
+        can :manage, Alchemy::Content
+        can :manage, Alchemy::Element
+        can :manage, Alchemy::EssenceAudio
+        can :manage, Alchemy::EssenceFile
+        can :manage, Alchemy::EssencePicture
+        can :manage, Alchemy::EssenceVideo
+        can :manage, Alchemy::Ingredient
+        can [:crop], Alchemy::Ingredients::Picture
+        can :manage, Alchemy::LegacyPageUrl
+        can :manage, Alchemy::Node
+        can [:read, :url], Alchemy::Picture
         can [:read, :autocomplete], Alchemy::Tag
-        can(:edit_content,          Alchemy::Page) { |p| p.editable_by?(@user) }
+        can(:edit_content, Alchemy::Page) { |p| p.editable_by?(@user) }
       end
     end
 
@@ -140,9 +141,6 @@ module Alchemy
           :alchemy_admin_users,
         ]
 
-        # Controller actions
-        can :clear, :trash
-
         # Resources
         can [
           :copy,
@@ -164,13 +162,16 @@ module Alchemy
         can([
           :create,
           :destroy,
-          :publish,
         ], Alchemy::Page) { |p| p.editable_by?(@user) }
 
+        can(:publish, Alchemy::Page) do |page|
+          page.language.public? && page.editable_by?(@user)
+        end
+
         can :manage, Alchemy::Picture
         can :manage, Alchemy::Attachment
         can :manage, Alchemy::Tag
-        can :index,  Alchemy::Language
+        can :index, Alchemy::Language
       end
     end
 
@@ -185,14 +186,14 @@ module Alchemy
         alchemy_editor_rules
 
         # Navigation
-        can :index,                 [:alchemy_admin_sites, :alchemy_admin_styleguide]
+        can :index, [:alchemy_admin_sites, :alchemy_admin_styleguide]
 
         # Controller actions
         can [:info, :update_check], :alchemy_admin_dashboard
 
         # Resources
-        can :manage,                Alchemy::Language
-        can :manage,                Alchemy::Site
+        can :manage, Alchemy::Language
+        can :manage, Alchemy::Site
       end
     end
 

data/lib/alchemy/resource.rb

@@ -286,6 +286,11 @@ module Alchemy
       resource_relation(column_name).try(:[], :attr_type)
     end
 
+    def resource_relation_class(association)
+      class_name = association.options[:class_name] || association.name.to_s.classify
+      class_name.constantize
+    end
+
     def resource_column_type(col)
       resource_relation_type(col.name) || (col.try(:array) ? :array : col.type)
     end
@@ -298,10 +303,15 @@ module Alchemy
     def map_relations
       self.resource_relations = {}
       model.alchemy_resource_relations.each do |name, options|
-        name = name.to_s.gsub(/_id$/, "") # ensure that we don't have an id
-        association = association_from_relation_name(name)
+        relation_name = name.to_s.gsub(/_id$/, "") # ensure that we don't have an id
+        association = association_from_relation_name(relation_name)
         foreign_key = association.options[:foreign_key] || "#{association.name}_id".to_sym
-        resource_relations[foreign_key] = options.merge(model_association: association, name: name)
+        collection = options[:collection] || resource_relation_class(association).all
+        resource_relations[foreign_key] = options.merge(
+          model_association: association,
+          name: relation_name,
+          collection: collection,
+        )
       end
     end
 

data/lib/alchemy/tasks/tidy.rb

@@ -62,6 +62,23 @@ module Alchemy
         end
       end
 
+      def remove_trashed_elements
+        puts "\n## Removing trashed elements"
+        elements = Alchemy::Element.unscoped.where(position: nil)
+        if elements.any?
+          log "Destroying #{elements.size} trashed elements"
+          nested_elements, parent_elements = elements.partition(&:parent_element_id)
+          (nested_elements + parent_elements).each do |element|
+            element.destroy
+            print "."
+          end
+          puts "\n"
+          log "Done", :message
+        else
+          log "No trashed elements found", :skip
+        end
+      end
+
       def remove_orphaned_contents
         puts "\n## Removing orphaned contents"
         contents = Alchemy::Content.unscoped.all
@@ -81,6 +98,18 @@ module Alchemy
         end
       end
 
+      def remove_duplicate_legacy_urls
+        puts "\n## Removing duplicate legacy URLs"
+        sql = <<~SQL
+          DELETE FROM alchemy_legacy_page_urls A USING alchemy_legacy_page_urls B
+          WHERE A.page_id = B.page_id
+            AND A.urlname = B.urlname
+            AND A.id < B.id
+        SQL
+        count = ActiveRecord::Base.connection.exec_delete(sql)
+        log "Deleted #{count} duplicate legacy URLs"
+      end
+
       private
 
       def destroy_orphaned_records(records, class_name)

data/lib/alchemy/test_support.rb

@@ -2,17 +2,8 @@
 
 module Alchemy
   module TestSupport
-    class << self
-      def factory_paths
-        Dir[
-          ::Alchemy::Engine.root.join("lib", "alchemy", "test_support", "factories", "*_factory.rb")
-        ].map { |path| path.sub(/.rb\z/, "") }
-      end
-      deprecate factory_paths: :factories_path, deprecator: Alchemy::Deprecation
-
-      def factories_path
-        ::Alchemy::Engine.root.join("lib", "alchemy", "test_support", "factories")
-      end
+    def self.factories_path
+      ::Alchemy::Engine.root.join("lib", "alchemy", "test_support", "factories")
     end
   end
 end

data/lib/alchemy/test_support/essence_shared_examples.rb

@@ -265,7 +265,6 @@ RSpec.shared_examples_for "an essence" do
 
   context "delegations" do
     it { should delegate_method(:restricted?).to(:page) }
-    it { should delegate_method(:trashed?).to(:element) }
     it { should delegate_method(:public?).to(:element) }
   end
 

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

@@ -4,7 +4,8 @@ FactoryBot.define do
   factory :alchemy_element, class: "Alchemy::Element" do
     name { "article" }
     autogenerate_contents { false }
-    association :page, factory: :alchemy_page
+    autogenerate_ingredients { false }
+    association :page_version, factory: :alchemy_page_version
 
     trait :fixed do
       fixed { true }
@@ -16,23 +17,22 @@ FactoryBot.define do
       name { "header" }
     end
 
-    trait :trashed do
-      after(:create) do |element|
-        element.update_column(:position, :null)
-      end
-    end
-
     trait :with_nestable_elements do
       name { "slider" }
     end
 
     trait :nested do
-      association :parent_element, factory: :alchemy_element, name: "slider"
+      parent_element { build(:alchemy_element, name: "slider", page_version: page_version) }
       name { "slide" }
     end
 
     trait :with_contents do
       autogenerate_contents { true }
     end
+
+    trait :with_ingredients do
+      name { "element_with_ingredients" }
+      autogenerate_ingredients { true }
+    end
   end
 end

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

@@ -0,0 +1,7 @@
+# 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_video_factory.rb

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

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  %w[
+    audio
+    boolean
+    datetime
+    file
+    headline
+    html
+    link
+    node
+    page
+    picture
+    richtext
+    select
+    text
+  ].each do |ingredient|
+    factory :"alchemy_ingredient_#{ingredient}", class: "Alchemy::Ingredients::#{ingredient.classify}" do
+      role { ingredient }
+      type { "Alchemy::Ingredients::#{ingredient.classify}" }
+      association :element, name: "all_you_can_eat_ingredients", factory: :alchemy_element
+    end
+  end
+end

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

@@ -29,7 +29,26 @@ FactoryBot.define do
 
     trait :public do
       sequence(:name) { |n| "A Public Page #{n}" }
-      public_on { Time.current }
+      transient do
+        public_on { Time.current }
+        public_until { nil }
+      end
+      after(:build) do |page, evaluator|
+        page.build_public_version(
+          public_on: evaluator.public_on,
+          public_until: evaluator.public_until,
+        )
+      end
+      after(:create) do |page|
+        if page.autogenerate_elements
+          page.definition["autogenerate"].each do |name|
+            create(:alchemy_element,
+              name: name,
+              page_version: page.public_version,
+              autogenerate_contents: true)
+          end
+        end
+      end
     end
 
     trait :layoutpage do

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :alchemy_page_version, class: "Alchemy::PageVersion" do
+    association :page, factory: :alchemy_page
+
+    trait :published do
+      public_on { Time.current }
+    end
+
+    transient do
+      element_count { 1 }
+    end
+
+    trait :with_elements do
+      after(:build) do |page_version, evaluator|
+        evaluator.element_count.times do
+          page_version.elements.build(name: "article")
+        end
+      end
+    end
+  end
+end

data/lib/alchemy/test_support/having_crop_action_examples.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples_for "having crop action" do |args|
+  describe "#crop" do
+    let(:picture) { Alchemy::Picture.new }
+
+    before do
+      expect(args[:model_class]).to receive(:find).and_return(croppable_resource)
+    end
+
+    context "with no picture assigned" do
+      it "renders error message" do
+        get :crop, params: { id: 1 }
+        expect(assigns(:no_image_notice)).to eq(Alchemy.t(:no_image_for_cropper_found))
+      end
+    end
+
+    context "with picture assigned" do
+      subject { get :crop, params: { id: 1, picture_id: picture.id } }
+
+      let(:default_mask) do
+        [
+          0,
+          0,
+          300,
+          250,
+        ]
+      end
+
+      let(:settings) { {} }
+
+      before do
+        picture.image_file_width = 300
+        picture.image_file_height = 250
+        allow(croppable_resource).to receive(:settings) { settings }
+        expect(Alchemy::Picture).to receive(:find_by) { picture }
+      end
+
+      context "with no render_size present in croppable_resource" do
+        before do
+          expect(croppable_resource).to receive(:render_size).at_least(:once).and_return(nil)
+        end
+
+        context "with sizes in settings" do
+          let(:settings) do
+            { size: "300x250" }
+          end
+
+          it "sets sizes to given values" do
+            subject
+            expect(assigns(:settings)[:min_size]).to eq([300, 250])
+          end
+        end
+
+        context "with no sizes in settings" do
+          it "sets sizes to zero" do
+            subject
+            expect(assigns(:settings)[:min_size]).to eq([0, 0])
+          end
+        end
+      end
+
+      context "with render_size present in croppable_resource" do
+        it "sets sizes from these values" do
+          expect(croppable_resource).to receive(:render_size).at_least(:once).and_return("30x25")
+
+          subject
+          expect(assigns(:settings)[:min_size]).to eq([30, 25])
+        end
+
+        context "when width or height is not fixed" do
+          it "infers the height from the image file preserving the aspect ratio" do
+            expect(croppable_resource).to receive(:render_size).at_least(:once).and_return("30x")
+
+            subject
+            expect(assigns(:settings)[:min_size]).to eq([30, 25])
+          end
+
+          context "and aspect ratio set on the settings" do
+            let(:settings) do
+              { fixed_ratio: "2" }
+            end
+
+            it "does not infer the height from the image file preserving the aspect ratio" do
+              expect(croppable_resource).to receive(:render_size).at_least(:once).and_return("x25")
+
+              subject
+              expect(assigns(:settings)[:min_size]).to eq([50, 25])
+            end
+          end
+        end
+
+        context "when width or height is not fixed and an aspect ratio is given" do
+          context "and aspect ratio set on the settings" do
+            let(:settings) do
+              { fixed_ratio: "0.5" }
+            end
+
+            it "width is given, it infers the height from width and ratio" do
+              expect(croppable_resource).to receive(:render_size).at_least(:once).and_return("30x")
+
+              subject
+              expect(assigns(:settings)[:min_size]).to eq([30, 60])
+            end
+          end
+
+          it "infers the height from the image file preserving the aspect ratio" do
+            expect(croppable_resource).to receive(:render_size).at_least(:once).and_return("x25")
+
+            subject
+            expect(assigns(:settings)[:min_size]).to eq([30, 25])
+          end
+        end
+      end
+
+      context "no crop sizes present in croppable_resource" do
+        it "assigns default mask boxes" do
+          subject
+          expect(assigns(:settings)[:default_box]).to eq(default_mask)
+        end
+      end
+
+      context "crop sizes present in croppable_resource" do
+        let(:mask) { [0, 0, 120, 160] }
+
+        before do
+          allow(croppable_resource).to receive(:crop_from).and_return("0x0")
+          allow(croppable_resource).to receive(:crop_size).and_return("120x160")
+        end
+
+        it "assigns cropping boxes" do
+          subject
+          expect(assigns(:settings)[:default_box]).to eq(default_mask)
+        end
+      end
+
+      context "with fixed_ratio set to false" do
+        let(:settings) do
+          { fixed_ratio: false }
+        end
+
+        it "sets ratio to false" do
+          subject
+          expect(assigns(:settings)[:ratio]).to eq(false)
+        end
+      end
+
+      context "with fixed_ratio set to a non float string" do
+        let(:settings) do
+          { fixed_ratio: "123,45" }
+        end
+
+        it "raises error" do
+          expect { subject }.to raise_error(ArgumentError)
+        end
+      end
+
+      context "with no fixed_ratio set" do
+        let(:settings) do
+          { size: "80x60" }
+        end
+
+        it "sets a fixed ratio from sizes" do
+          subject
+          expect(assigns(:settings)[:ratio]).to eq(80.0 / 60.0)
+        end
+      end
+    end
+  end
+end