galaaz 0.4.10 → 2.0.0

data/lib/gknit/knitr_engine.rb

@@ -23,11 +23,25 @@
 
 require 'singleton'
 require 'fileutils'
+require 'pathname'
 
+# gKnit touches the bridge before the first document chunk runs (install.packages, source, …).
+# If GALAAZ_BRIDGE_TIMEOUT_SEC is unset, use a generous default so render does not hit 60s while
+# the Rmd setup chunk has not yet run. Whitespace-only counts as unset.
+if ENV['GALAAZ_BRIDGE_TIMEOUT_SEC'].nil? || ENV['GALAAZ_BRIDGE_TIMEOUT_SEC'].to_s.strip.empty?
+  ENV['GALAAZ_BRIDGE_TIMEOUT_SEC'] = '300'
+end
+
+# Load these before anything else to ensure bridge is initialized and libraries are present
 R.install_and_loads('knitr', 'rmarkdown')
 
-# dir = File.dirname(File.expand_path('.', __FILE__))
-# src = "#{dir}/R/eng_ruby.R"
+# Source the R-side include engine wrapper that reads files before calling Ruby
+# This avoids callback deadlock and escaping issues with file content
+dir = File.dirname(File.expand_path(__FILE__))
+include_engine_r = File.join(dir, '..', 'R_interface', 'include_engine.R')
+if File.exist?(include_engine_r)
+  R.bridge.eval_r("source('#{include_engine_r}')")
+end
 
 class KnitrEngine
 
@@ -361,40 +375,62 @@ class KnitrEngine
   # the non-exported function.
   #--------------------------------------------------------------------------------------
 
-  R::Support.eval(<<-R)
+  R::Support.eval(<<-GK_BOOT)
 
