rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/alias_attr_reader_source.rb

@@ -0,0 +1,38 @@
+# `alias`/`alias_method` may name an attr_reader/attr_accessor-generated
+# method as the source. The new name then reads the same backing ivar,
+# carrying the ivar's inferred type (so typed uses like upcase work).
+class Token
+  attr_reader :access_token
+  attr_accessor :scope
+  alias value access_token
+  alias_method :token2, :access_token
+  alias scope_alias scope
+
+  def initialize
+    @access_token = "tok"
+    @scope = "read"
+  end
+end
+
+t = Token.new
+puts t.value
+puts t.token2
+puts t.value.upcase          # type must propagate: string method
+puts "#{t.value}!"           # interpolation
+puts t.scope_alias
+
+# Aliasing an inherited attr_reader from the parent class.
+class Base
+  attr_reader :name
+  def initialize(n)
+    @name = n
+  end
+end
+
+class Derived < Base
+  alias title name
+end
+
+d = Derived.new("spinel")
+puts d.title
+puts d.title.upcase

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

@@ -0,0 +1,7 @@
+tok
+tok
+TOK
+tok!
+read
+spinel
+SPINEL

data/vendor/spinel/test/alias_inherited_method.rb

@@ -0,0 +1,20 @@
+# `alias` can reference a method inherited from an ancestor, not just one
+# defined directly on the class. The alias snapshots the inherited body.
+class Parent
+  def foo; "parent-foo"; end
+  def greet(name); "hi " + name; end
+end
+
+class Child < Parent
+  alias bar foo
+  alias hail greet
+end
+
+puts Child.new.bar
+puts Child.new.hail("ada")
+
+# Two levels up resolves too.
+class Grandchild < Child
+  alias baz foo
+end
+puts Grandchild.new.baz

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

@@ -0,0 +1,3 @@
+parent-foo
+hi ada
+parent-foo

data/vendor/spinel/test/alias_method_dispatch.rb

@@ -0,0 +1,14 @@
+class Animal
+  def speak(n); "sound" + n.to_s; end
+  alias_method :vocalize, :speak
+  alias cry speak
+end
+class Dog < Animal
+  alias_method :woof, :speak
+end
+a = Animal.new
+puts a.speak(2)
+puts a.vocalize(3)
+puts a.cry(1)
+d = Dog.new
+puts d.woof(4)

data/vendor/spinel/test/analyze_fail/attributes_non_symbol.rb

@@ -0,0 +1,3 @@
+class BadAttributes
+  attributes "name"
+end

data/vendor/spinel/test/analyze_fail/attributes_non_symbol.stderr.expected

@@ -0,0 +1 @@
+Spinel: attributes requires symbol names

data/vendor/spinel/test/analyze_fail/dynamic_define_method.rb

@@ -0,0 +1,4 @@
+class BadDynamicDefineMethod
+  name = "bad"
+  define_method(name) { 1 }
+end

data/vendor/spinel/test/analyze_fail/dynamic_define_method.stderr.expected

@@ -0,0 +1 @@
+Spinel: define_method requires a compile-time-known name

data/vendor/spinel/test/analyze_fail/instance_exec_def_in_block.rb

@@ -0,0 +1,14 @@
+# A `def` inside instance_exec defines a singleton method at runtime,
+# which Spinel does not model -- it must be a compile-time error, not a
+# silent miscompile. (CRuby defines a singleton method on the receiver.)
+class Box
+  def initialize(v)
+    @v = v
+  end
+end
+
+class BoxPlus < Box
+end
+
+b = BoxPlus.new(5)
+b.instance_exec { def greet; end }

data/vendor/spinel/test/analyze_fail/instance_exec_def_in_block.stderr.expected

@@ -0,0 +1 @@
+Spinel: instance_exec: block contains a 'def', defining a method at runtime; Spinel does not support runtime method definition; define the method statically on the receiver's class

data/vendor/spinel/test/analyze_fail/instance_exec_define_method.rb

