ckeditor5 1.15.8 → 1.15.9

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

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Presets::PresetBuilder do
+  let(:builder) { described_class.new }
+
+  describe '#initialize' do
+    it 'sets default values' do
+      expect(builder.version).to be_nil
+      expect(builder.premium?).to be false
+      expect(builder.cdn).to eq(:jsdelivr)
+      expect(builder.translations).to eq([:en])
+      expect(builder.license_key).to be_nil
+      expect(builder.type).to eq(:classic)
+      expect(builder.ckbox).to be_nil
+      expect(builder.editable_height).to be_nil
+      expect(builder.config).to eq({ plugins: [], toolbar: [] })
+    end
+
+    it 'accepts a configuration block' do
+      builder = described_class.new do
+        version '35.0.0'
+        premium true
+        translations :en, :pl
+      end
+
+      expect(builder.version).to eq('35.0.0')
+      expect(builder.premium?).to be true
+      expect(builder.translations).to eq(%i[en pl])
+    end
+  end
+
+  describe '#initialize_copy' do
+    let(:original) do
+      described_class.new do
+        version '35.0.0'
+        translations :en, :pl
+        ckbox '1.0.0'
+        toolbar :bold, :italic
+        plugins :Essentials
+      end
+    end
+    let(:copy) { original.dup }
+
+    it 'creates a deep copy' do
+      expect(copy.translations.object_id).not_to eq(original.translations.object_id)
+      expect(copy.ckbox.object_id).not_to eq(original.ckbox.object_id)
+      expect(copy.config[:plugins].object_id).not_to eq(original.config[:plugins].object_id)
+      expect(copy.config[:toolbar].object_id).not_to eq(original.config[:toolbar].object_id)
+    end
+
+    it 'maintains the same values' do
+      expect(copy.version).to eq(original.version)
+      expect(copy.translations).to eq(original.translations)
+      expect(copy.ckbox).to eq(original.ckbox)
+
+      # Compare toolbar separately
+      expect(copy.config[:toolbar][:items]).to eq(original.config[:toolbar][:items])
+      expect(copy.config[:toolbar][:shouldNotGroupWhenFull]).to eq(
+        original.config[:toolbar][:shouldNotGroupWhenFull]
+      )
+
+      # Compare plugin names
+      copy_names = copy.config[:plugins].map { |p| p.name.to_s }
+      original_names = original.config[:plugins].map { |p| p.name.to_s }
+      expect(copy_names).to eq(original_names)
+    end
+  end
+
+  describe 'configuration methods' do
+    describe '#automatic_upgrades' do
+      it 'enables automatic upgrades' do
+        builder.automatic_upgrades
+        expect(builder.automatic_upgrades?).to be true
+      end
+
+      it 'detects latest safe version when enabled' do
+        allow(CKEditor5::Rails::VersionDetector).to receive(:latest_safe_version)
+          .with('35.0.0')
+          .and_return('35.1.0')
+
+        builder.automatic_upgrades
+        builder.version '35.0.0'
+
+        expect(builder.version).to eq('35.1.0')
+      end
+    end
+
+    describe '#license_key' do
+      it 'sets license key and switches to cloud CDN for non-GPL licenses' do
+        builder.license_key('commercial-key')
+        expect(builder.license_key).to eq('commercial-key')
+        expect(builder.cdn).to eq(:cloud)
+      end
+
+      it 'keeps current CDN for GPL license' do
+        builder.cdn(:jsdelivr)
+        builder.license_key('GPL')
+        expect(builder.cdn).to eq(:jsdelivr)
+      end
+    end
+
+    describe '#menubar' do
+      it 'configures menubar visibility' do
+        builder.menubar(visible: true)
+        expect(builder.config[:menuBar]).to eq({ isVisible: true })
+        expect(builder.menubar?).to be true
+      end
+    end
+
+    describe '#toolbar' do
+      it 'configures toolbar items' do
+        builder.toolbar(:bold, :italic, should_group_when_full: false)
+        expect(builder.config[:toolbar]).to eq({
+                                                 items: %i[bold italic],
+                                                 shouldNotGroupWhenFull: true
+                                               })
+      end
+
+      it 'doesn\'t override existing toolbar if no items provided' do
+        original_config = { items: [:bold], shouldNotGroupWhenFull: true }
+        builder.config[:toolbar] = original_config
+        builder.toolbar
+        expect(builder.config[:toolbar]).to eq(original_config)
+      end
+
+      it 'overrides existing toolbar if items provided' do
+        builder.config[:toolbar] = { items: [:bold], shouldNotGroupWhenFull: true }
+        builder.toolbar(:italic)
+        expect(builder.config[:toolbar][:items]).to eq([:italic])
+      end
+
+      it 'accepts a configuration block' do
+        builder.toolbar do
+          append :bold, :italic
+          prepend :undo
+          remove :|
+        end
+        expect(builder.config[:toolbar][:items]).to include(:bold, :italic, :undo)
+      end
+    end
+
+    describe '#plugins' do
+      it 'adds plugins' do
+        builder.plugins(:Essentials, :Paragraph)
+        plugin_names = builder.config[:plugins].map { |p| p.name.to_s }
+        expect(plugin_names).to eq(%w[Essentials Paragraph])
+      end
+
+      it 'accepts a configuration block' do
+        builder.plugins do
+          append :Essentials
+          prepend :Paragraph
+          remove :Base64UploadAdapter
+        end
+        plugin_names = builder.config[:plugins].map { |p| p.name.to_s }
+        expect(plugin_names).to eq(%w[Paragraph Essentials])
+      end
+    end
+
+    describe '#simple_upload_adapter' do
+      it 'configures simple upload adapter' do
+        builder.simple_upload_adapter('/custom/upload')
+        expect(builder.config[:simpleUpload]).to eq({ uploadUrl: '/custom/upload' })
+
+        plugin_names = builder.config[:plugins].map(&:name)
+        expect(plugin_names).to include(:SimpleUploadAdapter)
+      end
+    end
+  end
+
+  describe '#inline_plugin' do
+    let(:plugin_code) do
+      <<~JAVASCRIPT
+        import Plugin from 'ckeditor5/src/plugin';
+        export default class CustomPlugin extends Plugin {
+          init() {
+            // plugin initialization
+          }
+        }
+      JAVASCRIPT
+    end
+
+    it 'adds inline plugin to configuration' do
+      builder.inline_plugin(:CustomPlugin, plugin_code)
+
+      plugin = builder.config[:plugins].first
+      expect(plugin).to be_a(CKEditor5::Rails::Editor::PropsInlinePlugin)
+      expect(plugin.name).to eq(:CustomPlugin)
+      expect(plugin.code).to eq(plugin_code)
+    end
+
+    it 'allows multiple inline plugins' do
+      builder.inline_plugin(:Plugin1, plugin_code)
+      builder.inline_plugin(:Plugin2, plugin_code)
+
+      plugin_names = builder.config[:plugins].map(&:name)
+      expect(plugin_names).to eq(%i[Plugin1 Plugin2])
+    end
+  end
+
+  describe '#cdn' do
+    it 'returns current cdn when called without arguments' do
+      expect(builder.cdn).to eq(:jsdelivr)
+    end
+
+    it 'sets cdn when string/symbol provided' do
+      builder.cdn(:cloud)
+      expect(builder.cdn).to eq(:cloud)
+    end
+
+    context 'with block' do
+      it 'accepts block with correct arity' do
+        cdn_block = ->(bundle, version, path) { "#{bundle}/#{version}/#{path}" }
+        builder.cdn(&cdn_block)
+        expect(builder.cdn).to eq(cdn_block)
+      end
+
+      it 'raises error when block has wrong arity' do
+        expect do
+          builder.cdn { |bundle| bundle }
+        end.to raise_error(ArgumentError, 'Block must accept exactly 3 arguments: bundle, version, path')
+      end
+
+      it 'raises error when block has wrong arity (too many args)' do
+        expect do
+          builder.cdn { |bundle, version, path, extra| bundle } # rubocop:disable Lint/UnusedBlockArgument
+        end.to raise_error(ArgumentError, 'Block must accept exactly 3 arguments: bundle, version, path')
+      end
+    end
+  end
+
+  describe '#type' do
+    it 'returns current type when called without arguments' do
+      expect(builder.type).to eq(:classic)
+    end
+
+    it 'sets type when valid type provided' do
+      allow(CKEditor5::Rails::Editor::Props).to receive(:valid_editor_type?)
+        .with(:inline)
+        .and_return(true)
+
+      builder.type(:inline)
+      expect(builder.type).to eq(:inline)
+    end
+
+    it 'raises error when invalid type provided' do
+      allow(CKEditor5::Rails::Editor::Props).to receive(:valid_editor_type?)
+        .with(:invalid)
+        .and_return(false)
+
+      expect do
+        builder.type(:invalid)
+      end.to raise_error(ArgumentError, 'Invalid editor type: invalid')
+    end
+  end
+
+  describe '#to_h_with_overrides' do
+    let(:builder) do
+      described_class.new do
+        version '35.0.0'
+        premium true
+        translations :en, :pl
+      end
+    end
+
+    it 'returns hash with default values' do
+      result = builder.to_h_with_overrides
+      expect(result).to include(
+        version: '35.0.0',
+        premium: true,
+        translations: %i[en pl]
+      )
+    end
+
+    it 'applies overrides' do
+      result = builder.to_h_with_overrides(
+        version: '36.0.0',
+        premium: false,
+        translations: [:en]
+      )
+      expect(result).to include(
+        version: '36.0.0',
+        premium: false,
+        translations: [:en]
+      )
+    end
+  end
+
+  describe '#language' do
+    it 'returns language config when called without arguments' do
+      builder.language(:pl, content: :en)
+      expect(builder.language).to eq({ ui: :pl, content: :en })
+    end
+
+    it 'sets both UI and content language to same value by default' do
+      builder.language(:pl)
+      expect(builder.config[:language]).to eq({ ui: :pl, content: :pl })
+    end
+
+    it 'allows different UI and content languages' do
+      builder.language(:pl, content: :en)
+      expect(builder.config[:language]).to eq({ ui: :pl, content: :en })
+    end
+  end
+
+  describe '#deep_copy_toolbar' do
+    context 'with array toolbar' do
+      it 'returns duplicated array' do
+        original = %i[bold italic]
+        copy = builder.send(:deep_copy_toolbar, original)
+        expect(copy.object_id).not_to eq(original.object_id)
+        expect(copy).to eq(original)
+      end
+    end
+
+    context 'with hash toolbar' do
+      it 'returns deep copy of toolbar config' do
+        original = {
+          items: %i[bold italic],
+          shouldNotGroupWhenFull: true
+        }
+        copy = builder.send(:deep_copy_toolbar, original)
+
+        expect(copy[:items].object_id).not_to eq(original[:items].object_id)
+        expect(copy).to eq(original)
+      end
+    end
+
+    context 'with nil toolbar' do
+      it 'returns empty hash' do
+        expect(builder.send(:deep_copy_toolbar, nil)).to eq({})
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::Presets::ToolbarBuilder do
+  let(:items) { %i[bold italic | link] }
+  let(:builder) { described_class.new(items) }
+
+  describe '#initialize' do
+    it 'creates a builder with given items' do
+      expect(builder.items).to eq(%i[bold italic | link])
+    end
+  end
+
+  describe '#remove' do
+    it 'removes specified items' do
+      builder.remove(:italic, :|)
+      expect(builder.items).to eq(%i[bold link])
+    end
+
+    it 'ignores non-existent items' do
+      builder.remove(:nonexistent)
+      expect(builder.items).to eq(%i[bold italic | link])
+    end
+  end
+
+  describe '#prepend' do
+    context 'without before option' do
+      it 'adds items at the beginning' do
+        builder.prepend(:underline, :strike)
+        expect(builder.items).to eq(%i[underline strike bold italic | link])
+      end
+    end
+
+    context 'with before option' do
+      it 'adds items before specified item' do
+        builder.prepend(:underline, before: :italic)
+        expect(builder.items).to eq(%i[bold underline italic | link])
+      end
+
+      it 'raises error when target item not found' do
+        expect do
+          builder.prepend(:underline, before: :nonexistent)
+        end.to raise_error(ArgumentError, "Item 'nonexistent' not found in array")
+      end
+    end
+  end
+
+  describe '#append' do
+    context 'without after option' do
+      it 'adds items at the end' do
+        builder.append(:underline, :strike)
+        expect(builder.items).to eq(%i[bold italic | link underline strike])
+      end
+    end
+
+    context 'with after option' do
+      it 'adds items after specified item' do
+        builder.append(:underline, after: :italic)
+        expect(builder.items).to eq(%i[bold italic underline | link])
+      end
+
+      it 'raises error when target item not found' do
+        expect do
+          builder.append(:underline, after: :nonexistent)
+        end.to raise_error(ArgumentError, "Item 'nonexistent' not found in array")
+      end
+    end
+  end
+end