-    # Function to guess the extension name of a file based on the device type
-    knitr_dev2ext = function(x) {
+    # Bind on .GlobalEnv so Ruby exec_function("evaluate_plot_snapshot") / recordPlot / knitr
+    # always resolve them (new bridge evaluates in a per-session env; plain '=' here can leave
+    # helpers only in transient frames, so gknit never records ggplot output).
+    .GlobalEnv$knitr_dev2ext <- function(x) {
         knitr:::dev2ext(x)
     }
 
-    #" Capture snapshot of current device.
-    #"
-    #" There's currently no way to capture when a graphics device changes,
-    #" except to check its contents after the evaluation of every expression.
-    #" This means that only the last plot of a series will be captured.
-    #"
-    evaluate_plot_snapshot = function() {
-        evaluate:::plot_snapshot()
+    #" Capture snapshot of current device (base R recordPlot; same as galaaz_device.R).
+    # g_simpleMessage: same signature as simpleMessage; transforms "; " to newlines then calls base::simpleMessage
+    .GlobalEnv$g_simpleMessage <- function(message) {
+        message <- gsub("; ", "; \n", message, fixed = TRUE)
+        base::simpleMessage(message)
+    }
+
+    # g_simpleWarning: same signature as simpleWarning; transforms "; " to newlines then calls base::simpleWarning
+    .GlobalEnv$g_simpleWarning <- function(message) {
+        message <- gsub("; ", "; \n", message, fixed = TRUE)
+        base::simpleWarning(message)
+    }
+
+    #" evaluate:::plot_snapshot() does not exist in the evaluate package, so use recordPlot().
+    .GlobalEnv$evaluate_plot_snapshot <- function() {
+        grDevices::recordPlot()
     }
 
-    knitr_wrap = function(x, options) {
+    # Save a recorded plot to a file in one R call (open device, replayPlot, dev.off) so device state is consistent.
+    .GlobalEnv$save_recorded_plot <- function(path, plot, width, height, dev, res, units) {
+        if (dev == "png" || dev == "pdf") {
+            if (dev == "png") do.call(grDevices::png, list(path, width = width, height = height, res = res, units = units))
+            else do.call(grDevices::pdf, list(path, width = width, height = height))
+            grDevices::replayPlot(plot)
+            grDevices::dev.off()
+        }
+    }
+
+    .GlobalEnv$knitr_wrap <- function(x, options) {
       knitr:::wrap(x, options)
     }
 
-    wrap.message = function(x, options) {
+    assign("wrap.message", function(x, options) {
       knitr:::msg_wrap(paste("Message:\n", x$message, collapse = ''), 'message', options)
-    }
+    }, envir = .GlobalEnv)
 
     # The showtext package, is able to support more font formats and more graphics
     # devices, and avoids using external software such as Ghostscript. showtext makes it
     # even easier to use various types of fonts (TrueType, OpenType, Type 1, web fonts,
     # etc.) in R graphs.
-    showtext = function() {
+    .GlobalEnv$showtext <- function() {
       showtext::showtext_begin()
     }
-    
-    R
+
+    invisible(NULL)
+
+  GK_BOOT
 
   #--------------------------------------------------------------------------------------
   #
@@ -402,7 +438,18 @@ class KnitrEngine
 
   def units
     opt_units = (@options[["units"]])
-    (opt_units.is__null >> 0) ? "in" : opt_units
+    (opt_units.is__null.unboxed_get(0)) ? "in" : opt_units
+  end
+
+  #--------------------------------------------------------------------------------------
+  # Safely normalize scalar chunk option values that may come boxed from R.
+  #--------------------------------------------------------------------------------------
+
+  def scalar_option_string(opt)
+    return opt.unboxed_get(0).to_s if opt.respond_to?(:unboxed_get)
+    opt.to_s
+  rescue StandardError
+    opt.to_s
   end
 
   #--------------------------------------------------------------------------------------
@@ -420,10 +467,10 @@ class KnitrEngine
   #--------------------------------------------------------------------------------------
 
   def fig_keep
-    @keep = @options.fig__keep
+    @keep = @fig__keep
     @keep_idx = nil
     
-    if (@keep.is__numeric >> 0)
+    if (@keep.is__numeric.unboxed_get(0))
       @keep_idx = @keep
       @keep = "index"
     end
@@ -436,10 +483,13 @@ class KnitrEngine
 
   def file_ext
     # guess plot file type if it is NULL
-    if (((@keep != 'none') >> 0) && (@options.fig__ext.is__null >> 0))
-      @fig__ext = (R.knitr_dev2ext(@options.dev) >> 0)
+    # Use @fig__ext (already set from options['fig.ext']) to avoid calling R's fig.ext(options) which triggers invalid connection
+    fig_ext_empty = @fig__ext.nil? || (@fig__ext.respond_to?(:to_s) && @fig__ext.to_s.strip.empty?)
+    # NA from knitr "inherit" must not skip dev2ext (same as GalaazUtil.knitr_logical_trueish? for chunk options).
+    keep_plots = GalaazUtil.knitr_logical_trueish?(((@keep != 'none') rescue nil))
+    if keep_plots && fig_ext_empty
+      @fig__ext = (R.knitr_dev2ext(@options).unboxed_get(0))
     end
-    
   end
 
   #--------------------------------------------------------------------------------------
@@ -451,18 +501,18 @@ class KnitrEngine
     @options = options
 
     # Chunk options
-    @label = (options['label'] >> 0)
+    @label = (options['label'].unboxed_get(0))
     
     # Text results
-    @eval = options['eval'] 
-    @echo = (options['echo'] >> 0)
+    @eval = options[["eval"]] 
+    @echo = GalaazUtil.knitr_option_trueish?(options, 'echo', default: true)
     @results = options['results'] 
     @collapse = options['collapse'] 
     @warning = options['warning'] 
     @error = options['error'] 
     @message = options['message'] 
     @split = options['split'] 
-    @include = options['include'] 
+    @include = GalaazUtil.knitr_option_trueish?(options, 'include', default: true)
     @strip__white = options['strip.white'] 
     # @render = options['render'] # a function
     @class__output = options['class.output'] 
@@ -477,13 +527,13 @@ class KnitrEngine
     @background = options['background'] 
     @class__source = options['class_source'] 
     
-    # Plots
-    @fig__path = (options['fig.path'] >> 0)
-    # @fig__keep = options['fig.keep'] # can be a vector
+    # Plots - avoid unboxed_get in callback as it uses RESULT_FIFO which fails with "invalid connection"
+    @fig__path = scalar_option_string(options['fig.path'])
+    @fig__keep = options['fig.keep'] # can be a vector; use options['fig.keep'] not options.fig__keep to avoid R's fig.keep() which triggers invalid connection
     @fig__show = options['fig.show'] 
     @dev = options['dev'] 
     # @dev__args = options['dev.args'] # can be a vector
-    @fig__ext = (options['fig.ext'] >> 0)
+    @fig__ext = scalar_option_string(options['fig.ext'])
     @dpi = options['dpi'] 
     @fig__width = options['fig.width'] 
     @fig__height = options['fig.height'] 
@@ -521,7 +571,7 @@ class KnitrEngine
 
     # create temporary file for storing plots
     # TODO: should remove this directory afterwards
-    @tmp_fig = (R.tempfile() >> 0)
+    @tmp_fig = (R.tempfile().unboxed_get(0))
     
   end
 
@@ -543,24 +593,58 @@ class KnitrEngine
 
   def self.device(dev_type, filename = nil, *args, width: 480, height: 480,
                   units: "px", res: 72, pointsize: 12, bg: "white")
+    supported_devices = %w[awt svg png pdf jpg jpeg bmp]
+    dev_name = dev_type.to_s.strip
+    unless supported_devices.include?(dev_name)
+      raise "Unsupported graphics device '#{dev_name}'. Supported devices: #{supported_devices.join(', ')}"
+    end
 
-    case dev_type
+    case dev_name
         
     when "awt"
     when "svg"
       R.svg(filename)
-    when "png", "pdf"
+    when "png"
       R.png(filename, width, height, units, pointsize, bg, res, *args)
+    when "pdf"
+      width_in = width
+      height_in = height
+      units_s = units.to_s
+      if units_s == "px"
+        width_in = width.to_f / res.to_f
+        height_in = height.to_f / res.to_f
+      elsif units_s == "cm"
+        width_in = width.to_f / 2.54
+        height_in = height.to_f / 2.54
+      end
+      R.pdf(filename, width_in, height_in, *args)
     when "jpg", "jpeg"
       R.jpeg(filename, width, height, units, pointsize, bg, res, *args)
     when "bmp" 
       R.bmp(filename, width, height, units, pointsize, bg, res, *args)
-    else
-      raise "Invalid device type #{device}"
     end
     
   end
 
+  #--------------------------------------------------------------------------------------
+  # A figure is renderable only if the artifact exists and is valid for its device.
+  # For PDFs, enforce at least one page so LaTeX includegraphics won't fail.
+  #--------------------------------------------------------------------------------------
+
+  def figure_artifact_ready?(path)
+    return false unless File.exist?(path)
+    return false unless File.size(path).to_i > 0
+
+    ext = File.extname(path).downcase
+    return true unless ext == ".pdf"
+
+    pdf_data = File.binread(path)
+    counts = pdf_data.scan(%r{/Count\s+(\d+)}).flatten.map(&:to_i)
+    !counts.empty? && counts.max > 0
+  rescue StandardError
+    false
+  end
+
   #--------------------------------------------------------------------------------------
   # Captures a plot by calling evaluate::plot_snapshot, which has the latest plotted
   # graphics.  
@@ -568,25 +652,50 @@ class KnitrEngine
   
   def capture_plot
 
-    # gets a plot snapshot.  Uses function plot_snapshot from package 'evaluate'
+    # gets a plot snapshot (base R recordPlot via evaluate_plot_snapshot)
     plot = R.evaluate_plot_snapshot
 
-    if (!(plot.is__null >> 0))
+    if (!(plot.is__null.unboxed_get(0)))
       # create directory for the graphics files if does not already exists
-      # unless (R.dir__exists(@fig__path) >> 0)
       unless File.directory?(@fig__path)
         FileUtils.mkdir_p(@fig__path)
       end
 
-      @options.dev.each do |dev_type|
-        KnitrEngine.device(dev_type >> 0, @filename,
-                           width: @options.fig__width,
-                           height: @options.fig__height, units: units)
-        R.print(plot)
-        R.dev__off
-        return plot
-      end
-      
+      # use absolute path so the file is created where Ruby expects and include_graphics can find it
+      filename_abs = File.expand_path(@filename)
+      # Save in one R call (open device, replayPlot, dev.off) so the file is actually written
+      w = (@fig__width >> 0) rescue 480
+      h = (@fig__height >> 0) rescue 480
+      res = (@dpi >> 0) rescue 72
+      dev_str = @dev.respond_to?(:>>) ? (@dev >> 0) : @dev.to_s
+      dev_str = dev_str.to_s.split.first if dev_str.respond_to?(:to_s)
+      units_str = (units.respond_to?(:>>) ? (units >> 0) : units).to_s rescue "in"
+      R.save_recorded_plot(filename_abs, plot, w, h, dev_str, res, units_str)
+      return plot
+    end
+
+    # Fallback when recordPlot() returns NULL on non-screen devices:
+    # copy from the active device to the target figure file.
+    unless File.directory?(@fig__path)
+      FileUtils.mkdir_p(@fig__path)
+    end
+    filename_abs = File.expand_path(@filename)
+    w = (@fig__width >> 0) rescue 480
+    h = (@fig__height >> 0) rescue 480
+    res = (@dpi >> 0) rescue 72
+    dev_str = @dev.respond_to?(:>>) ? (@dev >> 0).to_s : @dev.to_s
+    dev_str = dev_str.gsub('"', '').strip
+
+    case
+    when dev_str.include?('png')
+      R::Support.eval("grDevices::dev.copy(grDevices::png, filename='#{filename_abs.gsub("'", "\\\\'")}', width=#{w}, height=#{h}, units='in', res=#{res}); grDevices::dev.off()")
+      return true
+    when dev_str.include?('svg')
+      R::Support.eval("grDevices::dev.copy(grDevices::svg, filename='#{filename_abs.gsub("'", "\\\\'")}', width=#{w}, height=#{h}); grDevices::dev.off()")
+      return true
+    when dev_str.include?('pdf')
+      R::Support.eval("grDevices::dev.copy(grDevices::pdf, file='#{filename_abs.gsub("'", "\\\\'")}', width=#{w}, height=#{h}); grDevices::dev.off()")
+      return true
     end
 
     false
@@ -600,7 +709,8 @@ class KnitrEngine
   #--------------------------------------------------------------------------------------
   
   def add(spec)
-    (~:knit_engines).set.call(spec)
+    # Use [[ so R returns the engine function; single bracket [ returns a list, not callable
+    R.knitr___knit_engines[["set"]].call(spec)
   end
 
   #--------------------------------------------------------------------------------------
@@ -623,34 +733,54 @@ class KnitrEngine
   #--------------------------------------------------------------------------------------
 
   def initialize
-    
+
+    @chunk_index = 0
+
+    # Knitr invokes this proc with top-level self (main). Engine state (@options, @filename,
+    # capture_plot, process_options) must run on this KnitrEngine singleton (RubyEngine.instance).
+    _gknit_self = self
+
   #--------------------------------------------------------------------------------------
   # Basic engine for processing a chunk
   #--------------------------------------------------------------------------------------
 
     @base_engine = Proc.new do |options|
-      
+      _gknit_self.instance_eval do
+      # grDevices::dev.cur() as an R handle (g2_v*) can be reassigned across NewBridge
+      # callbacks; dev.off(that_handle) then sees wrong/empty `which`. Unbox immediately.
+      dv_n = nil
       begin
 
         out = R.list
 
         # process the chunk options.
         process_options(options)
+        @chunk_index += 1
+        $stderr.puts "[gknit] Processing chunk #{@chunk_index}: #{@label}"
         
-        # opens a device for the current chunk for plot recording
-        KnitrEngine.device(@options.dev >> 0, @tmp_fig)
-        
-        # dv gets the current device
-        dv = R.dev__cur
+        # Open chunk device directly on the final figure target path so inclusion does not
+        # depend on later snapshot copying behavior.
+        FileUtils.mkdir_p(@fig__path) unless File.directory?(@fig__path)
+        chunk_fig_target = File.expand_path(@filename)
+        KnitrEngine.device(@dev.unboxed_get(0), chunk_fig_target)
         
+        v = (R.dev__cur >> nil) rescue nil
+        if v
+          x = v.is_a?(Array) ? v.first : v
+          dv_n = x.to_i if x.is_a?(Numeric)
+        end
+
         # executes the code chunk with the given options
         # the returned value is a list properly formatted to be given to engine_output
         # exec_ruby catches StandardError, so no execution errors on the block will
         # reach here, they are formatted in the return list to be printed
         res = GalaazUtil.exec_ruby(@options)
         
+        include_chunk = !!@include
+
         # function engine_output will format whatever is in out inside a white box
-        out = R.engine_output(@options, out: res) if @echo
+        # (exec_ruby now uses simpleMessage/simpleWarning so conditionMessage() works in engine_output)
+        out = @echo ? R.engine_output(@options, out: res) : res
         
         # ouputs the data in RubyChunk '@outputs' variable. Everything that should
         # be processed by 'pandoc' and not appear in the output block from
@@ -660,63 +790,49 @@ class KnitrEngine
         out = R.c(out, RChunk.out_list)
         RChunk.reset_outputs
         
-        # @TODO: allow capturing many plots in the block.  For now, only the last
-        # plot will be captured.  Not a very serious problem for now.
-        # Captures the last plot in the Ruby block. 
-        if (capture_plot)
-          plot = R.knitr_wrap(R.knit_print(R.include_graphics(@filename)), @options)
-          
-          # add to the output the result of plot.  Whatever is included after the
-          # engine_output output will appear 'as.is' in the report.  The 'plot'
-          # variable is a command that in rmarkdown includes the image in the
-          # report
-          out = R.c(out, plot)
+        # Finalize the chunk device before testing/including artifact; PDF files are not
+        # valid for includegraphics until dev.off() closes the page stream.
+        if dv_n.is_a?(Integer) && dv_n > 1
+          R.dev__off(dv_n)
+          dv_n = nil
         end
 
+        # Include only real, renderable figure artifacts for this chunk.
+        if include_chunk
+          fig_path = File.expand_path(@filename)
+          if figure_artifact_ready?(fig_path)
+            fig_rel = Pathname.new(fig_path).relative_path_from(Pathname.new(Dir.pwd)).to_s rescue fig_path
+            fig_md = "![](" + fig_rel + ")"
+            out = R.c(out, fig_md)
+          end
+        end
+
+        # knitr semantics: include=FALSE still evaluates code/side effects, but emits nothing.
+        out = R.list unless include_chunk
+
         out
         
+      rescue StandardError, RuntimeError => e
+        begin
+          GknitDiagnostics.record(chunk_label: (@label || 'unknown'), error: e) if defined?(GknitDiagnostics)
+        rescue StandardError
+          nil
+        end
+        # Format error with newlines so R/knitr displays it on multiple lines (not semicolon-joined).
+        formatted = e.message.to_s
+        formatted += "\n\n--- Ruby backtrace ---\n" + e.backtrace.join("\n") if e.backtrace && !e.backtrace.empty?
+        R.list(R.simpleMessage(formatted))
       ensure
-        # closes the current device
-        # R.dev__off(dv)
+        # Close the device we opened (which > 1; 1 is the null device and must not be passed to dev.off).
+        if dv_n.is_a?(Integer) && dv_n > 1
+          R.dev__off(dv_n)
+        end
       end
-      
-    end
-    
-    super
-    
-  end
-  
-end
-
-=begin
-module R
-
-  class Object
-
-    #--------------------------------------------------------------------------------------
-    # Redefine to_s in order to capture plots when in knitr
-    #--------------------------------------------------------------------------------------
-    
-    def to_s
-
-      STDERR.puts "+++++++++++++++++++++++++++"
-      STDERR.puts "in to_s"
-      STDERR.puts "+++++++++++++++++++++++++++"
-      
-      cap = nil
-      cap = R::Support.capture.call(r_interop)
-      str = String.new
-      (0...(cap.size - 1)).each do |i|
-        str << cap[i] << "\n"
       end
-      str << cap[cap.size - 1] if cap.size >= 1
-      re = RubyEngine.instance
-      re.capture_plot
-      str
     end
 
+    super
+    
   end
   
 end
-
-=end

data/lib/gknit/rb_engine.rb

@@ -34,10 +34,10 @@ class RbEngine < KnitrEngine
     
     @engine = Proc.new do |options|
 
-      # the 'rb' engine has the code to be executed in the options.label
-      # argument
+      # the 'rb' engine has the code to be executed in the options['label']
+      # argument (use list indexing; options.label would call R's label() which does not exist)
       # options[['code']] = options[['label']]
-      options.code = options.label
+      options.code = options['label']
       # we do not want the code to be returned
       options.echo = false
       

data/lib/gknit.rb

@@ -23,7 +23,10 @@
 
 require 'galaaz'
 
+require_relative 'gknit/diagnostics'
 require_relative 'gknit/knitr_engine'
 require_relative 'gknit/ruby_engine'
 require_relative 'gknit/rb_engine'
 require_relative 'gknit/include_engine'
+require_relative 'gknit/draft'
+