@@ -0,0 +1,15 @@
+# define_method inside instance_exec is a runtime method definition
+# Spinel does not support; reject at compile time. (CRuby raises
+# NoMethodError -- define_method is private -- but the point is the same:
+# no static lowering exists.)
+class Box
+  def initialize(v)
+    @v = v
+  end
+end
+
+class BoxPlus < Box
+end
+
+b = BoxPlus.new(5)
+b.instance_exec { define_method(:greet) { 1 } }

data/vendor/spinel/test/analyze_fail/instance_exec_define_method.stderr.expected

@@ -0,0 +1 @@
+Spinel: instance_exec: block calls 'define_method', defining a method at runtime; Spinel does not support runtime method definition; define the method statically on the receiver's class

data/vendor/spinel/test/analyze_fail/instance_exec_no_block.rb

@@ -0,0 +1,13 @@
+# instance_exec with no block is a LocalJumpError in CRuby; surface it
+# at compile time rather than emitting a call to a block that isn't there.
+class Box
+  def initialize(v)
+    @v = v
+  end
+end
+
+class BoxPlus < Box
+end
+
+b = BoxPlus.new(5)
+b.instance_exec

data/vendor/spinel/test/analyze_fail/instance_exec_no_block.stderr.expected

@@ -0,0 +1 @@
+Spinel: instance_exec: no block given; pass a literal block (`recv.instance_exec { ... }`)

data/vendor/spinel/test/analyze_fail/nonliteral_define_method_each.rb

@@ -0,0 +1,7 @@
+class BadDefineMethodEach
+  names = [:one, :two]
+
+  names.each do |name|
+    define_method("#{name}") { 1 }
+  end
+end

data/vendor/spinel/test/analyze_fail/nonliteral_define_method_each.stderr.expected

@@ -0,0 +1 @@
+Spinel: compile-time define_method.each requires a literal collection

data/vendor/spinel/test/argv_gc.rb

@@ -0,0 +1,45 @@
+# sp_argv stores `const char *` pointers into the str-heap (via
+# sp_str_dup_external on main entry). Without explicit GC marking,
+# sp_str_sweep reaps them on the first collect, leaving sp_argv.data
+# entries as dangling pointers that any later `ARGV[i]` read
+# dereferences.
+#
+# Triggering the bug requires:
+#  - Reading ARGV[i] (just the read, not even a method call).
+#  - GC pressure that actually fires sp_gc_collect — string allocs
+#    don't accrue to sp_gc_bytes per sp_str_alloc's threshold note,
+#    so we need object allocations to push past 256 KB.
+#  - Reading ARGV[i] again after GC; the dangling pointer either
+#    segfaults outright or yields freed memory.
+#
+# The fix marks sp_argv.data[*] alongside the regex globals in
+# sp_re_mark_globals, so sp_str_sweep keeps argv strings alive.
+# argv_gc.rb.args feeds five short args so the harness exercises a
+# non-empty ARGV (short strings hit the segfault path under the bug).
+
+class Trash
+  def initialize(n)
+    @n = n
+    @s = "padding payload " * 64    # ~1 KB heap string per Trash
+  end
+  attr_reader :n
+end
+
+# Allocate ~5000 Trash instances (~5 MB) — far past the 256 KB GC
+# threshold — to force sp_gc_collect / sp_str_sweep cycles.
+junk = []
+j = 0
+while j < 5000
+  junk << Trash.new(j)
+  j = j + 1
+end
+puts junk.length     # 5000
+
+# Read ARGV[i] after GC. With the bug, sp_argv.data[i] points to
+# freed memory; reading it (and its length) crashes or returns
+# garbage.
+i = 0
+while i < ARGV.length
+  puts ARGV[i] + ":" + ARGV[i].length.to_s
+  i = i + 1
+end

data/vendor/spinel/test/argv_gc.rb.args

@@ -0,0 +1 @@
+first second third fourth fifth

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

@@ -0,0 +1,6 @@
+5000
+first:5
+second:6
+third:5
+fourth:6
+fifth:5

data/vendor/spinel/test/array_at_out_of_bounds.rb

