rubyduino 0.1.1

data/vendor/spinel/test/redo.rb

@@ -0,0 +1,263 @@
+# RedoNode coverage — `redo` re-runs the current iteration of the
+# enclosing loop without re-evaluating the guard or advancing the
+# iterator. Spinel emits a labeled goto back to the iteration top.
+# Each loop form needs the wrapping helper trio (push_redo_label /
+# emit_redo_label / pop_redo_label) so this file exercises every
+# form that has it.
+#
+# Per-section `def t_<form>; ...; end; t_<form>` isolates the
+# `attempts` / `i` / `x` locals. Was 17 separate tests covering
+# each loop form individually plus a nested case.
+
+# === times ===
+def t_times
+  attempts = 0
+  3.times do |i|
+    attempts += 1
+    if i == 1 && attempts < 5
+      redo
+    end
+    puts "i=#{i} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_times
+
+# === Array#each ===
+def t_each
+  attempts = 0
+  [10, 20, 30].each do |x|
+    attempts += 1
+    if x == 20 && attempts < 5
+      redo
+    end
+    puts "x=#{x} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_each
+
+# === while ===
+def t_while
+  i = 0
+  attempts = 0
+  while i < 3
+    attempts += 1
+    if i == 1 && attempts < 5
+      redo
+    end
+    puts "i=#{i} attempt=#{attempts}"
+    i += 1
+  end
+  puts "total=#{attempts}"
+end
+t_while
+
+# === until ===
+def t_until
+  i = 0
+  attempts = 0
+  until i >= 3
+    attempts += 1
+    if i == 1 && attempts < 5
+      redo
+    end
+    puts "i=#{i} attempt=#{attempts}"
+    i += 1
+  end
+  puts "total=#{attempts}"
+end
+t_until
+
+# === for-in over range ===
+def t_for_range
+  attempts = 0
+  for i in 0..2
+    attempts += 1
+    if i == 1 && attempts < 5
+      redo
+    end
+    puts "i=#{i} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_for_range
+
+# === for-in over array ===
+def t_for_array
+  attempts = 0
+  for x in [10, 20, 30]
+    attempts += 1
+    if x == 20 && attempts < 5
+      redo
+    end
+    puts "x=#{x} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_for_array
+
+# === Kernel#loop (uses break to terminate) ===
+def t_loop
+  i = 0
+  attempts = 0
+  loop do
+    attempts += 1
+    if i == 1 && attempts < 5
+      redo
+    end
+    puts "i=#{i} attempt=#{attempts}"
+    i += 1
+    break if i >= 3
+  end
+  puts "total=#{attempts}"
+end
+t_loop
+
+# === Integer#upto ===
+def t_upto
+  attempts = 0
+  0.upto(2) do |i|
+    attempts += 1
+    if i == 1 && attempts < 5
+      redo
+    end
+    puts "i=#{i} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_upto
+
+# === Integer#downto ===
+def t_downto
+  attempts = 0
+  2.downto(0) do |i|
+    attempts += 1
+    if i == 1 && attempts < 5
+      redo
+    end
+    puts "i=#{i} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_downto
+
+# === Integer#step ===
+def t_step
+  attempts = 0
+  0.step(4, 2) do |i|
+    attempts += 1
+    if i == 2 && attempts < 5
+      redo
+    end
+    puts "i=#{i} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_step
+
+# === Array#each_with_index ===
+def t_each_with_index
+  attempts = 0
+  ["a", "b", "c"].each_with_index do |x, i|
+    attempts += 1
+    if i == 1 && attempts < 5
+      redo
+    end
+    puts "x=#{x} i=#{i} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_each_with_index
+
+# === Array#each_cons ===
+def t_each_cons
+  attempts = 0
+  [1, 2, 3, 4].each_cons(2) do |pair|
+    attempts += 1
+    if pair[0] == 2 && attempts < 5
+      redo
+    end
+    puts "pair=#{pair.inspect} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_each_cons
+
+# === Array#each_slice ===
+def t_each_slice
+  attempts = 0
+  [1, 2, 3, 4, 5].each_slice(2) do |chunk|
+    attempts += 1
+    if chunk[0] == 3 && attempts < 5
+      redo
+    end
+    puts "chunk=#{chunk.inspect} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_each_slice
+
+# === Array#each_with_object ===
+def t_each_with_object
+  attempts = 0
+  result = [1, 2, 3].each_with_object([]) do |x, acc|
+    attempts += 1
+    if x == 2 && attempts < 5
+      redo
+    end
+    acc << x * 10
+  end
+  puts result.inspect
+  puts "total=#{attempts}"
+end
+t_each_with_object
+
+# === Array#zip iteration ===
+def t_zip
+  attempts = 0
+  [1, 2, 3].zip([10, 20, 30]) do |a, b|
+    attempts += 1
+    if a == 2 && attempts < 5
+      redo
+    end
+    puts "a=#{a} b=#{b} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_zip
+
+# === Array#cycle (with count to terminate) ===
+def t_cycle
+  attempts = 0
+  [1, 2].cycle(2) do |x|
+    attempts += 1
+    if x == 1 && attempts < 3
+      redo
+    end
+    puts "x=#{x} attempt=#{attempts}"
+  end
+  puts "total=#{attempts}"
+end
+t_cycle
+
+# === Nested redo (mixed loop kinds) — exercises label-stack uniqueness ===
+def t_nested
+  inner_attempts = 0
+  outer_done = 0
+  i = 0
+  while i < 2
+    outer_done += 1
+    3.times do |j|
+      inner_attempts += 1
+      if i == 0 && j == 1 && inner_attempts < 4
+        redo
+      end
+      puts "i=#{i} j=#{j} attempt=#{inner_attempts}"
+    end
+    i += 1
+  end
+  puts "outer_done=#{outer_done}"
+  puts "inner_attempts=#{inner_attempts}"
+end
+t_nested

