alchemy_cms 4.6.0 → 5.0.0.rc2

data/lib/alchemy/resources_helper.rb

@@ -104,30 +104,24 @@ module Alchemy
       options = {hint: resource_handler.help_text_for(attribute)}
       input_type = attribute[:type].to_s
       case input_type
-      when 'boolean'
+      when "boolean"
         options
-      when 'date', 'time', 'datetime'
+      when "date", "time", "datetime"
         date = resource_instance_variable.send(attribute[:name]) || Time.current
         options.merge(
-          as: 'string',
+          as: "string",
           input_html: {
-            'data-datepicker-type' => input_type,
-            value: date ? date.iso8601 : nil
-          }
+            "data-datepicker-type" => input_type,
+            value: date ? date.iso8601 : nil,
+          },
         )
-      when 'text'
-        options.merge(as: 'text', input_html: {rows: 4})
+      when "text"
+        options.merge(as: "text", input_html: {rows: 4})
       else
-        options.merge(as: 'string')
+        options.merge(as: "string")
       end
     end
 
-    # Renders the human model name with a count as h1 header
-    def resources_header
-      Alchemy::Deprecation.warn "resources_header is deprecated. Render 'alchemy/admin/resources/table_header' partial instead."
-      render 'alchemy/admin/resources/table_header'
-    end
-
     # Returns true if the resource contains any relations
     def contains_relations?
       resource_handler.resource_relations.present?
@@ -171,7 +165,7 @@ module Alchemy
     def render_resources
       render partial: resource_name, collection: resources_instance_variable
     rescue ActionView::MissingTemplate
-      render partial: 'resource', collection: resources_instance_variable
+      render partial: "resource", collection: resources_instance_variable
     end
 
     def resource_has_tags
@@ -185,8 +179,8 @@ module Alchemy
     def resource_filter_select
       resource_model.alchemy_resource_filters.map do |filter_scope|
         [
-          Alchemy.t(filter_scope.to_sym, scope: ['resources', resource_name, 'filters']),
-          filter_scope
+          Alchemy.t(filter_scope.to_sym, scope: ["resources", resource_name, "filters"]),
+          filter_scope,
         ]
       end
     end

data/lib/alchemy/routing_constraints.rb

@@ -34,7 +34,7 @@ module Alchemy
     def no_rails_route?
       return true if !%w(development test).include?(Rails.env)
 
