interfacets 0.9.9 → 0.9.99

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1f88601fcc7349a9d14fb653aa28bd0fb988dce3571ea4c488d9ea0c46ece93
-  data.tar.gz: 8e954aa9c6b4c0d40fdf4df5487fcc0f4de2d36b6ff6e0abfcf446e321cc8e8d
+  metadata.gz: 8e7e08a925c26ef4b7ee1e2aa2bbdcd716388b6f3aaa22f8d5bf9e7a51a76cee
+  data.tar.gz: 222f5f5f8129c913d19ce4f6d6331f820ad643a6198f35f63ce0b9df2743e059
 SHA512:
-  metadata.gz: 0ad6edcb3b43786a4b914c18d0899ff3e4400ad039e92a11553f31e1d97dee3125a1bd9a58050bb4bb8f28db5d568ba00e0f9d9dfe6afd7ea71edc7b29e0ffb1
-  data.tar.gz: 163066c8f07e91d45351bf396473a6bd655db05d1b9bc792bad92c54fa9ac09d1aa4a1d4d68c59ddf03a8c8ef71e996c2e742bf2ad238ff72cb584697633998d
+  metadata.gz: 68e278e17a2b033f8dc0ee6941f80a76d6ddb6bfeb0d7c79267ed24150d48b6d7e1ff54bda300cb0db5b4caa238632be5efe8b228fa018362482b7d8cea1264a
+  data.tar.gz: 3ca6b351b7089d7e9d99e513a282c937cea531a813a1ebfdfd35a514b2f34f95187f19c63ac57e1a5691c61d111f67f2dbae0b614c490c252a2f76b3dcc5006a

data/.tmp

@@ -0,0 +1,5 @@
+import { Test } from 
+
+export const registry = {
+  Test,
+};

data/Rakefile

@@ -5,6 +5,10 @@ require "minitest/test_task"
 
 Minitest::TestTask.create do |t|
   t.warning = false
+  t.test_globs = (
+    Rake::FileList["test/**/test_*.rb", "test/**/*_test.rb"]
+    .exclude("test/fixtures/**/*")
+  )
 end
 
 task default: :test

data/lib/interfacets/client/assets.rb

@@ -33,6 +33,7 @@ class InterfacetsLogger
       puts "#{method_name.to_s.upcase}: #{message}" if level_value >= @level
     end
   end
+
 end
 
 $VERBOSE = original_verbose

data/lib/interfacets/client/bus.rb

@@ -48,7 +48,11 @@ module Interfacets
         channel.handle(
           entity: @entity,
           event: event.fetch("payload"),
-          build_entity: ->(name) { @entity = registry.build(name) }
+          build_entity: ->(name, id) {
+            @entity = registry.build(name, id)
+            channel_index.values.each { _1.prepare(@entity) }
+            @entity
+          }
         )
 
         channel_index.values.each { _1.prepare(entity) }

data/lib/interfacets/client/channels/api.rb

@@ -22,7 +22,7 @@ module Interfacets
             }
           end
 
-          def submit(meth)
+          def submit(meth, nesting: )
             raise("only one submission per action") if request
 
             System.logger.debug("submitting #{meth}")
@@ -46,7 +46,7 @@ module Interfacets
                       .serialize(
                         to: "server" ,
                         action: meth,
-                        nesting: ["root"]
+                        nesting:
                       )
                   )
                 },
@@ -81,7 +81,14 @@ module Interfacets
 
         def handle(event:, entity:, build_entity:)
           facet_name = event.fetch("facet")
-          entity = build_entity.(facet_name)
+          id = event.dig(
+            "payload",
+            "payload",
+            "attributes",
+            "internal_entity_id"
+          )
+
+          entity = build_entity.(facet_name, id)
 
           Shared::Entities::Bus
             .new(entity:)

data/lib/interfacets/client/registry.rb

@@ -3,82 +3,21 @@
 module Interfacets
   module Client
     class Registry
-      def build(name)
-        entity = Object.const_get("#{name}::Client::Entity")
+      def initialize
+        @stores = {}
+      end
+
+      def build(name, id)
+        entity = Object.const_get(name).client_entity_class
+
+        @stores[id] ||= entity.store.new
 
         entity.new(
-          store: entity.store.new,
+          store: @stores[id],
           parent: nil,
           nesting: ["root"]
         )
       end
