rubyduino 0.2.0 → 0.2.1

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

@@ -0,0 +1,8 @@
+[104, 105]
+[104, 105, 0]
+[0, 104, 105]
+[104, 0, 105]
+"hi"
+"x"
+"ab"
+"ab"

data/vendor/spinel/test/struct_dig.rb

@@ -0,0 +1,16 @@
+# Struct#dig is variadic. The first key is member access (by symbol /
+# string name or integer position); any further keys dig recursively
+# into the member's value. Previously dig fell through to an unresolved
+# nil and emitted a C type error.
+Person = Struct.new(:name, :age)
+p = Person.new("Alice", 30)
+puts p.dig(:name)
+puts p.dig(:age)
+puts p.dig(0)
+puts p.dig(1)
+
+# nested dig: a member holding a hash is dug recursively
+Config = Struct.new(:name, :address)
+c = Config.new("server", { "country" => "JP", "city" => "Tokyo" })
+puts c.dig(:address, "country")
+puts c.dig(:address, "city")

data/vendor/spinel/test/struct_int_member_unboxed.rb

@@ -0,0 +1,14 @@
+Rec = Struct.new(:id, :name)
+
+full = Rec.new(1, "alice")
+puts full.id
+puts full.name
+
+empty = Rec.new
+puts empty.id.nil?
+puts empty.name.nil?
+
+empty.id = 7
+empty.name = "bob"
+puts empty.id
+puts empty.name

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

@@ -0,0 +1,6 @@
+1
+alice
+true
+true
+7
+bob

data/vendor/spinel/test/struct_member_name_no_global_merge.rb

@@ -0,0 +1,28 @@
+# A Struct member name must not globally type-merge with an unrelated
+# method of the same name. Here Struct member `b` (an Integer) shares
+# its name with Weight#b (a Float array); the int use through an
+# unresolved receiver must stay Integer, not get widened to FloatArray.
+class Weight
+  def initialize
+    @v = [1.0, 2.0, 3.0]
+  end
+  def b
+    @v
+  end
+end
+Ctx = Struct.new(:t, :b)
+def sum_to(batch)
+  r = batch % 7
+  i = 0
+  s = 0
+  while i < batch
+    s = s + i
+    i = i + 1
+  end
+  s + r
+end
+w = Weight.new
+puts w.b.length
+ctx = Ctx.new(3, 5)
+puts sum_to(ctx.b)
+puts sum_to(10)

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

@@ -0,0 +1,3 @@
+3
+15
+48

data/vendor/spinel/test/struct_to_a_values.rb

@@ -0,0 +1,12 @@
+# Struct#to_a and #values gather the member values into an array,
+# preserving declaration order. Members may be heterogeneous.
+Person = Struct.new(:name, :age)
+pp = Person.new("Alice", 30)
+p pp.values
+p pp.to_a
+puts pp.values.inspect
+Point = Struct.new(:x, :y)
+p Point.new(3, 4).to_a
+Mixed = Struct.new(:a, :b, :c)
+p Mixed.new(1.5, [1, 2, 3], "hi").to_a
+p Mixed.new(1.5, [1, 2, 3], "hi").values

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

@@ -0,0 +1,6 @@
+["Alice", 30]
+["Alice", 30]
+["Alice", 30]
+[3, 4]
+[1.5, [1, 2, 3], "hi"]
+[1.5, [1, 2, 3], "hi"]

data/vendor/spinel/test/struct_to_h.rb

@@ -0,0 +1,8 @@
+# Struct#to_h builds a symbol-keyed hash of member name => value.
+# Checked by lookup + length (inspect format varies across Ruby).
+Person = Struct.new(:name, :age, :city)
+h = Person.new("Alice", 30, "NYC").to_h
+p h[:name]
+p h[:age]
+p h[:city]
+p h.length

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

@@ -0,0 +1,4 @@
+"Alice"
+30
+"NYC"
+3

data/vendor/spinel/test/struct_to_h_block.rb

