rubyduino 0.1.3 → 0.2.1

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

@@ -0,0 +1,15 @@
+Row
+Article
+Row
+Article
+true
+false
+true
+false
+true
+false
+true
+false
+true
+true
+true

data/vendor/spinel/test/class_reopen_replaces_methods.rb

@@ -0,0 +1,40 @@
+# #489. Two `class Foo` definitions in the same translation unit
+# (whether from two require_relative'd files or a single file with
+# re-opened class) previously emitted duplicate C function symbols
+# for each repeated method name (sp_Foo_go twice, etc.), failing
+# C compile with "redefinition of 'sp_Foo_go'". CRuby's semantics
+# are "last definition wins": the second body replaces the first
+# for any method with the same name; methods unique to either copy
+# survive. Fix: append_cls_meth / append_cls_cmeth detect a matching
+# existing entry and replace its row in the parallel arrays instead
+# of appending. Same shape repro across require_relative is fully
+# covered by this single-file reopen.
+
+class Foo
+  def initialize
+    @x = 1
+  end
+  def go
+    "first: " + @x.to_s
+  end
+  def only_first
+    "kept"
+  end
+end
+
+class Foo
+  def initialize
+    @x = 2
+  end
+  def go
+    "second: " + @x.to_s
+  end
+  def only_second
+    "added"
+  end
+end
+
+f = Foo.new
+puts f.go
+puts f.only_first
+puts f.only_second

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

@@ -0,0 +1,3 @@
+second: 2
+kept
+added

data/vendor/spinel/test/class_singleton_def.rb

@@ -0,0 +1,27 @@
+# Issue #719. `class << self; def X; ...; end; end` inside a class
+# body defines a singleton method on the enclosing class, equivalent
+# to `def self.X`. spinel used to leave the SingletonClassNode
+# unhandled in classes; only the module-side attr_accessor path
+# fired.
+
+class C
+  class << self
+    def cls_method; "singleton"; end
+    def with_arg(n); "got " + n.to_s; end
+  end
+end
+
+puts C.cls_method
+puts C.with_arg(42)
+
+# Mixed form: regular `def self.X` plus a `class << self` block
+# coexist in the same class.
+class D
+  def self.alpha; "a"; end
+  class << self
+    def beta; "b"; end
+  end
+end
+
+puts D.alpha
+puts D.beta

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

@@ -0,0 +1,4 @@
+singleton
+got 42
+a
+b

data/vendor/spinel/test/class_superclass.rb

@@ -0,0 +1,15 @@
+class A
+end
+
+class B < A
+end
+
+class C
+  def foo
+    1
+  end
+end
+
+puts A.superclass
+puts B.superclass
+puts C.superclass

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

@@ -0,0 +1,3 @@
+Object
+A
+Object

data/vendor/spinel/test/class_value_builtin_and_nested.rb

@@ -0,0 +1,36 @@
+# Followup to #404. Built-in exception classes (StandardError,
+# RuntimeError, ...) and nested user classes (M::Inner) used as
+# values must lower to sp_Class compound literals, the same way
+# flat user-class constants already did. Pre-fix the emit was a
+# bare C identifier (`StandardError`, `M_Inner`) that gcc rejected
+# with "use of undeclared identifier". Issue #637.
+
+# Shape A: built-in exception class as value.
+def takes_class(c)
+  puts c.name
+end
+
+takes_class(StandardError)
+takes_class(RuntimeError)
+takes_class(ArgumentError)
+
+# Class object via a local — round-trip through a value slot.
+c = StandardError
+puts c.name
+
+# Shape B: nested user class as value. Verify the value compiles
+# and survives a round-trip through a local; the displayed
+# `c.name` between spinel and MRI may differ (spinel uses `_` as
+# the internal separator), but `c == Inner-class` confirms the
+# value emit and equality semantics hold.
+module M
+  class Inner
+  end
+end
+
+def make
+  M::Inner
+end
+
+c2 = make
+puts c2 == M::Inner ? "round-trip ok" : "round-trip BROKEN"

