ckeditor5 1.15.8 → 1.15.10

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

@@ -0,0 +1,203 @@
+# 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
+
+      context 'with as parameter' do
+        subject(:rendered_editor) do
+          builder.build_editor(:content, as: 'custom_field')
+        end
+
+        it 'uses custom field name' do
+          expect(rendered_editor).to have_tag('ckeditor-component', with: {
+                                                name: 'post[custom_field]'
+                                              })
+        end
+      end
+
+      context 'without object_name' do
+        let(:builder) { described_class.new('', post, template) }
+
+        it 'uses method name as field name' do
+          expect(rendered_editor).to have_tag('ckeditor-component', with: {
+                                                name: 'content'
+                                              })
+        end
+
+        context 'with as parameter' do
+          subject(:rendered_editor) do
+            builder.build_editor(:content, as: 'custom_field')
+          end
+
+          it 'uses as parameter as field name' do
+            expect(rendered_editor).to have_tag('ckeditor-component', with: {
+                                                  name: 'custom_field'
+                                                })
+          end
+        end
+      end
+
+      context 'with initial data handling' do
+        before do
+          allow(template).to receive(:ckeditor5_editor)
+        end
+
+        context 'when object responds to the method' do
+          it 'passes object method value as initial_data' do
+            builder.build_editor(:content)
+
+            expect(template).to have_received(:ckeditor5_editor)
+              .with(hash_including(initial_data: 'Initial content'))
+          end
+        end
+
+        context 'when object does not respond to the method' do
+          let(:post) { double('Post') }
+
+          it 'passes options initial_data value' do
+            builder.build_editor(:content, initial_data: 'Provided content')
+
+            expect(template).to have_received(:ckeditor5_editor)
+              .with(hash_including(initial_data: 'Provided content'))
+          end
+        end
+      end
+
+      context 'with validation classes handling' do
+        before do
+          allow(template).to receive(:ckeditor5_editor)
+        end
+
+        context 'when object has errors on the field' do
+          let(:post) do
+            instance_double('Post', errors: { content: ['is invalid'] })
+          end
+
+          it 'adds is-invalid class' do
+            builder.build_editor(:content, class: 'custom-class')
+
+            expect(template).to have_received(:ckeditor5_editor)
+              .with(hash_including(class: 'custom-class is-invalid'))
+          end
+
+          it 'adds is-invalid class when no initial class exists' do
+            builder.build_editor(:content)
+
+            expect(template).to have_received(:ckeditor5_editor)
+              .with(hash_including(class: 'is-invalid'))
+          end
+        end
+
+        context 'when object has no errors' do
+          let(:post) do
+            instance_double('Post', errors: {})
+          end
+
+          it 'keeps original class unchanged' do
+            builder.build_editor(:content, class: 'custom-class')
+
+            expect(template).to have_received(:ckeditor5_editor)
+              .with(hash_including(class: 'custom-class'))
+          end
+        end
+
+        context 'when object does not respond to errors' do
+          let(:post) { double('Post') }
+
+          it 'keeps original class unchanged' do
+            builder.build_editor(:content, class: 'custom-class')
+
+            expect(template).to have_received(:ckeditor5_editor)
+              .with(hash_including(class: 'custom-class'))
+          end
+        end
+      end
+    end
+  end
+
+  describe CKEditor5::Rails::Hooks::Form::FormBuilderExtension do
+    let(:template) { instance_double('ActionView::Base') }
+    let(:object) { double('Post') }
+    let(:builder) do
+      Class.new do
+        include CKEditor5::Rails::Hooks::Form::FormBuilderExtension
+        attr_reader :object_name, :object, :template
+
+        def initialize(object_name, object, template)
+          @object_name = object_name
+          @object = object
+          @template = template
+        end
+      end.new('post', object, template)
+    end
+
+    describe '#ckeditor5' do
+      let(:input_builder) { instance_double(CKEditor5::Rails::Hooks::Form::EditorInputBuilder) }
+
+      before do
+        allow(CKEditor5::Rails::Hooks::Form::EditorInputBuilder)
+          .to receive(:new)
+          .with('post', object, template)
+          .and_return(input_builder)
+        allow(input_builder).to receive(:build_editor)
+      end
+
+      it 'creates EditorInputBuilder with correct parameters' do
+        builder.ckeditor5(:content, class: 'custom-class')
+
+        expect(CKEditor5::Rails::Hooks::Form::EditorInputBuilder)
+          .to have_received(:new)
+          .with('post', object, template)
+      end
+
+      it 'calls build_editor with correct parameters' do
+        options = { class: 'custom-class' }
+        builder.ckeditor5(:content, options)
+
+        expect(input_builder)
+          .to have_received(:build_editor)
+          .with(:content, options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Hooks::SimpleForm::CKEditor5Input do
+  let(:template) { instance_double('ActionView::Base') }
+  let(:object) { double('Post', content: 'Initial content') }
+  let(:object_name) { 'post' }
+  let(:builder) do
+    double('FormBuilder',
+           object: object,
+           object_name: object_name,
+           template: template)
+  end
+  let(:attribute_name) { :content }
+  let(:input_html_options) { {} }
+  let(:input_options) { {} }
+
+  subject(:input) do
+    described_class.new(builder, attribute_name, nil, input_html_options, input_options)
+  end
+
+  before do
+    allow(template).to receive(:ckeditor5_editor)
+  end
+
+  describe '#input' do
+    it 'renders ckeditor with default options' do
+      input.input
+
+      expect(template).to have_received(:ckeditor5_editor).with(
+        hash_including(
+          preset: :default,
+          type: :classic,
+          config: nil,
+          initial_data: 'Initial content',
+          name: 'post[content]',
+          class: [{}, :required] # Simple Form adds these classes by default
+        )
+      )
+    end
+
+    context 'with custom options' do
+      let(:input_options) do
+        {
+          preset: :custom_preset,
+          type: :inline,
+          config: { toolbar: [:bold] }
+        }
+      end
+      let(:input_html_options) do
+        { class: 'custom-class', id: 'custom-id' }
+      end
+
+      it 'renders ckeditor with merged options' do
+        input.input
+
+        expect(template).to have_received(:ckeditor5_editor).with(
+          hash_including(
+            preset: :custom_preset,
+            type: :inline,
+            config: { toolbar: [:bold] },
+            initial_data: 'Initial content',
+            name: 'post[content]',
+            class: [{ class: 'custom-class', id: 'custom-id' }, :required]
+          )
+        )
+      end
+    end
+
+    context 'when object does not respond to attribute' do
+      let(:object) { double('Post') }
+      let(:input_options) { { initial_data: 'Provided content' } }
+
+      it 'uses initial_data from options' do
+        input.input
+
+        expect(template).to have_received(:ckeditor5_editor).with(
+          hash_including(initial_data: 'Provided content')
+        )
+      end
+    end
+
+    context 'with wrapper options' do
+      let(:wrapper_options) { { wrapper_class: 'wrapper' } }
+      let(:input_html_options) { { class: 'input' } }
+
+      it 'merges wrapper options with input options' do
+        input.input(wrapper_options)
+
+        expect(template).to have_received(:ckeditor5_editor).with(
+          hash_including(
+            class: [{ class: 'input' }, :required],
+            wrapper_class: 'wrapper'
+          )
+        )
+      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(:items) { [] }
+  let(:builder) { described_class.new(items) }
+
+  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
+      items.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(items.map(&:name)).to eq(['Plugin2'])
+    end
+  end
+
+  describe '#prepend' do
+    let(:existing_plugin) { CKEditor5::Rails::Editor::PropsPlugin.new('ExistingPlugin') }
+
+    before do
+      items.push(existing_plugin)
+    end
+
+    context 'without before option' do
+      it 'adds plugins at the beginning' do
+        builder.prepend('NewPlugin1', 'NewPlugin2')
+        expect(items.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(items.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
+      items.push(existing_plugin)
+    end
+
+    context 'without after option' do
+      it 'adds plugins at the end' do
+        builder.append('NewPlugin1', 'NewPlugin2')
+        expect(items.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(items.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