-      (@params['urlname'] =~ /\Arails\//).nil?
+      (@params["urlname"] =~ /\Arails\//).nil?
     end
   end
 end

data/lib/alchemy/seeder.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "alchemy/shell"
 
 module Alchemy
@@ -23,11 +24,14 @@ module Alchemy
 
       def try_seed_pages
         return unless page_seeds_file.file?
+
         if Alchemy::Page.exists?
           desc "Seeding Alchemy pages"
           log "There are already pages present in your database. " \
               "Please use `rake db:reset' if you want to rebuild your database.", :skip
         else
+          create_default_site! unless Alchemy::Site.default
+          create_default_language! unless Alchemy::Language.default
           seed_pages if contentpages.present?
           seed_layoutpages if layoutpages.present?
         end
@@ -41,9 +45,8 @@ module Alchemy
 
         contentpages.each do |page|
           create_page(page, {
-            parent: Alchemy::Page.root,
             language: Alchemy::Language.default,
-            language_root: true
+            language_root: true,
           })
         end
       end
@@ -51,12 +54,8 @@ module Alchemy
       def seed_layoutpages
         desc "Seeding Alchemy layout pages from #{page_seeds_file}"
         language = Alchemy::Language.default
-        layout_root = Alchemy::Page.find_or_create_layout_root_for(language.id)
         layoutpages.each do |page|
-          create_page(page, {
-            parent: layout_root,
-            language: language
-          })
+          create_page(page, { language: language })
         end
       end
 
@@ -66,7 +65,7 @@ module Alchemy
         if Alchemy.user_class.exists?
           log "There are already users present in your database. " \
               "Please use `rake db:reset' if you want to rebuild your database.", :skip
-          return false
+          false
         else
           users = YAML.load_file(user_seeds_file)
           users.each do |draft|
@@ -79,7 +78,7 @@ module Alchemy
       private
 
       def page_seeds_file
-        @_page_seeds_file ||= Rails.root.join('db', 'seeds', 'alchemy', 'pages.yml')
+        @_page_seeds_file ||= Rails.root.join("db", "seeds", "alchemy", "pages.yml")
       end
 
       def page_yml
@@ -87,23 +86,52 @@ module Alchemy
       end
 
       def contentpages
-        page_yml.reject { |p| p['layoutpage'] }
+        page_yml.reject { |p| p["layoutpage"] }
       end
 
       def layoutpages
-        page_yml.select { |p| p['layoutpage'] }
+        page_yml.select { |p| p["layoutpage"] }
       end
 
       def user_seeds_file
-        @_user_seeds_file ||= Rails.root.join('db', 'seeds', 'alchemy', 'users.yml')
+        @_user_seeds_file ||= Rails.root.join("db", "seeds", "alchemy", "users.yml")
       end
 
       def create_page(draft, attributes = {})
-        children = draft.delete('children') || []
+        children = draft.delete("children") || []
         page = Alchemy::Page.create!(draft.merge(attributes))
         log "Created page: #{page.name}"
         children.each do |child|
-          create_page(child, parent: page)
+          create_page(child, parent: page, language: page.language)
+        end
+      end
+
+      # If no languages are present, create a default language based
+      # on the host app's Alchemy configuration.
+      def create_default_language!
+        default_language = Alchemy::Config.get(:default_language)
+        if default_language
+          Alchemy::Language.create!(
+            name: default_language["name"],
+            language_code: default_language["code"],
+            locale: default_language["code"],
+            frontpage_name: default_language["frontpage_name"],
+            page_layout: default_language["page_layout"],
+            public: true,
+            default: true,
+            site: Alchemy::Site.default,
+          )
+        else
+          raise DefaultLanguageNotFoundError
+        end
+      end
+
+      def create_default_site!
+        default_site = Alchemy::Config.get(:default_site)
+        if default_site
+          Alchemy::Site.create!(name: default_site["name"], host: default_site["host"])
+        else
+          raise DefaultSiteNotFoundError
         end
       end
     end

data/lib/alchemy/shell.rb

@@ -1,10 +1,18 @@
-require 'thor/shell/color'
+# frozen_string_literal: true
+require "thor/shell/color"
 
 module Alchemy
   # Provides methods for collecting sentences and displaying them
   # in a list on the shell / log
   #
   module Shell
+    COLORS = {
+      clear: Thor::Shell::Color::CLEAR,
+      green: Thor::Shell::Color::GREEN,
+      red: Thor::Shell::Color::RED,
+      yellow: Thor::Shell::Color::YELLOW,
+    }.freeze
+
     def self.silence!
       @silenced = true
     end
@@ -20,11 +28,11 @@ module Alchemy
     def desc(message)
       unless Alchemy::Shell.silenced?
         puts "\n#{message}"
-        puts "#{'-' * message.length}\n"
+        puts "#{"-" * message.length}\n"
       end
     end
 
-    def todo(todo, title = '')
+    def todo(todo, title = "")
       add_todo [title, todo]
     end
 
@@ -56,7 +64,7 @@ module Alchemy
       todos.each_with_index do |todo, i|
         title = "\n#{i + 1}. #{todo[0]}"
         log title, :message
-        puts '=' * title.length
+        puts "=" * title.length
         puts ""
         log todo[1], :message
       end
@@ -96,12 +104,7 @@ module Alchemy
     # @return [String]
     #
     def color(name)
-      color_const = name.to_s.upcase
-      if Thor::Shell::Color.const_defined?(color_const)
-        "Thor::Shell::Color::#{color_const}".constantize
-      else
-        ""
-      end
+      COLORS[name]
     end
   end
 end

data/lib/alchemy/taggable.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Alchemy
   # ActsAsTaggableOn to Gutentag interface compatibility module
   # Include this module to add tagging support to your model.

data/lib/alchemy/tasks/tidy.rb

@@ -1,4 +1,5 @@
-require 'alchemy/shell'
+# frozen_string_literal: true
+require "alchemy/shell"
 
 module Alchemy
   class Tidy
@@ -52,7 +53,7 @@ module Alchemy
           end
           if orphaned_elements.any?
             log "Found #{orphaned_elements.size} orphaned elements"
-            destroy_orphaned_records(orphaned_elements, 'element')
+            destroy_orphaned_records(orphaned_elements, "element")
           else
             log "No orphaned elements found", :skip
           end
@@ -71,7 +72,7 @@ module Alchemy
           end
           if orphaned_contents.any?
             log "Found #{orphaned_contents.size} orphaned contents"
-            destroy_orphaned_records(orphaned_contents, 'content')
+            destroy_orphaned_records(orphaned_contents, "content")
           else
             log "No orphaned contents found", :skip
           end

data/lib/alchemy/test_support/config_stubbing.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Alchemy
   module TestSupport
     # Allows you to stub the Alchemy configuration in your specs

data/lib/alchemy/test_support/essence_shared_examples.rb

@@ -1,36 +1,36 @@
 # frozen_string_literal: true
 
-require 'shoulda-matchers'
-require 'alchemy/test_support/factories/page_factory'
-require 'alchemy/test_support/factories/element_factory'
-require 'alchemy/test_support/factories/content_factory'
+require "shoulda-matchers"
+require "alchemy/test_support/factories/page_factory"
+require "alchemy/test_support/factories/element_factory"
+require "alchemy/test_support/factories/content_factory"
 
 RSpec.shared_examples_for "an essence" do
   let(:element) { Alchemy::Element.new }
-  let(:content) { Alchemy::Content.new(name: 'foo') }
-  let(:content_definition) { {'name' => 'foo'} }
+  let(:content) { Alchemy::Content.new(name: "foo") }
+  let(:content_definition) { { "name" => "foo" } }
 
-  describe 'eager loading' do
+  describe "eager loading" do
     before do
       2.times { described_class.create! }
     end
 
-    it 'does not throw error if eager loaded' do
+    it "does not throw error if eager loaded" do
       expect {
         described_class.all.includes(:ingredient_association).to_a
       }.to_not raise_error
     end
   end
 
-  it "touches the content after update" do
+  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)
 
-    content.update_column(:updated_at, 3.days.ago)
+    element.update_column(:updated_at, 3.days.ago)
     content.essence.update(essence.ingredient_column.to_sym => ingredient_value)
 
-    content.reload
-    expect(content.updated_at).to be_within(3.seconds).of(Time.current)
+    element.reload
+    expect(element.updated_at).to be_within(3.seconds).of(Time.current)
   end
 
   it "should have correct partial path" do
@@ -38,28 +38,28 @@ RSpec.shared_examples_for "an essence" do
     expect(essence.to_partial_path).to eq("alchemy/essences/#{underscored_essence}_view")
   end
 
-  describe '#definition' do
+  describe "#definition" do
     subject { essence.definition }
 
-    context 'without element' do
+    context "without element" do
       it { is_expected.to eq({}) }
     end
 
-    context 'with element' do
+    context "with element" do
       before do
         expect(essence).to receive(:element).at_least(:once).and_return(element)
       end
 
-      context 'but without content definitions' do
+      context "but without content definitions" do
         it { is_expected.to eq({}) }
       end
 
-      context 'and content definitions' do
+      context "and content definitions" do
         before do
           allow(essence).to receive(:content).and_return(content)
         end
 
-        context 'containing the content name' do
+        context "containing the content name" do
           before do
             expect(element).to receive(:content_definitions).at_least(:once).and_return([content_definition])
           end
@@ -69,7 +69,7 @@ RSpec.shared_examples_for "an essence" do
           end
         end
 
-        context 'not containing the content name' do
+        context "not containing the content name" do
           before do
             expect(element).to receive(:content_definitions).at_least(:once).and_return([])
           end
@@ -80,200 +80,200 @@ RSpec.shared_examples_for "an essence" do
     end
   end
 
-  describe '#ingredient=' do
-    it 'should set the value to ingredient column' do
+  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
+  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'})
+    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
+    describe "presence" do
+      context "with string given as validation type" do
         before do
-          allow(essence).to receive(:definition).and_return({'validate' => ['presence']})
+          allow(essence).to receive(:definition).and_return({ "validate" => ["presence"] })
         end
 
-        context 'when the ingredient column is empty' do
+        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
+          it "should not be valid" do
             expect(essence).to_not be_valid
           end
         end
 
-        context 'when the ingredient column is not nil' do
+        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
+          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
+      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}]})
+            allow(essence).to receive(:definition).and_return({ "validate" => [{ "presence" => true }] })
           end
 
