Merge branch 'main' into animation

res/modules/internal/debugging.lua

@@ -148,3 +148,29 @@ function error(message, level)
     end
     __error(message, level)
 end
+
+local LoggerClass = {
+    __index = {
+        info = function (self, text)
+            debug.log(string.format("[%s] %s", self.name, text))
+        end,
+        warning = function (self, text)
+            debug.warning(string.format("[%s] %s", self.name, text))
+        end,
+        error = function (self, text)
+            debug.error(string.format("[%s] %s", self.name, text))
+        end
+    }
+}
+
+local _getinfo = debug.getinfo
+
+function debug.Logger(name)
+    if not name then
+        local source = _getinfo(2, "S").source
+        name = file.remove_ext(source)
+    else
+        name = string.format("%s:%s", file.prefix(_getinfo(2, "S").source), name)
+    end
+    return setmetatable({name=name}, LoggerClass)
+end

res/modules/internal/events.lua

@@ -14,6 +14,7 @@ function events.on(event, func)
         events.handlers[event] = {}
     end
     table.insert(events.handlers[event], func)
+    return func
 end
 
 function events.reset(event, func)
@@ -24,6 +25,14 @@ function events.reset(event, func)
     end
 end
 
+function events.remove(event, handler)
+    local handlers = events.handlers[event]
+    if not handlers then
+        return
+    end
+    table.remove_value(handlers, handler)
+end
+
 function events.remove_by_prefix(prefix)
     for name, handlers in pairs(events.handlers) do
         local actualname = name

res/modules/internal/extensions/file.lua

@@ -23,6 +23,10 @@ function file.parent(path)
     return dir
 end
 
+function file.remove_ext(path)
+    return string.format("%s/%s", file.parent(path), file.stem(path))
+end
+
 function file.path(path)
     local pos = path:find(':')
     return path:sub(pos + 1)

res/modules/internal/extensions/table.lua

@@ -59,11 +59,7 @@ end
 
 function table.extend(t1, t2)
     for i, v in pairs(t2) do
