hokusai-zero 0.1.1

data/ui/src/hokusai/mounting/loop_entry.rb

@@ -0,0 +1,230 @@
+require "forwardable"
+require_relative "../diff"
+
+module Hokusai
+  module Mounting
+    class LoopContext
+      attr_reader :table
+      def initialize
+        @table = {}
+      end
+
+      def add_entry(var, value)
+        table[var] = value
+      end
+
+      def send_target(target, func)
+        args = func.args.map do |arg|
+          table[arg]
+        end
+
+        target.public_send(func.method, *args)
+      end
+    end
+
+    class LoopEntry
+      extend Forwardable
+
+      INDEX_KEY = "index".freeze
+
+      def_delegators :@entry, :ast, :block, :target, :parent
+
+      def initialize(mount_entry)
+        @entry = mount_entry
+      end
+
+      def register
+        child_block_class = target.class.use(ast.type)
+        values = target.public_send(ast.loop.method)
+
+        unless values.is_a?(Enumerable)
+          raise Hokusai::Error.new("Loop directive `#{ast.loop.method}` on #{target.class} must return an Enumerable")
+        end
+
+        entries_to_return = []
+        secondary_entries = []
+
+        # puts "COMPILING #{ast.type}"
+        # portal = Node.new(ast)
+        # node = child_block_class.compile(ast.type, portal)
+
+        values.each_with_index do |value, index|
+          ctx = LoopContext.new
+          ctx.add_entry(ast.loop.var, value)
+          ctx.add_entry(INDEX_KEY, index)
+
+          if ast.has_if_condition?
+            if ast.if.args.size > 0
+              ctx.send_target(target, target.if)
+            else
+              condition = target.public_send(ast.if.method)
+            end
+
+            next if condition
+          end
+
+          portal = Node.new(ast)
+          node = child_block_class.compile(ast.type, portal)
+          child_block = child_block_class.new(node: node)
+          child_block.node.add_styles(target.class)
+          child_block.node.add_props_from_block(target, context: ctx)
+          child_block.node.meta.props[ast.loop.var.to_sym] = value
+          child_block.node.meta.publisher.add(target)
+
+          UpdateEntry.new(child_block, block, target).register(context: ctx)
+
+          child_block.class.provides.merge!(parent.class.provides)
+
+          block.node.meta << child_block
+
+          node.ast.children.each_with_index do |child, idx|
+            entries_to_return << MountEntry.new(index, child, child_block, child_block, child_block, context: nil)
+          end
+
+          siblings = []
+          portal.ast.children.each_with_index do |child, idx|
+            siblings << MountEntry.new(idx, child, child_block, child_block, target, context: ctx)
+          end
+
+          secondary_entries << siblings
+        end
+
+        update_loop
+
+        [entries_to_return, secondary_entries]
+      end
+
+      def update_loop
+        block.node.meta.on_update(target) do |ublock, uparent, utarget|
+          values = utarget.public_send(ast.loop.method)
+
+          unless values.is_a?(Enumerable)
+            raise Hokusai::Error.new("Loop directive `#{ast.loop.method}` on #{target.class} must return an Enumerable")
+          end
+
+          key_prop = ast.props["key"]
+
+          raise Hokusai::Error.new("Loop children must have a :key method defined") if key_prop.nil?
+
+          key_ctx = LoopContext.new
+
+          new_values = []
+
+          index_key = "index".freeze
+          values.each_with_index do |value, index|
+            key_ctx.add_entry(ast.loop.var, value)
+            key_ctx.add_entry(index_key, index)
+
+            if key_prop.value.args.size > 0
+              key = key_ctx.send_target(utarget, key_prop.value)
+            elsif key_ctx.table[key_prop.value.method]
+              key = key_ctx.table[key_prop.value.method]
+            else
+              key = utarget.public_send(key_prop.value.method)
+            end
+
+            new_values << [key, value]
+          end
+
+          previous_values = []
+          children = []
+          loop_var = ast.loop.var.to_sym
+
+          ublock.children?&.each do |child|
+            if key = child.node.meta.get_prop(:key)
+              raise Hokusai::Error.new("Loop children must use :key field") unless key
+
+              previous_values << [key, child.node.meta.get_prop(loop_var)]
+            end
+
+            children << child
+          end
+
+          next if new_values == previous_values
+
+          Diff.new(previous_values, new_values).patch do |patch|
+            case patch
+            when UpdatePatch
+              ctx = LoopContext.new
+              ctx.add_entry("index", patch.target)
+              ctx.add_entry(ast.loop.var, patch.value)
+              children[patch.target].node.add_styles(target.class)
+              children[patch.target].node.add_props_from_block(target, context: ctx)
+              children[patch.target].node.meta.set_prop(ast.loop.var.to_sym, patch.value)
+
+              UpdateEntry.new(children[patch.target], uparent, utarget).register(context: ctx)
+            when MovePatch
+              if patch.delete
+                from = children[patch.from]
+                children[patch.to] = from
+                children[patch.from].public_send(:on_destroy) if children[patch.from].respond_to? :on_destroy
+                children[patch.from].node.destroy
+                children[patch.from] = nil
+              else
+                from = children[patch.from]
+                to = children[patch.to]
+
+                children[patch.to] = from
+                children[patch.from] = to
+              end
+
+              ctx = LoopContext.new
+              ctx.add_entry(INDEX_KEY, patch.to)
+              children[patch.to].node.meta.props.each do |k, v|
+                ctx.add_entry(k.to_s, v)
+              end
+
+              children[patch.to].node.add_styles(target.class)
+              children[patch.to].node.add_props_from_block(target, context: ctx)
+            when InsertPatch
+              target_ast = ast
+              ctx = LoopContext.new
+              ctx.add_entry(INDEX_KEY, patch.target)
+              ctx.add_entry(ast.loop.var, patch.value)
+
+              if ast.has_if_condition?
+                if ast.if.args.size > 0
+                  condition = ctx.send_target(target, ast.if.method)
+                else
+                  condition = target.public_send(ast.if.method)
+                end
+
+                if !condition && ast.has_else_condition?
+                  target_ast = ast.else_ast
+                elsif !condition
+                  children[patch.target].public_send(:on_destroy) if children[patch.target].respond_to? :on_destroy
+                  children[patch.target].node.destroy
+                  children[patch.target] = nil
+                  next
+                end
+              end
+
+              child_block_class = utarget.class.use(target_ast.type)
+              portal = Node.new(ast)
+              node = child_block_class.compile(target_ast.type, portal)
+              node.add_props_from_block(target, context: ctx)
+              child_block = NodeMounter.new(node, child_block_class).mount(context: ctx)
+              child_block.node.add_styles(target.class)
+              child_block.node.meta.publisher.add(target)
+
+              child_block.class.provides.merge!(parent.class.provides)
+
+              if patch.delete
+                children[patch.target] = child_block
+              else
+                children.insert(patch.target, child_block)
+              end
+            when DeletePatch
+              children[patch.target].public_send(:on_destroy) if children[patch.target].respond_to? :on_destroy
+              children[patch.target].node.destroy
+              children[patch.target] = nil
+              # TODO: update rest of block props
+            end
+          end
+
+          ublock.node.meta.children = children.reject(&:nil?)
+        end
+      end
+    end
+  end
+end

