ckeditor5 1.15.8 → 1.15.10

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+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)
+    end
+
+    it 'initializes successfully when required methods are implemented' do
+      expect { concrete_class.new }.not_to raise_error
+    end
+  end
+
+  describe '#empty?' do
+    subject(:bundle) { concrete_class.new }
+
+    it 'returns true when no assets are present' do
+      expect(bundle).to be_empty
+    end
+  end
+
+  describe '#translations_scripts' do
+    let(:bundle) { concrete_class.new }
+    let(:translation_script) { instance_double(CKEditor5::Rails::Assets::JSExportsMeta, translation?: true) }
+    let(:regular_script) { instance_double(CKEditor5::Rails::Assets::JSExportsMeta, translation?: false) }
+
+    before do
+      allow(bundle).to receive(:scripts).and_return([translation_script, regular_script])
+    end
+
+    it 'returns only translation scripts' do
+      expect(bundle.translations_scripts).to eq([translation_script])
+    end
+  end
+
+  describe '#<<' do
+    let(:script1) { instance_double(CKEditor5::Rails::Assets::JSExportsMeta) }
+    let(:script2) { instance_double(CKEditor5::Rails::Assets::JSExportsMeta) }
+    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
+
+    it 'raises TypeError when argument is not an AssetsBundle' do
+      expect { bundle1 << 'not a bundle' }.to raise_error(TypeError)
+    end
+
+    it 'merges scripts and stylesheets from both bundles' do
+      bundle1 << bundle2
+
+      expect(bundle1.scripts).to eq([script1, script2])
+      expect(bundle1.stylesheets).to eq([stylesheet1, stylesheet2])
+    end
+  end
+
+  describe '#preloads' do
+    let(:script1) { instance_double(CKEditor5::Rails::Assets::JSExportsMeta, url: '/js/script1.js') }
+    let(:script2) { instance_double(CKEditor5::Rails::Assets::JSExportsMeta, url: '/js/script2.js') }
+    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]
+    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'
+                                    ])
+    end
+  end
+end
+
+RSpec.describe CKEditor5::Rails::Assets::JSExportsMeta do
+  let(:url) { '/path/to/script.js' }
+
+  describe '#initialize' do
+    it 'creates instance with import_name' do
+      meta = described_class.new(url, import_name: 'module')
+      expect(meta.import_name).to eq('module')
+    end
+
+    it 'creates instance with window_name' do
+      meta = described_class.new(url, window_name: 'MyModule')
+      expect(meta.window_name).to eq('MyModule')
+    end
+
+    it 'marks as translation when specified' do
+      meta = described_class.new(url, translation: true, import_name: 'module')
+      expect(meta).to be_translation
+    end
+  end
+end
+
+RSpec.describe CKEditor5::Rails::Assets::JSImportMeta do
+  describe '#initialize' do
+    it 'raises error when neither import_name nor window_name is provided' do
+      expect { described_class.new }.to raise_error(ArgumentError)
+    end
+
+    it 'raises error when import_as is present without import_name' do
+      expect { described_class.new(import_as: 'alias', window_name: 'Module') }
+        .to raise_error(ArgumentError)
+    end
+
+    it 'creates valid instance with import_name' do
+      meta = described_class.new(import_name: 'module')
+      expect(meta).to be_esm
+    end
+
+    it 'creates valid instance with window_name' do
+      meta = described_class.new(window_name: 'Module')
+      expect(meta).to be_window
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with only present values' do
+      meta = described_class.new(import_name: 'module', import_as: 'alias')
+      expect(meta.to_h).to eq({
+                                import_name: 'module',
+                                import_as: 'alias'
+                              })
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Cdn::CKBoxBundle do
+  let(:version) { CKEditor5::Rails::Semver.new('2.6.0') }
+  let(:cdn) { :jsdelivr }
+  let(:theme) { :lark }
+  let(:translations) { [] }
+  let(:bundle) { described_class.new(version, theme: theme, cdn: cdn, translations: translations) }
+
+  describe '#initialize' do
+    context 'with valid parameters' do
+      it 'creates bundle successfully' do
+        expect { bundle }.not_to raise_error
+      end
+    end
+
+    context 'with invalid parameters' do
+      it 'raises error for invalid version' do
+        expect { described_class.new('invalid', theme: theme) }
+          .to raise_error(ArgumentError, 'version must be semver')
+      end
+
+      it 'raises error for invalid theme type' do
+        expect { described_class.new(version, theme: 123) }
+          .to raise_error(ArgumentError, 'theme must be a string or symbol')
+      end
+
+      it 'raises error for invalid translations type' do
+        expect { described_class.new(version, theme: theme, translations: 'invalid') }
+          .to raise_error(ArgumentError, 'translations must be an array')
+      end
+    end
+  end
+
+  describe '#scripts' do
+    it 'returns array with main script' do
+      expect(bundle.scripts.first).to be_a(CKEditor5::Rails::Assets::JSExportsMeta)
+      expect(bundle.scripts.first.url).to include('ckbox.js')
+      expect(bundle.scripts.first.window_name).to eq('CKBox')
+    end
+
+    context 'with translations' do
+      let(:translations) { [:pl] }
+
+      it 'includes translation scripts' do
+        translation_script = bundle.scripts.last
+        expect(translation_script.url).to include('translations/pl.js')
+        expect(translation_script.window_name).to eq('CKBOX_TRANSLATIONS')
+        expect(translation_script.translation?).to be true
+      end
+    end
+  end
+
+  describe '#stylesheets' do
+    it 'returns array with theme stylesheet' do
+      expect(bundle.stylesheets.first).to include('styles/themes/lark.css')
+    end
+
+    context 'with custom theme' do
+      let(:theme) { :custom }
+
+      it 'uses custom theme in stylesheet path' do
+        expect(bundle.stylesheets.first).to include('styles/themes/custom.css')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Cdn::CKEditorBundle do
+  let(:version) { CKEditor5::Rails::Semver.new('34.1.0') }
+  let(:import_name) { '@ckeditor/ckeditor5-build-classic' }
+  let(:translations) { %w[pl de] }
+  let(:cdn) { 'https://cdn.example.com' }
+
+  before do
+    allow(CKEditor5::Rails::Engine.default_preset).to receive(:cdn).and_return(cdn)
+    allow_any_instance_of(described_class).to receive(:create_cdn_url) do |_, pkg, ver, file|
+      "#{cdn}/npm/#{pkg}@#{ver}/build/#{file}"
+    end
+  end
+
+  describe '#initialize' do
+    it 'creates instance with valid parameters' do
+      expect do
+        described_class.new(version, import_name, translations: translations)
+      end.not_to raise_error
+    end
+
+    it 'raises error when version is not Semver' do
+      expect do
+        described_class.new('34.1.0', import_name)
+      end.to raise_error(ArgumentError, 'version must be semver')
+    end
+
+    it 'raises error when import_name is not string' do
+      expect do
+        described_class.new(version, :invalid)
+      end.to raise_error(ArgumentError, 'import_name must be a string')
+    end
+
+    it 'raises error when translations is not array' do
+      expect do
+        described_class.new(version, import_name, translations: 'invalid')
+      end.to raise_error(ArgumentError, 'translations must be an array')
+    end
+  end
+
+  describe '#scripts' do
+    subject(:bundle) { described_class.new(version, import_name, translations: translations) }
+
+    it 'returns main script and translation scripts' do
+      expect(bundle.scripts.count).to eq(3)
+      expect(bundle.scripts.first.url).to eq("#{cdn}/npm/#{import_name}@#{version}/build/#{import_name}.js")
+      expect(bundle.scripts.first).not_to be_translation
+    end
+
+    it 'includes translation scripts' do
+      translation_scripts = bundle.scripts.select(&:translation?)
+      expect(translation_scripts.count).to eq(2)
+      expect(translation_scripts.map(&:url)).to contain_exactly(
+        "#{cdn}/npm/#{import_name}@#{version}/build/translations/pl.js",
+        "#{cdn}/npm/#{import_name}@#{version}/build/translations/de.js"
+      )
+    end
+  end
+
+  describe '#stylesheets' do
+    subject(:bundle) { described_class.new(version, import_name) }
+
+    it 'returns stylesheet URL' do
+      expect(bundle.stylesheets).to eq(
+        ["#{cdn}/npm/#{import_name}@#{version}/build/#{import_name}.css"]
+      )
+    end
+  end
+end

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

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Cdn::Helpers do
+  let(:test_class) { Class.new { include CKEditor5::Rails::Cdn::Helpers } }
+  let(:helper) { test_class.new }
+  let(:preset) do
+    instance_double(
+      CKEditor5::Rails::Presets::PresetBuilder,
+      to_h_with_overrides: {
+        cdn: :cloud,
+        version: '34.1.0',
+        type: 'classic',
+        translations: %w[pl],
+        ckbox: nil,
+        license_key: nil,
+        premium: false
+      }
+    )
+  end
+  let(:bundle_html) { '<script src="test.js"></script>' }
+  let(:serializer) do
+    instance_double(CKEditor5::Rails::Assets::AssetsBundleHtmlSerializer, to_html: bundle_html)
+  end
+
+  before do
+    allow(CKEditor5::Rails::Engine).to receive(:find_preset).and_return(preset)
+    allow(CKEditor5::Rails::Assets::AssetsBundleHtmlSerializer).to receive(:new).and_return(serializer)
+  end
+
+  describe '#ckeditor5_assets' do
+    context 'with valid preset' do
+      it 'returns serialized bundle html' do
+        expect(helper.ckeditor5_assets(preset: :default)).to eq(bundle_html)
+      end
+
+      it 'creates base bundle' do
+        expect(CKEditor5::Rails::Cdn::CKEditorBundle).to receive(:new)
+          .with(
+            instance_of(CKEditor5::Rails::Semver),
+            'ckeditor5',
+            translations: %w[pl],
+            cdn: :cloud
+          )
+          .and_call_original
+
+        helper.ckeditor5_assets(preset: :default)
+      end
+
+      context 'with premium features' do
+        let(:preset) do
+          instance_double(
+            CKEditor5::Rails::Presets::PresetBuilder,
+            to_h_with_overrides: {
+              cdn: :cloud,
+              version: '34.1.0',
+              type: 'classic',
+              translations: %w[pl],
+              ckbox: nil,
+              license_key: nil,
+              premium: true
+            }
+          )
+        end
+
+        it 'creates base and premium bundles' do
+          expect(CKEditor5::Rails::Cdn::CKEditorBundle).to receive(:new)
+            .with(
+              instance_of(CKEditor5::Rails::Semver),
+              'ckeditor5',
+              translations: %w[pl],
+              cdn: :cloud
+            )
+            .and_call_original
+            .ordered
+
+          expect(CKEditor5::Rails::Cdn::CKEditorBundle).to receive(:new)
+            .with(
+              instance_of(CKEditor5::Rails::Semver),
+              'ckeditor5-premium-features',
+              translations: %w[pl],
+              cdn: :cloud
+            )
+            .and_call_original
+            .ordered
+
+          helper.ckeditor5_assets(preset: :default)
+        end
+      end
+
+      context 'with ckbox' do
+        let(:preset) do
+          instance_double(
+            CKEditor5::Rails::Presets::PresetBuilder,
+            to_h_with_overrides: {
+              cdn: :cloud,
+              version: '34.1.0',
+              type: 'classic',
+              translations: %w[pl],
+              ckbox: { version: '1.0.0', theme: :lark },
+              license_key: nil,
+              premium: false
+            }
+          )
+        end
+
+        it 'creates ckbox bundle' do
+          expect(CKEditor5::Rails::Cdn::CKBoxBundle).to receive(:new)
+            .with(
+              instance_of(CKEditor5::Rails::Semver),
+              theme: :lark,
+              cdn: :ckbox
+            )
+            .and_call_original
+
+          helper.ckeditor5_assets(preset: :default)
+        end
+      end
+
+      context 'when destructuring preset hash' do
+        let(:preset) do
+          instance_double(
+            CKEditor5::Rails::Presets::PresetBuilder,
+            to_h_with_overrides: {
+              cdn: :cloud,
+              version: '34.1.0',
+              type: 'classic',
+              translations: %w[pl],
+              ckbox: nil,
+              license_key: nil,
+              premium: false,
+              extra: 'value'
+            }
+          )
+        end
+
+        it 'successfully matches and extracts required parameters' do
+          expect { helper.ckeditor5_assets(preset: :default) }.not_to raise_error
+        end
+      end
+    end
+
+    context 'with invalid preset' do
+      before do
+        allow(CKEditor5::Rails::Engine).to receive(:find_preset).and_return(nil)
+      end
+
+      it 'raises error' do
+        expect { helper.ckeditor5_assets(preset: :invalid) }
+          .to raise_error(ArgumentError, /forgot to define your invalid preset/)
+      end
+    end
+
+    context 'with missing required parameters' do
+      let(:preset) do
+        instance_double(
+          CKEditor5::Rails::Presets::PresetBuilder,
+          to_h_with_overrides: { cdn: :cloud }
+        )
+      end
+
+      before do
+        allow(helper).to receive(:merge_with_editor_preset).and_return({})
+      end
+
+      it 'raises error about missing required parameters' do
+        expect { helper.ckeditor5_assets(preset: :default) }
+          .to raise_error(NoMatchingPatternKeyError)
+      end
+    end
+
+    context 'with empty hash from preset' do
+      let(:preset) do
+        instance_double(
+          CKEditor5::Rails::Presets::PresetBuilder,
+          to_h_with_overrides: {}
+        )
+      end
+
+      it 'raises error about missing version and type' do
+        expect { helper.ckeditor5_assets(preset: :default) }
+          .to raise_error(ArgumentError, /forgot to define version/)
+      end
+    end
+  end
+
+  context 'when overriding preset values with kwargs' do
+    let(:preset) do
+      CKEditor5::Rails::Presets::PresetBuilder.new do
+        version '34.1.0'
+        type :classic
+        translations :pl
+        cdn :cloud
+        license_key 'preset-license'
+        premium false
+      end
+    end
+
+    before do
+      allow(CKEditor5::Rails::Engine).to receive(:find_preset).and_return(preset)
+    end
+
+    it 'allows overriding preset values with kwargs' do
+      result = helper.send(:merge_with_editor_preset, :default, license_key: 'overridden-license')
+      expect(result).to include(license_key: 'overridden-license')
+    end
+
+    it 'preserves non-overridden preset values' do
+      result = helper.send(:merge_with_editor_preset, :default, license_key: 'overridden-license')
+      expect(result).to eq(
+        version: '34.1.0',
+        premium: false,
+        cdn: :cloud,
+        translations: [:pl],
+        license_key: 'overridden-license',
+        type: :classic,
+        ckbox: nil,
+        config: { plugins: [], toolbar: [] }
+      )
+    end
+  end
+
+  describe 'cdn helper methods' do
+    it 'generates helper methods for third-party CDNs' do
+      expect(helper).to respond_to(:ckeditor5_unpkg_assets)
+      expect(helper).to respond_to(:ckeditor5_jsdelivr_assets)
+    end
+
+    it 'calls main helper with proper cdn parameter' do
+      expect(helper).to receive(:ckeditor5_assets).with(cdn: :unpkg, version: '34.1.0')
+      helper.ckeditor5_unpkg_assets(version: '34.1.0')
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'action_view'
+
+RSpec.describe CKEditor5::Rails::Context::Helpers do
+  let(:test_class) do
+    Class.new do
+      include ActionView::Helpers::TagHelper
+      include CKEditor5::Rails::Context::Helpers
+    end
+  end
+
+  let(:helper) { test_class.new }
+
+  describe '#ckeditor5_context' do
+    it 'creates context component with default attributes' do
+      expect(helper.ckeditor5_context).to have_tag(
+        'ckeditor-context-component',
+        with: {
+          plugins: '[]',
+          config: '{}'
+        }
+      )
+    end
+
+    it 'creates context component with preset configuration' do
+      expect(helper.ckeditor5_context(preset: :custom)).to have_tag(
+        'ckeditor-context-component',
+        with: {
+          plugins: '[]',
+          config: '{"preset":"custom"}'
+        }
+      )
+    end
+
+    it 'creates context component with cdn configuration' do
+      expect(helper.ckeditor5_context(cdn: :jsdelivr)).to have_tag(
+        'ckeditor-context-component',
+        with: {
+          plugins: '[]',
+          config: '{"cdn":"jsdelivr"}'
+        }
+      )
+    end
+
+    it 'creates context component with multiple configurations' do
+      result = helper.ckeditor5_context(preset: :custom, cdn: :jsdelivr)
+
+      expect(result).to have_tag(
+        'ckeditor-context-component',
+        with: {
+          plugins: '[]',
+          config: '{"preset":"custom","cdn":"jsdelivr"}'
+        }
+      )
+    end
+
+    it 'accepts block content' do
+      result = helper.ckeditor5_context { 'Content' }
+
+      expect(result).to have_tag('ckeditor-context-component') do
+        with_text 'Content'
+      end
+    end
+  end
+end

