ckeditor5 1.20.1 → 1.21.0

data/lib/ckeditor5/rails/editor/props.rb

@@ -14,16 +14,17 @@ module CKEditor5::Rails::Editor
     }.freeze
 
     def initialize(
-      controller_context, type, config,
-      watchdog: true, editable_height: nil, language: nil
+      type, config,
+      bundle: nil,
+      watchdog: true,
+      editable_height: nil
     )
       raise ArgumentError, "Invalid editor type: #{type}" unless Props.valid_editor_type?(type)
 
-      @controller_context = controller_context
+      @bundle = bundle
       @watchdog = watchdog
       @type = type
       @config = config
-      @language = language
       @editable_height = EditableHeightNormalizer.new(type).normalize(editable_height)
     end
 
@@ -40,11 +41,11 @@ module CKEditor5::Rails::Editor
 
     private
 
-    attr_reader :controller_context, :watchdog, :type, :config, :editable_height
+    attr_reader :bundle, :watchdog, :type, :config, :editable_height
 
     def serialized_attributes
       {
-        translations: serialize_translations,
+        bundle: bundle.to_json,
         plugins: serialize_plugins,
         config: serialize_config,
         watchdog: watchdog
@@ -52,10 +53,6 @@ module CKEditor5::Rails::Editor
         .merge(editable_height ? { 'editable-height' => editable_height } : {})
     end
 
-    def serialize_translations
-      controller_context[:bundle]&.translations_scripts&.map(&:to_h).to_json || '[]'
-    end
-
     def serialize_plugins
       (config[:plugins] || []).map { |plugin| PropsBasePlugin.normalize(plugin).to_h }.to_json
     end
@@ -63,10 +60,6 @@ module CKEditor5::Rails::Editor
     def serialize_config
       config
         .except(:plugins)
-        .tap do |cfg|
-          cfg[:licenseKey] = controller_context[:license_key] if controller_context[:license_key]
-          cfg[:language] = { ui: @language } if @language
-        end
         .to_json
     end
   end

data/lib/ckeditor5/rails/engine.rb

@@ -7,6 +7,8 @@ require_relative 'plugins/simple_upload_adapter'
 require_relative 'plugins/wproofreader'
 
 module CKEditor5::Rails
+  class PresetNotFoundError < ArgumentError; end
+
   class Engine < ::Rails::Engine
     config.ckeditor5 = ActiveSupport::OrderedOptions.new
     config.ckeditor5.presets = Presets::Manager.new
@@ -47,6 +49,10 @@ module CKEditor5::Rails
         config.ckeditor5.presets.default
       end
 
+      def presets
+        config.ckeditor5.presets
+      end
+
       def configure(&block)
         proxy = ConfigurationProxy.new(config.ckeditor5)
         proxy.instance_eval(&block)
@@ -57,6 +63,13 @@ module CKEditor5::Rails
 
         base.presets[preset]
       end
+
+      def find_preset!(preset)
+        found_preset = find_preset(preset)
+        return found_preset if found_preset.present?
+
+        raise PresetNotFoundError, "Preset '#{preset}' not found. Please define it in the initializer."
+      end
     end
 
     class ConfigurationProxy

data/lib/ckeditor5/rails/presets/manager.rb

@@ -8,6 +8,8 @@ module CKEditor5::Rails::Presets
   class Manager
     attr_reader :presets
 
+    alias to_h presets
+
     # Initializes a new Manager instance and sets up the default preset
     def initialize
       @presets = {}

data/lib/ckeditor5/rails/presets/preset_builder.rb

@@ -86,7 +86,7 @@ module CKEditor5::Rails
       # Merge preset with configuration hash
       # @param overrides [Hash] Configuration options to merge
       # @return [self]
-      def merge_with_hash!(**overrides) # rubocop:disable Metrics/AbcSize
+      def merge_with_hash!(**overrides)
         @version = Semver.new(overrides[:version]) if overrides.key?(:version)
         @premium = overrides.fetch(:premium, premium)
         @cdn = overrides.fetch(:cdn, cdn)

data/lib/ckeditor5/rails/version.rb

@@ -2,7 +2,7 @@
 
 module CKEditor5
   module Rails
-    VERSION = '1.20.1'
+    VERSION = '1.21.0'
 
     DEFAULT_CKEDITOR_VERSION = '44.0.0'
   end

data/spec/e2e/features/ajax_form_integration_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'e2e/spec_helper'
+
+RSpec.describe 'AJAX Form Integration', type: :feature, js: true do
+  before do
+    visit('form_ajax')
+    setup_form_tracking(page)
+  end
+
+  shared_examples 'an ajax form with CKEditor' do |form_testid, editor_testid, submit_testid, response_id| # rubocop:disable Metrics/BlockLength
+    let(:form) { find("[data-testid='#{form_testid}']") }
+    let(:editor) { find("[data-testid='#{editor_testid}']") }
+    let(:editable) { editor.find('.ck-editor__editable') }
+    let(:text_field) { editor.find('textarea', visible: :hidden) }
+    let(:submit_button) { find("[data-testid='#{submit_testid}']") }
+    let(:response_container) { find("##{response_id}") }
+
+    before do
+      expect(page).to have_css('.ck-editor__editable', wait: 10)
+    end
+
+    it 'loads editor properly' do
+      expect(page).to have_css("[data-testid='#{editor_testid}'] .ck-editor__editable")
+      expect(editor).to have_invisible_textarea
+    end
+
+    it 'validates required fields' do
+      editable.click
+      editable.send_keys([[:control, 'a'], :backspace])
+      text_field.set('')
+      submit_button.click
+
+      expect(form).not_to have_been_submitted
+      expect(text_field).to be_invalid
+    end
+
+    it 'submits form and shows response' do
+      test_content = "Test content #{Time.now.to_i}"
+
+      editable.click
+      editable.send_keys([[:control, 'a'], :backspace])
+      editable.send_keys(test_content)
+
+      sleep 1
+
+      submit_button.click
+
+      eventually(timeout: 13) do
+        expect(response_container).to be_visible
+        expect(response_container).to have_text('Success!')
+        expect(response_container).to have_text(test_content)
+
+        # Verify that CKEditor initializes in the response
+        response_editor = response_container.find('.ck-editor__editable', wait: 10)
+
+        expect(response_editor).to be_visible
+        expect(response_editor).to have_text(test_content)
+      end
+    end
+  end
+
+  describe 'Regular AJAX form' do
+    it_behaves_like 'an ajax form with CKEditor',
+                    'rails-form',
+                    'rails-form-editor',
+                    'rails-form-submit',
+                    'response'
+  end
+
+  describe 'Turbo Stream form' do
+    it_behaves_like 'an ajax form with CKEditor',
+                    'rails-form-stream',
+                    'rails-form-editor-stream',
+                    'rails-form-submit-stream',
+                    'response-stream'
+  end
+end

data/spec/e2e/features/lazy_assets_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'e2e/spec_helper'
+
+RSpec.describe 'Lazy Assets', type: :feature do
+  context 'without JavaScript', js: false do
+    before do
+      visit 'classic_lazy_assets?no_embed=true'
+    end
+
+    it 'does not load CKEditor assets' do
+      expect(page).not_to have_css('link[href*="ckeditor5"]', visible: false)
+      expect(page).not_to have_css('script[src*="ckeditor5"]', visible: false)
+
+      scripts = page.all('script:not([type="importmap"]):not([type="module"])', visible: false)
+      external_scripts = scripts.reject { |s| s[:src].nil? }
+      expect(external_scripts).not_to include(match(/ckeditor5/))
+
+      expect(page).to have_css('script[type="importmap"]', visible: false)
+    end
+  end
+
+  context 'with JavaScript', js: true do
+    before { visit 'classic_lazy_assets' }
+
+    it 'loads editor when needed' do
+      expect(page).to have_css('.ck-editor__editable', wait: 10)
+      expect(page).to have_css('link[href*="ckeditor5"]', visible: false)
+    end
+
+    it 'initializes editor properly' do
+      editor = find('.ck-editor__editable')
+      expect(editor).to be_visible
+
+      editor.click
+      editor.send_keys('Test content')
+
+      expect(editor).to have_text('Test content')
+    end
+
+    it 'supports multiple editor instances' do
+      visit 'classic_lazy_assets?multiple=true'
+
+      editors = all('.ck-editor__editable', wait: 10)
+      expect(editors.length).to eq(2)
+
+      editors.each do |editor|
+        editor.click
+        editor.send_keys('Content for editor')
+        expect(editor).to have_text('Content for editor')
+      end
+    end
+  end
+end

data/spec/e2e/support/form_helpers.rb

@@ -6,7 +6,10 @@ module FormHelpers
       window.lastSubmittedForm = null;
 
       document.addEventListener('submit', (e) => {
-        e.preventDefault();
+        if (!e.target.hasAttribute('data-turbo-frame')) {
+          e.preventDefault();
+        }
+
         window.lastSubmittedForm = e.target.id;
       });
     JS

data/spec/lib/ckeditor5/rails/assets/assets_bundle_hml_serializer_spec.rb

@@ -138,6 +138,59 @@ RSpec.describe CKEditor5::Rails::Assets::AssetsBundleHtmlSerializer do
                                  nonce: 'true'
                                })
     end
