rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/string_scanner_check_unscan.rb

@@ -0,0 +1,24 @@
+require "strscan"
+# StringScanner#check must save the pre-match position (like #scan) so that
+# a following #unscan rewinds to just before the check, not to the start.
+
+s = StringScanner.new("hello world")
+s.scan(/hello/)          # pos -> 5
+s.check(/ /)             # pos stays 5, but last_pos must become 5
+puts s.pos               # 5
+s.unscan
+puts s.pos               # 5, not 0
+
+# check also feeds pre_match / post_match, which key off the saved position.
+t = StringScanner.new("hello world")
+t.scan(/hello/)
+t.check(/ /)
+puts t.pre_match.inspect   # "hello"
+puts t.post_match.inspect  # "world"
+
+# unscan rewinds to the most recent check, not the first scan.
+u = StringScanner.new("ab cd")
+u.scan(/ab/)
+u.check(/ /)
+u.unscan
+puts u.pos               # 2

data/vendor/spinel/test/string_scanner_getch_utf8.rb

@@ -0,0 +1,26 @@
+require "strscan"
+# getch advances by one UTF-8 character, not one byte.
+s = StringScanner.new("café")
+puts s.getch
+puts s.getch
+puts s.getch
+puts s.getch
+puts s.eos?
+puts s.pos
+
+# pos tracks byte offsets across multibyte chars; unscan rewinds the char.
+t = StringScanner.new("añb")
+puts t.getch
+puts t.getch
+puts t.pos
+t.unscan
+puts t.pos
+puts t.getch
+puts t.getch
+puts t.eos?
+
+# 3-byte character.
+u = StringScanner.new("€x")
+puts u.getch
+puts u.pos
+puts u.getch

data/vendor/spinel/test/string_scanner_nullable.rb

@@ -0,0 +1,75 @@
+# StringScanner's string-returning methods return nil (not "") on a
+# miss / EOS / no-last-match, matching CRuby. The matched (non-nil)
+# result is a first-class string usable in every string operation.
+require "strscan"
+
+# scan / check / scan_until: nil on miss
+s = StringScanner.new("hello world")
+p s.scan(/x/)            # nil
+p s.check(/x/)           # nil
+p s.scan(/hello/)        # "hello"
+p s.check(/ /)           # " "
+p s.scan_until(/o/)      # " wo"
+p s.scan_until(/zzz/)    # nil
+
+# matched / pre_match / post_match
+s2 = StringScanner.new("foobarbaz")
+p s2.matched             # nil (no match yet)
+s2.scan(/foo/)
+p s2.matched             # "foo"
+p s2.pre_match           # ""
+p s2.post_match          # "barbaz"
+s2.scan(/bar/)
+p s2.pre_match           # "foo"
+
+# getch: nil at EOS
+s3 = StringScanner.new("ab")
+p s3.getch               # "a"
+p s3.getch               # "b"
+p s3.getch               # nil
+
+# [] capture group: nil out of range
+s4 = StringScanner.new("2026-06-05")
+s4.scan(/(\d+)-(\d+)/)
+p s4[0]                  # "2026-06"
+p s4[1]                  # "2026"
+p s4[9]                  # nil
+
+# A matched result behaves as a plain string across every operation.
+s5 = StringScanner.new("key=val")
+m = s5.scan(/\w+/)       # "key" : string?
+puts(m + "!")            # concat
+puts(m * 2)              # repeat
+puts(m == "key")         # eq
+puts(m < "z")            # compare
+puts([m].length)         # array-literal element
+acc = []
+acc << m                 # array push
+puts acc.length
+h = {}
+h[m] = 1                 # hash key
+puts h.length
+puts m.to_sym.inspect    # to_sym
+puts "[#{m}]"            # interpolation
+
+# truthiness + || default
+puts "truthy" if s5.scan(/=/)
+puts(s5.scan(/zzz/) || "default")
+
+# The full operator set on a matched result.
+s6 = StringScanner.new("mno")
+w = s6.scan(/mno/)       # "mno"
+puts(w > "a")            # true
+puts(w <= "mno")         # true
+puts(w >= "z")           # false
+puts(w.between?("a", "z")) # true
+fmt = StringScanner.new("%d")
+pat = fmt.scan(/%d/)     # "%d"
+puts(pat % 7)            # "7"
+
+# A nil result (miss) flows through operators CRuby treats as valid.
+miss = StringScanner.new("abc").scan(/zzz/)  # nil
+puts("[#{miss}]")        # "[]" -- nil interpolates to ""
+puts(miss == "abc")      # false
+puts(miss != "abc")      # true
+puts(miss.nil?)          # true

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

