Extract platform-specifics from ENV to Crystal::System::Env and implement for win32

spec/std/env_spec.cr

@@ -52,19 +52,19 @@ describe "ENV" do
 
   describe "[]=" do
     it "disallows NUL-bytes in key" do
-      expect_raises(ArgumentError, "Key contains null byte") do
+      expect_raises(ArgumentError, "String `key` contains null byte") do
         ENV["FOO\0BAR"] = "something"
       end
     end
 
     it "disallows NUL-bytes in key if value is nil" do
-      expect_raises(ArgumentError, "Key contains null byte") do
+      expect_raises(ArgumentError, "String `key` contains null byte") do
         ENV["FOO\0BAR"] = nil
       end
     end
 
     it "disallows NUL-bytes in value" do
-      expect_raises(ArgumentError, "Value contains null byte") do
+      expect_raises(ArgumentError, "String `value` contains null byte") do
         ENV["FOO"] = "BAR\0BAZ"
       end
     end
@@ -95,4 +95,22 @@ describe "ENV" do
       end
     end
   end
+
+  it "handles unicode" do
+    ENV["TEST_UNICODE_1"] = "bar\u{d7ff}\u{10000}"
+    ENV["TEST_UNICODE_2"] = "\u{1234}"
+    ENV["TEST_UNICODE_1"].should eq "bar\u{d7ff}\u{10000}"
+    ENV["TEST_UNICODE_2"].should eq "\u{1234}"
+
+    values = {} of String => String
+    ENV.each do |key, value|
+      if key.starts_with?("TEST_UNICODE_")
+        values[key] = value
+      end
+    end
+    values.should eq({
+      "TEST_UNICODE_1" => "bar\u{d7ff}\u{10000}",
+      "TEST_UNICODE_2" => "\u{1234}",
+    })
+  end
 end

spec/std/string/utf16_spec.cr

@@ -23,31 +23,50 @@ describe "String UTF16" do
     end
   end
 
-  describe "from_utf16" do
+  describe ".from_utf16" do
     it "in the range U+0000..U+D7FF" do
       input = Slice[0_u16, 0x68_u16, 0x65_u16, 0x6c_u16, 0x6c_u16, 0x6f_u16, 0xd7ff_u16]
       String.from_utf16(input).should eq("\u{0}hello\u{d7ff}")
+      String.from_utf16(input.to_unsafe).should eq({"", input.to_unsafe + 1})
     end
 
     it "in the range U+E000 to U+FFFF" do
       input = Slice[0xe000_u16, 0xffff_u16]
       String.from_utf16(input).should eq("\u{e000}\u{ffff}")
+
+      pointer = Slice[0xe000_u16, 0xffff_u16, 0_u16].to_unsafe
+      String.from_utf16(pointer).should eq({"\u{e000}\u{ffff}", pointer + 3})
     end
 
     it "in the range U+10000..U+10FFFF" do
       input = Slice[0xd800_u16, 0xdc00_u16]
       String.from_utf16(input).should eq("\u{10000}")
+
+      pointer = Slice[0xd800_u16, 0xdc00_u16, 0_u16].to_unsafe
+      String.from_utf16(pointer).should eq({"\u{10000}", pointer + 3})
     end
 
     it "in the range U+D800..U+DFFF" do
       input = Slice[0xdc00_u16, 0xd800_u16]
       String.from_utf16(input).should eq("\u{fffd}\u{fffd}")
+
+      pointer = Slice[0xdc00_u16, 0xd800_u16, 0_u16].to_unsafe
+      String.from_utf16(pointer).should eq({"\u{fffd}\u{fffd}", pointer + 3})
     end
 
     it "handles null bytes" do
       slice = Slice[104_u16, 105_u16, 0_u16, 55296_u16, 56485_u16]
       String.from_utf16(slice).should eq("hi\0000𐂥")
-      String.from_utf16(slice.to_unsafe).should eq("hi")
+      String.from_utf16(slice.to_unsafe).should eq({"hi", slice.to_unsafe + 3})
+    end
+
+    it "with pointer reads multiple strings" do
+      input = Slice[0_u16, 0x68_u16, 0x65_u16, 0x6c_u16, 0x6c_u16, 0x6f_u16, 0xd7ff_u16, 0_u16]
+      pointer = input.to_unsafe
+      string, pointer = String.from_utf16(pointer)
+      string.should eq("")
+      string, pointer = String.from_utf16(pointer)
+      string.should eq("hello\u{d7ff}")
     end
   end
 end

src/crystal/system/env.cr

