rubyduino 0.1.3 → 0.2.1

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

@@ -0,0 +1,8 @@
+2
+4
+0
+13
+7
+10
+18
+2

data/vendor/spinel/test/sprintf_long_interp.rb

@@ -0,0 +1,23 @@
+# sp_sprintf truncated string-interpolation results to 4095 bytes.
+#
+# Every Ruby string interpolation ("...#{x}...") compiles to
+# sp_sprintf (see compile_interpolated in spinel_codegen.rb), which
+# formatted into a fixed `char _sp_tmp[4096]` stack buffer and then
+# clamped the result length to sizeof(buf)-1 -- silently dropping
+# everything past 4095 bytes. vsnprintf already returns the would-be
+# length, so the fix re-renders into a correctly-sized heap buffer for
+# the overflow case (the common <4096 path keeps the stack temp +
+# memcpy fast path).
+#
+# Surfaced in roundhouse view emit: a lowering that coalesces
+# `io << a; io << b; io << c` append runs into a single
+# `io << "...#{}..."` produced interpolations larger than 4096 bytes,
+# which truncated rendered HTML pages mid-content.
+
+big = "A" * 5000
+out = "[#{big}]"
+# Full length must survive, and both ends must be intact (a mid-string
+# clamp would keep the head but drop the closing bracket).
+puts out.length
+puts out[0, 1]
+puts out[out.length - 1, 1]

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

@@ -0,0 +1,3 @@
+5002
+[
+]

data/vendor/spinel/test/stdlib_class_in_ivar.rb

@@ -0,0 +1,85 @@
+# A stdlib class with no Spinel struct (Mutex, Pathname, OpenStruct,
+# IPAddr, ...) stored in an instance variable previously made analyze
+# type the ivar `obj_<Class>` and codegen emit an undeclared
+# `sp_<Class> *` field, failing the C build with `unknown type name`.
+#
+# Fix: when a constructor's target class has no struct (not a
+# user-defined class), type the slot as int — codegen already lowers
+# the unresolved `.new` to integer 0 — so the field compiles. The
+# stdlib object itself is inert (its methods stay unresolved), so the
+# assertions below only observe ivars that don't depend on it.
+require 'thread'
+require 'pathname'
+require 'ostruct'
+require 'ipaddr'
+
+class WithMutex
+  def initialize
+    @lock = Mutex.new
+    @n = 5
+  end
+  def n
+    @n
+  end
+end
+
+class WithPathname
+  def initialize
+    @path = Pathname.new('/tmp')
+    @v = 7
+  end
+  def v
+    @v
+  end
+end
+
+class WithOpenStruct
+  def initialize
+    @os = OpenStruct.new(a: 1)
+    @w = 9
+  end
+  def w
+    @w
+  end
+end
+
+class WithIPAddr
+  def initialize
+    @ip = IPAddr.new('1.2.3.4')
+    @z = 11
+  end
+  def z
+    @z
+  end
+end
+
+puts WithMutex.new.n          #=> 5
+puts WithPathname.new.v       #=> 7
+puts WithOpenStruct.new.w     #=> 9
+puts WithIPAddr.new.z         #=> 11
+
+# Local (not ivar) constructor of an unresolved class also compiles.
+local_obj = Mutex.new
+puts "local ok"
+
+# A user-defined class is unaffected — it keeps its obj_<Class> slot.
+class Point
+  def initialize(x)
+    @x = x
+  end
+  def x
+    @x
+  end
+end
+
+class Holder
+  def initialize
+    @p = Point.new(42)
+  end
+  def px
+    @p.x
+  end
+end
+
+puts Holder.new.px            #=> 42
+puts "done"

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

@@ -0,0 +1,7 @@
+5
+7
+9
+11
+local ok
+42
+done

data/vendor/spinel/test/str_array_max_min_by.rb

@@ -0,0 +1,6 @@
+# Issue #863: max_by / min_by on String arrays return the element,
+# not the score (and not 0).
+puts ["hello", "hi", "goodbye"].max_by { |s| s.length }
+puts ["hello", "hi", "goodbye"].min_by { |s| s.length }
+# Negation flips the ordering.
+puts ["a", "bb", "ccc"].max_by { |s| -s.length }

data/vendor/spinel/test/str_array_sort_by.rb