@@ -0,0 +1,30 @@
+# Struct#to_h with a block yields each (member_symbol, value) pair and
+# builds a hash from the [k, v] arrays the block returns. Values are
+# asserted via key lookup rather than Hash#inspect so the test does not
+# depend on the `=>` inspect spacing, which differs across Ruby versions.
+Person = Struct.new(:name, :age)
+p = Person.new("Alice", 30)
+h = p.to_h { |name, val| [name.to_s, val] }
+puts h["name"]
+puts h["age"]
+puts h.size
+
+Point = Struct.new(:x, :y)
+pt = Point.new(3, 4)
+# transform the value too
+h2 = pt.to_h { |k, v| [k.to_s, v * 2] }
+puts h2["x"]
+puts h2["y"]
+
+# both elements stringified (block returns a str_array)
+h3 = pt.to_h { |k, v| [k.to_s, v.to_s] }
+puts h3["x"]
+puts h3["y"]
+
+# heterogeneous members (string, int, bool)
+Rec = Struct.new(:label, :count, :on)
+r = Rec.new("widget", 7, true)
+h4 = r.to_h { |k, v| [k.to_s, v] }
+puts h4["label"]
+puts h4["count"]
+puts h4["on"]

data/vendor/spinel/test/super_in_non_initialize.rb

@@ -0,0 +1,44 @@
+# Issue #401: `super` in a non-`initialize` instance method
+# previously emitted literal `0` instead of a call to the parent
+# method. Compiled cleanly when the method's return type was
+# `mrb_int` (silent wrong-result), failed C-compile when types
+# diverged.
+#
+# Fix: SuperNode / ForwardingSuperNode in compile_expr now resolve
+# the parent's same-named method (find_method_owner walks the
+# parent chain) and emit a direct C call with `self` cast to the
+# owner's pointer type. infer_type also returns the parent's
+# method's return type for the result.
+
+class A
+  def value
+    10
+  end
+
+  def doubled(x)
+    x * 2
+  end
+end
+
+class B < A
+  def value
+    super         # bare super forwards no args
+  end
+
+  def doubled(x)
+    super(x) + 1  # explicit super(arg) -> A.doubled(x) + 1
+  end
+end
+
+class C < B
+  def value
+    super + 5     # B.value calls A.value (10) -> 10 + 5 = 15
+  end
+end
+
+b = B.new
+puts b.value.to_s       # 10
+puts b.doubled(3).to_s  # 6 + 1 = 7
+
+c = C.new
+puts c.value.to_s       # 15

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

@@ -0,0 +1,3 @@
+10
+7
+15

data/vendor/spinel/test/super_with_args.rb

@@ -0,0 +1,25 @@
+# super (bare or with explicit args) must propagate Child param
+# types to Parent params; otherwise spinel infers Parent's params
+# as default int and emits a wrong-type call.
+class Parent
+  def greet(name)
+    puts "Parent: #{name}"
+  end
+end
+
+class Child < Parent
+  def greet(name)
+    super
+    puts "Child: #{name}"
+  end
+end
+
+class Echo < Parent
+  def greet(name)
+    super(name)
+    puts "Echo done"
+  end
+end
+
+Child.new.greet("Alice")
+Echo.new.greet("Bob")

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

@@ -0,0 +1,4 @@
+Parent: Alice
+Child: Alice
+Parent: Bob
+Echo done

data/vendor/spinel/test/sym_hash_cross_variant_merge.rb

@@ -0,0 +1,40 @@
+# #515. Cross-variant Hash#merge between sym_str_hash and
+# sym_poly_hash (sibling to #510) used to fail in both directions:
+#
+# - sym_str_hash.merge(sym_poly_hash): codegen routed to
+#   sp_SymStrHash_merge and passed the poly arg as `b`, tripping
+#   -Wincompatible-pointer-types and producing runtime garbage.
+#
+# - sym_poly_hash.merge(sym_str_hash): no helper at all,
+#   "cannot resolve call to 'merge' on sym_poly_hash" warning.
+#
+# Fix: new sp_SymStrHash_to_sym_poly (codegen-emitted alongside
+# the existing sym_str_hash runtime helpers) and
+# sp_SymPolyHash_merge_str. Both directions return a fresh
+# sym_poly_hash. Analyze's merge inference returns
+# sym_poly_hash for the cross-variant pair.
+
+def dir1_str_recv_poly_arg(t)
+  poly = { method: :delete, id: 42, text: t }
+  str  = { class: "btn", role: "button" }
+  str.merge(poly)
+end
+
+def dir2_poly_recv_str_arg(t)
+  poly = { method: :delete, id: 42, text: t }
+  str  = { class: "btn", role: "button" }
+  poly.merge(str)
+end
+
+# Both directions: receiver has 2 keys, arg has 3 keys, no
+# overlap -> 5 entries in the merged hash.
+puts dir1_str_recv_poly_arg("a").length
+puts dir2_poly_recv_str_arg("a").length
+
+# Overlap: arg's value wins (standard Hash#merge semantics).
+def overlap_dir1
+  base = { class: "btn", id: 1 }
+  over = { id: 99, name: :foo }
+  base.merge(over)[:id]
+end
+p overlap_dir1

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

