rubyduino 0.1.3 → 0.2.1

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

@@ -0,0 +1,9 @@
+42
+true
+false
+true
+false
+true
+true
+true
+true

data/vendor/spinel/test/ivar_assign_and_expr.rb

@@ -0,0 +1,22 @@
+# `@x = expr and rest` parses as `(@x = expr) and rest`; @x must be
+# typed from expr (poly), not the boolean `and` result.
+class C
+  def initialize(o = {})
+    @debug = o[:debug] and o[:debug] == true
+  end
+  def debug; @debug; end
+end
+p C.new(debug: true).debug
+p C.new.debug
+# `@x = @x + 1` as a method's value returns the (boxed) slot value.
+class A
+  def initialize(attrs = {})
+    @id = attrs[:id] || 0
+  end
+  def bump = (@id = @id + 1)
+  def id = @id
+end
+a = A.new(id: 10)
+a.bump
+a.bump
+puts a.id

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

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

data/vendor/spinel/test/ivar_lazy_init_push_via_inherited_getter.rb

@@ -0,0 +1,67 @@
+# #451: cross-class sequel to #430. The lazy-init getter
+# `def errors; @errors = [] if @errors.nil?; @errors; end` is
+# defined on a parent class; the push `errors << "..."` happens
+# from a child class method. Before the fix, scan_writer_calls
+# only inspected @current_class_idx for the getter, so the
+# parent's @errors stayed `sp_IntArray *` and the child's
+# String push failed C compile.
+
+class Base
+  def errors
+    @errors = [] if @errors.nil?
+    @errors
+  end
+end
+
+class Foo < Base
+  def add_error(msg)
+    errors << "#{msg} bad"
+  end
+end
+
+f = Foo.new
+f.add_error("name")
+f.add_error("body")
+puts f.errors.length
+puts f.errors[0]
+puts f.errors[1]
+
+# Two levels of inheritance — getter on grandparent.
+class Tracker
+  def events
+    @events = [] if @events.nil?
+    @events
+  end
+end
+
+class TrackerMid < Tracker
+end
+
+class TrackerLeaf < TrackerMid
+  def record(name)
+    events << name
+  end
+end
+
+t = TrackerLeaf.new
+t.record("a")
+t.record("b")
+puts t.events.length
+puts t.events.join(",")
+
+# Same-class case (post-#430) still works.
+class Same
+  def items
+    @items = [] if @items.nil?
+    @items
+  end
+
+  def add(s)
+    items << s
+  end
+end
+
+s = Same.new
+s.add("x")
+s.add("y")
+puts s.items.join(":")

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

@@ -0,0 +1,6 @@
+2
+name bad
+body bad
+2
+a,b
+x:y

data/vendor/spinel/test/json_generate_basic.rb

@@ -0,0 +1,16 @@
+require "json"
+# JSON.generate over the common Hash/Array/scalar shapes. Compact
+# form, `:` separators, nil->null, symbol/int keys coerced to strings,
+# JSON string escaping. Nested structures recurse.
+puts JSON.generate({"x" => "y"})
+puts JSON.generate({"a" => 1, "b" => 2})
+puts JSON.generate({a: 1, b: 2})
+puts JSON.generate({a: "hi"})
+puts JSON.generate({"a" => [1, 2, 3], "b" => 5})
+puts JSON.generate({a: nil, b: true, c: false})
+puts JSON.generate([1, 2, 3])
+puts JSON.generate(["x", "y"])
+puts JSON.generate({"k" => "a\"b\nc\td"})
+puts JSON.generate({"nested" => {"x" => 1}})
+puts JSON.generate(42)
+puts JSON.dump({"d" => "dump"})

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

@@ -0,0 +1,12 @@
+{"x":"y"}
+{"a":1,"b":2}
+{"a":1,"b":2}
+{"a":"hi"}
+{"a":[1,2,3],"b":5}
+{"a":null,"b":true,"c":false}
+[1,2,3]
+["x","y"]
+{"k":"a\"b\nc\td"}
+{"nested":{"x":1}}
+42
+{"d":"dump"}

