ckeditor5 1.18.3 → 1.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60fcadf8181318c867cdb47b5baf04d0c3630faf3182145f1d3f37952778aeb9
-  data.tar.gz: c04696863a8b29644a37c6782b75dca5317a9bd2d0e166da05ae0cab357f1bc0
+  metadata.gz: 63ee1d664150a118c2c9fe63458b1e3163afaea9ed3ebecd5e2ddc712403be1e
+  data.tar.gz: d36eefbd3b1d662a68d92396639d8905cb448fedd7cef6ad7a332feaed9083a4
 SHA512:
-  metadata.gz: d13f472504a89a4a8ebc13caa463546995ac8592da03aba6ec52a85705990e0cf5c4b8582cccf143ee560541406db5ca449782e22642c57cf0d91beeeaa4edd3
-  data.tar.gz: 7c2f98547ea4a7044f73ec6017f35dadae2842aa61ea91ba7961ec0e114cb81491c5e30dc90c1ec964d394e3e49b1b6a28beaeed24a3264154e4d9a6e3bc7cee
+  metadata.gz: 25ee39187fa672d9a9df9bda4fce9108db977b7b1771a451c94f3f6934f85e32680ea9c91738fafdcfee4b9b1620782d59878921cb7a76a04a0213fbc5aed713
+  data.tar.gz: 1c69b5973b264cd16aaec7f697bff803f3ffaafed4a600ef47fb7abbb16577cad681714fa4c18268f9fb0095392b44f73296e2e00585874cbf62e9e4e294913d

data/README.md

