hokusai-zero 0.1.1

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

@@ -0,0 +1,42 @@
+describe Hokusai::Meta do
+  let(:app) do
+    Class.new(Hokusai::Block) do
+      template <<~EOF
+      [template]
+        hblock#focus
+          empty#first
+          empty#second
+        hblock#unfocus
+          empty#third
+          empty#fourth
+      EOF
+
+      uses(
+        hblock: Hokusai::Blocks::Hblock,
+        empty: Hokusai::Blocks::Empty
+      )
+    end    
+  end
+
+  describe "focusing" do
+    it "#focus focuses this block and all of it's children" do
+      with_app(app) do |client, app|
+        child_to_focus = app.children.first
+        child_to_focus.node.meta.focus
+
+        expect(child_to_focus.node.meta.focused).to be(true)
+
+        child_to_focus.children.each do |child|
+          expect(child.node.meta.focused).to be(true)
+        end
+
+        child_unfocused = app.children.last
+        expect(child_unfocused.node.meta.focused).to be(false)
+        
+        child_unfocused.children.each do |child|
+          expect(child.node.meta.focused).to be(false)
+        end
+      end
+    end
+  end
+end

data/ui/spec/hokusai/publisher_spec.rb

@@ -0,0 +1,38 @@
+require_relative "../spec_helper"
+
+describe Hokusai::Publisher do
+  let!(:mock) do
+    ->(&block) do
+      klass = Class.new do
+        attr_reader :state, :publisher
+        def initialize
+          @state = []
+          @publisher = Hokusai::Publisher.new
+        end
+
+        def target(name)
+          @state << name
+        end
+      end
+
+      block.call klass.new
+    end
+  end
+
+  it "publishes events from a child node to it's parent" do
+    mock.call do |parent|
+      mock.call do |child|
+        child.publisher.add(parent)
+        child.publisher.notify(:target, "one")
+        child.publisher.notify(:target, "two")
+      end
+
+      mock.call do |child|
+        child.publisher.add(parent)
+        child.publisher.notify(:target, "three")
+      end
+
+      expect(parent.state).to eq(["one", "two", "three"])
+    end
+  end
+end

data/ui/spec/hokusai/slots_spec.rb

@@ -0,0 +1,150 @@
+require_relative "../spec_helper"
+
+describe "Slots" do
+
+  let(:virtual) do
+    klass = Class.new(Hokusai::Block) do
+      template <<~EOF
+      [template]
+        virtual
+      EOF
+    end
+
+    klass
+  end
+
+  describe "Basic" do
+
+    let(:slotted) do
+      virtual_klass = virtual
+
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          sibling1
+          slot
+          sibling2
+        EOF
+  
+        uses(sibling1: virtual_klass, sibling2: virtual_klass)
+      end
+  
+      klass
+    end
+  
+    let(:root_klass) do
+      slotted_klass = slotted
+      virtual_klass = virtual
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          slotted
+            between { :prop="id" @event="root_event" }
+        EOF
+  
+        uses(slotted: slotted_klass, between: virtual_klass)
+    
+        attr_accessor :id
+    
+        def root_event(value)
+          self.id += value
+        end
+    
+        def initialize(**args)
+          @id = 3
+    
+          super
+        end
+      end
+
+      klass
+    end
+
+    it "mounts portaled children inside slot" do
+      root = root_klass.mount
+      expect(root.children.size).to eq(1)
+
+      child = root.children.first
+      expect(child.node.type).to eq('slotted') 
+
+      sibling_types = child.children.map {|c| c.node.type }
+
+      expect(sibling_types).to eq(["sibling1", "between", "sibling2"])
+    end
+
+    it "slotted blocks have access to their parent data and events" do
+      root = root_klass.mount
+      between = root.children.first.children[1]
+      expect(between.node.meta.props[:prop]).to eq(3)
+      between.emit("event", 2)
+      expect(root.id).to eq(5)
+    end
+  end
+
+  describe "Nested" do
+    let(:slot) do
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          slot
+        EOF
+      end
+
+      klass
+    end
+
+    let(:nested) do
+      slot_klass = slot
+      virtual_klass = virtual
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          empty
+            slot
+            virtual
+        EOF
+
+        uses(empty: slot_klass, virtual: virtual_klass)
+      end
+
+      klass
+    end
+
+    let(:root_klass) do
+      nested_klass = nested
+      virtual_klass = virtual
+      klass = Class.new(Hokusai::Block) do
+        template <<~EOF
+        [template]
+          first { prop="first"}
+          nested
+            second { prop="second" }
+          third { prop="third" }
+        EOF
+
+        uses(first: virtual_klass, nested: nested_klass, second: virtual_klass, third: virtual_klass)
+      end
+
+      klass
+    end
+
+    it "slots can be nested" do
+      root = root_klass.mount
+
+      expect(root.children.size).to eq(3)
+      empty = root.children[1].children.first
+
+      expect(empty.node.type).to eq("empty")
+      
+      second = empty.children.first
+      expect(second.node.type).to eq("second")
+
+      expect(second.node.meta.props[:prop]).to eq("second")
+      
+      children = root.children
+      expect(children.first.node.meta.props[:prop]).to eq("first")
+
+      expect(children.last.node.meta.props[:prop]).to eq("third")
+    end
+  end
+end