+
+    context 'with lazy loading' do
+      subject(:html) { described_class.new(bundle, lazy: true).to_html }
+
+      it 'does not include preload tags' do
+        expect(html).not_to have_tag('link', with: { rel: 'preload' })
+        expect(html).not_to have_tag('link', with: { rel: 'modulepreload' })
+      end
+
+      it 'does not include stylesheet links' do
+        stylesheets.each do |url|
+          expect(html).not_to have_tag('link', with: { href: url, rel: 'stylesheet' })
+        end
+      end
+
+      it 'does not include window script tags' do
+        scripts.each do |script|
+          expect(html).not_to have_tag('script', with: { src: script.url }) if script.window?
+        end
+      end
+
+      it 'includes web component script' do
+        expect(html).to have_tag('script', with: { type: 'module' })
+      end
+    end
+
+    context 'with eager loading (lazy: false)' do
+      subject(:html) { described_class.new(bundle, lazy: false).to_html }
+
+      it 'includes preload tags' do
+        scripts.each do |script|
+          expect(html).to have_tag('link', with: {
+                                     href: script.url,
+                                     rel: script.esm? ? 'modulepreload' : 'preload'
+                                   })
+        end
+      end
+
+      it 'includes stylesheet links' do
+        stylesheets.each do |url|
+          expect(html).to have_tag('link', with: {
+                                     href: url,
+                                     rel: 'stylesheet'
+                                   })
+        end
+      end
+
+      it 'includes window script tags' do
+        scripts.each do |script|
+          expect(html).to have_tag('script', with: { src: script.url }) if script.window?
+        end
+      end
+    end
   end
 
   describe '.url_resource_preload_type' do