@@ -0,0 +1,23 @@
+# Array#at returns nil for an out-of-range index. For a scalar element
+# array the result is now typed int?/float?, so the out-of-bounds
+# sentinel (sp_IntArray_get already returns SP_INT_NIL; sp_FloatArray_get
+# now returns the float-nil) is recognised by `== nil`, `.nil?`, and
+# inspect. (Array#[] keeps the plain element type -- making it nullable
+# would cascade the sentinel through every hot index.)
+
+p([1, 2, 3, 4, 5, 6].at(99) == nil)        #=> true
+p [1, 2, 3].at(99)                          #=> nil
+p [1, 2, 3].at(1)                           #=> 2
+p [1, 2, 3].at(-1)                          #=> 3
+p([1, 2, 3].at(99).nil?)                    #=> true
+p([1, 2, 3].at(1).nil?)                     #=> false
+p ["a", "b"].at(5)                          #=> nil
+
+# In-bounds results still behave as plain scalars in arithmetic.
+puts [10, 20, 30].at(1) + 5                 #=> 25
+puts [1.5, 2.5].at(0) + 1.0                 #=> 2.5
+
+# Float out-of-range.
+p([1.5, 2.5].at(9) == nil)                  #=> true
+p [1.5, 2.5].at(9)                          #=> nil
+puts "done"

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

@@ -0,0 +1,12 @@
+true
+nil
+2
+3
+true
+false
+nil
+25
+2.5
+true
+nil
+done

data/vendor/spinel/test/array_clear_expr.rb

@@ -0,0 +1,26 @@
+# Array#clear in expression position was only implemented for
+# poly_array; on a typed array (`[1,2,3].clear`) it fell through to the
+# unresolved-call path, returning int 0 and mis-typing the result. The
+# statement-form clear already worked for every typed array.
+
+p [1, 2, 3, 4].clear                 #=> []
+p ["a", "b"].clear                   #=> []
+p [1.0, 2.0].clear                   #=> []
+p [:x, :y].clear                     #=> []
+p([1, 2, 3, 4].clear == [])          #=> true (same-typed empty arrays)
+p ["a", "b"].clear.length            #=> 0
+p [1.0, 2.0].clear.length            #=> 0
+
+# clear resets the int_array sliding window, so a later push refills
+# from index 0.
+a = [1, 2, 3]
+a.shift
+a.clear
+a.push(9)
+p a                                   #=> [9]
+
+# Statement form still empties in place.
+b = ["x", "y", "z"]
+b.clear
+p b.length                            #=> 0
+puts "done"

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

@@ -0,0 +1,10 @@
+[]
+[]
+[]
+[]
+true
+0
+0
+[9]
+0
+done

data/vendor/spinel/test/array_combination_block.rb

@@ -0,0 +1,11 @@
+# Array#combination(k) with a block iterates each combination
+# without materialising a giant intermediate array.
+
+count = 0
+[1, 2, 3, 4].combination(2) { |c| count = count + 1 }
+puts count
+
+# Body actually sees each sub-array.
+out = []
+[1, 2, 3].combination(2) { |c| out.push(c[0] + c[1]) }
+puts out.inspect

data/vendor/spinel/test/array_compact_eq.rb

@@ -0,0 +1,16 @@
+# `[1, nil, 2].compact` yields a poly_array, but a literal like `[1, 2]`
+# stays an int_array, so `compact == [1, 2]` compared distinct pointer
+# types and failed the -Werror build. Add a poly_array-vs-typed-array
+# equality that boxes the typed side per element and compares via
+# sp_poly_eq (both operand orders).
+
+p [1, nil, 2].compact                          #=> [1, 2]
+p([1, nil, 2].compact == [1, 2])               #=> true
+p([1, nil, 2].compact == [1, 3])               #=> false
+p([1, 2] == [1, nil, 2].compact)               #=> true  (reverse order)
+p(["a", nil, "b"].compact == ["a", "b"])       #=> true
+p([1.0, nil, 2.0].compact == [1.0, 2.0])       #=> true
+p([1, nil].compact == [1])                     #=> true
+p([1, nil, 2].compact != [1, 2])               #=> false
+p([1, nil, 2].compact != [9])                  #=> true
+puts "done"

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