@@ -0,0 +1,37 @@
+nil
+nil
+"hello"
+" "
+" wo"
+nil
+nil
+"foo"
+""
+"barbaz"
+"foo"
+"a"
+"b"
+nil
+"2026-06"
+"2026"
+nil
+key!
+keykey
+true
+true
+1
+1
+1
+:key
+[key]
+truthy
+default
+true
+true
+false
+true
+7
+[]
+false
+true
+true

data/vendor/spinel/test/string_scanner_scan_to_local.rb

@@ -0,0 +1,11 @@
+require "strscan"
+# StringScanner#scan / #scan_until assigned to a local must type the local as
+# a String (the matched text), not String#scan's array-of-matches.
+s = StringScanner.new("42 hi")
+m = s.scan(/\d+/)
+puts(m + "!")
+puts m.to_i + 1
+n = s.scan_until(/hi/)
+puts n.length
+# String#scan (on a real String) still returns an array.
+p "a1b2c3".scan(/[a-z]\d/)

data/vendor/spinel/test/string_scanner_unscan_error.rb

@@ -0,0 +1,54 @@
+require "strscan"
+# StringScanner#unscan raises StringScanner::Error when there is no match
+# record to rewind to (double unscan, or unscan before any scan). A single
+# valid unscan after a successful scan must still succeed.
+# The class renders differently across implementations, so assert only via
+# the message, is_a?, and which rescue clauses catch it.
+
+# Positive case: one valid unscan after a scan works.
+s = StringScanner.new("abc")
+s.scan(/a/)
+s.unscan
+puts s.pos                       # 0
+
+# Double unscan raises with CRuby's message.
+s2 = StringScanner.new("abc")
+s2.scan(/a/)
+s2.unscan
+begin
+  s2.unscan
+  puts "no error"
+rescue StringScanner::Error => e
+  puts "double: #{e.message}"
+end
+
+# unscan before any scan raises too.
+s3 = StringScanner.new("abc")
+begin
+  s3.unscan
+  puts "no error"
+rescue StringScanner::Error => e
+  puts "fresh: #{e.message}"
+end
+
+# StringScanner::Error < StandardError, so these rescue forms catch it.
+s4 = StringScanner.new("abc")
+begin
+  s4.unscan
+rescue StandardError => e
+  puts "standard: #{e.message}"
+end
+
+s5 = StringScanner.new("abc")
+begin
+  s5.unscan
+rescue => e
+  puts "bare: #{e.message}"
+end
+
+s6 = StringScanner.new("abc")
+begin
+  s6.unscan
+rescue StringScanner::Error => e
+  puts "is StandardError? #{e.is_a?(StandardError)}"
+end

data/vendor/spinel/test/string_scrub.rb

@@ -0,0 +1,7 @@
+# String#scrub replaces invalid UTF-8 bytes with the given
+# replacement (or U+FFFD by default).
+puts "\xff".scrub("?")
+puts "a\xffb".scrub("?")
+puts "valid".scrub("?")
+# Default replacement (U+FFFD = "\xEF\xBF\xBD") is 3 bytes.
+puts "\xff".scrub.bytes.inspect

data/vendor/spinel/test/string_slice_range.rb

@@ -0,0 +1,18 @@
+# String#slice(Range) — decompose the Range and reuse the same
+# runtime helper as String#[](Range). Inclusive, exclusive,
+# endless, beginless and negative endpoints all supported.
+p "hello".slice(1..3)
+p "hello".slice(1...3)
+p "hello".slice(1..)
+p "hello".slice(..2)
+p "hello".slice(1..-2)
+p "hello".slice(2..10)
+p "hello".slice(0..-1)
+
+# slice still works with (start, length) and single-index forms.
+p "hello".slice(1, 2)
+p "hello".slice(1)
+
+# Through a local receiver too.
+s = "spinel"
+p s.slice(2..4)

data/vendor/spinel/test/string_split_capture.rb

