vcvars 0.1.0

data/lib/vcvars/environment.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+require "vcvars/locator"
+
+module Vcvars
+  # Captures the MSVC build environment produced by a vcvars*.bat script and
+  # imports it into the current process's ENV.
+  #
+  # vcvars cannot be "sourced" into a running process, so we run it inside a
+  # short-lived child cmd.exe, dump the resulting environment with `set`, and
+  # diff it against the current one. A unique marker line separates vcvars'
+  # banner noise from the `set` dump.
+  module Environment
+    module_function
+
+    MARKER = "___VCVARS_ENV_BEGIN___"
+
+    # Transient / shell-private variables that must never leak into the parent
+    # process. (Compared case-insensitively against upcased names.)
+    SKIP = %w[_ PROMPT ERRORLEVEL CMDCMDLINE].freeze
+
+    # True if a developer environment is already active in this process.
+    def active?
+      return true if ENV["VSCMD_VER"] && !ENV["VSCMD_VER"].empty?
+      cl_on_path?
+    end
+
+    def cl_on_path?
+      (ENV["PATH"] || "").split(File::PATH_SEPARATOR).any? do |dir|
+        !dir.empty? && File.exist?(File.join(dir, "cl.exe"))
+      end
+    end
+
+    # Locate VS, run vcvars, and import the resulting env into ENV.
+    # Idempotent: returns false (a no-op) when a dev env is already active,
+    # true when it actually activated. Pass force: true to re-import anyway.
+    def activate!(arch: Locator.default_arch, force: false)
+      return false if !force && active?
+
+      inst = Locator.find(arch: arch)
+      if inst.nil?
+        raise Error, "Could not find Visual Studio with the VC++ tools for " \
+          "arch #{arch.inspect}. Install the \"Desktop development with C++\" " \
+          "workload, or confirm vswhere.exe exists at #{Locator::VSWHERE}."
+      end
+
+      import!(capture(vcvars: inst.vcvars))
+      true
+    end
+
+    # The set of variables vcvars adds or changes relative to the current ENV
+    # (case-insensitive comparison). Does NOT mutate ENV. Handy for `vcvars env`.
+    def delta(arch: Locator.default_arch)
+      current = upcased_snapshot
+      captured = capture(arch: arch)
+      captured.reject do |k, v|
+        SKIP.include?(k.upcase) || current[k.upcase] == v
+      end
+    end
+
+    # Run vcvars in a child process and return the full captured environment
+    # as a Hash (does NOT mutate ENV). Provide an explicit vcvars path to skip
+    # location.
+    def capture(vcvars: nil, arch: Locator.default_arch)
+      vcvars ||= begin
+        inst = Locator.find(arch: arch)
+        raise Error, "Could not locate a vcvars batch script for arch #{arch.inspect}" if inst.nil?
+        inst.vcvars
+      end
+      raise Error, "vcvars script not found: #{vcvars}" unless File.exist?(vcvars)
+
+      out = run_capture_batch(vcvars)
+      parse_set_output(out)
+    end
+
+    # Parse the stdout of "<vcvars> ; echo MARKER ; set" into a Hash. Public so
+    # it can be unit-tested without invoking a real vcvars script.
+    def parse_set_output(out)
+      body = out.split(MARKER, 2)[1]
+      raise Error, "vcvars produced no environment (marker missing). " \
+        "Output head: #{out[0, 200].inspect}" if body.nil?
+
+      env = {}
+      body.each_line do |raw|
+        line = raw.chomp
+        i = line.index("=")
+        # Skip blank lines and Windows drive pseudo-vars ("=C:", "=ExitCode").
+        next if i.nil? || i.zero?
+        # Split on the FIRST "=" only — values legitimately contain "=".
+        env[line[0...i]] = line[(i + 1)..]
+      end
+
+      unless env.keys.any? { |k| k.casecmp("INCLUDE").zero? }
+        raise Error, "vcvars ran but did not set INCLUDE; the MSVC environment " \
+          "was not initialized (is the C++ workload installed?)."
+      end
+      env
+    end
+
+    # Import a captured env Hash into ENV: skip transient vars, and only write
+    # values that differ (case-insensitively) from the current ENV. Returns the
+    # hash. Public for testing.
+    def import!(env)
+      current = upcased_snapshot
+      env.each do |k, v|
+        next if SKIP.include?(k.upcase)
+        ENV[k] = v if current[k.upcase] != v
+      end
+      env
+    end
+
+    # --- internals -----------------------------------------------------------
+
+    def upcased_snapshot
+      snap = {}
+      ENV.each { |k, v| snap[k.upcase] = v }
+      snap
+    end
+
+    # Write a tiny batch that calls vcvars then dumps `set`, run it via a clean
+    # `cmd /c <file>` (a single unquoted token arg — avoids the embedded-quote
+    # escaping that breaks compound cmd lines on Windows), and return stdout.
+    def run_capture_batch(vcvars)
+      script = +"@echo off\r\n"
+      script << %{call "#{vcvars}"\r\n}
+      script << "echo #{MARKER}\r\n"
+      script << "set\r\n"
+
+      path = nil
+      begin
+        file = Tempfile.create(["vcvars_capture", ".bat"])
+        path = file.path
+        file.write(script)
+        file.close # must be closed before cmd.exe can read it on Windows
+
+        out, status = Open3.capture2("cmd.exe", "/c", path)
+        unless status.success?
+          raise Error, "vcvars batch exited #{status.exitstatus} (script: #{vcvars})"
+        end
+        out
+      ensure
+        File.unlink(path) if path && File.exist?(path)
+      end
+    end
+  end
+end

