galaaz 0.4.10 → 2.0.0

data/specs/formula_semantics_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'Formula semantics' do
+  context 'formula construction' do
+    it 'builds formulas from string and DSL' do
+      f1 = R.formula('mpg ~ wt + cyl')
+      expect(f1.to_s.lines.first.chomp).to eq('mpg ~ wt + cyl')
+
+      f2 = R[:mpg].til R[:wt] + R[:cyl]
+      expect(f2.to_s.lines.first.chomp).to eq('mpg ~ wt + cyl')
+    end
+
+    it 'builds interaction formulas with operators' do
+      f1 = R[:y].til R[:x] * R[:x2]
+      expect(f1.to_s.lines.first.chomp).to eq('y ~ x * x2')
+
+      f2 = R[:y].til R[:x] + R[:x2] + (R[:x].inter R[:x2])
+      expect(f2.to_s.lines.first.chomp).to eq('y ~ x + x2 + x:x2')
+
+      f3 = R[:y].til R[:a] + (R[:b]._ :in, R[:a])
+      expect(f3.to_s.lines.first.chomp).to eq('y ~ a + b %in% a')
+    end
+
+    it 'builds formulas using dot and one-sided forms' do
+      rhs_dot = R[:supp].til R[:__]
+      expect(rhs_dot.to_s.lines.first.chomp).to eq('supp ~ .')
+      expect(rhs_dot.rclass).to eq('formula')
+
+      lhs_dot = R[:__].til R[:supp]
+      expect(lhs_dot.to_s.lines.first.chomp).to eq('. ~ supp')
+      expect(lhs_dot.rclass).to eq('formula')
+
+      one_sided = R[:all].til R[:supp]
+      expect(one_sided.to_s.lines.first.chomp).to eq('~supp')
+      expect(one_sided.rclass).to eq('formula')
+    end
+
+    it 'builds conditional and function-lhs formulas' do
+      cond = R[:Sepal__Width].til R[:Petal__Width] | R[:Species]
+      expect(cond.to_s.lines.first.chomp).to eq('Sepal.Width ~ Petal.Width | Species')
+
+      lhs_fun = E.log(:y).til R[:a] + E.log(:x)
+      expect(lhs_fun.to_s.lines.first.chomp).to eq('log(y) ~ a + log(x)')
+    end
+
+    it "builds subtraction operator formula terms" do
+      f = R[:y].til R[:x1] - R[:x2]
+      expect(f.to_s.lines.first.chomp).to eq('y ~ x1 - x2')
+    end
+  end
+
+  context 'model.frame and lm with formula' do
+    it 'builds model frame with deterministic values under set.seed' do
+      R.set__seed(123)
+      x = R.rnorm(5)
+      x2 = R.rnorm(5)
+      y = R.rnorm(5)
+
+      formula = R[:y].til R[:x] * R[:x2]
+      model = R.model__frame(formula, data: R.data__frame(x: x, y: y, x2: x2))
+
+      expect((model[1, 1] >> 0)).to be_within(1e-9).of(1.2240817974394615)
+      expect((model[1, 3] >> 0)).to be_within(1e-9).of(1.715064986883281)
+      expect((model[3, 2] >> 0)).to be_within(1e-9).of(1.558708314149124)
+      expect((model[5, 1] >> 0)).to be_within(1e-9).of(-0.5558411347540749)
+    end
+
+    it 'fits lm on mtcars and predicts expected trend values' do
+      fit = R.lm((R[:mpg].til R[:wt] + R[:cyl]), data: :mtcars)
+      expect((fit.coefficients[[1]] >> 0)).to be_within(1e-9).of(39.68626148025295)
+      expect((fit.coefficients[['wt']] >> 0)).to be_within(1e-9).of(-3.190972138983746)
+      expect((fit.coefficients[['cyl']] >> 0)).to be_within(1e-9).of(-1.507794968259798)
+
+      pred = R.predict(fit, R.data__frame(wt: R.c(3.0, 2.0), cyl: R.c(6.0, 4.0)))
+      expect((pred[1] >> 0)).to be_within(1e-9).of(21.066575253742926)
+      expect((pred[2] >> 0)).to be_within(1e-9).of(27.273137329246268)
+    end
+  end
+end

