interfacets 0.1.0 → 0.9.99

data/lib/interfacets/client.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    def self.start(...)
+      @system = System.start(...)
+    end
+
+    def self.system
+      @system
+    end
+  end
+end

data/lib/interfacets/component_registry.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+require 'json'
+require "interfacets/component_schema_parser"
+
+module Interfacets
+  class ComponentRegistry
+    def initialize(config_path:)
+      @config_path = config_path
+      @schema_cache = {}
+    end
+
+    def write_client_registry(path:)
+      components = load_components
+      content = generate_registry_content(components)
+      write_atomic(path, content)
+    end
+
+    private
+
+    def load_components
+      raise Errno::ENOENT, "Configuration file not found at #{@config_path}" unless File.exist?(@config_path)
+      
+      # 1. Load the raw YAML
+      components = YAML.load_file(@config_path, aliases: true) || {}
+      
+      # 2. Parse with the V2 parser
+      parser = Interfacets::ComponentSchemaParser.new
+      parsed_components = {}
+      components.each do |name, config|
+        next unless config.is_a?(Hash)
+        component_data = { name => config }
+        # The result of parse is the component data, which we merge.
+        parsed_components.merge!(parser.parse(component_data))
+      end
+      
+      parsed_components
+    end
+
+    def generate_registry_content(components)
+      registry_components = components.select { |_, config| config.key?("js") || has_transforms?(config) }
+
+      imports = []
+      mappings = []
+      any_transforms = false
+
+      registry_components.each do |name, config|
+        js_config = config["js"]
+        path = js_config&.dig("path")
+
+        transforms = extract_transforms(config)
+
+        if path
+          imports << if js_config["default"]
+            "import #{name} from \"#{path}\";"
+          elsif (export = js_config["export"])
+            "import { #{export} as #{name} } from \"#{path}\";"
+          else
+            "import { #{name} } from \"#{path}\";"
+          end
+        else
+          # Native element
+          imports << "const #{name} = \"#{name}\";"
+        end
+
+        if transforms.any?
+          any_transforms = true
+          mappings << "  #{name}: withTransform(#{name}, #{transforms.to_json}),"
+        else
+          mappings << "  #{name},"
+        end
+      end
+
+      if any_transforms
+        imports.unshift('import { withTransform } from "interfacets/withTransform";')
+      end
+
+      template = []
+      template << imports.join("\n") if imports.any?
+      template << <<~JS.strip
+        export const registry = {
+        #{mappings.join("\n")}
+        };
+      JS
+
+      "#{template.join("\n\n")}\n"
+    end
+
+    def has_transforms?(config)
+      extract_transforms(config).any?
+    end
+
+    def extract_transforms(config)
+      transforms = {}
+      if props = config["props"]
+        props.each do |prop_name, prop_config|
+          if prop_config["is_event"] && prop_config.key?("transform")
+            transforms[prop_name] = prop_config["transform"]
+          end
+        end
+      end
+      transforms
+    end
+
+
+
+    def write_atomic(path, content)
+      temp_file = "#{path}.tmp"
+      File.write(temp_file, content)
+      FileUtils.mv(temp_file, path)
+    end
+  end
+end