@@ -0,0 +1,11 @@
+# sort_by on str_array previously bombed at C compile time:
+# `cannot resolve call to 'sort_by' on str_array`, then the
+# pointer slot got assigned (mrb_int)0. Explicit block and the
+# `&:length` / `&:bytesize` / `&:to_i` symbol-to-proc shortcuts
+# are now handled.
+puts ["bb", "a", "ccc"].sort_by(&:length).inspect
+puts ["bb", "a", "ccc"].sort_by { |s| s.length }.inspect
+puts ["10", "1", "100"].sort_by(&:to_i).inspect
+puts ["zzz", "a", "bb"].sort_by { |s| s.length }.inspect
+# Equal-key elements keep their original order (bubble sort is stable).
+puts ["bb", "a", "cc"].sort_by(&:length).inspect

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

@@ -0,0 +1,5 @@
+["a", "bb", "ccc"]
+["a", "bb", "ccc"]
+["1", "10", "100"]
+["a", "bb", "zzz"]
+["a", "bb", "cc"]

data/vendor/spinel/test/str_chomp_paragraph_mode.rb

@@ -0,0 +1,16 @@
+# String#chomp edge cases: no-arg strips ONE separator,
+# paragraph mode (chomp("")) strips trailing \r\n/\n sequences
+# but not standalone \r.
+
+# No-arg chomp: one separator
+puts "hello\r\n".chomp.inspect
+puts "hello\n".chomp.inspect
+puts "hello\r".chomp.inspect
+puts "hello\r\n\r\n".chomp.inspect
+puts "hello".chomp.inspect
+
+# Paragraph mode
+puts "hello\r\n".chomp("").inspect
+puts "hello\n".chomp("").inspect
+puts "hello\r".chomp("").inspect
+puts "hello\r\n\r\n".chomp("").inspect

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

@@ -0,0 +1,9 @@
+"hello"
+"hello"
+"hello"
+"hello\r\n"
+"hello"
+"hello"
+"hello"
+"hello\r"
+"hello"

data/vendor/spinel/test/str_count_multi_arg.rb

@@ -0,0 +1,11 @@
+# String#count with multiple args computes intersection of charsets
+# Each additional arg further restricts which chars to count.
+
+# single arg
+puts "hello world".count("lo")
+# two args (intersection of "lo" and "o" = just "o")
+puts "hello world".count("lo", "o")
+# two args with no intersection
+puts "hello world".count("l", "o")
+# two args with negation
+puts "hello world".count("^l", "lo")

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

@@ -0,0 +1,4 @@
+5
+2
+0
+2

data/vendor/spinel/test/str_delete_count_negation.rb

@@ -0,0 +1,16 @@
+# String#delete and String#count with ^-negated charset
+# ^ at the start inverts the charset meaning.
+
+# delete: normal charset
+puts "hello".delete("l").inspect
+# delete: negated charset
+puts "hello".delete("^l").inspect
+
+# count: normal charset
+puts "hello".count("l")
+# count: negated charset
+puts "hello".count("^l")
+
+# a lone "^" is the literal caret, not negation
+puts "a^b^c".delete("^").inspect
+puts "a^b^c".count("^")

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

@@ -0,0 +1,6 @@
+"heo"
+"ll"
+2
+3
+"abc"
+2

data/vendor/spinel/test/str_force_encoding_return.rb

@@ -0,0 +1,26 @@
+# `def f(s); s.force_encoding(...); end` whose body's last
+# expression is `force_encoding` (a receiver passthrough at codegen)
+# previously had its return type inferred as mrb_int — the function
+# signature returned mrb_int while the body returned a const char *.
+#
+# Codegen already lowers force_encoding (and encode / b) as a
+# receiver passthrough at line 13953; the analyze side just had no
+# matching infer_call_type arm, so the call's static type fell back
+# to "int". Add force_encoding / encode / b to infer_call_type's
+# string-recv arm so the return type carries through.
+
+def normalize(s)
+  s.force_encoding("UTF-8")
+end
+
+def utf8_to_bin(s)
+  s.encode("ASCII-8BIT")
+end
+
+def to_binary(s)
+  s.b
+end
+
+puts normalize("hello")
+puts utf8_to_bin("world")
+puts to_binary("bytes")

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

@@ -0,0 +1,3 @@
+hello
+world
+bytes

data/vendor/spinel/test/str_int_hash_missing_key_nil.rb

@@ -0,0 +1,16 @@
+h = {"a" => 1, "b" => 2}
+# Missing-key reads are value-level nil (#801).
+p h["miss"]
+p h["miss"].nil?
+p h["miss"].inspect
+p(h["miss"] || 42)
+# Stored in a local, then observed (the case the consumption-site rewrites miss).
+v = h["miss"]
+p v.nil?
+p(v || 7)
+# Present keys are unaffected.
+p h["a"]
+p h["a"].nil?
+p(h["a"] + 1)
+w = h["b"]
+p(w + 10)

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