@@ -0,0 +1,8 @@
+# Issue #856: split with a regex that has capture groups splices
+# the matched groups into the result between segments.
+puts "hello world".split(/(\s+)/).inspect
+# Without a capture group, behaviour unchanged.
+puts "hello world".split(/\s+/).inspect
+# Multiple capture groups: each captured substring is spliced
+# in, in group-index order.
+puts "a1b2c3d".split(/(\d)/).inspect

data/vendor/spinel/test/string_split_inline_arg_gc_root.rb

@@ -0,0 +1,77 @@
+# Inline split arguments must stay valid across compiled split calls with
+# GC-managed pressure nearby. The pressure loop grows retained int arrays so
+# runtime allocation and collection paths are exercised before each split.
+
+def churn_gc
+  keep = []
+  while GC.stat["bytes"] <= GC.stat["threshold"] && keep.length < 64
+    chunk = []
+    j = 0
+    while j < 65536
+      chunk << j
+      j = j + 1
+    end
+    keep << chunk
+  end
+  keep
+end
+
+def same_strings(a, b)
+  if a.length != b.length
+    return false
+  end
+
+  i = 0
+  while i < a.length
+    if a[i] != b[i]
+      return false
+    end
+    i = i + 1
+  end
+
+  true
+end
+
+lines = []
+i = 0
+while i < 40
+  lines << i.to_s
+  i = i + 1
+end
+
+data = lines.join(10.chr)
+keep = churn_gc
+
+plain = data.split(10.chr)
+keep = []
+keep2 = churn_gc
+positive = data.split(10.chr, 2)
+keep2 = []
+keep3 = churn_gc
+negative = (data + 10.chr).split(10.chr, -1)
+keep3 = []
+
+tail = []
+i = 1
+while i < lines.length
+  tail << lines[i]
+  i = i + 1
+end
+
+expected_positive = []
+expected_positive << lines[0]
+expected_positive << tail.join(10.chr)
+
+expected_negative = []
+i = 0
+while i < lines.length
+  expected_negative << lines[i]
+  i = i + 1
+end
+expected_negative << ""
+
+ok = same_strings(plain, lines)
+ok = ok && same_strings(positive, expected_positive)
+ok = ok && same_strings(negative, expected_negative)
+
+puts(ok ? "ok" : "bad")

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

@@ -0,0 +1 @@
+ok

data/vendor/spinel/test/string_squeeze_no_trailing_nul.rb

@@ -0,0 +1,12 @@
+# Issue #921: String#squeeze shrinks the heap-string header
+# so length / bytes report the post-squeeze size, not the
+# pre-squeeze allocation.
+s = "aaabbbccc"
+result = s.squeeze
+puts result.length
+puts result.bytes.inspect
+puts result.inspect
+
+# Trailing NULs leak the GC marker byte; ensure none.
+puts "xxxxx".squeeze.length
+puts "xxxxx".squeeze

data/vendor/spinel/test/string_sub_hash_replacement.rb

@@ -0,0 +1,8 @@
+# Issue #910: sub / gsub with a hash replacement argument.
+# The hash's matched-substring value is the replacement; missing
+# keys substitute with the empty string (CRuby semantics).
+puts "hello".sub(/l/, "l" => "X")
+puts "foo bar baz".sub(/\w+/, "foo" => "XXX")
+puts "hello".sub("l", "l" => "X")
+# gsub form (previously worked).
+puts "hello".gsub(/l/, "l" => "X")

data/vendor/spinel/test/string_to_i_base.rb

@@ -0,0 +1,9 @@
+# Issue #883: String#to_i with explicit base argument. Without the
+# fix, the base was silently dropped and the call returned 0 for
+# any non-decimal input.
+puts "ff".to_i(16)
+puts "1010".to_i(2)
+puts "777".to_i(8)
+puts "z".to_i(36)
+puts "-ff".to_i(16)
+puts "1_0".to_i(16)

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

@@ -0,0 +1,6 @@
+255
+10
+511
+35
+-255
+16

data/vendor/spinel/test/string_to_i_base_zero.rb

@@ -0,0 +1,9 @@
+# String#to_i(0) auto-detects the base from the literal prefix.
+puts "0xff".to_i(0)
+puts "0b10".to_i(0)
+puts "0777".to_i(0)
+puts "0o755".to_i(0)
+puts "42".to_i(0)         # no prefix → decimal
+# Sign handling.
+puts "-0xff".to_i(0)
+puts "+0b101".to_i(0)

data/vendor/spinel/test/string_to_i_overflow_raises.rb

