hokusai-zero 0.1.1

data/ui/src/hokusai/automation/keys_transcoder.rb

@@ -0,0 +1,128 @@
+module Hokusai::Automation
+  module KeysTranscoder
+    KEYS = {
+      shift: "\ue008",
+      ctrl: "\ue009",
+      alt: "\ue00A",
+      super: "\ue03D",
+      lshift: "\ue008",
+      lctrl: "\ue009",
+      lalt: "\ue00A",
+      lsuper: "\ue03D",
+      rshift: "\ue050",
+      rctrl: "\ue051",
+      ralt: "\ue052",
+      rsuper: "\ue053",
+      enter: "\ue007",
+      tab: "\ue004",
+      backspace: "\ue003",
+      insert: "\ue016",
+      delete: "\ue017",
+      up: "\ue013",
+      right: "\ue014",
+      down: "\ue015",
+      left: "\ue012",
+      page_up: "\ue00E",
+      page_down: "\ue00F",
+      end: "\ue010",
+      home: "\ue011",
+      pause: "\ue00B",
+      escape: "\ue00C",
+      null: "\ue000",
+      cancel: "\ue001",
+      f1: "\ue031",
+      f2: "\ue032",
+      f3: "\ue033",
+      f4: "\ue034",
+      f5: "\ue035",
+      f6: "\ue036",
+      f7: "\ue037",
+      f8: "\ue038",
+      f9: "\ue039",
+      f10: "\ue03A",
+      f11: "\ue03B",
+      f12: "\ue03C",
+      kp0: "\ue01A",
+      kp1: "\ue01B",
+      kp2: "\ue01C",
+      kp3: "\ue01D",
+      kp4: "\ue01E",
+      kp5: "\ue01F",
+      kp6: "\ue020",
+      kp7: "\ue021",
+      kp8: "\ue022",
+      kp9: "\ue023",
+      multiply: "\ue024",
+      add: "\ue025",
+      separator: "\ue026",
+      subtract: "\ue027",
+      decimal: "\ue028",
+      divide: "\ue029",
+      equal: "\ue019",
+      caps_lock: "\ue054",
+      scroll_lock: "\ue055",
+      num_lock: "\ue056",
+      print_screen: "\ue057",
+      kb_menu: "\ue058",
+      back: "\ue059",
+      menu: "\ue05A",
+      volume_up: "\ue05B",
+      volume_down: "\ue05C",
+    }
+
+    REVERSE_KEYS = KEYS.invert
+
+    def self.[](key)
+      return KEYS[key] if KEYS[key]
+
+      raise Hokusai::Automation::Error.new("Unsupported key: #{key}")
+    end
+
+    def self.decode(str)
+      parts = str.split("")
+      keys = []
+      prog = []
+
+      while part = parts.shift
+
+        if key = REVERSE_KEYS[part]
+          if key == :null
+            keys << prog
+            prog = []
+          else
+            prog << key
+          end
+        else
+          prog << part.to_s
+        end
+      end
+
+      keys.concat prog
+      keys
+    end
+
+    def self.encode(keys)
+      keys.map { |key| encode_key(key) }.join("")
+    end
+
+    def self.encode_key(key)
+      case key
+      when Symbol
+        self[key]
+      when Array
+        key = key.map do |e|
+          if e.is_a?(Symbol)
+            self[e]
+          else
+            e
+          end
+        end
+
+        key << self[:null]
+        key.join("")
+      else
+        key.to_s
+      end
+    end
+  end
+end

data/ui/src/hokusai/automation/selector.rb

@@ -0,0 +1,39 @@
+module Hokusai::Automation
+  class Selector
+    attr_reader :node, :id, :class_list
+
+    def initialize(node, id, classes)
+      @node = node
+      @id = id
+      @class_list = classes || []
+    end
+
+    def matches(block)
+      if portal = block.node.portal
+        ast = portal.ast
+
+        matches = [[ast.type, node], [ast.id, id]].reduce(true) do |memo, (ast_property, target)|
+          next memo if target.nil?
+
+          target == ast_property && memo
+        end
+
+        return (class_list & ast.classes) == class_list && matches
+      end
+
+      false
+    end
+
+    def to_s(str = "")
+      classes_string = nil
+
+      unless class_list.empty?
+        classes_string = ".#{class_list.join(".")}"
+
+        str << "#{node || ""}##{id || ""}#{classes_string || ""}"
+      end
+
+      str
+    end
+  end
+end

