hokusai-zero 0.1.1

data/ui/spec/hokusai/ast_spec.rb

@@ -0,0 +1,88 @@
+require_relative "../spec_helper"
+
+describe Hokusai::Ast do
+  let(:template) do
+    <<~EOF
+      [template]
+        first#id.class1.class2 { prop1="one" prop2="two" prop3="three" @event1="first" @event2="second" }
+    EOF
+  end
+
+  let(:parent) { Hokusai::Ast.parse(template, "root") }
+  let(:ast) { parent.children.first }
+
+  it ".parse returns a new ast from a template" do
+    expect(parent).to be_instance_of(Hokusai::Ast), "#{ast.class} not #{Hokusai::Ast}"
+  end
+
+  it "#type returns the ast type" do
+    expect(ast.type).to eq("first")
+  end
+
+  it "#id returns the ast id" do
+    expect(ast.id).to eq("id")
+  end
+
+  it "#each_event iterates events" do
+    count = 0
+    ast.each_event do |_|
+      count += 1
+    end
+
+    expect(count).to eq(2)
+  end
+
+  it "#each_prop iterates props" do
+    count = 0
+    ast.each_prop do |_|
+      count += 1
+    end
+
+    expect(count).to eq(3)
+  end
+
+  describe "#prop" do
+    let(:template) do
+      <<~EOF
+        [template]
+          first { :computed="true" }
+          second { notcomputed="true" }
+      EOF
+    end
+
+    it "returns nil if a prop is not found" do
+      expect(ast.prop("nope")).to be(nil)
+    end
+
+    it "returns a Hokusai::Ast::Prop" do
+      prop1 = parent.children[0].prop("computed")
+      prop2 = parent.children[1].prop("notcomputed")
+
+      expect(prop1).to be_a(Hokusai::Ast::Prop)
+      expect(prop1.value.method).to eq("true")
+      expect(prop1.computed?).to be(true)
+
+      expect(prop2.computed?).to be(false)
+    end
+  end
+
+  describe "#event" do
+    let(:template) do
+      <<~EOF
+        [template]
+          first { @click="handle_click", @hover="handle_hover" }
+      EOF
+    end
+
+    it "returns nil if an event isn't found" do
+      expect(ast.event("none")).to be(nil)
+    end
+
+    it "returns a Hokusai::Ast::Event" do
+      event = ast.event("hover")
+      expect(event).to be_a(Hokusai::Ast::Event)
+      expect(event.name).to eq("hover")
+      expect(event.value.method).to eq("handle_hover")
+    end
+  end
+end

data/ui/spec/hokusai/automation/keys_transcoder_spec.rb

@@ -0,0 +1,50 @@
+describe Hokusai::Automation::KeysTranscoder do
+  def with_encoded(*keys)
+    encoded = Hokusai::Automation::KeysTranscoder.encode(keys.to_a)
+    yield encoded
+  end
+
+  def decode(encoded)
+    Hokusai::Automation::KeysTranscoder.decode(encoded)
+  end
+  
+  it "decodes a simple string" do
+    with_encoded("h", "e", "l", "l", "o") do |encoded|
+      expect(decode(encoded)).to eq(%w[h e l l o])
+    end
+  end
+
+  it "decodes a string with modifiers" do
+    with_encoded([:shift, 'h'], 'e','l','l','o') do |encoded|
+      decode(encoded).should eq([[:lshift, 'h'], 'e','l','l','o'])
+    end
+  end
+
+  it "decodes multiple modifiers" do
+    with_encoded([:shift, 'h'], [:ctrl, 'e','l','l','o']) do |encoded|
+      decode(encoded).should eq([[:lshift, 'h'], [:lctrl, 'e','l','l','o']])
+    end
+  end
+
+  it "encodes a simple string" do
+    with_encoded('h','e','l','l','o') do |encoded|
+      encoded.should eq("hello")
+    end
+  end
+
+  it "encodeds a modifier key" do
+    with_encoded(:tab) do |encoded|
+      encoded.should eq("\ue004")
+    end
+  end
+
+  it "encodes mmultiple modifiers" do
+    with_encoded([:shift, 'h'], [:ctrl, 'e','l','l','o']) do |encoded|
+      encoded.should eq("\ue008h\ue000\ue009ello\ue000")
+    end
+  end
+
+  it "raises when a modifier cannot be found" do
+    expect { with_encoded('h','e','l','l','o', :foobar) {} }.to raise_error(Hokusai::Automation::Error)
+  end
+end

