ckeditor5 1.15.9 → 1.16.0

data/spec/e2e/features/form_integration_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'e2e/spec_helper'
+
+RSpec.describe 'Form Integration', type: :feature, js: true do
+  before do
+    visit('form')
+    setup_form_tracking(page)
+  end
+
+  shared_examples 'a form with CKEditor' do |form_testid, editor_testid, submit_testid| # rubocop:disable Metrics/BlockLength
+    let(:form) { find("[data-testid='#{form_testid}']") }
+    let(:editor) { find("[data-testid='#{editor_testid}']") }
+    let(:editable) { editor.find('.ck-editor__editable') }
+    let(:text_field) { editor.find('textarea', visible: :hidden) }
+    let(:submit_button) { find("[data-testid='#{submit_testid}']") }
+
+    it 'loads editor properly' do
+      expect(page).to have_css("[data-testid='#{editor_testid}'] .ck-editor__editable")
+      expect(editor).to have_invisible_textarea
+    end
+
+    it 'validates required fields' do
+      editable.click
+      editable.send_keys([[:control, 'a'], :backspace])
+
+      text_field.set('')
+      submit_button.click
+
+      expect(form).not_to have_been_submitted
+      expect(text_field).to be_invalid
+    end
+
+    it 'submits with valid data' do
+      editable.click
+      editable.send_keys('New content')
+      text_field.set('Second field value')
+
+      submit_button.click
+
+      eventually do
+        expect(form).to have_been_submitted
+      end
+    end
+  end
+
+  describe 'Rails form' do
+    it_behaves_like 'a form with CKEditor',
+                    'rails-form',
+                    'rails-form-editor',
+                    'rails-form-submit'
+  end
+
+  describe 'Simple form' do
+    it_behaves_like 'a form with CKEditor',
+                    'simple-form',
+                    'simple-form-editor',
+                    'simple-form-submit'
+  end
+end

data/spec/e2e/spec_helper.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'capybara'
+require 'capybara/rspec'
+require 'capybara/cuprite'
+
+ENV['RAILS_ENV'] ||= 'test'
+
+require File.expand_path('../../sandbox/config/environment', __dir__)
+
+require 'capybara/rails'
+
+Capybara.app = Rails.application
+
+Capybara.register_driver(:cuprite) do |app|
+  driver = Capybara::Cuprite::Driver.new(
+    app,
+    window_size: [1200, 800],
+    headless: ENV['HEADLESS'] == 'true',
+    browser_options: {
+      'no-sandbox': nil,
+      'disable-gpu': nil,
+      'enable-logging': nil
+    },
+    process_timeout: 20,
+    timeout: 20,
+    inspector: true
+  )
+
+  process = driver.browser.process
+  puts ''
+  puts "Browser: #{process.browser_version}"
+  puts "Protocol: #{process.protocol_version}"
+  puts "V8: #{process.v8_version}"
+  puts "Webkit: #{process.webkit_version}"
+  driver
+end
+
+Capybara.server = :webrick
+Capybara.default_driver = :cuprite
+Capybara.javascript_driver = :cuprite
+
+Dir[File.expand_path('support/**/*.rb', __dir__)].each { |f| require f }

data/spec/e2e/support/eventually.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Add eventually helper for async operations
+def eventually(timeout: 5, delay: 0.1)
+  deadline = Time.zone.now + timeout
+  loop do
+    yield
+    break
+  rescue RSpec::Expectations::ExpectationNotMetError, StandardError => e
+    raise e if Time.zone.now >= deadline
+
+    sleep delay
+  end
+end

data/spec/e2e/support/form_helpers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module FormHelpers
+  def setup_form_tracking(driver)
+    driver.execute_script <<~JS
+      window.lastSubmittedForm = null;
+
+      document.addEventListener('submit', (e) => {
+        e.preventDefault();
+        window.lastSubmittedForm = e.target.id;
+      });
+    JS
+  end
+end
+
+RSpec.configure do |config|
+  config.include FormHelpers, type: :feature
+end
+
+RSpec::Matchers.define :be_invalid do
+  match do |element|
+    element[:validity] == 'false' ||
+      element.evaluate_script('!this.validity.valid')
+  end
+end
+
+RSpec::Matchers.define :have_been_submitted do
+  match do |form|
+    page.evaluate_script('window.lastSubmittedForm') == form['id']
+  end
+end
+
+RSpec::Matchers.define :have_invisible_textarea do
+  match do |element|
+    element.has_css?('textarea', visible: :hidden)
+  end
+end

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