data/vendor/spinel/test/json_generate_struct_record.rb

@@ -0,0 +1,9 @@
+require "json"
+
+Rec = Struct.new(:id, :name)
+puts JSON.generate(Rec.new(1, "alice"))
+puts JSON.dump(Rec.new(2, "bob"))
+puts JSON.generate(Rec.new)
+
+Esc = Struct.new(:text)
+puts JSON.generate(Esc.new("a\"b\nc\td"))

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

@@ -0,0 +1,4 @@
+{"id":1,"name":"alice"}
+{"id":2,"name":"bob"}
+{"id":null,"name":null}
+{"text":"a\"b\nc\td"}

data/vendor/spinel/test/kernel_complex.rb

@@ -0,0 +1,9 @@
+# Kernel#Complex(re, im) builds a Complex value (imaginary part defaults
+# to 0). Previously the no-receiver Complex() call fell through to the
+# integer 0 fallback.
+p Complex(2, 3)
+p Complex(1)
+p Complex(2.5, -1.5)
+p Complex(0, 1)
+p(Complex(1, 2) + Complex(3, 4))
+p(Complex(2, 3) * Complex(1, 1))

data/vendor/spinel/test/kernel_dir.rb

@@ -0,0 +1,9 @@
+# Issue #878: Kernel#__dir__ returns the dirname of the source
+# file at compile time. The parser emits SOURCE_FILE <path> near
+# the AST head so the codegen can compute dirname without needing
+# the source to reference __FILE__.
+#
+# `caller` is intentionally NOT supported -- it would require per-
+# call frame tracking that slows the dispatch hot path.
+puts __dir__.is_a?(String)
+puts __dir__.length > 0

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

@@ -0,0 +1,2 @@
+true
+true

data/vendor/spinel/test/kernel_float_strict.rb

@@ -0,0 +1,16 @@
+# Issue #888: Kernel#Float() raises ArgumentError on unparseable
+# input per MRI; previously silently returned 0.0 from strtod.
+begin
+  Float("abc")
+rescue ArgumentError => e
+  puts "abc: " + e.message
+end
+begin
+  Float("")
+rescue ArgumentError => e
+  puts "empty: " + e.message
+end
+puts Float("3.14")
+puts Float("  42.5  ")
+puts Float(7)
+puts Float(2.5)

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

@@ -0,0 +1,6 @@
+abc: invalid value for Float(): "abc"
+empty: invalid value for Float(): ""
+3.14
+42.5
+7.0
+2.5

data/vendor/spinel/test/kernel_integer_with_base.rb

@@ -0,0 +1,16 @@
+# Issue #887: Kernel#Integer(s, base) parses non-decimal correctly
+# and raises catchable ArgumentError on invalid input.
+puts Integer("ff", 16)
+puts Integer("1010", 2)
+puts Integer("777", 8)
+puts Integer("z", 36)
+begin
+  Integer("zz", 16)
+rescue ArgumentError => e
+  puts "caught: " + e.message
+end
+begin
+  Integer("xyz", 8)
+rescue ArgumentError => e
+  puts "caught: " + e.message
+end

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

@@ -0,0 +1,6 @@
+255
+10
+511
+35
+caught: invalid value for Integer(): "zz"
+caught: invalid value for Integer(): "xyz"

data/vendor/spinel/test/kwarg_back_propagate_callee_type.rb