data/vendor/spinel/test/redo.rb.expected

@@ -0,0 +1,71 @@
+i=0 attempt=1
+i=1 attempt=5
+i=2 attempt=6
+total=6
+x=10 attempt=1
+x=20 attempt=5
+x=30 attempt=6
+total=6
+i=0 attempt=1
+i=1 attempt=5
+i=2 attempt=6
+total=6
+i=0 attempt=1
+i=1 attempt=5
+i=2 attempt=6
+total=6
+i=0 attempt=1
+i=1 attempt=5
+i=2 attempt=6
+total=6
+x=10 attempt=1
+x=20 attempt=5
+x=30 attempt=6
+total=6
+i=0 attempt=1
+i=1 attempt=5
+i=2 attempt=6
+total=6
+i=0 attempt=1
+i=1 attempt=5
+i=2 attempt=6
+total=6
+i=2 attempt=1
+i=1 attempt=5
+i=0 attempt=6
+total=6
+i=0 attempt=1
+i=2 attempt=5
+i=4 attempt=6
+total=6
+x=a i=0 attempt=1
+x=b i=1 attempt=5
+x=c i=2 attempt=6
+total=6
+pair=[1, 2] attempt=1
+pair=[2, 3] attempt=5
+pair=[3, 4] attempt=6
+total=6
+chunk=[1, 2] attempt=1
+chunk=[3, 4] attempt=5
+chunk=[5] attempt=6
+total=6
+[10, 20, 30]
+total=6
+a=1 b=10 attempt=1
+a=2 b=20 attempt=5
+a=3 b=30 attempt=6
+total=6
+x=1 attempt=3
+x=2 attempt=4
+x=1 attempt=5
+x=2 attempt=6
+total=6
+i=0 j=0 attempt=1
+i=0 j=1 attempt=4
+i=0 j=2 attempt=5
+i=1 j=0 attempt=6
+i=1 j=1 attempt=7
+i=1 j=2 attempt=8
+outer_done=2
+inner_attempts=8