data/ui/spec/hokusai/automation/selector_spec.rb

@@ -0,0 +1,68 @@
+describe Hokusai::Automation::Selector do
+  let(:selector_child_klass) do
+    Class.new(Hokusai::Block) do
+      template <<~EOF
+      [template]
+        virtual
+      EOF
+    end
+  end
+
+  let(:app) do
+    child = selector_child_klass
+
+    Class.new(Hokusai::Block) do
+      template <<~EOF
+      [template]
+        child#id.class1.class2
+        child2.class1
+      EOF
+
+      uses(child: child, child2: child)
+    end
+  end
+
+  let(:fixture) { app.mount }
+  let(:child1) { fixture.children[0] }
+  let(:child2) { fixture.children[1] }
+
+  let(:with_selector) do
+    ->(node: nil, id: nil, classes: nil, &block) do
+      block.call Hokusai::Automation::Selector.new(node, id, classes)
+    end
+  end
+
+  it "#match returns true if a selector matches a block" do
+    with_selector.call(id: "id") do |selector|
+      expect(selector.matches(child1)).to be(true)
+    end
+
+    with_selector.call(node: "child") do |selector|
+      expect(selector.matches(child1)).to be(true)
+    end
+
+    with_selector.call(classes: %w[class1 class2]) do |selector|
+      expect(selector.matches(child1)).to be(true)
+    end
+
+    with_selector.call(node: "child", id: "id", classes: %w[class1 class2]) do |selector|
+      expect(selector.matches(child1)).to be(true)
+    end
+
+    with_selector.call(node: "child2", id: nil, classes: %w[class1]) do |selector|
+      expect(selector.matches(child2)).to be(true)
+    end
+  end
+
+  it "#match returns false if a selector doesn't match a block" do
+    with_selector.call(id: "foobar") do |selector|
+      expect(selector.matches(child1)).to be(false)
+    end
+  end
+
+  it "#match returns false if any part of the selector doesn't match a block" do
+    with_selector.call(id: "id", node: "child", classes: %w[class1 class3]) do |selector|
+      expect(selector.matches(child1)).to be(false)
+    end
+  end
+end

data/ui/spec/hokusai/block_spec.rb

@@ -0,0 +1,126 @@
+require_relative "../spec_helper"
+
+describe Hokusai::Block do
+  let(:child_klass) do
+    Class.new(Hokusai::Block) do
+      template <<~EOF
+        [template]
+          virtual
+      EOF
+      computed! :echo
+
+      def self.foobar
+        nil
+      end
+
+      def hello
+        @state += 1
+
+        emit("get", @state)
+      end
+
+      def initialize(**args)
+        @state = 0
+
+        super(**args)
+      end
+    end
+  end
+
+  let(:parent) do
+    child_block = child_klass
+    klass = Class.new(Hokusai::Block) do
+      template <<~EOF
+        [template]
+          child { :echo="total" @get="get_it" }
+      EOF
+
+      attr_reader :state, :total, :mounted
+
+      uses(child: child_block)
+
+      def get_it(count)
+        @state += count
+        @total = "total: #{state}"
+      end
+
+      def on_mounted
+        @mounted = true
+      end
+
+      def initialize(**args)
+        @state = 0
+        @total = "total: #{state}"
+        @mounted = false
+
+        super(**args)
+      end
+    end
+
+    klass.mount
+  end
+
+  let(:child) do
+    parent.children.first
+  end
+
+  describe ".mount" do
+    it "mounts blocks together" do
+      expect(parent.children.size).to eq(1)
+      expect(child).to respond_to(:hello)
+    end
+
+    it "blocks have a node and portal node" do
+      expect(parent.node.type).to eq("root")
+      expect(child.node.portal.type).to eq("child")
+    end
+
+    it "mounts props into children" do
+      expect(child.echo).to eq("total: 0")
+    end
+  end
+
+  describe "#emit" do
+    it "emits events to the parent" do
+      child.emit("get", 1)
+
+      expect(parent.state).to eq(1)
+    end
+
+    it "raises when an emit is missing a param" do
+      expect { child.emit("get") }.to raise_error(ArgumentError)
+    end
+
+    it "does not raise when an emit is not subscribe to" do
+      expect { child.emit("foobarrr", 1,23) }.not_to raise_error
+    end
+  end
+
+  describe "#update" do
+    it "updates child props with new state" do
+      child.emit("get", 1)
+      expect(child.echo).to eq("total: 0")
+
+      parent.update
+      expect(child.echo).to eq("total: 1")
+    end
+  end
+
+  describe ".using" do
+    it "returns a Hokusai::Block by a key" do
+      expect(parent.class.use("child")).to respond_to(:foobar)
+    end
+
+    it "raise if the key isn't found" do
+      expect { parent.class.use("whaaa") }.to raise_error(Hokusai::Error) do |err|
+        expect(err.message).to match(/Type whaaa is not used/)
+      end
+    end
+  end
+
+  describe "#on_mounted" do
+    it "triggers when the block is mounted" do
+      expect(parent.mounted).to be(true)
+    end
+  end
+end