-          context 'when the ingredient column is empty' do
+          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
+            it "should not be valid" do
               expect(essence).to_not be_valid
             end
           end
 
-          context 'when the ingredient column is not nil' do
+          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
+            it "should be valid" do
               expect(essence).to be_valid
             end
           end
         end
 
-        context 'where the value is false' do
+        context "where the value is false" do
           before do
-            allow(essence).to receive(:definition).and_return({'validate' => [{'presence' => false}]})
+            allow(essence).to receive(:definition).and_return({ "validate" => [{ "presence" => false }] })
           end
 
-          it 'should be valid' do
+          it "should be valid" do
             expect(essence).to be_valid
           end
         end
       end
     end
 
-    describe 'uniqueness' do
+    describe "uniqueness" do
       before do
-        allow(essence).to receive(:element).and_return(FactoryBot.build_stubbed(:alchemy_element))
+        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
+      context "with string given as validation type" do
         before do
-          expect(essence).to receive(:definition).at_least(:once).and_return({'validate' => ['uniqueness']})
+          expect(essence).to receive(:definition).at_least(:once).and_return({ "validate" => ["uniqueness"] })
         end
 
-        context 'when a duplicate exists' do
+        context "when a duplicate exists" do
           before do
             allow(essence).to receive(:duplicates).and_return([essence.dup])
           end
 
