hokusai-zero 0.1.1

data/ui/src/hokusai/block.rb

@@ -0,0 +1,237 @@
+require_relative "./publisher"
+require "stringio"
+require "forwardable"
+
+module Hokusai
+  module Blocks; end
+  class Block
+    attr_reader :node
+    attr_reader :publisher
+    attr_reader :provides
+
+    def self.provide(name, value = nil, &block)
+      if block_given?
+        provides[name] = block
+      else
+        if value.is_a?(Symbol)
+          provides[name] = value
+        else
+          provides[name] = ->{value}
+        end
+      end
+    end
+
+    def self.provides
+      @provides ||= {}
+    end
+
+    # Sets the template for this block
+    #
+    # @param [String] template to set
+    def self.template(template)
+      @template = template
+      @uses ||= {}
+    end
+
+    def self.style(template)
+      case template
+      when String
+        @styles = Hokusai::Style.parse(template)
+      when Hokusai::Style
+        @styles = template
+      end
+    end
+
+    # Sets the template for this block
+    # Uses a file
+    #
+    # @param [String] the filename to use
+    def self.template_from_file(path)
+      @template = File.read(path)
+    end
+
+    # Fetches the template for this block
+    #
+    # @return [String] the template
+    def self.template_get
+      @template || (raise Hokusai::Error.new("Must define template for #{self}"))
+    end
+
+    def self.styles_get
+      @styles || {}
+    end
+
+    def self.uses(**args)
+      args.each do |key, value|
+        raise Hokusai::Error.new("#{key} value must be a Block, got #{value}") unless value.is_a?(Block.class)
+
+        @uses[key.to_s.downcase] = value
+      end
+    end
+
+    def self.use(type)
+      if block_klass = @uses[type]
+        block_klass
+      else
+        raise Hokusai::Error.new("Type #{type} is not used on #{self}")
+      end
+    end
+
+    def self.computed(name, **args)
+      define_method(name) do
+        prop = node.meta.get_prop(name.to_sym)#props[name.to_sym]
+
+        if prop.nil?
+          prop = args[:default]
+        end
+
+        if prop.nil?
+          return
+        end
+
+        case args[:convert]
+        when Proc
+          args[:convert].call(prop)
+        when NilClass
+          prop
+        else
+          if args[:convert].respond_to?(:convert)
+            args[:convert].convert(prop)
+          else
+            raise Hokusai::Error.new("Prop converter #{args[:convert]} requires a convert method `.convert(value) => #{args[:convert]}`")
+          end
+        end
+      end
+    end
+
+    def self.computed!(name)
+      define_method(name.to_sym) do
+        return node.meta.get_prop(name.to_sym) || (raise Hokusai::Error.new("Missing prop: #{name} on #{self.class}"))
+      end
+    end
+
+    def self.inject(name, aliased = name)
+      define_method(aliased) do
+        if provider = Node.provides[node.uuid]&.[](name)
+          provider.call
+        end
+      end
+    end
+
+    def self.inject!(name, aliased)
+      define_method(aliased) do
+        if provider = Node.provides[node.uuid]&.[](name)
+          return provider.call
+        end
+
+        raise Hokusai::Error.new("No provision for #{name}")
+      end
+    end
+
+    def self.compile(name = "root", parent_node = nil)
+      Node.parse(template_get, name, parent_node)
+    end
+
+    def self.mount(name = "root", parent_node = nil)
+      compile(name, parent_node).mount(self)
+    end
+
+    def initialize(**args)
+      raise Hokusai::Error.new("Must supply node argument to #{self.class}.new") unless args[:node]
+
+      @node = args[:node]
+    end
+
+    def children?
+      node.meta.children?
+    end
+
+    def children
+      node.meta.children!
+    end
+
+    def update
+      node.meta.children?&.each do |child|
+        child.before_updated if child.respond_to?(:before_updated)
+      end
+
+      node.meta.update(self)
+
+      node.meta.children?&.each do |child|
+        child.after_updated if child.respond_to?(:after_updated)
+      end
+    end
+
+    def emit(name, *args, **kwargs)
+      if portal = node.portal
+        if event = portal.event(name)
+          node.meta.publisher.notify(event.value.method, *args, **kwargs)
+        end
+      end
+    end
+
+    def draw(&block)
+      instance_eval(&block)
+      # node.meta.commands.each(&:draw)
+      # node.meta.commands.clear!
+    end
+
+    def method_missing(name, *args,**kwargs, &block)
+      if Hokusai::Meta.commands.respond_to?(name)
+        return Hokusai::Meta.commands.send(name, *args, **kwargs, &block)
+      end
+
+      super
+    end
+
+    def draw_with
+      yield Hokusai::Meta.commands
+
+      # node.meta.commands.each(&:draw)
+      # node.meta.commands.clear!
+    end
+
+    def render(canvas)
+      yield(canvas)
+    end
+
+    def on_resize(canvas); end
+
+    def dump(level = 1, show_props: false)
+      io = ""
+      io << "#{self.class}"
+      io << " if " if node.ast.has_if_condition?
+      io <<  "(#{node.type})"
+
+      if portal = node.portal
+        io << ".#{portal.ast.classes.join(".")}"
+      end
+
+      io << "\n"
+
+      if node.meta.props!.values.size > 0 && show_props
+        io << "#{" " * level * 2}{\n"
+        node.meta.props!.each do |key, value|
+          io << "#{" " * level * 3}#{key} = #{value}\n"
+        end
+
+        unless node.portal.nil?
+          node.portal.ast.events.each do |_, event|
+            io << "#{" " * level * 3}@#{event.name} = #{event.value.method} #{!!node.portal.ast.event(event.name)}\n"
+          end
+        end
+        io << "#{" " * level * 2}}\n"
+      end
+
+      if children.nil?
+        io << "#{" " * level * 2}(no children)\n"
+      else
+        child_dump = children?&.map {|child| child.dump(level + 1, show_props: show_props) }
+        io << "#{" " * level * 2}#{child_dump.join("#{" " * level * 2}") }\n"
+      end
+
+      io
+    end
+  end
+end
+

