mt-lang 0.2.0

data/lib/milk_tea/bindings/vendored_c_library.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "pathname"
+require "shellwords"
+
+module MilkTea
+  module VendoredCLibrary
+    class Error < RawBindings::Error; end
+
+    class Base
+      attr_reader :name, :source_root, :include_roots
+
+      def initialize(name:, source_root:, include_roots: [], cc_env_var: nil)
+        @name = name.to_s
+        @source_root = Pathname.new(File.expand_path(source_root.to_s))
+        @include_roots = include_roots.map { |path| Pathname.new(File.expand_path(path.to_s)) }.freeze
+        @cc_env_var = cc_env_var
+      end
+
+      def include_flags
+        include_roots.map { |path| "-I#{path}" }
+      end
+
+      def build_flags(platform: nil)
+        include_flags
+      end
+
+      def prepare!(env: ENV, cc: ENV.fetch("CC", "cc"), platform: nil)
+        raise NotImplementedError, "#{self.class} must implement #prepare!"
+      end
+
+      def link_flags(platform: nil)
+        raise NotImplementedError, "#{self.class} must implement #link_flags"
+      end
+
+      private
+
+      def resolved_cc(env, default_cc)
+        return default_cc unless @cc_env_var
+
+        env.fetch(@cc_env_var, default_cc)
+      end
+
+      def signature_path(root)
+        root.join(".milk-tea-signature")
+      end
+
+      def read_signature(root)
+        path = signature_path(root)
+        return unless File.exist?(path)
+
+        File.read(path)
+      end
+
+      def write_signature(root, value)
+        File.write(signature_path(root), value)
+      end
+
+      def newest_tree_file_mtime(root)
+        Dir.glob(File.join(root.to_s, "**", "*"))
+          .select { |path| File.file?(path) }
+          .map { |path| File.mtime(path) }
+          .max
+      end
+
+      def command_error(label, stdout, stderr)
+        details = [stdout, stderr].reject(&:empty?).join
+        details.empty? ? label : "#{label}:\n#{details}"
+      end
+
+      def tool_not_found(error)
+        Error.new("tool not found while building vendored #{name}: #{error.message}")
+      end
+    end
+
+    class Archive < Base
+      attr_reader :build_root, :archive_path, :sources, :defines
+
+      def initialize(name:, source_root:, build_root:, archive_name:, sources:, include_roots: [], defines: [], system_link_flags: [], cc_env_var: nil, c_flags: [], cxx_env_var: nil, cxx_flags: [], ar_env_var: nil, default_ar: "ar")
+        resolved_include_roots = include_roots.empty? ? [source_root] : include_roots
+        super(name:, source_root:, include_roots: resolved_include_roots, cc_env_var:)
+        @build_root = Pathname.new(File.expand_path(build_root.to_s))
+        @archive_path = @build_root.join(archive_name)
+        @sources = sources.dup.freeze
+        @defines = defines.dup.freeze
+        @system_link_flags = system_link_flags.dup.freeze
+        @c_flags = c_flags.dup.freeze
+        @cxx_env_var = cxx_env_var
+        @cxx_flags = cxx_flags.dup.freeze
+        @ar_env_var = ar_env_var
+        @default_ar = default_ar
+      end
+
+      def link_flags(platform: nil)
+        ["-L#{build_root}", *@system_link_flags]
+      end
+
+      def build_flags(platform: nil)
+        [*include_flags, *defines.map { |define| "-D#{define}" }].uniq
+      end
+
+      def prepare!(env: ENV, cc: ENV.fetch("CC", "cc"), cxx: ENV.fetch("CXX", "c++"), platform: nil)
+        resolved_cc = resolved_cc(env, cc)
+        resolved_cxx = resolved_cxx(env, cxx)
+        resolved_ar = env.fetch(@ar_env_var || "AR", @default_ar)
+        signature = configuration_signature(cc: resolved_cc, cxx: resolved_cxx, ar: resolved_ar)
+        signature_changed = signature != read_signature(build_root)
+
+        FileUtils.mkdir_p(build_root)
+        object_paths = sources.map do |source|
+          build_object(source, cc: resolved_cc, cxx: resolved_cxx, force_rebuild: signature_changed)
+        end
+        if !signature_changed && archive_up_to_date?(object_paths)
+          ensure_archive_index(ar: resolved_ar)
+          return archive_path.to_s
+        end
+
+        stdout, stderr, status = Open3.capture3(resolved_ar, "rcs", archive_path.to_s, *object_paths)
+        unless status.success?
+          raise Error, command_error("failed to archive vendored #{name}", stdout, stderr)
+        end
+        ensure_archive_index(ar: resolved_ar)
+
+        write_signature(build_root, signature)
+        archive_path.to_s
+      rescue Errno::ENOENT => e
+        raise tool_not_found(e)
+      end
+
+      private
+
+      def configuration_signature(cc:, cxx:, ar:)
+        [cc, cxx, ar, *include_flags, *defines, *@c_flags, *@cxx_flags].join("\0")
+      end
+
+      def resolved_cxx(env, default_cxx)
+        return default_cxx unless @cxx_env_var
+
+        env.fetch(@cxx_env_var, default_cxx)
+      end
+
+      def build_object(source, cc:, cxx:, force_rebuild:)
+        source_path = source_root.join(source)
+        object_path = build_root.join(source.sub(/\.(?:c|cc|cpp|cxx)\z/, ".o"))
+        if !force_rebuild && File.exist?(object_path) && File.size?(object_path) && File.mtime(object_path) >= File.mtime(source_path)
+          return object_path.to_s
+        end
+
+        FileUtils.mkdir_p(object_path.dirname)
+
+        compiler, language_flags = compiler_for_source(source, cc:, cxx:)
+
+        command = [
+          compiler,
+          "-c",
+          source_path.to_s,
+          *language_flags,
+          *include_flags,
+          *defines.map { |define| "-D#{define}" },
+          "-o",
+          object_path.to_s,
+        ]
+        stdout, stderr, status = Open3.capture3(*command)
+        unless status.success?
+          FileUtils.rm_f(object_path)
+          raise Error, command_error("failed to compile vendored #{name} source #{source}", stdout, stderr)
+        end
+
+        object_path.to_s
+      end
+
+      def compiler_for_source(source, cc:, cxx:)
+        case File.extname(source)
+        when ".cc", ".cpp", ".cxx"
+          [cxx, @cxx_flags]
+        else
+          [cc, @c_flags]
+        end
+      end
+
+      def ensure_archive_index(ar:)
+        stdout, stderr, status = Open3.capture3(ar, "s", archive_path.to_s)
+        unless status.success?
+          raise Error, command_error("failed to index vendored #{name} archive", stdout, stderr)
+        end
+      end
+
+      def archive_up_to_date?(object_paths)
+        return false unless File.exist?(archive_path)
+
+        archive_mtime = File.mtime(archive_path)
+        object_paths.all? { |path| File.mtime(path) <= archive_mtime }
+      end
+    end
+
+    class CMake < Base
+      attr_reader :build_root, :install_root, :archive_path
+
+      def initialize(name:, source_root:, build_root:, install_root:, archive_path:, include_roots: [], configure_args: [], build_target: "install", system_link_flags: [], pkg_config_name: nil, cc_env_var: nil, cmake_env_var: nil)
+        super(name:, source_root:, include_roots:, cc_env_var:)
+        @build_root = Pathname.new(File.expand_path(build_root.to_s))
+        @install_root = Pathname.new(File.expand_path(install_root.to_s))
+        @archive_path = Pathname.new(File.expand_path(archive_path.to_s))
+        @configure_args = configure_args.dup.freeze
+        @build_target = build_target
+        @system_link_flags = system_link_flags.dup.freeze
+        @pkg_config_name = pkg_config_name
+        @cmake_env_var = cmake_env_var
+      end
+
+      def link_flags(platform: nil)
+        ["-L#{archive_path.dirname}", *pkg_config_link_flags, *@system_link_flags].uniq
+      end
+
+      def build_flags(platform: nil)
+        include_flags
+      end
+
+      def prepare!(env: ENV, cc: ENV.fetch("CC", "cc"), platform: nil)
+        resolved_cc = resolved_cc(env, cc)
+        resolved_cmake = env.fetch(@cmake_env_var || "CMAKE", "cmake")
+        signature = configuration_signature(cc: resolved_cc, cmake: resolved_cmake)
+        needs_configure = signature != read_signature(build_root) || !File.exist?(build_root.join("CMakeCache.txt"))
+        needs_build = !archive_up_to_date?
+        return archive_path.to_s unless needs_configure || needs_build
+
+        FileUtils.mkdir_p(build_root)
+        FileUtils.mkdir_p(install_root)
+        configure(cmake: resolved_cmake, cc: resolved_cc)
+        build(cmake: resolved_cmake)
+        unless File.exist?(archive_path)
+          raise Error, "failed to build vendored #{name}: missing #{archive_path}"
+        end
+
+        write_signature(build_root, signature)
+        archive_path.to_s
+      rescue Errno::ENOENT => e
+        raise tool_not_found(e)
+      end
+
+      private
+
+      def configuration_signature(cc:, cmake:)
+        [cmake, cc, install_root.to_s, *include_flags, *@configure_args, @build_target].join("\0")
+      end
+
+      def archive_up_to_date?
+        return false unless File.exist?(archive_path)
+
+        newest_source_mtime = newest_tree_file_mtime(source_root)
+        return true unless newest_source_mtime
+
+        newest_source_mtime <= File.mtime(archive_path)
+      end
+
+      def configure(cmake:, cc:)
+        command = [
+          cmake,
+          "-S",
+          source_root.to_s,
+          "-B",
+          build_root.to_s,
+          "-G",
+          "Ninja",
+          "-DCMAKE_INSTALL_PREFIX=#{install_root}",
+          *@configure_args,
+        ]
+        stdout, stderr, status = Open3.capture3({ "CC" => cc }, *command)
+        unless status.success?
+          raise Error, command_error("failed to configure vendored #{name}", stdout, stderr)
+        end
+      end
+
+      def build(cmake:)
+        command = [cmake, "--build", build_root.to_s, "--target", @build_target]
+        stdout, stderr, status = Open3.capture3(*command)
+        unless status.success?
+          raise Error, command_error("failed to build vendored #{name}", stdout, stderr)
+        end
+      end
+
+      def pkg_config_link_flags
+        return [] unless @pkg_config_name
+
+        path = install_root.join("lib/pkgconfig/#{@pkg_config_name}.pc")
+        return [] unless File.exist?(path)
+
+        lines = File.readlines(path, chomp: true)
+        variables = pkg_config_variables(lines)
+        lines.filter_map do |line|
+          line.split(":", 2).last&.strip if line.start_with?("Libs:", "Libs.private:")
+        end.flat_map do |value|
+          Shellwords.split(expand_pkg_config_value(value, variables))
+        end
+      end
+
+      def pkg_config_variables(lines)
+        variables = {
+          "prefix" => install_root.to_s,
+          "exec_prefix" => install_root.to_s,
+          "libdir" => archive_path.dirname.to_s,
+          "includedir" => install_root.join("include").to_s,
+        }
+
+        lines.each do |line|
+          next if line.empty? || line.start_with?("#") || line.include?(":") || !line.include?("=")
+
+          key, value = line.split("=", 2)
+          variables[key] = expand_pkg_config_value(value, variables)
+        end
+
+        variables
+      end
+
+      def expand_pkg_config_value(value, variables)
+        value.gsub(/\$\{([^}]+)\}/) { variables.fetch(Regexp.last_match(1), "") }
+      end
+    end
+  end
+end