-
-      def register(schema, namespace: "Things")
-        schema.each do |name, schema|
-          next if registry.key?(name)
-
-          shared = Class.new(Shared::Entity) do
-            schema.fetch("shared").each { class_exec(&eval(_1)) }
-          end
-
-          view = Class.new(View) do
-            schema.fetch("view").each { view(&eval(_1)) }
-          end
-
-          entity = Class.new(Shared::Entity) do
-            define_singleton_method(:view) { view }
-            self.manifest = shared
-
-            schema.fetch("shared").each { class_exec(&eval(_1)) }
-            schema.fetch("client").each { class_exec(&eval(_1)) }
-
-            actions.each do |name, spec|
-              if name.start_with?("after_")
-                define_method(name) {}
-              end
-            end
-          end
-
-          store = Shared::GeneratedStore.construct(entity)
-
-          mod = set_const(
-            [
-              namespace,
-              name.split("::"),
-            ].flatten,
-            Module.new
-          )
-          entity.define_singleton_method(:facet_name) { name }
-          mod.const_set("Entity", entity)
-          entity.const_set("Shared", shared)
-          entity.const_set("View", view)
-
-          registry[name] = { entity:, store: }
-        end
-      end
-
-      private
-
-      def set_const(mods, klass)
-
-        namespace = Object
-
-        mods[0..-1].each do |mod|
-          namespace = (
-            if namespace.const_defined?(mod, false)
-              namespace.const_get(mod)
-            else
-              namespace.const_set(mod, Module.new)
-            end
-          )
-        end
-
-        namespace.const_set(mods.last, klass)
-      end
-
-      def registry
-        @registry ||= {}
-      end
     end
   end
 end

data/lib/interfacets/client/utils/mruby_patches.rb

@@ -60,7 +60,7 @@ module Interfacets
 
         module StringPresence
           def blank?
-            match?(/^\s*$/)
+            !!match(/\A\s*\z/)
           end
         end
 

data/lib/interfacets/client/utils/open_struct.rb

@@ -2,101 +2,114 @@
 
 # copied from github
 
-class OpenStruct
-  def initialize hash=nil
-    @table = {}
-    if hash
-      hash.each do |k,v|
-        k = k.to_sym
-        @table[k] = v
-        new_ostruct_member(k)
-      end
-    end
+required = (
+  begin
+    require "ostruct"
+    true
+  rescue
+    false
   end
+)
 
-  def initialize_copy orig
-    super
-    @table = @table.dup
-    @table.each_key{|key| new_ostruct_member(key)}
-  end
+unless required
 
-  def to_h
-    @table.dup
-  end
 
-  def each_pair
-    return to_enum __method__ unless block_given?
-    @table.each{|p| yield p}
-  end
+  class OpenStruct
+    def initialize hash=nil
+      @table = {}
+      if hash
+        hash.each do |k,v|
+          k = k.to_sym
+          @table[k] = v
+          new_ostruct_member(k)
+        end
+      end
+    end
 
-  def new_ostruct_member name
-    name = name.to_sym
-    unless respond_to?(name)
-      define_singleton_method(name){ @table[name] }
-      define_singleton_method("#{name}=".to_sym){ |x| @table[name] = x }
+    def initialize_copy orig
+      super
+      @table = @table.dup
+      @table.each_key{|key| new_ostruct_member(key)}
     end
-    name
-  end
-  protected :new_ostruct_member
 
-  def inspect
-    str = "#<#{self.class}"
-    ary = []
-    @table.each do |k,v|
-      ary << "#{k}=#{v}"
+    def to_h
+      @table.dup
     end
-    if 0 < ary.length
-      str << ' '
-      str << ary.join(', ')
+
+    def each_pair
+      return to_enum __method__ unless block_given?
+      @table.each{|p| yield p}
     end
-    str << '>'
-  end
-  alias :to_s :inspect
 
-  def delete_field name
-    sym = name.to_sym
-    singleton_class.__send__ :remove_method, sym, "#{sym}=".to_sym
-    @table.delete sym
-  end
+    def new_ostruct_member name
+      name = name.to_sym
+      unless respond_to?(name)
+        define_singleton_method(name){ @table[name] }
+        define_singleton_method("#{name}=".to_sym){ |x| @table[name] = x }
+      end
+      name
+    end
+    protected :new_ostruct_member
 
-  def == other
-    return false unless other.kind_of?(OpenStruct)
-    @table == other.table
-  end
+    def inspect
+      str = "#<#{self.class}"
+      ary = []
+      @table.each do |k,v|
+        ary << "#{k}=#{v}"
+      end
+      if 0 < ary.length
+        str << ' '
+        str << ary.join(', ')
+      end
+      str << '>'
+    end
+    alias :to_s :inspect
 