@@ -86,6 +86,13 @@ RSpec.describe CKEditor5::Rails::Assets::AssetsBundleHtmlSerializer do
     it 'includes web component script' do
       expect(html).to include('<script type="module" nonce="true">')
     end
+
+    it 'memoizes scripts import map' do
+      first_call = serializer.send(:scripts_import_map_tag)
+      second_call = serializer.send(:scripts_import_map_tag)
+
+      expect(first_call.object_id).to eq(second_call.object_id)
+    end
   end
 
   describe '.url_resource_preload_type' do

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

@@ -160,7 +160,25 @@ RSpec.describe CKEditor5::Rails::Cdn::Helpers do
         )
       end
 
-      it 'raises error when version is missing' do
+      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

data/spec/lib/ckeditor5/rails/concerns/checksum_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Concerns::Checksum do
+  let(:dummy_class) do
+    Class.new do
+      include CKEditor5::Rails::Concerns::Checksum
+
+      public :calculate_object_checksum
+    end
+  end
+
+  subject(:instance) { dummy_class.new }
+
+  describe '#calculate_object_checksum' do
+    it 'returns a 16-character string' do
+      result = instance.calculate_object_checksum({ test: 'value' })
+      expect(result).to eq(
+        'f98be16ebfa861cb39a61faff9e52b33f5bcc16bb6ae72e728d226dc07093932'
+      )
+    end
+
+    it 'returns consistent checksums for the same input' do
+      input = { name: 'test', value: 123 }
+      first_result = instance.calculate_object_checksum(input)
+      second_result = instance.calculate_object_checksum(input)
+      expect(first_result).to eq(second_result)
+    end
+
+    it 'returns different checksums for different inputs' do
+      result1 = instance.calculate_object_checksum({ a: 1 })
+      result2 = instance.calculate_object_checksum({ a: 2 })
+      expect(result1).not_to eq(result2)
+    end
+
+    it 'handles arrays' do
+      result = instance.calculate_object_checksum([1, 2, 3])
+      expect(result).to eq(
+        'a615eeaee21de5179de080de8c3052c8da901138406ba71c38c032845f7d54f4'
+      )
+    end
+
+    it 'is order dependent for hashes' do
+      result1 = instance.calculate_object_checksum({ a: 1, b: 2 })
+      result2 = instance.calculate_object_checksum({ b: 2, a: 1 })
+      expect(result1).not_to eq(result2)
+    end
+  end
+end

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

@@ -25,9 +25,15 @@ RSpec.describe CKEditor5::Rails::Context::Props do
   describe '#to_attributes' do
     subject(:attributes) { props.to_attributes }
 
+    it 'returns integrity property' do
+      expect(attributes[:integrity]).to eq(
+        '24e46c3ee19f6764930b38ecdf62c0ac824a0acbe6616b46199d892afb211acb'
+      )
+    end
+
     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])
+      expect(attributes.keys).to match_array(%i[plugins integrity config])
     end
 
     describe ':plugins key' do

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Editor::PropsBasePlugin do
+  let(:concrete_class) do
+    Class.new(described_class) do
+      def to_unsafe_h
+        { type: :test, name: name }
+      end
+    end
+  end
+
+  let(:instance) { concrete_class.new(:TestPlugin) }
+
+  describe '#initialize' do
+    it 'sets the name attribute' do
+      expect(instance.name).to eq(:TestPlugin)
+    end
+  end
+
+  describe '#to_h' do
+    it 'raises NotImplementedError' do
+      expect { instance.to_h }.to raise_error(NotImplementedError)
+    end
+  end
+end

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

@@ -28,11 +28,13 @@ RSpec.describe CKEditor5::Rails::Editor::Props do
 
     it 'includes required attributes' do
       attributes = props.to_attributes
+
       expect(attributes).to include(
         type: 'ClassicEditor',
         translations: String,
         plugins: String,
         config: String,
+        integrity: '358d88b83d041f208d94ac957b2fd68135f1caab5c0d101d33cf04d5d39d81ef',
         watchdog: true
       )
     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

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

@@ -42,6 +42,162 @@ RSpec.describe CKEditor5::Rails::Hooks::Form do
                                               })
         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