data/specs/galaaz_util_exec_ruby_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe GalaazUtil do
+  describe RC do
+    it 'normalizes R objects and arrays recursively for output' do
+      rc = RC.new
+      vec = R.c(1, 2, 3)
+      normalized = rc.normalize_output_arg([vec, 'x', [vec]])
+      expect(normalized[0]).to eq(vec.to_s)
+      expect(normalized[1]).to eq('x')
+      expect(normalized[2][0]).to eq(vec.to_s)
+    end
+
+    it 'tracks outputs and resets output list' do
+      rc = RC.new
+      rc.outputs('a')
+      expect(rc.out_list).to be_a(R::List).or be_a(R::Vector)
+      rc.reset_outputs
+      expect(rc.out_list).to eq(nil)
+      expect(rc.get_binding).to be_a(Binding)
+    end
+  end
+
+  describe '.knitr_logical_trueish?' do
+    let(:wrapper) do
+      Struct.new(:value) do
+        def unboxed_get(_idx)
+          value
+        end
+      end
+    end
+
+    it 'treats nil and NA-like wrappers as true by default' do
+      expect(GalaazUtil.knitr_logical_trueish?(nil)).to eq(true)
+      expect(GalaazUtil.knitr_logical_trueish?(wrapper.new(nil))).to eq(true)
+    end
+
+    it 'handles booleans and numerics from wrappers' do
+      expect(GalaazUtil.knitr_logical_trueish?(wrapper.new(true))).to eq(true)
+      expect(GalaazUtil.knitr_logical_trueish?(wrapper.new(false))).to eq(false)
+      expect(GalaazUtil.knitr_logical_trueish?(wrapper.new(0))).to eq(false)
+      expect(GalaazUtil.knitr_logical_trueish?(wrapper.new(2))).to eq(true)
+    end
+
+    it 'handles string-like values from wrappers' do
+      expect(GalaazUtil.knitr_logical_trueish?(wrapper.new('FALSE'))).to eq(false)
+      expect(GalaazUtil.knitr_logical_trueish?(wrapper.new('true'))).to eq(true)
+    end
+  end
+
+  describe '.knitr_option_trueish?' do
+    let(:bridge) { instance_double('Bridge') }
+    let(:options) { Struct.new(:r_interop).new('g2_v_opts') }
+
+    before do
+      allow(R).to receive(:bridge).and_return(bridge)
+    end
+
+    it 'returns default when options are not interop-like' do
+      expect(GalaazUtil.knitr_option_trueish?(nil, 'echo', default: false)).to eq(false)
+      expect(GalaazUtil.knitr_option_trueish?(Object.new, 'echo', default: true)).to eq(true)
+    end
+
+    it 'parses TRUE/FALSE and numeric tokens from R output' do
+      allow(bridge).to receive(:eval_r).and_return('[1] "TRUE"', '[1] "FALSE"', '[1] "0"', '[1] "3"')
+      expect(GalaazUtil.knitr_option_trueish?(options, 'echo', default: false)).to eq(true)
+      expect(GalaazUtil.knitr_option_trueish?(options, 'echo', default: true)).to eq(false)
+      expect(GalaazUtil.knitr_option_trueish?(options, 'echo', default: true)).to eq(false)
+      expect(GalaazUtil.knitr_option_trueish?(options, 'echo', default: false)).to eq(true)
+    end
+
+    it 'falls back to default for NA/NULL/empty or bridge errors' do
+      allow(bridge).to receive(:eval_r).and_return('[1] "NA"', '[1] "NULL"', '')
+      expect(GalaazUtil.knitr_option_trueish?(options, 'echo', default: false)).to eq(false)
+      expect(GalaazUtil.knitr_option_trueish?(options, 'echo', default: true)).to eq(true)
+      expect(GalaazUtil.knitr_option_trueish?(options, 'echo', default: false)).to eq(false)
+
+      allow(bridge).to receive(:eval_r).and_raise(StandardError, 'bridge down')
+      expect(GalaazUtil.knitr_option_trueish?(options, 'echo', default: true)).to eq(true)
+    end
+  end
+end
+