-  def [] key
-    @table[key.to_sym]
-  end
+    def delete_field name
+      sym = name.to_sym
+      singleton_class.__send__ :remove_method, sym, "#{sym}=".to_sym
+      @table.delete sym
+    end
 
-  def []= key, value
-    @table[new_ostruct_member(key)] = value
-  end
+    def == other
+      return false unless other.kind_of?(OpenStruct)
+      @table == other.table
+    end
 
-  def eql? other
-    return false unless other.kind_of?(OpenStruct)
-    @table.eql?(other.table)
-  end
+    def [] key
+      @table[key.to_sym]
+    end
 
-  def hash
-    @table.hash
-  end
+    def []= key, value
+      @table[new_ostruct_member(key)] = value
+    end
+
+    def eql? other
+      return false unless other.kind_of?(OpenStruct)
+      @table.eql?(other.table)
+    end
+
+    def hash
+      @table.hash
+    end
 
-  attr_reader :table
-  protected :table
+    attr_reader :table
+    protected :table
 
-  def method_missing mid, *args
-    mname = mid.to_s
-    len = args.length
-    if mname.chomp! '='
-      if len != 1
-        raise ArgumentError, "wrong number of arguments (#{len} for 1)"
+    def method_missing mid, *args
+      mname = mid.to_s
+      len = args.length
+      if mname.chomp! '='
+        if len != 1
+          raise ArgumentError, "wrong number of arguments (#{len} for 1)"
+        end
+        @table[new_ostruct_member(mname)] = args[0]
+      elsif len == 0
+        @table[mid]
+      else
+        raise NoMethodError, "undefined method `#{mid}' for #{self}"
       end
-      @table[new_ostruct_member(mname)] = args[0]
-    elsif len == 0
-      @table[mid]
-    else
-      raise NoMethodError, "undefined method `#{mid}' for #{self}"
     end
   end
+  # rubocop:enable all
 end
-# rubocop:enable all

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/server/api.rb

@@ -3,20 +3,6 @@
 module Interfacets
   module Server
     class Api
-      class Channel
-        attr_reader :klass, :store
-
-        def rendered?
-          @rendered
-        end
-
-        def render(klass, store)
-          @rendered = true
-          @klass = klass
-          @store = store
-        end
-      end
-
       attr_reader :entity, :name, :registry
       def initialize(entity:, name:, registry:)
         @entity = entity
@@ -25,36 +11,30 @@ module Interfacets
       end
 
       def handle(event)
-        channel = Channel.new
-
-        entity.channel = channel
         Shared::Entities::Bus
           .new(entity:)
           .handle(event:)
 
         if entity.channel.rendered?
-          registry.build(
-            channel.klass,
-            channel.store,
-          ).render
+          entity.channel.render_facet
         else
-          emit("after_#{event.fetch("action")}")
+          emit("after_#{event.fetch("action")}", nesting: event.fetch("nesting"))
         end
       end
 
       def render
-        emit("after_load")
+        emit("after_load", nesting: ["root"])
       end
 
       private
 
-      def emit(action)
+      def emit(action, nesting: )
         {
           facet: name,
           payload: (
             Shared::Entities::Bus
               .new(entity:)
-              .serialize(to: "client", action:, nesting: ["root"])
+              .serialize(to: "client", action:, nesting:)
           )
         }
       end

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

@@ -23,18 +23,19 @@ module Interfacets
           current_mod = ""
           mods.each do |mod_name|
             current_mod += "::#{mod_name}"
-            type = current_mod.constantize.is_a?(Module) ? :module : :class
+            type = current_mod.constantize.is_a?(Class) ? :class : :module
             headers << "#{type} #{mod_name}"
             footers << "end"
           end
 
-          headers << "class #{klass_name} < Interfacets::Client::Facet"
+          headers << "class #{klass_name}"
+          headers << "  include Interfacets::Shared::Facet"
           footers << "end"
 
           <<~TXT
             #{headers.join("\n")}
 
-              include Interfacets::Client::Facets::Schema
+              include Interfacets::Shared::Facets::Schema
 
               view_spec #{write_source(klass.client_config.view.block)}
 
@@ -54,6 +55,7 @@ module Interfacets
             .of(block, keep_script_lines: true)
             .source
             .strip
+
         end
       end
     end