data/ui/src/hokusai/blocks/button.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+class Hokusai::Blocks::Button < Hokusai::Block
+  template <<~EOF
+    [template]
+      rect {
+        @click="emit_click"
+        @hover="set_hovered"
+        @mouseout="unset_hovered"
+        :color="background_color"
+        :height="button_height"
+        :width="button_width"
+        :rounding="rounding"
+        :outline="outline"
+        :outline_color="outline_color"
+      }
+        label {
+          :padding="padding"
+          :color="color"
+          @width_updated="update_width"
+          :content="content"
+          :size="size"
+        }
+  EOF
+
+  uses(label: Hokusai::Blocks::Label, rect: Hokusai::Blocks::Rect)
+
+  DEFAULT_BACKGROUND = [39, 95, 206]
+  DEFAULT_CLICKED_BACKGROUND = [24, 52, 109]
+  DEFAULT_HOVERED_BACKGROUND = [242, 52, 109]
+
+  computed :padding, default: [5.0, 15.0, 5.0, 15.0], convert: Hokusai::Padding
+  computed :size, default: 24
+  computed :rounding, default: 0.5
+  computed :content, default: ""
+  computed :outline, default: 0.0, convert: Hokusai::Outline
+  computed :outline_color, default: nil, convert: Hokusai::Color
+  computed :background, default: DEFAULT_BACKGROUND, convert: Hokusai::Color
+  computed :hovered_background, default: DEFAULT_HOVERED_BACKGROUND, convert: Hokusai::Color
+  computed :clicked_background, default: DEFAULT_CLICKED_BACKGROUND, convert: Hokusai::Color
+  computed :color, default: [215, 213, 226], convert: Hokusai::Color
+
+  attr_accessor :button_width
+
+  def emit_click(event)
+    @clicked = true
+
+    event.stop
+
+    emit("clicked", event)
+  end
+
+  def update_width(value)
+    self.button_width = value + (outline.right)
+  end
+
+  def set_hovered(event)
+    @hovered = true
+    @clicked = event.left.down
+
+    Hokusai.set_mouse_cursor(:pointer)
+  end
+
+  def unset_hovered(_)
+    @clicked = false
+
+    if @hovered
+      Hokusai.set_mouse_cursor(:default)
+    end
+
+    @hovered = false
+  end
+
+  def button_height
+    size + padding.top + padding.bottom
+  end
+
+  def after_updated
+    node.meta.props[:height] = button_height
+  end
+
+  def background_color
+    @hovered ? (@clicked ? clicked_background : hovered_background) : background
+  end
+
+  def render(canvas)
+    canvas.height = button_height
+    canvas.width = button_width
+
+    yield canvas
+  end
+
+  def initialize(**args)
+    @button_width = 0.0
+    @hovered = false
+    @clicked = false
+
+    super(**args)
+  end
+end