@@ -0,0 +1,26 @@
+# #561 (Sam Ruby). Kwarg passthrough back-propagation: when
+# method outer forwards `inner(name: lvar)` and inner's
+# `name:` is typed (default value or body usage), outer's
+# matching kwarg should pick up the callee's slot type
+# rather than defaulting to int. Pre-fix outer.s stayed int
+# and the C compile failed at the int -> const char *
+# coercion at the inner call site.
+#
+# This mirrors the positional callee_slot back-propagation
+# pass but keyed on kwarg name rather than position; the
+# kwarg path also accepts any concrete callee type
+# (string / int_array / hash variant / etc.) rather than
+# just ptr / obj.
+
+module Broadcasts
+  def self.append(stream:, target:, html:)
+    record(action: :append, stream: stream, target: target, html: html)
+  end
+
+  def self.record(action:, stream:, target:, html:)
+    out = action.to_s + "|" + stream + "|" + target + "|len=" + html.length.to_s
+    out
+  end
+end
+
+puts Broadcasts.append(stream: "s", target: "t", html: "<div>")

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

@@ -0,0 +1 @@
+append|s|t|len=5

data/vendor/spinel/test/kwargs_double_splat.rb

@@ -0,0 +1,15 @@
+# `foo(**h)` — double-splat a sym-keyed hash into the callee's
+# keyword params. Only the single-arg shape is wired here
+# (no positional + splat mixing); the splat hash must be
+# sym-keyed (sym_int/sym_str/sym_poly).
+def foo(a:, b:)
+  puts "a=#{a} b=#{b}"
+end
+h = {a: 1, b: 2}
+foo(**h)
+
+def bar(x:, y:, z:)
+  puts "#{x},#{y},#{z}"
+end
+h2 = {x: 10, y: 20, z: 30}
+bar(**h2)

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

@@ -0,0 +1,2 @@
+a=1 b=2
+10,20,30

data/vendor/spinel/test/kwargs_merge_default_hash.rb

@@ -0,0 +1,51 @@
+# `CONST.merge(opts)` where CONST is a Symbol-keyed hash and `opts`
+# is a method parameter with an empty-hash default (`def m(opts = {})`).
+# CRuby folds trailing keyword arguments into a Symbol-keyed positional
+# Hash when the callee declares no keyword params, so the kwargs reach
+# `opts` and `merge` dispatches sym-keyed. The empty default must also
+# merge cleanly (returning the receiver's defaults).
+#
+# Output is per-key (not hash#inspect) so it is independent of the
+# reference Ruby's hash formatting (3.2 `{:k=>v}` vs 3.4+ `{k: v}`).
+
+DEFAULTS = { timeout: 30, host: "localhost" }
+
+def configure(opts = {})
+  DEFAULTS.merge(opts)
+end
+
+# Keyword-call form: kwargs collapse into the positional hash.
+c1 = configure(timeout: 5)
+puts c1[:timeout]                 # 5  (override applied)
+puts c1[:host]                    # localhost (default kept)
+
+# No-arg form: the empty `{}` default merges to just the defaults.
+c2 = configure
+puts c2[:timeout]                 # 30
+puts c2[:host]                    # localhost
+
+# The same idiom inside a constructor, the shape the spinelgems
+# harvest cluster (rack-health, stream-chat-ruby, ...) uses.
+class Client
+  def initialize(opts = {})
+    @config = DEFAULTS.merge(opts)
+  end
+  def config; @config; end
+end
+
+c3 = Client.new(host: "example.com", timeout: 5).config
+puts c3[:timeout]                 # 5
+puts c3[:host]                    # example.com
+
+c4 = Client.new.config
+puts c4[:timeout]                 # 30
+puts c4[:host]                    # localhost
+
+# A method that genuinely declares keyword params must NOT collapse:
+# named kwargs bind to their own slots, and `**h` double-splat forwards.
+def greet(name:, greeting: "hi")
+  "#{greeting}, #{name}"
+end
+puts greet(name: "Ada")           # hi, Ada
+opts = { name: "Bob", greeting: "yo" }
+puts greet(**opts)                # yo, Bob

data/vendor/spinel/test/lambda_arrow_string_return.rb