data/spec/lib/ckeditor5/rails/semver_spec.rb

@@ -42,4 +42,62 @@ RSpec.describe CKEditor5::Rails::Semver do
       expect(semver.version).to eq(version)
     end
   end
+
+  describe '#<=>' do
+    let(:version1) { described_class.new('1.2.3') }
+
+    it 'compares versions correctly' do
+      expect(version1).to be < described_class.new('1.2.4')
+      expect(version1).to be < described_class.new('1.3.0')
+      expect(version1).to be < described_class.new('2.0.0')
+      expect(version1).to be > described_class.new('1.2.2')
+      expect(version1).to be > described_class.new('1.1.9')
+      expect(version1).to be > described_class.new('0.9.9')
+      expect(version1).to eq described_class.new('1.2.3')
+    end
+
+    it 'returns nil when comparing with non-Semver object' do
+      expect(version1 <=> 'not a version').to be_nil
+    end
+  end
+
+  describe '#safe_update?' do
+    let(:base_version) { described_class.new('1.2.3') }
+
+    context 'when major version changes' do
+      it 'returns false for major version increase' do
+        expect(base_version.safe_update?('2.0.0')).to be false
+      end
+
+      it 'returns false for major version decrease' do
+        expect(base_version.safe_update?('0.2.3')).to be false
+      end
+    end
+
+    context 'when minor version changes' do
+      it 'returns true for minor version increase' do
+        expect(base_version.safe_update?('1.3.0')).to be true
+      end
+
+      it 'returns false for minor version decrease' do
+        expect(base_version.safe_update?('1.1.9')).to be false
+      end
+    end
+
+    context 'when patch version changes' do
+      it 'returns true for patch version increase' do
+        expect(base_version.safe_update?('1.2.4')).to be true
+      end
+
+      it 'returns false for patch version decrease' do
+        expect(base_version.safe_update?('1.2.2')).to be false
+      end
+    end
+
+    context 'when version is the same' do
+      it 'returns false for identical version' do
+        expect(base_version.safe_update?('1.2.3')).to be false
+      end
+    end
+  end
 end