@@ -0,0 +1,30 @@
+# String#to_i / Integer() on input exceeding int64 raises
+# RangeError rather than saturating silently. spinel's int model
+# is int64-only, so the CRuby Bignum promotion path lowers to a
+# user-catchable RangeError.
+
+begin
+  "99999999999999999999".to_i
+  puts "no exception"
+rescue RangeError
+  puts "to_i raised RangeError"
+end
+
+begin
+  "ffffffffffffffff0".to_i(16)
+  puts "no exception"
+rescue RangeError
+  puts "to_i(16) raised RangeError"
+end
+
+begin
+  Integer("99999999999999999999")
+  puts "no exception"
+rescue RangeError
+  puts "Integer raised RangeError"
+end
+
+# In-range values still work.
+puts "42".to_i
+puts "ff".to_i(16)
+puts Integer("-1000")

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

@@ -0,0 +1,6 @@
+to_i raised RangeError
+to_i(16) raised RangeError
+Integer raised RangeError
+42
+255
+-1000

data/vendor/spinel/test/string_undump.rb

@@ -0,0 +1,9 @@
+# String#undump is the inverse of String#dump. Round-tripping a string
+# through dump then undump returns the original (each engine round-trips
+# its own dump format, so the comparison is version-independent).
+# Previously undump was unresolved.
+["hello", "a\tb\nc", "q\"u\\o#te", "tab\there", "café"].each do |s|
+  puts(s.dump.undump == s)
+end
+# undump of an explicit dumped form
+puts "\"hi\\nthere\"".undump

data/vendor/spinel/test/string_upto.rb

@@ -0,0 +1,20 @@
+# String#upto walks successive strings (the same succ-based sequence a
+# String range produces) from the receiver to the argument inclusive,
+# yielding each to the block. The block-less form materializes the
+# sequence as an array. Previously codegen treated the receiver as an
+# integer loop variable and failed to compile.
+count = 0
+"a".upto("e") { |c| count += 1 }
+puts count
+
+out = ""
+"x".upto("z") { |c| out += c }
+puts out
+
+# multi-character carry
+multi = ""
+"ay".upto("bb") { |c| multi += c + "," }
+puts multi
+
+# block-less form materializes to an array
+puts "a".upto("c").to_a.join("-")

data/vendor/spinel/test/string_with_embedded_nul.rb

@@ -0,0 +1,46 @@
+# Spinel-allocated strings encode their byte length in the heap
+# header (sp_str_hdr.len), but several runtime helpers and one
+# codegen `bytesize` emit walked the buffer via NUL-terminated
+# strlen/`while(*p)` semantics. A `0.chr` value carrying a header
+# length of 1 with byte content `\x00` reported `length=0`,
+# `bytesize=0`, and sliced wrong past any embedded NUL.
+#
+# Fix: `sp_str_length` and `sp_utf8_byte_offset` consume the
+# header-tracked byte length instead of terminating at the first
+# NUL byte. `bytesize` codegen now emits
+# `sp_str_byte_len(...)` instead of `(mrb_int)strlen(...)`.
+# Issue #593.
+
+# Single-byte NUL.
+puts 0.chr.length              # 1
+puts 0.chr.bytesize            # 1
+puts 0.chr.ord                 # 0
+
+# Concat preserves NULs in the middle.
+b = 0.chr + 0xc8.chr
+puts b.length                  # 2
+puts b.bytesize                # 2
+puts b[0].ord                  # 0
+puts b[1].ord                  # 200 (0xc8)
+
+# Mixed ASCII + NUL + ASCII -- indexing past the NUL.
+c = "x" + 0.chr + "y"
+puts c.length                  # 3
+puts c[0].ord                  # 120 ('x')
+puts c[1].ord                  # 0
+puts c[2].ord                  # 121 ('y')
+
+# Progressive build with NUL in the middle.
+d = ""
+d = d + 0x81.chr
+d = d + 0x7e.chr
+d = d + 0x00.chr
+d = d + 0xc8.chr
+puts d.length                  # 4
+puts d[2].ord                  # 0
+puts d[3].ord                  # 200
+
+# Substring across NUL.
+e = d[0, 4]
+puts e.length                  # 4
+puts e[3].ord                  # 200

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

@@ -0,0 +1,16 @@
+1
+1
+0
+2
+2
+0
+200
+3
+120
+0
+121
+4
+0
+200
+4
+200