data/lib/milk_tea/bindings/vendored_cjson.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module VendoredCJSON
+    Error = VendoredCLibrary::Error
+
+    SOURCES = %w[
+      cJSON.c
+    ].freeze
+
+    SYSTEM_LINK_FLAGS = %w[
+      -lm
+    ].freeze
+
+    module_function
+
+    def library(root: MilkTea.root)
+      resolved_root = Pathname.new(File.expand_path(root.to_s))
+      @libraries ||= {}
+      @libraries[resolved_root.to_s] ||= VendoredCLibrary::Archive.new(
+        name: "cjson",
+        source_root: source_root(root: resolved_root),
+        build_root: build_root(root: resolved_root),
+        archive_name: "libcjson.a",
+        sources: SOURCES,
+        include_roots: [source_root(root: resolved_root)],
+        system_link_flags: SYSTEM_LINK_FLAGS,
+        cc_env_var: "CJSON_CC",
+      )
+    end
+
+    def source_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("third_party/cjson-upstream")
+    end
+
+    def build_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("tmp/vendored-cjson")
+    end
+
+    def archive_path(root: MilkTea.root)
+      build_root(root:).join("libcjson.a")
+    end
+
+    def link_flags(root: MilkTea.root)
+      library(root:).link_flags
+    end
+
+    def prepare!(root: MilkTea.root, **kwargs)
+      library(root:).prepare!(**kwargs)
+    end
+  end
+end