@@ -0,0 +1,10 @@
+[1, 2]
+true
+false
+true
+true
+true
+true
+false
+true
+done

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

@@ -0,0 +1 @@
+[42, 42, 42]

data/vendor/spinel/test/array_first_last_empty.rb

@@ -0,0 +1,12 @@
+# Array#first / Array#last on an empty array return nil,
+# not SP_INT_NIL printed as a huge negative number.
+# CRuby returns nil for [].first and [].last.
+
+puts [].first.inspect
+puts [].last.inspect
+puts [].first.nil?.inspect
+puts [].last.nil?.inspect
+puts [1, 2, 3].first.inspect
+puts [1, 2, 3].last.inspect
+puts [1, 2, 3].first(2).inspect
+puts [1, 2, 3].last(2).inspect

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

@@ -0,0 +1,8 @@
+nil
+nil
+true
+true
+1
+3
+[1, 2]
+[2, 3]

data/vendor/spinel/test/array_flatten_typed_elements.rb

@@ -0,0 +1,19 @@
+# Array#flatten on a typed-array-of-typed-array concatenates the inner
+# arrays into one flat typed array. Previously only int elements were
+# specialized; str and float now mirror it (the pr_geohash gem's
+# neighbors does map{...}.flatten over string cells).
+ints = [[1, 2], [3, 4]]
+p ints.flatten
+puts ints.flatten.length
+
+strs = [["a", "b"], ["c", "d"]]
+p strs.flatten
+puts strs.flatten.length
+
+floats = [[1.0, 2.0], [3.5, 4.5]]
+p floats.flatten
+puts floats.flatten.length
+
+# Uneven inner lengths and an empty inner array.
+mixed = [["x"], [], ["y", "z"]]
+p mixed.flatten

data/vendor/spinel/test/array_frozen_mutate_raises.rb

@@ -0,0 +1,36 @@
+# Array mutating methods on frozen arrays must raise FrozenError.
+# IntArray#pop/#shift already had the guard; FloatArray, StrArray,
+# and the reverse_bang/sort_bang/shuffle_bang/rotate_bang/delete_at
+# /delete/insert methods were missing it.
+
+# IntArray
+a = [1, 2, 3]
+a.freeze
+begin; a.reverse!; puts "BUG int reverse!"; rescue FrozenError; puts "int reverse!"; end
+begin; a.sort!; puts "BUG int sort!"; rescue FrozenError; puts "int sort!"; end
+begin; a.shuffle!; puts "BUG int shuffle!"; rescue FrozenError; puts "int shuffle!"; end
+begin; a.rotate!(1); puts "BUG int rotate!"; rescue FrozenError; puts "int rotate!"; end
+begin; a.delete_at(0); puts "BUG int delete_at"; rescue FrozenError; puts "int delete_at"; end
+begin; a.delete(1); puts "BUG int delete"; rescue FrozenError; puts "int delete"; end
+
+# FloatArray
+f = [1.5, 2.5, 3.5]
+f.freeze
+begin; f.reverse!; puts "BUG float reverse!"; rescue FrozenError; puts "float reverse!"; end
+begin; f.sort!; puts "BUG float sort!"; rescue FrozenError; puts "float sort!"; end
+begin; f.shuffle!; puts "BUG float shuffle!"; rescue FrozenError; puts "float shuffle!"; end
+begin; f.rotate!(1); puts "BUG float rotate!"; rescue FrozenError; puts "float rotate!"; end
+begin; f.pop; puts "BUG float pop"; rescue FrozenError; puts "float pop"; end
+begin; f.shift; puts "BUG float shift"; rescue FrozenError; puts "float shift"; end
+
+# StrArray
+s = ["a", "b", "c"]
+s.freeze
+begin; s.reverse!; puts "BUG str reverse!"; rescue FrozenError; puts "str reverse!"; end
+begin; s.sort!; puts "BUG str sort!"; rescue FrozenError; puts "str sort!"; end
+begin; s.shuffle!; puts "BUG str shuffle!"; rescue FrozenError; puts "str shuffle!"; end
+begin; s.rotate!(1); puts "BUG str rotate!"; rescue FrozenError; puts "str rotate!"; end
+begin; s.pop; puts "BUG str pop"; rescue FrozenError; puts "str pop"; end
+begin; s.delete_at(0); puts "BUG str delete_at"; rescue FrozenError; puts "str delete_at"; end
+begin; s.delete("a"); puts "BUG str delete"; rescue FrozenError; puts "str delete"; end
+begin; s.insert(0, "z"); puts "BUG str insert"; rescue FrozenError; puts "str insert"; end

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