data/vendor/spinel/test/reduce_acc_shadow.rb

@@ -0,0 +1,31 @@
+# Array#reduce: the accumulator block param's type must come from the
+# seed (init_val), not from the element type. infer_type(acc) inside
+# the block must follow the seed in both directions — pointer seed
+# (string) over a value-typed outer, and value seed (int) over a
+# pointer-typed outer.
+
+def f
+  total = [1, 2, 3].reduce("") { |acc, x| acc + x.to_s }
+  puts total   # 123
+end
+f
+
+# Outer same-named local of a different type must not leak into the block.
+def g
+  acc = 99
+  out = [10, 20, 30].reduce("=") { |acc, x| acc + x.to_s }
+  puts out   # =102030
+  puts acc   # 99
+end
+g
+
+# Reverse direction: int seed must shadow an outer string acc without
+# the outer binding leaking into the block's `acc + x` (which would
+# dispatch as string concat instead of mrb_int addition).
+def h
+  acc = "outer"
+  sum = [1, 2, 3, 4, 5].reduce(0) { |acc, x| acc + x }
+  puts sum   # 15
+  puts acc   # outer
+end
+h

data/vendor/spinel/test/reduce_acc_shadow.rb.expected

@@ -0,0 +1,5 @@
+123
+=102030
+99
+15
+outer

data/vendor/spinel/test/regex.rb

