plot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 67d6a3629080da18f0e3a73f6d8c49454c32698e54581c8b7bf8744c4773649c
+  data.tar.gz: c4456dfbd322ae85cfe26e26e063122942922d9781eb4649a82351c8811b54d8
+SHA512:
+  metadata.gz: 6afb6dd820edb324e75f3478610dcee2fb2798e909471c11b91dad7152ace8bd336b837fc646b7a5d1d6911c4d72d6ff223d91d5b82e61df1411da8a249a1d29
+  data.tar.gz: 665f0c522e9e9c37ba2093972367ff5a5115df26efa34300ecaef5606170a281a857333dfb2010cea1a2d5426029815fc21b1d928bfeb28fef7b339e1b6b3d5d

data/lib/js/bun_runner.js

@@ -0,0 +1,33 @@
+(function(program, execJS) { (function() {execJS(program) }).call({}); })(async function() { #{source}
+}, function(program) {
+  // Force BunJS to use sloppy mode see https://github.com/oven-sh/bun/issues/4527#issuecomment-1709520894
+  exports.abc = function(){}
+  var __process__ = process;
+  var printFinal = function(string) {
+    process.stdout.write('' + string, function() {
+      __process__.exit(0);
+    });
+  };
+  try {
+    //delete this.process;
+    //delete this.console;
+    (program()).then((result) => {
+      process = __process__;
+      if (typeof result == 'undefined' && result !== null) {
+        printFinal('["ok"]');
+      } else {
+        try {
+          printFinal(JSON.stringify(['ok', result]));
+        } catch (err) {
+          printFinal(JSON.stringify(['err', '' + err, err.stack]));
+        }
+      }
+    }).catch((err) => {
+      process = __process__;
+      printFinal(JSON.stringify(['err', '' + err, err.stack]));
+    })
+  } catch (err) {
+    process = __process__;
+    printFinal(JSON.stringify(['err', '' + err, err.stack]));
+  }
+});

data/lib/js/context.js

@@ -0,0 +1,16 @@
+const Plot = await import('@observablehq/plot');
+const d3 = await import('d3');
+const { JSDOM } = (await import('jsdom')).default;
+
+const jsdom = new JSDOM("")
+
+global.window = jsdom.window
+global.document = jsdom.window.document
+global.navigator = jsdom.window.navigator
+global.Event = jsdom.window.Event
+global.Node = jsdom.window.Node
+global.NodeList = jsdom.window.NodeList
+global.HTMLCollection = jsdom.window.HTMLCollection
+
+global.d3 = d3
+global.Plot = Plot

data/lib/plot/mark.rb

@@ -0,0 +1,89 @@
+class Plot::MarkProxy
+    def initialize(mark, type)
+        @mark = mark
+        @mark.type = type
+    end
+
+    def channel(name, value, **obj)
+        # TODO: add checking if option is a channel
+        obj[:value] = value
+        @mark.add_option(name, obj)
+    end
+
+    def option(name, value)
+        if(value.class == Proc || [:title, :href, :ariaLabel].include?(name)) then
+            raise "A channel should be used in place of option"
+        end
+        @mark.add_option(name, { value: value })
+    end
+
+    def style(name, value)
+        if([:fill, 
+            :fillOpacity, 
+            :stroke, 
+            :strokeWidth,
+            :strokeOpacity,
+            :strokeLinejoin,
+            :strokeLinecap,
+            :strokeMiterlimit,
+            :strokeDasharray,
+            :strokeDashoffset,
+            :opacity,
+            :mixBlendMode,
+            :imageFilter,
+            :shapeRendering,
+            :paintOrder,
+            :dx,
+            :dy,
+            :target,
+            :ariaDescription,
+            :ariaHidden,
+            :pointerEvents,
+            :clip,
+            :tip].include? name) 
+        then
+            @mark.add_option(name, value) 
+        else
+            raise "Not a style option"
+        end
+    end
+
+
+end
+
+class Plot::Mark
+
+    attr_accessor :type, :options
+
+    def initialize(type, **options)
+        @type = type
+        @options = options
+    end
+
+    def add_option(k, v)
+        @options[k.to_s] = v
+    end
+
+
+    def render(data)
+        @options.values do |o|
+            if o.try(:value).try(:lambda?)
+                output = []
+                data.each? do |obj|
+                    output.push(o.call(obj))
+                end
+
+                o.value = output
+            end
+
+            if o.try(:transform).try(:lambda?)
+                o.value = o.transform.call(data).to_a
+                o.transform = nil
+            end
+        end
+
+        "Plot['#{@type}'](JSON.parse('#{JSON.generate(data)}'), JSON.parse('#{JSON.generate(@options)}'))"
+    end
+
+    
+end

