rubyduino 0.1.3 → 0.2.1

data/vendor/spinel/test/bundle_tiny_string.rb

@@ -0,0 +1,226 @@
+# Bundled tiny tests (auto-grouped by bundler):
+#   - empty_string_to_sym
+#   - str_each_line_chomp
+#   - str_lines_chomp
+#   - str_tr_empty_replacement
+#   - string_ascii_only
+#   - string_chomp_separator
+#   - string_codepoints
+#   - string_delete_multi_arg
+#   - string_gsub_empty_pat
+#   - string_range_splat
+#   - string_scan_capture
+#   - string_spaceship
+#   - string_squeeze_multi_arg
+#   - string_strip_nul
+#   - string_symbol_itself
+#   - string_tr_s
+#   - string_valid_encoding
+#   - string_with_nul_byte
+
+# === empty_string_to_sym ===
+def t_empty_string_to_sym
+# Empty-string interning: "".to_sym and the :"" literal must resolve to the
+# same symbol id (an empty symbol once broke the C build).
+p("".to_sym == :"")
+p(:"" == "".to_sym)
+p("abc".to_sym == :abc)
+p("".to_sym.to_s == "")
+end
+t_empty_string_to_sym
+
+# === str_each_line_chomp ===
+def t_str_each_line_chomp
+# String#each_line(chomp: true) strips trailing line endings.
+"a\nb\nc".each_line(chomp: true) { |l| p l }
+puts "---"
+"a\nb\nc".each_line { |l| p l }
+puts "---"
+"x\r\ny\r\n".each_line(chomp: true) { |l| p l }
+end
+t_str_each_line_chomp
+
+# === str_lines_chomp ===
+def t_str_lines_chomp
+# String#lines(chomp: true) strips line endings from each line.
+# Without the chomp: keyword, line endings are preserved.
+
+puts "a\nb\nc".lines(chomp: true).inspect
+puts "a\nb\nc".lines.inspect
+puts "a\r\nb\r\nc\r\n".lines(chomp: true).inspect
+end
+t_str_lines_chomp
+
+# === str_tr_empty_replacement ===
+def t_str_tr_empty_replacement
+# String#tr / tr_s with empty replacement string
+# When the to-string is empty, matched characters are deleted.
+
+puts "abc".tr("a", "").inspect
+puts "abcdef".tr("a-c", "").inspect
+puts "aabbbccc".tr_s("ab", "").inspect
+end
+t_str_tr_empty_replacement
+
+# === string_ascii_only ===
+def t_string_ascii_only
+# String#ascii_only? : true iff every byte is 7-bit ASCII.
+p "hello".ascii_only?
+p "héllo".ascii_only?
+p "".ascii_only?
+p "abc123!".ascii_only?
+p "あ".ascii_only?
+end
+t_string_ascii_only
+
+# === string_chomp_separator ===
+def t_string_chomp_separator
+# Issue #881: String#chomp with an explicit separator argument
+# strips that suffix. Without the fix the arg was silently dropped
+# and the default newline rules were applied.
+puts "hello!".chomp("!").inspect
+puts "hello\n".chomp.inspect
+puts "hello\r\n".chomp.inspect
+puts "hello".chomp("!").inspect
+puts "hello\n\n".chomp("").inspect
+end
+t_string_chomp_separator
+
+# === string_codepoints ===
+def t_string_codepoints
+# Issue #903: String#codepoints returns int_array of UTF-8
+# codepoints (not bytes).
+puts "hello".codepoints.inspect
+puts "あ".codepoints.inspect
+puts "".codepoints.inspect
+end
+t_string_codepoints
+
+# === string_delete_multi_arg ===
+def t_string_delete_multi_arg
+# String#delete with multiple args deletes the intersection of the
+# charsets (each arg is a charset spec).
+p "hello".delete("l", "o")
+p "hello".delete("lo", "l")
+p "hello".delete("l", "h", "e")
+p "hello".delete("el", "ello")
+p "hello".delete("l")
+p "hello".delete("^l")
+end
+t_string_delete_multi_arg
+
+# === string_gsub_empty_pat ===
+def t_string_gsub_empty_pat
+# Issue #850: String#gsub with empty pattern inserts the
+# replacement between every character (and at the start/end).
+# Pre-fix, empty pattern was a no-op.
+puts "hello".gsub("", "x")
+puts "abc".gsub("", "-")
+end
+t_string_gsub_empty_pat
+
+# === string_range_splat ===
+def t_string_range_splat
+# Splatting a string range into an array literal expands it into a
+# str_array (the runtime already has sp_StrArray_from_string_range; the
+# bug was the literal mis-typing to int_array and emitting a char*-in-
+# int-loop).
+p [*"a".."e"]
+p [*"a"..."d"]        # exclusive range drops the endpoint
+p [*"x".."z", "!"]    # splat-first, then a trailing literal
+p [*" ".."&"]         # the printable-ASCII idiom from the bug report
+end
+t_string_range_splat
+
+# === string_scan_capture ===
+def t_string_scan_capture
+# Issue #880: String#scan returns nested arrays for capture groups.
+
+puts "hello world".scan(/(\w+)/).inspect
+puts "a1 b22".scan(/([a-z]+)(\d+)/).inspect
+puts "hello world".scan(/\w+/).inspect
+puts "ab ac".scan(/a(?:b|c)/).inspect
+end
+t_string_scan_capture
+
+# === string_spaceship ===
+def t_string_spaceship
+# Issue #900: String#<=> dispatches strcmp clamped to -1/0/1.
+# Pre-fix: always returned 0.
+puts "abc" <=> "abd"
+puts "abd" <=> "abc"
+puts "abc" <=> "abc"
+puts "ab" <=> "abc"
+end
+t_string_spaceship
+
+# === string_squeeze_multi_arg ===
+def t_string_squeeze_multi_arg
+# String#squeeze with multiple args squeezes runs of chars in the
+# intersection of the charsets.
+p "aaabbbccc".squeeze("a", "b")
+p "aaabbbccc".squeeze("a", "ab")
+p "aaabbbccc".squeeze("abc")
+p "aaabbbccc".squeeze
+end
+t_string_squeeze_multi_arg
+
+# === string_strip_nul ===
+def t_string_strip_nul
+# String#strip / #lstrip / #rstrip remove the NUL byte along with ASCII
+# whitespace, matching CRuby.
+p "\0 abc \0".strip
+p "abc\0\0".rstrip
+p "\0\0abc".lstrip
+p "  \t\nx\r\f ".strip
+p "\0".strip
+p "no change".strip
+end
+t_string_strip_nul
+
+# === string_symbol_itself ===
+def t_string_symbol_itself
+# Kernel#itself on string and symbol returns self.
+puts "hello".itself
+puts :foo.itself.inspect
+end
+t_string_symbol_itself
+
+# === string_tr_s ===
+def t_string_tr_s
+# Issue #902: String#tr_s translates and squeezes adjacent
+# identical translated chars (untranslated runs keep their
+# duplicates).
+puts "hello".tr_s("l", "r")
+puts "aaabbbccc".tr_s("a", "x")
+# Without squeeze for comparison
+puts "hello".tr("l", "r")
+puts "aaabbb".tr_s("ab", "xy")
+end
+t_string_tr_s
+
+# === string_valid_encoding ===
+def t_string_valid_encoding
+# String#valid_encoding? — true for ASCII / well-formed UTF-8,
+# false for invalid byte sequences.
+puts "hello".valid_encoding?
+puts "".valid_encoding?
+puts "日本語".valid_encoding?
+puts "\xff\xff".valid_encoding?
+puts "abc\xc3\x28".valid_encoding?
+end
+t_string_valid_encoding
+
+# === string_with_nul_byte ===
+def t_string_with_nul_byte
+# Issue #722: a string literal with an embedded NUL byte reports
+# the full length, and .bytes iterates all bytes (not strlen-
+# truncated at the NUL). Pre-fix the parser AST text format also
+# truncated the field at the NUL.
+puts "hello\0world".length
+puts "hello\0world".bytes.length
+puts "a\0b\0c".length
+puts "\0\0\0".length
+end
+t_string_with_nul_byte
+

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