@@ -161,6 +161,7 @@ For extending CKEditor's functionality, refer to the [plugins directory](https:/
       - [Setting the language in the initializer](#setting-the-language-in-the-initializer)
       - [Setting the language on the editor level](#setting-the-language-on-the-editor-level)
       - [Preloading multiple translation packs](#preloading-multiple-translation-packs)
+    - [Spell and Grammar Checking 📝](#spell-and-grammar-checking-)
     - [Integrating with Forms 📋](#integrating-with-forms-)
       - [Rails form builder integration](#rails-form-builder-integration)
       - [Simple form integration](#simple-form-integration)
@@ -928,6 +929,23 @@ CKEditor5::Rails.configure do
 end
 ```
 
+If no `language` is set, the plugin will use the default language of the editor. If you want to set the language of the WProofreader plugin, you can use the `language` keyword argument:
+
+```rb
+# config/initializers/ckeditor5.rb
+
+CKEditor5::Rails.configure do
+  # ... other configuration
+
+  wproofreader serviceId: 'your-service-ID',
+               srcUrl: 'https://svc.webspellchecker.net/spellcheck31/wscbundle/wscbundle.js',
+               language: :en_US,
+               localization: :pl
+end
+```
+
+For more info about the WProofreader plugin, check the [official documentation](https://ckeditor.com/docs/ckeditor5/latest/features/spelling-and-grammar-checking.html).
+
 </details>
 
 ### Controller / View helpers 📦
@@ -1585,6 +1603,23 @@ CKEditor5::Rails.configure do
 end
 ```
 
+### Spell and Grammar Checking 📝
+
+CKEditor 5 provides a spell and grammar checking feature through the WProofreader plugin. You can enable this feature by configuring the WProofreader plugin in the initializer.
+
+```rb
+# config/initializers/ckeditor5.rb
+
+CKEditor5::Rails.configure do
+  wproofreader serviceId: 'your-service-ID',
+               srcUrl: 'https://svc.webspellchecker.net/spellcheck31/wscbundle/wscbundle.js'
+end
+```
+
+See [`wproofreader(version: nil, cdn: nil, **config)` method](#wproofreaderversion-nil-cdn-nil-config-method) for more information about the WProofreader plugin configuration.
+
+See the [official documentation](https://ckeditor.com/docs/ckeditor5/latest/features/spelling-and-grammar-checking.html) for more information about the WProofreader plugin.
+
 ### Integrating with Forms 📋
 
 You can integrate CKEditor 5 with Rails form builders like `form_for` or `simple_form`. The example below shows how to integrate CKEditor 5 with a Rails form using the `form_for` helper:

data/lib/ckeditor5/rails/assets/assets_bundle.rb

@@ -1,11 +1,21 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/module'
+require 'uri'
 
 module CKEditor5::Rails::Assets
   class AssetsBundle
-    def initialize
-      validate_implementation!
+    def initialize(scripts: nil, stylesheets: nil)
+      @scripts = scripts
+      @stylesheets = stylesheets
+    end
+
+    def scripts
+      @scripts || []
+    end
+
+    def stylesheets
+      @stylesheets || []
     end
 
     def empty?
@@ -17,7 +27,7 @@ module CKEditor5::Rails::Assets
     end
 
     def preloads
-      stylesheets + scripts.map(&:url)
+      stylesheets + scripts.map(&:preloads)
     end
 
     def <<(other)
@@ -26,16 +36,6 @@ module CKEditor5::Rails::Assets
       @scripts = scripts + other.scripts
       @stylesheets = stylesheets + other.stylesheets
     end
-
-    private
-
-    def validate_implementation!
-      %i[scripts stylesheets].each do |method|
-        unless respond_to?(method, true)
-          raise NotImplementedError, "#{self.class} must implement the ##{method} method"
-        end
-      end
-    end
   end
 
   class JSUrlImportMeta
@@ -56,6 +56,14 @@ module CKEditor5::Rails::Assets
     def to_h
       import_meta.to_h.merge({ url: url })
     end
+
+    def preloads
+      {
+        as: 'script',
+        rel: esm? ? 'modulepreload' : 'preload',
+        href: url
+      }
+    end
   end
 
   class JSImportMeta

data/lib/ckeditor5/rails/assets/assets_bundle_html_serializer.rb

@@ -19,10 +19,10 @@ module CKEditor5::Rails::Assets
 
     def to_html
       safe_join([
+                  scripts_import_map_tag,
                   preload_tags,
                   styles_tags,
                   window_scripts_tags,
-                  scripts_import_map_tag,
                   web_component_tag
                 ])
     end
@@ -51,7 +51,9 @@ module CKEditor5::Rails::Assets
       return @scripts_import_map_tag if defined?(@scripts_import_map_tag)
 
       import_map = bundle.scripts.each_with_object({}) do |script, map|
-        map[script.import_name] = script.url if script.esm?
+        next if !script.esm? || looks_like_url?(script.import_name)
+
+        map[script.import_name] = script.url
       end
 
       @scripts_import_map_tag = tag.script(
@@ -68,10 +70,28 @@ module CKEditor5::Rails::Assets
     end
 
     def preload_tags
-      @preload_tags ||= safe_join(bundle.preloads.map do |url|
-        tag.link(href: url, rel: 'preload', as: self.class.url_resource_preload_type(url),
-                 crossorigin: 'anonymous')
+      @preload_tags ||= safe_join(bundle.preloads.map do |preload|
+        if preload.is_a?(Hash) && preload[:as] && preload[:href]
+          tag.link(
+            **preload,
+            crossorigin: 'anonymous'
+          )
+        else
+          tag.link(
+            href: preload,
+            rel: 'preload',
+            as: self.class.url_resource_preload_type(preload),
+            crossorigin: 'anonymous'
+          )
+        end
       end)
     end
+
+    def looks_like_url?(str)
+      uri = URI.parse(str)
+      uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+    rescue URI::InvalidURIError
+      false
+    end
   end
 end

data/lib/ckeditor5/rails/assets/webcomponents/utils.mjs

@@ -86,6 +86,20 @@ function loadAsyncImports(imports = []) {
   }));
 }
 
+/**
+ * Checks if stylesheet with given href already exists in document
+ *
+ * @param {string} href - Stylesheet URL to check
+ * @returns {boolean} True if stylesheet already exists
+ */
+function stylesheetExists(href) {
+  return Array
+    .from(document.styleSheets)
+    .some(sheet =>
+      sheet.href === href || sheet.href === new URL(href, window.location.href).href
+    );
+}
+
 /**
  * Dynamically loads CSS files based on configuration
  *
@@ -96,19 +110,19 @@ function loadAsyncImports(imports = []) {
 function loadAsyncCSS(stylesheets = []) {
   const promises = stylesheets.map(href =>
     new Promise((resolve, reject) => {
-      const link = document.createElement('link');
+      if (stylesheetExists(href)) {
+        resolve();
+        return;
+      }
 
+      const link = document.createElement('link');
       link.rel = 'stylesheet';
       link.href = href;
 
       link.onerror = reject;
-      link.onload = () => {
-        resolve();
-      };
+      link.onload = () => resolve();
 
       document.head.appendChild(link);
-
-      return link;
     })
   );
 

data/lib/ckeditor5/rails/cdn/helpers.rb

@@ -26,6 +26,7 @@ module CKEditor5::Rails
       bundle = build_base_cdn_bundle(cdn, version, translations)
       bundle << build_premium_cdn_bundle(cdn, version, translations) if premium
       bundle << build_ckbox_cdn_bundle(ckbox) if ckbox
+      bundle << build_plugins_cdn_bundle(mapped_preset.plugins.items)
 
       @__ckeditor_context = {
         license_key: license_key,
@@ -98,5 +99,11 @@ module CKEditor5::Rails
         cdn: ckbox[:cdn] || :ckbox
       )
     end
+
+    def build_plugins_cdn_bundle(plugins)
+      plugins.each_with_object(Assets::AssetsBundle.new(scripts: [], stylesheets: [])) do |plugin, bundle|
+        bundle << plugin.preload_assets_bundle if plugin.preload_assets_bundle.present?
+      end
+    end
   end
 end

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

@@ -8,8 +8,8 @@ module CKEditor5::Rails::Editor
       @name = name
     end
 
-    def preload_assets_urls
-      []
+    def preload_assets_bundle
+      nil
     end
 
     def to_h

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

@@ -18,8 +18,11 @@ module CKEditor5::Rails::Editor
       )
     end
 
-    def preload_assets_urls
-      @stylesheets + [@js_import_meta.url]
+    def preload_assets_bundle
+      @preload_assets_bundle ||= CKEditor5::Rails::Assets::AssetsBundle.new(
+        scripts: [@js_import_meta],
+        stylesheets: @stylesheets
+      )
     end
 
     def to_h

data/lib/ckeditor5/rails/presets/concerns/plugin_methods.rb

@@ -22,6 +22,7 @@ module CKEditor5::Rails
         end
 
         def plugin(name, **kwargs)
+          premium(true) if kwargs[:premium] && respond_to?(:premium)
           register_plugin(PluginsBuilder.create_plugin(name, **kwargs))
         end
 

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

@@ -207,8 +207,8 @@ module CKEditor5::Rails
       def wproofreader(version: nil, cdn: nil, **config)
         configure :wproofreader, config
         plugins do
-          prepend Plugins::WProofreaderSync.new
-          append Plugins::WProofreader.new(version: version, cdn: cdn)
+          prepend(Plugins::WProofreaderSync.new)
+          append(Plugins::WProofreader.new(version: version, cdn: cdn))
         end
       end
 

data/lib/ckeditor5/rails/version.rb

@@ -2,7 +2,7 @@
 
 module CKEditor5
   module Rails
-    VERSION = '1.18.3'
+    VERSION = '1.19.0'
 
     DEFAULT_CKEDITOR_VERSION = '43.3.1'
   end

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

@@ -3,20 +3,6 @@
 require 'spec_helper'
 
 RSpec.describe CKEditor5::Rails::Assets::AssetsBundleHtmlSerializer do
-  let(:test_bundle_class) do
-    Class.new(CKEditor5::Rails::Assets::AssetsBundle) do
-      attr_accessor :scripts, :stylesheets
-
-      def initialize(scripts, stylesheets)
-        @scripts = scripts
-        @stylesheets = stylesheets
-        super()
-      end
-    end
-  end
-
-  let(:bundle) { test_bundle_class.new(scripts, stylesheets) }
-
   let(:scripts) do
     [
       CKEditor5::Rails::Assets::JSUrlImportMeta.new(
@@ -31,7 +17,7 @@ RSpec.describe CKEditor5::Rails::Assets::AssetsBundleHtmlSerializer do
   end
 
   let(:stylesheets) { ['https://cdn.com/style1.css', 'https://cdn.com/style2.css'] }
-  let(:preloads) { bundle.preloads }
+  let(:bundle) { CKEditor5::Rails::Assets::AssetsBundle.new(scripts: scripts, stylesheets: stylesheets) }
 
   subject(:serializer) { described_class.new(bundle) }
 
@@ -48,43 +34,102 @@ RSpec.describe CKEditor5::Rails::Assets::AssetsBundleHtmlSerializer do
   describe '#to_html' do
     subject(:html) { serializer.to_html }
 
-    it 'includes window scripts' do
-      expect(html).to include(
-        '<script src="https://cdn.com/script1.js" nonce="true" crossorigin="anonymous">'
-      )
+    it 'includes window script tags' do
+      expect(html).to have_tag('script', with: {
+                                 src: 'https://cdn.com/script1.js',
+                                 nonce: 'true',
+                                 crossorigin: 'anonymous'
+                               })
     end
 
     it 'includes import map' do
-      expect(html).to include('type="importmap"')
-      expect(html).to include('"@ckeditor/script2":"https://cdn.com/script2.js"')
+      expect(html).to have_tag('script', with: { type: 'importmap' }) do
+        with_text(%r{"@ckeditor/script2":"https://cdn\.com/script2\.js"})
+      end
     end
 
-    it 'includes stylesheet links' do
-      stylesheets.each do |url|
-        expect(html).to include("<link href=\"#{url}\" rel=\"stylesheet\" crossorigin=\"anonymous\">")
-      end
+    it 'includes import map with correct attributes' do
+      expect(html).to have_tag('script', with: {
+                                 type: 'importmap',
+                                 nonce: 'true'
+                               })
     end
 
-    it 'includes preload links' do
-      expect(html).to include(
-        '<link href="https://cdn.com/style1.css" rel="preload" as="style" crossorigin="anonymous">'
+    it 'does not include URL-like imports in import map' do
+      bundle = CKEditor5::Rails::Assets::AssetsBundle.new(
+        scripts: [
+          CKEditor5::Rails::Assets::JSUrlImportMeta.new(
+            'https://cdn.com/script.js',
+            import_name: 'https://example.com/module'
+          ),
+          CKEditor5::Rails::Assets::JSUrlImportMeta.new(
+            'https://cdn.com/script.js',
+            import_name: 'module'
+          )
+        ]
       )
+      html = described_class.new(bundle).to_html
 
-      expect(html).to include(
-        '<link href="https://cdn.com/style2.css" rel="preload" as="style" crossorigin="anonymous">'
-      )
+      expect(html).to have_tag('script', with: { type: 'importmap' }) do
+        with_text('{"imports":{"module":"https://cdn.com/script.js"}}')
+      end
+    end
 
-      expect(html).to include(
-        '<link href="https://cdn.com/script1.js" rel="preload" as="script" crossorigin="anonymous">'
+    it 'includes only ESM scripts in import map' do
+      bundle = CKEditor5::Rails::Assets::AssetsBundle.new(
+        scripts: [
+          CKEditor5::Rails::Assets::JSUrlImportMeta.new(
+            'https://cdn.com/script1.js',
+            window_name: 'WindowScript'
+          ),
+          CKEditor5::Rails::Assets::JSUrlImportMeta.new(
+            'https://cdn.com/script2.js',
+            import_name: '@ckeditor/module'
+          )
+        ]
       )
+      html = described_class.new(bundle).to_html
 
-      expect(html).to include(
-        '<link href="https://cdn.com/script2.js" rel="preload" as="script" crossorigin="anonymous">'
-      )
+      expect(html).to have_tag('script', with: { type: 'importmap' }) do
+        with_text('{"imports":{"@ckeditor/module":"https://cdn.com/script2.js"}}')
+      end
+    end
+
+    it 'includes stylesheet links' do
+      stylesheets.each do |url|
+        expect(html).to have_tag('link', with: {
+                                   href: url,
+                                   rel: 'stylesheet',
+                                   crossorigin: 'anonymous'
+                                 })
+      end
+    end
+
+    it 'includes preload links' do
+      scripts.each do |script|
+        expect(html).to have_tag('link', with: {
+                                   href: script.url,
+                                   rel: script.esm? ? 'modulepreload' : 'preload',
+                                   as: 'script',
+                                   crossorigin: 'anonymous'
+                                 })
+      end
+
+      stylesheets.each do |url|
+        expect(html).to have_tag('link', with: {
+                                   href: url,
+                                   rel: 'preload',
+                                   as: 'style',
+                                   crossorigin: 'anonymous'
+                                 })
+      end
     end
 
     it 'includes web component script' do
-      expect(html).to include('<script type="module" nonce="true">')
+      expect(html).to have_tag('script', with: {
+                                 type: 'module',
+                                 nonce: 'true'
+                               })
     end
 
     it 'memoizes scripts import map' do
@@ -108,4 +153,17 @@ RSpec.describe CKEditor5::Rails::Assets::AssetsBundleHtmlSerializer do
       expect(described_class.url_resource_preload_type('file.unknown')).to eq('fetch')
     end
   end
+
+  describe '#looks_like_url? (private)' do
+    subject(:serializer) { described_class.new(CKEditor5::Rails::Assets::AssetsBundle.new) }
+
+    it 'returns false for invalid URIs' do
+      expect(serializer.send(:looks_like_url?, '@ckeditor/foo')).to be false
+      expect(serializer.send(:looks_like_url?, 'http')).to be false
+      expect(serializer.send(:looks_like_url?, 'invalid')).to be false
+      expect(serializer.send(:looks_like_url?, 'http://[invalid')).to be false
+      expect(serializer.send(:looks_like_url?, "http://example.com\nmalicious")).to be false
+      expect(serializer.send(:looks_like_url?, 'http://<invalid>')).to be false
+    end
+  end
 end

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

@@ -3,48 +3,45 @@
 require 'spec_helper'
 
 RSpec.describe CKEditor5::Rails::Assets::AssetsBundle do
-  let(:concrete_class) do
-    Class.new(described_class) do
-      def scripts
-        []
-      end
-
-      def stylesheets
-        []
-      end
-    end
-  end
-
   describe '#initialize' do
-    it 'raises error when required methods are not implemented' do
-      expect { described_class.new }.to raise_error(NotImplementedError)
+    it 'initializes with empty arrays by default' do
+      bundle = described_class.new
+      expect(bundle.scripts).to eq([])
+      expect(bundle.stylesheets).to eq([])
     end
 
-    it 'initializes successfully when required methods are implemented' do
-      expect { concrete_class.new }.not_to raise_error
+    it 'accepts scripts and stylesheets' do
+      bundle = described_class.new(scripts: [:script], stylesheets: [:stylesheet])
+      expect(bundle.scripts).to eq([:script])
+      expect(bundle.stylesheets).to eq([:stylesheet])
     end
   end
 
   describe '#empty?' do
-    subject(:bundle) { concrete_class.new }
-
     it 'returns true when no assets are present' do
+      bundle = described_class.new
       expect(bundle).to be_empty
     end
+
+    it 'returns false when scripts are present' do
+      bundle = described_class.new(scripts: [:script])
+      expect(bundle).not_to be_empty
+    end
+
+    it 'returns false when stylesheets are present' do
+      bundle = described_class.new(stylesheets: [:stylesheet])
+      expect(bundle).not_to be_empty
+    end
   end
 
   describe '#translations_scripts' do
-    let(:bundle) { concrete_class.new }
     let(:translation_script) do
       instance_double(CKEditor5::Rails::Assets::JSUrlImportMeta, translation?: true)
     end
     let(:regular_script) { instance_double(CKEditor5::Rails::Assets::JSUrlImportMeta, translation?: false) }
 
-    before do
-      allow(bundle).to receive(:scripts).and_return([translation_script, regular_script])
-    end
-
     it 'returns only translation scripts' do
+      bundle = described_class.new(scripts: [translation_script, regular_script])
       expect(bundle.translations_scripts).to eq([translation_script])
     end
   end
@@ -54,41 +51,8 @@ RSpec.describe CKEditor5::Rails::Assets::AssetsBundle do
     let(:script2) { instance_double(CKEditor5::Rails::Assets::JSUrlImportMeta) }
     let(:stylesheet1) { '/path/to/style1.css' }
     let(:stylesheet2) { '/path/to/style2.css' }
-
-    let(:bundle1) do
-      Class.new(described_class) do
-        attr_writer :scripts, :stylesheets
-
-        def scripts
-          @scripts ||= []
-        end
-
-        def stylesheets
-          @stylesheets ||= []
-        end
-      end.new
-    end
-
-    let(:bundle2) do
-      Class.new(described_class) do
-        attr_writer :scripts, :stylesheets
-
-        def scripts
-          @scripts ||= []
-        end
-
-        def stylesheets
-          @stylesheets ||= []
-        end
-      end.new
-    end
-
-    before do
-      bundle1.scripts = [script1]
-      bundle1.stylesheets = [stylesheet1]
-      bundle2.scripts = [script2]
-      bundle2.stylesheets = [stylesheet2]
-    end
+    let(:bundle1) { described_class.new(scripts: [script1], stylesheets: [stylesheet1]) }
+    let(:bundle2) { described_class.new(scripts: [script2], stylesheets: [stylesheet2]) }
 
     it 'raises TypeError when argument is not an AssetsBundle' do
       expect { bundle1 << 'not a bundle' }.to raise_error(TypeError)
@@ -103,36 +67,23 @@ RSpec.describe CKEditor5::Rails::Assets::AssetsBundle do
   end
 
   describe '#preloads' do
-    let(:script1) { instance_double(CKEditor5::Rails::Assets::JSUrlImportMeta, url: '/js/script1.js') }
-    let(:script2) { instance_double(CKEditor5::Rails::Assets::JSUrlImportMeta, url: '/js/script2.js') }
+    let(:script1) { CKEditor5::Rails::Assets::JSUrlImportMeta.new('/js/script1.js', import_name: 'script1') }
+    let(:script2) { CKEditor5::Rails::Assets::JSUrlImportMeta.new('/js/script2.js', import_name: 'script2') }
     let(:stylesheet1) { '/css/style1.css' }
     let(:stylesheet2) { '/css/style2.css' }
-
     let(:bundle) do
-      Class.new(described_class) do
-        attr_writer :scripts, :stylesheets
-
-        def scripts
-          @scripts ||= []
-        end
-
-        def stylesheets
-          @stylesheets ||= []
-        end
-      end.new
-    end
-
-    before do
-      bundle.scripts = [script1, script2]
-      bundle.stylesheets = [stylesheet1, stylesheet2]
+      described_class.new(
+        scripts: [script1, script2],
+        stylesheets: [stylesheet1, stylesheet2]
+      )
     end
 
     it 'returns array of stylesheet paths and script urls' do
       expect(bundle.preloads).to eq([
                                       '/css/style1.css',
                                       '/css/style2.css',
-                                      '/js/script1.js',
-                                      '/js/script2.js'
+                                      { as: 'script', rel: 'modulepreload', href: '/js/script1.js' },
+                                      { as: 'script', rel: 'modulepreload', href: '/js/script2.js' }
                                     ])
     end
   end
@@ -168,6 +119,18 @@ RSpec.describe CKEditor5::Rails::Assets::JSUrlImportMeta do
                               })
     end
   end
+
+  describe '#preloads' do
+    it 'returns preload hash' do
+      meta = described_class.new(url, window_name: 'module')
+      expect(meta.preloads).to eq({ as: 'script', rel: 'preload', href: url })
+    end
+
+    it 'returns modulepreload hash when esm' do
+      meta = described_class.new(url, import_name: 'module')
+      expect(meta.preloads).to include({ as: 'script', rel: 'modulepreload', href: url })
+    end
+  end
 end
 
 RSpec.describe CKEditor5::Rails::Assets::JSImportMeta do

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

@@ -108,6 +108,30 @@ RSpec.describe CKEditor5::Rails::Cdn::Helpers do
           helper.ckeditor5_assets(preset: :default)
         end
       end
+
+      context 'with plugins having preload assets' do
+        let(:plugin_bundle) { CKEditor5::Rails::Assets::AssetsBundle.new(scripts: ['plugin.js']) }
+        let(:plugin) { instance_double('Plugin', preload_assets_bundle: plugin_bundle) }
+        let(:plugin_without_preload) { instance_double('Plugin', preload_assets_bundle: nil) }
+
+        before do
+          allow(preset).to receive_message_chain(:plugins, :items)
+            .and_return([plugin, plugin_without_preload])
+        end
+
+        it 'includes plugin preload assets in the bundle' do
+          helper.ckeditor5_assets(preset: :default)
+          expect(context[:bundle].scripts).to include('plugin.js')
+        end
+
+        it 'merges plugin assets with the main bundle' do
+          expect(serializer).to receive(:to_html)
+          helper.ckeditor5_assets(preset: :default)
+
+          bundle = context[:bundle]
+          expect(bundle.scripts).to include('plugin.js')
+        end
+      end
     end
 
     context 'when overriding preset values' do

data/spec/lib/ckeditor5/rails/editor/props_base_plugin_spec.rb

@@ -33,11 +33,11 @@ RSpec.describe CKEditor5::Rails::Editor::PropsBasePlugin do
     end
   end
 
-  describe '#preload_assets_urls' do
-    it 'returns empty array' do
+  describe '#preload_assets_bundle' do
+    it 'returns nil by default' do
       plugin = described_class.new(:Bold)
 
-      expect(plugin.preload_assets_urls).to eq([])
+      expect(plugin.preload_assets_bundle).to be_nil
     end
   end
 

data/spec/lib/ckeditor5/rails/editor/props_external_plugin_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe CKEditor5::Rails::Editor::PropsExternalPlugin do
       plugin = described_class.new('Test', script: 'https://example.org/plugin.js')
 
       expect(plugin.name).to eq('Test')
-      expect(plugin.preload_assets_urls).to include('https://example.org/plugin.js')
+      expect(plugin.preload_assets_bundle.scripts.first.url).to eq('https://example.org/plugin.js')
     end
 
     it 'accepts optional parameters' do
@@ -20,23 +20,21 @@ RSpec.describe CKEditor5::Rails::Editor::PropsExternalPlugin do
         stylesheets: ['https://example.org/style.css']
       )
 
-      expect(plugin.preload_assets_urls).to include('https://example.org/style.css')
+      expect(plugin.preload_assets_bundle.stylesheets).to include('https://example.org/style.css')
     end
   end
 
-  describe '#preload_assets_urls' do
-    it 'returns array with script and stylesheets urls' do
+  describe '#preload_assets_bundle' do
+    it 'returns bundle with script and stylesheets' do
       plugin = described_class.new(
         'Test',
         script: 'https://example.org/plugin.js',
         stylesheets: ['https://example.org/style1.css', 'https://example.org/style2.css']
       )
 
-      expect(plugin.preload_assets_urls).to eq([
-                                                 'https://example.org/style1.css',
-                                                 'https://example.org/style2.css',
-                                                 'https://example.org/plugin.js'
-                                               ])
+      bundle = plugin.preload_assets_bundle
+      expect(bundle.scripts.first.url).to eq('https://example.org/plugin.js')
+      expect(bundle.stylesheets).to eq(['https://example.org/style1.css', 'https://example.org/style2.css'])
     end
   end
 

data/spec/lib/ckeditor5/rails/engine_spec.rb

@@ -78,10 +78,28 @@ RSpec.describe CKEditor5::Rails::Engine do
       end
     end
 
-    describe 'simple_form initializer', if: defined?(SimpleForm) do
-      it 'registers ckeditor5 input type' do
-        expect(SimpleForm::FormBuilder.mappings[:ckeditor5])
-          .to eq(CKEditor5::Rails::Hooks::SimpleForm::CKEditor5Input)
+    describe 'simple_form initializer' do
+      context 'when SimpleForm is defined' do
+        it 'registers ckeditor5 input type' do
+          expect(SimpleForm::FormBuilder.mappings[:ckeditor5])
+            .to eq(CKEditor5::Rails::Hooks::SimpleForm::CKEditor5Input)
+        end
+      end
+
+      context 'when SimpleForm is not defined' do
+        before do
+          @simple_form = SimpleForm if defined?(SimpleForm)
+          Object.send(:remove_const, :SimpleForm) if defined?(SimpleForm)
+        end
+
+        after do
+          Object.const_set(:SimpleForm, @simple_form) if @simple_form
+        end
+
+        it 'does not raise error' do
+          initializer = described_class.initializers.find { |i| i.name == 'ckeditor5.simple_form' }
+          expect { initializer.run(Rails.application) }.not_to raise_error
+        end
       end
     end
   end

data/spec/lib/ckeditor5/rails/plugins/wproofreader_spec.rb

@@ -14,12 +14,10 @@ RSpec.describe CKEditor5::Rails::Plugins::WProofreader do
         expect(plugin.name).to eq(:WProofreader)
       end
 
-      it 'returns correct preload assets urls' do
-        expected_urls = [
-          "#{default_cdn}@#{default_version}/dist/browser/index.css",
-          "#{default_cdn}@#{default_version}/dist/browser/index.js"
-        ]
-        expect(plugin.preload_assets_urls).to eq(expected_urls)
+      it 'returns correct preload assets bundle' do
+        bundle = plugin.preload_assets_bundle
+        expect(bundle.stylesheets).to eq(["#{default_cdn}@#{default_version}/dist/browser/index.css"])
+        expect(bundle.scripts.first.url).to eq("#{default_cdn}@#{default_version}/dist/browser/index.js")
       end
 
       it 'returns correct hash representation' do
@@ -39,12 +37,10 @@ RSpec.describe CKEditor5::Rails::Plugins::WProofreader do
       let(:custom_version) { '4.0.0' }
       subject(:plugin) { described_class.new(version: custom_version, cdn: custom_cdn) }
 
-      it 'returns correct preload assets urls with custom CDN' do
-        expected_urls = [
-          "#{custom_cdn}@#{custom_version}/dist/browser/index.css",
-          "#{custom_cdn}@#{custom_version}/dist/browser/index.js"
-        ]
-        expect(plugin.preload_assets_urls).to eq(expected_urls)
+      it 'returns correct preload assets bundle with custom CDN' do
+        bundle = plugin.preload_assets_bundle
+        expect(bundle.stylesheets).to eq(["#{custom_cdn}@#{custom_version}/dist/browser/index.css"])
+        expect(bundle.scripts.first.url).to eq("#{custom_cdn}@#{custom_version}/dist/browser/index.js")
       end
 
       it 'returns correct hash representation with custom CDN' do

data/spec/lib/ckeditor5/rails/presets/preset_builder_spec.rb

@@ -226,6 +226,48 @@ RSpec.describe CKEditor5::Rails::Presets::PresetBuilder do
     end
   end
 
+  describe '#plugin' do
+    it 'adds normalized plugin to config' do
+      plugin = builder.plugin('Test')
+
+      expect(builder.config[:plugins]).to include(plugin)
+      expect(plugin).to be_a(CKEditor5::Rails::Editor::PropsPlugin)
+    end
+
+    it 'accepts plugin options' do
+      plugin = builder.plugin('Test', premium: true)
+
+      expect(plugin.to_h[:import_name]).to eq('ckeditor5-premium-features')
+    end
+
+    it 'sets premium flag when premium option provided' do
+      builder.plugin('Test', premium: true)
+      expect(builder.premium?).to be true
+    end
+  end
+
+  describe '#external_plugin' do
+    it 'adds external plugin to config' do
+      plugin = builder.external_plugin('Test', script: 'https://example.org/script.js')
+
+      expect(builder.config[:plugins]).to include(plugin)
+      expect(plugin).to be_a(CKEditor5::Rails::Editor::PropsExternalPlugin)
+    end
+
+    it 'accepts plugin options' do
+      plugin = builder.external_plugin(
+        'Test',
+        script: 'https://example.org/script.js',
+        import_as: 'ABC',
+        stylesheets: ['https://example.org/style.css']
+      )
+
+      expect(plugin.to_h[:import_name]).to eq('https://example.org/script.js')
+      expect(plugin.to_h[:import_as]).to eq('ABC')
+      expect(plugin.to_h[:stylesheets]).to include('https://example.org/style.css')
+    end
+  end
+
   describe '#cdn' do
     it 'returns current cdn when called without arguments' do
       expect(builder.cdn).to eq(:jsdelivr)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ckeditor5
 version: !ruby/object:Gem::Version
-  version: 1.18.3
+  version: 1.19.0
 platform: ruby
 authors:
 - Mateusz Bagiński
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-28 00:00:00.000000000 Z
+date: 2024-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails