konpeito 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53a3bbb24175ed554f9f560c38e6f8138206da3fb6385f87358e9dfa3eed4f10
-  data.tar.gz: 80026dca6352dcb9effa9e7bac8e7ebc58e517ae84cb1f15627935fbb3d5fee4
+  metadata.gz: 85de87c8abf1bbf3ecaf6303ba4fd875f16016099a38734c55c108f123fa4086
+  data.tar.gz: 843f4b6d722d68526d031734c035c9126c520d9869a2488259dbf39ce1eade84
 SHA512:
-  metadata.gz: 4233ae433c5730c64da97806275ca0300d80f77e5af8c338cf2185f54205d69b99091447a097506b5d2944dac437396a8a4e04ae9a97a90df60f8a93d60e730d
-  data.tar.gz: 911c32b9ac29989060b08fe6fc352074a02038ae20f8b516723e56a263bf602b0ee70206cf41a3bbe682044ab4c7511552fa255ef9d7b137da952dcea271f860
+  metadata.gz: eaf22b341a9135b2d81fcda350790330a78f2da9255771833676047086fbcd861919295f8cf7f4967f380cc62c8ea882499cd6b89a863b86bbd1c53e6e6f2b9e
+  data.tar.gz: ab456db3432eca45ff8b658b80c07d38cdbec33c1e4cd6e379d59dbb0cf8f3384b6f715b3bac61f7d120dfb25e479fe86b65dc4c44ad5c7e86ab18703ff6e6a9

data/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to Konpeito will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-02-19
+
+### Added
+- Inliner: keyword argument mapping for correct inlining of functions with keyword params
+- Inliner: ProcNew/BlockDef deep cloning with proper captured variable renaming
+- Vendor setup script (`scripts/setup_vendor.sh`) to download yyjson source files
+
+### Fixed
+- HIR builder: save/restore `@current_block` in NativeHashEach to emit into correct basic block
+- Inliner: ProcCall handler for proc_value and args renaming during inlining
+- JSON stdlib: add tracked `yyjson_wrapper.c` providing non-inline wrappers for LLVM-generated code (fixes SEGV in `parse_as`/`parse_array_as` tests)
+- CRuby backend: reference yyjson wrapper from tracked source location instead of vendor directory
+
+## [0.1.3] - 2026-02-18
+
+### Fixed
+- JVM backend: resolve class method descriptor mismatch when called from instance methods (pre-register singleton method descriptors)
+- Documentation: correct JWM and Skija GitHub URLs in README
+
+### Added
+- Documentation: Castella UI calculator demo with Style composition
+
 ## [0.1.2] - 2026-02-17
 
 ### Fixed
@@ -99,6 +121,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `%a{extern}` - external C struct wrappers
 - `%a{simd}` - SIMD vectorization
 
+[0.2.0]: https://github.com/i2y/konpeito/compare/v0.1.3...v0.2.0
+[0.1.3]: https://github.com/i2y/konpeito/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/i2y/konpeito/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/i2y/konpeito/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/i2y/konpeito/releases/tag/v0.1.0

data/README.md

@@ -135,7 +135,7 @@ The JVM backend supports seamless Java interop — call Java libraries directly
 
 ## Castella UI
 
-A reactive GUI framework for the JVM backend, powered by [JWM](https://github.com/nicenote/jwm) + [Skija](https://github.com/nicenote/skija).
+A reactive GUI framework for the JVM backend, powered by [JWM](https://github.com/HumbleUI/JWM) + [Skija](https://github.com/HumbleUI/Skija).
 
 ### DSL
 
@@ -230,6 +230,144 @@ column(spacing: 12.0) {
 }
 ```
 
+### Calculator Demo
+
+A port of the original Python Castella calculator. Flex layout, button kinds (`KIND_DANGER`, `KIND_WARNING`, `KIND_SUCCESS`), reactive `state()`, and class methods called from instance method callbacks — all in ~130 lines:
+
+<p align="center">
+  <img src="docs/screenshots/calc.png" alt="Calculator" width="320" />
+</p>
+
+```ruby
+class Calc < Component
+  def initialize
+    super
+    @display = state("0")
+    @lhs = 0.0
+    @current_op = ""
+    @is_refresh = true
+  end
+
+  # --- Calculator logic ---
+
+  def press_number(label)
+    if @display.value == "0" || @is_refresh
+      @display.set(label)
+    else
+      @display.set(@display.value + label)
+    end
+    @is_refresh = false
+  end
+
+  def press_dot
+    if @is_refresh
+      @display.set("0.")
+      @is_refresh = false
+      return
+    end
+    if !@display.value.include?(".")
+      @display.set(@display.value + ".")
+    end
+  end
+
+  def all_clear
+    @display.set("0")
+    @lhs = 0.0
+    @current_op = ""
+    @is_refresh = true
+  end
+
+  def self.calc(lhs, op, rhs)
+    if op == "+"
+      lhs + rhs
+    elsif op == "-"
+      lhs - rhs
+    elsif op == "\u00D7"
+      lhs * rhs
+    elsif op == "\u00F7"
+      if rhs == 0.0
+        0.0
+      else
+        lhs / rhs
+      end
+    else
+      rhs
+    end
+  end
+
+  def self.format_result(val)
+    if val == val.to_i.to_f
+      val.to_i.to_s
+    else
+      val.to_s
+    end
+  end
+
+  def press_operator(new_op)
+    rhs = @display.value.to_f
+    if @current_op != ""
+      result = Calc.calc(@lhs, @current_op, rhs)
+      @display.set(Calc.format_result(result))
+      @lhs = result
+    else
+      @lhs = rhs
+    end
+    if new_op == "="
+      @current_op = ""
+    else
+      @current_op = new_op
+    end
+    @is_refresh = true
+  end
+
+  # --- View ---
+
+  def view
+    grid = Style.new.spacing(4.0)
+    btn  = Style.new.font_size(32.0)
+    op   = btn + Style.new.kind(KIND_WARNING)
+    ac   = btn + Style.new.kind(KIND_DANGER).flex(3)
+    eq   = btn + Style.new.kind(KIND_SUCCESS)
+    wide = btn + Style.new.flex(2)
+
+    column(spacing: 4.0, padding: 4.0) {
+      text @display.value, font_size: 48.0, align: :right, kind: KIND_INFO, height: 72.0
+      row(grid) {
+        button("AC", ac) { all_clear }
+        button("\u00F7", op) { press_operator("\u00F7") }
+      }
+      row(grid) {
+        button("7", btn) { press_number("7") }
+        button("8", btn) { press_number("8") }
+        button("9", btn) { press_number("9") }
+        button("\u00D7", op) { press_operator("\u00D7") }
+      }
+      row(grid) {
+        button("4", btn) { press_number("4") }
+        button("5", btn) { press_number("5") }
+        button("6", btn) { press_number("6") }
+        button("-", op) { press_operator("-") }
+      }
+      row(grid) {
+        button("1", btn) { press_number("1") }
+        button("2", btn) { press_number("2") }
+        button("3", btn) { press_number("3") }
+        button("+", op) { press_operator("+") }
+      }
+      row(grid) {
+        button("0", wide) { press_number("0") }
+        button(".", btn) { press_dot }
+        button("=", eq) { press_operator("=") }
+      }
+    }
+  end
+end
+
+frame = JWMFrame.new("Castella Calculator", 320, 480)
+app = App.new(frame, Calc.new)
+app.run
+```
+
 ## Performance
 
 Konpeito shines in compute-heavy, typed loops where unboxed arithmetic and backend optimizations kick in. All benchmarks compare against Ruby 4.0.1 with YJIT enabled on Apple M4 Max.

data/lib/konpeito/codegen/cruby_backend.rb

@@ -893,7 +893,10 @@ module Konpeito
         yyjson_dir = File.expand_path("../../../vendor/yyjson", __dir__)
         yyjson_c = File.join(yyjson_dir, "yyjson.c")
         yyjson_obj = File.join(yyjson_dir, "yyjson.o")
-        wrapper_c = File.join(yyjson_dir, "yyjson_wrapper.c")
+
+        # Wrapper source is tracked in repo alongside JSON stdlib
+        json_stdlib_dir = File.expand_path("../stdlib/json", __dir__)
+        wrapper_c = File.join(json_stdlib_dir, "yyjson_wrapper.c")
         wrapper_obj = File.join(yyjson_dir, "yyjson_wrapper.o")
 
         return [] unless File.exist?(yyjson_c) && File.exist?(wrapper_c)
@@ -906,7 +909,7 @@ module Konpeito
           system(*cmd) or return []
         end
 
-        # Compile wrapper
+        # Compile wrapper (needs yyjson.h from vendor dir)
         unless File.exist?(wrapper_obj) && File.mtime(wrapper_obj) > File.mtime(wrapper_c)
           cmd = [cc, "-c", "-O3", "-fPIC", "-I#{yyjson_dir}", "-o", wrapper_obj, wrapper_c]
           system(*cmd) or return []

data/lib/konpeito/codegen/inliner.rb

@@ -178,6 +178,17 @@ module Konpeito
             param_map[param.name] = call_inst.args[i]
           end
         end
+        # Also map keyword arguments by name
+        if call_inst.respond_to?(:keyword_args) && call_inst.has_keyword_args?
+          call_inst.keyword_args.each do |kw_name, kw_value|
+            # Find the callee param with matching name
+            callee.params.each do |param|
+              if param.name.to_s == kw_name.to_s
+                param_map[param.name] = kw_value
+              end
+            end
+          end
+        end
 
         # Clone and transform instructions from callee
         result_instructions = []
@@ -438,6 +449,17 @@ module Konpeito
           new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
           HIR::SuperCall.new(args: new_args, type: inst.type, result_var: new_result)
 
+        when HIR::ProcNew
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_block_def = clone_block_def(inst.block_def, prefix, param_map)
+          HIR::ProcNew.new(block_def: new_block_def, result_var: new_result)
+
+        when HIR::ProcCall
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_proc = transform_value(inst.proc_value, prefix, param_map)
+          new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
+          HIR::ProcCall.new(proc_value: new_proc, args: new_args, type: inst.type, result_var: new_result)
+
         else
           # For other instructions, just return as-is with renamed result
           inst
@@ -481,6 +503,90 @@ module Konpeito
           value
         end
       end
+
+      # Deep-clone a BlockDef, renaming captured (non-block-local) variables.
+      # Block parameters are NOT renamed (they are local to the closure).
+      def clone_block_def(block_def, prefix, param_map)
+        return block_def unless block_def
+
+        block_param_names = Set.new(block_def.params.map { |p| p.name.to_s })
+
+        new_body = block_def.body.map do |bb|
+          if bb.respond_to?(:instructions)
+            new_bb = HIR::BasicBlock.new(label: bb.label)
+            bb.instructions.each do |bi|
+              new_inst = clone_block_instruction(bi, prefix, param_map, block_param_names)
+              new_bb.add_instruction(new_inst) if new_inst
+            end
+            new_bb.set_terminator(bb.terminator) if bb.terminator
+            new_bb
+          else
+            clone_block_instruction(bb, prefix, param_map, block_param_names)
+          end
+        end
+
+        HIR::BlockDef.new(
+          params: block_def.params,
+          body: new_body,
+          captures: block_def.captures,
+          is_lambda: block_def.is_lambda
+        )
+      end
+
+      # Clone a single instruction inside a block body, renaming captured vars.
+      def clone_block_instruction(inst, prefix, param_map, block_param_names)
+        case inst
+        when HIR::LoadLocal
+          var_name = inst.var.name.to_s
+          if block_param_names.include?(var_name)
+            # Block-local parameter: don't rename
+            inst
+          else
+            # Captured variable: rename with prefix
+            new_var = HIR::LocalVar.new(
+              name: prefix + var_name,
+              type: inst.var.type
+            )
+            HIR::LoadLocal.new(var: new_var, type: inst.type, result_var: inst.result_var)
+          end
+        when HIR::StoreLocal
+          var_name = inst.var.name.to_s
+          new_value = clone_block_value(inst.value, prefix, param_map, block_param_names)
+          if block_param_names.include?(var_name)
+            HIR::StoreLocal.new(var: inst.var, value: new_value, type: inst.type)
+          else
+            new_var = HIR::LocalVar.new(name: prefix + var_name, type: inst.var.type)
+            HIR::StoreLocal.new(var: new_var, value: new_value, type: inst.type)
+          end
+        when HIR::Call
+          new_receiver = clone_block_value(inst.receiver, prefix, param_map, block_param_names)
+          new_args = inst.args.map { |a| clone_block_value(a, prefix, param_map, block_param_names) }
+          HIR::Call.new(
+            receiver: new_receiver, method_name: inst.method_name,
+            args: new_args, block: inst.block,
+            type: inst.type, result_var: inst.result_var
+          )
+        else
+          # Other instructions: return as-is (literals, etc.)
+          inst
+        end
+      end
+
+      # Clone a value reference inside a block, renaming captured variables.
+      def clone_block_value(value, prefix, param_map, block_param_names)
+        case value
+        when HIR::LoadLocal
+          var_name = value.var.name.to_s
+          if block_param_names.include?(var_name)
+            value
+          else
+            new_var = HIR::LocalVar.new(name: prefix + var_name, type: value.var.type)
+            HIR::LoadLocal.new(var: new_var, type: value.type, result_var: nil)
+          end
+        else
+          value
+        end
+      end
     end
   end
 end

data/lib/konpeito/codegen/jvm_generator.rb

@@ -3278,6 +3278,24 @@ module Konpeito
             instructions << { "op" => "invokestatic", "owner" => "java/lang/Boolean",
                               "name" => "valueOf", "descriptor" => "(Z)Ljava/lang/Boolean;" }
             type = :value
+          # Unbox Object to match expected primitive return type (static methods only).
+          # Instance method descriptors are always normalized to Object return, so
+          # unboxing would be incorrect — the value might not be the expected wrapper type.
+          elsif !@generating_instance_method && @current_function_return_type == :double && type == :value
+            instructions << { "op" => "checkcast", "type" => "java/lang/Double" }
+            instructions << { "op" => "invokevirtual", "owner" => "java/lang/Double",
+                              "name" => "doubleValue", "descriptor" => "()D" }
+            type = :double
+          elsif !@generating_instance_method && @current_function_return_type == :i64 && type == :value
+            instructions << { "op" => "checkcast", "type" => "java/lang/Long" }
+            instructions << { "op" => "invokevirtual", "owner" => "java/lang/Long",
+                              "name" => "longValue", "descriptor" => "()J" }
+            type = :i64
+          elsif !@generating_instance_method && @current_function_return_type == :i8 && type == :value
+            instructions << { "op" => "checkcast", "type" => "java/lang/Boolean" }
+            instructions << { "op" => "invokevirtual", "owner" => "java/lang/Boolean",
+                              "name" => "booleanValue", "descriptor" => "()Z" }
+            type = :i8
           end
 
           instructions << case type
@@ -4029,6 +4047,33 @@ module Konpeito
 
           @method_descriptors[key] = "(#{params_desc})#{type_to_descriptor(ret_type)}"
         end
+
+        # Pre-register singleton (class) method descriptors
+        (class_def.singleton_methods || []).each do |method_name|
+          key = "#{class_name}.#{method_name}"
+          next if @method_descriptors.key?(key)
+
+          func = find_class_singleton_method(class_name, method_name.to_s)
+          next unless func
+
+          rbs_param_types = resolve_rbs_param_types(class_name, method_name.to_s, true)
+          params_desc = func.params.each_with_index.map do |p, i|
+            rbs_t = rbs_param_types && i < rbs_param_types.size ? rbs_param_types[i] : nil
+            t = (rbs_t && rbs_t != :value) ? rbs_t : param_type(p)
+            t = :value if t == :void
+            type_to_descriptor(t)
+          end.join
+
+          rbs_ret = resolve_rbs_return_type(class_name, method_name.to_s, true)
+          if rbs_ret && rbs_ret != :value
+            ret_type = rbs_ret
+          else
+            frt = function_return_type(func)
+            ret_type = (frt == :void) ? :value : frt
+          end
+
+          @method_descriptors[key] = "(#{params_desc})#{type_to_descriptor(ret_type)}"
+        end
       end
 
       def resolve_class_fields(class_def)
@@ -4407,9 +4452,17 @@ module Konpeito
         @current_generating_func_name = func.name.to_s
         reset_function_state(func)
 
-        # Pre-determine return type so generate_return knows if method returns Object
-        pre_ret = function_return_type(func)
-        @current_function_return_type = (pre_ret == :void) ? :value : pre_ret
+        # Pre-determine return type so generate_return knows if method returns Object.
+        # If a descriptor was pre-registered (from RBS), use its return type to ensure
+        # the generated return instruction matches the pre-registered descriptor.
+        pre_registered = @method_descriptors["#{class_def.name}.#{func.name}"]
+        if pre_registered
+          pre_ret = parse_descriptor_return_type(pre_registered)
+        else
+          pre_ret = function_return_type(func)
+          pre_ret = :value if pre_ret == :void
+        end
+        @current_function_return_type = pre_ret
 
         # Try to resolve param types from RBS if HIR types are unresolved
         rbs_param_types = resolve_rbs_param_types(class_def.name.to_s, func.name.to_s, true)
@@ -4435,9 +4488,36 @@ module Konpeito
           instructions << default_return(ret_type)
         end
 
-        # Build descriptor from actual param types (which may have been corrected from RBS)
-        params_desc = func.params.map { |p| type_to_descriptor(@variable_types[p.name.to_s] || :value) }.join
-        descriptor = "(#{params_desc})#{type_to_descriptor(ret_type)}"
+        # Build descriptor: if pre-registered, use that descriptor directly for consistency.
+        # The pre-registered descriptor was computed from param_type/RBS before code gen,
+        # matching what the call site will use. The code-gen-derived descriptor may differ
+        # because detect_return_type_from_instructions can miss returns in branching code.
+        if pre_registered
+          descriptor = pre_registered
+          # Ensure final return instruction matches the pre-registered return type
+          pre_ret_type = parse_descriptor_return_type(pre_registered)
+          if pre_ret_type != :void && pre_ret_type != :value
+            # Replace trailing void return with typed default return if needed
+            if instructions.last && instructions.last["op"] == "return"
+              instructions.pop
+              case pre_ret_type
+              when :i64
+                instructions << { "op" => "lconst_0" }
+                instructions << { "op" => "lreturn" }
+              when :double
+                instructions << { "op" => "dconst_0" }
+                instructions << { "op" => "dreturn" }
+              when :i8
+                instructions << { "op" => "iconst_0" }
+                instructions << { "op" => "ireturn" }
+              end
+            end
+          end
+        else
+          # Build descriptor from actual param types (which may have been corrected from RBS)
+          params_desc = func.params.map { |p| type_to_descriptor(@variable_types[p.name.to_s] || :value) }.join
+          descriptor = "(#{params_desc})#{type_to_descriptor(ret_type)}"
+        end
 
         # When renaming for conflict avoidance, use prefixed JVM name
         jvm_name = if rename_prefix
@@ -5396,6 +5476,10 @@ module Konpeito
 
         return [] unless target_func
 
+        # Look up the registered descriptor first to determine expected param types
+        registered = @method_descriptors["#{class_name}.#{method_name}"]
+        registered_param_types = registered ? parse_descriptor_param_types(registered) : nil
+
         # Resolve param types: prefer RBS types over HIR types (which may be unresolved TypeVars)
         rbs_param_types = resolve_rbs_param_types(class_name, method_name, true)
 
@@ -5416,18 +5500,17 @@ module Konpeito
             end
             arg_types << :hash
           elsif i < args.size
-            param_t = param_type(param)
-            # Fallback to RBS type if param type is unresolved
-            if param_t == :value && rbs_param_types && i < rbs_param_types.size && rbs_param_types[i] != :value
-              # RBS resolved what HM couldn't — undo typevar fallback
-              @typevar_fallback_count -= 1 if @typevar_fallback_count > 0
-              param_t = rbs_param_types[i]
-            end
-            # Also try inferring from arg itself
-            if param_t == :value
-              arg_var = extract_var_name(args[i])
-              param_t = arg_var ? (@variable_types[arg_var] || :value) : (infer_type_from_hir(args[i]) || :value)
-            end
+            # Use registered descriptor's param type if available (most accurate)
+            param_t = if registered_param_types && i < registered_param_types.size
+                        registered_param_types[i]
+                      else
+                        pt = param_type(param)
+                        if pt == :value && rbs_param_types && i < rbs_param_types.size && rbs_param_types[i] != :value
+                          rbs_param_types[i]
+                        else
+                          pt
+                        end
+                      end
             instructions.concat(load_value(args[i], param_t))
             arg_types << param_t
           else
@@ -5439,7 +5522,6 @@ module Konpeito
         end
 
         # Build descriptor — prefer registered descriptor for consistency
-        registered = @method_descriptors["#{class_name}.#{method_name}"]
         if registered
           descriptor = registered
           ret_type = parse_descriptor_return_type(registered)

data/lib/konpeito/hir/builder.rb

@@ -4038,13 +4038,15 @@ module Konpeito
         key_var = param_names[0] || "k"
         value_var = param_names[1] || "v"
 
-        # Build block body
+        # Build block body — save/restore @current_block so NativeHashEach
+        # is emitted into the original block, not the loop body block
+        saved_block = @current_block
         body_child = block_child.children.find { |c| c.node_type == :statements }
         block_body = []
 
         if body_child
           # Create a new basic block for the iteration body
-          loop_bb = BasicBlock.new(label: new_label("hash_each_body"))
+          loop_bb = BasicBlock.new(label: "hash_each_body_#{@block_counter}")
           @current_block = loop_bb
           block_body << loop_bb
 
@@ -4052,6 +4054,7 @@ module Konpeito
             visit(stmt)
           end
         end
+        @current_block = saved_block
 
         result_var = new_temp_var
         inst = NativeHashEach.new(

data/lib/konpeito/stdlib/json/yyjson_wrapper.c

@@ -0,0 +1,60 @@
+/*
+ * yyjson_wrapper.c - Non-inline wrappers for yyjson functions
+ *
+ * yyjson uses static inline functions in its header. When linking with
+ * LLVM-generated code, we need non-inline versions that can be called
+ * via external symbol references. This file provides those wrappers.
+ */
+
+#include "yyjson.h"
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+yyjson_doc *konpeito_yyjson_read(const char *dat, size_t len, yyjson_read_flag flg) {
+    return yyjson_read(dat, len, flg);
+}
+
+yyjson_val *konpeito_yyjson_doc_get_root(yyjson_doc *doc) {
+    return yyjson_doc_get_root(doc);
+}
+
+void konpeito_yyjson_doc_free(yyjson_doc *doc) {
+    yyjson_doc_free(doc);
+}
+
+yyjson_val *konpeito_yyjson_obj_get(yyjson_val *obj, const char *key) {
+    return yyjson_obj_get(obj, key);
+}
+
+int64_t konpeito_yyjson_get_sint(yyjson_val *val) {
+    return yyjson_get_sint(val);
+}
+
+uint64_t konpeito_yyjson_get_uint(yyjson_val *val) {
+    return yyjson_get_uint(val);
+}
+
+double konpeito_yyjson_get_real(yyjson_val *val) {
+    return yyjson_get_real(val);
+}
+
+bool konpeito_yyjson_get_bool(yyjson_val *val) {
+    return yyjson_get_bool(val);
+}
+
+const char *konpeito_yyjson_get_str(yyjson_val *val) {
+    return yyjson_get_str(val);
+}
+
+size_t konpeito_yyjson_get_len(yyjson_val *val) {
+    return yyjson_get_len(val);
+}
+
+size_t konpeito_yyjson_arr_size(yyjson_val *arr) {
+    return yyjson_arr_size(arr);
+}
+
+yyjson_val *konpeito_yyjson_arr_get(yyjson_val *arr, size_t idx) {
+    return yyjson_arr_get(arr, idx);
+}

data/lib/konpeito/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Konpeito
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/scripts/setup_vendor.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# Setup vendored dependencies for Konpeito
+#
+# Downloads yyjson (fast JSON library) source files.
+# Run this after cloning the repository:
+#   bash scripts/setup_vendor.sh
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+YYJSON_DIR="$PROJECT_ROOT/vendor/yyjson"
+
+YYJSON_VERSION="0.10.0"
+YYJSON_BASE_URL="https://raw.githubusercontent.com/ibireme/yyjson/${YYJSON_VERSION}/src"
+
+echo "Setting up vendored dependencies..."
+
+# --- yyjson ---
+mkdir -p "$YYJSON_DIR"
+
+if [ -f "$YYJSON_DIR/yyjson.h" ] && [ -f "$YYJSON_DIR/yyjson.c" ]; then
+  echo "  yyjson: already present (skipping download)"
+else
+  echo "  yyjson: downloading v${YYJSON_VERSION}..."
+  curl -sL "${YYJSON_BASE_URL}/yyjson.h" -o "$YYJSON_DIR/yyjson.h"
+  curl -sL "${YYJSON_BASE_URL}/yyjson.c" -o "$YYJSON_DIR/yyjson.c"
+  echo "  yyjson: downloaded yyjson.h and yyjson.c"
+fi
+
+echo ""
+echo "Done. Vendor dependencies are ready."
+echo "  yyjson: $YYJSON_DIR"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: konpeito
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Yasushi Itoh
@@ -131,6 +131,7 @@ files:
 - lib/konpeito/stdlib/json/json.rb
 - lib/konpeito/stdlib/json/json.rbs
 - lib/konpeito/stdlib/json/json_native.c
+- lib/konpeito/stdlib/json/yyjson_wrapper.c
 - lib/konpeito/stdlib/ui/extconf.rb
 - lib/konpeito/stdlib/ui/konpeito_ui_native.cpp
 - lib/konpeito/stdlib/ui/konpeito_ui_native.h
@@ -202,6 +203,7 @@ files:
 - lib/konpeito/ui/widgets/text.rb
 - lib/konpeito/ui/widgets/tree.rb
 - lib/konpeito/version.rb
+- scripts/setup_vendor.sh
 - test_native_array.rb
 - test_native_array_class.rb
 - test_native_class.rb