data/vendor/spinel/test/cls_method_specialization_boxer.expected

@@ -0,0 +1,2 @@
+alice
+title!

data/vendor/spinel/test/cls_method_specialization_boxer.rb

@@ -0,0 +1,47 @@
+class Base
+  def self.from_row(row)
+    instance = new
+    if row.is_a?(CommentRow)
+      instance.commenter = row.commenter
+    elsif row.is_a?(ArticleRow)
+      instance.title = row.title
+    end
+    instance
+  end
+
+  def []=(field, value)
+    case field
+    when :commenter then @commenter = value
+    when :title then @title = value
+    when :body then @body = value
+    end
+  end
+end
+
+class Comment < Base
+  attr_accessor :commenter
+  attr_accessor :body
+end
+
+class Article < Base
+  attr_accessor :title
+end
+
+class CommentRow
+  attr_reader :commenter
+  def initialize(c); @commenter = c; end
+end
+
+class ArticleRow
+  attr_reader :title
+  def initialize(t); @title = t; end
+end
+
+seed = Comment.new
+seed[:body] = 42
+seed[:commenter] = "x"
+
+c = Comment.from_row(CommentRow.new("alice"))
+a = Article.from_row(ArticleRow.new("title!"))
+puts c.commenter
+puts a.title

data/vendor/spinel/test/cmeth_name_collision_with_kernel.rb

@@ -0,0 +1,56 @@
+# Issue #407 case 1: a class/module class method whose name
+# collides with a Kernel/Object inferred-type default (e.g.
+# `hash`, `to_s` is exempt because it actually works the right
+# way already; `inspect`, `methods`, ...) used to lose the
+# user-defined return type. `infer_method_name_type`'s arms have
+# shape `if mname == "hash"; return "int"; end` regardless of
+# receiver, so a `def self.hash(plain) -> String` on a class
+# resolved to "int" through the Kernel-side hash hardcode and
+# downstream locals widened to mrb_int -- the C compile then
+# tripped at the next site that fed the supposed-integer to a
+# `const char *` parameter.
+#
+# Fix: at the top of `infer_method_name_type`, return "" when
+# recv is a constant-class-or-module reference whose target
+# defines a class method named mname. This defers to the
+# receiver-aware resolution that `infer_constant_recv_type` runs
+# later (cls_cmethod_return_inherited / `<Mod>_cls_<m>` synth
+# lookup), so user-defined cmeths win over the Kernel-name
+# defaults exactly when the receiver pins them.
+#
+# Coverage:
+#   - module class method named `hash` returning String,
+#   - real-class class method named `methods` returning String,
+#   - real-class class method named `to_s` already had the right
+#     answer through other paths; `inspect` here exercises the
+#     same shape with a fresh name to lock the receiver-aware
+#     gate independently.
+
+module Auth
+  class Password
+    def self.hash(plain)
+      "pbkdf2$" + plain
+    end
+  end
+end
+
+stored = Auth::Password.hash("hunter2")
+puts stored                               # pbkdf2$hunter2
+puts stored.length.to_s                   # 14
+
+class Registry
+  def self.methods(prefix)
+    "[" + prefix + ":methods]"
+  end
+
+  def self.inspect_kind(kind)
+    "<Registry inspect: " + kind + ">"
+  end
+end
+
+names = Registry.methods("public")
+puts names                                # [public:methods]
+puts names.length.to_s                    # 16
+
+shape = Registry.inspect_kind("module")
+puts shape                                # <Registry inspect: module>

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

@@ -0,0 +1,5 @@
+pbkdf2$hunter2
+14
+[public:methods]
+16
+<Registry inspect: module>

data/vendor/spinel/test/cmeth_return_nil_or_obj_via_intermediate.rb