@@ -0,0 +1,10 @@
+nil
+true
+"nil"
+42
+true
+7
+1
+false
+2
+12

data/vendor/spinel/test/str_match_position.rb

@@ -0,0 +1,15 @@
+# String#match and String#match? with position argument
+# The position is a codepoint index (not byte offset) that limits
+# where the regex search starts.
+
+# match? with position
+puts "hello".match?(/h/, 1)
+puts "hello".match?(/e/, 1)
+puts "hello".match?(/o/, -1)
+puts "hello".match?(/h/, 0)
+puts "hello".match?(/z/, 0)
+
+# match with position
+r = "hello".match(/h/, 1); puts r == nil ? "nil" : r[0]
+r = "hello".match(/e/, 1); puts r == nil ? "nil" : r[0]
+r = "hello".match(/o/, -1); puts r == nil ? "nil" : r[0]

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

@@ -0,0 +1,8 @@
+false
+true
+true
+true
+false
+nil
+e
+o

data/vendor/spinel/test/str_method_nil_arg_no_segv.rb

@@ -0,0 +1,47 @@
+# #504. Several String methods receiving the wrong arg shape used
+# to SEGV. CRuby raises ArgumentError; spinel can't raise but we
+# should at least not crash. Codegen emits compile_arg0 -> "0"
+# (NULL) for missing args and the runtime helpers then ran
+# strlen(NULL) or worse.
+#
+# Fix: NULL guards in sp_str_count / sp_str_delete /
+# sp_str_rindex / sp_str_concat; setbyte (which would have
+# written through a read-only string literal) is now warned and
+# returns 0 without mutating; rindex with a regex arg routes
+# through the new sp_re_rindex helper instead of the plain
+# string-substring path; `<<` on a string return-types as
+# `string` instead of falling through to the catch-all `int`.
+
+# count / rindex / include? / start_with? / end_with? with no arg
+# (NULL at C level): spinel now raises TypeError, matching CRuby's
+# nil-arg path more closely than the old silent sentinel return.
+begin
+  "foo".count
+  puts "BUG count: no raise"
+rescue TypeError => e
+  puts "count: #{e.message}"
+end
+p "foo".delete   # CRuby: ArgumentError. spinel: "foo" unchanged (was: SEGV)
+p "foo".rindex(/missing/)  # CRuby + spinel post-#532: nil. (was: -1)
+p "abcdabcd".rindex(/c/)   # CRuby & spinel: 6 (new sp_re_rindex helper)
+begin
+  "foo".send(:<<)          # CRuby: ArgumentError. spinel: FrozenError (after #886)
+  puts "no raise"
+rescue FrozenError => e
+  puts "send-lshift: " + e.message
+end
+
+# setbyte on a literal: spinel adopts frozen-string-literal: true
+# semantics globally, so literals raise FrozenError on mutation.
+# Heap-allocated strings (via .dup, +, etc.) mutate as usual.
+# Test pins both behaviors: literal -> raise, dup -> mutate.
+(str = "a")
+begin
+  str.setbyte(0, 98)
+  puts "literal not frozen: " + str
+rescue FrozenError => e
+  puts "frozen literal: " + e.message
+end
+str2 = "a".dup
+str2.setbyte(0, 98)
+puts str2  # "b" (heap, mutates)

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

@@ -0,0 +1,7 @@
+count: no implicit conversion of nil into String
+"foo"
+nil
+6
+send-lshift: can't modify frozen String
+frozen literal: can't modify frozen String
+b

data/vendor/spinel/test/str_oct_prefix.rb

@@ -0,0 +1,11 @@
+# String#oct with prefix auto-detection.
+# CRuby's oct handles 0x (hex), 0b (binary), 0o (explicit octal),
+# 0 (implicit octal), and bare digits (base 8). Previously spinel
+# used strtoll(base=8) unconditionally, so "0xff".oct returned 0
+# instead of 255.
+
+p "0xff".oct      # hex prefix: 255
+p "0b101".oct     # binary prefix: 5
+p "0o77".oct      # explicit octal: 63
+p "77".oct        # bare digits base-8: 63
+p "010".oct       # implicit octal: 8

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

@@ -0,0 +1,5 @@
+255
+5
+63
+63
+8

data/vendor/spinel/test/str_ord_empty.rb

@@ -0,0 +1,11 @@
+# String#ord on empty string should raise ArgumentError, not return 0.
+begin
+  "".ord
+  puts "BUG: no raise"
+rescue ArgumentError => e
+  puts "ArgumentError: " + e.message
+end
+
+# Normal ord still works
+p "A".ord
+p "a".ord

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