data/ui/src/hokusai/mounting/mount_entry.rb

@@ -0,0 +1,74 @@
+module Hokusai
+  module Mounting
+    class MountEntry
+      attr_reader :block, :parent, :ast, :target, :index, :ctx
+
+      def initialize(index, ast, block, parent, target = parent, context: nil)
+        @index = index
+        @ast = ast
+        @block = block
+        @parent = parent
+        @target = target
+        @ctx = context
+      end
+
+      def loop?
+        ast.loop?
+      end
+
+      def virtual?
+        ast.virtual?
+      end
+
+      def slot?
+        ast.slot?
+      end
+
+      def debug
+        StringIO.open do |io|
+          io << "#{block.class} | #{ast.type} (#{index})\n"
+          io << "#{block.node.ast.children.map(&:type)}"
+          io << "parent: #{parent.class}\n"
+          io << "target: #{target.class}\n\n"
+        end.string
+      end
+
+      def with_block(new_block, supercede_parent: false)
+        parent_block = supercede_parent ? block : parent
+        MountEntry.new(index, ast, new_block, parent_block, target, context: ctx)
+      end
+
+      def mount(context: nil)
+        klass = target.class.use(ast.type)
+        portal = Node.new(ast)
+
+        node = klass.compile(ast.type, portal)
+        node.add_styles(target.class)
+        node.add_props_from_block(target, context: context || ctx)
+
+        child_block = klass.new(node: node)
+        child_block.node.meta.publisher.add(target) # todo
+        UpdateEntry.new(child_block, block, target).register(context: context || ctx)
+
+        block.class.provides.each do |k, v|
+          if v.is_a?(Symbol)
+            Node.provide(child_block.node, k, ->{ block.public_send(v) })
+
+            # child_block.node.meta.provides[k] = -> { block.public_send(v) }
+            # child_block.class.provides[k] = -> { block.public_send(v) }
+          else
+            Node.provide(child_block.node, k, v)
+            # child_block.node.meta.provides[k] = v
+            # child_block.class.provides[k] = v
+          end
+        end
+
+        block.node.meta << child_block
+
+        yield child_block
+
+        block.public_send(:on_mounted) if block.respond_to?(:on_mounted)
+      end
+    end
+  end
+end