-        if type(i) == "number" then
-            t1[#t1 + 1] = v
-        else
-            t1[i] = v
-        end
+        t1[i] = v
     end
 
     return t1
@@ -201,3 +197,11 @@ function table.tostring(t)
     end
     return s..']'
 end
+
+function table.keys(t)
+    local keys = {}
+    for key, _ in pairs(t) do
+        table.insert(keys, key)
+    end
+    return keys
+end

res/modules/internal/gui_util.lua

@@ -77,15 +77,18 @@ function Element.new(docname, name)
 end
 
 -- the engine automatically creates an instance for every ui document (layout)
-local Document = {}
-function Document.new(docname)
-    return setmetatable({name=docname}, {
-        __index=function(self, k)
-            local elem = Element.new(self.name, k)
-            rawset(self, k, elem)
-            return elem
+local Document = {
+    __index=function(self, k)
+        if type(k) ~= "string" then
+            error("element id is not a string")
         end
-    })
+        local elem = Element.new(self.name, k)
+        rawset(self, k, elem)
+        return elem
+    end
+}
+function Document.new(docname)
+    return setmetatable({name=docname}, Document)
 end
 
 local RadioGroup = {}

res/modules/internal/stream_providers/bytearray.lua

@@ -0,0 +1,131 @@
+local io_stream = require "core:io_stream"
+
+local lib = { }
+
+local buffers = { }
+local positions = { }
+
+local next_descriptor = 0
+
+local function open_descriptor(buffer)
+    next_descriptor = next_descriptor + 1
+
+    buffers[next_descriptor] = buffer
+    positions[next_descriptor] = 1
+
+    return next_descriptor
+end
+
+local function require_descriptor(descriptor)
+    if not buffers[descriptor] then
+        error("unknown descriptor")
+    end
+end
+
+function lib.read(descriptor, length)
+    require_descriptor(descriptor)
+
+    local buf = buffers[descriptor]
+    local buf_length = #buf
+    local pos = positions[descriptor]
+
+    local to_read = math.min(buf_length - pos + 1, length)
+
+    if to_read <= 0 then
+        return Bytearray()
+    end
+
+    local segment = buf:slice(pos, to_read)
+
+    positions[descriptor] = pos + to_read
+
+    return segment
+end
+
+function lib.write(descriptor, data)
+    require_descriptor(descriptor)
+
+    local buf = buffers[descriptor]
+    local pos = positions[descriptor]
+
+    local buf_length = #buf
+    local data_length = #data
+
+    local end_pos = pos + data_length - 1
+
+    -- size ensuring
+    if end_pos > buf_length then
+        for i = buf_length + 1, end_pos do
+            buf[i] = 0
+        end
+    end
+
+    for i = 1, data_length do
+        buf[i + pos - 1] = data[i]
+    end
+
+    positions[descriptor] = pos + data_length
+end
+
+function lib.seek(descriptor, mode, offset)
+    require_descriptor(descriptor)
+
+    local buf = buffers[descriptor]
+    local buf_length = #buf
+
+    local base
+
+    if mode == 'b' then
+        base = 1
+    elseif mode == 'c' then
+        base = positions[descriptor]
+    elseif mode == 'e' then
+        base = buf_length + 1
+    else error('invalid seek mode') end
+
+    local new_pos = base + offset
+
+    if new_pos < 1 then
+        error('failed to seek stream')
+    end
+
+    positions[descriptor] = new_pos
+end
+
+function lib.tell(descriptor)
+    require_descriptor(descriptor)
+
+    return positions[descriptor]
+end
+
+function lib.available(descriptor)
+    require_descriptor(descriptor)
+
+    local buf = buffers[descriptor]
+    local pos = positions[descriptor]
+
+    return math.max(#buf - pos + 1, 0)
+end
+
+function lib.is_alive(descriptor)
+    return buffers[descriptor] ~= nil
+end
+
+function lib.close(descriptor)
+    require_descriptor(descriptor)
+
+    buffers[descriptor] = nil
+    positions[descriptor] = nil
+end
+
+return function(buffer, binary_mode)
+    if binary_mode == nil then
+        binary_mode = true
+    end
+
+    return io_stream.new(
+        open_descriptor(buffer),
+        binary_mode,
+        lib
+    )
+end

res/modules/internal/stream_providers/file.lua

@@ -4,15 +4,28 @@ local lib = {
     read = file.__read_descriptor,
     write = file.__write_descriptor,
     seek = file.__seek_descriptor,
+    tell = file.__tell_descriptor,
     flush = file.__flush_descriptor,
+    available = file.__available_descriptor,
     is_alive = file.__has_descriptor,
     close = file.__close_descriptor
 }
 
+local __open_descriptor = file.__open_descriptor
+file.__open_descriptor = nil
+file.__read_descriptor = nil
+file.__write_descriptor = nil
+file.__seek_descriptor = nil
+file.__tell_descriptor = nil
+file.__flush_descriptor = nil
+file.__available_descriptor = nil
+file.__has_descriptor = nil
+file.__close_descriptor = nil
+
 return function(path, mode)
     return io_stream.new(
-        file.__open_descriptor(path, mode),
+        __open_descriptor(path, mode),
         mode:find('b') ~= nil,
         lib
     )
-end
+end

res/modules/internal/stream_providers/named_pipe_unix.lua

@@ -9,6 +9,7 @@ int close(int fd);
 ssize_t read(int fd, void *buf, size_t count);
 ssize_t write(int fd, const void *buf, size_t count);
 int fcntl(int fd, int cmd, ...);
+int ioctl(int fd, unsigned long request, ...);
 
 const char *strerror(int errnum);
 ]]
@@ -20,6 +21,7 @@ local O_WRONLY   = 0x1
 local O_RDWR     = 0x2
 local O_NONBLOCK = 0x800
 local F_GETFL    = 3
+local FIONREAD   = 0x541B
 
 local function getError()
     local err = FFI.errno()
@@ -58,12 +60,16 @@ function lib.write(fd, bytearray)
     end
 end
 
-function lib.seek(fd, mode, offset)
-    error("cannot seek the named pipe")
-end
+function lib.available(fd)
+    if fd == nil or fd < 0 then return 0 end
 
-function lib.flush(fd)
-    -- no flush on unix
+    local bytes_ready = FFI.new("int[1]", 0)
+
+    if C.ioctl(fd, FIONREAD, bytes_ready) == -1 then
+        return 0
+    end
+
+    return tonumber(bytes_ready[0])
 end
 
 function lib.is_alive(fd)

res/modules/internal/stream_providers/named_pipe_windows.lua

@@ -97,14 +97,26 @@ function lib.write(handle, bytearray)
     end
 end
 
-function lib.seek(handle, mode, offset)
-    error("cannot seek the named pipe")
-end
-
 function lib.flush(handle)
     C.FlushFileBuffers(handle)
 end
 
+function lib.available(handle)
+    if handle == nil or handle == INVALID_HANDLE_VALUE then
+        return 0
+    end
+
+    local bytes_available = FFI.new("DWORD[1]")
+
+    local success = C.PeekNamedPipe(handle, nil, 0, nil, bytes_available, nil)
+
+    if success == 0 then
+        return 0
+    end
+
+    return tonumber(bytes_available[0])
+end
+
 function lib.is_alive(handle)
     if handle == nil or handle == INVALID_HANDLE_VALUE then
         return false

res/modules/internal/stream_providers/socket.lua

