ruby_wasm_ui 0.8.1

data/packages/npm-packages/runtime/spec/ruby_wasm_ui/utils/arrays_spec.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubyWasmUi::Utils::Arrays do
+  describe '.without_nulls' do
+    context 'Basic functionality' do
+      it 'removes nil values from an array containing nils' do
+        arr = [1, nil, 2, nil, 3]
+        result = described_class.without_nulls(arr)
+        expect(result).to eq([1, 2, 3])
+      end
+
+      it 'returns the original array when it contains no nil values' do
+        arr = [1, 2, 3]
+        result = described_class.without_nulls(arr)
+        expect(result).to eq([1, 2, 3])
+      end
+    end
+
+    context 'Edge cases' do
+      it 'returns an empty array when given an empty array' do
+        arr = []
+        result = described_class.without_nulls(arr)
+        expect(result).to eq([])
+      end
+
+      it 'returns an empty array when all elements are nil' do
+        arr = [nil, nil, nil]
+        result = described_class.without_nulls(arr)
+        expect(result).to eq([])
+      end
+
+      it 'preserves falsy values like false, 0, and empty string' do
+        arr = [false, 0, '', nil]
+        result = described_class.without_nulls(arr)
+        expect(result).to eq([false, 0, ''])
+      end
+    end
+  end
+
+  describe '.diff' do
+    context 'Basic functionality' do
+      it 'correctly detects added and removed elements' do
+        old_array = [1, 2, 3]
+        new_array = [2, 3, 4]
+        result = described_class.diff(old_array, new_array)
+        expect(result).to eq({
+          added: [4],
+          removed: [1]
+        })
+      end
+
+      it 'returns empty arrays when comparing identical arrays' do
+        array = [1, 2, 3]
+        result = described_class.diff(array, array)
+        expect(result).to eq({
+          added: [],
+          removed: []
+        })
+      end
+    end
+
+    context 'Edge cases' do
+      it 'works correctly when comparing with an empty array' do
+        old_array = []
+        new_array = [1, 2, 3]
+        result = described_class.diff(old_array, new_array)
+        expect(result).to eq({
+          added: [1, 2, 3],
+          removed: []
+        })
+      end
+
+      it 'handles duplicate elements correctly' do
+        old_array = [1, 1, 2, 2]
+        new_array = [2, 2, 3, 3]
+        result = described_class.diff(old_array, new_array)
+        expect(result).to eq({
+          added: [3],
+          removed: [1]
+        })
+      end
+    end
+  end
+
+  describe '.diff_sequence' do
+    context 'Basic functionality' do
+      it 'returns correct sequence for simple addition' do
+        old_array = [1, 2, 3]
+        new_array = [1, 2, 3, 4]
+        result = described_class.diff_sequence(old_array, new_array)
+        expect(result).to eq([
+          { op: 'noop', original_index: 0, index: 0, item: 1 },
+          { op: 'noop', original_index: 1, index: 1, item: 2 },
+          { op: 'noop', original_index: 2, index: 2, item: 3 },
+          { op: 'add', index: 3, item: 4 }
+        ])
+      end
+
+      it 'returns correct sequence for simple removal' do
+        old_array = [1, 2, 3, 4]
+        new_array = [1, 2, 3]
+        result = described_class.diff_sequence(old_array, new_array)
+        expect(result).to eq([
+          { op: 'noop', original_index: 0, index: 0, item: 1 },
+          { op: 'noop', original_index: 1, index: 1, item: 2 },
+          { op: 'noop', original_index: 2, index: 2, item: 3 },
+          { op: 'remove', index: 3, item: 4 }
+        ])
+      end
+
+      it 'returns correct sequence for reordering' do
+        old_array = [1, 2, 3]
+        new_array = [3, 1, 2]
+        result = described_class.diff_sequence(old_array, new_array)
+        expect(result).to eq([
+          { op: 'move', original_index: 2, from: 2, index: 0, item: 3 },
+          { op: 'noop', original_index: 0, index: 1, item: 1 },
+          { op: 'noop', original_index: 1, index: 2, item: 2 }
+        ])
+      end
+    end
+
+    context 'Complex scenarios' do
+      it 'handles multiple operations in sequence' do
+        old_array = [1, 2, 3, 4]
+        new_array = [5, 2, 1, 6]
+        result = described_class.diff_sequence(old_array, new_array)
+        expect(result).to eq([
+          { op: 'add', index: 0, item: 5 },
+          { op: 'move', original_index: 1, from: 2, index: 1, item: 2 },
+          { op: 'noop', original_index: 0, index: 2, item: 1 },
+          { op: 'remove', index: 3, item: 3 },
+          { op: 'remove', index: 3, item: 4 },
+          { op: 'add', index: 3, item: 6 }
+        ])
+      end
+
+      it 'handles empty arrays' do
+        old_array = []
+        new_array = []
+        result = described_class.diff_sequence(old_array, new_array)
+        expect(result).to eq([])
+      end
+
+      it 'handles complete replacement' do
+        old_array = ['X', 'A', 'A', 'B', 'C']
+        new_array = ['C', 'K', 'A', 'B']
+
+        result = described_class.diff_sequence(old_array, new_array)
+        expect(result).to eq([
+          { op: 'remove', index: 0, item: 'X' },
+          { op: 'move', original_index: 4, from: 3, index: 0, item: 'C' },
+          { op: 'add', index: 1, item: 'K' },
+          { op: 'noop', original_index: 1, index: 2, item: 'A' },
+          { op: 'move', original_index: 3, from: 4, index: 3, item: 'B' },
+          { op: 'remove', index: 4, item: 'A' }
+        ])
+      end
+    end
+
+    context 'Custom equal_proc' do
+      it 'uses custom equal_proc for comparison' do
+        # ハッシュのidフィールドで比較するカスタム比較関数
+        equal_proc = ->(a, b) { a[:id] == b[:id] }
+
+        old_array = [
+          { id: 1, name: 'Alice' },
+          { id: 2, name: 'Bob' },
+          { id: 3, name: 'Charlie' }
+        ]
+        new_array = [
+          { id: 1, name: 'Alice Updated' },  # 名前が変わったが同じid
+          { id: 3, name: 'Charlie' },
+          { id: 2, name: 'Bob' }
+        ]
+
+        result = described_class.diff_sequence(old_array, new_array, equal_proc)
+        expect(result).to eq([
+          { op: 'noop', original_index: 0, index: 0, item: { id: 1, name: 'Alice' } },
+          { op: 'move', original_index: 2, from: 2, index: 1, item: { id: 3, name: 'Charlie' } },
+          { op: 'noop', original_index: 1, index: 2, item: { id: 2, name: 'Bob' } }
+        ])
+      end
+
+      it 'works with case-insensitive string comparison' do
+        equal_proc = ->(a, b) { a.downcase == b.downcase }
+
+        old_array = ['Hello', 'World', 'Test']
+        new_array = ['HELLO', 'test', 'New']
+
+        result = described_class.diff_sequence(old_array, new_array, equal_proc)
+        expect(result).to eq([
+          { op: 'noop', original_index: 0, index: 0, item: 'Hello' },
+          { op: 'remove', index: 1, item: 'World' },
+          { op: 'noop', original_index: 2, index: 1, item: 'Test' },
+          { op: 'add', index: 2, item: 'New' }
+        ])
+      end
+
+      it 'handles numeric comparison with tolerance' do
+        equal_proc = ->(a, b) { (a - b).abs < 0.1 }
+
+        old_array = [1.0, 2.0, 3.0]
+        new_array = [1.05, 3.02, 2.98]  # 許容誤差内で同じとみなされる値
+
+        result = described_class.diff_sequence(old_array, new_array, equal_proc)
+        expect(result).to eq([
+          { op: 'noop', original_index: 0, index: 0, item: 1.0 },
+          { op: 'remove', index: 1, item: 2.0 },
+          { op: 'noop', original_index: 2, index: 1, item: 3.0 },
+          { op: 'add', index: 2, item: 2.98 }
+        ])
+      end
+
+      it 'defaults to standard equality when equal_proc is not provided' do
+        old_array = [1, 2, 3]
+        new_array = [1, 3, 2]
+
+        result_with_default = described_class.diff_sequence(old_array, new_array)
+        result_with_explicit = described_class.diff_sequence(old_array, new_array, ->(a, b) { a == b })
+
+        expect(result_with_default).to eq(result_with_explicit)
+      end
+    end
+  end
+end

data/packages/npm-packages/runtime/spec/ruby_wasm_ui/utils/objects_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubyWasmUi::Utils::Objects do
+  describe '.diff' do
+    context 'Basic diff calculation' do
+      it 'correctly detects added keys' do
+        old_obj = { a: 1, b: 2 }
+        new_obj = { a: 1, b: 2, c: 3 }
+
+        result = described_class.diff(old_obj, new_obj)
+
+        expect(result[:added]).to eq([:c])
+        expect(result[:removed]).to be_empty
+        expect(result[:updated]).to be_empty
+      end
+
+      it 'correctly detects removed keys' do
+        old_obj = { a: 1, b: 2, c: 3 }
+        new_obj = { a: 1, b: 2 }
+
+        result = described_class.diff(old_obj, new_obj)
+
+        expect(result[:added]).to be_empty
+        expect(result[:removed]).to eq([:c])
+        expect(result[:updated]).to be_empty
+      end
+
+      it 'correctly detects updated keys' do
+        old_obj = { a: 1, b: 2, c: 3 }
+        new_obj = { a: 1, b: 3, c: 3 }
+
+        result = described_class.diff(old_obj, new_obj)
+
+        expect(result[:added]).to be_empty
+        expect(result[:removed]).to be_empty
+        expect(result[:updated]).to eq([:b])
+      end
+    end
+
+    context 'Edge cases' do
+      it 'works correctly with empty objects' do
+        old_obj = {}
+        new_obj = { a: 1 }
+
+        result = described_class.diff(old_obj, new_obj)
+
+        expect(result[:added]).to eq([:a])
+        expect(result[:removed]).to be_empty
+        expect(result[:updated]).to be_empty
+      end
+
+      it 'works correctly with completely different objects' do
+        old_obj = { a: 1, b: 2 }
+        new_obj = { c: 3, d: 4 }
+
+        result = described_class.diff(old_obj, new_obj)
+
+        expect(result[:added]).to eq([:c, :d])
+        expect(result[:removed]).to eq([:a, :b])
+        expect(result[:updated]).to be_empty
+      end
+
+      it 'shows no differences when comparing the same object' do
+        obj = { a: 1, b: 2 }
+
+        result = described_class.diff(obj, obj)
+
+        expect(result[:added]).to be_empty
+        expect(result[:removed]).to be_empty
+        expect(result[:updated]).to be_empty
+      end
+    end
+  end
+
+  describe '.has_own_property' do
+    context 'with Hash objects' do
+      let(:hash_obj) { { name: 'test', age: 25, 'city' => 'Tokyo' } }
+
+      it 'returns true when the key exists (symbol)' do
+        expect(described_class.has_own_property(hash_obj, :name)).to be true
+      end
+
+      it 'returns true when the key exists (string)' do
+        expect(described_class.has_own_property(hash_obj, 'city')).to be true
+      end
+
+      it 'returns false when the key does not exist' do
+        expect(described_class.has_own_property(hash_obj, :email)).to be false
+      end
+
+      it 'returns false when the key does not exist (string)' do
+        expect(described_class.has_own_property(hash_obj, 'country')).to be false
+      end
+
+      it 'works correctly with empty hash' do
+        empty_hash = {}
+        expect(described_class.has_own_property(empty_hash, :any_key)).to be false
+      end
+    end
+
+    context 'with custom objects' do
+      let(:custom_object) do
+        obj = Object.new
+        obj.instance_variable_set(:@name, 'test')
+        obj.instance_variable_set(:@age, 25)
+        obj
+      end
+
+      it 'returns true when the instance variable exists' do
+        expect(described_class.has_own_property(custom_object, :name)).to be true
+        expect(described_class.has_own_property(custom_object, 'age')).to be true
+      end
+
+      it 'returns false when the instance variable does not exist' do
+        expect(described_class.has_own_property(custom_object, :email)).to be false
+        expect(described_class.has_own_property(custom_object, 'city')).to be false
+      end
+
+      it 'works correctly with object without instance variables' do
+        empty_object = Object.new
+        expect(described_class.has_own_property(empty_object, :any_property)).to be false
+      end
+    end
+  end
+end

data/packages/npm-packages/runtime/spec/ruby_wasm_ui/utils/props_spec.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubyWasmUi::Utils::Props do
+  describe '.extract_props_and_events' do
+    context 'when vdom has props with events using symbol key' do
+      it 'separates props and events correctly' do
+        click_handler = proc { puts 'clicked' }
+        vdom = RubyWasmUi::Vdom.new(
+          'div',
+          {
+            :on => { :click => click_handler },
+            :class => 'container',
+            :id => 'main'
+          },
+          RubyWasmUi::Vdom::DOM_TYPES[:ELEMENT],
+          [],
+          nil
+        )
+
+        result = described_class.extract_props_and_events(vdom)
+
+        expect(result[:props]).to eq({ :class => 'container', :id => 'main' })
+        expect(result[:events]).to eq({ :click => click_handler })
+      end
+    end
+
+    context 'when vdom has props with events using string key' do
+      it 'separates props and events correctly' do
+        click_handler = proc { puts 'clicked' }
+        vdom = RubyWasmUi::Vdom.new(
+          'div',
+          {
+            "on" => { :click => click_handler },
+            :class => 'container',
+            :id => 'main'
+          },
+          RubyWasmUi::Vdom::DOM_TYPES[:ELEMENT],
+          [],
+          nil
+        )
+
+        result = described_class.extract_props_and_events(vdom)
+
+        expect(result[:props]).to eq({ :class => 'container', :id => 'main' })
+        expect(result[:events]).to eq({ :click => click_handler })
+      end
+    end
+
+    context 'when vdom has props without events' do
+      it 'returns all props as props and empty events' do
+        vdom = RubyWasmUi::Vdom.new(
+          'div',
+          {
+            :class => 'container',
+            :id => 'main',
+            :style => 'color: red'
+          },
+          RubyWasmUi::Vdom::DOM_TYPES[:ELEMENT],
+          [],
+          nil
+        )
+
+        result = described_class.extract_props_and_events(vdom)
+
+        expect(result[:props]).to eq({
+          :class => 'container',
+          :id => 'main',
+          :style => 'color: red'
+        })
+        expect(result[:events]).to eq({})
+      end
+    end
+
+    context 'when vdom has empty props' do
+      it 'returns empty props and events' do
+        vdom = RubyWasmUi::Vdom.new(
+          'div',
+          {},
+          RubyWasmUi::Vdom::DOM_TYPES[:ELEMENT],
+          [],
+          nil
+        )
+
+        result = described_class.extract_props_and_events(vdom)
+
+        expect(result[:props]).to eq({})
+        expect(result[:events]).to eq({})
+      end
+    end
+
+    context 'when vdom.props is nil' do
+      it 'returns empty props and events' do
+        vdom = RubyWasmUi::Vdom.new(
+          'div',
+          nil,
+          RubyWasmUi::Vdom::DOM_TYPES[:ELEMENT],
+          [],
+          nil
+        )
+
+        result = described_class.extract_props_and_events(vdom)
+
+        expect(result[:props]).to eq({})
+        expect(result[:events]).to eq({})
+      end
+    end
+
+    context 'when vdom is nil' do
+      it 'returns empty props and events' do
+        result = described_class.extract_props_and_events(nil)
+
+        expect(result[:props]).to eq({})
+        expect(result[:events]).to eq({})
+      end
+    end
+
+    context 'when vdom has props with both symbol and string keys' do
+      it 'prioritizes symbol key for events' do
+        symbol_click_handler = proc { puts 'symbol click' }
+        string_hover_handler = proc { puts 'string hover' }
+        vdom = RubyWasmUi::Vdom.new(
+          'div',
+          {
+            :on => { :click => symbol_click_handler },
+            "on" => { :hover => string_hover_handler },
+            :class => 'container'
+          },
+          RubyWasmUi::Vdom::DOM_TYPES[:ELEMENT],
+          [],
+          nil
+        )
+
+        result = described_class.extract_props_and_events(vdom)
+
+        expect(result[:props]).to eq({ :class => 'container' })
+        expect(result[:events]).to eq({ :click => symbol_click_handler })
+      end
+    end
+
+    context 'when vdom has props with only on events' do
+      it 'returns only events and empty props' do
+        click_handler = proc { puts 'clicked' }
+        hover_handler = proc { puts 'hovered' }
+        vdom = RubyWasmUi::Vdom.new(
+          'div',
+          {
+            :on => {
+              :click => click_handler,
+              :hover => hover_handler
+            }
+          },
+          RubyWasmUi::Vdom::DOM_TYPES[:ELEMENT],
+          [],
+          nil
+        )
+
+        result = described_class.extract_props_and_events(vdom)
+
+        expect(result[:props]).to eq({})
+        expect(result[:events]).to eq({
+          :click => click_handler,
+          :hover => hover_handler
+        })
+      end
+    end
+
+    context 'when vdom has complex props structure' do
+      it 'correctly separates complex props and events' do
+        click_handler = proc { puts 'clicked' }
+        mouseover_handler = proc { puts 'mouseover' }
+        vdom = RubyWasmUi::Vdom.new(
+          'div',
+          {
+            :on => {
+              :click => click_handler,
+              :mouseover => mouseover_handler
+            },
+            :class => ['container', 'active'],
+            :style => { :color => 'red', :fontSize => '16px' },
+            :data_testid => 'my-component',
+            :aria_label => 'Interactive element'
+          },
+          RubyWasmUi::Vdom::DOM_TYPES[:ELEMENT],
+          [],
+          nil
+        )
+
+        result = described_class.extract_props_and_events(vdom)
+
+        expect(result[:props]).to eq({
+          :class => ['container', 'active'],
+          :style => { :color => 'red', :fontSize => '16px' },
+          :data_testid => 'my-component',
+          :aria_label => 'Interactive element'
+        })
+        expect(result[:events]).to eq({
+          :click => click_handler,
+          :mouseover => mouseover_handler
+        })
+      end
+    end
+  end
+end

data/packages/npm-packages/runtime/spec/ruby_wasm_ui/utils/strings_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubyWasmUi::Utils::Strings do
+  describe '.is_not_empty_string' do
+    context 'Basic functionality' do
+      it 'returns true for non-empty strings' do
+        result = described_class.is_not_empty_string('hello')
+        expect(result).to be true
+      end
+
+      it 'returns false for empty strings' do
+        result = described_class.is_not_empty_string('')
+        expect(result).to be false
+      end
+
+      it 'returns true for strings with only spaces' do
+        result = described_class.is_not_empty_string('   ')
+        expect(result).to be true
+      end
+
+      it 'returns true for strings with special characters' do
+        result = described_class.is_not_empty_string('!@#$%')
+        expect(result).to be true
+      end
+    end
+
+    context 'Edge cases' do
+      it 'returns true for single character strings' do
+        result = described_class.is_not_empty_string('a')
+        expect(result).to be true
+      end
+
+      it 'returns true for strings with newlines' do
+        result = described_class.is_not_empty_string("\n")
+        expect(result).to be true
+      end
+
+      it 'returns true for strings with tabs' do
+        result = described_class.is_not_empty_string("\t")
+        expect(result).to be true
+      end
+    end
+  end
+
+  describe '.is_not_blank_or_empty_string' do
+    context 'Basic functionality' do
+      it 'returns true for non-empty strings' do
+        result = described_class.is_not_blank_or_empty_string('hello')
+        expect(result).to be true
+      end
+
+      it 'returns false for empty strings' do
+        result = described_class.is_not_blank_or_empty_string('')
+        expect(result).to be false
+      end
+
+      it 'returns false for strings with only spaces' do
+        result = described_class.is_not_blank_or_empty_string('   ')
+        expect(result).to be false
+      end
+
+      it 'returns true for strings with content and leading/trailing spaces' do
+        result = described_class.is_not_blank_or_empty_string('  hello  ')
+        expect(result).to be true
+      end
+
+      it 'returns true for strings with special characters' do
+        result = described_class.is_not_blank_or_empty_string('!@#$%')
+        expect(result).to be true
+      end
+    end
+
+    context 'Edge cases' do
+      it 'returns false for strings with only newlines' do
+        result = described_class.is_not_blank_or_empty_string("\n\n")
+        expect(result).to be false
+      end
+
+      it 'returns false for strings with only tabs' do
+        result = described_class.is_not_blank_or_empty_string("\t\t")
+        expect(result).to be false
+      end
+
+      it 'returns false for strings with mixed whitespace characters' do
+        result = described_class.is_not_blank_or_empty_string(" \t\n ")
+        expect(result).to be false
+      end
+
+      it 'returns true for single non-whitespace character' do
+        result = described_class.is_not_blank_or_empty_string('a')
+        expect(result).to be true
+      end
+
+      it 'returns true for strings with content surrounded by mixed whitespace' do
+        result = described_class.is_not_blank_or_empty_string(" \t hello \n ")
+        expect(result).to be true
+      end
+
+      it 'returns true for Unicode whitespace (strip does not remove Unicode whitespace)' do
+        result = described_class.is_not_blank_or_empty_string("\u00A0\u2000\u2001")
+        expect(result).to be true
+      end
+    end
+  end
+end

data/packages/npm-packages/runtime/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+Dir[File.expand_path('../../src/**/*.rb', __FILE__)].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end

data/packages/npm-packages/runtime/src/__tests__/sample.test.js

@@ -0,0 +1,5 @@
+import { expect, test } from "vitest";
+
+test("sample test", () => {
+  expect(1).toBe(1);
+});