hokusai-zero 0.1.1

data/ui/src/hokusai/ast.rb

@@ -0,0 +1,446 @@
+# frozen_string_literal: true
+
+module Hokusai
+  # Wrapper for interacting with asts produced
+  # by LibHokusai
+  class Ast
+    def self.registry
+      @registry ||= {}
+    end
+
+    def self.get(template)
+      registry[template]
+    end
+
+    def self.save(template, ast)
+      registry[template] = ast
+    end
+
+    # A node representing a loop
+    class Loop
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      # The loop variable
+      # eg [for="item in list"]
+      # the var is `item`
+      def var
+        @name ||= raw[:name].freeze
+      end
+
+      # The loop method
+      # eg [for="item in list"]
+      # the method is `list`
+      def method
+        @list_name ||= raw[:list_name].freeze
+      end
+    end
+
+    # A node representing a function
+    # call
+    class Func
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      # Name of the func
+      # eg @target="run_this(one,two)"
+      # the name is `run_this`
+      #
+      # @return [String]
+      def method
+        @method ||= raw[:function].freeze
+      end
+
+      # Args of the func
+      # eg @target="run_this(one, two)"
+      # the args are [one, two]
+      #
+      # @return [Array(String)]
+      def args
+        @strargs ||= raw[:strargs]
+          .read_array_of_type(:pointer, :read_pointer, raw[:args_len])
+          .map(&:read_string).freeze
+      end
+    end
+
+    # A node representing an
+    # ast event
+    class Event
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      # @return [String]
+      def name
+        @name ||= @raw[:name].freeze
+      end
+
+      # @return [Func?]
+      def value
+        @call ||= raw[:call]
+
+        return nil if @call.null?
+
+        @func ||= Func.new(@call)
+      end
+    end
+
+    class Prop
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def computed?
+        raw[:computed]
+      end
+
+      def name
+        @name ||= raw[:name].freeze
+      end
+
+      def value
+        @call ||= raw[:call]
+
+        return nil if @call.null?
+
+        @func ||= Func.new(@call)
+      end
+    end
+
+    attr_reader :raw
+    attr_accessor :updater, :parent, :target
+
+    def initialize(raw)
+      @raw = raw
+      @dirty = false
+      @children = nil
+      @siblings = nil
+      @classes = nil
+      @else_active = false
+    end
+
+    # @param [String] template the template to parse
+    # @param [String] type a name for this template (default root)
+    # @return [Hokusai::Ast]
+    def self.parse(template, type)
+      ast = LibHokusai.parse_template(type, template)
+      errored = LibHokusai.hoku_errored_ast(ast)
+
+      unless errored.null?
+        begin
+          raise Hokusai::Error.new(errored[:error]) 
+        ensure
+          # LibHokusai.hoku_ast_free(errored)
+        end
+      end
+
+      new(ast)
+    end
+
+    def style
+      @style ||= Style.parse_styles(raw[:styles]) unless raw[:styles].null?
+    end
+
+    def style_list
+      @style_list ||= begin
+        list = []
+
+        head = raw[:style_list]
+        until head.null?
+          list << head[:name]
+
+          head = head[:next]
+        end
+
+        list
+      end
+    end
+
+    def dirty!
+      @dirty = true
+    end
+
+    def dirty?
+      @dirty
+    end
+
+    def slot?
+      type == "slot"
+    end
+
+    def virtual?
+      type == "virtual"
+    end
+
+    def loop?
+      @loop_condition = !raw[:loop].null? if @loop_condition.nil?
+
+      @loop_condition
+    end
+
+    def has_if_condition?
+      @if_condition = !raw[:cond].null? if @if_condition.nil?
+
+      @if_condition
+    end
+
+    def has_else_condition?
+      @else_condition = !raw[:else_relations].null? if @else_condition.nil?
+
+      @else_condition
+    end
+
+    def else_condition_active?
+      has_else_condition? && @else_active == 1
+    end
+
+    def else_active=(val)
+      @else_active = val
+    end
+
+    def else_ast
+      return nil unless has_else_condition?
+
+      Ast.new(raw[:else_relations][:next_child])
+    end
+
+    def loop
+      return nil unless loop?
+
+      @loop ||= Loop.new(raw[:loop])
+    end
+
+    def if
+      @cond ||= raw[:cond]
+
+      return nil if @cond.null?
+
+      @call ||= @cond[:call]
+
+      return nil if @call.null?
+
+      @func ||= Func.new(@call)
+    end
+
+    def type
+      @type ||= raw[:type].nil? ? "(null)" : raw[:type]
+    end
+
+    def id
+      @id ||= raw[:id].nil? ? "(null)" : raw[:id]
+    end
+
+    def classes
+      return @classes unless @classes.nil?
+
+      @classes = []
+      each_class do |child|
+        @classes << child
+      end
+
+      @classes
+    end
+
+    def children
+      return @children unless @children.nil?
+
+      @children = []
+      each_child do |child|
+        @children << child
+      end
+
+      @children
+    end
+
+    def siblings
+      return @siblings unless @siblings.nil?
+
+      @siblings = []
+
+      ast = raw[:relations][:next_sibling]
+      while !ast.null?
+        @siblings << Ast.new(ast)
+
+        ast = ast[:relations][:next_sibling]
+      end
+
+      @siblings
+    end
+
+    def else_children
+      children = []
+
+      ast = raw[:else_relations][:next_child]
+      while !ast.null?
+        children << ast
+
+        ast = ast[:relations][:next_sibling]
+      end
+
+      children
+    end
+
+    def props
+      return @props unless @props.nil?
+
+      @props = {}
+
+      each_prop do |prop|
+        @props[prop.name] = prop
+      end
+
+      @props
+    end
+
+    def events
+      return @events unless @events.nil?
+
+      @events = {}
+
+      each_event do |event|
+        @events[event.name] = event
+      end
+
+      @events
+    end
+
+    # Iterate over each child node of this ast
+    #
+    # @yield [Hokusai::Ast]
+    def each_child
+      ast = raw[:relations][:next_child]
+      i = 0
+
+      while !ast.null?
+        yield Ast.new(ast), i
+
+        i += 1
+        ast = ast[:relations][:next_sibling]
+      end
+    end
+
+    # Iterate over all class names for this ast
+    #
+    # @yield [String] the name of the class
+    def each_class
+      ast = raw[:class_list]
+      i = 0
+
+      while !ast.null?
+        yield(ast[:name], i)
+
+        i += 1
+        ast = ast[:next]
+      end
+    end
+
+    # Iterate over all events in this ast
+    #
+    # @yield [Hokusai::Ast::Event]
+    def each_event
+      i = FFI::MemoryPointer.new(:size_t)
+      i.write(:size_t, 0)
+      item = FFI::MemoryPointer.new :pointer
+
+      while LibHokusai.hashmap_iter(raw[:events], i, item)
+        event = item.get_pointer(0)
+        event = LibHokusai::HmlAstEvent.new(event)
+
+        yield Event.new(event)
+      end
+
+      item.free
+      i.free
+    end
+
+    # Iterate over all props in this ast
+    #
+    # @yield [Hokusai::Ast::Prop]
+    def each_prop
+      i = FFI::MemoryPointer.new :size_t
+      i.write(:size_t, 0)
+      item = FFI::MemoryPointer.new :pointer
+
+      while LibHokusai.hashmap_iter(raw[:props], i, item)
+        prop = item.get_pointer(0)
+        prop = LibHokusai::HmlAstProp.new(prop)
+
+        yield Prop.new(prop)
+      end
+
+      item.free
+      i.free
+    end
+
+    def prop(name)
+      props[name]
+    end
+
+    # Search for a prop by name
+    #
+    # @param [String] name the name of the prop to find
+    # @return [Hokusai::Ast::Prop?] the prop if found
+    # def prop(name)
+    #   prop_ptr = FFI::MemoryPointer.new :pointer
+    #   code = LibHokusai.hoku_ast_prop_init(prop_ptr, name)
+    #
+    #   raise Hokusai::Error.new("Failed to allocate prop") unless code.zero?
+    #
+    #   prop_ptr2 = prop_ptr.get_pointer(0)
+    #   prop = LibHokusai::HmlAstProp.new(prop_ptr2)
+    #   response = LibHokusai.hoku_ast_get_prop(raw, prop)
+    #   return nil if response.null?
+    #
+    #   Prop.new(response)
+    # ensure
+    #   prop_ptr.free
+    # end
+
+    def event(name)
+      events[name]
+    end
+
+    # Search for an event by name
+    #
+    # @param [String] name the name of the prop to find
+    # @return [Prop?] the prop if found
+    # def event(name)
+    #   event_ptr = FFI::MemoryPointer.new :pointer
+    #   code = LibHokusai.hoku_ast_prop_init(event_ptr, name)
+    #
+    #   raise Hokusai::Error.new("Failed to allocate prop") unless code.zero?
+    #
+    #   event_ptr2 = event_ptr.get_pointer(0)
+    #   event = LibHokusai::HmlAstEvent.new(event_ptr2)
+    #   response = LibHokusai.hoku_ast_get_event(raw, event)
+    #   event_ptr.free
+    #
+    #   return nil if response.null?
+    #
+    #   Event.new(response)
+    # ensure
+    #   event_ptr.free
+    # end
+
+    def destroy
+      puts "before destroy"
+      LibHokusai.hoku_ast_free(raw)
+      puts "after destroy"
+    end
+
+    # dumps this ast to STDOUT
+    def dump
+      LibHokusai.hoku_dump(raw, 0)
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+require_relative "./constants"
+require "json"
+require "uri"
+require "rest-client"
+
+module Hokusai
+  module Automation
+    class Client
+      class Block
+        attr_reader :uuid, :client
+
+        def self.locate(selector, client)
+          value = client.make_request("commands/locate", { selector: selector })
+          new(value, client)
+        end
+
+        def self.locate_all(selector, client)
+          value = client.make_request("commands/locate", { selector: selector })
+
+          value.map do |val|
+            new(val, client)
+          end
+        end
+
+        def initialize(uuid, client)
+          @uuid = uuid
+          @client = client
+        end
+
+        [[:left, 0], [:middle, 1], [:right, 2]].each do |(type, button)|
+          define_method("#{type}_click") do
+            client.make_request("commands/click", {uuid: uuid, button: button})
+          end
+
+          define_method("#{type}_mouseup") do
+            client.make_request("commands/mouseup", {uuid: uuid, button: button})
+          end
+        end
+    
+        def click
+          left_click
+        end
+
+        def mouseup
+          left_mouseup
+        end
+
+        def prop(name)
+          client.make_request("commands/attribute", { uuid: uuid, attribute_name: name})
+        end
+
+        def invoke(name)
+          client.make_request("commands/invoke", {uuid: uuid, method: name})
+        end
+
+        def hover
+          client.make_request("commands/hover", { uuid: uuid })
+        end
+
+        def drag_to(x, y)
+          client.make_request("commands/drag", {uuid: uuid, x: x, y: y})
+        end
+
+        def send_keys(keys)
+          case keys
+          when String
+            encoded = KeysTranscoder.encode(keys.chars)
+          else
+            encoded = KeysTranscoder.encode(keys)
+          end
+
+          client.make_request("commands/keyboard", {uuid: uuid, keys: encoded})
+        end
+    
+        def scroll(to)
+          client.make_request("commands/wheel", {id: uuid, scroll_amount: to})
+        end
+      end
+
+      attr_reader :host, :port
+
+      def self.start(host = "localhost", port=3000)
+        new URI.parse("http://#{host}:#{port}")
+      end
+
+      def self.start_unix(path)
+        new URI.parse("unix://#{path}")
+      end
+
+      def initialize(uri)
+        @host = uri.host
+        @port = uri.port
+        @http = RestClient::Resource.new("#{uri.host}:#{uri.port}")
+
+        wait_until_ready
+      end
+
+      def block(selector)
+        block = Client::Block.locate(selector, self)
+        if block_given?
+          yield block
+        else
+          block
+        end
+      end
+
+      def blocks(selector)
+        Client::Block.locate_all(selector, self)
+      end
+
+      def make_request(command, json)
+        begin
+          res = @http[command].post(json.to_json, headers)
+
+          if res.code == 200
+            JSON.parse(res.body)["value"]
+          else
+            raise Automation::Error.new("Got status code #{res.code} - #{res.body}")
+          end
+        rescue StandardError => ex
+          raise Automation::Error.new("Failed to make request: #{ex}")
+        end
+      end
+
+      def wait_until_stopped(timeout: 2, interval: 0.2)
+        time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        val = nil
+
+        while (Process.clock_gettime(Process::CLOCK_MONOTONIC) - time) < timeout
+          begin
+            res = @http["ready"].post
+            if res.code != 200
+              break
+            else
+              sleep interval
+            end
+          rescue
+            sleep interval
+          end
+        end
+      end
+
+      def wait_until_ready(timeout: 2, interval: 0.2)
+        time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        val = nil
+
+        while (Process.clock_gettime(Process::CLOCK_MONOTONIC) - time) < timeout
+          begin
+            @http.start
+            res = @http["ready"].post
+            if res.code == 200
+              break
+            else
+              sleep interval
+            end
+          rescue
+            sleep interval
+          end
+        end
+      end
+
+      def headers
+        {"Content-Type" => "application/json" }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+require "logger"
+require_relative "./keys_transcoder"
+
+module Hokusai::Automation
+  class Error < StandardError; end
+
+  Log = Logger.new($stdout)
+
+  case ENV["LOG_LEVEL"]
+  when "debug"
+    Log.level = Logger::DEBUG
+  when "info"
+    Log.level = Logger::INFO
+  when "warn"
+    Log.level = Logger::WARN
+  when "error"
+    Log.level = Logger::ERROR
+  end
+
+  CODE_TO_HML_KEY = {
+    '\0' => :null,
+    '\'' => :apostrophe,
+    ',' => :comma,
+    '-' => :minus,
+    '.' => :period,
+    '\\' => :slash,
+    '0' => :zero,
+    '1' => :one,
+    '2' => :two,
+    '3' => :three,
+    "4" => :four,
+    '5' => :five,
+    '6' => :six,
+    '7' => :seven,
+    '8' => :eight,
+    '9' => :nine,
+    ';' => :semicolon,
+    '=' => :equal,
+    'A' => :a,
+    'B' => :b,
+    'C' => :c,
+    'D' => :d,
+    'E' => :e,
+    'F' => :f,
+    'G' => :g,
+    'H' => :h,
+    'I' => :i,
+    'J' => :j,
+    'K' => :k,
+    'L' => :l,
+    'M' => :m,
+    'N' => :n,
+    'O' => :o,
+    'P' => :p,
+    'Q' => :q,
+    'R' => :r,
+    'S' => :s,
+    'T' => :t,
+    'U' => :u,
+    'V' => :v,
+    'W' => :w,
+    'X' => :x,
+    'Y' => :y,
+    'Z' => :z,
+    'a' => :a,
+    'b' => :b,
+    'c' => :c,
+    'd' => :d,
+    'e' => :e,
+    'f' => :f,
+    'g' => :g,
+    'h' => :h,
+    'i' => :i,
+    'j' => :j,
+    'k' => :k,
+    'l' => :l,
+    'm' => :m,
+    'n' => :n,
+    'o' => :o,
+    'p' => :p,
+    'q' => :q,
+    'r' => :r,
+    's' => :s,
+    't' => :t,
+    'u' => :u,
+    'v' => :v,
+    'w' => :w,
+    'x' => :x,
+    'y' => :y,
+    'z' => :z,
+    '[' => :left_bracket,
+    '/' => :backslash,
+    ']' => :right_bracket,
+    '~' => :grave,
+    ' ' => :space,
+    '\e' => :escape,
+  }.merge(KeysTranscoder::KEYS.to_h { |k, v| [k, k]})
+end