@@ -0,0 +1,8 @@
+# An arrow lambda (`-> {}`, the sp_Val / sp_lam_* ABI, distinct from the
+# `lambda {}` proc-call ABI) returning a string literal round-trips its
+# value instead of the old hardcoded sp_lam_int(0) stub.
+f = -> { "arrow" }
+puts f.call
+
+g = -> { 7 }
+puts g.call

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

@@ -0,0 +1,2 @@
+arrow
+7

data/vendor/spinel/test/lambda_inference_chain.rb

@@ -0,0 +1,35 @@
+# Stress test: lambda parameter inference through a chain of top-level
+# methods. infer_lambda_param_types runs a fixed-point loop that
+# discovers `g`-as-lambda one hop at a time: f1's g is detected from
+# the direct `.call`, then f2 inherits because it passes its g to f1
+# (which now has lambda-typed param), then f3 inherits from f2, etc.
+# A chain of N methods needs N iterations to converge. With the new
+# 256-iteration safety cap and oscillation guard, this monotonic
+# 5-deep chain must converge cleanly without tripping either.
+
+def f1(g)
+  g.call(1)
+end
+
+def f2(g)
+  f1(g)
+end
+
+def f3(g)
+  f2(g)
+end
+
+def f4(g)
+  f3(g)
+end
+
+def f5(g)
+  f4(g)
+end
+
+double = ->(x) { x * 2 }
+puts f5(double)
+puts f4(double)
+puts f3(double)
+puts f2(double)
+puts f1(double)

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

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

data/vendor/spinel/test/local_empty_array_push_promotion_propagates.rb

@@ -0,0 +1,61 @@
+# #450 cascade 3. A local seeded with `[]` (default int_array)
+# whose subsequent push observations promote it to an obj-ptr_array:
+# the promoted element type needs to propagate back to (a) ivars
+# assigned from the local, and (b) the function's return type when
+# the local is the body's implicit return. Before the fix, both
+# sites pinned at sp_IntArray * based on the local's pre-promotion
+# type that scan_writer_calls / infer_body_return saw.
+
+class Item
+  attr_accessor :id, :name
+  def initialize
+    @id = 0
+    @name = ""
+  end
+end
+
+# (a) ivar = local with push promotion.
+class Holder
+  def initialize
+    @items = nil
+  end
+
+  def build
+    results = []
+    a = Item.new
+    a.id = 1
+    a.name = "first"
+    results << a
+    b = Item.new
+    b.id = 2
+    b.name = "second"
+    results << b
+    @items = results
+  end
+
+  def first_name
+    @items[0].name
+  end
+end
+
+h = Holder.new
+h.build
+puts h.first_name
+
+# (b) method returns the local-pushed-into.
+def collect_items
+  results = []
+  i = 0
+  while i < 3
+    item = Item.new
+    item.id = i
+    item.name = "item_" + i.to_s
+    results << item
+    i = i + 1
+  end
+  results
+end
+
+items = collect_items
+puts items.length
+puts items[1].name

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

@@ -0,0 +1,3 @@
+first
+3
+item_1

data/vendor/spinel/test/logical_pointer_guard.rb

@@ -0,0 +1,20 @@
+class Holder
+  def initialize
+    @text = nil
+  end
+
+  def attach
+    @text = "hi"
+  end
+
+  def active?
+    return false if @text && @text.length == 2
+
+    true
+  end
+end
+
+h = Holder.new
+puts h.active?
+h.attach
+puts h.active?

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

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

data/vendor/spinel/test/logical_value_return.rb

@@ -0,0 +1,15 @@
+def assert_equal(expected, actual)
+  if expected != actual
+    raise "logical value return mismatch"
+  end
+end
+
+assert_equal(2, 1 && 2)
+assert_equal(nil, nil && 2)
+assert_equal(nil, false || nil)
+assert_equal(false, false && 3)
+assert_equal(true, true || nil)
+assert_equal(nil, true && nil)
+assert_equal(4, false || 4)
+
+puts "ok"

data/vendor/spinel/test/lv_widen_from_callee_arg_slot.rb