@@ -0,0 +1,3 @@
+5
+5
+99

data/vendor/spinel/test/sym_int_hash_merge.rb

@@ -0,0 +1,52 @@
+# #546. Sibling of #510 -- merge / dup / delete dispatch was
+# missing on sym_int_hash (Symbol-key, Int-value). #510 fixed
+# the same surface for sym_str_hash and sym_poly_hash. Spinel
+# emitted `cannot resolve call to 'merge' on sym_int_hash
+# (emitting 0)` and the call no-op'd.
+#
+# Trigger in roundhouse: `ActionView::ViewHelpers.link_to`
+# builds an HTML-attrs hash via `.merge`; when the value type
+# was numeric (sym_int_hash variant) the merge dropped silently.
+#
+# Fix:
+# 1. spinel_codegen.rb: new `sp_SymIntHash_merge` runtime helper
+#    (mirrors the sym_str_hash version with NULL-guard on the
+#    second arg per the #542 / #546 NULL-receiver pattern).
+# 2. spinel_codegen.rb: sym_int_hash recv dispatch block gains
+#    merge / dup / delete arms.
+# 3. spinel_codegen.rb: kwarg-shorthand merge (`h.merge(c: 3)`)
+#    builds the matching sp_SymIntHash inline from the
+#    KeywordHashNode pairs, mirroring the kwarg-as-bundle path
+#    in compile_constructor_args.
+
+def merge_kwarg(h)
+  h.merge(c: 3, d: 4)
+end
+
+def merge_hash(h)
+  h.merge({c: 3, d: 4})
+end
+
+# Both forms work post-fix.
+r1 = merge_kwarg({a: 1, b: 2})
+puts r1[:a]   # 1
+puts r1[:b]   # 2
+puts r1[:c]   # 3
+puts r1[:d]   # 4
+
+r2 = merge_hash({a: 10, b: 20})
+puts r2[:a]   # 10
+puts r2[:c]   # 3
+
+# dup
+h = {x: 100, y: 200}
+h2 = h.dup
+puts h2[:x]   # 100
+puts h2[:y]   # 200
+
+# delete
+h3 = {p: 1, q: 2, r: 3}
+h3.delete(:q)
+puts h3[:p]   # 1
+puts h3[:q]   # 0 (missing now)
+puts h3[:r]   # 3

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

@@ -0,0 +1,11 @@
+1
+2
+3
+4
+10
+3
+100
+200
+1
+
+3

data/vendor/spinel/test/sym_int_hash_missing_key_nil.rb

@@ -0,0 +1,15 @@
+h = {a: 1, b: 2}
+p h[:miss]
+p h[:miss].nil?
+p h[:miss].inspect
+p(h[:miss] || 42)
+v = h[:miss]
+p v.nil?
+p(v || 7)
+p h[:a]
+p(h[:a] + 1)
+# Hash.new(N) keeps its explicit default; {} default is nil.
+c = Hash.new(0)
+p c[:z]
+p({}.default)
+p c.default

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

@@ -0,0 +1,11 @@
+nil
+true
+"nil"
+42
+true
+7
+1
+2
+0
+nil
+0

data/vendor/spinel/test/sym_poly_hash_merge_sym_int.rb

@@ -0,0 +1,18 @@
+# #559 (Sam Ruby). Sibling of #551. sym_poly_hash.merge with
+# a positional sym_int_hash argument was missing dispatch
+# (only the KeywordHashNode and same-variant shapes were
+# wired). The cross-variant lowering routes through a new
+# sp_SymPolyHash_merge_int runtime helper that boxes each
+# int value as sp_box_int into the result poly slot.
+
+def f
+  h = { a: "x", b: 1 }
+  other = { c: 2 }
+  h.merge(other)
+end
+
+m = f
+puts m.length
+puts m.has_key?(:a)
+puts m.has_key?(:b)
+puts m.has_key?(:c)

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