data/ui/src/hokusai/automation/server.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "rack"
+require "thin"
+require "ostruct"
+require_relative "./driver"
+require_relative "./constants"
+
+module Hokusai
+  module Automation
+    class App
+      attr_reader :driver
+
+      def self.queue
+        @queue ||= {}
+      end
+
+      def initialize(driver)
+        @driver = driver
+      end
+
+      ROUTES = [
+        ["/commands/locate", DriverCommands::Locate],
+        ["/commands/invoke", DriverCommands::Invoke],
+        ["/commands/attribute", DriverCommands::GetAttribute],
+        ["/commands/click", DriverCommands::TriggerMouseClick],
+        ["/commands/drag", DriverCommands::TriggerMouseDrag],
+        ["/commands/hover", DriverCommands::TriggerMouseHover],
+        ["/commands/mousemove", DriverCommands::TriggerMouseMove],
+        ["/commands/mousewheel", DriverCommands::TriggerMouseWheel],
+        ["/commands/keyboard", DriverCommands::TriggerKeyboard]
+      ].to_h
+
+      def call(env)
+        request = Rack::Request.new(env)
+
+        unless request.post?
+          return respond(404, "Not Found", {})
+        end
+
+        return respond(200, "") if request.path == "/ready"
+
+        if command_klass = ROUTES[request.path]
+          json = JSON.parse(request.body.string, symbolize_names: true)
+          command = command_klass.new(json)
+          driver.execute(command)
+
+          Log.debug { "Pushed #{command.class} command #{driver.queue.commands}" }
+
+          poll(command.request_id)
+        else
+          respond(403, "Bad Request", {})
+        end
+      end
+
+      def poll(request_id)
+        poll_timeout = 2
+        poll_interval = 0.02
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        while (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) < poll_timeout
+          begin
+            if payload = driver.results[request_id]
+              driver.results.delete(request_id)
+
+              _, value = payload
+
+              Log.debug { "request id found! sending payload #{value}" }
+
+              if value.is_a?(Automation::Error)
+                message = value.message || "Something went wrong"
+
+                return respond(500, "Error occurred: #{message}" , {"Content-Type" => "text/plain"})
+              else
+                return respond(200, {"value" => value}.to_json)
+              end
+            end
+
+            sleep poll_interval
+          rescue ex
+            respond(500, "Error occurred while processing command: #{ex.message}", {"Content-Type" => "text/plain"})
+          end
+        end
+
+        respond(408, "Timeout", {"Content-Type" => "text/plain"})
+      end
+
+      def parse_body(request)
+        JSON.parse(request.body, symbolize_names: true) unless request.body.nil?
+      end
+
+      def respond(status, message, headers = {"Content-Type" => "application/json"})
+        [status, headers, message]
+      end
+    end
+
+    class Server
+      def self.start(*args, driver: Hokusai::Automation::Driver.new)
+        app = App.new(driver)
+
+        @socket = Thin::Server.new(*args, app)
+        Hokusai::ThreadPool.post do
+          @socket.start
+        end
+      end
+
+      def self.stop
+        @socket.stop
+
+        Hokusai::ThreadPool.prune_pool
+      end
+    end
+  end
+end

data/ui/src/hokusai/automation.rb

@@ -0,0 +1,3 @@
+require "colorize"
+require_relative "./automation/server"
+require_relative "./automation/client"

data/ui/src/hokusai/backends/raylib/config.rb