data/ui/src/hokusai/mounting/update_entry.rb

@@ -0,0 +1,101 @@
+module Hokusai
+  module Mounting
+    class UpdateEntry
+      attr_reader :block, :parent, :target
+
+      def initialize(block, parent, target)
+        @block = block
+        @parent = parent
+        @target = target
+      end
+
+      def meta
+        block.node.meta
+      end
+
+      def register(context: nil)
+        meta.on_update(target) do |ublock, uparent, utarget|
+          if portal = ublock.node.portal
+            portal.ast.children.each_with_index do |child, index|
+              next unless child.has_if_condition?
+
+              child_present = ->(child) do
+                meta.has_ast?(child, index)
+              end 
+
+              if child.if.args.size > 0
+                visible = utarget.public_send(child.if.method, context: context)
+              else
+                visible = utarget.public_send(child.if.method)
+              end
+              child_block_klass = target.class.use(child.type)
+
+              if !!visible
+                if child.else_condition_active?
+                  meta.child_delete(index) if child_present.call(child)
+                  child.else_active = 0
+                end
+
+                unless child_present.call(child)
+                  portal = Node.new(child, Node.new(child))
+                  node = child_block_klass.compile("root", portal)
+
+                  stack = []
+                  child.children.each_with_index do |ast, ast_index|
+                    stack << MountEntry.new(ast_index, ast, ublock, uparent, utarget)
+                  end
+
+                  child_block = NodeMounter.new(node, child_block_klass, [stack]).mount(context: context)
+                  UpdateEntry.new(child_block, block, target).register(context: context)
+
+                  child_block.node.add_styles(target.class)
+                  child_block.node.add_props_from_block(target, context: context)
+                  child_block.node.meta.publisher.add(target)
+
+                  meta.children!.insert(index, child_block)
+
+                  child_block.public_send(:before_updated) if child_block.respond_to?(:before_updated)
+                  child_block.update
+                  child.else_active = 0
+                end
+              elsif !visible
+                if !child.has_else_condition? || (child.has_else_condition? && !child.else_condition_active?)
+                  if (child_present.call(child))
+                    meta.child_delete(index)
+                  end
+                end
+
+                if child.has_else_condition? && !child.else_condition_active?
+                  portal = Node.new(child, Node.new(child))
+                  else_child_block_klass = target.class.use(child.else_ast.type)
+                  node = else_child_block_klass.compile(child.else_ast.type, portal)
+
+                  stack = []
+                  child.else_ast.children.each_with_index do |ast, ast_index|
+                    stack << MountEntry.new(ast_index, ast, ublock, uparent, utarget)
+                  end
+
+                  child_block = NodeMounter.new(node, else_child_block_klass, [stack]).mount(context: context)
+                  UpdateEntry.new(child_block, block, utarget).register(context: context)
+                  
+                  child_block.node.add_styles(utarget.class)
+                  child_block.node.add_props_from_block(utarget, context: context)
+                  child_block.node.meta.publisher.add(utarget)
+                  meta.children!.insert(index, child_block)
+
+                  child_block.public_send(:before_updated) if child_block.respond_to?(:before_updated)
+                  child_block.update
+                  child.else_active = 1
+                end
+              end
+            end
+          end
+
+          ublock.public_send(:before_updated) if ublock.respond_to?(:before_updated)
+          ublock.node.add_props_from_block(utarget, context: context)
+          ublock.public_send(:after_updated) if ublock.respond_to?(:after_updated)
+        end
+      end
+    end
+  end
+end