@@ -0,0 +1,64 @@
+local io_stream = require "core:io_stream"
+
+local lib = { }
+
+local sockets = { }
+
+local next_descriptor = 0
+
+local function open_descriptor(socket)
+    next_descriptor = next_descriptor + 1
+
+    sockets[next_descriptor] = socket
+
+    return next_descriptor
+end
+
+local function require_descriptor(descriptor)
+    if not sockets[descriptor] then
+        error("unknown descriptor")
+    end
+end
+
+function lib.read(descriptor, length)
+    require_descriptor(descriptor)
+
+    return sockets[descriptor]:recv(length)
+end
+
+function lib.write(descriptor, data)
+    require_descriptor(descriptor)
+
+    sockets[descriptor]:send(data)
+end
+
+function lib.available(descriptor)
+    require_descriptor(descriptor)
+
+    return sockets[descriptor]:available()
+end
+
+function lib.is_alive(descriptor)
+    local socket = sockets[descriptor]
+
+    return socket ~= nil and socket:is_alive()
+end
+
+function lib.close(descriptor)
+    require_descriptor(descriptor)
+
+    sockets[descriptor]:close()
+    sockets[descriptor] = nil
+end
+
+return function(socket, binary_mode)
+    if binary_mode == nil then
+        binary_mode = true
+    end
+
+    return io_stream.new(
+        open_descriptor(socket),
+        binary_mode,
+        lib
+    )
+end

res/modules/internal/test.lua

@@ -0,0 +1,139 @@
+local __app = __vc_app
+
+local function get_node_center(node)
+    local pos = node.wpos
+    local size = node.size
+    return pos[1] + size[1] / 2, pos[2] + size[2] / 2
+end
+
+local function types_check_enum(value, enum)
+    if value == nil then
+        return true, nil
+    end
+    if type(value) ~= "string" then
+        return false, string.format("string expected [%s]", table.concat(table.keys(enum), "|"))
+    end
+    return true, nil
+end
+
+local function types_check_number(value)
+    if value == nil then
+        return true, nil
+    end
+    local value_type = type(value)
+    if value_type ~= "number" then
+        return false, string.format("number expected, got %s", value_type)
+    end
+end
+
+local function check_option(t, key, func, ...)
+    local value = t[key]
+    if value == nil then
+        return nil
+    end
+    local success, message = func(value, ...)
+    if not success then
+        error(string.format("invalid option '%s': %s", key, message))
+    end
+end
+
+local buttons_enum = {
+    left = 0,
+    right = 1,
+    middle = 2,
+}
+local no_options = {}
+
+local _tick = __app.tick
+local _set_button_pressed = test.set_button_pressed
+local _set_key_pressed = test.set_key_pressed
+local _enter_text = test.enter_text
+test.set_button_pressed = nil
+test.set_key_pressed = nil
+test.enter_text = nil
+
+function test.click(node, options)
+    options = options or no_options
+
+    check_option(options, 'button', types_check_enum, buttons_enum)
+    check_option(options, 'timeout', types_check_number)
+
+    local button = buttons_enum[options.button or 'left']
+    local timeout = options.timeout or 1000
+
+    local tm = time.precise_time()
+    while (time.precise_time() - tm) * 1000 < timeout do
+        if node.exists then
+            break
+        end
+        _tick()
+    end
+    if not node.exists then
+        error(string.format("timeout %s ms exceeded: element %s does not exists",
+            math.floor(timeout), string.escape(rawget(node, 'name'))))
+    end
+
+    local center_x, center_y = get_node_center(node)
+    _set_button_pressed(button, center_x, center_y, true)
+    _tick()
+    _set_button_pressed(button, center_x, center_y, false)
+    _tick()
+end
+
+-- TODO: replace with resolving in C++ side
+function test.find_by_attr(node, attr, value)
+    if getmetatable(node) == Document then
+        return test.find_by_attr(node.root, attr, value)
+    end
+    if node[attr] == value then
+        return node
+    end
+    local i = 1
+    while true do
+        local subnode = node[i]
+        if subnode == nil then
+            break
+        end
+        local found = test.find_by_attr(subnode, attr, value)
+        if found then
+            return found
+        end
+        i = i + 1
+    end
+end
+
+function test.find_by_text(node, text)
+    return test.find_by_attr(node, "text", text)
+end
+
+function test.find_by_attr_presence(node, attr)
+    if node[attr] then
+        return node
+    end
+    local i = 1
+    while true do
+        local subnode = node[i]
+        if subnode == nil then
+            break
+        end
+        local found = test.find_by_attr_presence(subnode, attr)
+        if found then
+            return found
+        end
+        i = i + 1
+    end
+end
+
+function test.fill(node, text, options)
+    test.click(node, options)
+    __app.tick()
+    _enter_text(text)
+    test.press("enter")
+end
+
+function test.press(key)
+    _set_key_pressed(key, true)
+    __app.tick()
+    _set_key_pressed(key, false)
+    __app.tick()
+end