data/vendor/spinel/test/stringio_new_mode.rb

@@ -0,0 +1,21 @@
+# StringIO.new(str, mode) honours the mode's first char. Only io.string
+# / io.read are asserted: Spinel copies the initial string while CRuby
+# operates on it by reference, so the passed-in variable diverges and is
+# out of scope here.
+require 'stringio'
+
+# "w" truncates the initial content to empty.
+io = StringIO.new("existing", "w")
+io.print("foo")
+p io.string
+p StringIO.new("existing", "w").string
+
+# "a" keeps the content and seeks to the end, so writes append.
+io2 = StringIO.new("head", "a")
+io2.print("tail")
+p io2.string
+
+# "r" and the no-mode form keep the content at position 0.
+io3 = StringIO.new("data", "r")
+p io3.read
+p StringIO.new("data").string

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

@@ -0,0 +1,5 @@
+"foo"
+""
+"headtail"
+"data"
+"data"

data/vendor/spinel/test/stringio_new_nil.rb

@@ -0,0 +1,14 @@
+# StringIO.new(nil) raises TypeError, matching CRuby, instead of
+# running strlen(NULL) at the C level (which warned -Wnonnull and would
+# segfault). The reporter's "null device" framing is incorrect: CRuby
+# rejects a nil initial string outright.
+require 'stringio'
+begin
+  StringIO.new(nil)
+  puts "BUG: no raise"
+rescue TypeError => e
+  puts "TypeError: #{e.message}"
+end
+# A real string still constructs normally.
+io = StringIO.new("ok")
+puts io.string

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

@@ -0,0 +1,2 @@
+TypeError: no implicit conversion of nil into String
+ok

data/vendor/spinel/test/stringio_open.rb

@@ -0,0 +1,30 @@
+require "stringio"
+
+# Block form returns the block's value, with the io bound to the param.
+r = StringIO.open("foo") { |f| f.read }
+p r
+
+# The returned value is a first-class string.
+puts r.upcase
+puts r.length
+
+# Statement form (block result discarded).
+StringIO.open("bar") { |f| puts f.read }
+
+# Block whose value is not a string.
+n = StringIO.open("hello") { |f| f.read.length }
+p n
+
+# The common write-into-buffer idiom: build text, return io.string.
+s = StringIO.open { |io| io.puts "hello"; io.puts "world"; io.string }
+print s
+
+# No-block form returns the constructed io.
+io = StringIO.open("hi")
+p io.read
+
+# Nested inside another block.
+["a", "bb"].each do |x|
+  v = StringIO.open(x) { |f| f.read }
+  puts v.upcase
+end

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

@@ -0,0 +1,10 @@
+"foo"
+FOO
+3
+bar
+5
+hello
+world
+"hi"
+A
+BB

data/vendor/spinel/test/stringio_putc_fsync.rb

@@ -0,0 +1,24 @@
+require "stringio"
+
+# putc: String writes the first byte; Integer is the codepoint.
+io = StringIO.new
+io.putc "A"
+io.putc 66
+io.putc "CD"
+puts io.string
+
+# fsync is a no-op returning 0.
+io2 = StringIO.new
+puts io2.fsync
+
+# StringIO used inside a rescue (setjmp) scope -- exercises the
+# volatile-qualifier cast.
+def via_rescue
+  s = StringIO.new
+  s.write("in-")
+  s.write("rescue")
+  s.string
+rescue => e
+  "err"
+end
+puts via_rescue

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

@@ -0,0 +1,3 @@
+ABC
+0
+in-rescue

data/vendor/spinel/test/strip_nul.rb

@@ -0,0 +1,13 @@
+# strip/lstrip/rstrip remove the NUL byte (CRuby strips "\0\t\n\v\f\r ").
+# Embedded NUL needs a heap string (literals truncate at \0); build via pack.
+s = [0, 104, 105, 0].pack("C*")          # "\0hi\0"
+p s.strip.bytes
+p s.lstrip.bytes
+p s.rstrip.bytes
+mid = [0, 0, 104, 0, 105, 0].pack("C*")  # "\0\0h\0i\0" -- interior NUL survives
+p mid.strip.bytes
+# normal strings unchanged
+p "  hi  ".strip
+p "\tx\n".strip
+p "ab  ".rstrip
+p "  ab".lstrip