data/ui/src/hokusai/node.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "random/formatter"
+require "forwardable"
+require_relative "./node_mounter"
+require_relative "./meta"
+
+module Hokusai
+  class Node
+    extend Forwardable
+    attr_reader :ast, :node, :uuid, :meta, :portal
+
+    def_delegators :@ast, :slot?, :type, :event
+
+    def self.provides
+      @provides ||= {}
+    end
+
+    def self.provide(node, key, value)
+      provides[node.uuid] ||= {}
+      provides[node.uuid][key] = value
+    end
+
+    def self.parse(template, name = "root", parent = nil)
+      ast = Ast.parse(template, name)
+
+      new(ast, parent)
+    end
+
+    def initialize(ast, portal = nil)
+      @ast = ast
+      @portal = portal
+      @uuid = Random.hex(6).freeze
+      @meta = Meta.new
+    end
+
+    def mount(klass)
+      NodeMounter.new(self, klass).mount
+    end
+
+    def destroy
+      # meta.children?&.each do |child|
+      #   child.node.destroy
+      # end
+      #
+      # ast.destroy
+    end
+
+    def emit(name, **args)
+      if node = portal
+        if event = node.event(name)
+          meta.publisher.notify(event.value.name, **args)
+        else
+          raise Hokusai::Error.new("Invocation failed: @#{name} doesn't exist on #{node.type}")
+        end
+      end
+    end
+
+    def add_styles(klass)
+      return if portal.nil?
+
+      portal.ast.style_list.each do |style_name|
+        style = klass.styles_get[style_name]
+
+        raise Hokusai::Error.new("Style #{style_name} doesn't exist in the styles for this block #{klass} - #{klass.styles_get.keys}") if style.nil?
+
+        style.each do |key, value|
+          meta.set_prop(key.to_sym, value)
+        end
+      end
+    end
+
+    def add_props_from_block(parent, context: nil)
+      if local_portal = portal
+        if block = parent
+          local_portal.ast.props.each do |_, prop|
+            method = prop.value.method
+
+            case prop.computed?
+            when true
+              if prop.value.args.size > 0 && context
+                value = context.send_target(block, prop.value)
+              elsif context&.table&.[](method)
+                value = context.table[method]
+              else
+                value = block.public_send(method)
+              end
+            else
+              value = method
+            end
+
+            meta.set_prop(prop.name.to_sym, value)
+          end
+        end
+      end
+    end
+  end
+end

data/ui/src/hokusai/node_mounter.rb

@@ -0,0 +1,102 @@
+require_relative "./mounting/loop_entry.rb"
+require_relative "./mounting/mount_entry.rb"
+require_relative "./mounting/update_entry.rb"
+
+module Hokusai
+  class NodeMounter
+    attr_accessor :primary_stack, :secondary_stack
+    attr_reader :root
+
+    def initialize(node, klass, secondary_stack = [], previous_target = nil)
+      @root = klass.new(node: node)
+      @secondary_stack = secondary_stack
+      @primary_stack = []
+
+      node.ast.children.each_with_index do |child, index|
+        primary_stack << Mounting::MountEntry.new(index, child, root, root, previous_target || root)
+      end
+    end
+
+    def mount(context: nil)
+      while entry = primary_stack.shift
+        next if entry.virtual?
+
+        if entry.loop?
+          entries, secondary_entries = Mounting::LoopEntry.new(entry).register
+
+          self.primary_stack = entries + primary_stack
+          self.secondary_stack = secondary_entries + secondary_stack
+
+          next
+        end
+
+        if entry.ast.has_if_condition?
+          next unless entry.target.public_send(entry.ast.if.method)
+        end
+
+        if entry.slot?
+          while siblings = secondary_stack.shift
+            next if siblings.empty?
+
+            continue = false
+
+            while sibling_entry = siblings.pop
+              # if we encounter a nested slot, we will
+              # add the current siblings to the end of the next
+              # non-empty slot sibling group
+              # and continue processing slots
+              if sibling_entry.slot?
+                continue = true
+
+                secondary_stack.each_with_index do |previous_siblings, i|
+                  next if previous_siblings.empty?
+
+                  secondary_stack[i] = siblings +  previous_siblings
+                  siblings.clear
+
+                  break
+                end
+              else
+                primary_stack.unshift sibling_entry.with_block(entry.block)
+              end
+            end
+
+            next if continue
+            break
+          end
+
+          next
+        end
+
+        entry.mount(context: context) do |child_block|
+          # create a subentry to register event handling and prop passing
+          Mounting::UpdateEntry.new(child_block, entry.block, entry.target).register(context: context || entry.ctx)
+
+          # Populate the secondary stack with the portal children
+          # this stack will be used to populate any slots in the primary_stack
+          items = []
+
+          entry.ast.children.each_with_index do |child, child_index|
+            child.has_if_condition?
+            items << Mounting::MountEntry.new(child_index, child, child_block, entry.parent, entry.target, context: entry.ctx)
+          end
+
+          secondary_stack.unshift items
+
+          # populate the primary stack with the newly compiled
+          # ast from child_block
+          primary_items = []
+
+          child_block.node.ast.children.each_with_index do |child, child_index|
+            primary_items << Mounting::MountEntry.new(child_index, child, child_block, child_block, context: entry.ctx)
+          end
+
+          self.primary_stack = primary_items + primary_stack
+        end
+      end
+
+      root.public_send(:on_mounted) if root.respond_to?(:on_mounted)
+      root
+    end
+  end
+end