data/spec/lib/ckeditor5/rails/version_detector_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails::VersionDetector do
+  let(:current_version) { '35.1.0' }
+
+  let(:npm_response) do
+    {
+      'versions' => {
+        '34.0.0' => {},
+        '34.1.0' => {},
+        '35.0.0' => {},
+        '35.1.0' => {},
+        '35.2.0' => {},
+        '36.0.0' => {},
+        '35.2.1-dev' => {},
+        '36.0.0-nightly' => {}
+      }
+    }.to_json
+  end
+
+  let(:success_response) do
+    double('Net::HTTPSuccess',
+           body: npm_response,
+           is_a?: true)
+  end
+
+  before do
+    described_class.instance.clear_cache!
+
+    allow(Net::HTTP).to receive(:new).and_return(
+      double('Net::HTTP').tap do |http|
+        allow(http).to receive(:use_ssl=)
+        allow(http).to receive(:open_timeout=)
+        allow(http).to receive(:read_timeout=)
+        allow(http).to receive(:get).and_return(success_response)
+      end
+    )
+  end
+
+  describe '.latest_safe_version' do
+    before do
+      described_class.instance.clear_cache!
+      setup_http_mock(success_response)
+    end
+
+    it 'returns the latest safe version' do
+      expect(described_class.latest_safe_version(current_version)).to eq('35.2.0')
+    end
+
+    it 'caches the result' do
+      first_call = described_class.latest_safe_version(current_version)
+
+      # Simulate different NPM response
+      allow(success_response).to receive(:body).and_return(
+        { 'versions' => { '35.3.0' => {} } }.to_json
+      )
+
+      second_call = described_class.latest_safe_version(current_version)
+
+      expect(first_call).to eq(second_call)
+    end
+  end
+
+  describe 'error handling' do
+    before do
+      described_class.instance.clear_cache!
+    end
+
+    context 'when HTTP request fails' do
+      before do
+        allow(Net::HTTP).to receive(:new).and_raise(StandardError.new('Connection failed'))
+        allow_any_instance_of(Kernel).to receive(:warn)
+      end
+
+      it 'returns nil and logs warning' do
+        expect_any_instance_of(Kernel).to receive(:warn).with('Error fetching versions: Connection failed')
+        expect(described_class.latest_safe_version(current_version)).to be_nil
+      end
+    end
+
+    context 'when response is not successful' do
+      let(:error_response) do
+        double('Net::HTTPNotFound',
+               is_a?: false)
+      end
+
+      before do
+        setup_http_mock(error_response)
+        allow_any_instance_of(Kernel).to receive(:warn)
+      end
+
+      it 'returns nil and logs warning' do
+        expect_any_instance_of(Kernel).to receive(:warn).with('Failed to fetch CKEditor versions')
+        expect(described_class.latest_safe_version(current_version)).to be_nil
+      end
+    end
+  end
+
+  describe 'version filtering' do
+    before do
+      described_class.instance.clear_cache!
+      setup_http_mock(success_response)
+    end
+
+    it 'ignores nightly and dev versions' do
+      latest = described_class.latest_safe_version(current_version)
+      expect(latest).not_to include('nightly')
+      expect(latest).not_to include('dev')
+    end
+
+    it 'only returns versions safe to update to' do
+      expect(described_class.latest_safe_version('35.0.0')).to eq('35.2.0')
+      expect(described_class.latest_safe_version('34.0.0')).to eq('34.1.0')
+    end
+  end
+
+  private
+
+  def setup_http_mock(response) # rubocop:disable Metrics/AbcSize
+    allow(Net::HTTP).to receive(:new).and_return(
+      double('Net::HTTP').tap do |http|
+        allow(http).to receive(:use_ssl=)
+        allow(http).to receive(:open_timeout=)
+        allow(http).to receive(:read_timeout=)
+        allow(http).to receive(:get).and_return(response)
+      end
+    )
+  end
+end