@@ -0,0 +1,89 @@
+# Issue #411. A class method that initializes a local to `nil`,
+# conditionally reassigns it through an intermediate variable, and
+# returns the local emitted with return type `mrb_int` even though
+# the local itself was correctly typed `sp_Foo *`:
+#
+#   static mrb_int sp_Bar_cls_find(void) {
+#       sp_Foo * lv_result = NULL;
+#       sp_Foo * lv_instance = NULL;
+#       lv_result = NULL;
+#       lv_instance = sp_Foo_new();
+#       lv_result = lv_instance;
+#       return lv_result;       // sp_Foo * -> mrb_int — fails
+#   }
+#
+# Root cause: `infer_all_returns`'s cmeth branch ran a single
+# `scan_locals` pass before calling `infer_body_return`. The first
+# pass typed `result` as "nil" (only the initial `result = nil`
+# was visible), so the tail expression `result` inferred as nil
+# and `unify_return_type` collapsed the cmeth's return to "nil"
+# -> `mrb_int`. The local-decl precompute later upgraded the
+# local correctly via `refine_method_body_locals`'s 2-pass logic
+# ("nil + nullable_pointer_type -> obj_<C>?"), but by that point
+# `@cls_cmeth_returns` was already pinned at "nil".
+#
+# Fix: replace the single-pass scan_locals in
+# `infer_all_returns`'s cmeth branch with a
+# `refine_method_body_locals` call so the multi-pass refinement
+# runs before `infer_body_return` reads the tail.
+#
+# Coverage:
+#   - the canonical Rails-style `_adapter_find_by_id` shape with
+#     intermediate variable (the issue's repro),
+#   - same shape returning the local directly through an `if/else`
+#     branch (no intermediate, regression check that the existing
+#     direct path still works),
+#   - the simple `nil`-fallback flow control (`return nil unless
+#     ...`) to confirm the unify-with-nil tail still resolves
+#     correctly to `obj_<C>?`.
+
+class Foo
+  attr_accessor :tag
+  attr_accessor :flag
+  def initialize(tag)
+    @tag = tag
+    @flag = 0
+  end
+end
+
+class Bar
+  def self.find(t)
+    result = nil
+    if t == "yes"
+      instance = Foo.new("found")
+      result = instance
+    end
+    result
+  end
+
+  def self.find_direct(t)
+    result = nil
+    if t == "yes"
+      result = Foo.new("direct")
+    end
+    result
+  end
+
+  def self.maybe(t)
+    return nil unless t == "yes"
+    Foo.new("maybe")
+  end
+end
+
+x = Bar.find("yes")
+puts x.nil? ? "nil" : x.tag       # found
+
+y = Bar.find("no")
+puts y.nil? ? "nil" : y.tag       # nil
+
+a = Bar.find_direct("yes")
+puts a.nil? ? "nil" : a.tag       # direct
+
+b = Bar.find_direct("no")
+puts b.nil? ? "nil" : b.tag       # nil
+
+c = Bar.maybe("yes")
+puts c.nil? ? "nil" : c.tag       # maybe
+
+d = Bar.maybe("no")
+puts d.nil? ? "nil" : d.tag       # nil

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

@@ -0,0 +1,6 @@
+found
+nil
+direct
+nil
+maybe
+nil

data/vendor/spinel/test/comparable_between_user_type.rb

@@ -0,0 +1,26 @@
+# Comparable#between? on a user type (`self >= min && self <= max`) must
+# dispatch through the class's <=>, not a raw struct comparison which
+# gcc rejects ("invalid operands to binary >="). Direct </>/<=/>= on
+# such types already worked via <=>; between? now does too.
+class Temp
+  include Comparable
+  attr_reader :deg
+  def initialize(d); @deg = d; end
+  def <=>(other); @deg <=> other.deg; end
+end
+
+a = Temp.new(10)
+puts a.between?(Temp.new(5), Temp.new(15))    # true
+puts a.between?(Temp.new(10), Temp.new(15))   # true (inclusive low)
+puts a.between?(Temp.new(5), Temp.new(10))    # true (inclusive high)
+puts a.between?(Temp.new(11), Temp.new(15))   # false
+puts a.between?(Temp.new(1), Temp.new(9))     # false
+
+# Direct comparisons still route through <=>
+puts (Temp.new(3) < Temp.new(7))
+puts (Temp.new(7) >= Temp.new(7))
+
+# Built-in receivers unaffected
+puts 5.between?(1, 10)
+puts "m".between?("a", "z")
+puts 2.5.between?(1.0, 3.0)

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

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