data/ui/spec/hokusai/directives_spec.rb

@@ -0,0 +1,327 @@
+require_relative "../spec_helper"
+
+describe "Block directives" do
+  let(:virtual) do
+    klass = Class.new(Hokusai::Block) do
+      template <<~EOF
+      [template]
+        virtual
+      EOF
+    end
+
+    klass
+  end
+
+  let(:slotted) do
+    klass = Class.new(Hokusai::Block) do
+      template <<~EOF
+      [template]
+        slot
+      EOF
+    end
+
+    klass
+  end
+
+  describe "if directive" do
+    let(:condition1) do
+      virtual_klass = virtual
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          type { content="1" }
+          slot
+        EOF
+
+        uses(type: virtual_klass)
+      end
+
+      klass
+    end
+
+    let(:condition2) do
+      virtual_klass = virtual
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          type { content="2" }
+          slot
+        EOF
+
+        uses(type: virtual_klass)
+      end
+
+      klass
+    end
+
+    let(:branch) do
+      virtual_klass = virtual
+      cond1 = condition1
+      cond2 = condition2
+      slot = slotted
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          slotted
+            [if="state"]
+              cond1
+                control1
+            [else]
+              cond2
+                control2
+            control
+        EOF
+
+        uses(
+          slotted: slot,
+          cond1: cond1,
+          cond2: cond2,
+          control: virtual_klass,
+          control1: virtual_klass,
+          control2: virtual_klass
+        )
+
+        attr_accessor :state
+
+        def initialize(**props)
+          @state = true
+
+          super
+        end
+      end
+    end
+
+    let (:content) do
+      ->(root) do
+        root
+          .children[0]
+          .children[0]
+          .children[0]
+          .node
+          .meta
+          .get_prop(:content)
+      end
+    end
+
+    let (:portal_type) do
+      ->(root) do
+        root
+          .children[0]
+          .children[0]
+          .children[1]
+          .node
+          .type
+      end
+    end
+
+    it "simple condition" do
+      root = branch.mount
+      expect(content.call(root)).to eq("1")
+      
+      root.state = false
+      root.update
+      expect(content.call(root)).to eq("2")
+    end
+
+    it "switches back and forth" do
+      root = branch.mount
+
+      expect(content.call(root)).to eq("1")
+      expect(root.children[0].children[-1].node.type).to eq("control")
+
+      root.state = false
+      root.update
+
+      expect(content.call(root)).to eq("2")
+      expect(root.children[0].children[-1].node.type).to eq("control")
+
+      root.state = true
+      root.update
+
+      expect(content.call(root)).to eq("1")
+      expect(root.children[0].children[-1].node.type).to eq("control")
+    end
+
+    it "mounts portaled children into the slot" do
+      root = branch.mount
+
+      expect(portal_type.call(root)).to eq("control1")
+
+      root.state = false
+      root.update
+
+      expect(portal_type.call(root)).to eq("control2")
+    end
+  end
+
+  describe "loop directives" do
+    let(:cell) do
+      virtual_klass = virtual
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          empty { :content="value" }
+        EOF
+
+        computed! :value
+        
+        uses(empty: virtual_klass)
+      end
+
+      klass
+    end
+
+    let(:column) do
+      cell_klass = cell
+      slotted_klass = slotted
+
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          slotted
+            [for="value in columns"]
+              cell { :value="value" }
+        EOF
+        computed! :row_index
+
+        uses(cell: cell_klass, slotted: slotted_klass)
+
+        def columns
+          %w[A B C D].map { |letter| "#{letter}#{row_index}" }
+        end
+      end
+
+      klass
+    end
+
+    let(:csv) do
+      column_klass = column
+      slotted_klass = slotted
+
+
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          slotted
+            [for="row in rows"]
+              column { :row_index="row" }          
+        EOF
+
+        uses(slotted: slotted_klass, column: column_klass)
+
+        def rows
+          %w[1 2 3 4]
+        end
+      end
+
+      klass
+    end
+
+    let(:list_item) do
+      virtual_klass = virtual
+
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          empty
+        EOF
+
+        attr_accessor :state
+
+        uses(empty: virtual_klass)
+
+        computed! :item
+
+        def initialize(**args)
+          @state = "hello"
+
+          super
+        end
+      end
+
+      klass
+    end
+
+    let(:list) do
+      list_item_klass = list_item
+      slotted_klass = slotted
+
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          slotted
+            [for="item in list"]
+              list_item { :item="item" :key="key(item, index)" }
+        EOF
+
+        attr_accessor :limit
+
+        uses(slotted: slotted_klass, list_item: list_item_klass)
+
+        def list
+          (0...limit).to_a
+        end
+
+        def key(item, index)
+          "#{item}-#{index}"
+        end
+
+        def initialize(**args)
+          @limit = 5
+
+          super
+        end
+      end
+
+      klass
+    end
+
+    it "mounts nested loops" do
+      root = csv.mount
+      
+      rows = %w[1 2 3 4]
+      cols = %w[A B C D]
+
+      rows.each_with_index do |row, ridx|
+        actual_rows = root.children[0].children
+        expect(actual_rows.size).to eq(4)
+
+        actual_row = actual_rows[ridx]
+        expect(actual_row.row_index).to eq(row)
+
+        actual_columns = actual_row.children[0].children
+        expect(actual_columns.size).to eq(4)
+
+        cols.each_with_index do |col, cidx|
+          expect(actual_columns[cidx].value).to eq("#{col}#{row}")
+        end
+      end
+    end
+
+    it "diffs so that unchanged blocks are not remounted" do
+      root = list.mount
+      children = root.children[0].children
+      expect(children.size).to eq(5)
+
+      children[0].state = "1"
+      children[1].state = "2"
+      children[2].state = "3"
+      children[3].state = "4"
+      children[4].state = "5"
+
+      root.limit = 2
+      root.update
+      expect(root.children[0].children.size).to eq(2)
+
+
+      root.limit = 3
+      root.update
+      expect(root.children[0].children.size).to eq(3)
+
+      updated_children = root.children[0].children
+      expect(updated_children[0].state).to eq("1")
+      expect(updated_children[1].state).to eq("2")
+      expect(updated_children[2].state).to eq("hello")
+    end
+  end
+end