@@ -0,0 +1,20 @@
+int reverse!
+int sort!
+int shuffle!
+int rotate!
+int delete_at
+int delete
+float reverse!
+float sort!
+float shuffle!
+float rotate!
+float pop
+float shift
+str reverse!
+str sort!
+str shuffle!
+str rotate!
+str pop
+str delete_at
+str delete
+str insert

data/vendor/spinel/test/array_frozen_slice_bang.rb

@@ -0,0 +1,19 @@
+# Array#slice! must raise FrozenError on a frozen array (Gemini
+# follow-up to #1029: slice! was the remaining unguarded mutator).
+a = [1, 2, 3]
+a.freeze
+begin
+  a.slice!(0, 1)
+  puts "BUG: no raise"
+rescue FrozenError
+  puts "int slice!"
+end
+
+s = ["a", "b", "c"]
+s.freeze
+begin
+  s.slice!(1, 1)
+  puts "BUG: no raise"
+rescue FrozenError
+  puts "str slice!"
+end

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

@@ -0,0 +1,2 @@
+int slice!
+str slice!

data/vendor/spinel/test/array_get_oob_negative.rb

@@ -0,0 +1,22 @@
+# a[-100] with a 3-element array must not segfault.
+# Before the fix, sp_IntArray_get adjusted the negative index but
+# didn't bounds-check the result, reading far below the buffer.
+# The int? nil-display gap is a known limitation; this test only
+# verifies that OOB access doesn't crash.
+
+a = [1, 2, 3]
+# these used to segfault — now they return SP_INT_NIL (non-crashing)
+a[-100]
+a[100]
+puts a[-1]
+puts a[2]
+
+sa = ["a", "b", "c"]
+puts sa[-100].inspect
+puts sa[100].inspect
+
+fa = [1.0, 2.0, 3.0]
+fa[-100]
+fa[100]
+puts fa[-1]
+puts fa[1]

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

@@ -0,0 +1,6 @@
+3
+3
+nil
+nil
+3.0
+2.0

data/vendor/spinel/test/array_grep.rb

@@ -0,0 +1,12 @@
+# Array#grep(pattern) / #grep_v(pattern) without a block: collect the
+# elements matching (or not matching) the pattern via `pattern ===`.
+# Supported: Range over an int array, primitive Class over a poly array,
+# Regexp over a str array. (The block form falls through to unresolved.)
+p [1, 2, 3, 4, 5].grep(1..3)
+p [1, 2, 3, 4, 5].grep_v(1..3)
+p [1, 2, 3, 4, 5].grep(2...4)
+p [1, 2].grep(10..20)
+p [1, "two", 3, "four"].grep(String)
+p [1, "two", 3, "four"].grep(Integer)
+p ["apple", "banana", "avocado"].grep(/^a/)
+p ["apple", "banana", "avocado"].grep_v(/^a/)

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

@@ -0,0 +1,8 @@
+[1, 2, 3]
+[4, 5]
+[2, 3]
+[]
+["two", "four"]
+[1, 3]
+["apple", "avocado"]
+["banana"]

data/vendor/spinel/test/array_index_int_opt_narrow.rb