@@ -0,0 +1,47 @@
+module Hokusai::Backends
+  class RaylibBackend::ConfigError < StandardError; end
+
+  class RaylibBackend::Config
+    attr_accessor :width, :height, :fps,
+                  :title, :config_flags, :window_state_flags,
+                  :automation_driver, :background, :after_load_cb,
+                  :host, :port, :automated, :on_reload, :event_waiting
+
+    def initialize
+      @width = 500
+      @height = 500
+      @fps = 60
+      @title = "(Unknown Title)"
+      @config_flags = Raylib::FLAG_WINDOW_RESIZABLE | Raylib::FLAG_VSYNC_HINT
+      @window_state_flags = Raylib::FLAG_WINDOW_RESIZABLE
+      @automation_driver = nil
+      @background = Raylib::WHITE
+      @after_load_cb = nil
+      @host = "127.0.0.1"
+      @port = 4333
+      @automated = false
+      @on_reload = ->(_){}
+      @event_waiting = false
+    end
+
+    def start_automation_driver
+      raise ConfigError.new("Need a Hokusai::Driver in order to automate") if automation_driver.nil?
+
+      automation_driver.serve(host, port)
+    end
+
+    def automate(host, port)
+      self.host = host
+      self.port = port
+      self.automated = true
+    end
+
+    def after_load(&block)
+      self.after_load_cb = block
+    end
+
+    def on_reload(&block)
+      @on_reload = block
+    end
+  end
+end

data/ui/src/hokusai/backends/raylib/font.rb

@@ -0,0 +1,113 @@
+module Hokusai
+  module Backends
+    class RaylibBackend
+      class DataForCb < FFI::Struct
+        layout :size, :int,
+               :spacing, :int,
+               :raw, :pointer
+  
+        def self.create(size, spacing, raw)
+          obj = new.tap do |instance|
+            instance[:size] = size
+            instance[:spacing] = spacing
+            instance[:raw] = raw
+          end
+  
+          yield obj.to_ptr
+        end
+      end
+  
+      OnWidthCb = Proc.new do |char, ffi_pointer|
+        data = DataForCb.new ffi_pointer
+
+        Raylib.MeasureTextEx(data[:raw], "#{char.chr}", data[:size], data[:spacing]).x + data[:spacing]
+      end
+
+      class Font < Hokusai::Font
+        attr_reader :raw
+
+        DEFAULT = "–—‘’“”…\r\n\t0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%%^&*(),.?/\"\\[]-_=+|~`{}<>;:'\0"
+
+        def self.default
+          font = Raylib.GetFontDefault
+          Raylib.SetTextureFilter(font.texture, Raylib::TEXTURE_FILTER_BILINEAR)
+          Raylib.GenTextureMipmaps(font.texture)
+
+          new(font)
+        end
+
+        def self.from(file)
+          font = Raylib.LoadFont(file)
+          Raylib.SetTextureFilter(font.texture, Raylib::TEXTURE_FILTER_BILINEAR)
+          Raylib.GenTextureMipmaps(font.texture)
+
+          new(font)
+        end
+
+        def self.from_ext(file, font_size, codepoint_string = DEFAULT)
+          ptr = FFI::MemoryPointer.new :int
+          codepoints = Raylib.LoadCodepoints(codepoint_string, ptr)
+          count = ptr.read_int
+
+          raylib_font = Raylib.LoadFontEx(file, font_size, codepoints, count)
+          Raylib.GenTextureMipmaps(raylib_font.texture)
+          Raylib.SetTextureFilter(raylib_font.texture, Raylib::TEXTURE_FILTER_BILINEAR)
+
+          font = new(raylib_font)
+          Raylib.UnloadCodepoints(codepoints)
+
+          font
+        end
+
+        def initialize(raw, spacing = 1.0)
+          @raw = raw
+          @spacing = spacing
+        end
+
+        # returns the spacing for this font
+        # based on the text size
+        def spacing
+          ssize = raw.baseSize || 1
+          ssize = 10 if ssize < 10
+
+          (ssize / (raw.baseSize.zero? ? 1 : raw.baseSize)).to_f
+        end
+
+        def measure(string, size)
+          vec = Raylib.MeasureTextEx(raw, string, size, spacing)
+
+          [vec.x, vec.y]
+        end
+
+        def height
+          raw.baseSize
+        end
+
+
+        def clamp_markdown(text, size, width, initial_offset = 0.0)
+          clamping_pointer = FFI::MemoryPointer.new :pointer
+          RaylibBackend::DataForCb.create(size, spacing, raw) do |ptr|
+            ret = LibHokusai.hoku_text_md_clamp(clamping_pointer, text, width, initial_offset, ptr, RaylibBackend::OnWidthCb)
+            raise Hokusai::Error.new("Clamping failed") unless ret.zero?
+          end
+
+          clamping = LibHokusai::HokuClamping.new(FFI::AutoPointer.new(clamping_pointer.get_pointer(0), LibHokusai.method(:hoku_text_clamping_free)))
+          
+          Hokusai::Clamping.new(clamping, markdown: true)
+        end
+
+        def clamp(text, size, width, initial_offset = 0.0)
+          clamping_pointer = FFI::MemoryPointer.new :pointer
+          RaylibBackend::DataForCb.create(size, spacing, raw) do |ptr|
+            ret = LibHokusai.hoku_text_clamp(clamping_pointer, text, width, initial_offset, ptr, RaylibBackend::OnWidthCb)
+            raise Hokusai::Error.new("Clamping failed") unless ret.zero?
+          end
+
+          clamping = LibHokusai::HokuClamping.new(FFI::AutoPointer.new(clamping_pointer.get_pointer(0), LibHokusai.method(:hoku_text_clamping_free)))
+          
+          Hokusai::Clamping.new(clamping)
+        end
+      end
+    end
+  end
+end