data/ui/src/hokusai/blocks/checkbox.rb

@@ -0,0 +1,51 @@
+class Hokusai::Blocks::Checkbox < Hokusai::Block
+  template <<~EOF
+    [template]
+      rect#checkbox {
+        @click="check"
+        :width="size"
+        :height="size"
+        :color="color"
+      }
+        [if="checked"]
+          circle { :radius="circle_size" :color="circle_color" }
+  EOF
+
+  uses(
+    rect: Hokusai::Blocks::Rect,
+    circle: Hokusai::Blocks::Circle,
+    empty: Hokusai::Blocks::Empty
+  )
+
+  DEFAULT_COLOR = [184,201,219]
+  DEFAULT_CIRCLE_COLOR = [44, 113, 183]
+
+  computed :color, default: DEFAULT_COLOR, convert: Hokusai::Color
+  computed :circle_color, default: DEFAULT_CIRCLE_COLOR, convert: Hokusai::Color
+  computed :size, default: 25.0
+
+  attr_accessor :checked
+
+  def circle_size
+    (size.to_f * 0.35)
+  end
+
+  def check(event)
+    self.checked = !checked
+
+    emit("check", checked)
+  end
+
+  def initialize(**args)
+    @checked = false
+
+    super(**args)
+  end
+
+  def render(canvas)
+    canvas.width = size.to_f
+    canvas.height = size.to_f
+
+    yield canvas
+  end
+end

data/ui/src/hokusai/blocks/circle.rb

@@ -0,0 +1,28 @@
+class Hokusai::Blocks::Circle < Hokusai::Block
+  template <<~EOF
+    [template]
+      virtual
+  EOF
+
+  computed :radius, default: 10.0, convert: proc(&:to_f)
+  computed :color, default: [255,255,255], convert: Hokusai::Color
+  computed :outline, default: nil
+  computed :outline_color, default: [0,0,0,0], convert: Hokusai::Color
+
+  def render(canvas)
+    x = canvas.x + (canvas.width / 2)
+    y = canvas.y + canvas.height / 2
+
+    draw do
+      circle(x, y, radius) do |command|
+        command.color = color
+        if outline
+          command.outline = outline
+          command.outline_color = outline_color
+        end
+      end
+    end
+
+    yield canvas
+  end
+end

data/ui/src/hokusai/blocks/clipped.rb

@@ -0,0 +1,23 @@
+class Hokusai::Blocks::Clipped < Hokusai::Block
+  style <<-EOF
+  [style]
+  scissorStyle {
+    height: 0.0;
+    width: 0.0;
+  }
+  EOF
+
+  template <<-EOF
+  [template]
+    scissorbegin { :offset="offset" }
+      slot
+      scissorend { ...scissorStyle }
+  EOF
+
+  uses(
+    scissorbegin: Hokusai::Blocks::ScissorBegin,
+    scissorend: Hokusai::Blocks::ScissorEnd,
+  )
+
+  computed :offset, default: 0.0
+end

data/ui/src/hokusai/blocks/cursor.rb