data/specs/galaaz_util_inline_file_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+require 'galaaz'
+
+describe GalaazUtil do
+  describe '.inline_file_path' do
+    it 'resolves a local .rb file when relative is true' do
+      Dir.mktmpdir('galaaz_inline_local') do |dir|
+        file = File.join(dir, 'snippet.rb')
+        File.write(file, "puts 'ok'\n")
+
+        path = GalaazUtil.inline_file_path('snippet', true, dir)
+        expect(path).to eq(file)
+      end
+    end
+
+    it 'resolves from load path when relative is false' do
+      Dir.mktmpdir('galaaz_inline_loadpath') do |dir|
+        file = File.join(dir, 'from_load_path.rb')
+        File.write(file, "puts 'loadpath'\n")
+
+        begin
+          $LOAD_PATH.unshift(dir)
+          path = GalaazUtil.inline_file_path('from_load_path', false, '/tmp')
+          expect(path).to eq(file)
+        ensure
+          $LOAD_PATH.delete(dir)
+        end
+      end
+    end
+
+    it 'raises when file cannot be found' do
+      expect do
+        GalaazUtil.inline_file_path('definitely_missing_file_abc_xyz', false, '/tmp')
+      end.to raise_error(Errno::ENOENT)
+    end
+  end
+
+  describe '.inline_file' do
+    it 'returns full file contents' do
+      Dir.mktmpdir('galaaz_inline_read') do |dir|
+        file = File.join(dir, 'content.rb')
+        body = "a = 1\nb = 2\nputs a + b\n"
+        File.write(file, body)
+
+        code = GalaazUtil.inline_file('content', true, dir)
+        expect(code).to eq(body)
+      end
+    end
+  end
+end
+

data/specs/gknit_cli_option_permutation_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+describe 'gknit CLI option parsing' do
+  it 'accepts options when they appear before filename' do
+    stdout, stderr, status = Open3.capture3(
+      'ruby', 'bin/gknit', '--callback_timeout_ms', 'not_an_integer', 'specs/does_not_exist.Rmd'
+    )
+
+    expect(status.success?).to eq(false)
+    expect("#{stdout}\n#{stderr}").to include('invalid argument: --callback_timeout_ms')
+  end
+
+  it 'accepts options when they appear after filename' do
+    stdout, stderr, status = Open3.capture3(
+      'ruby', 'bin/gknit', 'specs/does_not_exist.Rmd',
+      '--callback_timeout_ms', 'not_an_integer'
+    )
+
+    expect(status.success?).to eq(false)
+    expect("#{stdout}\n#{stderr}").to include('invalid argument: --callback_timeout_ms')
+  end
+end

data/specs/gknit_include_engine_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'open3'
+require 'tmpdir'
+
+describe 'gknit include engine' do
+  def self.gknit_env
+    home = Dir.home
+    extra = [
+      File.join(home, 'bin'),
+      File.join(home, '.TinyTeX', 'bin')
+    ].select { |dir| File.directory?(dir) }
+    path = ENV.fetch('PATH', '')
+    path = ([*extra, path].join(File::PATH_SEPARATOR)) unless extra.empty?
+    {
+      'JAVA_OPTS' => '--add-opens=java.base/java.nio=ALL-UNNAMED',
+      'PATH' => path
+    }
+  end
+
+  it 'loads include file code so constants are available in following ruby chunks' do
+    root = File.expand_path('..', __dir__)
+    workdir = Dir.mktmpdir('gknit_include_engine_', root)
+
+    begin
+      model_rb = File.join(workdir, 'model.rb')
+      File.write(model_rb, <<~RUBY)
+        class Model
+          def answer
+            42
+          end
+        end
+      RUBY
+
+      rmd_path = File.join(workdir, 'include_model.Rmd')
+      File.write(rmd_path, <<~RMD)
+        ---
+        title: "include engine spec"
+        output:
+          github_document: default
+        ---
+
+        ```{include model}
+        ```
+
+        ```{ruby, echo=FALSE}
+        m = Model.new
+        puts m.answer
+        ```
+      RMD
+
+      rel_rmd = File.basename(workdir) + '/' + File.basename(rmd_path)
+      out, err, st = Open3.capture3(
+        self.class.gknit_env,
+        'bin/gknit', '--output_format', 'github_document', rel_rmd,
+        chdir: root
+      )
+      expect(st.success?).to be(true), "gknit failed\nstdout:\n#{out}\nstderr:\n#{err}"
+
+      md_path = rmd_path.sub(/\.Rmd\z/, '.md')
+      expect(File.exist?(md_path)).to be(true), "missing markdown output: #{md_path}"
+      md = File.read(md_path)
+
+      expect(md).to include('42')
+      expect(md).not_to include('uninitialized constant RC::Model')
+      expect(md).not_to include('Include failed:')
+    ensure
+      FileUtils.rm_rf(workdir) if workdir && File.directory?(workdir)
+    end
+  end
+end