@@ -0,0 +1,4 @@
+3
+true
+true
+true

data/vendor/spinel/test/symbol_id2name_ruby_desc_minmax.rb

@@ -0,0 +1,13 @@
+# #1249 Symbol#id2name: the symbol's name as a String (alias of to_s).
+p :hello.id2name
+p :foo_bar.id2name
+puts :sym.id2name.class
+
+# #1251 RUBY_DESCRIPTION is a String (value is engine-specific; only the
+# class is asserted so it stays portable).
+puts RUBY_DESCRIPTION.class
+
+# #1217 Range#minmax: [min, max], honouring exclusive end.
+p (1..10).minmax
+p (1...10).minmax
+p (5..5).minmax

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

@@ -0,0 +1,7 @@
+"hello"
+"foo_bar"
+String
+String
+[1, 10]
+[1, 9]
+[5, 5]

data/vendor/spinel/test/symbol_to_proc_after_positional.rb

@@ -0,0 +1,18 @@
+# &:symbol block-pass after a positional argument must parse as a
+# symbol-to-proc block, not a hash literal -- in both parenthesized
+# and command (paren-less) calls. Front-door blocker for bundler
+# (File.open(f, "r:UTF-8", &:read)) and minitest
+# (define_method :mu_pp, &:pretty_inspect).
+class Widget
+  define_method(:as_str, &:to_s)   # parenthesized, after a positional
+end
+
+class Gadget
+  define_method :label, &:to_s     # command (paren-less), after a positional
+end
+
+puts Widget.new.as_str(7)
+puts Gadget.new.label(8)
+p [1, 2, 3].map(&:to_s)            # sole arg in parens (regression guard)
+p [1, 2, 3].map &:to_s            # command-position sole arg
+p [10, 20, 30].inject(0, &:+)     # operator symbol after a positional (native)

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

@@ -0,0 +1,5 @@
+7
+8
+["1", "2", "3"]
+["1", "2", "3"]
+60

data/vendor/spinel/test/symbol_upcase_interpolation.rb

@@ -0,0 +1,24 @@
+# Symbol#upcase / #downcase on a method-returned (branch-poly) symbol
+# inside string interpolation lowers through sp_sym_intern. The runtime
+# helper is gated on @needs_sym_intern, which analyze set as a memoized
+# side effect and missed for this shape -> link failure on the call.
+# Found via the spinelgems harness (nagiosplugin).
+class P
+  def status(n)
+    return :critical if n > 2
+    return :warning if n > 1
+    :ok
+  end
+  def output(n)
+    "X #{status(n).upcase}"
+  end
+  def lower(n)
+    "y #{status(n).downcase}"
+  end
+end
+
+puts P.new.output(3)
+puts P.new.output(2)
+puts P.new.output(1)
+puts P.new.lower(3)
+puts "hi".to_sym.inspect

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

@@ -0,0 +1,5 @@
+X CRITICAL
+X WARNING
+X OK
+y critical
+:hi

data/vendor/spinel/test/system_argument_list.rb

@@ -0,0 +1,15 @@
+# Multi-argument system calls execute the command directly with its argv list.
+
+system("ruby", "-e", "puts 'stmt_ok'")
+
+ok = system("ruby", "-e", "exit 0")
+puts ok
+puts($? == 0)
+
+ok = system("ruby", "-e", "exit 1")
+puts ok
+puts($? == 0)
+
+ok = system("ruby", "-e", "exit(ARGV[0] == 'ok' ? 0 : 1)", "ok")
+puts ok
+puts($? == 0)

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

@@ -0,0 +1,7 @@
+stmt_ok
+true
+true
+false
+false
+true
+true

data/vendor/spinel/test/thread_new_value.rb

@@ -0,0 +1,5 @@
+t = Thread.new { 21 * 2 }
+puts t.value
+
+s = Thread.new { "hi" + "!" }
+puts s.value

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

@@ -0,0 +1,2 @@
+42
+hi!

data/vendor/spinel/test/time_localtime_gmtime.rb