data/lib/milk_tea/bindings/vendored_flecs.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module VendoredFlecs
+    Error = VendoredCLibrary::Error
+    SOURCE_NAME = "flecs"
+
+    SOURCES = %w[
+      distr/flecs.c
+    ].freeze
+
+    SYSTEM_LINK_FLAGS = %w[
+      -lrt
+      -lpthread
+      -lm
+    ].freeze
+
+    C_FLAGS = %w[
+      -std=gnu99
+    ].freeze
+
+    module_function
+
+    def source(root: MilkTea.root)
+      UpstreamSources.default_sources(root:).find { |entry| entry.name == SOURCE_NAME } ||
+        raise(Error, "missing upstream source definition for #{SOURCE_NAME}")
+    end
+
+    def library(root: MilkTea.root)
+      resolved_root = Pathname.new(File.expand_path(root.to_s))
+      @libraries ||= {}
+      @libraries[resolved_root.to_s] ||= VendoredCLibrary::Archive.new(
+        name: "flecs",
+        source_root: source_root(root: resolved_root),
+        build_root: build_root(root: resolved_root),
+        archive_name: "libflecs.a",
+        sources: SOURCES,
+        include_roots: [include_root(root: resolved_root)],
+        system_link_flags: SYSTEM_LINK_FLAGS,
+        cc_env_var: "FLECS_CC",
+        c_flags: C_FLAGS,
+      )
+    end
+
+    def source_root(root: MilkTea.root)
+      source(root:).checkout_root
+    end
+
+    def include_root(root: MilkTea.root)
+      source_root(root:).join("distr")
+    end
+
+    def header_path(root: MilkTea.root)
+      include_root(root:).join("flecs.h")
+    end
+
+    def build_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("tmp/vendored-flecs")
+    end
+
+    def archive_path(root: MilkTea.root)
+      build_root(root:).join("libflecs.a")
+    end
+
+    def include_flags(root: MilkTea.root)
+      library(root:).include_flags
+    end
+
+    def link_flags(root: MilkTea.root)
+      library(root:).link_flags
+    end
+
+    def prepare!(root: MilkTea.root, **kwargs)
+      source(root:).bootstrap!
+      library(root:).prepare!(**kwargs)
+    end
+  end
+end