data/specs/gknit_install_timeout_report_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'open3'
+require 'tmpdir'
+
+describe 'gknit install timeout reporting' do
+  def self.gknit_env
+    home = Dir.home
+    extra = [
+      File.join(home, 'bin'),
+      File.join(home, '.TinyTeX', 'bin')
+    ].select { |dir| File.directory?(dir) }
+    path = ENV.fetch('PATH', '')
+    path = ([*extra, path].join(File::PATH_SEPARATOR)) unless extra.empty?
+    {
+      'JAVA_OPTS' => '--add-opens=java.base/java.nio=ALL-UNNAMED',
+      'PATH' => path
+    }
+  end
+
+  it 'continues processing and prints timeout in final report' do
+    skip('Temporarily skipped: installation timeout behavior will be reviewed in a dedicated pass')
+    root = File.expand_path('..', __dir__)
+    workdir = Dir.mktmpdir('gknit_install_timeout_', root)
+
+    begin
+      rmd_path = File.join(workdir, 'install_timeout.Rmd')
+      File.write(rmd_path, <<~RMD)
+        ---
+        title: "install timeout"
+        output:
+          github_document: default
+        ---
+
+        ```{ruby setup_stub}
+        R.bridge.eval_r("install.packages <- function(...) { Sys.sleep(2); invisible(NULL) }")
+        ```
+
+        ```{ruby timeout_install}
+        R.install_and_loads('definitely_fake_pkg_for_timeout_spec')
+        ```
+
+        ```{ruby after_timeout}
+        puts "AFTER_TIMEOUT_CHUNK_OK"
+        ```
+      RMD
+
+      rel_rmd = File.basename(workdir) + '/' + File.basename(rmd_path)
+      out, err, st = Open3.capture3(
+        self.class.gknit_env,
+        'bin/gknit', '--output_format', 'github_document', '--bridge_timeout_sec', '1', rel_rmd,
+        chdir: root
+      )
+
+      md_path = File.join(workdir, 'install_timeout.md')
+      expect(st.success?).to be(true)
+      expect(File.exist?(md_path)).to be(true)
+      md = File.read(md_path)
+      expect(md).to include('AFTER_TIMEOUT_CHUNK_OK')
+      expect(err).to include('gknit internal errors detected:')
+      expect(err).to include('chunk=timeout_install')
+      expect(err).to include('no RET for')
+      expect(out).not_to be_nil
+    ensure
+      FileUtils.rm_rf(workdir) if workdir && File.directory?(workdir)
+    end
+  end
+end

data/specs/gknit_internal_error_report_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'open3'
+require 'tmpdir'
+
+describe 'gknit internal error report' do
+  def self.gknit_env
+    home = Dir.home
+    extra = [
+      File.join(home, 'bin'),
+      File.join(home, '.TinyTeX', 'bin')
+    ].select { |dir| File.directory?(dir) }
+    path = ENV.fetch('PATH', '')
+    path = ([*extra, path].join(File::PATH_SEPARATOR)) unless extra.empty?
+    {
+      'JAVA_OPTS' => '--add-opens=java.base/java.nio=ALL-UNNAMED',
+      'PATH' => path
+    }
+  end
+
+  it 'prints chunk-scoped report only when internal errors are detected' do
+    root = File.expand_path('..', __dir__)
+    workdir = Dir.mktmpdir('gknit_internal_report_', root)
+
+    begin
+      rmd_path = File.join(workdir, 'internal_error.Rmd')
+      File.write(rmd_path, <<~RMD)
+        ---
+        title: "internal report"
+        output:
+          github_document: default
+        ---
+
+        ```{ruby bad_dev, dev='tiff'}
+        puts "x"
+        ```
+      RMD
+
+      rel_rmd = File.basename(workdir) + '/' + File.basename(rmd_path)
+      _out, err, st = Open3.capture3(
+        self.class.gknit_env,
+        'bin/gknit', '--output_format', 'github_document', rel_rmd,
+        chdir: root
+      )
+
+      # Chunk-level errors are rendered inline; gknit process should still succeed.
+      expect(st.success?).to be(true)
+      expect(err).to include('gknit internal errors detected:')
+      expect(err).to include('chunk=bad_dev')
+      expect(err).to include('Unsupported graphics device')
+    ensure
+      FileUtils.rm_rf(workdir) if workdir && File.directory?(workdir)
+    end
+  end
+end
+