@@ -0,0 +1,49 @@
+class Hokusai::Blocks::Cursor < Hokusai::Block
+  template <<~EOF
+    [template]
+      virtual
+  EOF
+
+  DEFAULT_COLOR = [255,0,0,244]
+
+  computed :x, default: 0.0
+  computed :y, default: 0.0
+  computed :show, default: false
+  computed :speed, default: 0.1
+  computed :cursor_width, default: 2.0
+  computed :cursor_height, default: 0.0
+  computed :color, default: DEFAULT_COLOR, convert: Hokusai::Color
+
+  def initialize(**args)
+    @active = false
+    @iteration = 0
+
+    super(**args)
+  end
+
+  def before_updated
+    frames = speed * 30
+
+    @active = @iteration < frames
+
+    if @iteration >= 30
+      @iteration = 0
+    else
+      @iteration += 1
+    end
+  end
+
+  def render(canvas)
+    if show
+      draw do
+        if @active
+          rect(x, y, cursor_width, cursor_height) do |command|
+            command.color = color
+          end
+        end
+      end
+    end
+
+    yield canvas
+  end
+end

data/ui/src/hokusai/blocks/dynamic.rb

@@ -0,0 +1,37 @@
+class Hokusai::Blocks::Dynamic < Hokusai::Block
+  template <<~EOF
+    [template]
+      slot
+  EOF
+
+  computed :reverse, default: false
+
+  def before_updated
+    width, height = compute_size
+
+    emit("size_updated", width, height)
+  end
+
+  def on_mounted
+    compute_size
+  end
+
+  def compute_size
+    h = 0.0
+    w = 0.0
+
+    children.each do |block|
+      h += block.node.meta.get_prop?(:height)&.to_f || 0.0
+      w += block.node.meta.get_prop?(:width)&.to_f || 0.0
+    end
+
+    [w, h]
+  end
+
+  def render(canvas)
+    canvas.vertical = true
+    canvas.reverse = (reverse == true || reverse == "true")
+
+    yield canvas
+  end
+end

data/ui/src/hokusai/blocks/empty.rb

@@ -0,0 +1,10 @@
+class Hokusai::Blocks::Empty < Hokusai::Block
+  template <<~EOF
+    [template]
+      virtual
+  EOF
+
+  def render(canvas)
+    yield canvas
+  end
+end

data/ui/src/hokusai/blocks/hblock.rb

@@ -0,0 +1,35 @@
+class Hokusai::Blocks::Hblock < Hokusai::Block
+  template <<~EOF
+    [template]
+      slot
+  EOF
+
+  computed :padding, default: 0, convert: Hokusai::Padding
+  computed :background, default: nil, convert: Hokusai::Color
+  computed :rounding, default: 0.0
+  computed :outline, default: Hokusai::Outline.default, convert: Hokusai::Outline
+  computed :outline_color, default: nil, convert: Hokusai::Color
+  computed :reverse, default: false
+
+  def render(canvas)
+    canvas.vertical = false
+    canvas.reverse = reverse
+
+    if background.nil?
+      yield canvas
+    else
+      draw do
+        rect(canvas.x, canvas.y, canvas.width, canvas.height) do |command|
+          command.color = background
+          command.outline = outline if outline
+          command.outline_color = outline_color if outline_color
+          command.round = rounding.to_f if rounding
+          command.padding = padding
+          canvas = command.trim_canvas(canvas)
+        end
+      end
+
+      yield canvas
+    end
+  end
+end

data/ui/src/hokusai/blocks/image.rb

@@ -0,0 +1,18 @@
+class Hokusai::Blocks::Image < Hokusai::Block
+  template <<~EOF
+    [template]
+      virtual
+  EOF
+
+  computed! :source
+  computed :width, default: nil
+  computed :height, default: nil
+
+  def render(canvas)
+    draw do
+      image(source, canvas.x, canvas.y, width&.to_f || canvas.width, height&.to_f || canvas.height)
+    end
+
+    yield canvas
+  end
+end