ckeditor5 1.15.8 → 1.15.9

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'action_view'
+
+RSpec.describe CKEditor5::Rails::Editor::Helpers::Editor do
+  let(:test_class) do
+    Class.new do
+      include ActionView::Helpers::TagHelper
+      include CKEditor5::Rails::Editor::Helpers::Editor
+    end
+  end
+
+  let(:helper) { test_class.new }
+  let(:preset) { instance_double(CKEditor5::Rails::Presets::PresetBuilder) }
+  let(:context) { { preset: :default, cdn: :jsdelivr } }
+
+  before do
+    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)
+  end
+
+  describe '#ckeditor5_editor' do
+    before do
+      allow(helper).to receive(:find_preset).and_return(preset)
+    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/
+      )
+    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)
+    end
+
+    it 'merges extra configuration with preset config' do
+      extra_config = { toolbar: { items: ['bold'] } }
+      expect(helper).to receive(:build_editor_config)
+        .with(preset, nil, extra_config, nil)
+        .and_return(extra_config)
+
+      helper.ckeditor5_editor(extra_config: extra_config)
+    end
+
+    it 'sets initial data in config when provided' do
+      expect(helper).to receive(:build_editor_config)
+        .with(preset, nil, {}, 'initial content')
+        .and_call_original
+
+      helper.ckeditor5_editor(initial_data: 'initial content')
+    end
+
+    it 'cannot have both initial_data and block content' do
+      expect do
+        helper.ckeditor5_editor(initial_data: 'content') { 'block content' }
+      end.to raise_error(ArgumentError, /Cannot pass initial data and block/)
+    end
+
+    context 'when automatic upgrades are enabled' do
+      before do
+        allow(preset).to receive(:automatic_upgrades?).and_return(true)
+      end
+
+      it 'updates version when detector finds newer safe version' do
+        extra_config = { version: '35.1.0' }
+        allow(CKEditor5::Rails::VersionDetector).to receive(:latest_safe_version)
+          .with('35.1.0')
+          .and_return('35.3.0')
+
+        result = helper.ckeditor5_editor(extra_config: extra_config)
+        expect(result).to include('35.3.0')
+      end
+
+      it 'keeps original version when no safe upgrade is available' do
+        extra_config = { version: '35.1.0' }
+        allow(CKEditor5::Rails::VersionDetector).to receive(:latest_safe_version)
+          .with('35.1.0')
+          .and_return(nil)
+
+        result = helper.ckeditor5_editor(extra_config: extra_config)
+        expect(result).to include('35.1.0')
+      end
+
+      it 'skips version detection when version is not specified' do
+        expect(CKEditor5::Rails::VersionDetector).not_to receive(:latest_safe_version)
+        helper.ckeditor5_editor
+      end
+    end
+
+    context 'when automatic upgrades are disabled' do
+      before do
+        allow(preset).to receive(:automatic_upgrades?).and_return(false)
+      end
+
+      it 'does not modify version even when newer version is available' do
+        extra_config = { version: '35.1.0' }
+        expect(CKEditor5::Rails::VersionDetector).not_to receive(:latest_safe_version)
+
+        result = helper.ckeditor5_editor(extra_config: extra_config)
+        expect(result).to include('35.1.0')
+      end
+    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)
+          .and_return(preset)
+
+        helper.ckeditor5_editor
+      end
+
+      it 'uses preset from context when available' do
+        helper.instance_variable_set(:@__ckeditor_context, { preset: :custom })
+        expect(CKEditor5::Rails::Engine).to receive(:find_preset)
+          .with(:custom)
+          .and_return(preset)
+
+        helper.ckeditor5_editor
+      end
+
+      it 'prefers explicitly passed preset over context preset' do
+        helper.instance_variable_set(:@__ckeditor_context, { preset: :from_context })
+        expect(CKEditor5::Rails::Engine).to receive(:find_preset)
+          .with(:explicit)
+          .and_return(preset)
+
+        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)
+
+        expect { helper.ckeditor5_editor(preset: :unknown) }.to raise_error(
+          described_class::PresetNotFoundError,
+          'Preset unknown is not defined.'
+        )
+      end
+    end
+  end
+
+  describe '#ckeditor5_editable' do
+    it 'creates editable component with name' do
+      expect(helper.ckeditor5_editable('content')).to have_tag(
+        'ckeditor-editable-component',
+        with: { name: 'content' }
+      )
+    end
+  end
+
+  describe '#ckeditor5_ui_part' do
+    it 'creates ui part component with name' do
+      expect(helper.ckeditor5_ui_part('toolbar')).to have_tag(
+        'ckeditor-ui-part-component',
+        with: { name: 'toolbar' }
+      )
+    end
+  end
+
+  describe '#ckeditor5_toolbar' do
+    it 'creates toolbar ui part' do
+      expect(helper.ckeditor5_toolbar).to have_tag(
+        'ckeditor-ui-part-component',
+        with: { name: 'toolbar' }
+      )
+    end
+  end
+
+  describe '#ckeditor5_menubar' do
+    it 'creates menubar ui part' do
+      expect(helper.ckeditor5_menubar).to have_tag(
+        'ckeditor-ui-part-component',
+        with: { name: 'menuBarView' }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Editor::PropsInlinePlugin do
+  let(:valid_code) do
+    <<~JAVASCRIPT
+      import Plugin from '@ckeditor/ckeditor5-core/src/plugin';
+      export default class CustomPlugin extends Plugin {
+        init() {
+          console.log('Custom plugin initialized');
+        }
+      }
+    JAVASCRIPT
+  end
+
+  describe '#initialize' do
+    it 'accepts valid plugin code' do
+      expect { described_class.new(:CustomPlugin, valid_code) }.not_to raise_error
+    end
+
+    it 'raises error when code is not a string' do
+      expect { described_class.new(:CustomPlugin, nil) }
+        .to raise_error(ArgumentError, 'Code must be a String')
+    end
+
+    it 'raises error when code lacks export default' do
+      expect { described_class.new(:CustomPlugin, 'class CustomPlugin {}') }
+        .to raise_error(ArgumentError, /must include `export default`/)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns correct hash representation' do
+      plugin = described_class.new(:CustomPlugin, valid_code)
+      expect(plugin.to_h).to eq({
+                                  type: :inline,
+                                  name: :CustomPlugin,
+                                  code: valid_code
+                                })
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Editor::PropsPlugin do
+  describe '.normalize' do
+    it 'converts string to plugin instance' do
+      plugin = described_class.normalize('Bold')
+      expect(plugin).to be_a(described_class)
+      expect(plugin.name).to eq('Bold')
+    end
+
+    it 'converts symbol to plugin instance' do
+      plugin = described_class.normalize(:Bold)
+      expect(plugin).to be_a(described_class)
+      expect(plugin.name).to eq(:Bold)
+    end
+
+    it 'returns existing plugin instances unchanged' do
+      original = described_class.new(:Bold)
+      plugin = described_class.normalize(original)
+      expect(plugin).to be(original)
+    end
+
+    it 'returns inline plugin instances unchanged' do
+      inline = CKEditor5::Rails::Editor::PropsInlinePlugin.new(:Custom, 'export default class {}')
+      plugin = described_class.normalize(inline)
+      expect(plugin).to be(inline)
+    end
+
+    it 'raises error for invalid input' do
+      expect { described_class.normalize({}) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#to_h' do
+    it 'generates hash for standard plugin' do
+      plugin = described_class.new(:Bold)
+      expect(plugin.to_h).to include(
+        type: :external,
+        import_name: 'ckeditor5',
+        import_as: :Bold
+      )
+    end
+
+    it 'generates hash for premium plugin' do
+      plugin = described_class.new(:Bold, premium: true)
+      expect(plugin.to_h).to include(
+        type: :external,
+        import_name: 'ckeditor5-premium-features',
+        import_as: :Bold
+      )
+    end
+
+    it 'handles custom import metadata' do
+      plugin = described_class.new(:Custom,
+                                   import_name: 'custom-module',
+                                   window_name: 'CustomPlugin')
+      expect(plugin.to_h).to include(
+        type: :external,
+        import_name: 'custom-module',
+        window_name: 'CustomPlugin'
+      )
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Editor::Props do
+  let(:controller_context) do
+    {
+      bundle: double('Bundle', translations_scripts: [{ path: 'translations/en.js' }]),
+      license_key: nil
+    }
+  end
+  let(:type) { :classic }
+  let(:config) { { plugins: [], toolbar: { items: [] } } }
+
+  describe '#initialize' do
+    it 'accepts valid editor type' do
+      expect { described_class.new(controller_context, :classic, {}) }.not_to raise_error
+    end
+
+    it 'raises error for invalid editor type' do
+      expect { described_class.new(controller_context, :invalid, {}) }
+        .to raise_error(ArgumentError, 'Invalid editor type: invalid')
+    end
+  end
+
+  describe '#to_attributes' do
+    subject(:props) { described_class.new(controller_context, type, config) }
+
+    it 'includes required attributes' do
+      attributes = props.to_attributes
+      expect(attributes).to include(
+        type: 'ClassicEditor',
+        translations: String,
+        plugins: String,
+        config: String,
+        watchdog: true
+      )
+    end
+
+    context 'with editable height' do
+      subject(:props) { described_class.new(controller_context, type, config, editable_height: '500px') }
+
+      it 'includes editable-height attribute' do
+        expect(props.to_attributes['editable-height']).to eq('500px')
+      end
+    end
+
+    context 'with license key' do
+      let(:controller_context) do
+        { bundle: double('Bundle', translations_scripts: []), license_key: 'ABC123' }
+      end
+
+      it 'includes license key in config' do
+        config_json = props.to_attributes[:config]
+        expect(config_json).to include('licenseKey')
+        expect(JSON.parse(config_json)['licenseKey']).to eq('ABC123')
+      end
+    end
+  end
+
+  describe '.valid_editor_type?' do
+    it 'returns true for valid types' do
+      %i[classic inline balloon decoupled multiroot].each do |type|
+        expect(described_class.valid_editor_type?(type)).to be true
+      end
+    end
+
+    it 'returns false for invalid types' do
+      expect(described_class.valid_editor_type?(:invalid)).to be false
+    end
+  end
+
+  describe 'editable height validation' do
+    context 'with non-classic editor' do
+      let(:type) { :inline }
+
+      it 'raises error when editable height is set' do
+        expect do
+          described_class.new(controller_context, type, config, editable_height: '500px')
+        end.to raise_error(CKEditor5::Rails::Editor::InvalidEditableHeightError)
+      end
+    end
+
+    context 'with classic editor' do
+      let(:type) { :classic }
+
+      it 'accepts integer values' do
+        props = described_class.new(controller_context, type, config, editable_height: 500)
+        expect(props.to_attributes['editable-height']).to eq('500px')
+      end
+
+      it 'accepts pixel string values' do
+        props = described_class.new(controller_context, type, config, editable_height: '500px')
+        expect(props.to_attributes['editable-height']).to eq('500px')
+      end
+
+      it 'raises error for invalid values' do
+        expect do
+          described_class.new(controller_context, type, config, editable_height: '500em')
+        end.to raise_error(CKEditor5::Rails::Editor::InvalidEditableHeightError)
+      end
+    end
+  end
+end

data/spec/lib/ckeditor5/rails/hooks/form_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Hooks::Form do
+  describe CKEditor5::Rails::Hooks::Form::EditorInputBuilder do
+    let(:post) { Post.new(content: 'Initial content') }
+    let(:builder) { described_class.new(:post, post, template) }
+    let(:template) do
+      ActionView::Base.new(ActionView::LookupContext.new([]), {}, nil)
+    end
+
+    before do
+      template.ckeditor5_assets(version: '34.1.0')
+    end
+
+    describe '#build_editor' do
+      subject(:rendered_editor) { builder.build_editor(:content) }
+
+      it 'renders ckeditor element' do
+        attrs = {
+          name: 'post[content]',
+          id: 'post_content',
+          type: 'ClassicEditor',
+          translations: '[{"import_name":"ckeditor5/translations/en.js"}]',
+          watchdog: 'true'
+        }
+
+        expect(rendered_editor).to have_tag('ckeditor-component', with: attrs)
+      end
+
+      context 'with custom attributes' do
+        subject(:rendered_editor) do
+          builder.build_editor(:content, class: 'custom-class', id: 'custom-id', name: 'custom-name')
+        end
+
+        it 'respects custom HTML attributes' do
+          expect(rendered_editor).to have_tag('ckeditor-component', with: {
+                                                class: 'custom-class',
+                                                id: 'custom-id',
+                                                name: 'custom-name'
+                                              })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Presets::Manager do
+  subject(:manager) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates empty presets hash' do
+      expect(manager.presets).to be_a(Hash)
+    end
+
+    it 'defines default preset' do
+      expect(manager.default).to be_a(CKEditor5::Rails::Presets::PresetBuilder)
+    end
+  end
+
+  describe '#define' do
+    context 'with inheritance' do
+      it 'creates new preset based on default' do
+        manager.define(:custom) do
+          automatic_upgrades enabled: false
+          version '36.0.0'
+        end
+
+        expect(manager[:custom].version).to eq('36.0.0')
+        expect(manager[:custom].type).to eq(manager.default.type)
+      end
+    end
+
+    context 'without inheritance' do
+      it 'creates completely new preset' do
+        manager.define(:custom, inherit: false) do
+          automatic_upgrades enabled: false
+          version '36.0.0'
+        end
+
+        expect(manager[:custom].version).to eq('36.0.0')
+        expect(manager[:custom].config).to eq({ plugins: [], toolbar: [] })
+      end
+    end
+  end
+
+  describe '#override/#extend' do
+    before do
+      manager.define(:custom) do
+        automatic_upgrades enabled: false
+        version '35.0.0'
+        toolbar :bold
+      end
+    end
+
+    it 'modifies existing preset' do
+      manager.override(:custom) do
+        automatic_upgrades enabled: false
+        version '36.0.0'
+        toolbar :italic
+      end
+
+      expect(manager[:custom].version).to eq('36.0.0')
+      expect(manager[:custom].config[:toolbar][:items]).to eq([:italic])
+    end
+
+    it 'allows using extend as alias for override' do
+      manager.extend(:custom) do
+        automatic_upgrades enabled: false
+        version '36.0.0'
+      end
+
+      expect(manager[:custom].version).to eq('36.0.0')
+    end
+  end
+
+  describe '#[]' do
+    it 'returns preset by name' do
+      manager.define(:custom) do
+        automatic_upgrades enabled: false
+        version '36.0.0'
+      end
+
+      expect(manager[:custom]).to be_a(CKEditor5::Rails::Presets::PresetBuilder)
+      expect(manager[:custom].version).to eq('36.0.0')
+    end
+
+    it 'returns nil for non-existent preset' do
+      expect(manager[:non_existent]).to be_nil
+    end
+  end
+
+  describe '#default' do
+    it 'has default configuration' do
+      expect(manager.default.version).to eq(CKEditor5::Rails::DEFAULT_CKEDITOR_VERSION)
+      expect(manager.default.type).to eq(:classic)
+      expect(manager.default.automatic_upgrades?).to be true
+      expect(manager.default.menubar?).to be true
+      expect(manager.default.config[:plugins]).not_to be_empty
+      expect(manager.default.config[:toolbar][:items]).not_to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Presets::PluginsBuilder do
+  let(:plugins) { [] }
+  let(:builder) { described_class.new(plugins) }
+
+  describe '.create_plugin' do
+    context 'when name is a string' do
+      it 'creates a new PropsPlugin' do
+        plugin = described_class.create_plugin('Test')
+        expect(plugin).to be_a(CKEditor5::Rails::Editor::PropsPlugin)
+        expect(plugin.name).to eq('Test')
+      end
+    end
+
+    context 'when name is already a plugin instance' do
+      let(:existing_plugin) { CKEditor5::Rails::Editor::PropsPlugin.new('Test') }
+
+      it 'returns the plugin instance unchanged' do
+        plugin = described_class.create_plugin(existing_plugin)
+        expect(plugin).to eq(existing_plugin)
+      end
+    end
+  end
+
+  describe '#remove' do
+    before do
+      plugins.push(
+        CKEditor5::Rails::Editor::PropsPlugin.new('Plugin1'),
+        CKEditor5::Rails::Editor::PropsPlugin.new('Plugin2'),
+        CKEditor5::Rails::Editor::PropsPlugin.new('Plugin3')
+      )
+    end
+
+    it 'removes specified plugins' do
+      builder.remove('Plugin1', 'Plugin3')
+      expect(plugins.map(&:name)).to eq(['Plugin2'])
+    end
+  end
+
+  describe '#prepend' do
+    let(:existing_plugin) { CKEditor5::Rails::Editor::PropsPlugin.new('ExistingPlugin') }
+
+    before do
+      plugins.push(existing_plugin)
+    end
+
+    context 'without before option' do
+      it 'adds plugins at the beginning' do
+        builder.prepend('NewPlugin1', 'NewPlugin2')
+        expect(plugins.map(&:name)).to eq(%w[NewPlugin1 NewPlugin2 ExistingPlugin])
+      end
+    end
+
+    context 'with before option' do
+      it 'adds plugins before specified plugin' do
+        builder.prepend('NewPlugin', before: 'ExistingPlugin')
+        expect(plugins.map(&:name)).to eq(%w[NewPlugin ExistingPlugin])
+      end
+
+      it 'raises error when target plugin not found' do
+        expect do
+          builder.prepend('NewPlugin', before: 'NonExistent')
+        end.to raise_error(ArgumentError, "Plugin 'NonExistent' not found")
+      end
+    end
+  end
+
+  describe '#append' do
+    let(:existing_plugin) { CKEditor5::Rails::Editor::PropsPlugin.new('ExistingPlugin') }
+
+    before do
+      plugins.push(existing_plugin)
+    end
+
+    context 'without after option' do
+      it 'adds plugins at the end' do
+        builder.append('NewPlugin1', 'NewPlugin2')
+        expect(plugins.map(&:name)).to eq(%w[ExistingPlugin NewPlugin1 NewPlugin2])
+      end
+    end
+
+    context 'with after option' do
+      it 'adds plugins after specified plugin' do
+        builder.append('NewPlugin', after: 'ExistingPlugin')
+        expect(plugins.map(&:name)).to eq(%w[ExistingPlugin NewPlugin])
+      end
+
+      it 'raises error when target plugin not found' do
+        expect do
+          builder.append('NewPlugin', after: 'NonExistent')
+        end.to raise_error(ArgumentError, "Plugin 'NonExistent' not found")
+      end
+    end
+  end
+end