config: parse include and exclude as lexical_path.Patterns

... and accept `lexical_path.Pattern`s in more places

Author: euclidianAce

build/cyan/commands/build.lua

@@ -93,7 +93,7 @@ local function build(args: command.Args, loaded_config: config.Config, starting_
    local include <const> = loaded_config.include or {}
    local exclude <const> = loaded_config.exclude and { table.unpack(loaded_config.exclude) } or {}
    if abs_source_dir == starting_dir then
-      table.insert(exclude, "tlconfig.lua")
+      table.insert(exclude, lexical_path.parse_pattern "tlconfig.lua")
    end
    local dont_write_lua_files <const> = source_dir == build_dir
 

build/cyan/config.lua

@@ -19,8 +19,8 @@ local record Config
 
    build_dir: lexical_path.Path
    source_dir: lexical_path.Path
-   include: {string}
-   exclude: {string}
+   include: {lexical_path.Pattern}
+   exclude: {lexical_path.Pattern}
    global_env_def: string
    include_dir: {lexical_path.Path}
 
@@ -292,6 +292,25 @@ function config.is_config(c_in: any): Config, {string}, {string}
    end
 
    result.externals = c.externals as {string:any}
+
+   if type(c.include) == "table" then
+      result.include = {}
+      for i, patt in ipairs(c.include as {any}) do
+         if patt is string then
+            result.include[i] = lexical_path.parse_pattern(patt)
+         end
+      end
+   end
+
+   if type(c.exclude) == "table" then
+      result.exclude = {}
+      for i, patt in ipairs(c.exclude as {any}) do
+         if patt is string then
+            result.exclude[i] = lexical_path.parse_pattern(patt)
+         end
+      end
+   end
+
    for k in pairs(valid_keys) do
       if (result as {string:any})[k] == nil then
          (result as {string:any})[k] = copy(c[k])

build/cyan/fs.lua

@@ -130,7 +130,7 @@ end
 ---@desc
 --- If the given path matches any of the patterns in `patterns`, returns the index of the matched pattern
 --- otherwise returns `nil`
-function fs.match_any(path: lexical_path.Path, patterns: {lexical_path.Pattern}): integer
+function fs.match_any(path: lexical_path.Path, patterns: {string | lexical_path.Pattern}): integer
    for i, pattern in ipairs(patterns) do
       if path:match(pattern) then
          return i
@@ -143,9 +143,20 @@ end
 --- Recursively iterate over the files in a directory, following the provided `include` and `exclude` patterns
 ---
 --- For information on path patterns, see the `Path:match()` method
-function fs.scan_directory(dir: lexical_path.Path, include?: {string}, exclude?: {string}, include_directories?: boolean): function(): lexical_path.Path
-   local include_patterns <const>: {lexical_path.Pattern} = util.tab.map(include or {}, lexical_path.parse_pattern)
-   local exclude_patterns <const>: {lexical_path.Pattern} = util.tab.map(exclude or {}, lexical_path.parse_pattern)
+function fs.scan_directory(
+   dir: lexical_path.Path,
+   include?: {string | lexical_path.Pattern},
+   exclude?: {string | lexical_path.Pattern},
+   include_directories?: boolean
+): function(): lexical_path.Path
+   local function ensure_pattern(x: string | lexical_path.Pattern): lexical_path.Pattern
+      if x is string then
+         return lexical_path.parse_pattern(x)
+      end
+      return x
+   end
+   local include_patterns <const>: {lexical_path.Pattern} = util.tab.map(include or {}, ensure_pattern)
+   local exclude_patterns <const>: {lexical_path.Pattern} = util.tab.map(exclude or {}, ensure_pattern)
 
    local function matches(to_match: lexical_path.Path): boolean
       local inc: integer = nil

docs/index.html

@@ -260,7 +260,7 @@ end
 ---
 --- Returns `nil` if a circular dependency was found, along
 --- with a list of the filenames in the cycle
-function graph.scan_directory(dir: lexical_path.Path, include?: {string}, exclude?: {string}): Dag, {string}
+function graph.scan_directory(dir: lexical_path.Path, include?: {string | lexical_path.Pattern}, exclude?: {string | lexical_path.Pattern}): Dag, {string}
    local d <const> = graph.empty()
 
    for p in fs.scan_directory(dir, include, exclude) do