data/spec/lib/ckeditor5/rails/assets/assets_bundle_spec.rb

@@ -115,7 +115,8 @@ RSpec.describe CKEditor5::Rails::Assets::JSUrlImportMeta do
       expect(meta.to_h).to eq({
                                 url: url,
                                 import_name: 'module',
-                                import_as: 'alias'
+                                import_as: 'alias',
+                                translation: false
                               })
     end
   end

data/spec/lib/ckeditor5/rails/cdn/helpers_spec.rb

@@ -35,10 +35,15 @@ RSpec.describe CKEditor5::Rails::Cdn::Helpers do
   end
 
   before do
-    allow(CKEditor5::Rails::Engine).to receive(:find_preset).and_return(preset)
+    allow(CKEditor5::Rails::Engine).to receive(:find_preset!).and_return(preset)
     allow(CKEditor5::Rails::Assets::AssetsBundleHtmlSerializer).to receive(:new).and_return(serializer)
   end
 
+  after do
+    RSpec::Mocks.space.proxy_for(CKEditor5::Rails::Engine).reset
+    RSpec::Mocks.space.proxy_for(CKEditor5::Rails::Assets::AssetsBundleHtmlSerializer).reset
+  end
+
   describe '#ckeditor5_assets' do
     context 'with valid preset' do
       it 'creates base bundle' do
@@ -206,12 +211,13 @@ RSpec.describe CKEditor5::Rails::Cdn::Helpers do
 
     context 'destructure non-matching preset override' do
       before do
-        allow(CKEditor5::Rails::Engine).to receive(:find_preset).and_return(nil)
+        RSpec::Mocks.space.proxy_for(CKEditor5::Rails::Engine).reset
       end
 
       it 'raises error' do
         expect { helper.ckeditor5_assets(preset: :invalid) }
-          .to raise_error(ArgumentError, /forgot to define your invalid preset/)
+          .to raise_error(CKEditor5::Rails::PresetNotFoundError)
+        RSpec::Mocks.space.proxy_for(CKEditor5::Rails::Engine).reset
       end
     end
 
@@ -256,6 +262,92 @@ RSpec.describe CKEditor5::Rails::Cdn::Helpers do
     end
   end
 
