Embeded ruby has consistent exception handling

Ruby code that can raise exceptions is invoked within a single `rescue`
block within ERBRenderer (see: template_evaluation_context.rb).

- JSON reading, parsing moves into ruby `ERBRenderer`
- `TemplateEvaluationContext` initiization moves into `ERBRenderer`
- invocation of `TemplateEvaluationContext#name` uses nil-safe acccessor

Author: aramprice

templatescompiler/erbrenderer/erb_renderer_test.go

@@ -118,7 +118,10 @@ property3: default_value3
 			})
 
 			Describe("error handling within Ruby", func() {
-				const rubyExceptionPrefix = "Error filling in template " // see template_evaluation_context.rb
+				var (
+					// see template_evaluation_context.rb
+					rubyExceptionPrefixTemplate = "Error filling in template '%s' "
+				)
 
 				Context("with invalid ERB", func() {
 					BeforeEach(func() {
@@ -132,16 +135,25 @@ property3: default_value3
 						err := erbRenderer.Render(erbTemplateFilepath, renderedTemplatePath, context)
 						Expect(err).To(HaveOccurred())
 						Expect(err.Error()).To(ContainSubstring("RuntimeError: test error"))
-						Expect(err.Error()).To(ContainSubstring(rubyExceptionPrefix))
+						Expect(err.Error()).To(ContainSubstring(fmt.Sprintf(rubyExceptionPrefixTemplate, erbTemplateFilepath)))
 					})
 
 					Context("with missing ERB template", func() {
 						It("returns an error with a known ruby exception", func() {
 							invalidErbPath := "invalid/template.erb"
 							err := erbRenderer.Render(invalidErbPath, renderedTemplatePath, context)
 							Expect(err).To(HaveOccurred())
-							Expect(err.Error()).To(MatchRegexp(fmt.Sprintf("No such file or directory .* %s", invalidErbPath)))
-							Expect(err.Error()).To(ContainSubstring(rubyExceptionPrefix))
+							Expect(err.Error()).To(ContainSubstring(fmt.Sprintf("<Errno::ENOENT: No such file or directory @ rb_sysopen - %s>", invalidErbPath)))
+							Expect(err.Error()).To(ContainSubstring(fmt.Sprintf(rubyExceptionPrefixTemplate, invalidErbPath)))
+						})
+					})
+
+					Context("with context JSON which does not have the expected elements", func() {
+						It("returns an error with a known ruby exception", func() {
+							err := erbRenderer.Render(erbTemplateFilepath, renderedTemplatePath, &testTemplateEvaluationContext{})
+							Expect(err).To(HaveOccurred())
+							Expect(err.Error()).To(ContainSubstring("undefined method `recursive_merge!'"))
+							Expect(err.Error()).To(ContainSubstring(fmt.Sprintf(rubyExceptionPrefixTemplate, erbTemplateFilepath)))
 						})
 					})
 				})

templatescompiler/erbrenderer/template_evaluation_context.rb

@@ -166,20 +166,23 @@ def dump(*args)
 end
 
 class ERBRenderer
-  def initialize(context)
-    @context = context
+  def initialize(json_context_path)
+    @json_context_path = json_context_path
   end
 
   def render(src_path, dst_path)
     erb = ERB.new(File.read(src_path), safe_level = nil, trim_mode = "-")
     erb.filename = src_path
 
+    context_hash = JSON.load(File.read(@json_context_path))
+    template_evaluation_context = TemplateEvaluationContext.new(context_hash)
+
     File.open(dst_path, "w") do |f|
-      f.write(erb.result(@context.get_binding))
+      f.write(erb.result(template_evaluation_context.get_binding))
     end
 
   rescue Exception => e
-    name = "#{@context.name}/#{@context.index}"
+    name = "#{template_evaluation_context&.name}/#{template_evaluation_context&.index}"
 
     line_i = e.backtrace.index { |l| l.include?("#{erb&.filename}") }
     line_num = line_i ? e.backtrace[line_i].split(':')[1] : "unknown"
@@ -192,9 +195,6 @@ def render(src_path, dst_path)
 if $0 == __FILE__
   json_context_path, erb_template_path, rendered_template_path = *ARGV
 
-  context_hash = JSON.load(File.read(json_context_path))
-  context = TemplateEvaluationContext.new(context_hash)
-
-  renderer = ERBRenderer.new(context)
+  renderer = ERBRenderer.new(json_context_path)
   renderer.render(erb_template_path, rendered_template_path)
 end