@@ -0,0 +1,78 @@
+true
+true
+true
+true
+"a"
+"b"
+"c"
+---
+"a\n"
+"b\n"
+"c"
+---
+"x"
+"y"
+["a", "b", "c"]
+["a\n", "b\n", "c"]
+["a", "b", "c"]
+"bc"
+"def"
+"ccc"
+true
+false
+true
+true
+false
+"hello"
+"hello"
+"hello"
+"hello"
+"hello"
+[104, 101, 108, 108, 111]
+[12354]
+[]
+"hello"
+"heo"
+"hello"
+"ho"
+"heo"
+"ll"
+xhxexlxlxox
+-a-b-c-
+["a", "b", "c", "d", "e"]
+["a", "b", "c"]
+["x", "y", "z", "!"]
+[" ", "!", "\"", "#", "$", "%", "&"]
+[["hello"], ["world"]]
+[["a", "1"], ["b", "22"]]
+["hello", "world"]
+["ab", "ac"]
+-1
+1
+0
+-1
+"aaabbbccc"
+"abbbccc"
+"abc"
+"abc"
+"abc"
+"abc"
+"abc"
+"x"
+""
+"no change"
+hello
+:foo
+hero
+xbbbccc
+herro
+xy
+true
+true
+true
+false
+false
+11
+11
+5
+3

data/vendor/spinel/test/captured_block_call_value.rb

@@ -0,0 +1,45 @@
+# A nested proc literal can capture an enclosing method's &block (an
+# sp_Proc param) and call it, and the value flows back at the block's
+# real type. Covers the value carried through the proc-var indirection
+# (`p = proc { blk.call }; p.call`) for int / string / argument blocks,
+# at top level and inside an instance method.
+
+# top-level, int block
+def f_int(&blk)
+  p = proc { blk.call }
+  p.call
+end
+puts f_int { 7 }
+
+# top-level, string block: the value rides the int slot and reads back
+# as a string (typed through the p.call -> blk.call indirection).
+def f_str(&blk)
+  p = proc { blk.call }
+  p.call
+end
+puts f_str { "hi" }
+
+# top-level, block with an argument
+def f_arg(&blk)
+  p = proc { blk.call(10) }
+  p.call
+end
+puts f_arg { |x| x + 5 }
+
+# a plain proc local inside an instance method (no &block) is typed proc
+class Box
+  def make
+    p = proc { 42 }
+    p.call
+  end
+end
+puts Box.new.make
+
+# instance method capturing its &block through a proc local, string block
+class Runner
+  def run(&blk)
+    p = proc { blk.call }
+    p.call
+  end
+end
+puts Runner.new.run { "inst" }

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

@@ -0,0 +1,5 @@
+7
+hi
+15
+42
+inst

data/vendor/spinel/test/case_fallthrough_returns_nil.expected

@@ -0,0 +1,5 @@
+nil
+"one"
+nil
+42
+other

data/vendor/spinel/test/case_fallthrough_returns_nil.rb

@@ -0,0 +1,8 @@
+# Issue #707: case without `else` returns nil on fallthrough.
+puts (case 99; when 1; "one"; end).inspect
+puts (case 1; when 1; "one"; end).inspect
+puts (case "x"; when "a"; 42; end).inspect
+puts (case "a"; when "a"; 42; end).inspect
+
+# With else clause - unchanged behavior.
+puts (case 99; when 1; "one"; else; "other"; end)

data/vendor/spinel/test/case_in_no_match_error.rb

@@ -0,0 +1,54 @@
+begin
+  case 5
+  in 3
+    puts "three"
+  in 4
+    puts "four"
+  end
+rescue NoMatchingPatternError => e
+  puts "caught int miss"
+end
+
+# Match still works
+case 5
+in 3
+  puts "three"
+in 5
+  puts "matched five"
+end
+
+# With else: no raise
+case 99
+in 1
+  puts "one"
+else
+  puts "else clause"
+end
+
+# String scrutinee
+begin
+  case "x"
+  in "y"
+  end
+rescue NoMatchingPatternError => e
+  puts "caught str miss"
+end
+
+# Symbol scrutinee
+begin
+  case :foo
+  in :bar
+  end
+rescue NoMatchingPatternError => e
+  puts "caught sym miss"
+end
+
+# StandardError parent catches NoMatchingPatternError
+begin
+  case 7
+  in 1
+  in 2
+  end
+rescue StandardError => e
+  puts "caught via parent"
+end

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

@@ -0,0 +1,6 @@
+caught int miss
+matched five
+else clause
+caught str miss
+caught sym miss
+caught via parent

data/vendor/spinel/test/case_local_in_lambda.rb

@@ -0,0 +1,57 @@
+# A local assigned inside a `case`/`when` branch of a lambda/proc
+# body must be declared in the proc's emitted C function. The proc
+# capture scanner walked `if`/`while` branches but not `case` arms
+# (they hang off @nd_conditions), so a branch-only local was never
+# classified — neither captured nor declared — and the lambda's C
+# function referenced an undeclared `lv_<name>`. Plain method and
+# `.each {}` bodies were unaffected.
+
+# 1. case-branch local, read after the branch.
+f = lambda do |t|
+  case t
+  when :a
+    x = 10
+    x + 1
+  end
+end
+puts f.call(:a)                   #=> 11
+
+# 2. proc form, same shape.
+g = proc do |t|
+  case t
+  when :b
+    y = 20
+    y * 2
+  end
+end
+puts g.call(:b)                   #=> 40
+
+# 3. Closure mutation inside a case branch updates the captured
+#    outer variable (not a shadowing proc-local).
+acc = 0
+h = lambda do |t|
+  case t
+  when :a
+    acc = acc + 10
+  when :b
+    acc = acc + 100
+  end
+  acc
+end
+h.call(:a)
+h.call(:b)
+puts acc                          #=> 110
+
+# 4. if-branch local in a lambda (the already-working sibling path,
+#    kept as a guard).
+k = lambda do |n|
+  if n > 0
+    m = n * 3
+    m + 1
+  else
+    0
+  end
+end
+puts k.call(4)                    #=> 13
+
+puts "done"

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

@@ -0,0 +1,5 @@
+11
+40
+110
+13
+done

data/vendor/spinel/test/case_when_class.rb

@@ -1,70 +1,32 @@
-# Issue #67: `case obj when SomeClass` lowered the predicate to an
-# `mrb_int` and then compared it against the bare class identifier
-# (`Var`, `List`), which weren't declared in C. Two pieces:
+# Issue #404 Phase 3 Tier 4 follow-up: `case obj when ClassConst`
+# on a poly receiver. Pre-Tier-4 the lowering left ConstantReadNode
+# arms unimplemented for poly recv (literal cascade only handled
+# sym/str/int/float/nil/bool). Module#=== is equivalent to
+# `arg.is_a?(recv)`, so we route through sp_class_le over
+# sp_class_for_poly and the precomputed ancestors.
 #
-# - The case-temp now keeps the predicate's pointer type
-#   (`sp_<Cls> *`) so the value is comparable as-is.
-# - `compile_when_conds` resolves `when ClassName` against an
-#   obj-typed predicate at compile time using
-#   `is_class_or_ancestor` — same-class or ancestor matches; an
-#   unrelated when-class folds to a literal `0`. Nullable predicate
-#   types (`obj_<Cls>?`) match only when the value is non-NULL.
-#
-# Subclass matching against a parent-typed predicate (where the
-# instance is actually a child class) needs a runtime cls_id check
-# and stays out of scope here.
-
-class Var; end
-class List; end
-
-# Statement form — the issue's exact reproducer.
-node = Var.new
-case node
-when Var
-  puts "var"
-when List
-  puts "list"
-end
-# => var
+# Coverage:
+#   - Class match against a poly recv carrying primitives.
+#   - Multiple primitive class arms in one case.
+#   - else clause.
 
-# Statement form, the other arm wins.
-items = List.new
-case items
-when Var
-  puts "var2"
-when List
-  puts "list2"
+def describe(v)
+  case v
+  when Integer
+    "int"
+  when String
+    "string"
+  when Float
+    "float"
+  when Symbol
+    "symbol"
+  else
+    "other"
+  end
 end
-# => list2
 
-# Expression form — same dispatch, value-returning.
-n = Var.new
-label = case n
-        when Var  then "v"
-        when List then "l"
-        else            "?"
-        end
-puts label
-# => v
-
-# Else clause when no when arm matches.
-class Other; end
-class Sentinel; end
-o = Other.new
-case o
-when Var      then puts "x"
-when List     then puts "y"
-when Sentinel then puts "z"
-else               puts "default"
-end
-# => default
-
-# Inheritance: when arm names an ancestor of the predicate's class.
-class Animal; end
-class Dog < Animal; end
-d = Dog.new
-case d
-when Animal then puts "ancestor"
-else             puts "else"
-end
-# => ancestor
+puts describe(42)
+puts describe("hello")
+puts describe(3.14)
+puts describe(:sym)
+puts describe(nil)

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

@@ -1,5 +1,5 @@
-var
-list2
-v
-default
-ancestor
+int
+string
+float
+symbol
+other

data/vendor/spinel/test/case_when_class_scalar_predicate.rb

@@ -0,0 +1,53 @@
+# `case <scalar> when ClassConst` previously compiled the
+# class-constant when-arm into a strcmp against the sp_Class
+# struct, failing C compile with "incompatible type for argument
+# 2 of strcmp". The same shape applied to int / float / symbol /
+# bool predicates would have compared the predicate's value
+# against an sp_Class struct. Fix: at compile_when_conds, when
+# the when-arg is a ConstantReadNode naming a built-in class,
+# resolve via Module#=== — match only when the class corresponds
+# to the predicate's kind (Integer / Float for numeric, String
+# for string, Symbol for symbol, TrueClass / FalseClass for
+# bool). Anything else is a static false.
+
+class Box
+  attr_accessor :v
+  def initialize; @v = nil; end
+  def setstr(s); @v = s; end
+end
+
+def classify(b)
+  v = b.v
+  case v
+  when String
+    "string"
+  else
+    "other"
+  end
+end
+
+b1 = Box.new
+b1.setstr("hello")
+puts classify(b1)
+
+# int predicate + class consts
+n = 42
+case n
+when Integer
+  puts "int-matched"
+when String
+  puts "wrong"
+else
+  puts "no"
+end
+
+# sym predicate + class consts
+s = :hello
+case s
+when Symbol
+  puts "sym-matched"
+when String
+  puts "wrong-sym"
+else
+  puts "no-sym"
+end

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

@@ -0,0 +1,3 @@
+string
+int-matched
+sym-matched