improve auto-rendering of interpreted types

Author: cosmos72

display.go

@@ -157,14 +157,6 @@ func (kernel *Kernel) canAutoRender(data interface{}, typ xreflect.Type) bool {
 }
 
 var autoRenderers = map[string]func(Data, interface{}) Data{
-	"Data": func(d Data, i interface{}) Data {
-		if x, ok := i.(Data); ok {
-			d.Data = merge(d.Data, x.Data)
-			d.Metadata = merge(d.Metadata, x.Metadata)
-			d.Transient = merge(d.Transient, x.Transient)
-		}
-		return d
-	},
 	"Renderer": func(d Data, i interface{}) Data {
 		if r, ok := i.(Renderer); ok {
 			x := r.Render()
@@ -262,20 +254,24 @@ var autoRenderers = map[string]func(Data, interface{}) Data{
 // detect and render data types that should be auto-rendered graphically
 func (kernel *Kernel) autoRender(mimeType string, arg interface{}, typ xreflect.Type) Data {
 	var data Data
-
-	// try all autoRenderers
-	for _, fun := range autoRenderers {
-		data = fun(data, arg)
+	// try Data
+	if x, ok := arg.(Data); ok {
+		data = x
 	}
 
-	if kernel != nil && typ != nil {
+	if kernel == nil || typ == nil {
+		// try all autoRenderers
+		for _, fun := range autoRenderers {
+			data = fun(data, arg)
+		}
+	} else {
 		// in gomacro, methods of interpreted types are emulated.
 		// Thus type-asserting them to interface types as done by autoRenderer functions above cannot succeed.
-		// Manually check if emulated type "pretends" to implement one of the a above interfaces
+		// Manually check if emulated type "pretends" to implement one or more of the above interfaces
 		// and, in case, tell the interpreter to convert to them
 		for name, xtyp := range kernel.render {
 			fun := autoRenderers[name]
-			if fun == nil || !typ.Implements(xtyp) || typ.ReflectType().Implements(xtyp.ReflectType()) {
+			if fun == nil || !typ.Implements(xtyp) {
 				continue
 			}
 			conv := kernel.ir.Comp.Converter(typ, xtyp)
@@ -316,7 +312,6 @@ func fillDefaults(data Data, arg interface{}, s string, b []byte, mimeType strin
 			data.Data[mimeType] = b
 		}
 	}
-	fmt.Printf("%+v\n", data)
 	return data
 }
 

examples/Display.ipynb

@@ -423,6 +423,7 @@
     "\tMIMETypePNG        = \"image/png\"\n",
     "\tMIMETypePDF        = \"application/pdf\"\n",
     "\tMIMETypeSVG        = \"image/svg+xml\"\n",
+    "\tMIMETypeText       = \"text/plain\"\n",
     ")\n",
     "\n",
     "// MIMEMap holds data that can be presented in multiple formats. The keys are MIME types\n",
@@ -431,6 +432,8 @@
     "// it will be set automatically.\n",
     "type MIMEMap = map[string]interface{}\n",
     "\n",
+    "// Data is the exact structure sent to the front-end (Jupyter...) for displaying.\n",
+    "// It contains all the information needed to graphically show a value.\n",
     "type Data = struct {\n",
     "\tData      MIMEMap\n",
     "\tMetadata  MIMEMap\n",

x_package.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"image"
+	"image/color"
 	r "reflect"
 
 	"github.com/cosmos72/gomacro/imports"
@@ -40,6 +42,7 @@ var display = imports.Package{
 		"Data":           r.TypeOf((*Data)(nil)).Elem(),
 		"HTMLer":         r.TypeOf((*HTMLer)(nil)).Elem(),
 		"JavaScripter":   r.TypeOf((*JavaScripter)(nil)).Elem(),
+		"Image":          r.TypeOf((*image.Image)(nil)).Elem(),
 		"JPEGer":         r.TypeOf((*JPEGer)(nil)).Elem(),
 		"JSONer":         r.TypeOf((*JSONer)(nil)).Elem(),
 		"Latexer":        r.TypeOf((*Latexer)(nil)).Elem(),
@@ -54,6 +57,7 @@ var display = imports.Package{
 		// these are needed to allow interpreted types
 		// to implement the corresponding interfaces
 		"HTMLer":         r.TypeOf((*proxy_HTMLer)(nil)).Elem(),
+		"Image":          r.TypeOf((*proxy_image_Image)(nil)).Elem(),
 		"JPEGer":         r.TypeOf((*proxy_JPEGer)(nil)).Elem(),
 		"JSONer":         r.TypeOf((*proxy_JSONer)(nil)).Elem(),
 		"Latexer":        r.TypeOf((*proxy_Latexer)(nil)).Elem(),
@@ -166,6 +170,24 @@ func (P *proxy_SVGer) SVG() string {
 	return P.SVG_(P.Object)
 }
 
+// --------------- proxy for image.Image ---------------
+type proxy_image_Image struct {
+	Object      interface{}
+	At_         func(_proxy_obj_ interface{}, x int, y int) color.Color
+	Bounds_     func(interface{}) image.Rectangle
+	ColorModel_ func(interface{}) color.Model
+}
+
+func (P *proxy_image_Image) At(x int, y int) color.Color {
+	return P.At_(P.Object, x, y)
+}
+func (P *proxy_image_Image) Bounds() image.Rectangle {
+	return P.Bounds_(P.Object)
+}
+func (P *proxy_image_Image) ColorModel() color.Model {
+	return P.ColorModel_(P.Object)
+}
+
 // --------------------------------------------------------
 // allow importing "display" and "github.com/gopherdata/gophernotes" packages
 func init() {