@@ -0,0 +1,152 @@
+# Regex coverage — issue #61's five stages plus literal-form
+# tests. Was six tests; class names didn't collide and the only
+# top-level `def` (regex_local_var's `find`) is unique within this
+# file. Local-name collisions (`re`, `re2` reused across files for
+# different regex literals) are dodged with per-section prefixes
+# so spinel's local-type inference doesn't unify them across the
+# script and widen to poly.
+
+# === Stage 1: UTF-8 source byte-length ===
+# A regex source containing multi-byte UTF-8 chars must reach the
+# runtime with the correct byte length. This section just verifies
+# the binary runs past regex init.
+re_s1a = /[₀₁₂₃₄₅₆₇₈₉]+/
+re_s1b = /\A→\z/
+re_s1c = /[αβγ]/
+puts "ok"
+
+# === Stage 2: UTF-8 character class ===
+puts(("₁" =~ /[₀-₉]/) ? "ok1" : "fail1")
+puts(("α" =~ /[α-ω]/) ? "ok2" : "fail2")
+puts(("abc₁def" =~ /[₀₁₂₃₄₅₆₇₈₉]+/) ? "ok3" : "fail3")
+puts(("a"  =~ /[^₀-₉]/) ? "ok4" : "fail4")
+puts(("₁" =~ /[^₀-₉]/) ? "fail5" : "ok5")
+puts(("z"  =~ /[a-z₀-₉]/) ? "ok6" : "fail6")
+puts(("₅" =~ /[a-z₀-₉]/) ? "ok7" : "fail7")
+puts(("₁" =~ /[α-ω]/) ? "fail8" : "ok8")
+puts(("a"  =~ /[α-ω]/) ? "fail9" : "ok9")
+m_s2 = "abc₁₂₃def" =~ /[₀-₉]+/
+puts(m_s2 ? "ok10" : "fail10")
+
+# === Stage 3: regex via constant ===
+RX = /[₀₁₂₃₄₅₆₇₈₉ₐₑₒₓₔ]+/
+puts RX.match?("₁₂")
+puts RX.match?("abc")
+if "₁₂" =~ RX
+  puts "lhs match"
+else
+  puts "lhs miss"
+end
+if RX =~ "₁₂"
+  puts "rhs match"
+else
+  puts "rhs miss"
+end
+m_s3 = RX.match("₁₂")
+puts m_s3 ? "match ok" : "match fail"
+
+# === Stage 4: regex via local variable ===
+re_lv = /[₀₁₂₃₄₅₆₇₈₉]+/
+puts re_lv.match?("₁₂")
+puts re_lv.match?("abc")
+if "abc₁def" =~ re_lv
+  puts "lhs match"
+else
+  puts "lhs miss"
+end
+if re_lv =~ "abc₁def"
+  puts "rhs match"
+else
+  puts "rhs miss"
+end
+
+# Inside a method body — fresh scope, fresh local.
+def find(s)
+  rx = /[a-z]+/
+  rx.match?(s)
+end
+puts find("hello")
+puts find("123")
+
+# Multi-write disqualifies dispatch; the fall-through still compiles.
+re2_lv = /a/
+re2_lv = "not a regex"
+puts re2_lv
+
+# === Stage 5: UTF-8 quantifier ===
+puts "abc₁₂def".gsub(/[₀-₉]+/, "N")
+puts "abc₁₂₃def".gsub(/[₀-₉]+/, "N")
+puts "₁abc₂₃def₄₅₆".scan(/[₀-₉]+/).length
+puts "₀₁".match?(/[₀-₉]{2}/) ? "ok2" : "fail2"
+puts "₀".match?(/[₀-₉]{2}/) ? "fail3" : "ok3"
+puts "a₁b₂c".scan(/[a-z₀-₉]+/).length
+puts "₁₂₃".scan(/[₀-₉]/).length
+puts "αβ".match?(/[α-ω]+/) ? "ok7" : "fail7"
+
+# === Multi-line / escape patterns ===
+re_ml1 = /
+  bar
+/x
+if re_ml1 =~ "barbar"
+  puts "ok1"
+else
+  puts "no1"
+end
+
+re_ml_t = /a\tb/
+if re_ml_t =~ "a\tb"
+  puts "ok2"
+else
+  puts "no2"
+end
+
+re_ml_n = /a\nb/
+if re_ml_n =~ "a\nb"
+  puts "ok3"
+else
+  puts "no3"
+end
+
+re_ml_r = /a\rb/
+if re_ml_r =~ "a\rb"
+  puts "ok4"
+else
+  puts "no4"
+end
+
+# InterpolatedRegularExpressionNode (/foo_#{x}/). Pattern is only known
+# at execution time; each AST site gets a `sp_re_dyn_<idx>(const char *)`
+# helper with a function-scope cache so heap is bounded to one engine
+# pattern per source location. Match-site dispatch goes through the
+# regex_pat_c_expr helper so =~, match?, match, gsub, sub, scan, and
+# split all accept either form.
+
+# match? predicate (boolean -- safe across CRuby/Spinel int/value
+# differences in =~ which returns a position vs a count).
+ir_x = "bar"
+puts "foo_bar".match?(/foo_#{ir_x}/)   #=> true
+puts "foo_baz".match?(/foo_#{ir_x}/)   #=> false
+
+# Captures populate $1
+if "foo_bar_42" =~ /foo_#{ir_x}_(\d+)/
+  puts $1   #=> 42
+end
+
+# gsub with interpolated pattern
+ir_who = "world"
+puts "hello world".gsub(/#{ir_who}/, "Ruby")   #=> hello Ruby
+
+# sub
+puts "abc 123 def".sub(/(\d+)/, "X")           #=> abc X def
+
+# Interpolation that varies per-iteration (proves no stale cache and
+# that runtime compilation actually re-fires per evaluation).
+ir_i = 0
+while ir_i < 3
+  ir_seed = ir_i.to_s
+  puts ("v_" + ir_seed).match?(/v_#{ir_seed}/)
+  ir_i = ir_i + 1
+end
+#=> true
+#=> true
+#=> true

data/vendor/spinel/test/regex.rb.expected

@@ -0,0 +1,43 @@
+ok
+ok1
+ok2
+ok3
+ok4
+ok5
+ok6
+ok7
+ok8
+ok9
+ok10
+true
+false
+lhs match
+rhs match
+match ok
+true
+false
+lhs match
+rhs match
+true
+false
+not a regex
+abcNdef
+abcNdef
+3
+ok2
+ok3
+1
+3
+ok7
+ok1
+ok2
+ok3
+ok4
+true
+false
+42
+hello Ruby
+abc X def
+true
+true
+true

data/vendor/spinel/test/regexp.rb

@@ -0,0 +1,34 @@
+# Test Regexp support
+
+# match operator
+if "hello 123 world" =~ /\d+/
+  puts "matched"
+end
+
+# match with capture
+str = "2024-03-17"
+if str =~ /(\d{4})-(\d{2})-(\d{2})/
+  puts $1  # 2024
+  puts $2  # 03
+  puts $3  # 17
+end
+
+# String#match?
+puts "hello".match?(/ell/)    # true
+puts "hello".match?(/xyz/)    # false
+
+# String#gsub with regexp
+puts "hello world".gsub(/o/, "0")   # hell0 w0rld
+
+# String#sub with regexp
+puts "hello world".sub(/o/, "0")    # hell0 world
+
+# String#scan
+"one 1 two 2 three 3".scan(/\d+/) do |m|
+  puts m
+end
+# 1, 2, 3
+
+# String#split with regexp
+parts = "a, b,  c".split(/,\s*/)
+puts parts.length  # 3

data/vendor/spinel/test/regexp.rb.expected

@@ -0,0 +1,12 @@
+matched
+2024
+03
+17
+true
+false
+hell0 w0rld
+hell0 world
+1
+2
+3
+3

data/vendor/spinel/test/reopen_class.rb

@@ -0,0 +1,33 @@
+# Test: reopening a user-defined class merges into the existing one
+# instead of producing duplicate C struct/constructor definitions.
+
+class Point
+  attr_accessor :x
+  def initialize(x, y)
+    @x = x
+    @y = y
+  end
+end
+
+class Point
+  attr_accessor :y
+  def to_s
+    "(" + @x.to_s + "," + @y.to_s + ")"
+  end
+end
+
+p = Point.new(3, 4)
+puts p.to_s
+puts p.x
+puts p.y
+p.x = 10
+p.y = 20
+puts p.to_s
+
+class Foo
+end
+
+class Foo
+end
+
+puts "ok"

data/vendor/spinel/test/reopen_class.rb.expected

@@ -0,0 +1,5 @@
+(3,4)
+3
+4
+(10,20)
+ok

data/vendor/spinel/test/require/lib/greeter.rb

@@ -0,0 +1,9 @@
+class Greeter
+  def initialize(name)
+    @name = name
+  end
+
+  def greet
+    "Hello, " + @name + "!"
+  end
+end

data/vendor/spinel/test/require/main.rb

@@ -0,0 +1,5 @@
+require_relative "lib/greeter"
+
+g = Greeter.new("world")
+puts g.greet   # Hello, world!
+puts "done"

data/vendor/spinel/test/require_dedup/lib/data.rb

@@ -0,0 +1,2 @@
+require_relative 'types'
+DATA = [DT_Vertex.new(10, 20), DT_Vertex.new(30, 40)]

data/vendor/spinel/test/require_dedup/lib/types.rb

@@ -0,0 +1 @@
+DT_Vertex = Struct.new(:x, :y)

data/vendor/spinel/test/require_dedup/main.rb

@@ -0,0 +1,8 @@
+# Both lib/types and lib/data are required directly. lib/data internally
+# requires lib/types too. Without dedup, struct sp_DT_Vertex_s would be
+# emitted twice and the C compile would fail with "redefinition".
+require_relative 'lib/types'
+require_relative 'lib/data'
+
+puts DATA.length
+DATA.each { |v| puts "#{v.x},#{v.y}" }