[#20] engine: include optional logging

Fixes #20

Author: gi

lib/handlebars/engine.rb

@@ -21,7 +21,8 @@ class Engine
     #   environment.
     # @param path [String, nil] the path to the version of Handlebars to load.
     #   If `nil`, the contents of `Handlebars::Source.bundled_path` is loaded.
-    def initialize(lazy: false, path: nil)
+    def initialize(lazy: false, logger: nil, path: nil)
+      @logger = logger
       @path = path
       init! unless lazy
     end
@@ -175,13 +176,16 @@ def version
 
     def attach(name, &block)
       init!
+      @logger&.debug { "[handlebars] attaching #{name}" }
       @context.attach(name.to_s, block)
     end
 
     def call(name, args, assign: false, eval: false)
       init!
       name = name.to_s
 
+      @logger&.debug { "[handlebars] calling #{name} with args #{args}" }
+
       if assign || eval
         call_via_eval(name, args, assign: assign)
       else
@@ -207,6 +211,7 @@ def call_via_eval(name, args, assign: false)
     end
 
     def evaluate(code)
+      @logger&.debug { "[handlebars] evaluating #{code}" }
       @context.eval(code)
     end
 
@@ -222,10 +227,18 @@ def helper_missing_name(type)
     def init!
       return if @init
 
+      @logger&.debug { "[handlebars] initializing" }
+
       @context = MiniRacer::Context.new
+      @context.attach(
+        "console.log",
+        ->(*args) { @logger&.debug { "[handlebars] #{args.join(" ")}" } },
+      )
       @context.load(@path || ::Handlebars::Source.bundled_path)
       @context.load(File.absolute_path("engine/init.js", __dir__))
 
+      @logger&.debug { "[handlebars] initialized" }
+
       @init = true
     end
 

lib/handlebars/engine/function.rb

@@ -4,12 +4,14 @@ module Handlebars
   class Engine
     # A proxy for a JavaScript function defined in the context.
     class Function
-      def initialize(context, name)
+      def initialize(context, name, logger: nil)
         @context = context
+        @logger = logger
         @name = name
       end
 
       def call(*args)
+        @logger&.debug { "[handlebars] calling #{@name} with args #{args.inspect}" }
         @context.call(@name, *args)
       end
     end

spec/handlebars/engine_spec.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require "logger"
 require "tempfile"
 
 RSpec.describe Handlebars::Engine do
   let(:engine) { described_class.new(**engine_options) }
   let(:engine_context) { engine.instance_variable_get(:@context) }
   let(:engine_options) { {} }
+  let(:log) { Tempfile.new }
+  let(:logger) { Logger.new(log, level: Logger::FATAL) }
   let(:render) { renderer.call(render_context, render_options) }
   let(:render_context) { { name: "Zach", age: 30 } }
   let(:render_options) { {} }
@@ -44,6 +47,25 @@
       end
     end
 
+    context "when `logger` is defined" do
+      before do
+        engine_options[:logger] = logger
+        logger.debug!
+      end
+
+      it "logs initialization" do
+        engine
+        log.rewind
+        expect(log.read).to include("[handlebars] initializing")
+      end
+
+      it "logs javascript" do
+        engine.send(:evaluate, "console.log('js', 'log')")
+        log.rewind
+        expect(log.read).to include("[handlebars] js log")
+      end
+    end
+
     context "when `path` is defined" do
       let(:file) { Tempfile.open }