rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/rbs/README.md

@@ -0,0 +1,45 @@
+# RBS extractor golden tests
+
+Golden tests for `spinel_rbs_extract` — the tool that reads `*.rbs`
+files and emits the line-oriented seed format `spinel_analyze` consumes
+under `spinel --rbs DIR`. See `docs/RBS-EXTRACT.md` for the supported
+subset and `experiments/rbs/` for an end-to-end seeding spike.
+
+The extractor is a pure, deterministic text transform (`*.rbs` in →
+seed lines on stdout) and a compiled C binary, so it golden-tests
+cleanly with **no Ruby at test time** — unlike the compile-and-run
+fixtures under `test/`. This layer is also where RBS regressions are
+actually visible: seeds are advisory, so most extractor bugs produce
+identical *program* output and slip past the `test/*.rb` suite.
+
+## Layout
+
+Each case is one input/golden pair:
+
+- `<name>.rbs` — input RBS source
+- `<name>.seed.expected` — committed expected seed output
+
+`make rbs-test` runs `spinel_rbs_extract <name>.rbs` for every case and
+diffs stdout against the golden. It is a prerequisite of `make test`,
+and skips gracefully when `vendor/rbs` has not been fetched.
+
+## Adding or updating a case
+
+1. Add (or edit) `<name>.rbs`.
+2. `make regen-rbs-expected` to (re)generate every `.seed.expected`.
+3. **Read the diff** — the goldens encode intended behavior, so confirm
+   the change is what you meant before committing both files.
+
+## Coverage
+
+Single-file fixtures cover the documented subset: the scalar type
+vocabulary, nominal types, `Array[T]` / `Hash[K,V]` tag selection,
+nullable (`T?` / `T | nil`), heterogeneous-union → `poly`, member kinds
+(`meth` / `cmeth` / `self?.` / `attr_*` / `@ivar`), unqualified
+parent-scope resolution, first-overload-wins, and the signature- and
+type-level shapes that drop a method wholesale.
+
+Multi-file cross-file resolution (issue #658) is not covered here:
+output ordering across files depends on `readdir`, which isn't portable
+enough for a stable golden. The single-file `unqualified.rbs` exercises
+the parent-scope fallback deterministically.

data/vendor/spinel/test/rbs/arrays.rbs

@@ -0,0 +1,10 @@
+# Array[T] maps to a per-element-type array tag; element types outside
+# the int/float/string/symbol/nominal set fall back to poly_array.
+class Arrays
+  def i: (Array[Integer]) -> Array[Integer]
+  def f: (Array[Float]) -> Array[Float]
+  def s: (Array[String]) -> Array[String]
+  def y: (Array[Symbol]) -> Array[Symbol]
+  def o: (Array[Foo]) -> Array[Foo]
+  def p: (Array[bool]) -> Array[bool]
+end

data/vendor/spinel/test/rbs/arrays.seed.expected

@@ -0,0 +1,7 @@
+class Arrays
+meth i int_array int_array
+meth f float_array float_array
+meth s str_array str_array
+meth y sym_array sym_array
+meth o obj_Foo_ptr_array obj_Foo_ptr_array
+meth p poly_array poly_array

data/vendor/spinel/test/rbs/dropped_members.rbs

@@ -0,0 +1,13 @@
+# Member kinds that are not modeled: mixins (include/extend/prepend),
+# visibility (public/private), alias, and `@@cvar` class-variable
+# declarations. `kept` confirms emission resumes after them.
+class DroppedMembers
+  include Enumerable
+  extend Forwardable
+  prepend Helper
+  public
+  private
+  alias foo bar
+  @@count: Integer
+  def kept: (Integer) -> Integer
+end

data/vendor/spinel/test/rbs/dropped_members.seed.expected

@@ -0,0 +1,2 @@
+class DroppedMembers
+meth kept int int

data/vendor/spinel/test/rbs/dropped_sigs.rbs

@@ -0,0 +1,14 @@
+# Method signature shapes that take the whole method out of subset:
+# anything other than plain required positional params. `kept` confirms
+# emission resumes after each dropped method.
+#
+# (Keyword and block params are handled separately and are intentionally
+# NOT exercised here -- see the PR description.)
+class DroppedSigs
+  def opt: (?String) -> void
+  def rest: (*Integer) -> void
+  def trailing: (Integer, ?String, Integer) -> void
+  def restkw: (**Integer) -> void
+  def generic: [X] (X) -> X
+  def kept: (Integer) -> Integer
+end

data/vendor/spinel/test/rbs/dropped_sigs.seed.expected

@@ -0,0 +1,2 @@
+class DroppedSigs
+meth kept int int

data/vendor/spinel/test/rbs/dropped_types.rbs

@@ -0,0 +1,14 @@
+# Type-level shapes with no spinel tag. Any one of these in a required
+# positional (or as the return) drops the whole method. `kept` confirms
+# emission resumes. Note: `untyped` is NOT here -- it maps to poly.
+class DroppedTypes
+  def a: (self) -> void
+  def b: (instance) -> void
+  def c: (_Each) -> void
+  def d: (Integer & String) -> void
+  def e: (:sym) -> void
+  def f: (Integer, String) -> [Integer, String]
+  def g: ({ name: String }) -> void
+  def h: (^(Integer) -> void) -> void
+  def kept: (Integer) -> Integer
+end

data/vendor/spinel/test/rbs/dropped_types.seed.expected

@@ -0,0 +1,2 @@
+class DroppedTypes
+meth kept int int

data/vendor/spinel/test/rbs/hashes.rbs

@@ -0,0 +1,11 @@
+# Hash[K, V] is supported only when K is String or Symbol. The value
+# type collapses to int / string / poly. A non-String/Symbol key takes
+# the whole signature out of subset (see dropped_types.rbs).
+class Hashes
+  def si: (Hash[String, Integer]) -> Hash[String, Integer]
+  def ss: (Hash[String, String]) -> Hash[String, String]
+  def sp: (Hash[String, Float]) -> Hash[String, Float]
+  def yi: (Hash[Symbol, Integer]) -> Hash[Symbol, Integer]
+  def ys: (Hash[Symbol, String]) -> Hash[Symbol, String]
+  def yp: (Hash[Symbol, Float]) -> Hash[Symbol, Float]
+end

data/vendor/spinel/test/rbs/hashes.seed.expected

@@ -0,0 +1,7 @@
+class Hashes
+meth si str_int_hash str_int_hash
+meth ss str_str_hash str_str_hash
+meth sp str_poly_hash str_poly_hash
+meth yi sym_int_hash sym_int_hash
+meth ys sym_str_hash sym_str_hash
+meth yp sym_poly_hash sym_poly_hash

data/vendor/spinel/test/rbs/ivars.rbs

@@ -0,0 +1,8 @@
+# All four ivar sources emit an `ivar` line: attr_accessor / attr_reader
+# / attr_writer and a bare `@name: Type` instance-variable declaration.
+class Ivars
+  attr_accessor acc: String
+  attr_reader rd: Integer
+  attr_writer wr: Symbol
+  @direct: Float
+end

data/vendor/spinel/test/rbs/ivars.seed.expected

@@ -0,0 +1,5 @@
+class Ivars
+ivar acc string
+ivar rd int
+ivar wr symbol
+ivar @direct float

data/vendor/spinel/test/rbs/members.rbs

@@ -0,0 +1,7 @@
+# Member kinds: instance method (meth), singleton method (cmeth via
+# `def self.`), and `def self?.` which emits BOTH a meth and a cmeth.
+class Members
+  def inst: (Integer) -> String
+  def self.cls: (Integer) -> String
+  def self?.both: (Integer) -> String
+end

data/vendor/spinel/test/rbs/members.seed.expected

@@ -0,0 +1,5 @@
+class Members
+meth inst string int
+cmeth cls string int
+meth both string int
+cmeth both string int

data/vendor/spinel/test/rbs/nominal.rbs

@@ -0,0 +1,7 @@
+# Nominal class types map to obj_<QualifiedName>, with `::` flattened
+# to `_`. No symbol table is consulted; the mapping is purely
+# structural.
+class Holder
+  def a: (Foo) -> Foo
+  def b: (Foo::Bar) -> Foo::Bar
+end

data/vendor/spinel/test/rbs/nominal.seed.expected

@@ -0,0 +1,3 @@
+class Holder
+meth a obj_Foo obj_Foo
+meth b obj_Foo_Bar obj_Foo_Bar

data/vendor/spinel/test/rbs/nullable.rbs

@@ -0,0 +1,8 @@
+# `T?` and the two-arm `T | nil` / `nil | T` unions both reduce to the
+# nilable tag `<T>?`. Doubled nullability and `nil?` are normalized.
+class Nullable
+  def a: (String?) -> Integer?
+  def b: (String | nil) -> (nil | Integer)
+  def c: (Foo?) -> Foo?
+  def d: (Array[String]?) -> Array[Integer]?
+end

data/vendor/spinel/test/rbs/nullable.seed.expected

@@ -0,0 +1,5 @@
+class Nullable
+meth a int? string?
+meth b int? string?
+meth c obj_Foo? obj_Foo?
+meth d int_array? str_array?

data/vendor/spinel/test/rbs/overloads.rbs

@@ -0,0 +1,13 @@
+# Only the first overload is considered. `first_ok`'s first overload is
+# in-subset, so it is emitted (the String overload is ignored).
+# `first_bad`'s first overload is a proc type (out of subset), so the
+# whole method is dropped even though a later overload is in-subset.
+class Overloads
+  def first_ok: (Integer) -> Integer
+              | (String) -> String
+
+  def first_bad: (^(Integer) -> void) -> void
+               | (Integer) -> Integer
+
+  def kept: (Integer) -> Integer
+end

data/vendor/spinel/test/rbs/overloads.seed.expected

@@ -0,0 +1,3 @@
+class Overloads
+meth first_ok int int
+meth kept int int

data/vendor/spinel/test/rbs/scalars.rbs

@@ -0,0 +1,12 @@
+# Scalar type vocabulary: every primitive RBS type that reduces to a
+# single spinel tag, plus the return-only `void`.
+class Scalars
+  def i: (Integer) -> Integer
+  def f: (Float) -> Float
+  def s: (String) -> String
+  def y: (Symbol) -> Symbol
+  def b: (bool) -> bool
+  def t: (TrueClass) -> FalseClass
+  def n: (NilClass) -> nil
+  def v: () -> void
+end

data/vendor/spinel/test/rbs/scalars.seed.expected

@@ -0,0 +1,9 @@
+class Scalars
+meth i int int
+meth f float float
+meth s string string
+meth y symbol symbol
+meth b bool bool
+meth t bool bool
+meth n nil nil
+meth v nil -

data/vendor/spinel/test/rbs/union_poly.rbs

@@ -0,0 +1,9 @@
+# Heterogeneous unions (anything other than the two-arm `T | nil`
+# nilable shape) have no single concrete C representation, so they map
+# to the bare `poly` tag (sp_RbVal, the tagged union) rather than
+# dropping the whole seed. Regression guard for matz/spinel#1255.
+class Unions
+  def two: (Integer | String) -> (Integer | String)
+  def three: (Integer | String | Symbol) -> void
+  def with_nil: (Integer | String | nil) -> void
+end

data/vendor/spinel/test/rbs/union_poly.seed.expected

@@ -0,0 +1,4 @@
+class Unions
+meth two poly poly
+meth three nil poly
+meth with_nil nil poly

data/vendor/spinel/test/rbs/unqualified.rbs

@@ -0,0 +1,13 @@
+# Unqualified type resolution: inside `module Geo; class Point`, a bare
+# `Base` resolves to obj_Geo_Base via single-level parent fallback, and
+# `Point` resolves to obj_Geo_Point. The enclosing class name is
+# flattened to Geo_Point.
+module Geo
+  class Base
+  end
+
+  class Point
+    def base: () -> Base
+    def twin: (Point) -> Point
+  end
+end

data/vendor/spinel/test/rbs/unqualified.seed.expected

@@ -0,0 +1,4 @@
+class Geo
+class Geo_Point
+meth base obj_Geo_Base -
+meth twin obj_Geo_Point obj_Geo_Point

data/vendor/spinel/test/recursive_block_forward_value.rb

@@ -0,0 +1,19 @@
+# A method that forwards its &block down a recursive call and returns
+# the result carries the block's value back. The tail is the recursive
+# call (its value must be returned, not dropped for side-effect), and
+# the governing blk.call is in the base case `return blk.call if ...`.
+
+def countdown(n, &blk)
+  return blk.call if n <= 0
+  countdown(n - 1) { blk.call }
+end
+
+# string block: value survives every recursive sp_proc_call hop and is
+# typed string via the base-case return.
+puts countdown(2) { "done" }
+
+# int block at the same method
+puts countdown(3) { 42 }
+
+# depth 0 (base case taken immediately)
+puts countdown(0) { "base" }

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

@@ -0,0 +1,3 @@
+done
+42
+base

data/vendor/spinel/test/recursive_implicit_yield_value.rb

@@ -0,0 +1,35 @@
+# A self-recursive method that uses implicit `yield` and forwards its
+# block down the recursion (`countdown(n - 1) { yield }`) carries the
+# block's value back at the block's real type. Such methods are lowered
+# to an &block (sp_Proc) form: yield -> sp_proc_call(__yblk__), the
+# literal block is forwarded as a proc, and the nested `{ yield }`
+# captures the synthetic block param.
+
+def countdown(n)
+  return yield if n <= 0
+  countdown(n - 1) { yield }
+end
+puts countdown(2) { "done" }   # string block
+puts countdown(3) { 42 }       # int block at the same method
+puts countdown(0) { "base" }   # base case taken immediately
+
+# Non-recursive yield methods are unaffected (still inlined).
+def twice
+  yield
+  yield
+end
+twice { puts "tick" }
+
+def give
+  yield 5
+end
+puts give { |x| x + 1 }
+
+# Instance-method implicit-yield recursion.
+class Counter
+  def countdown(n)
+    return yield if n <= 0
+    countdown(n - 1) { yield }
+  end
+end
+puts Counter.new.countdown(2) { "inst" }

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

@@ -0,0 +1,7 @@
+done
+42
+base
+tick
+tick
+6
+inst

data/vendor/spinel/test/regex.rb

@@ -27,6 +27,13 @@ puts(("₁" =~ /[α-ω]/) ? "fail8" : "ok8")
 puts(("a"  =~ /[α-ω]/) ? "fail9" : "ok9")
 m_s2 = "abc₁₂₃def" =~ /[₀-₉]+/
 puts(m_s2 ? "ok10" : "fail10")
+m_s2_index = "abc" =~ /b/
+puts m_s2_index + 10
+if ("abc" =~ /z/) && true
+  puts "fail11"
+else
+  puts "ok11"
+end
 
 # === Stage 3: regex via constant ===
 RX = /[₀₁₂₃₄₅₆₇₈₉ₐₑₒₓₔ]+/

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

@@ -9,6 +9,8 @@ ok7
 ok8
 ok9
 ok10
+11
+ok11
 true
 false
 lhs match

data/vendor/spinel/test/regex_backref_oob_nil.rb

@@ -0,0 +1,13 @@
+# Issue #848: out-of-range / unmatched backreference ($3 when
+# the regex has 2 captures) returns nil, not "". Codegen now
+# returns sp_re_captures[N] directly (NULL for unset) so
+# downstream NULL-safe paths render it as nil.
+"ab" =~ /(a)(b)/
+puts "$1=#{$1.inspect}"
+puts "$2=#{$2.inspect}"
+puts "$3=#{$3.inspect}"
+puts "$4=#{$4.inspect}"
+
+# No match clears all captures.
+"hello" =~ /xyz/
+puts "$1=#{$1.inspect}"

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

@@ -0,0 +1,5 @@
+$1="a"
+$2="b"
+$3=nil
+$4=nil
+$1=nil

data/vendor/spinel/test/regex_const_freeze.rb

@@ -0,0 +1,17 @@
+# Issue #394: a top-level `PATTERN = /regex/.freeze` constant
+# was not recognised as a regex source. `gsub(PATTERN, ...)` then
+# fell through to `sp_str_gsub(... cst_PATTERN ...)` (mrb_int -> char *
+# C-compile error). The non-`.freeze` form already worked because
+# find_regexp_index recursed through @const_expr_ids; .freeze
+# wraps the literal in a CallNode so the recursion missed.
+#
+# Fix: find_regexp_index now peels the `.freeze` CallNode wrapper
+# before checking for RegularExpressionNode.
+
+PATTERN1 = /abc/
+PATTERN2 = /xy[0-9]+/.freeze
+PATTERN3 = /^foo/.freeze
+
+puts "xabcyz".gsub(PATTERN1, "Q")        # "xQyz"
+puts "xy42 xy7".gsub(PATTERN2, "M")      # "M M"
+puts "foobar foobaz".gsub(PATTERN3, "Y") # "Ybar foobaz"

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

@@ -0,0 +1,3 @@
+xQyz
+M M
+Ybar foobaz

data/vendor/spinel/test/regex_hex_shorthand.rb

@@ -0,0 +1,13 @@
+# Regex hex-digit shorthands \h ([0-9a-fA-F]) and \H (its negation).
+p("deadbeef" =~ /\A\h+\z/)
+p("ab"       =~ /\H/)
+p("xyz"      =~ /\h/)
+p("12ab"     =~ /\H/)
+p("g"        =~ /\h/)
+p("g"        =~ /\H/)
+p("a1F"      =~ /\h+/)
+p("z" =~ /[\h]/)
+p("a" =~ /[\h]/)
+p("a" =~ /[\H]/)
+p("z" =~ /[\H]/)
+p("X9k" =~ /[^\h]/)

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

@@ -0,0 +1,12 @@
+0
+nil
+nil
+nil
+nil
+0
+0
+nil
+0
+nil
+0
+0

data/vendor/spinel/test/regex_match_nonstring.rb

@@ -0,0 +1,18 @@
+# `Regexp#=~` (and match?/===) with a non-String operand raises
+# TypeError in CRuby; Spinel used to pass the scalar where a char* was
+# expected and segfault.
+x = 5
+begin
+  if /p/ =~ x
+    puts "matched"
+  else
+    puts "no match"
+  end
+  puts "NO RAISE"
+rescue TypeError => e
+  puts "TE: " + e.message
+end
+
+# A real String operand still matches and returns the offset (or nil).
+puts(/l/ =~ "hello")
+p(/zz/ =~ "hello")

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

@@ -0,0 +1,3 @@
+TE: no implicit conversion of Integer into String
+2
+nil

data/vendor/spinel/test/regex_namespaced_const.rb

@@ -0,0 +1,17 @@
+# Refs #1008. A regex in a namespaced constant must resolve like a top-level
+# one: gsub/sub/scan/=~ should dispatch to the engine, not silently no-op
+# (gsub) or raise undefined-method (scan).
+module M
+  RE = /a/
+end
+puts "banana".gsub(M::RE, "X")
+puts "banana".scan(M::RE).length
+
+# nested namespace + .freeze
+module A
+  module B
+    WS = /\s+/.freeze
+  end
+end
+puts "x  y   z".gsub(A::B::WS, "-")
+puts "x  y   z".scan(A::B::WS).length

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

@@ -0,0 +1,4 @@
+bXnXnX
+3
+x-y-z
+2

data/vendor/spinel/test/regex_negated_shorthand_toplevel.rb

@@ -0,0 +1,9 @@
+# Top-level \D \W \S must match the complement set (not double-negate).
+p("5" =~ /\D/); p("x" =~ /\D/)
+p("a" =~ /\W/); p(" " =~ /\W/)
+p("x" =~ /\S/); p(" " =~ /\S/)
+# Non-negated and bracket forms unchanged.
+p("5" =~ /\d/); p("x" =~ /\d/)
+p("a" =~ /\w/); p(" " =~ /\w/)
+p("5" =~ /[\D]/); p("x" =~ /[\D]/)
+p("héllo" =~ /\D/)

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

@@ -0,0 +1,13 @@
+nil
+0
+nil
+0
+0
+nil
+0
+nil
+0
+nil
+nil
+0
+0

data/vendor/spinel/test/regex_sub_backref.rb

@@ -0,0 +1,11 @@
+# Issue #855: sub / gsub expand `\1`..`\9` and `\&` backreferences
+# in the replacement string.
+puts "hello world".sub(/(\w+)/, '\1_up')
+puts "hello world".gsub(/(\w+)/, '\1!')
+puts "abc".sub(/b/, '[\&]')
+# Swap two captured groups via \2\1.
+puts "foo:bar".sub(/(\w+):(\w+)/, '\2:\1')
+# `\\` is a literal backslash, not a backref.
+puts "x".sub(/x/, '\\')
+# Numeric backref beyond captured groups stays empty.
+puts "ab".sub(/(a)(b)/, '\1-\2-\3')

data/vendor/spinel/test/regex_unanchored_class_seq.rb

@@ -0,0 +1,13 @@
+# Issue #909. Unanchored class-sequence patterns (e.g. /\w\w/, /(.)(.)/ )
+# used to skip position 0 because a later-starting Pike VM thread
+# overwrote the earlier-starting match's captures. Now the MATCH
+# update picks the best match per Ruby semantics: earliest start
+# wins, longest-at-same-start wins.
+puts ("abc" =~ /\w\w/).inspect
+puts ("abc def" =~ /\w\w/).inspect
+puts "abc def".scan(/(.)(.)/).inspect
+
+# Greedy still works.
+puts ("aaabbb" =~ /a+/).inspect
+puts "aaabbb".scan(/a+/).inspect
+puts "aaa-bbb-ccc".scan(/\w+/).inspect

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

@@ -0,0 +1,6 @@
+0
+0
+[["a", "b"], ["c", " "], ["d", "e"]]
+0
+["aaa"]
+["aaa", "bbb", "ccc"]

data/vendor/spinel/test/regexp_capture_ivar_hash.rb

@@ -0,0 +1,48 @@
+# A regex match-capture used as the key of an instance-variable hash,
+# inside a loop, must store the capture as a boxed String key, so keys
+# come back as Strings and lookups by a String literal find them --
+# not stored unboxed as a raw integer/pointer. The "parse lines ->
+# build a lookup table in an ivar" shape (afm, i18n-country-translations).
+class Font
+  def initialize(text)
+    @table = {}
+    text.each_line do |line|
+      if (m = line.match(/^(\w+) (.+)/))
+        @table[m[1]] = m[2]
+      end
+    end
+  end
+
+  def keys
+    @table.keys
+  end
+
+  def [](name)
+    @table[name]
+  end
+end
+
+f = Font.new("FontName Times\nWeight Bold\nItalicAngle zero")
+p f.keys
+p f["FontName"]
+p f["Weight"]
+p f["ItalicAngle"]
+p f["Missing"]
+
+# Value derived from the same capture (downcase): still a String hash.
+class Index
+  def initialize(text)
+    @h = {}
+    text.each_line do |line|
+      if (m = line.match(/^(\w+)/))
+        @h[m[1]] = m[1].downcase
+      end
+    end
+  end
+  def lookup(k); @h[k]; end
+  def size; @h.keys.length; end
+end
+
+i = Index.new("Alpha\nBeta\nGamma")
+p i.lookup("Beta")
+p i.size

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

@@ -0,0 +1,7 @@
+["FontName", "Weight", "ItalicAngle"]
+"Times"
+"Bold"
+"zero"
+nil
+"beta"
+3

data/vendor/spinel/test/regexp_error_catchable.rb

@@ -0,0 +1,14 @@
+# Issue #846: a bad `Regexp.new("...")` raises a catchable
+# RegexpError. Pre-fix the static-table compile error fired
+# before main()'s setjmp scope and terminated the process.
+begin
+  r = Regexp.new("[invalid")
+  puts "no error raised"
+rescue => e
+  puts "caught: " + e.class.to_s + ": " + e.message
+end
+puts "after rescue"
+
+# Valid pattern still compiles.
+r2 = Regexp.new("hello")
+puts "world hello".match?(r2)

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

@@ -0,0 +1,3 @@
+caught: RegexpError: unterminated character class: /[invalid/
+after rescue
+true