data/lib/milk_tea/bindings/vendored_glfw.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module VendoredGLFW
+    Error = VendoredCLibrary::Error
+    SOURCE_NAME = "glfw"
+
+    CONFIGURE_ARGS = %w[
+      -DCMAKE_BUILD_TYPE=Release
+      -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+      -DBUILD_SHARED_LIBS=OFF
+      -DGLFW_BUILD_EXAMPLES=OFF
+      -DGLFW_BUILD_TESTS=OFF
+      -DGLFW_BUILD_DOCS=OFF
+    ].freeze
+
+    module_function
+
+    def source(root: MilkTea.root)
+      UpstreamSources.default_sources(root:).find { |entry| entry.name == SOURCE_NAME } ||
+        raise(Error, "missing upstream source definition for #{SOURCE_NAME}")
+    end
+
+    def library(root: MilkTea.root)
+      resolved_root = Pathname.new(File.expand_path(root.to_s))
+      @libraries ||= {}
+      @libraries[resolved_root.to_s] ||= VendoredCLibrary::CMake.new(
+        name: "glfw",
+        source_root: source_root(root: resolved_root),
+        build_root: build_root(root: resolved_root),
+        install_root: install_root(root: resolved_root),
+        archive_path: archive_path(root: resolved_root),
+        include_roots: [include_root(root: resolved_root)],
+        configure_args: CONFIGURE_ARGS,
+        pkg_config_name: "glfw3",
+        cc_env_var: "GLFW_CC",
+      )
+    end
+
+    def source_root(root: MilkTea.root)
+      source(root:).checkout_root
+    end
+
+    def include_root(root: MilkTea.root)
+      source_root(root:).join("include")
+    end
+
+    def header_root(root: MilkTea.root)
+      include_root(root:).join("GLFW")
+    end
+
+    def build_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("tmp/vendored-glfw")
+    end
+
+    def install_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("tmp/vendored-glfw-prefix")
+    end
+
+    def archive_path(root: MilkTea.root)
+      install_root(root:).join("lib/libglfw3.a")
+    end
+
+    def include_flags(root: MilkTea.root)
+      library(root:).include_flags
+    end
+
+    def link_flags(root: MilkTea.root)
+      library(root:).link_flags
+    end
+
+    def prepare!(root: MilkTea.root, **kwargs)
+      source(root:).bootstrap!
+      library(root:).prepare!(**kwargs)
+    end
+  end
+end