@@ -0,0 +1,19 @@
+# Time#gmtime / #localtime (and the getutc / getlocal variants) flip the
+# UTC-presentation flag. The underlying instant is unchanged, so these
+# checks stay timezone-independent.
+t = Time.utc(2000, 1, 2, 3, 4, 5)
+
+# gmtime / getutc present the instant in UTC.
+p t.gmtime.year
+p t.gmtime.hour
+p t.getutc.hour
+p t.getutc.min
+
+# localtime changes the presentation, but flipping back to UTC restores
+# the original broken-down fields (the instant is preserved).
+p t.localtime.utc.hour
+p t.localtime.getutc.year
+
+# The epoch second is invariant across presentation flips.
+p t.to_i == t.localtime.to_i
+p t.to_i == t.gmtime.to_i

data/vendor/spinel/test/time_mktime_local_utc.rb

@@ -0,0 +1,24 @@
+# Time.mktime / Time.local / Time.utc — all three name the local
+# (and gm/utc) constructor. Time.now and Time.new were already
+# wired; this test covers the aliases plus the UTC variant that
+# uses a timezone-independent days-from-civil epoch.
+t = Time.now
+puts t.class
+
+t2 = Time.mktime(2025, 1, 15, 10, 30, 0)
+puts t2.year
+puts t2.month
+puts t2.day
+puts t2.hour
+puts t2.min
+
+t3 = Time.local(2026, 3, 5)
+puts t3.year
+puts t3.month
+puts t3.day
+
+t4 = Time.utc(2025, 6, 15, 12, 0, 0)
+puts t4.year
+puts t4.month
+puts t4.day
+puts t4.hour

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

@@ -0,0 +1,13 @@
+Time
+2025
+1
+15
+10
+30
+2026
+3
+5
+2025
+6
+15
+12

data/vendor/spinel/test/time_strftime_long_format.rb

@@ -0,0 +1,21 @@
+# strftime output longer than the old fixed 256-byte buffer was silently
+# dropped to "". A roomier buffer now handles realistic long formats
+# (lots of literal text, repeated or wide directives). A pathological
+# field width still does not fit and yields "" gracefully (no crash);
+# that case isn't asserted here because CRuby raises Errno::ERANGE for it.
+t = Time.at(0).utc
+
+# %Y-%m-%d rather than %F: MinGW's libc strftime doesn't implement the
+# C99 %F directive (it returns ""), and this helper calls strftime(3)
+# directly. The buffer fix is what this test exercises, not %F.
+puts t.strftime("%Y-%m-%d")
+puts t.strftime("%Y-%m-%d %H:%M:%S")
+
+# ~500 bytes of output from a repeated directive
+puts t.strftime("%Y-" * 100).length
+
+# ~304 bytes: long literal run followed by a directive
+puts t.strftime("x" * 300 + "%Y").length
+
+# empty format stays empty
+p t.strftime("")

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

@@ -0,0 +1,5 @@
+1970-01-01
+1970-01-01 00:00:00
+500
+304
+""

data/vendor/spinel/test/time_subsec_utc.rb

@@ -0,0 +1,19 @@
+# Time instance accessors that read existing sp_Time fields:
+#   utc? / gmt?      -> the is_utc presentation flag (bool)
+#   tv_usec / usec   -> microsecond fraction (tv_nsec / 1000)
+#   tv_nsec / nsec   -> nanosecond fraction
+#   tv_sec           -> whole epoch seconds (alias of to_i)
+g = Time.utc(1997, 11, 21, 9, 55, 6)
+puts g.utc?
+puts g.gmt?
+
+l = Time.local(1997, 11, 21, 9, 55, 6)
+puts l.utc?
+
+a = Time.at(1.5)
+puts a.tv_sec
+puts a.tv_usec
+puts a.usec
+puts a.tv_nsec
+puts a.nsec
+puts a.utc?

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

@@ -0,0 +1,9 @@
+true
+true
+false
+1
+500000
+500000
+500000000
+500000000
+false

data/vendor/spinel/test/time_to_s.rb

@@ -0,0 +1,5 @@
+# Time#to_s renders the "YYYY-MM-DD HH:MM:SS +ZZZZ" form (no subsecond
+# fraction). Use .utc for a timezone-independent, deterministic string.
+t = Time.at(1700000000).utc
+puts t.to_s
+puts t.to_s.length > 0