ckeditor5 1.15.8 → 1.15.9

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,217 @@
+# 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
+
+      it 'raises error when version is missing' 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

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