data/specs/gknit_vector_map_output_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'open3'
+require 'tmpdir'
+
+describe 'gknit vector map output' do
+  def self.gknit_env
+    home = Dir.home
+    extra = [
+      File.join(home, 'bin'),
+      File.join(home, '.TinyTeX', 'bin')
+    ].select { |dir| File.directory?(dir) }
+    path = ENV.fetch('PATH', '')
+    path = ([*extra, path].join(File::PATH_SEPARATOR)) unless extra.empty?
+    {
+      'JAVA_OPTS' => '--add-opens=java.base/java.nio=ALL-UNNAMED',
+      'PATH' => path
+    }
+  end
+
+  it 'renders vec.map in ruby chunks without missing bridge methods' do
+    root = File.expand_path('..', __dir__)
+    workdir = Dir.mktmpdir('gknit_vec_map_', root)
+
+    begin
+      rmd_path = File.join(workdir, 'vector_map.Rmd')
+      File.write(rmd_path, <<~RMD)
+        ---
+        title: "gknit vector map"
+        output:
+          github_document: default
+        ---
+
+        ```{ruby, echo=FALSE}
+        vec = R.c(1, 2, 3, 4)
+        puts vec.map { |x| x + 2 }
+        ```
+      RMD
+
+      rel_rmd = File.basename(workdir) + '/' + File.basename(rmd_path)
+      out, err, st = Open3.capture3(
+        self.class.gknit_env,
+        'bin/gknit', '--output_format', 'github_document', rel_rmd,
+        chdir: root
+      )
+      expect(st.success?).to be(true), "gknit failed\nstdout:\n#{out}\nstderr:\n#{err}"
+
+      md_path = rmd_path.sub(/\.Rmd\z/, '.md')
+      expect(File.exist?(md_path)).to be(true), "missing markdown output: #{md_path}"
+      md = File.read(md_path)
+
+      expect(md).to include('\\[1\\] 3 4 5 6')
+      expect(md).not_to include("undefined method 'push_double_vector'")
+    ensure
+      FileUtils.rm_rf(workdir) if workdir && File.directory?(workdir)
+    end
+  end
+end

data/specs/globalenv_guardrail_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+describe 'GlobalEnv mutable write guardrail' do
+  it 'does not introduce unapproved .GlobalEnv$... <- writes in active bridge path' do
+    root = Pathname.new(__dir__).join('..').expand_path
+
+    scoped_files = Dir[root.join('lib/**/*.rb').to_s]
+
+    allow_by_file = {
+      'lib/R_interface/rdevice.rb' => [
+        /\.GlobalEnv\$evaluate_plot_snapshot <- function\(\)/,
+        /\.GlobalEnv\$galaaz_save_plot <- function\(path, dev_type, width, height, dpi\)/
+      ],
+      'lib/gknit/knitr_engine.rb' => [
+        /\.GlobalEnv\$knitr_dev2ext <- function\(x\)/,
+        /\.GlobalEnv\$g_simpleMessage <- function\(message\)/,
+        /\.GlobalEnv\$g_simpleWarning <- function\(message\)/,
+        /\.GlobalEnv\$evaluate_plot_snapshot <- function\(\)/,
+        /\.GlobalEnv\$save_recorded_plot <- function\(path, plot, width, height, dev, res, units\)/,
+        /\.GlobalEnv\$knitr_wrap <- function\(x, options\)/,
+        /\.GlobalEnv\$showtext <- function\(\)/
+      ],
+      'lib/R_interface/rsupport.rb' => [
+        /assignment = "\.GlobalEnv\$\#\{var_name\} <- \{ \#\{final_r_code\}\\n \}"/,
+        /R\.bridge\.eval_r\("\.GlobalEnv\$\#\{var\} <- \#\{rhs\}"\)/
+      ],
+      'lib/R_interface/robject.rb' => [
+        /assignment = "\.GlobalEnv\$\#\{var\} <- \#\{r_code\}"/
+      ],
+      'lib/R_interface/rvector.rb' => [
+        /assignment = "\.GlobalEnv\$\#\{var_name\} <- \#\{@r_interop\}\[\[\#\{idx \+ 1\}\]\]"/
+      ]
+    }
+
+    violations = []
+
+    scoped_files.each do |file|
+      rel = Pathname.new(file).relative_path_from(root).to_s
+      lines = File.readlines(file, chomp: true)
+      lines.each_with_index do |line, idx|
+        next unless line.match?(/\.GlobalEnv\$.*<-/)
+
+        allowed = allow_by_file.fetch(rel, []).any? { |rx| line.match?(rx) }
+        violations << "#{rel}:#{idx + 1}: #{line.strip}" unless allowed
+      end
+    end
+
+    expect(violations).to eq([])
+  end
+end