+  describe '#ckeditor5_lazy_javascript_tags' do
+    let(:web_component_html) do
+      '<script type="module" src="web-component.js">web component code</script>'.html_safe
+    end
+
+    let(:import_map_html) { '<script type="importmap">{"imports":{}}</script>'.html_safe }
+
+    let(:web_component_bundle) do
+      instance_double(CKEditor5::Rails::Assets::WebComponentBundle, to_html: web_component_html)
+    end
+    let(:import_map_bundle) do
+      instance_double(CKEditor5::Rails::Assets::AssetsImportMap, to_html: import_map_html)
+    end
+    let(:preset_manager) { instance_double(CKEditor5::Rails::Presets::Manager) }
+    let(:test_preset1) { instance_double(CKEditor5::Rails::Presets::PresetBuilder) }
+    let(:test_preset2) { instance_double(CKEditor5::Rails::Presets::PresetBuilder) }
+
+    before do
+      allow(CKEditor5::Rails::Assets::WebComponentBundle).to receive(:instance).and_return(
+        web_component_bundle
+      )
+
+      allow(CKEditor5::Rails::Assets::AssetsImportMap).to receive(:new).and_return(
+        import_map_bundle
+      )
+
+      allow(CKEditor5::Rails::Engine).to receive(:presets).and_return(preset_manager)
+      allow(preset_manager).to receive(:to_h).and_return({
+                                                           test1: test_preset1,
+                                                           test2: test_preset2
+                                                         })
+
+      allow(helper).to receive(:create_preset_bundle).with(test_preset1)
+                                                     .and_return(CKEditor5::Rails::Assets::AssetsBundle.new(
+                                                                   scripts: ['test1.js']
+                                                                 ))
+
+      allow(helper).to receive(:create_preset_bundle).with(test_preset2)
+                                                     .and_return(CKEditor5::Rails::Assets::AssetsBundle.new(
+                                                                   scripts: ['test2.js']
+                                                                 ))
+    end
+
+    context 'when importmap is available' do
+      before do
+        allow(helper).to receive(:importmap_available?).and_return(true)
+        allow(helper).to receive(:importmap_rendered?).and_return(false)
+      end
+
+      it 'stores bundle in context and returns web component script' do
+        result = helper.ckeditor5_lazy_javascript_tags
+
+        expect(result).to have_tag('script', with: {
+                                     type: 'module',
+                                     src: 'web-component.js'
+                                   })
+        expect(context[:bundle].scripts).to match_array(['test1.js', 'test2.js'])
+      end
+
+      it 'raises error when importmap is already rendered' do
+        allow(helper).to receive(:importmap_rendered?).and_return(true)
+
+        expect { helper.ckeditor5_lazy_javascript_tags }
+          .to raise_error(CKEditor5::Rails::Cdn::Helpers::ImportmapAlreadyRenderedError)
+      end
+    end
+
+    context 'when importmap is not available' do
+      before do
+        allow(helper).to receive(:importmap_available?).and_return(false)
+      end
+
+      it 'returns both importmap and web component scripts as one string' do
+        result = helper.ckeditor5_lazy_javascript_tags
+
+        expect(result).to have_tag('script', with: { type: 'importmap' },
+                                             text: '{"imports":{}}')
+
+        expect(result).to have_tag('script', with: {
+                                     type: 'module',
+                                     src: 'web-component.js'
+                                   })
+      end
+    end
+  end
+
   describe 'cdn helper methods' do
     it 'generates helper methods for third-party CDNs' do
       expect(helper).to respond_to(:ckeditor5_unpkg_assets)

data/spec/lib/ckeditor5/rails/editor/helpers/editor_helpers_spec.rb

@@ -16,30 +16,69 @@ RSpec.describe CKEditor5::Rails::Editor::Helpers::Editor do
   let(:context) { { preset: :default, cdn: :jsdelivr } }
 
   before do
+    RSpec::Mocks.space.proxy_for(CKEditor5::Rails::Engine).reset
+
     helper.instance_variable_set(:@__ckeditor_context, context)
+
     allow(preset).to receive(:type).and_return(:classic)
     allow(preset).to receive(:config).and_return({})
     allow(preset).to receive(:automatic_upgrades?).and_return(false)
+    allow(preset).to receive(:editable_height).and_return(nil)
   end
 
-  describe '#ckeditor5_editor' do
+  before do
+    test_class.send(:public, :ckeditor5_context_or_fallback)
+  end
+
+  describe '#ckeditor5_context_or_fallback' do
     before do
-      allow(helper).to receive(:find_preset).and_return(preset)
+      if helper.instance_variable_defined?(:@__ckeditor_context)
+        helper.remove_instance_variable(:@__ckeditor_context)
+      end
     end
 