data/ui/src/hokusai/backends/raylib/keys.rb

@@ -0,0 +1,124 @@
+module Hokusai::Backends
+  class RaylibBackend
+    Keys = [
+      [:null, Raylib::KEY_NULL],
+      [:left_shift, Raylib::KEY_LEFT_SHIFT],
+      [:left_control, Raylib::KEY_LEFT_CONTROL],
+      [:left_alt, Raylib::KEY_LEFT_ALT],
+      [:left_super, Raylib::KEY_LEFT_SUPER],
+      [:right_shift, Raylib::KEY_RIGHT_SHIFT],
+      [:right_control, Raylib::KEY_RIGHT_CONTROL],
+      [:right_alt, Raylib::KEY_RIGHT_ALT],
+      [:right_super, Raylib::KEY_RIGHT_SUPER],
+      [:apostrophe, Raylib::KEY_APOSTROPHE],
+      [:comma, Raylib::KEY_COMMA],
+      [:minus, Raylib::KEY_MINUS],
+      [:period, Raylib::KEY_PERIOD],
+      [:slash, Raylib::KEY_SLASH],
+      [:zero, Raylib::KEY_ZERO],
+      [:one, Raylib::KEY_ONE],
+      [:two, Raylib::KEY_TWO],
+      [:three, Raylib::KEY_THREE],
+      [:four, Raylib::KEY_FOUR],
+      [:five, Raylib::KEY_FIVE],
+      [:six, Raylib::KEY_SIX],
+      [:seven, Raylib::KEY_SEVEN],
+      [:eight, Raylib::KEY_EIGHT],
+      [:nine, Raylib::KEY_NINE],
+      [:semicolon, Raylib::KEY_SEMICOLON],
+      [:equal, Raylib::KEY_EQUAL],
+      [:a, Raylib::KEY_A],
+      [:b, Raylib::KEY_B],
+      [:c, Raylib::KEY_C],
+      [:d, Raylib::KEY_D],
+      [:e, Raylib::KEY_E],
+      [:f, Raylib::KEY_F],
+      [:g, Raylib::KEY_G],
+      [:h, Raylib::KEY_H],
+      [:i, Raylib::KEY_I],
+      [:j, Raylib::KEY_J],
+      [:k, Raylib::KEY_K],
+      [:l, Raylib::KEY_L],
+      [:m, Raylib::KEY_M],
+      [:n, Raylib::KEY_N],
+      [:o, Raylib::KEY_O],
+      [:p, Raylib::KEY_P],
+      [:q, Raylib::KEY_Q],
+      [:r, Raylib::KEY_R],
+      [:s, Raylib::KEY_S],
+      [:t, Raylib::KEY_T],
+      [:u, Raylib::KEY_U],
+      [:v, Raylib::KEY_V],
+      [:w, Raylib::KEY_W],
+      [:x, Raylib::KEY_X],
+      [:y, Raylib::KEY_Y],
+      [:z, Raylib::KEY_Z],
+      [:left_bracket, Raylib::KEY_LEFT_BRACKET],
+      [:backslash, Raylib::KEY_BACKSLASH],
+      [:right_bracket, Raylib::KEY_RIGHT_BRACKET],
+      [:grave, Raylib::KEY_GRAVE],
+      [:space, Raylib::KEY_SPACE],
+      [:escape, Raylib::KEY_ESCAPE],
+      [:enter, Raylib::KEY_ENTER],
+      [:tab, Raylib::KEY_TAB],
+      [:backspace, Raylib::KEY_BACKSPACE],
+      [:insert, Raylib::KEY_INSERT],
+      [:delete, Raylib::KEY_DELETE],
+      [:right, Raylib::KEY_RIGHT],
+      [:left, Raylib::KEY_LEFT],
+      [:down, Raylib::KEY_DOWN],
+      [:up, Raylib::KEY_UP],
+      [:page_up, Raylib::KEY_PAGE_UP],
+      [:page_down, Raylib::KEY_PAGE_DOWN],
+      [:home, Raylib::KEY_HOME],
+      [:end, Raylib::KEY_END],
+      [:caps_lock, Raylib::KEY_CAPS_LOCK],
+      [:scroll_lock, Raylib::KEY_SCROLL_LOCK],
+      [:num_lock, Raylib::KEY_NUM_LOCK],
+      [:print_screen, Raylib::KEY_PRINT_SCREEN],
+      [:pause, Raylib::KEY_PAUSE],
+      [:f1, Raylib::KEY_F1],
+      [:f2, Raylib::KEY_F2],
+      [:f3, Raylib::KEY_F3],
+      [:f4, Raylib::KEY_F4],
+      [:f5, Raylib::KEY_F5],
+      [:f6, Raylib::KEY_F6],
+      [:f7, Raylib::KEY_F7],
+      [:f8, Raylib::KEY_F8],
+      [:f9, Raylib::KEY_F9],
+      [:f10, Raylib::KEY_F10],
+      [:f11, Raylib::KEY_F11],
+      [:f12, Raylib::KEY_F12],
+      [:left_shift, Raylib::KEY_LEFT_SHIFT],
+      [:left_control, Raylib::KEY_LEFT_CONTROL],
+      [:left_alt, Raylib::KEY_LEFT_ALT],
+      [:left_super, Raylib::KEY_LEFT_SUPER],
+      [:right_shift, Raylib::KEY_RIGHT_SHIFT],
+      [:right_control, Raylib::KEY_RIGHT_CONTROL],
+      [:right_alt, Raylib::KEY_RIGHT_ALT],
+      [:right_super, Raylib::KEY_RIGHT_SUPER],
+      [:kb_menu, Raylib::KEY_KB_MENU],
+      [:kp_0, Raylib::KEY_KP_0],
+      [:kp_1, Raylib::KEY_KP_1],
+      [:kp_2, Raylib::KEY_KP_2],
+      [:kp_3, Raylib::KEY_KP_3],
+      [:kp_4, Raylib::KEY_KP_4],
+      [:kp_5, Raylib::KEY_KP_5],
+      [:kp_6, Raylib::KEY_KP_6],
+      [:kp_7, Raylib::KEY_KP_7],
+      [:kp_8, Raylib::KEY_KP_8],
+      [:kp_9, Raylib::KEY_KP_9],
+      [:kp_decimal, Raylib::KEY_KP_DECIMAL],
+      [:kp_divide, Raylib::KEY_KP_DIVIDE],
+      [:kp_multiply, Raylib::KEY_KP_MULTIPLY],
+      [:kp_subtract, Raylib::KEY_KP_SUBTRACT],
+      [:kp_add, Raylib::KEY_KP_ADD],
+      [:kp_enter, Raylib::KEY_KP_ENTER],
+      [:kp_equal, Raylib::KEY_KP_EQUAL],
+      [:back, Raylib::KEY_BACK],
+      [:menu, Raylib::KEY_MENU],
+      [:volume_up, Raylib::KEY_VOLUME_UP],
+      [:volume_down, Raylib::KEY_VOLUME_DOWN]]
+  end
+end
+