data/lib/vcvars/locator.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "open3"
+require "rbconfig"
+
+module Vcvars
+  # Finds a Visual Studio / Build Tools installation and the arch-specific
+  # vcvars batch script that activates the MSVC build environment.
+  #
+  # Strategy (most robust first):
+  #   1. `vswhere -find VC\Auxiliary\Build\<vcvars>.bat` — returns the script
+  #      path directly. This is used as the primary method because on some VS
+  #      layouts (observed on the VS "18" / 2026 line) `-property
+  #      installationPath` comes back empty, while `-find` still works.
+  #   2. `vswhere -property installationPath` + the known relative path.
+  #   3. `VSINSTALLDIR` (set when already inside a developer environment).
+  #   4. Scan well-known install roots (Program Files\Microsoft Visual Studio).
+  module Locator
+    module_function
+
+    VSWHERE = File.join(
+      ENV["ProgramFiles(x86)"] || 'C:\Program Files (x86)',
+      "Microsoft Visual Studio", "Installer", "vswhere.exe"
+    ).freeze
+
+    # Selects the newest STABLE install carrying the x64/x86 VC++ toolset.
+    # Prerelease/Insiders installs are only considered as a fallback (find
+    # retries with "-prerelease" appended), so a stable VS is preferred when
+    # both are present.
+    VSWHERE_SELECT = [
+      "-latest", "-products", "*",
+      "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64"
+    ].freeze
+
+    Installation = Struct.new(:vs_path, :vcvars, :arch, :version, :name, keyword_init: true) do
+      def to_s
+        "#{name || 'Visual Studio'}#{version ? " (#{version})" : ''} at #{vs_path}"
+      end
+    end
+
+    # The arch this Ruby was built for, e.g. "x64-mswin64_140".
+    def default_arch
+      RbConfig::CONFIG["arch"]
+    end
+
+    # Map a Ruby/target arch to the matching vcvars script name. The build host
+    # is assumed to be x64 (overwhelmingly true for Ruby on Windows), so arm64
+    # and x86 targets use the x64-hosted cross scripts.
+    def vcvars_name(arch)
+      case arch.to_s.downcase
+      when "x64", "amd64", "x86_64", /\Ax64\b/, /x86_64/, /amd64/ then "vcvars64.bat"
+      when "arm64", "aarch64", /arm64/, /aarch64/                 then "vcvarsamd64_arm64.bat"
+      when "x86", "i386", "i686", /\Ai\d86/, /\Ax86\b/            then "vcvars32.bat"
+      else
+        raise ArgumentError, "unsupported arch for vcvars: #{arch.inspect}"
+      end
+    end
+
+    # Returns an Installation, or nil if no suitable VS install is found.
+    # Memoized per arch within a process (the install location is stable).
+    def find(arch: default_arch)
+      @cache ||= {}
+      key = arch.to_s
+      return @cache[key] if @cache.key?(key)
+
+      @cache[key] = resolve(arch)
+    end
+
+    def resolve(arch)
+      name = vcvars_name(arch)
+
+      if File.exist?(VSWHERE)
+        # Prefer a stable install; only then consider prerelease/Insiders.
+        [VSWHERE_SELECT, VSWHERE_SELECT + ["-prerelease"]].each do |select|
+          inst = resolve_via_vswhere(select, name, arch)
+          return inst if inst
+        end
+      end
+
+      bat = resolve_via_env(name) || scan_known_roots(name)
+      return nil unless bat
+
+      Installation.new(vs_path: win(vs_root_from(bat)), vcvars: win(bat),
+                       arch: arch.to_s, version: nil, name: nil)
+    end
+
+    # Resolve a complete Installation from ONE vswhere selection, so the vcvars
+    # path and the reported metadata (version/name) describe the SAME install.
+    def resolve_via_vswhere(select, name, arch)
+      path = vswhere(select + ["-property", "installationPath"]).strip
+      bat = nil
+      unless path.empty?
+        cand = File.join(path, "VC", "Auxiliary", "Build", name)
+        bat = cand if File.exist?(cand)
+      end
+
+      # Some VS layouts return an empty installationPath; -find yields the path.
+      if bat.nil?
+        found = vswhere(select + ["-find", "VC\\Auxiliary\\Build\\#{name}"])
+        bat = found.lines.map(&:strip).find { |l| !l.empty? && File.exist?(l) }
+        return nil unless bat
+        path = vs_root_from(bat)
+      end
+
+      version = first_nonempty(
+        vswhere(select + ["-property", "installationVersion"]).strip,
+        vswhere(select + ["-property", "catalog_productDisplayVersion"]).strip
+      )
+      display = vswhere(select + ["-property", "displayName"]).strip
+
+      Installation.new(
+        vs_path: win(path),
+        vcvars:  win(bat),
+        arch:    arch.to_s,
+        version: version,
+        name:    display.empty? ? nil : display
+      )
+    end
+
+    # Normalize to native Windows separators for clean display (File.join mixes
+    # "/" into the backslash paths vswhere returns). Harmless for File.* / cmd.
+    def win(path)
+      path.nil? ? path : path.tr("/", "\\")
+    end
+
+    # The vcvars*.bat under VSINSTALLDIR (set inside an active dev env), or nil.
+    def resolve_via_env(name)
+      vsdir = ENV["VSINSTALLDIR"]
+      return nil if vsdir.nil? || vsdir.empty?
+
+      cand = File.join(vsdir, "VC", "Auxiliary", "Build", name)
+      File.exist?(cand) ? cand : nil
+    end
+
+    def first_nonempty(*values)
+      values.find { |v| v && !v.empty? }
+    end
+
+    def scan_known_roots(name)
+      bases = [ENV["ProgramFiles"], ENV["ProgramFiles(x86)"]].compact.uniq
+      # VS 2026 uses a numeric "18" directory; 2022/2019/2017 use the year.
+      versions = %w[18 2022 2019 2017]
+      editions = %w[Preview Enterprise Professional Community BuildTools]
+      bases.each do |pf|
+        root = File.join(pf, "Microsoft Visual Studio")
+        versions.each do |ver|
+          editions.each do |ed|
+            cand = File.join(root, ver, ed, "VC", "Auxiliary", "Build", name)
+            return cand if File.exist?(cand)
+          end
+        end
+      end
+      nil
+    end
+
+    # The install root is four levels up from <root>\VC\Auxiliary\Build\x.bat.
+    def vs_root_from(bat)
+      File.dirname(File.dirname(File.dirname(File.dirname(bat))))
+    end
+
+    # Run vswhere with the given args; returns stdout ("" on any failure).
+    # Args are passed as a real argv (no shell), so the literal "*" in
+    # "-products *" reaches vswhere instead of being glob-expanded.
+    def vswhere(args)
+      out, status = Open3.capture2(VSWHERE, *args)
+      status.success? ? out : ""
+    rescue StandardError
+      ""
+    end
+  end
+end

data/lib/vcvars/rake.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "vcvars"
+
+# Requiring this file auto-activates the MSVC build environment, so that
+# rake-compiler's `rake compile` (which hardcodes `nmake` and assumes cl.exe is
+# already on PATH) works without first opening a "Developer Command Prompt".
+#
+# Usage — put this BEFORE Rake::ExtensionTask.new in your Rakefile:
+#
+#   require "vcvars/rake"
+#   require "rake/extensiontask"
+#   Rake::ExtensionTask.new("my_ext", spec) { |e| e.lib_dir = "lib/my_ext" }
+#
+# It is a no-op off mswin Ruby, and a no-op inside an already-active developer
+# environment. rake-compiler shells out with FileUtils#sh, which inherits this
+# process's ENV, so activating once at Rakefile load time covers the extconf,
+# nmake build, and nmake install steps.
+if Vcvars.mswin?
+  begin
+    Vcvars.activate!
+  rescue Vcvars::Error => e
+    warn "[vcvars] could not load the MSVC environment: #{e.message}"
+    warn "[vcvars] run `vcvars doctor` to diagnose."
+  end
+end
+
+module Vcvars
+  # Optional belt-and-suspenders: call AFTER defining your compile task to also
+  # guarantee activation as a task dependency (covers sub-rake invocations that
+  # bypass the load-time activation above).
+  #
+  #   Rake::ExtensionTask.new("my_ext", spec)
+  #   Vcvars.enhance_compile_task!
+  def self.enhance_compile_task!(task_name = "compile")
+    return unless mswin?
+    return unless defined?(Rake) && Rake::Task.task_defined?(task_name)
+
+    Rake::Task.define_task("vcvars:activate") { Vcvars.activate! }
+    Rake::Task[task_name].enhance(["vcvars:activate"])
+  end
+end

data/lib/vcvars/scaffold.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "vcvars/version"
+
+module Vcvars
+  # Generates a new C-extension gem skeleton that is correct for an MSVC
+  # (mswin) Ruby: an MSVC-aware extconf.rb, a Rakefile wired to `vcvars/rake`
+  # (so `rake compile` works without a Developer Command Prompt), a
+  # warning-clean sample .c, and a passing test.
+  class Scaffold
+    NAME_RE = /\A[a-z][a-z0-9_]*\z/
+
+    attr_reader :name, :module_name, :dest
+
+    def initialize(name, dir: nil)
+      @name = name.to_s
+      unless @name =~ NAME_RE
+        raise Error, "invalid extension name #{name.inspect}: use lowercase " \
+          "letters, digits and underscores, starting with a letter (e.g. my_ext)."
+      end
+      @module_name = camelize(@name)
+      @dest = File.expand_path(dir || @name)
+    end
+
+    # Writes the skeleton. Returns the list of created file paths.
+    # Raises if the destination already contains files (unless force: true).
+    def generate(force: false)
+      if File.directory?(@dest) && !Dir.empty?(@dest) && !force
+        raise Error, "destination #{@dest} already exists and is not empty " \
+          "(pass force: true / --force to overwrite)."
+      end
+
+      created = []
+      files.each do |relpath, content|
+        full = File.join(@dest, relpath)
+        FileUtils.mkdir_p(File.dirname(full))
+        File.write(full, content)
+        created << full
+      end
+      created
+    end
+
+    # relpath => contents
+    def files
+      {
+        "#{name}.gemspec"               => render(GEMSPEC),
+        "Gemfile"                       => render(GEMFILE),
+        "Rakefile"                      => render(RAKEFILE),
+        "README.md"                     => render(README),
+        "LICENSE.txt"                   => render(LICENSE),
+        ".gitignore"                    => render(GITIGNORE),
+        "lib/#{name}.rb"                => render(LIB_ENTRY),
+        "lib/#{name}/version.rb"        => render(LIB_VERSION),
+        "ext/#{name}/extconf.rb"        => render(EXTCONF),
+        "ext/#{name}/#{name}.c"         => render(EXT_C),
+        "test/test_#{name}.rb"          => render(TEST)
+      }
+    end
+
+    private
+
+    def camelize(str)
+      str.split("_").map { |p| p.empty? ? p : (p[0].upcase + p[1..]) }.join
+    end
+
+    def render(template)
+      template
+        .gsub("{{name}}", name)
+        .gsub("{{Name}}", module_name)
+        .gsub("{{vcvars_version}}", Vcvars::VERSION)
+    end
+
+    # --- templates -----------------------------------------------------------
+
+    GEMSPEC = <<~'RUBY'
+      # frozen_string_literal: true
+
+      require_relative "lib/{{name}}/version"
+
+      Gem::Specification.new do |spec|
+        spec.name        = "{{name}}"
+        spec.version     = {{Name}}::VERSION
+        spec.authors     = ["Your Name"]
+        spec.email       = ["you@example.com"]
+        spec.summary     = "A native C extension for Ruby."
+        # NOTE: RubyGems rejects a description that begins with TODO/FIXME, so
+        # this ships as a valid placeholder — edit it, don't prefix it with TODO.
+        spec.description = "The {{name}} native C extension for Ruby, scaffolded by vcvars."
+        spec.homepage    = "https://example.com/{{name}}"
+        spec.license     = "MIT"
+        spec.required_ruby_version = ">= 3.0"
+
+        spec.files = Dir.glob(["lib/**/*.rb", "ext/**/*.{c,h,rb}", "README.md", "LICENSE*"])
+        spec.require_paths = ["lib"]
+
+        # Build the extension from source on `gem install`.
+        spec.extensions = ["ext/{{name}}/extconf.rb"]
+
+        spec.add_development_dependency "rake"
+        spec.add_development_dependency "rake-compiler"
+        spec.add_development_dependency "minitest"
+        # vcvars loads the MSVC toolchain so `rake compile` works on an mswin Ruby.
+        spec.add_development_dependency "vcvars", ">= {{vcvars_version}}"
+      end
+    RUBY
+
+    GEMFILE = <<~'RUBY'
+      # frozen_string_literal: true
+
+      source "https://rubygems.org"
+
+      gemspec
+    RUBY
+
+    RAKEFILE = <<~'RUBY'
+      # frozen_string_literal: true
+
+      require "vcvars/rake"        # loads the MSVC build env on mswin Ruby (no-op elsewhere)
+      require "rake/extensiontask"
+      require "rake/testtask"
+
+      spec = Gem::Specification.load("{{name}}.gemspec")
+
+      Rake::ExtensionTask.new("{{name}}", spec) do |ext|
+        ext.lib_dir = "lib/{{name}}"   # built {{name}}.so lands at lib/{{name}}/{{name}}.so
+      end
+
+      Rake::TestTask.new(test: :compile) do |t|
+        t.libs << "test" << "lib"
+        t.test_files = FileList["test/**/test_*.rb"]
+        t.warning = false
+      end
+
+      task default: :test
+    RUBY
+
+    LIB_ENTRY = <<~'RUBY'
+      # frozen_string_literal: true
+
+      require "{{name}}/version"
+      require "{{name}}/{{name}}"   # the compiled C extension (lib/{{name}}/{{name}}.so)
+
+      module {{Name}}
+      end
+    RUBY
+
+    LIB_VERSION = <<~'RUBY'
+      # frozen_string_literal: true
+
+      module {{Name}}
+        VERSION = "0.1.0"
+      end
+    RUBY
+
+    EXTCONF = <<~'RUBY'
+      # frozen_string_literal: true
+      #
+      # extconf.rb for the {{name}} C extension.
+      #
+      # mkmf reads RbConfig and emits the right Makefile per platform. On an
+      # MSVC (mswin) Ruby it generates an *nmake* Makefile whose compile line is
+      # "cl -nologo $(INCFLAGS) -MD ... -Fo$(@) -c -Tc<src>". The -MD (dynamic
+      # CRT) flag is baked into RbConfig, so every object links against the same
+      # CRT as Ruby. NEVER force -MT/-MTd: a static-CRT extension mixed with
+      # Ruby's dynamic CRT causes LNK2005 duplicate symbols and heap corruption.
+      #
+      # The Ruby import library (e.g. x64-vcruntime140-ruby340.lib) is added to
+      # the link line automatically — you do not name or locate it here.
+
+      require "mkmf"
+
+      # Optional: wrap an external library (adds --with-foo-dir/-include/-lib,
+      # and is mswin-aware: -I to $INCFLAGS, -libpath: to $LIBPATH).
+      #   dir_config("foo")
+      #   have_header("foo.h") or abort "missing foo.h"
+      #   have_library("foo", "foo_init") or abort "missing foo.lib"  # bare name; no -l on mswin
+
+      # append_cflags probes each flag with warnings-as-errors; cl rejects
+      # GCC-style flags like -std=gnu11, so this is a safe no-op on MSVC and only
+      # applies on gcc/clang (MinGW/UCRT/Unix).
+      append_cflags(["-std=c11"])
+
+      # "{{name}}/{{name}}" installs the .so under {{name}}/ so it can be required
+      # as "{{name}}/{{name}}". On mswin the artifact is {{name}}.so (DLEXT is "so").
+      create_makefile("{{name}}/{{name}}")
+    RUBY
+
+    EXT_C = <<~'C'
+      #include <ruby.h>
+
+      /*
+       * On mswin Ruby the Init_ entry point is exported automatically by mkmf via
+       * an auto-generated .def file passed to the linker — do NOT add
+       * __declspec(dllexport)/RUBY_FUNC_EXPORTED here.
+       *
+       * Ruby's CFLAGS promote several warnings to errors (-we4028 -we4047 -we4013
+       * -we4142). Including <ruby.h>, using correct VALUE signatures, the
+       * RUBY_METHOD_FUNC cast, and the NUM2INT/INT2NUM + rb_str_* APIs keeps the
+       * build warning- and error-clean. Unused params (C4100) are suppressed by
+       * Ruby's own flags, so an unused `self` is fine.
+       */
+
+      /* Adds two integers and returns the sum. */
+      static VALUE
+      {{name}}_add(VALUE self, VALUE a, VALUE b)
+      {
+          int x = NUM2INT(a);
+          int y = NUM2INT(b);
+          return INT2NUM(x + y);
+      }
+
+      /* Returns a greeting string for the given name. */
+      static VALUE
+      {{name}}_greet(VALUE self, VALUE name)
+      {
+          VALUE who = StringValue(name);          /* validate/coerce to String */
+          VALUE out = rb_str_new_cstr("Hello, ");
+          rb_str_append(out, who);
+          rb_str_cat_cstr(out, "!");
+          return out;
+      }
+
+      void
+      Init_{{name}}(void)
+      {
+          VALUE m{{Name}} = rb_define_module("{{Name}}");
+          rb_define_singleton_method(m{{Name}}, "add",   RUBY_METHOD_FUNC({{name}}_add),   2);
+          rb_define_singleton_method(m{{Name}}, "greet", RUBY_METHOD_FUNC({{name}}_greet), 1);
+      }
+    C
+
+    TEST = <<~'RUBY'
+      # frozen_string_literal: true
+
+      require "minitest/autorun"
+      require "{{name}}"
+
+      class {{Name}}Test < Minitest::Test
+        def test_add
+          assert_equal 5, {{Name}}.add(2, 3)
+          assert_equal(-1, {{Name}}.add(2, -3))
+        end
+
+        def test_greet
+          assert_equal "Hello, Ruby!", {{Name}}.greet("Ruby")
+        end
+      end
+    RUBY
+
+    README = <<~'MARKDOWN'
+      # {{name}}
+
+      A native C extension for Ruby, scaffolded by [vcvars](https://rubygems.org/gems/vcvars).
+
+      ## Build & test
+
+      On an MSVC (mswin) Ruby you do **not** need to open a Developer Command
+      Prompt — the `Rakefile` requires `vcvars/rake`, which locates Visual Studio
+      and loads the MSVC toolchain automatically.
+
+      ```sh
+      bundle install
+      rake compile   # builds ext/{{name}}/{{name}}.c -> lib/{{name}}/{{name}}.so
+      rake test
+      ```
+
+      If a build fails, run `vcvars doctor` to diagnose the toolchain.
+
+      ## Usage
+
+      ```ruby
+      require "{{name}}"
+
+      {{Name}}.add(2, 3)      # => 5
+      {{Name}}.greet("Ruby")  # => "Hello, Ruby!"
+      ```
+    MARKDOWN
+
+    LICENSE = <<~'TEXT'
+      MIT License
+
+      Copyright (c) 2026 Your Name
+
+      Permission is hereby granted, free of charge, to any person obtaining a copy
+      of this software and associated documentation files (the "Software"), to deal
+      in the Software without restriction, including without limitation the rights
+      to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+      copies of the Software, and to permit persons to whom the Software is
+      furnished to do so, subject to the following conditions:
+
+      The above copyright notice and this permission notice shall be included in all
+      copies or substantial portions of the Software.
+
+      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+      OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+      SOFTWARE.
+    TEXT
+
+    GITIGNORE = <<~'TEXT'
+      /pkg/
+      /tmp/
+      /.bundle/
+      Gemfile.lock
+
+      # build artifacts
+      *.o
+      *.obj
+      *.so
+      *.dll
+      *.lib
+      *.exp
+      *.pdb
+      *.def
+      Makefile
+      mkmf.log
+      /lib/{{name}}/{{name}}.so
+    TEXT
+  end
+end

data/lib/vcvars/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Vcvars
+  VERSION = "0.1.0"
+end