data/lib/plot/plot.rb

@@ -0,0 +1,54 @@
+class Plot::Plot
+
+    attr_accessor :data
+    
+    def initialize(**data)
+        @data = data
+    end
+
+    def render
+        self.class::definition.render(@data)
+    end
+
+    # Rails renderable
+    def render_in(view_context)
+        view_context.render html: render.html_safe
+    end
+end
+
+class Plot::PlotProxy
+
+    def initialize(plot)
+        @plot = plot
+    end
+
+    def mark(type, id, &block)
+        mark = Plot::Mark.new(nil)
+        mark_proxy = Plot::MarkProxy.new(mark, type)
+        mark_proxy.instance_eval(&block)
+        @plot.add_mark(id, mark)
+    end
+
+    def plot_options(**options)
+        @plot.options = options
+    end
+end
+
+
+class Plot::PlotDefinition
+
+    attr_accessor :marks, :options
+
+    def initialize(marks, **options)
+        @marks = marks.to_h
+        @options = options
+    end
+
+    def add_mark(id, mark)
+        @marks[id.to_s] = mark
+    end
+
+    def render(data)
+        Plot.plot(@marks, data, @options)
+    end
+end

data/lib/plot.rb

@@ -0,0 +1,46 @@
+require "execjs"
+require "json"
+
+module Plot
+    @source = open(Gem.loaded_specs["plot"].gem_dir + "/lib/js/context.js").read
+        
+    @runtime = ExecJS::ExternalRuntime.new(
+        name:        "Bun.sh Async",
+        command:     ["bun"],
+        runner_path: Gem.loaded_specs["plot"].gem_dir + "/lib/js/bun_runner.js",
+        encoding:    'UTF-8'
+    )
+
+    @context = @runtime.compile(@source)
+
+    def self._context
+        @context
+    end
+
+    def self.encode_source(source)
+        @runtime.send(:encode_source,source)
+    end
+
+
+    def self.define(&block)
+        definition = PlotDefinition.new(nil)
+        plot_proxy = PlotProxy.new(definition)
+        plot_proxy.instance_eval(&block)
+        return definition
+    end
+
+
+    def self.call(method, *args)
+        puts *args
+        @context.call("Plot['#{method}']", *args)
+    end
+
+    def self.plot(marks, data, options)
+        rendered_marks = marks.keys.map { |m| marks[m.to_s].render(data[m.to_sym]) }
+        @context.call("function(marks, options) { const rendered_marks = marks.map((m) => eval(m)); return Plot.plot({ marks: rendered_marks, ...options }).outerHTML.toString() }", rendered_marks, options)
+    end
+    
+    require "plot/plot"
+    require "plot/mark"
+
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: plot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Reese Armstrong
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-10-10 00:00:00.000000000 Z
+dependencies: []
+description: An unofficial DSL for making charts with Observable Plot. You define
+  plot definitions with the DSL that create full charts when data is added. This gem
+  relies upon the installation of the Bun JavaScript runtime.
+email: me@reeseric.ci
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/js/bun_runner.js
+- lib/js/context.js
+- lib/plot.rb
+- lib/plot/mark.rb
+- lib/plot/plot.rb
+homepage: https://sr.ht/~reesericci/plot
+licenses:
+- ISC
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: DSL for making charts with Observable Plot
+test_files: []