data/lib/interfacets/component_schema_parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "json_schemer"
+
+module Interfacets
+  class ComponentSchemaParser
+    SCHEMA = {
+      "$schema" => "http://json-schema.org/draft-07/schema#",
+      "type" => "object",
+      "patternProperties" => {
+        "^.*$" => {
+          "type" => "object",
+          "properties" => {
+            "schema" => {
+              "if" => { "type" => "object" },
+              "then" => {
+                "not" => { "required" => ["props"] }
+              }
+            },
+            "props" => {
+              "type" => "object",
+              "patternProperties" => {
+                "^.*$" => {
+                  "type" => "object",
+                  "properties" => {
+                    "is_event" => { "type" => "boolean" }
+                  },
+                  "if" => {
+                    "required" => ["is_event"],
+                    "properties" => { "is_event" => { "const" => true } }
+                  },
+                  "then" => {
+                    "properties" => {
+                      "transform" => { "$ref" => "#/definitions/Transform" },
+                      "payload" => { "type" => "object" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "definitions" => {
+        "Transform" => {
+          "oneOf" => [
+            { "type" => "null" },
+            { "type" => "string" },
+            {
+              "type" => "object",
+              "additionalProperties" => {
+                "type" => "array",
+                "items" => [
+                  { "type" => "integer" }
+                ],
+                "additionalItems" => { "type" => "string" },
+                "minItems" => 1
+              }
+            }
+          ]
+        }
+      }
+    }.freeze
+
+    SCHEMER = JSONSchemer.schema(SCHEMA)
+
+    def parse(component_config)
+      errors = SCHEMER.validate(component_config).to_a
+      if errors.any?
+        if errors.any? { |e| e["data_pointer"].include?("/schema") && e["type"] == "not" }
+          raise StandardError, "Old schema format is not supported."
+        end
+
+        message = "Validation failed:\n"
+        errors.each do |error|
+          message += "  - #{error["data_pointer"]}: #{error["type"]} #{error["details"]}\n"
+        end
+        raise StandardError, message
+      end
+
+      component_config
+    end
+  end
+end

data/lib/interfacets/mruby/build.dockerfile

@@ -0,0 +1,66 @@
+FROM emscripten/emsdk:3.1.62
+
+RUN apt update
+RUN apt install -y vim git
+RUN apt install -y ruby
+RUN git clone https://github.com/mruby/mruby.git /home/root/interfacets/mruby
+WORKDIR /home/root/interfacets/mruby
+# RUN git fetch origin master && git reset --hard origin/master
+RUN git fetch origin --tags && git reset --hard 3.4.0
+RUN rake all test
+ENV PATH="/home/root/interfacets/mruby/bin:${PATH}"
+COPY ./lib/interfacets/mruby/build_config.rb \
+  /home/root/interfacets/
+WORKDIR /home/root/interfacets
+RUN cd mruby && \
+  sed -i '/MRB_STR_LENGTH_MAX 1048576/c#define MRB_STR_LENGTH_MAX 0' src/string.c && \
+  MRUBY_CONFIG=../build_config.rb rake
+RUN mkdir -p assets/mruby build
+RUN cp -r mruby/include assets/mruby \
+  && cp mruby/build/emscripten/lib/libmruby.a assets/mruby
+COPY ./lib/interfacets/mruby/init.c \
+  ./lib/interfacets/mruby/entrypoint.rb \
+  /home/root/interfacets/
+# RUN mrbc --help
+RUN mrbc -B ruby_app -o build/app.c entrypoint.rb
+RUN echo "\n" >> build/app.c && cat init.c >> build/app.c
+RUN emcc \
+  -s EXPORT_NAME=MRuby \
+  -s EXPORTED_FUNCTIONS='_ruby_eval,_main,_ruby_call,stringToNewUTF8' \
+  -s ENVIRONMENT=web \
+  -s MODULARIZE=1 \
+  -s EXPORT_ES6=1 \
+  -s ALLOW_MEMORY_GROWTH=1 \
+  -s SINGLE_FILE=1 \
+  -I ./assets/mruby/include \
+  build/app.c \
+  ./assets/mruby/libmruby.a \
+  -o build/ruby.js
+
+RUN emcc \
+  -s EXPORT_NAME=MRuby \
+  # -s EXPORTED_FUNCTIONS='_ruby_eval,_main,_ruby_call,stringToNewUTF8' \
+  -s ENVIRONMENT=node \
+  -s MODULARIZE=1 \
+  -s EXPORT_ES6=1 \
+  -s SIDE_MODULE=1 \
+  -s ALLOW_MEMORY_GROWTH=1 \
+  -I ./assets/mruby/include \
+  build/app.c \
+  ./assets/mruby/libmruby.a \
+  -o build/test.wasm
+
+RUN emcc \
+  -s EXPORT_NAME=MRuby \
+  -s EXPORTED_FUNCTIONS='_ruby_eval,_main,_ruby_call,stringToNewUTF8' \
+  -s ENVIRONMENT=node \
+  -s MODULARIZE=1 \
+  -s EXPORT_ES6=1 \
+  -s MAIN_MODULE=1 \
+  -s ALLOW_MEMORY_GROWTH=1 \
+  -I ./assets/mruby/include \
+  build/app.c \
+  ./assets/mruby/libmruby.a \
+  -o build/test.js
+
+RUN mv build /build

data/lib/interfacets/mruby/build_config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+MRuby::Build.new do |conf|
+  toolchain :gcc
+  conf.gembox("full-core")
+end
+
+MRuby::CrossBuild.new("emscripten") do |conf|
+  toolchain :clang
+  conf.gembox("full-core")
+  conf.cc.command = "emcc"
+  conf.cc.flags = ["-Os", "-fPIC"]
+  conf.linker.command = "emcc"
+  conf.archiver.command = "emar"
+
+  conf.gem(github: "mattn/mruby-json")
+  conf.gem(github: "mattn/mruby-base64")
+  conf.gem(github: "monochromegane/mruby-secure-random")
+  conf.gem(github: "iij/mruby-regexp-pcre")
+end

data/lib/interfacets/mruby/entrypoint.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Kernel
+  def wrapped_eval(str, path)
+    eval(str, binding, path)
+  rescue StandardError, SyntaxError => e
+    $stderr.puts(e.class)
+    $stderr.puts(e.message)
+    $stderr.puts(e.backtrace.join("\n"))
+  end
+
+  def wrapped_call(json_string)
+    spec = JSON.parse(json_string)
+    eval(spec.fetch("receiver")).send(
+      spec.fetch("method"),
+      *spec.fetch("args", []),
+    )
+  rescue StandardError, SyntaxError => e
+    $stderr.puts(e.class)
+    $stderr.puts(e.message)
+    $stderr.puts(e.backtrace.join("\n"))
+  end
+end

data/lib/interfacets/mruby/init.c

@@ -0,0 +1,66 @@
+#include <mruby.h>
+#include <mruby/irep.h>
+#include <emscripten.h>
+
+mrb_value js_eval(mrb_state* mrb, mrb_value self)
+{
+  char *js_code;
+  mrb_get_args(mrb, "z", &js_code);
+  emscripten_run_script(js_code);
+  return self;
+}
+
+mrb_state *mrb;
+void EMSCRIPTEN_KEEPALIVE ruby_eval(char* str, char* path) {
+  int ai = mrb_gc_arena_save(mrb);
+  mrb_funcall(
+    mrb,
+    mrb_top_self(mrb),
+    "wrapped_eval",
+    2,
+    mrb_str_new_cstr(mrb, str),
+    mrb_str_new_cstr(mrb, path)
+  );
+
+  if (mrb->exc) mrb_print_error(mrb);
+  mrb_gc_arena_restore(mrb, ai);
+}
+
+// json of the form:
+// {receiver: , method:, args: [ ...] ]
+void EMSCRIPTEN_KEEPALIVE ruby_call(char* json) {
+  int ai = mrb_gc_arena_save(mrb);
+
+  mrb_funcall(
+    mrb,
+    mrb_top_self(mrb),
+    "wrapped_call",
+    1,
+    mrb_str_new_cstr(mrb, json)
+  );
+
+  if (mrb->exc) mrb_print_error(mrb);
+  mrb_gc_arena_restore(mrb, ai);
+}
+
+int main() {
+  // Leave this open for all eternity
+  mrb = mrb_open();
+
+  if (!mrb) { /* handle error */ }
+
+  mrb_define_method(
+    mrb,
+    mrb->kernel_module,
+    "js_eval",
+    js_eval,
+    MRB_ARGS_REQ(1)
+  );
+
+  mrb_load_irep(mrb, ruby_app);
+
+  // If an exception, print error
+  if (mrb->exc) mrb_print_error(mrb);
+
+  return 0;
+}

data/lib/interfacets/server/api.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    class Api
+      attr_reader :entity, :name, :registry
+      def initialize(entity:, name:, registry:)
+        @entity = entity
+        @name = name
+        @registry = registry
+      end
+
+      def handle(event)
+        Shared::Entities::Bus
+          .new(entity:)
+          .handle(event:)
+
+        if entity.channel.rendered?
+          entity.channel.render_facet
+        else
+          emit("after_#{event.fetch("action")}", nesting: event.fetch("nesting"))
+        end
+      end
+
+      def render
+        emit("after_load", nesting: ["root"])
+      end
+
+      private
+
+      def emit(action, nesting: )
+        {
+          facet: name,
+          payload: (
+            Shared::Entities::Bus
+              .new(entity:)
+              .serialize(to: "client", action:, nesting:)
+          )
+        }
+      end
+
+    end
+  end
+end

data/lib/interfacets/server/assets/facet.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    module Assets
+      class Facet
+        def self.register(klass:, assets:)
+          assets[klass.name] = new(klass).code
+        end
+
+        attr_reader :klass
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def code
+          # nest it all so names resolve
+          *mods, klass_name = klass.name.split("::")
+
+          headers = []
+          footers = []
+
+          current_mod = ""
+          mods.each do |mod_name|
+            current_mod += "::#{mod_name}"
+            type = current_mod.constantize.is_a?(Class) ? :class : :module
+            headers << "#{type} #{mod_name}"
+            footers << "end"
+          end
+
+          headers << "class #{klass_name}"
+          headers << "  include Interfacets::Shared::Facet"
+          footers << "end"
+
+          <<~TXT
+            #{headers.join("\n")}
+
+              include Interfacets::Shared::Facets::Schema
+
+              view_spec #{write_source(klass.client_config.view.block)}
+
+              entity_spec #{write_source(klass.client_config.api.block)}
+
+              client_spec #{write_source(klass.client_config.entity.block)}
+            #{footers.join("\n")}
+          TXT
+        end
+
+        private
+
+        def write_source(block)
+          return unless block
+
+          RubyVM::AbstractSyntaxTree
+            .of(block, keep_script_lines: true)
+            .source
+            .strip
+
+        end
+      end
+    end
+  end
+end