data/ui/spec/hokusai/e2e/client_spec.rb

@@ -0,0 +1,58 @@
+describe Hokusai::Automation::Client do
+  let(:counter) do
+    klass = Class.new(Hokusai::Block) do
+      template <<~EOF
+      [template]
+        vblock
+          label#count { :content="count" size="90" }
+        hblock.counter
+          label#inc { @click="increment" content="Increment" }
+          label#dec { @click="decrement" content="Decrement" }
+      EOF
+
+      uses(
+        vblock: Hokusai::Blocks::Vblock,
+        hblock: Hokusai::Blocks::Hblock,
+        label: Hokusai::Blocks::Label
+      )
+
+      attr_accessor :count
+
+      def increment(_event)
+        self.count += 1
+      end
+
+      def decrement(_event)
+        self.count -= 1
+      end
+
+      def initialize(**args)
+        @count = 0
+
+        super(**args)
+      end
+    end
+
+    klass
+  end
+  
+  it "client works" do
+    with_app(counter) do |client, app|
+      output = client.block("#count")
+
+      expect(output.prop("content")).to eq(0)
+
+      client.block(".counter #inc") do |increment|
+        3.times { increment.click }
+      end
+
+      expect(output.prop("content")).to eq(3)
+
+      client.block("#dec") do |decrement|
+        2.times { decrement.click }
+      end
+
+      expect(output.prop("content")).to eq(1)
+    end
+  end
+end