rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/regexp_gsub_zero_width.rb

@@ -0,0 +1,27 @@
+# gsub with a zero-width match (anchors, empty pattern, word boundary,
+# zero-repeat quantifier) must insert the replacement at each match
+# position, keep the source character there, and advance by one -- not
+# drop the character, spin forever, or run the tail copy with an
+# underflowed length (which previously corrupted the heap / crashed).
+p "abc".gsub(/$/, "!")
+p "x\ny".gsub(/$/, "!")
+p "x\ny\nz".gsub(/$/, "!")
+p "a\nb".gsub(/^/, ">")
+p "hello".gsub(//, "-")
+p "abc".gsub(/b*/, "X")
+p "hello world".gsub(/\b/, "|")
+p "abc".sub(/$/, "!")
+
+# The each_line + $-anchored capture build, which surfaced the bug.
+table = {}
+"Name Ada\nLang Ruby\nYear 1995".each_line do |line|
+  if (m = line.match(/^(\w+) (.+)$/))
+    table[m[1]] = m[2]
+  end
+end
+p table.keys
+p table["Lang"]
+
+# Lengths are correct (metadata, not just strlen).
+p "x\ny".gsub(/$/, "!").length
+p "hello".gsub(//, "-").length

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

@@ -0,0 +1,12 @@
+"abc!"
+"x!\ny!"
+"x!\ny!\nz!"
+">a\n>b"
+"-h-e-l-l-o-"
+"XaXXcX"
+"|hello| |world|"
+"abc!"
+["Name", "Lang", "Year"]
+"Ruby"
+5
+11

data/vendor/spinel/test/regexp_last_match_capture.rb

@@ -0,0 +1,21 @@
+# Regexp.last_match(n) returns the n-th capture group of the most
+# recent match (n==0 is the whole match), or nil when the group is
+# out of range / didn't participate. Before, the call resolved to the
+# NoMethodError gate and emitted 0.
+
+"johndoe@example.com".match(/(\w+)@(\w+)/)
+puts Regexp.last_match(0)   # whole match
+puts Regexp.last_match(1)   # first group
+puts Regexp.last_match(2)   # second group
+
+# Variable index
+i = 1
+puts Regexp.last_match(i)
+
+# Out-of-range group -> nil
+p Regexp.last_match(7)
+
+# A group that didn't participate -> nil
+"abc".match(/(x)|(abc)/)
+p Regexp.last_match(1)
+puts Regexp.last_match(2)

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

@@ -0,0 +1,7 @@
+johndoe@example
+johndoe
+example
+johndoe
+nil
+nil
+abc

data/vendor/spinel/test/regexp_line_anchors.rb

@@ -0,0 +1,34 @@
+# Ruby's ^ and $ are always line-anchored, independent of the /m flag
+# (which in Ruby only makes `.` match newlines). ^ matches at the start
+# of the string and after any newline; $ matches at the end and before
+# any newline. \A / \z / \Z are the absolute-boundary anchors.
+
+# $ matches before a trailing newline (the each_line + capture pattern).
+m = "FontName Times\n".match(/^(\w+) (.+)$/)
+p m[1]
+p m[2]
+
+# ^ and $ at interior line boundaries.
+p "a\nb\nc".scan(/^\w/)
+p "a\nb\nc".scan(/\w$/)
+p "foo 1\nbar 2".scan(/^(\w+) (\d+)$/)
+
+# Building a lookup table from "key value\n" lines with a $-anchored regex.
+table = {}
+"Name Ada\nLang Ruby\nYear 1995".each_line do |line|
+  if (m = line.match(/^(\w+) (.+)$/))
+    table[m[1]] = m[2]
+  end
+end
+p table.keys
+p table["Name"]
+p table["Lang"]
+p table["Year"]
+
+# Absolute anchors are NOT line-anchored.
+p "abc\n".match?(/c$/)
+p "abc".match?(/b$/)
+p "a\nb".match?(/\Ab/)
+p "a\n".match?(/a\z/)
+p "a\n".match?(/a\Z/)
+p "a".match?(/a\z/)

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

@@ -0,0 +1,15 @@
+"FontName"
+"Times"
+["a", "b", "c"]
+["a", "b", "c"]
+[["foo", "1"], ["bar", "2"]]
+["Name", "Lang", "Year"]
+"Ada"
+"Ruby"
+"1995"
+true
+false
+false
+false
+true
+true

data/vendor/spinel/test/regexp_local_if_else_union.rb

@@ -0,0 +1,36 @@
+# An if/else expression whose branches both build a Regexp now
+# unifies to the new `regexp` type (mrb_regexp_pattern *) instead
+# of collapsing to int. Before this fix Regexp.new(...) was
+# untyped (default int fallback), the if/else result was int, and
+# the resulting `pattern.match?(...)` call had no statically
+# resolvable pattern to thread through — the codegen warned
+# "cannot resolve call to 'match?' on int (emitting 0)" and the
+# binary always reported no match. Issue #609.
+
+def check(use_a)
+  pattern = if use_a
+              Regexp.new("aaa")
+            else
+              Regexp.new("bbb")
+            end
+  puts pattern.match?("xaaay") ? "match" : "no match"
+end
+
+check(true)    # match    (uses /aaa/)
+check(false)   # no match (uses /bbb/, body has no "bbb")
+
+# Dynamic-source arm: each Regexp.new(<expr>) goes through the
+# per-call-site sp_re_dyn_<i> cache, but the regexp-typed local
+# still holds the resulting pointer.
+def check_dyn(prefix, body)
+  pattern = if prefix == "x"
+              Regexp.new(prefix + "aaa")
+            else
+              Regexp.new(prefix + "bbb")
+            end
+  puts pattern.match?(body) ? "dyn-match" : "dyn-no-match"
+end
+
+check_dyn("x", "xaaa-yes")     # dyn-match
+check_dyn("y", "ybbb-yes")     # dyn-match
+check_dyn("x", "nope")         # dyn-no-match

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

@@ -0,0 +1,5 @@
+match
+no match
+dyn-match
+dyn-match
+dyn-no-match

data/vendor/spinel/test/regexp_match_data.rb

@@ -0,0 +1,17 @@
+# Issue #867: String#match and Regexp#match return a MatchData-like
+# object instead of falling through to unresolved-call emit-0.
+md1 = "hello world".match(/\w+/)
+puts md1[0]
+
+md2 = /(\w+) (\w+)/.match("hello world")
+puts md2[0]
+puts md2[1]
+puts md2[2]
+
+md3 = "a".match(/(a)(b)?/)
+puts md3[2].nil? ? "nil capture" : "bad capture"
+puts "abc".match(/z/).nil? ? "nil match" : "bad match"
+
+md4 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".match(/(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)/)
+puts md4.length
+puts md4[31]

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

@@ -0,0 +1,8 @@
+hello
+hello world
+hello
+world
+nil capture
+nil match
+32
+a

data/vendor/spinel/test/regexp_match_p_position.rb

@@ -0,0 +1,7 @@
+# Issue #869: Regexp#match?(str, pos) starts matching at byte
+# offset `pos`. Previously the position argument was silently
+# dropped and the call returned true for any non-empty pattern.
+puts /world/.match?("hello world", 6)
+puts /hello/.match?("hello world", 6)
+puts /hello/.match?("hello world")
+puts /world/.match?("hello world", -5)

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

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

data/vendor/spinel/test/regexp_new_literal.rb

@@ -0,0 +1,72 @@
+# `Regexp.new("literal")` / `Regexp.compile("literal")` with a
+# string-literal argument folds into the same static pattern table
+# as a `/literal/` regex literal. The LV/const holding the value
+# is a placeholder; `.match?` / `.match` / `=~` resolve at the call
+# site through `regex_pat_c_expr`, dispatching to `sp_re_pat_<i>`.
+# Without this, the LV was typed `obj_Regexp` and codegen emitted
+# `sp_Regexp *lv_x = NULL;` which doesn't compile (no such type).
+
+# Direct call on the constructor expression.
+puts Regexp.new("foo").match?("foobar")   # true
+puts Regexp.new("xyz").match?("foobar")   # false
+
+# Local variable bound to a Regexp.new result.
+pat = Regexp.new("\\d+")
+puts pat.match?("hello 42")                # true
+puts pat =~ "abc 123"                      # 4
+
+# Compile alias.
+pat2 = Regexp.compile("foo")
+puts pat2.match?("foobar")                 # true
+
+# Constant bound to a Regexp.new result.
+RE = Regexp.new("foo")
+puts RE.match?("foobar")                   # true
+puts "abc foo def" =~ RE                   # 4
+
+# Dynamic-arg form: the argument is built at runtime via interpolation.
+# scan_features registers the CallNode with the per-call-site
+# `sp_re_dyn_<idx>` cache; at the read site `regex_pat_c_expr`
+# re-evaluates the arg string and the cache returns the compiled
+# pattern (recompile only on key change).
+tag = "div"
+puts Regexp.new("<#{tag}").match?("<div>")  # true
+puts Regexp.new("<#{tag}").match?("<span>") # false
+
+# LV bound to a dyn Regexp.new -- read site re-emits the dyn-cache
+# call, so the cache lookup uses the LV's free variables (here `tag`)
+# in scope at the read site.
+pat_dyn = Regexp.new("<#{tag}>")
+puts pat_dyn.match?("<div>")                # true
+puts pat_dyn =~ "before <div> after"        # 7
+
+# Dyn arg from method parameters -- the common idiom for an
+# assert_select-style helper.
+def find_tag(body, tag)
+  re = Regexp.new("<#{tag}[^>]*>")
+  body =~ re
+end
+puts find_tag("foo <span class=\"y\"> bar", "span") # 4
+
+# Regexp.escape neutralizes regex metachars so the resulting
+# string matches the original bytes literally inside `Regexp.new`.
+puts Regexp.escape("foo+bar")              # foo\+bar
+puts Regexp.escape("a.b*c")                # a\.b\*c
+content = "foo.bar"
+literal_pat = Regexp.new(Regexp.escape(content))
+puts literal_pat.match?("foo.bar")         # true
+puts literal_pat.match?("fooXbar")         # false (the . is now literal)
+
+# `=~` returns Integer|nil matching CRuby (not -1 for no-match).
+puts ("abc" =~ /b/).inspect                # 1
+puts ("abc" =~ /xyz/).inspect              # nil
+puts ("abc" =~ /xyz/).nil?                 # true
+puts ("abc" =~ /b/).nil?                   # false
+
+# $~ / $& / $` / $' -- regex match globals exposed as strings
+# (spinel has no MatchData wrapper, so $~ === $&).
+"hello world" =~ /(o w)/
+puts $~                                    # o w
+puts $&                                    # o w
+puts $`                                    # hell
+puts $'                                    # orld

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

@@ -0,0 +1,24 @@
+true
+false
+true
+4
+true
+true
+4
+true
+false
+true
+7
+4
+foo\+bar
+a\.b\*c
+true
+false
+1
+nil
+true
+false
+o w
+o w
+hell
+orld

data/vendor/spinel/test/regexp_source_options.rb

@@ -0,0 +1,10 @@
+# Issue #868: Regexp#source returns the original pattern string;
+# #options returns the CRuby flag bitmask (1=IGNORECASE, 2=EXTENDED,
+# 4=MULTILINE).
+# named_captures deferred -- would need a Hash + per-named-group
+# index array which the runtime doesn't expose yet.
+puts /hello/.source
+puts /hello/i.options
+puts /hello/.options
+puts /world/m.options
+puts /pat/x.options

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

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

data/vendor/spinel/test/regexp_sub_gsub_length.rb

@@ -0,0 +1,17 @@
+# Regex String#sub / #gsub build into an over-allocated buffer; the
+# result's stored byte length must reflect the bytes actually written,
+# not the buffer's slack. Without the fix, #length returned the padded
+# capacity and inspect/p showed trailing NUL bytes. Exercise the paths
+# that read the metadata length (p / #length), which strlen-based
+# operations like puts would otherwise hide.
+p "hello".gsub(/l/, "L")
+p "hello".gsub(/l/, "L").length
+p "hello world".gsub(/o/, "0")
+p "hello world".gsub(/o/, "0").length
+p "hello".sub(/l/, "L")
+p "hello".sub(/l/, "L").length
+p "aaa".gsub(/a/, "bb")
+p "aaa".gsub(/a/, "bb").length
+# Backreference expansion still lands at the right length.
+p "FontName Times".gsub(/(\w+) (\w+)/, '\2 \1')
+p "abcabc".gsub(/b/, "").length

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

@@ -0,0 +1,10 @@
+"heLLo"
+5
+"hell0 w0rld"
+11
+"heLlo"
+5
+"bbbbbb"
+6
+"Times FontName"
+4

data/vendor/spinel/test/regexp_sub_gsub_realloc.rb

@@ -0,0 +1,25 @@
+# When a regex sub / gsub / scrub result grows past the initial buffer
+# capacity, the buffer must be grown on a real malloc base. Previously
+# these built into a sp_str_alloc'd buffer and grew it with realloc on a
+# pointer offset past the string header -- undefined behaviour that
+# corrupted the heap once the output exceeded the initial slack. Each
+# input below produces output larger than its starting capacity.
+
+# gsub: 50 'a' -> 50 * "zzzz" = 200 bytes (cap starts ~180).
+g = ("a" * 50).gsub(/a/, "zzzz")
+p g.length
+p g[0, 8]
+
+# sub with a backreference that repeats the whole match: 100 -> 200.
+s = ("x" * 100).sub(/x+/, '\0\0')
+p s.length
+
+# gsub(regex, hash) with replacement longer than the match.
+h = { "a" => "zzzzz" }
+gh = ("a" * 40).gsub(/a/, h)
+p gh.length
+
+# scrub: 100 invalid bytes, each replaced by a 5-char string -> 500.
+sc = ("\xFF" * 100).scrub("XXXXX")
+p sc.length
+p sc == "X" * 500

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

@@ -0,0 +1,6 @@
+200
+"zzzzzzzz"
+200
+200
+500
+true

data/vendor/spinel/test/regexp_threeq.rb

@@ -0,0 +1,15 @@
+# Regexp#=== matches a string against the pattern (the operator
+# `case x when /re/` uses). Previously fell through to the
+# unresolved-call path and raised at runtime.
+puts (/foo/ === "foobar")
+puts (/foo/ === "bar")
+
+case "hello"
+when /h.*o/ then puts "matched"
+else puts "no match"
+end
+
+case "world"
+when /^h/ then puts "starts with h"
+else puts "other"
+end

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

@@ -0,0 +1,4 @@
+true
+false
+matched
+other

data/vendor/spinel/test/require_first_line.rb

@@ -0,0 +1,7 @@
+# Regression for #1150 bug 2: a `require` on the very first line (byte 0)
+# was skipped when another `require` followed it, so optparse.rb was never
+# inlined and OptionParser was undefined. Both requires must be processed.
+require "optparse"
+require "tmpdir"
+o = OptionParser.new
+puts o.class

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

@@ -0,0 +1 @@
+OptionParser

data/vendor/spinel/test/require_modifier.rb

@@ -0,0 +1,12 @@
+# A bare-string `require` followed by a trailing modifier (`rescue`,
+# `if`, ...) used to strand the modifier during require preprocessing and
+# produce a parse error ("unexpected 'rescue'"). The require now degrades
+# to a `nil` expression so the modifier attaches and the program parses.
+# (json/set are stdlib in the reference Ruby, so the rescue is a moot
+# defensive guard there; the program does not use either library.)
+require 'json' rescue nil
+puts "ok1"
+x = 5 rescue nil
+puts x
+require 'set' if false
+puts "ok2"

data/vendor/spinel/test/require_same_line.rb

@@ -0,0 +1,5 @@
+# Regression for #1150 bug 1: `require "x"; code` on one line truncated the
+# trailing code (the whole line was replaced). The code after the require
+# must survive.
+puts "start"
+require "json"; puts JSON.generate([1, 2, 3])

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

@@ -0,0 +1,2 @@
+start
+[1,2,3]

data/vendor/spinel/test/require_unsupported_lib.rb

@@ -0,0 +1,8 @@
+# A `require` of a natively-provided lib (json) is a silent no-op and the
+# module still works. A `require` of an unsupported stdlib (tmpdir) warns
+# at compile time ("not available in Spinel"; goes to stderr, not checked
+# here) but is ignored so the rest of the program still compiles and runs.
+require "json"
+require "tmpdir"
+puts JSON.generate([1, 2, 3])
+puts "ok"

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

@@ -0,0 +1,2 @@
+[1,2,3]
+ok

data/vendor/spinel/test/rescue_bind_in_fiber_body.rb

@@ -0,0 +1,24 @@
+# `rescue => e` inside a Fiber body binds the exception local in the
+# fiber body's own function. Regression: the binding was attributed to
+# the enclosing scope, so `_fiber_body_N` referenced an undeclared lv_e.
+fib = Fiber.new do
+  begin
+    raise "fib boom"
+  rescue => fe
+    Fiber.yield "fib: #{fe.message}"
+  end
+  "fib done"
+end
+puts fib.resume
+puts fib.resume
+
+# Distinct names bound by two rescues within one fiber body.
+g = Fiber.new do
+  begin; raise "one"; rescue => e1; Fiber.yield "a: #{e1.message}"; end
+  begin; raise "two"; rescue => e2; Fiber.yield "b: #{e2.message}"; end
+  "g done"
+end
+puts g.resume
+puts g.resume
+puts g.resume
+puts "after"

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

@@ -0,0 +1,6 @@
+fib: fib boom
+fib done
+a: one
+b: two
+g done
+after

data/vendor/spinel/test/rescue_bind_in_lambda_proc_body.rb

@@ -0,0 +1,16 @@
+# `rescue => e` inside a lambda / proc body binds `e` as a body-local
+# exception. Before the fix the binding leaked to the enclosing scope so
+# the closure referenced an undeclared `lv_e`, and infer_type recomputed
+# `e.message` as int (a `#{e.message}` interp formatted the string
+# pointer with %lld). The string is observed inside the body so the test
+# is independent of the proc-call return-value ABI.
+lambda { begin; raise "a"; rescue => e; puts "got #{e.message}"; end }.call
+proc { begin; raise "boom"; rescue => e; puts "p #{e.message} (#{e.class})"; end }.call
+
+# Same construct, stored then called.
+f = lambda { begin; raise "late"; rescue => e; puts "f: #{e.message}"; end }
+f.call
+
+# A non-raising path through the body still compiles and runs.
+g = proc { begin; puts "no raise"; rescue => e; puts "unreached #{e.message}"; end }
+g.call

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

@@ -0,0 +1,4 @@
+got a
+p boom (RuntimeError)
+f: late
+no raise

data/vendor/spinel/test/rescue_walks_class_hierarchy.rb

@@ -0,0 +1,37 @@
+# `rescue ParentClass => e` should catch a raised subclass
+# instance, and `e.is_a?(AncestorClass)` should walk the class
+# hierarchy. Pre-fix sp_exc_is_a only strcmp'd the class name,
+# so a `raise C` where `C < B < A < StandardError` slipped past
+# every `rescue B` / `rescue A` / `rescue StandardError` rescue
+# arm, and `e.is_a?(X)` always returned false for any X.
+# Issue #627.
+
+class A < StandardError; end
+class B < A; end
+class C < B; end
+
+# `rescue B` catches a raised C
+begin
+  raise C, "boom"
+rescue B => e
+  puts "caught B: " + e.message
+end
+
+# is_a? walks the chain
+begin
+  raise C, "x"
+rescue => e
+  puts "is_a A? " + (e.is_a?(A) ? "yes" : "no")
+  puts "is_a B? " + (e.is_a?(B) ? "yes" : "no")
+  puts "is_a C? " + (e.is_a?(C) ? "yes" : "no")
+  puts "is_a StandardError? " + (e.is_a?(StandardError) ? "yes" : "no")
+  puts "is_a String? " + (e.is_a?(String) ? "yes" : "no")
+end
+
+# Standard library exception hierarchy: ArgumentError < StandardError.
+# `rescue StandardError` should catch ArgumentError.
+begin
+  raise ArgumentError, "bad"
+rescue StandardError => e
+  puts "caught StandardError via ArgumentError: " + e.message
+end

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

@@ -0,0 +1,7 @@
+caught B: boom
+is_a A? yes
+is_a B? yes
+is_a C? yes
+is_a StandardError? yes
+is_a String? no
+caught StandardError via ArgumentError: bad

data/vendor/spinel/test/rescue_widens_nil_local_to_exception.expected

@@ -0,0 +1 @@
+#<NotImplementedError: boom>

data/vendor/spinel/test/rescue_widens_nil_local_to_exception.rb

@@ -0,0 +1,11 @@
+def f
+  raised = nil
+  begin
+    raise NotImplementedError, "boom"
+  rescue NotImplementedError => e
+    raised = e
+  end
+  raised
+end
+
+puts f.inspect

data/vendor/spinel/test/respond_to_def_self_method.rb

@@ -0,0 +1,14 @@
+# def self.m singleton methods must be visible to respond_to? on the
+# class constant, and module_function methods on the module constant.
+class Foo
+  def self.bar; 1; end
+end
+puts Foo.respond_to?(:bar)
+puts Foo.respond_to?(:nope)
+
+module M
+  module_function
+  def greet; "hi"; end
+end
+puts M.respond_to?(:greet)
+puts M.respond_to?(:nope)

data/vendor/spinel/test/respond_to_module_singleton_accessor.rb

@@ -0,0 +1,10 @@
+# class << self; attr_accessor :x on a module must be visible to
+# respond_to? for both the reader and the writer.
+module Foo
+  class << self
+    attr_accessor :x
+  end
+end
+puts Foo.respond_to?(:x)
+puts Foo.respond_to?(:x=)
+puts Foo.respond_to?(:nope)

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

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

data/vendor/spinel/test/respond_to_primitive.rb

@@ -0,0 +1,9 @@
+# Issue #716. `<primitive>.respond_to?(name)` should answer true for
+# the common method set, not just for obj-typed receivers. The compile-
+# time approximation uses a conservative allowlist of universal methods.
+
+puts 1.respond_to?(:to_s)
+puts "x".respond_to?(:class)
+puts :s.respond_to?(:inspect)
+puts 1.5.respond_to?(:nil?)
+puts [].respond_to?(:dup)

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

@@ -0,0 +1,5 @@
+true
+true
+true
+true
+true