data/vendor/spinel/test/compile_time_attribute_singular.rb

@@ -0,0 +1,12 @@
+class CompileTimeSingleAttribute
+  attribute :name
+
+  def initialize(name)
+    @name = name
+  end
+end
+
+obj = CompileTimeSingleAttribute.new("Ada")
+puts obj.name
+obj.name = "Grace"
+puts obj.name

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

@@ -0,0 +1,2 @@
+Ada
+Grace

data/vendor/spinel/test/compile_time_attribute_wrapped_record.rb

@@ -0,0 +1,72 @@
+Record = Struct.new(:published)
+
+class WrappedResult
+  attributes :ok
+  attributes :status
+
+  def initialize(ok, status, record_present, record)
+    @ok = ok
+    @status = status
+    @record_present = record_present
+    @record = record
+  end
+
+  def ok?
+    @ok
+  end
+
+  def record
+    return nil if @record_present == 0
+
+    @record
+  end
+end
+
+class ActionResult
+  attributes :status
+  attributes :error
+
+  def initialize(status, record_present, record, error)
+    @status = status
+    @record_present = record_present
+    @record = record
+    @error = error
+  end
+
+  def record
+    return nil if @record_present == 0
+
+    @record
+  end
+end
+
+class ActionContext
+  def ok(record)
+    ActionResult.new(200, 1, record, "")
+  end
+
+  def error(status, message)
+    ActionResult.new(status, 0, Record.new(""), message)
+  end
+end
+
+class ManualAction
+  def self.call(input, context)
+    context.ok(Record.new("manual:reviewed"))
+  end
+end
+
+class Domain
+  def manual_publish
+    action_result = ManualAction.call(0, ActionContext.new)
+    if action_result.status >= 400 || action_result.error.length > 0
+      return WrappedResult.new(false, action_result.status, 0, Record.new(""))
+    end
+
+    WrappedResult.new(true, action_result.status, 1, action_result.record)
+  end
+end
+
+result = Domain.new.manual_publish
+puts result.ok?
+puts result.record.published

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

@@ -0,0 +1,2 @@
+true
+manual:reviewed

data/vendor/spinel/test/compile_time_attributes.rb

@@ -0,0 +1,14 @@
+class CompileTimeAttributeHolder
+  attributes :name, :count
+
+  def initialize(name, count)
+    @name = name
+    @count = count
+  end
+end
+
+holder = CompileTimeAttributeHolder.new("Ada", 2)
+puts holder.name
+puts holder.count
+holder.count = 5
+puts holder.count

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

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

data/vendor/spinel/test/compile_time_define_method_direct.rb

@@ -0,0 +1,8 @@
+class CompileTimeDirectDefineMethod
+  define_method(:answer) { 42 }
+  define_method("greeting") { "hello" }
+end
+
+obj = CompileTimeDirectDefineMethod.new
+puts obj.answer
+puts obj.greeting

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

@@ -0,0 +1,2 @@
+42
+hello

data/vendor/spinel/test/compile_time_define_method_int.rb

@@ -0,0 +1,9 @@
+class CompileTimeIntMethods
+  [1, 2].each do |n|
+    define_method("value_#{n}") { n }
+  end
+end
+
+obj = CompileTimeIntMethods.new
+puts obj.value_1
+puts obj.value_2

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

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

data/vendor/spinel/test/compile_time_define_method_predicates.rb