-          it 'should not be valid' do
+          it "should not be valid" do
             expect(essence).to_not be_valid
           end
 
-          context 'when validated essence is not public' do
+          context "when validated essence is not public" do
             before do
               expect(essence).to receive(:public?).and_return(false)
             end
 
-            it 'should be valid' do
+            it "should be valid" do
               expect(essence).to be_valid
             end
           end
         end
 
-        context 'when no duplicate exists' do
+        context "when no duplicate exists" do
           before do
             expect(essence).to receive(:duplicates).and_return([])
           end
 
-          it 'should be valid' do
+          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
+      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}]})
+            expect(essence).to receive(:definition).at_least(:once).and_return({ "validate" => [{ "uniqueness" => true }] })
           end
 
-          context 'when a duplicate exists' do
+          context "when a duplicate exists" do
             before do
               allow(essence).to receive(:duplicates).and_return([essence.dup])
             end
 
-            it 'should not be valid' do
+            it "should not be valid" do
               expect(essence).to_not be_valid
             end
 
-            context 'when validated essence is not public' do
+            context "when validated essence is not public" do
               before do
                 expect(essence).to receive(:public?).and_return(false)
               end
 
-              it 'should be valid' do
+              it "should be valid" do
                 expect(essence).to be_valid
               end
             end
           end
 
-          context 'when no duplicate exists' do
+          context "when no duplicate exists" do
             before do
               expect(essence).to receive(:duplicates).and_return([])
             end
 
-            it 'should be valid' do
+            it "should be valid" do
               expect(essence).to be_valid
             end
           end
         end
 
-        context 'where the value is false' do
+        context "where the value is false" do
           before do
-            allow(essence).to receive(:definition).and_return({'validate' => [{'uniqueness' => false}]})
+            allow(essence).to receive(:definition).and_return({ "validate" => [{ "uniqueness" => false }] })
           end
 
-          it 'should be valid' do
+          it "should be valid" do
             expect(essence).to be_valid
           end
         end
       end
     end
 
-    describe '#acts_as_essence?' do
-      it 'should return true' do
+    describe "#acts_as_essence?" do
+      it "should return true" do
         expect(essence.acts_as_essence?).to be_truthy
       end
     end
   end
 
-  context 'delegations' 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)  }
+    it { should delegate_method(:public?).to(:element) }
   end
 
-  describe 'essence relations' do
-    let(:page)    { FactoryBot.create(:alchemy_page, :restricted) }
+  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