@@ -0,0 +1,3 @@
+ArgumentError: empty string
+65
+97

data/vendor/spinel/test/str_poly_hash_dup_widen.rb

@@ -0,0 +1,21 @@
+# A local declared `sp_StrPolyHash *` (because later poly-value writes
+# force the wider variant) initialized from `<str_str_hash>.dup`
+# previously emitted a raw `lv = sp_StrStrHash_dup(...)` assignment.
+# The two structs have different `vals[]` element types
+# (`const char **` vs `sp_RbVal *`), so subsequent reads through the
+# widened slot returned garbage (0 / nil) even when -Werror was off.
+# The prior `.length`-only assertion happened to land at an offset
+# both structs share. Issue #614.
+
+class Match
+  attr_reader :path_params
+  def initialize(pp); @path_params = pp; end
+end
+
+m = Match.new({ "article_id" => "1", "format" => "html" })
+merged = m.path_params.dup
+merged["x"] = 1        # int value forces analyzer-side widening to str_poly_hash
+puts merged["article_id"]   # round-trips the original str value
+puts merged["format"]
+puts merged["x"]
+puts merged.length

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

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

data/vendor/spinel/test/str_poly_hash_dup_widen_from_int.rb

@@ -0,0 +1,17 @@
+# Sibling case to str_poly_hash_dup_widen: the narrower-source variant
+# is `sp_StrIntHash *` (int values). The fix wraps the `.dup` call
+# with `sp_StrPolyHash_from_str_int_hash` so the slot's
+# `sp_RbVal` reads round-trip the original int as a boxed int.
+# Issue #614.
+
+class Counter
+  attr_reader :counts
+  def initialize(h); @counts = h; end
+end
+
+c = Counter.new({ "a" => 1, "b" => 2 })
+merged = c.counts.dup
+merged["x"] = "label"   # str value forces analyzer-side widening
+puts merged["a"]
+puts merged["b"]
+puts merged["x"]

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

@@ -0,0 +1,3 @@
+1
+2
+label

data/vendor/spinel/test/str_rindex_position.rb

@@ -0,0 +1,23 @@
+# String#rindex with position argument
+# The position limits the search to codepoint index <= pos.
+# Negative pos counts from end: effective = cl + pos.
+
+r = "hello".rindex("l", 2); puts r == nil ? "nil" : r
+r = "hello".rindex("l", 3); puts r == nil ? "nil" : r
+r = "hello".rindex("l"); puts r == nil ? "nil" : r
+r = "hello".rindex("h", 0); puts r == nil ? "nil" : r
+r = "hello".rindex("h", 1); puts r == nil ? "nil" : r
+r = "hello".rindex("x", 2); puts r == nil ? "nil" : r
+r = "hello".rindex("l", 10); puts r == nil ? "nil" : r
+# negative position
+r = "hello".rindex("l", -1); puts r == nil ? "nil" : r
+r = "hello".rindex("l", -2); puts r == nil ? "nil" : r
+r = "hello".rindex("l", -3); puts r == nil ? "nil" : r
+r = "hello".rindex("l", -4); puts r == nil ? "nil" : r
+r = "hello".rindex("l", -6); puts r == nil ? "nil" : r
+# empty substring
+r = "hello".rindex(""); puts r == nil ? "nil" : r
+r = "hello".rindex("", 3); puts r == nil ? "nil" : r
+r = "hello".rindex("", 10); puts r == nil ? "nil" : r
+r = "hello".rindex("", -1); puts r == nil ? "nil" : r
+r = "hello".rindex("", -6); puts r == nil ? "nil" : r

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

@@ -0,0 +1,17 @@
+2
+3
+3
+0
+0
+nil
+3
+3
+3
+2
+nil
+nil
+5
+3
+5
+4
+nil

data/vendor/spinel/test/str_split_space_whitespace.rb

@@ -0,0 +1,10 @@
+# String#split(" ") is whitespace-split mode (CRuby special case)
+# Strips leading whitespace, collapses consecutive whitespace.
+
+# split(" ") is whitespace mode
+puts "  hello  world  ".split(" ").inspect
+puts "a  b".split(" ").inspect
+# no-arg split is also whitespace mode
+puts "  hello  world  ".split.inspect
+# split(",") is literal mode (preserves empty fields)
+puts "a,,b".split(",").inspect

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

@@ -0,0 +1,4 @@
+["hello", "world"]
+["a", "b"]
+["hello", "world"]
+["a", "", "b"]

data/vendor/spinel/test/str_split_trailing_empty.rb