data/spec/lib/ckeditor5/rails/version_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CKEditor5::Rails do
+  describe 'VERSION' do
+    it 'is defined as a string' do
+      expect(described_class::VERSION).to be_a(String)
+    end
+
+    it 'follows semantic versioning format' do
+      expect(described_class::VERSION).to match(/^\d+\.\d+\.\d+$/)
+    end
+  end
+
+  describe 'DEFAULT_CKEDITOR_VERSION' do
+    it 'is defined as a string' do
+      expect(described_class::DEFAULT_CKEDITOR_VERSION).to be_a(String)
+    end
+
+    it 'follows semantic versioning format' do
+      expect(described_class::DEFAULT_CKEDITOR_VERSION).to match(/^\d+\.\d+\.\d+$/)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -8,12 +8,13 @@ SimpleCov.start do
   enable_coverage :line
 
   add_filter 'sandbox/'
+  add_filter 'spec/'
+  add_filter 'lib/ckeditor5/rails/version.rb' # Fix bug in coverage calculation
   add_group 'Library', 'lib/'
 
   track_files 'lib/**/*.rb'
 
-  # minimum_coverage 90
-  # minimum_coverage_by_file 80
+  minimum_coverage 98
 
   formatters = [
     SimpleCov::Formatter::HTMLFormatter,
@@ -31,6 +32,9 @@ require 'pry'
 require 'spec_helper'
 require 'rspec/rails'
 require 'rspec/expectations'
+require 'rspec-html-matchers'
+
+Dir[File.expand_path('support/**/*.rb', __dir__)].each { |f| require f }
 
 Rails.application.initialize!
 
@@ -57,4 +61,6 @@ RSpec.configure do |config|
   config.before(:each) do
     Rails.application.load_seed
   end
+
+  config.include RSpecHtmlMatchers
 end

data/spec/support/test_models.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Post
+  include ActiveModel::Model
+  attr_accessor :content
+end