@@ -0,0 +1,56 @@
+# Phase 3: LV back-propagation from callee arg slot.
+#
+# Body-derived widening of a callee's param (via
+# narrow_param_hash_types_from_body_writes) doesn't reach
+# the caller's local variable. The call site then passes
+# sp_StrIntHash * into a sp_StrPolyHash * slot.
+#
+# Shape (real-blog parse_request / parse_form_into):
+#
+#   def assign(into, k, v)
+#     # heterogeneous body — widens `into` to str_poly_hash
+#     if k.include?("[")
+#       into[k] = {}
+#     else
+#       into[k] = v
+#     end
+#   end
+#
+#   def parse(input, into)
+#     input.split("&").each { |p| assign(into, p, "v") }
+#   end
+#
+#   def run
+#     params = {}                     # str_int_hash by default
+#     parse("a=1&b=2", params)        # callee widens; params LV
+#                                     # needs to widen too
+#     params
+#   end
+#
+# Pre-fix the `params = {}` literal compiles as
+# sp_StrIntHash_new() and the call passes it to the
+# StrPolyHash slot — warns under -Wincompatible-pointer-types.
+# With this pass, params widens to str_poly_hash and the
+# literal lowers to sp_StrPolyHash_new() directly.
+
+module Form
+  def self.assign(into, k, v)
+    if k.include?("[")
+      into[k] = {}
+    else
+      into[k] = v
+    end
+  end
+
+  def self.parse(input, into)
+    input.split("&").each { |p| assign(into, p, "v") }
+  end
+
+  def self.run
+    params = {}
+    parse("a=1&b=2", params)
+    params["a"]
+  end
+end
+
+puts Form.run

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

@@ -0,0 +1 @@
+

data/vendor/spinel/test/map_block_string_new_join.rb

@@ -0,0 +1,33 @@
+# #526. Sibling to #522. #522 fixed `.map { String.new }` block-return
+# inference so the result is correctly typed as
+# `mutable_str_ptr_array` (a sp_PtrArray of sp_String*). But the
+# is_ptr_array_type recv block in codegen had no `join` arm for this
+# variant — `xs.map { String.new }.join(",")` fell through to the
+# unresolved-call warning and emitted 0 at the call site (compile-time
+# warning, runtime no-op producing empty output between separators in
+# the composite JSON-fragment use case in action_view/view_helpers).
+#
+# Fix: add the `join` arm in the ptr_array recv block (gated on
+# elem_type == "mutable_str") that emits sp_PtrArray_str_join, and the
+# matching runtime helper that reads each element's bytes via the
+# sp_String data/len pair.
+
+def make_str(x)
+  s = String.new
+  s << x.to_s
+  s
+end
+
+xs = [1, 2, 3]
+
+# The repro case from the issue: block returns String.new directly.
+puts xs.map { |x| String.new }.join(",")
+
+# Block body is a method call returning a mutable_str — mirrors the
+# real-world action_view/view_helpers pattern where the map block calls
+# something like `Views::Articles.article_json(article)` and the result
+# is joined with "," to form a JSON fragment.
+puts xs.map { |x| make_str(x) }.join("-")
+
+# Single-element (no separator emitted in output).
+puts [1].map { |x| make_str(x) }.join(",")

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

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

data/vendor/spinel/test/map_obj_array_poly_field.rb

@@ -0,0 +1,28 @@
+# map over an array of objects where the block returns a polymorphic
+# field (sp_RbVal) must collect into a PolyArray, not a PtrArray that
+# casts the sp_RbVal element through (void *).
+class Box
+  def initialize
+    @v = 0
+  end
+
+  def taint
+    @v = "x"
+  end
+
+  def v
+    @v
+  end
+end
+
+boxes = []
+boxes.push(Box.new)
+b2 = Box.new
+b2.taint
+boxes.push(b2)
+
+vs = boxes.map { |b| b.v }
+puts vs.length
+p vs
+p vs[0]
+p vs[1]