@@ -0,0 +1,18 @@
+class CompileTimePostState
+  attributes :state
+
+  def initialize(state)
+    @state = state
+  end
+
+  %i[draft published].each do |state|
+    define_method("#{state}?") { @state == state }
+  end
+end
+
+post = CompileTimePostState.new(:draft)
+puts post.draft?
+puts post.published?
+post.state = :published
+puts post.draft?
+puts post.published?

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

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

data/vendor/spinel/test/compile_time_define_method_strings.rb

@@ -0,0 +1,9 @@
+class CompileTimeStringMethods
+  ["red", "blue"].each do |name|
+    define_method("label_#{name}") { name }
+  end
+end
+
+obj = CompileTimeStringMethods.new
+puts obj.label_red
+puts obj.label_blue

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

@@ -0,0 +1,2 @@
+red
+blue

data/vendor/spinel/test/complex_polar.rb

@@ -0,0 +1,37 @@
+# Built-in `Complex` value type. Surfaced via optcarrot's
+# `nestopia_palette`:
+#   iq = Complex.polar(s, theta)
+#   iq += Complex.polar(level1, theta2)
+#   clr = y + (Complex.polar(g, t) * iq.conjugate).real
+#
+# Spinel models Complex as a 16-byte value type (sp_Complex with
+# `re` and `im` fields). Allocation-free; passes by value.
+# Methods: `Complex.polar(magnitude, angle)`, instance-side
+# `.real / .imaginary / .conjugate`, plus `+ *` between two
+# Complex values.
+
+# Polar form: r=2, theta=0 → (2, 0)
+a = Complex.polar(2.0, 0.0)
+puts a.real            # 2.0
+puts a.imaginary       # 0.0
+
+# r=1, theta=PI/2 → (~0, 1)
+b = Complex.polar(1.0, Math::PI / 2)
+puts b.real.abs < 1e-9    # true (cos(pi/2) ~ 0)
+puts (b.imaginary - 1.0).abs < 1e-9  # true
+
+# Addition: a + b
+c = a + b
+puts (c.real - 2.0).abs < 1e-9       # true
+puts (c.imaginary - 1.0).abs < 1e-9  # true
+
+# Conjugate flips the sign of imag
+d = b.conjugate
+puts d.real.abs < 1e-9    # true
+puts (d.imaginary + 1.0).abs < 1e-9  # true
+
+# Multiplication: (1, 1) * (1, -1) = (1*1 - 1*-1, 1*-1 + 1*1) = (2, 0)
+e = Complex.polar(Math.sqrt(2), Math::PI / 4)  # ~ (1, 1)
+f = e * e.conjugate                            # |e|^2 = 2 + 0i
+puts (f.real - 2.0).abs < 1e-9       # true
+puts f.imaginary.abs < 1e-9          # true

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

@@ -0,0 +1,10 @@
+2.0
+0.0
+true
+true
+true
+true
+true
+true
+true
+true

data/vendor/spinel/test/concat_chain_operand_gc_root.rb

@@ -0,0 +1,16 @@
+# A chained string concat `a + b + c` lowers to sp_str_concat3 (and
+# `a+b+c+d` to sp_str_concat4). The operands must be rooted before the
+# call: argument evaluation order is unspecified, so a fresh GC string
+# produced by one operand can be collected while a sibling operand
+# allocates. Here each tag() allocates and forces a GC, so a later
+# operand's GC.start collects an earlier operand's unrooted result.
+def tag(s)
+  r = "[" + s + "]"   # fresh heap string
+  GC.start            # collect; pre-fix frees sibling operands still pending
+  r
+end
+
+three = tag("a") + "\n" + tag("b") + "\n" + tag("c")
+four  = tag("w") + tag("x") + tag("y") + tag("z")
+puts three
+puts four

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

@@ -0,0 +1,4 @@
+[a]
+[b]
+[c]
+[w][x][y][z]