data/lib/milk_tea/bindings/vendored_libuv.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module VendoredLibUV
+    Error = VendoredCLibrary::Error
+    SOURCE_NAME = "libuv"
+
+    CONFIGURE_ARGS = %w[
+      -DCMAKE_BUILD_TYPE=Release
+      -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+      -DBUILD_SHARED_LIBS=OFF
+      -DBUILD_TESTING=OFF
+    ].freeze
+
+    module_function
+
+    def source(root: MilkTea.root)
+      UpstreamSources.default_sources(root:).find { |entry| entry.name == SOURCE_NAME } ||
+        raise(Error, "missing upstream source definition for #{SOURCE_NAME}")
+    end
+
+    def library(root: MilkTea.root)
+      resolved_root = Pathname.new(File.expand_path(root.to_s))
+      @libraries ||= {}
+      @libraries[resolved_root.to_s] ||= VendoredCLibrary::CMake.new(
+        name: "libuv",
+        source_root: source_root(root: resolved_root),
+        build_root: build_root(root: resolved_root),
+        install_root: install_root(root: resolved_root),
+        archive_path: archive_path(root: resolved_root),
+        include_roots: [include_root(root: resolved_root)],
+        configure_args: CONFIGURE_ARGS,
+        pkg_config_name: "libuv-static",
+        cc_env_var: "LIBUV_CC",
+      )
+    end
+
+    def source_root(root: MilkTea.root)
+      source(root:).checkout_root
+    end
+
+    def include_root(root: MilkTea.root)
+      source_root(root:).join("include")
+    end
+
+    def header_path(root: MilkTea.root)
+      include_root(root:).join("uv.h")
+    end
+
+    def build_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("tmp/vendored-libuv")
+    end
+
+    def install_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("tmp/vendored-libuv-prefix")
+    end
+
+    def archive_path(root: MilkTea.root)
+      install_root(root:).join("lib/libuv.a")
+    end
+
+    def include_flags(root: MilkTea.root)
+      library(root:).include_flags
+    end
+
+    def link_flags(root: MilkTea.root)
+      library(root:).link_flags
+    end
+
+    def prepare!(root: MilkTea.root, **kwargs)
+      source(root:).bootstrap!
+      library(root:).prepare!(**kwargs)
+    end
+  end
+end

data/lib/milk_tea/bindings/vendored_pcre2.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module VendoredPCRE2
+    Error = VendoredCLibrary::Error
+    SOURCE_NAME = "pcre2"
+
+    CONFIGURE_ARGS = %w[
+      -DCMAKE_BUILD_TYPE=Release
+      -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+      -DBUILD_SHARED_LIBS=OFF
+      -DPCRE2_BUILD_PCRE2_8=ON
+      -DPCRE2_BUILD_PCRE2_16=OFF
+      -DPCRE2_BUILD_PCRE2_32=OFF
+      -DPCRE2_BUILD_PCRE2GREP=OFF
+      -DPCRE2_BUILD_PCRE2TEST=OFF
+      -DPCRE2_BUILD_TESTS=OFF
+    ].freeze
+
+    SYSTEM_LINK_FLAGS = %w[
+      -lm
+    ].freeze
+
+    module_function
+
+    def source(root: MilkTea.root)
+      UpstreamSources.default_sources(root:).find { |entry| entry.name == SOURCE_NAME } ||
+        raise(Error, "missing upstream source definition for #{SOURCE_NAME}")
+    end
+
+    def library(root: MilkTea.root)
+      resolved_root = Pathname.new(File.expand_path(root.to_s))
+      @libraries ||= {}
+      @libraries[resolved_root.to_s] ||= VendoredCLibrary::CMake.new(
+        name: "pcre2",
+        source_root: source_root(root: resolved_root),
+        build_root: build_root(root: resolved_root),
+        install_root: install_root(root: resolved_root),
+        archive_path: archive_path(root: resolved_root),
+        include_roots: [include_root(root: resolved_root)],
+        configure_args: CONFIGURE_ARGS,
+        system_link_flags: SYSTEM_LINK_FLAGS,
+        cc_env_var: "PCRE2_CC",
+      )
+    end
+
+    def source_root(root: MilkTea.root)
+      source(root:).checkout_root
+    end
+
+    def include_root(root: MilkTea.root)
+      install_root(root:).join("include")
+    end
+
+    def header_path(root: MilkTea.root)
+      include_root(root:).join("pcre2.h")
+    end
+
+    def build_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("tmp/vendored-pcre2")
+    end
+
+    def install_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("tmp/vendored-pcre2-prefix")
+    end
+
+    def archive_path(root: MilkTea.root)
+      install_root(root:).join("lib/libpcre2-8.a")
+    end
+
+    def include_flags(root: MilkTea.root)
+      library(root:).include_flags
+    end
+
+    def link_flags(root: MilkTea.root)
+      library(root:).link_flags
+    end
+
+    def prepare!(root: MilkTea.root, **kwargs)
+      source(root:).bootstrap!
+      library(root:).prepare!(**kwargs)
+    end
+  end
+end