data/spec/lib/ckeditor5/rails/context/props_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Context::Props do
+  let(:config) do
+    {
+      plugins: [
+        CKEditor5::Rails::Editor::PropsPlugin.new('Plugin1', import_name: '@ckeditor/plugin1'),
+        CKEditor5::Rails::Editor::PropsInlinePlugin.new('plugin2', 'export default class Plugin2 {}')
+      ],
+      toolbar: { items: %w[bold italic] },
+      language: 'en'
+    }
+  end
+
+  subject(:props) { described_class.new(config) }
+
+  describe '#initialize' do
+    it 'accepts a config hash' do
+      expect { described_class.new({}) }.not_to raise_error
+    end
+  end
+
+  describe '#to_attributes' do
+    subject(:attributes) { props.to_attributes }
+
+    it 'returns a hash with plugins and config keys' do
+      expect(attributes).to be_a(Hash)
+      expect(attributes.keys).to match_array(%i[plugins config])
+    end
+
+    describe ':plugins key' do
+      subject(:plugins_json) { attributes[:plugins] }
+
+      it 'serializes plugins array to JSON' do
+        expect(plugins_json).to be_a(String)
+        expect(JSON.parse(plugins_json)).to be_an(Array)
+      end
+
+      it 'normalizes and includes all plugins' do
+        plugins = JSON.parse(plugins_json)
+        expect(plugins.size).to eq(2)
+        expect(plugins.first).to include(
+          'type' => 'external',
+          'import_name' => '@ckeditor/plugin1'
+        )
+        expect(plugins.last).to include(
+          'type' => 'inline',
+          'name' => 'plugin2',
+          'code' => 'export default class Plugin2 {}'
+        )
+      end
+    end
+
+    describe ':config key' do
+      subject(:config_json) { attributes[:config] }
+
+      it 'serializes config to JSON excluding plugins' do
+        expect(config_json).to be_a(String)
+        parsed = JSON.parse(config_json)
+        expect(parsed).to include(
+          'toolbar' => { 'items' => %w[bold italic] },
+          'language' => 'en'
+        )
+        expect(parsed).not_to include('plugins')
+      end
+    end
+  end
+end