@@ -0,0 +1,30 @@
+# Array#index on int_array returns the new int? (scalar-nullable
+# int with INT64_MIN sentinel) instead of being widened to poly.
+# After the nil-check guard the value narrows back to plain int
+# so downstream arithmetic compiles to direct integer ops without
+# poly box/unbox.
+#
+# Sibling of nil_guard_narrows_int_or_nil.rb (which exercises the
+# same shape on String#index, still poly-widened). Both forms
+# behave identically at the Ruby level; this test pins the
+# int_array case so a regression in the int?-narrow path surfaces
+# here.
+
+ARR = [10, 20, 30, 40, 50]
+
+def offset_or_zero(arr, target)
+  i = arr.index(target)
+  return 0 if i.nil?
+  i + 1
+end
+
+puts offset_or_zero(ARR, 30)    # 3
+puts offset_or_zero(ARR, 999)   # 0
+puts offset_or_zero(ARR, 10)    # 1
+
+# Inspect/.nil? on the int? value flows through the sentinel-aware
+# helpers (sp_int_opt_inspect / sp_int_is_nil).
+puts ARR.index(20).inspect      # 1
+puts ARR.index(999).inspect     # nil
+puts ARR.index(999).nil?        # true
+puts ARR.index(20).nil?         # false

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

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

data/vendor/spinel/test/array_map_bang.rb

@@ -0,0 +1,28 @@
+# Array#map! / #collect! transform each element in place and return the
+# (mutated) receiver. Typed arrays are homogeneous, so the block must
+# keep the element type; poly arrays accept any result.
+a = [1, 2, 3]
+r = a.map! { |x| x * 10 }
+p a
+p r
+
+b = ["a", "b", "c"]
+b.collect! { |s| s.upcase }
+p b
+
+c = [1.5, 2.5]
+c.map! { |x| x + 1.0 }
+p c
+
+g = [1, "two", 3]
+g.map! { |x| x }
+p g
+
+s = [:a, :b, :c]
+s.map! { |x| x }
+p s
+
+# Empty array.
+e = []
+e.map! { |x| x * 2 }
+p e

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

@@ -0,0 +1,7 @@
+[10, 20, 30]
+[10, 20, 30]
+["A", "B", "C"]
+[2.5, 3.5]
+[1, "two", 3]
+[:a, :b, :c]
+[]

data/vendor/spinel/test/array_minmax_block.rb

@@ -0,0 +1,14 @@
+# Array#minmax with a 2-param comparator block honours the block's
+# ordering instead of the default < / >.
+p [3, 1, 2].minmax { |a, b| b <=> a }   # reversed: [3, 1]
+p [3, 1, 2].minmax { |a, b| a <=> b }   # normal:   [1, 3]
+p [5, 2, 8, 1, 9].minmax { |a, b| a <=> b }
+p [5, 2, 8, 1, 9].minmax { |a, b| b <=> a }
+
+# String elements, comparing by length.
+p ["bb", "a", "ccc"].minmax { |a, b| a.length <=> b.length }
+p ["bb", "a", "ccc"].minmax { |a, b| b.length <=> a.length }
+
+# Single-element and the no-block form still work.
+p [42].minmax { |a, b| a <=> b }
+p [3, 1, 2].minmax

data/vendor/spinel/test/array_negative_index_too_small.rb

@@ -0,0 +1,22 @@
+# Issue #839: an extreme negative index on []= raises IndexError
+# per MRI. Spinel previously silently no-op'd when the index after
+# `+= len` was still negative.
+a = [1, 2, 3]
+begin
+  a[-999] = 99
+rescue IndexError => e
+  puts "int: " + e.message
+end
+puts a.inspect
+
+b = ["a", "b", "c"]
+begin
+  b[-50] = "x"
+rescue IndexError => e
+  puts "str: " + e.message
+end
+puts b.inspect
+
+# Valid negative index still works.
+a[-1] = 33
+puts a.inspect

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

@@ -0,0 +1,5 @@
+int: index -999 too small for array; minimum: -3
+[1, 2, 3]
+str: index -50 too small for array; minimum: -3
+["a", "b", "c"]
+[1, 2, 33]