-    it 'raises error when context is not defined' do
-      helper.remove_instance_variable(:@__ckeditor_context)
-      expect { helper.ckeditor5_editor }.to raise_error(
-        described_class::EditorContextError,
-        /CKEditor installation context is not defined/
-      )
+    it 'returns existing context when available' do
+      context = { preset: :custom, bundle: 'custom-bundle' }
+      helper.instance_variable_set(:@__ckeditor_context, context)
+
+      expect(helper.ckeditor5_context_or_fallback(nil)).to eq(context)
     end
 
-    it 'raises error when preset is not found' do
-      allow(helper).to receive(:find_preset).and_raise(described_class::PresetNotFoundError)
-      expect do
-        helper.ckeditor5_editor(preset: :unknown)
-      end.to raise_error(described_class::PresetNotFoundError)
+    it 'creates context from preset when provided' do
+      custom_preset = instance_double(CKEditor5::Rails::Presets::PresetBuilder)
+
+      allow(CKEditor5::Rails::Engine).to receive(:find_preset)
+        .with(:custom)
+        .and_return(custom_preset)
+
+      allow(helper).to receive(:create_preset_bundle)
+        .with(custom_preset)
+        .and_return('custom-bundle')
+
+      result = helper.ckeditor5_context_or_fallback(:custom)
+      expect(result).to match({
+                                bundle: 'custom-bundle',
+                                preset: custom_preset
+                              })
+    end
+
+    it 'returns fallback context when no context or preset is available' do
+      RSpec::Mocks.space.proxy_for(CKEditor5::Rails::Engine).reset
+
+      allow(CKEditor5::Rails::Engine).to receive(:default_preset)
+        .and_return(:default)
+
+      result = helper.ckeditor5_context_or_fallback(nil)
+      expect(result).to match({
+                                bundle: nil,
+                                preset: :default
+                              })
+    end
+  end
+
+  describe '#ckeditor5_editor' do
+    before do
+      allow(CKEditor5::Rails::Engine).to receive(:find_preset).with(:default).and_return(preset)
     end
 
     it 'merges extra configuration with preset config' do
@@ -124,10 +163,6 @@ RSpec.describe CKEditor5::Rails::Editor::Helpers::Editor do
     end
 
     context 'when using preset lookup' do
-      before do
-        RSpec::Mocks.space.proxy_for(helper).remove_stub(:find_preset)
-      end
-
       it 'uses default preset when none specified' do
         expect(CKEditor5::Rails::Engine).to receive(:find_preset)
           .with(:default)
@@ -154,15 +189,40 @@ RSpec.describe CKEditor5::Rails::Editor::Helpers::Editor do
         helper.ckeditor5_editor(preset: :explicit)
       end
 
-      it 'raises error when preset cannot be found' do
-        allow(CKEditor5::Rails::Engine).to receive(:find_preset)
-          .with(:unknown)
-          .and_return(nil)
+      it 'raises error when preset is not found' do
+        allow(CKEditor5::Rails::Engine).to receive(:find_preset).with(:unknown).and_return(nil)
+        expect do
+          helper.ckeditor5_editor(preset: :unknown)
+        end.to raise_error(CKEditor5::Rails::PresetNotFoundError)
+      end
+    end
+
+    it 'uses context from ckeditor5_context_or_fallback' do
+      custom_context = { preset: :custom, bundle: 'custom-bundle' }
+      allow(helper).to receive(:ckeditor5_context_or_fallback)
+        .with(nil)
+        .and_return(custom_context)
+
+      allow(CKEditor5::Rails::Engine).to receive(:find_preset)
+        .with(:custom)
+        .and_return(preset)
+
+      helper.ckeditor5_editor
+    end
+
+    context 'when using editable height' do
+      it 'uses editable height from preset when not explicitly provided' do
+        allow(preset).to receive(:editable_height).and_return(400)
+
+        expect(helper.ckeditor5_editor).to include('editable-height="400px"')
+      end
+
+      it 'uses editable height from options when provided' do
+        expect(helper.ckeditor5_editor(editable_height: 500)).to include('editable-height="500px"')
+
+        allow(preset).to receive(:editable_height).and_return(700)
 
-        expect { helper.ckeditor5_editor(preset: :unknown) }.to raise_error(
-          described_class::PresetNotFoundError,
-          'Preset unknown is not defined.'
-        )
+        expect(helper.ckeditor5_editor(editable_height: 600)).to include('editable-height="600px"')
       end
     end
   end