ckeditor5 1.15.8 → 1.15.10

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Editor::EditableHeightNormalizer do
+  subject(:normalizer) { described_class.new(editor_type) }
+
+  describe '#normalize' do
+    context 'when editor type is classic' do
+      let(:editor_type) { :classic }
+
+      it 'returns nil when value is nil' do
+        expect(normalizer.normalize(nil)).to be_nil
+      end
+
+      it 'converts integer to pixel string' do
+        expect(normalizer.normalize(500)).to eq('500px')
+      end
+
+      it 'accepts valid pixel string' do
+        expect(normalizer.normalize('300px')).to eq('300px')
+      end
+
+      it 'raises error for invalid string format' do
+        expect { normalizer.normalize('500') }.to raise_error(
+          CKEditor5::Rails::Editor::InvalidEditableHeightError,
+          /editable_height must be an integer representing pixels or string ending with 'px'/
+        )
+      end
+
+      it 'raises error for invalid value type' do
+        expect { normalizer.normalize([]) }.to raise_error(
+          CKEditor5::Rails::Editor::InvalidEditableHeightError,
+          /editable_height must be an integer representing pixels or string ending with 'px'/
+        )
+      end
+    end
+
+    context 'when editor type is not classic' do
+      let(:editor_type) { :inline }
+
+      it 'raises error' do
+        expect { normalizer.normalize(500) }.to raise_error(
+          CKEditor5::Rails::Editor::InvalidEditableHeightError,
+          'editable_height can be used only with ClassicEditor'
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Editor::Helpers::Config do
+  let(:test_class) { Class.new { include CKEditor5::Rails::Editor::Helpers::Config } }
+  let(:helper) { test_class.new }
+
+  describe '#ckeditor5_element_ref' do
+    it 'returns a hash with $element key' do
+      expect(helper.ckeditor5_element_ref('#editor')).to eq({ '$element': '#editor' })
+    end
+
+    it 'accepts any selector string' do
+      expect(helper.ckeditor5_element_ref('.custom-editor')).to eq({ '$element': '.custom-editor' })
+    end
+  end
+
+  describe '#ckeditor5_preset' do
+    let(:preset_builder) { instance_double(CKEditor5::Rails::Presets::PresetBuilder) }
+
+    context 'when name is provided' do
+      before do
+        allow(CKEditor5::Rails::Engine).to receive(:find_preset).with(:default).and_return(preset_builder)
+      end
+
+      it 'returns preset from engine' do
+        expect(helper.ckeditor5_preset(:default)).to eq(preset_builder)
+      end
+    end
+
+    context 'when block is provided' do
+      it 'returns new PresetBuilder instance' do
+        expect(CKEditor5::Rails::Presets::PresetBuilder).to receive(:new)
+        helper.ckeditor5_preset {}
+      end
+
+      it 'yields the block to PresetBuilder' do
+        expect { |b| helper.ckeditor5_preset(&b) }.to yield_control
+      end
+    end
+
+    context 'when neither name nor block is provided' do
+      it 'raises ArgumentError' do
+        expect { helper.ckeditor5_preset }.to raise_error(
+          ArgumentError,
+          'Configuration block is required for preset definition'
+        )
+      end
+    end
+  end
+end

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/engine_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Engine do
+  describe 'configuration' do
+    let(:preset) { instance_double(CKEditor5::Rails::Presets::PresetBuilder) }
+    let(:preset_manager) { instance_double(CKEditor5::Rails::Presets::Manager) }
+
+    before do
+      allow(described_class).to receive(:base).and_return(ActiveSupport::OrderedOptions.new)
+      allow(described_class.base).to receive(:presets).and_return(preset_manager)
+      allow(preset_manager).to receive(:default).and_return(preset)
+    end
+
+    it 'has default configuration' do
+      expect(described_class.base).to be_a(ActiveSupport::OrderedOptions)
+
+      default_preset = described_class.default_preset
+
+      expect(default_preset.type).to eq(:classic)
+      expect(default_preset.toolbar.items).to include(:undo, :redo, :'|', :heading)
+      expect(default_preset.plugins.items.map(&:name)).to include(:Essentials, :Paragraph, :Heading)
+    end
+
+    describe '.configure' do
+      it 'yields configuration proxy' do
+        yielded_config = nil
+        described_class.configure do |config|
+          yielded_config = config
+        end
+        expect(yielded_config).to be_a(described_class::ConfigurationProxy)
+      end
+
+      it 'allows configuring default preset' do
+        described_class.configure do
+          automatic_upgrades enabled: false
+          version '35.0.0'
+          license_key '1234567'
+        end
+
+        expect(described_class.default_preset.version).to eq('35.0.0')
+        expect(described_class.default_preset.license_key).to eq('1234567')
+      end
+    end
+
+    describe '.find_preset' do
+      before do
+        allow(preset_manager).to receive(:[]).with(:custom).and_return(preset)
+        allow(preset_manager).to receive(:[]).with(
+          kind_of(CKEditor5::Rails::Presets::PresetBuilder)
+        ).and_return(preset)
+      end
+
+      it 'returns preset instance if provided' do
+        test_preset = CKEditor5::Rails::Presets::PresetBuilder.new
+        expect(described_class.find_preset(test_preset)).to eq(test_preset)
+      end
+
+      it 'looks up preset by name' do
+        expect(described_class.find_preset(:custom)).to eq(preset)
+      end
+    end
+  end
+
+  describe 'initializers' do
+    describe 'helper initializer' do
+      it 'includes helpers in ActionView and ActionController' do
+        expect(ActionView::Base.included_modules).to include(CKEditor5::Rails::Helpers)
+        expect(ActionController::Base.included_modules).to include(CKEditor5::Rails::Helpers)
+      end
+    end
+
+    describe 'form_builder initializer' do
+      it 'includes FormBuilderExtension in ActionView::Helpers::FormBuilder' do
+        expect(ActionView::Helpers::FormBuilder.included_modules)
+          .to include(CKEditor5::Rails::Hooks::Form::FormBuilderExtension)
+      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)
+      end
+    end
+  end
+end