@@ -0,0 +1,19 @@
+module Crystal::System::Env
+  # Sets an environment variable or unsets it if *value* is `nil`.
+  # def self.set(key : String, value : String?) : Nil
+
+  # Gets an environment variable.
+  # def self.get(key : String) : String?
+
+  # Returns `true` if environment variable is set.
+  # def self.has_key?(key : String) : Bool
+
+  # Iterates all environment variables.
+  # def self.each(&block : String, String ->)
+end
+
+{% if flag?(:win32) %}
+  require "./win32/env"
+{% else %}
+  require "./unix/env"
+{% end %}

src/crystal/system/unix/env.cr

@@ -0,0 +1,55 @@
+require "c/stdlib"
+
+module Crystal::System::Env
+  # Sets an environment variable.
+  def self.set(key : String, value : String) : Nil
+    key.check_no_null_byte("key")
+    value.check_no_null_byte("value")
+
+    if LibC.setenv(key, value, 1) != 0
+      raise Errno.new("setenv")
+    end
+  end
+
+  # Unsets an environment variable.
+  def self.set(key : String, value : Nil) : Nil
+    key.check_no_null_byte("key")
+
+    if LibC.unsetenv(key) != 0
+      raise Errno.new("unsetenv")
+    end
+  end
+
+  # Gets an environment variable.
+  def self.get(key : String) : String?
+    key.check_no_null_byte("key")
+
+    if value = LibC.getenv(key)
+      String.new(value)
+    end
+  end
+
+  # Returns `true` if environment variable is set.
+  def self.has_key?(key : String) : Bool
+    key.check_no_null_byte("key")
+
+    !!LibC.getenv(key)
+  end
+
+  # Iterates all environment variables.
+  def self.each(&block : String, String ->)
+    environ_ptr = LibC.environ
+    while environ_ptr
+      environ_value = environ_ptr.value
+      if environ_value
+        key_value = String.new(environ_value).split('=', 2)
+        key = key_value[0]
+        value = key_value[1]? || ""
+        yield key, value
+        environ_ptr += 1
+      else
+        break
+      end
+    end
+  end
+end

src/crystal/system/win32/env.cr

@@ -0,0 +1,67 @@
+require "crystal/system/windows"
+require "c/winbase"
+
+module Crystal::System::Env
+  # Sets an environment variable or unsets it if *value* is `nil`.
+  def self.set(key : String, value : String) : Nil
+    key.check_no_null_byte("key")
+    value.check_no_null_byte("value")
+
+    if LibC.SetEnvironmentVariableW(key.to_utf16, value.to_utf16) == 0
+      raise WinError.new("SetEnvironmentVariableW")
+    end
+  end
+
+  # Unsets an environment variable.
+  def self.set(key : String, value : Nil) : Nil
+    key.check_no_null_byte("key")
+
+    if LibC.SetEnvironmentVariableW(key.to_utf16, nil) == 0
+      raise WinError.new("SetEnvironmentVariableW")
+    end
+  end
+
+  # Gets an environment variable.
+  def self.get(key : String) : String?
+    key.check_no_null_byte("key")
+
+    System.retry_wstr_buffer do |buffer, small_buf|
+      length = LibC.GetEnvironmentVariableW(key.to_utf16, buffer, buffer.size)
+      if 0 < length < buffer.size
+        return String.from_utf16(buffer[0, length])
+      elsif small_buf && length > 0
+        next length
+      elsif length == 0 && LibC.GetLastError == WinError::ERROR_ENVVAR_NOT_FOUND
+        return
+      else
+        raise WinError.new("GetEnvironmentVariableW")
+      end
+    end
+  end
+
+  # Returns `true` if environment variable is set.
+  def self.has_key?(key : String) : Bool
+    key.check_no_null_byte("key")
+
+    buffer = uninitialized UInt16[1]
+    LibC.GetEnvironmentVariableW(key.to_utf16, buffer, buffer.size) != 0
+  end
+
+  # Iterates all environment variables.
+  def self.each(&block : String, String ->)
+    orig_pointer = pointer = LibC.GetEnvironmentStringsW
+    raise WinError.new("GetEnvironmentStringsW") if pointer.null?
+
+    begin
+      while !pointer.value.zero?
+        string, pointer = String.from_utf16(pointer)
+        key_value = string.split('=', 2)
+        key = key_value[0]
+        value = key_value[1]? || ""
+        yield key, value
+      end
+    ensure
+      LibC.FreeEnvironmentStringsW(orig_pointer)
+    end
+  end
+end

src/crystal/system/win32/time.cr

@@ -141,13 +141,13 @@ module Crystal::System::Time
 
   # Normalizes the names of the standard and dst zones.
   private def self.normalize_zone_names(info : LibC::TIME_ZONE_INFORMATION) : Tuple(String, String)
-    stdname = String.from_utf16(info.standardName.to_unsafe)
+    stdname = String.from_utf16(info.standardName.to_slice)
 
     if normalized_names = WINDOWS_ZONE_NAMES[stdname]?
       return normalized_names
     end
 