@@ -0,0 +1,12 @@
+# String#split without limit drops trailing empty strings
+# String#split(sep, -1) keeps them (CRuby default vs no-limit behavior).
+# String#split(sep, 0) is "no limit" and drops trailing empties too;
+# only a negative limit keeps them.
+
+puts "a,b,c,".split(",").inspect
+puts "a,b,c,,,".split(",").inspect
+puts "a,b,c".split(",").inspect
+puts "a,b,c,".split(",", -1).inspect
+puts "a,b,c,".split(",", 0).inspect
+puts "a,b,c,,".split(",", 0).inspect
+puts "a,b,c,".split(",", 2).inspect

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

@@ -0,0 +1,7 @@
+["a", "b", "c"]
+["a", "b", "c"]
+["a", "b", "c"]
+["a", "b", "c", ""]
+["a", "b", "c"]
+["a", "b", "c"]
+["a", "b,c,"]

data/vendor/spinel/test/str_squeeze_arg.rb

@@ -0,0 +1,18 @@
+# String#squeeze with charset argument
+# The argument restricts which characters get squeezed.
+# "a" squeezes only 'a', "^a" squeezes everything except 'a'.
+
+# no-arg squeeze (all consecutive)
+puts "aaabbbccc".squeeze.inspect
+# single char
+puts "aaabbbccc".squeeze("a").inspect
+# multiple chars
+puts "aaabbbccc".squeeze("ab").inspect
+# range
+puts "aaabbbccc".squeeze("a-c").inspect
+# negated set
+puts "aaabbbccc".squeeze("^a").inspect
+# no change case
+puts "abc".squeeze("a").inspect
+# a lone "^" is the literal caret, not a negation
+puts "aaa^^^bbb".squeeze("^").inspect

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

@@ -0,0 +1,7 @@
+"abc"
+"abbbccc"
+"abccc"
+"abc"
+"aaabc"
+"abc"
+"aaa^bbb"

data/vendor/spinel/test/str_str_hash_nullable_bracket_assign.rb

@@ -0,0 +1,39 @@
+# Silent-elision regression: `<str_str_hash?>[k] = v` previously
+# fell through every arm of compile_bracket_assign with no emit, so
+# the assignment vanished. The two missing entry points were the
+# `str_str_hash` / `str_int_hash` base arms (mirror of the existing
+# `sym_*_hash` / `int_str_hash` arms), plus the nullable-pointer
+# strip at the top so `str_str_hash?` reaches the same emit.
+# Issue #610: roundhouse's `dispatch_request` builds a merged
+# str_str_hash from a path-params dup (typed str_str_hash? because
+# the source ivar is nullable) and then writes into it inside a
+# `.each` block; pre-fix the entire merge loop body disappeared.
+
+class HashHolder
+  def initialize
+    @h = nil
+  end
+
+  attr_accessor :h
+end
+
+def fill(holder)
+  # Force the slot's static type to `str_str_hash?` by routing the
+  # initial value through a method that returns the nullable shape.
+  holder.h = path_params
+  holder.h["c"] = "3"
+  holder.h["d"] = "4"
+end
+
+def path_params
+  { "a" => "1", "b" => "2" }
+end
+
+hh = HashHolder.new
+fill(hh)
+m = hh.h
+puts m["a"]   # 1
+puts m["b"]   # 2
+puts m["c"]   # 3
+puts m["d"]   # 4
+puts m.length # 4

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

@@ -0,0 +1,5 @@
+1
+2
+3
+4
+4

data/vendor/spinel/test/str_to_i_overflow.rb

@@ -0,0 +1,32 @@
+# String#to_i overflow handling. Pre-fix: undefined behavior on
+# int64 wrap (#743) — addressed by overflow-detected saturation.
+# Per #842 the saturate path is gone; overflow now raises
+# RangeError so a `rescue` can react instead of silently
+# returning INT64_MAX/MIN.
+
+# Below int64 limit: unchanged.
+puts "12345".to_i
+puts "-67890".to_i
+
+# At/over int64 max: raises RangeError.
+begin
+  puts "99999999999999999999999999999".to_i
+rescue RangeError
+  puts "raised"
+end
+
+begin
+  puts "-99999999999999999999999999999".to_i
+rescue RangeError
+  puts "raised"
+end
+
+# Exactly INT64_MAX: parses fine, no raise.
+puts "9_223_372_036_854_775_807".to_i
+
+# One past INT64_MAX: raises.
+begin
+  puts "9_223_372_036_854_775_808".to_i
+rescue RangeError
+  puts "raised"
+end