data/ui/spec/hokusai/util/piece_table_spec.rb

@@ -0,0 +1,90 @@
+describe Hokusai::Util::PieceTable do
+  def with_piece_table(initial = "")
+    table = Hokusai::Util::PieceTable.new(initial)
+
+    yield table
+  end
+
+  describe "with no initial buffer" do
+    it "inserts correctly" do
+      with_piece_table do |table|
+        table.insert("hello", 0)
+        table.insert(" ", 5)
+        table.insert("world", 6)
+        expect(table.to_s).to eq("hello world")
+      end
+    end
+  end
+
+  describe "with buffer" do
+    it "#insert at the start of a string" do
+      with_piece_table("hello world") do |table|
+        table.insert("ok ", 0)
+        expect(table.to_s).to eq("ok hello world")
+      end
+    end
+
+    it "#insert in the middle of a string" do
+      with_piece_table("hello world") do |table|
+        table.insert("big ", 6)
+        expect(table.to_s).to eq("hello big world")
+      end
+    end
+
+    it "#insert at the end of a string" do
+      with_piece_table("hello world") do |table|
+        table.insert(" ok?", 11)
+        expect(table.to_s).to eq("hello world ok?")
+      end
+    end
+
+    it "double insert" do
+      with_piece_table("hello world") do |table|
+        table.insert(" big", 5)
+        table.insert(" again", 5)
+        expect(table.to_s).to eq("hello again big world")
+      end
+    end
+
+    it "delete at the start of a string" do
+      with_piece_table("hello world") do |table|
+        table.delete(0, 6)
+        expect(table.to_s).to eq("world")
+      end
+    end
+
+    it "delete at the end of a string" do
+      with_piece_table("hello world") do |table|
+        table.delete(5, 6)
+        expect(table.to_s).to eq("hello")
+      end
+    end
+
+    it "delete in the middle of a string" do
+      with_piece_table("hello world") do |table|
+        table.delete(5, 1)
+        expect(table.to_s).to eq("helloworld")
+      end
+    end
+  end
+
+  describe "error cases" do
+    it "#insert wrong initial offset" do
+      with_piece_table("hello world") do |table|
+        expect { table.insert("boo", 20) }.to raise_error(Hokusai::Error)
+      end
+    end
+
+    it "#delete wrong offset" do
+      with_piece_table("hello world") do |table|
+        expect { table.delete(20, 1) }.to raise_error(Hokusai::Error)
+      end
+    end
+
+    it "#delete wrong size" do
+      with_piece_table("hello world") do |table|
+        expect { table.delete(5, 20) }.to raise_error(Hokusai::Error)
+      end
+    end
+  end
+end

data/ui/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require_relative "../src/hokusai"
+require_relative "../src/hokusai/backends/raylib"
+require_relative "../src/hokusai/automation"
+require "thread"
+
+def with_app(app, &block)
+  driver = Hokusai::Automation::Driver.new
+
+  backend = Hokusai::Backends::RaylibBackend.new do |config|
+    config.automate("localhost", 3000)
+    config.automation_driver = driver
+
+    config.width = 500
+    config.height = 500
+    config.title = "Test application"
+  end
+
+  block = app.mount
+
+  Hokusai::ThreadPool.post do
+    backend.run(block)
+  end
+
+  client = Hokusai::Automation::Client.start
+  yield client, block
+
+  backend.class.stop!
+
+  client.wait_until_stopped
+end