-    dstname = String.from_utf16(info.daylightName.to_unsafe)
+    dstname = String.from_utf16(info.daylightName.to_slice)
 
     if english_name = translate_zone_name(stdname, dstname)
       if normalized_names = WINDOWS_ZONE_NAMES[english_name]?

src/env.cr

@@ -1,4 +1,4 @@
-require "c/stdlib"
+require "crystal/system/env"
 
 # `ENV` is a hash-like accessor for environment variables.
 #
@@ -35,24 +35,15 @@ module ENV
   #
   # If *key* or *value* contains a null-byte an `ArgumentError` is raised.
   def self.[]=(key : String, value : String?)
-    raise ArgumentError.new("Key contains null byte") if key.byte_index(0)
+    Crystal::System::Env.set(key, value)
 
-    if value
-      raise ArgumentError.new("Value contains null byte") if value.byte_index(0)
-
-      if LibC.setenv(key, value, 1) != 0
-        raise Errno.new("Error setting environment variable #{key.inspect}")
-      end
-    else
-      LibC.unsetenv(key)
-    end
     value
   end
 
   # Returns `true` if the environment variable named *key* exists and `false`
   # if it doesn't.
   def self.has_key?(key : String) : Bool
-    !!LibC.getenv(key)
+    Crystal::System::Env.has_key?(key)
   end
 
   # Retrieves a value corresponding to the given *key*. Raises a `KeyError` exception if the
@@ -72,9 +63,11 @@ module ENV
   # Retrieves a value corresponding to a given *key*. Return the value of the block if
   # the *key* does not exist.
   def self.fetch(key : String, &block : String -> String?)
-    value = LibC.getenv key
-    return String.new(value) if value
-    yield(key)
+    if value = Crystal::System::Env.get(key)
+      return value
+    else
+      yield key
+    end
   end
 
   # Returns an array of all the environment variable names.
@@ -95,7 +88,7 @@ module ENV
   # the environment variable existed, otherwise returns `nil`.
   def self.delete(key : String) : String?
     if value = self[key]?
-      LibC.unsetenv(key)
+      Crystal::System::Env.set(key, nil)
       value
     else
       nil
@@ -111,18 +104,8 @@ module ENV
   # end
   # ```
   def self.each
-    environ_ptr = LibC.environ
-    while environ_ptr
-      environ_value = environ_ptr.value
-      if environ_value
-        key_value = String.new(environ_value).split('=', 2)
-        key = key_value[0]
-        value = key_value[1]? || ""
-        yield({key, value})
-        environ_ptr += 1
-      else
-        break
-      end
+    Crystal::System::Env.each do |key, value|
+      yield key, value
     end
   end
 

src/lib_c/x86_64-windows-msvc/c/stdlib.cr

@@ -10,7 +10,6 @@ lib LibC
   fun div(numer : Int, denom : Int) : DivT
   fun exit(status : Int) : NoReturn
   fun free(ptr : Void*) : Void
-  fun getenv(name : Char*) : Char*
   fun malloc(size : SizeT) : Void*
   fun putenv(string : Char*) : Int
   fun realloc(ptr : Void*, size : SizeT) : Void*

src/lib_c/x86_64-windows-msvc/c/winbase.cr

@@ -85,4 +85,9 @@ lib LibC
   INVALID_HANDLE_VALUE = HANDLE.new(-1)
 
   fun CloseHandle(hObject : HANDLE) : BOOL
+
+  fun GetEnvironmentVariableW(lpName : LPWSTR, lpBuffer : LPWSTR, nSize : DWORD) : DWORD
+  fun GetEnvironmentStringsW : LPWCH
+  fun FreeEnvironmentStringsW(lpszEnvironmentBlock : LPWCH) : BOOL
+  fun SetEnvironmentVariableW(lpName : LPWSTR, lpValue : LPWSTR) : BOOL
 end

src/lib_c/x86_64-windows-msvc/c/winnt.cr

@@ -6,6 +6,7 @@ lib LibC
   alias WCHAR = UInt16
   alias LPSTR = CHAR*
   alias LPWSTR = WCHAR*
+  alias LPWCH = WCHAR*
 
   alias HANDLE = Void*
 

src/string.cr

@@ -4244,8 +4244,11 @@ class String
   # Raises an `ArgumentError` if `self` has null bytes. Returns `self` otherwise.
   #
   # This method should sometimes be called before passing a `String` to a C function.
-  def check_no_null_byte
-    raise ArgumentError.new("String contains null byte") if byte_index(0)
+  def check_no_null_byte(name = nil)
+    if byte_index(0)
+      name = "`#{name}` " if name
+      raise ArgumentError.new("String #{name}contains null byte")
+    end
     self
   end