galaaz 0.5.0 → 2.0.0

data/specs/phase2_gknit_generic_rendering_guardrail_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+describe 'Phase 2 gknit generic rendering guardrail' do
+  it 'does not contain plotting-class-specific branches in gknit engine code' do
+    root = File.expand_path('..', __dir__)
+    targets = [
+      File.join(root, 'lib/gknit/knitr_engine.rb'),
+      File.join(root, 'lib/gknit/ruby_engine.rb'),
+      File.join(root, 'lib/gknit/rb_engine.rb'),
+      File.join(root, 'lib/gknit/include_engine.rb')
+    ]
+
+    # Guard only executable lines (skip comments/blank lines).
+    branch_tokens = [
+      /if\b.*\bggplot\b/,
+      /case\b.*\bggplot\b/,
+      /when\b.*\bggplot\b/,
+      /if\b.*\blattice\b/,
+      /case\b.*\blattice\b/,
+      /when\b.*\blattice\b/,
+      /if\b.*\bgrid\b/,
+      /case\b.*\bgrid\b/,
+      /when\b.*\bgrid\b/,
+      /inherits\s*\(.*["']ggplot["']/,
+      /inherits\s*\(.*["']lattice["']/,
+      /\bis\.ggplot\b/,
+      /\bclass\s*\(.*\).*ggplot/
+    ]
+
+    hits = []
+
+    targets.each do |path|
+      File.readlines(path, chomp: true).each_with_index do |line, idx|
+        stripped = line.strip
+        next if stripped.empty? || stripped.start_with?('#')
+
+        if branch_tokens.any? { |rx| stripped.match?(rx) }
+          rel = path.sub("#{root}/", '')
+          hits << "#{rel}:#{idx + 1}: #{stripped}"
+        end
+      end
+    end
+
+    expect(hits).to eq([])
+  end
+end

data/specs/phase2_gknit_no_raw_code_leakage_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+require 'open3'
+
+describe 'Phase 2 gknit raw code leakage' do
+  it 'does not leak unevaluated ruby source when echo is FALSE' do
+    root = File.expand_path('..', __dir__)
+    tmp_root = File.join(root, 'tmp')
+    FileUtils.mkdir_p(tmp_root)
+    work = Dir.mktmpdir('gknit_phase2_no_leak_', tmp_root)
+    input = File.join(work, 'fixture.Rmd')
+    output = File.join(work, 'rendered.md')
+
+    File.write(input, <<~RMD)
+      ---
+      title: "phase2-no-leak"
+      output:
+        github_document: default
+      ---
+
+      ```{ruby, echo=FALSE, eval=TRUE, include=TRUE}
+      leak_source_line = "PHASE2_RAW_SOURCE_SHOULD_NOT_LEAK"
+      puts "PHASE2_EVALUATED_OUTPUT_OK"
+      ```
+    RMD
+
+    begin
+      rel_input = input.sub("#{root}/", '')
+      cmd = ['bin/gknit', '-f', rel_input, '--output_format', 'github_document', '-o', 'rendered.md']
+      stdout, stderr, status = Open3.capture3(*cmd, chdir: root)
+      expect(status.success?).to eq(true), "gknit failed:\nSTDOUT:\n#{stdout}\nSTDERR:\n#{stderr}"
+
+      rendered = File.read(output)
+      expect(rendered).to include('PHASE2_EVALUATED_OUTPUT_OK')
+      expect(rendered).not_to include('PHASE2_RAW_SOURCE_SHOULD_NOT_LEAK')
+      expect(rendered).not_to include('leak_source_line =')
+    ensure
+      FileUtils.rm_rf(work) if work && File.directory?(work)
+    end
+  end
+end

data/specs/phase3_gknit_generic_graphics_capture_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+require 'open3'
+
+describe 'Phase 3 gknit generic graphics capture' do
+  def render_github_doc(input_path, output_filename = 'rendered.md')
+    root = File.expand_path('..', __dir__)
+    rel_input = input_path.sub("#{root}/", '')
+    cmd = ['bin/gknit', '-f', rel_input, '--output_format', 'github_document', '-o', output_filename]
+    Open3.capture3(*cmd, chdir: root)
+  end
+
+  it 'captures and includes base/grid/ggplot figures generically' do
+    root = File.expand_path('..', __dir__)
+    tmp_root = File.join(root, 'tmp')
+    FileUtils.mkdir_p(tmp_root)
+    work = Dir.mktmpdir('gknit_phase3_graphics_', tmp_root)
+    input = File.join(work, 'fixture.Rmd')
+    output = File.join(work, 'rendered.md')
+
+    begin
+      File.write(input, <<~RMD)
+        ---
+        title: "phase3-generic-graphics"
+        output:
+          github_document: default
+        ---
+
+        This document mixes multiple graphics systems.
+
+        ```{ruby, echo=FALSE, eval=TRUE, include=TRUE}
+        R.plot(R.c(1, 2, 3), R.c(1, 4, 9), type: "b")
+        ```
+
+        ```{ruby, echo=FALSE, eval=TRUE, include=TRUE}
+        R::Support.eval("grid::grid.newpage(); grid::grid.rect(gp = grid::gpar(fill='grey85'))")
+        ```
+
+        ```{ruby, echo=FALSE, eval=TRUE, include=TRUE}
+        unless R::Support.eval("requireNamespace('ggplot2', quietly=TRUE)") == true
+          raise "ggplot2 is not available"
+        end
+        R::Support.eval("p <- ggplot2::ggplot(mtcars, ggplot2::aes(wt, mpg)) + ggplot2::geom_point(); print(p)")
+        ```
+      RMD
+
+      stdout, stderr, status = render_github_doc(input)
+      expect(status.success?).to eq(true), "gknit failed:\nSTDOUT:\n#{stdout}\nSTDERR:\n#{stderr}"
+      expect(File.exist?(output)).to eq(true)
+
+      md = File.read(output)
+      expect(md).to include('phase3-generic-graphics')
+      expect(stderr).not_to include('ggplot2 is not available')
+      fig_dir = File.join(work, 'rendered_files', 'figure-gfm')
+      expect(File.directory?(fig_dir)).to eq(true)
+
+      # gknit/github_document should emit markdown image markup so pandoc can
+      # render figures consistently across output formats.
+      image_paths = md.scan(%r{!\[\]\((rendered_files/figure-gfm/[^\)]+)\)}).flatten
+      expect(image_paths.length).to be >= 3
+      image_paths.each do |rel|
+        rel = rel.sub(%r{^\./}, '')
+        expect(File.exist?(File.join(work, rel))).to eq(true), "missing figure artifact: #{rel}"
+      end
+    ensure
+      FileUtils.rm_rf(work) if work && File.directory?(work)
+    end
+  end
+end

data/specs/plot_device_semantics_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe R::Device do
+  it 'renders a base plot to png and writes a non-empty artifact' do
+    dev = R::Device.new('png', width: 4, height: 3, dpi: 96)
+    dev.open
+    R.barplot(R.c(2, 5, 3, 4))
+    dev.close
+
+    path = dev.instance_variable_get(:@dev_path)
+    expect(path).not_to be_nil
+    expect(File.exist?(path)).to eq(true)
+    expect(File.size(path)).to be > 0
+  end
+
+  it 'supports block form for svg device and writes artifact' do
+    dev = R::Device.new('svg', width: 4, height: 3, dpi: 96) do
+      R.plot(R.c(1, 2, 3, 4))
+    end
+
+    path = dev.instance_variable_get(:@dev_path)
+    expect(path).not_to be_nil
+    expect(File.exist?(path)).to eq(true)
+    expect(File.size(path)).to be > 0
+  end
+end

data/specs/plot_snapshot_semantics_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+require 'tmpdir'
+
+describe 'Plot snapshot/save semantics' do
+  it 'captures and saves recorded plot via R::Device helpers in plain runtime' do
+    work = Dir.mktmpdir('plot_snapshot_')
+
+    begin
+      Dir.chdir(work) do
+        dev = R::Device.new('png', width: 4, height: 3, dpi: 96, record: true)
+        dev.open
+        R.barplot(R.c(3, 1, 4, 2))
+        snap = dev.plot_snapshot
+        out_file = dev.save_plot(snap, 'snapshot_test', 'png', 4, 3, 'png', 96)
+        dev.close
+
+        path = File.join(work, out_file.to_s)
+        expect(File.exist?(path)).to eq(true)
+        expect(File.size(path)).to be > 0
+      end
+    ensure
+      FileUtils.rm_rf(work) if work && File.directory?(work)
+    end
+  end
+
+  it 'captures snapshots across plot pages and saves both artifacts' do
+    work = Dir.mktmpdir('plot_snapshot_multi_')
+
+    begin
+      Dir.chdir(work) do
+        dev = R::Device.new('png', width: 4, height: 3, dpi: 96, record: true)
+        dev.open
+
+        R.barplot(R.c(2, 5, 3, 4))
+        snap1 = dev.plot_snapshot
+        out1 = dev.save_plot(snap1, 'snapshot_page1', 'png', 4, 3, 'png', 96)
+
+        R::Support.eval('grid::grid.newpage(recording = TRUE)')
+        R.plot(R.c(1, 2, 3, 4))
+        snap2 = dev.plot_snapshot
+        out2 = dev.save_plot(snap2, 'snapshot_page2', 'png', 4, 3, 'png', 96)
+
+        dev.close
+
+        path1 = File.join(work, out1.to_s)
+        path2 = File.join(work, out2.to_s)
+        expect(File.exist?(path1)).to eq(true)
+        expect(File.size(path1)).to be > 0
+        expect(File.exist?(path2)).to eq(true)
+        expect(File.size(path2)).to be > 0
+      end
+    ensure
+      FileUtils.rm_rf(work) if work && File.directory?(work)
+    end
+  end
+end

data/specs/protocol_result_spec.rb

@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+# Phase 5: Per-call result protocol — all returns via result buffer (no fallback).
+# These specs assert that eval and exec_function return correct types from the
+# protocol envelope. When Phase 5 is complete (fallback removed), these tests
+# ensure every result path goes through the buffer.
+
+require 'galaaz'
+
+describe "Result protocol (Phase 5)" do
+
+  context "R::Support.eval returns via protocol envelope" do
+
+    it "returns scalar double as Float" do
+      v = R::Support.eval("3.14")
+      expect(v).to be_a(Numeric)
+      expect(v).to eq 3.14
+    end
+
+    it "returns scalar integer as Numeric (unboxed)" do
+      v = R::Support.eval("42L")
+      expect(v).to be_a(Numeric)
+      expect(v).to eq 42
+    end
+
+    it "returns scalar logical as true/false" do
+      expect(R::Support.eval("TRUE")).to eq true
+      expect(R::Support.eval("FALSE")).to eq false
+    end
+
+    it "returns scalar symbol as Ruby Symbol" do
+      v = R::Support.eval("as.symbol('foo')")
+      expect(v).to be_a(Symbol)
+      expect(v).to eq :foo
+    end
+
+    it "returns length-1 character as R::Vector (not unboxed)" do
+      v = R::Support.eval("'hello'")
+      expect(v).to be_a(R::Vector)
+      expect(v.length).to eq 1
+    end
+
+    it "returns vector (handle) as R::Vector with correct class" do
+      v = R::Support.eval("c(1, 2, 3)")
+      expect(v).to be_a(R::Vector)
+      rcls = v.rclass.to_s
+      expect(rcls).to match(/numeric|integer/)
+    end
+
+    it "returns list (handle) as R::List" do
+      v = R::Support.eval("list(1, 'a', TRUE)")
+      expect(v).to be_a(R::List)
+      expect(v.length).to be >= 1
+    end
+
+    it "returns matrix (handle) as R::Matrix" do
+      v = R::Support.eval("matrix(1:4, nrow = 2)")
+      expect(v).to be_a(R::Matrix)
+    end
+
+    it "returns data.frame (handle) as R::DataFrame" do
+      v = R::Support.eval("data.frame(a = 1:2, b = c('x', 'y'))")
+      expect(v).to be_a(R::DataFrame)
+    end
+
+    it "returns function (handle) as R::Closure" do
+      v = R::Support.eval("identity")
+      expect(v).to be_a(R::Closure)
+    end
+  end
+
+  context "R::Support.exec_function returns via protocol envelope" do
+
+    it "c() returns R::Vector" do
+      v = R::Support.exec_function("c", 1, 2, 3)
+      expect(v).to be_a(R::Vector)
+    end
+
+    it "list() returns R::List" do
+      v = R::Support.exec_function("list", 1, "x")
+      expect(v).to be_a(R::List)
+    end
+
+    it "matrix() returns R::Matrix" do
+      v = R::Support.exec_function("matrix", R.c(1, 2, 3, 4), 2)
+      expect(v).to be_a(R::Matrix)
+    end
+
+    it "identity (function) returns R::Closure" do
+      v = R::Support.exec_function("identity", 42)
+      expect(v).to eq 42
+    end
+
+    it "length() returns R object (protocol handle or scalar)" do
+      vec = R.c(1, 2, 3)
+      # length is special-cased to not unbox; returns R::Vector
+      v = R::Support.exec_function("length", vec)
+      expect(v).to be_a(R::Object)
+      expect(vec.length).to eq 3  # Vector#length uses unboxed_get
+    end
+  end
+
+  context "Public API uses protocol (R.c, R.list, ~R[:sym])" do
+
+    it "R.c builds vector via protocol" do
+      v = R.c(1, 2, 3)
+      expect(v).to be_a(R::Vector)
+      expect(v.length).to eq 3
+    end
+
+    it "R.list builds list via protocol" do
+      v = R.list(1, "a")
+      expect(v).to be_a(R::List)
+    end
+
+    it "~R[:x] retrieves object via protocol" do
+      R::Support.eval("x_protocol_test <- c(10, 20)")
+      v = ~R[:x_protocol_test]
+      expect(v).to be_a(R::Vector)
+      expect(v[1]).to eq 10
+    end
+  end
+
+  # Phase A (BasicObject migration): ensure R::Object has the explicit Ruby surface
+  # we need. Run with protocol + minimal set to catch regressions.
+  context "R::Object Ruby surface (Phase A — BasicObject migration)" do
+
+    let(:vec) { R.c(1, 2, 3) }
+    let(:lst) { R.list(1, "a") }
+
+    it "responds to class and returns the concrete Ruby class" do
+      expect(vec).to respond_to(:class)
+      expect(vec.class).to eq R::Vector
+      expect(lst.class).to eq R::List
+    end
+
+    it "responds to to_s and returns a string (R print output)" do
+      expect(vec).to respond_to(:to_s)
+      expect(vec.to_s).to be_a(String)
+      expect(vec.to_s).to match(/[1-3]/)
+    end
+
+    it "responds to respond_to? and reports explicit and forwarded methods" do
+      expect(vec).to respond_to(:respond_to?)
+      expect(vec.respond_to?(:r_interop)).to eq true
+      expect(vec.respond_to?(:length)).to eq true
+      expect(vec.respond_to?(:class)).to eq true
+      expect(vec.respond_to?(:>>)).to eq true
+      expect(vec.respond_to?(:[])).to eq true
+    end
+
+    it "responds to is_a? and kind_of? with correct type checks" do
+      expect(vec).to respond_to(:is_a?)
+      expect(vec).to respond_to(:kind_of?)
+      expect(vec.is_a?(R::Vector)).to eq true
+      expect(vec.is_a?(R::Object)).to eq true
+      expect(vec.kind_of?(R::Vector)).to eq true
+      expect(vec.is_a?(R::List)).to eq false
+    end
+
+    it "responds to instance_of? with correct class check" do
+      expect(vec).to respond_to(:instance_of?)
+      expect(vec.instance_of?(R::Vector)).to eq true
+      expect(vec.instance_of?(R::Object)).to eq false
+    end
+
+    it "responds to inspect and returns a string with class and handle" do
+      expect(vec).to respond_to(:inspect)
+      expect(vec.inspect).to be_a(String)
+      expect(vec.inspect).to include("R::Vector")
+      expect(vec.inspect).to include("r_interop")
+    end
+
+    it "responds to object_id and returns an integer" do
+      expect(vec).to respond_to(:object_id)
+      expect(vec.object_id).to be_a(Integer)
+      expect(vec.object_id).to eq vec.__id__
+    end
+  end
+
+  # Phase 1 performance: gatekeeper sends stable wrapper_tag on handle results (docs/performance_plan.md).
+  context "eval_r_with_result handle envelopes include wrapper_tag" do
+    def envelope_for_rhs(rhs_r)
+      vn = R::Support.generate_var_name
+      R.bridge.eval_r_with_result("#{vn} <- #{rhs_r}")
+    end
+
+    it "tags multi-element vector" do
+      env = envelope_for_rhs("c(1L, 2L, 3L)")
+      expect(env[:type]).to eq(:handle)
+      expect(env[:wrapper_tag]).to eq("vector")
+    end
+
+    it "tags data.frame" do
+      env = envelope_for_rhs("data.frame(a = 1:2, b = c('u', 'v'))")
+      expect(env[:type]).to eq(:handle)
+      expect(env[:wrapper_tag]).to eq("data_frame")
+    end
+
+    it "tags matrix" do
+      env = envelope_for_rhs("matrix(1:4, nrow = 2)")
+      expect(env[:type]).to eq(:handle)
+      expect(env[:wrapper_tag]).to eq("matrix")
+    end
+
+    it "tags list" do
+      env = envelope_for_rhs("list(1L, 'a', TRUE)")
+      expect(env[:type]).to eq(:handle)
+      expect(env[:wrapper_tag]).to eq("list")
+    end
+
+    it "tags closure" do
+      env = envelope_for_rhs("identity")
+      expect(env[:type]).to eq(:handle)
+      expect(env[:wrapper_tag]).to eq("closure")
+    end
+
+    it "tags environment" do
+      env = envelope_for_rhs("new.env()")
+      expect(env[:type]).to eq(:handle)
+      expect(env[:wrapper_tag]).to eq("environment")
+    end
+
+    it "tags language (call)" do
+      env = envelope_for_rhs("quote(1 + 2)")
+      expect(env[:type]).to eq(:handle)
+      expect(env[:wrapper_tag]).to eq("language")
+    end
+
+    it "omits wrapper_tag for scalar results" do
+      vn = R::Support.generate_var_name
+      env = R.bridge.eval_r_with_result("#{vn} <- 42L")
+      expect(env[:type]).to eq(:scalar_integer)
+      expect(env).not_to have_key(:wrapper_tag)
+    end
+  end
+end

data/specs/r_batch_fail_fast_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'R.batch (Phase 4 — fail-fast multi-op bridge)' do
+  it 'returns one legacy envelope per op when all succeed' do
+    a = R::Support.generate_var_name
+    b = R::Support.generate_var_name
+    c = R::Support.generate_var_name
+
+    res = R.batch do |batch|
+      batch.eval_with_result("#{a} <- 10L")
+      batch.eval_with_result("#{b} <- #{a} + 5L")
+      batch.eval_with_result("#{c} <- #{b} * 2L")
+    end
+
+    expect(res.size).to eq(3)
+    expect(res[0][:type]).to eq(:scalar_integer)
+    expect(res[0][:value]).to eq(10)
+    expect(res[1][:value]).to eq(15)
+    expect(res[2][:value]).to eq(30)
+  end
+
+  it 'raises BatchEvaluationError on first failing op with 0-based index' do
+    v1 = R::Support.generate_var_name
+    v3 = R::Support.generate_var_name
+
+    err = nil
+    expect do
+      R.batch do |batch|
+        batch.eval_with_result("#{v1} <- 1L")
+        batch.eval_with_result("stop('galaaz_batch_intentional_failure')")
+        batch.eval_with_result("#{v3} <- 99L")
+      end
+    end.to raise_error(R::BatchEvaluationError) { |e| err = e }
+
+    expect(err.failed_index).to eq(1)
+    expect(R::Support.eval(v1)).to eq(1)
+    expect { R::Support.eval(v3) }.to raise_error(NewBridge::SessionClient::RProcessError, /not found/i)
+  end
+
+  it 'rejects empty batch' do
+    expect do
+      R.batch { |_b| }
+    end.to raise_error(ArgumentError, /at least one/)
+  end
+end

data/specs/r_bridge_bootstrap_spec.rb

@@ -0,0 +1,11 @@
+require 'galaaz'
+
+describe 'R bridge bootstrap' do
+  it 'uses NewBridge adapter' do
+    expect(R.bridge).to be_a(R::NewBridgeAdapter)
+  end
+
+  it 'does not expose shadow bridge selector API' do
+    expect(R.respond_to?(:shadow_bridge_selected?)).to eq(false)
+  end
+end

data/specs/r_devices.spec.rb

@@ -30,7 +30,7 @@ describe R do
     # Read the R ToothGrowth variable and assign it to the
     # Ruby instance variable @tooth_growth that will be 
     # available to all Ruby chunks in this document.
-    @tooth_growth = ~:ToothGrowth
+    @tooth_growth = ~R[:ToothGrowth]
     
     # convert the dose to a factor
     @tooth_growth.dose = @tooth_growth.dose.as__factor

data/specs/r_eval.spec.rb

@@ -45,33 +45,31 @@ describe R do
 
     it "Interop pointers can be operated through eval" do
       var = R::Support.eval("5L")
-      # calling method 'class' on var returns a vector of size one with a string that
-      # contains the class of the object
-      expect("integer").to eq R::Support.eval("class").call(var).to_s
+      # class(var) returns length-1 character (boxed); unbox to scalar for comparison
+      expect("integer").to eq (R::Support.eval("class").call(var) >> 0)
     end
     
     it "A number evaluated in R is automatically unboxed as float in Ruby" do
       var = R::Support.eval("4")
       expect(4.0).to eq var
-      expect("numeric").to eq R::Support.eval("class").call(var).to_s
+      expect("numeric").to eq (R::Support.eval("class").call(var) >> 0)
     end
 
     it "R vectors can be indexed by the indexing method of the host language" do
       var = R::Support.eval("'Hello'")
-      expect(var[0]).to eq "Hello"
+      expect(var[1]).to eq "Hello"
     end
 
-    it "should retrieve named R objects to Ruby variables using eval. Returned value should be an Interop" do
+    it "should retrieve named R objects to Ruby variables using eval. Returned value should be an R::Object" do
       # retrieve x and hyp from R and attribute it to local Ruby variables
       x = R::Support.eval("x")
       # hyp is an R function and works like a named function in Ruby
       hyp = R::Support.eval("hyp")
 
-      # is is a foreign object
-      expect(Truffle::Interop.foreign?(x)).to be true
-      # we can index the object starting at 0.  This is a property offered by
-      # Interop API
-      expect(x[0]).to eq 1.0
+      # In Galaaz 2.0 we get R::Object wrappers (no Truffle interop)
+      expect(x).to be_a(R::Object)
+      # Indexing: R uses 1-based; we can get first element with [1] or >> 0
+      expect(x[1]).to eq 1.0
 
       # calling a named function or block is done by use of the 'call' method
       expect(hyp.call(3, 4)).to eq 5.0
@@ -83,12 +81,12 @@ describe R do
     
     it "should retrieve named R objects to Ruby variables by using '~' " do
       # retrieve x and hyp from R and attribute it to local Ruby variables
-      x = ~:x
+      x = ~R[:x]
 
       expect(x.is_a? R::Vector).to eq true
       expect(x.length).to eq 3
-      # it is not a foreign object. It's an R::Vectors
-      expect(Truffle::Interop.foreign?(x)).to be false
+      # In Galaaz 2.0 we always get R::Object subclasses (e.g. R::Vector), not raw interop
+      expect(x).to be_a(R::Vector)
       # Values are indexed starting with 1, the same as R notation
       expect(x[1]).to eq 1.0
     end
@@ -109,7 +107,7 @@ describe R do
       # to create a double vector through the Ruby interface, we need that at least
       # one element of the vector is a 'float'
       double = R.c(1.0, 2, 3)
-      expect((~:x).identical double).to eq true
+      expect((~R[:x]).identical double).to eq true
       expect(R.hyp(3, 4).all__equal(5)).to eq true
       # @TODO: this should work but raises the following error:
       # TypeError:
@@ -121,7 +119,7 @@ describe R do
 
     it "should box R functions in R::Closure Ruby class" do
       # hyp is an R function and works like a named function in Ruby
-      hyp = ~:hyp
+      hyp = ~R[:hyp]
       
       # calling a named function or block is done by use of the 'call' method
       expect(hyp.call(3, 4)).to eq 5.0
@@ -131,7 +129,7 @@ describe R do
     
     it "should print values the same way as R" do
       # retrieve x and hyp from R and attribute it to local Ruby variables
-      x = ~:x
+      x = ~R[:x]
       
       # Converting to string (to_s) will print as an R vector would
       expect(x[1].to_s).to eq ("[1] 1")
@@ -140,7 +138,7 @@ describe R do
 
     it "should allow logical comparison using R::Objects" do
       # retrieve x and hyp from R and attribute it to local Ruby variables
-      x = ~:x
+      x = ~R[:x]
 
       expect(x[1].all__equal(1)).to eq true
       expect(x[2].identical(1)).to eq false

data/specs/r_function.spec.rb

@@ -44,7 +44,7 @@ describe R do
   context "Using Ruby Procs as parameters to R functions and expressions" do
 
     before(:each) do
-      @x = @y = R.seq(-~:pi, ~:pi, length: 10)
+      @x = @y = R.seq(-~R[:pi], ~R[:pi], length: 10)
     end
     
     it "should accept a Proc as parameter" do