expressir 1.2.3-x64-mingw32 → 1.2.6-x64-mingw32

data/rakelib/cross-ruby.rake

@@ -1,11 +1,15 @@
 require "rbconfig"
 require "shellwords"
 
+WINDOWS_PLATFORM_REGEX = /mingw|mswin/.freeze
+LINUX_PLATFORM_REGEX = /linux/.freeze
+DARWIN_PLATFORM_REGEX = /darwin/.freeze
+GLIBC_MIN_VERSION = "2.17".freeze
+
 CrossRuby = Struct.new(:version, :host) do
-  WINDOWS_PLATFORM_REGEX = /mingw|mswin/
-  MINGW32_PLATFORM_REGEX = /mingw32/
-  LINUX_PLATFORM_REGEX = /linux/
-  DARWIN_PLATFORM_REGEX = /darwin/
+  def dll_staging_path
+    "tmp/#{platform}/stage/lib/expressir/express/#{minor_ver}/express_parser.#{dll_ext}"
+  end
 
   def windows?
     !!(platform =~ WINDOWS_PLATFORM_REGEX)
@@ -27,6 +31,14 @@ CrossRuby = Struct.new(:version, :host) do
     @minor_ver ||= ver[/\A\d\.\d(?=\.)/]
   end
 
+  def minor_ver_digi
+    @minor_ver_digi = minor_ver.delete(".").to_i
+  end
+
+  def ucrt?
+    minor_ver_digi >= 31
+  end
+
   def api_ver_suffix
     case minor_ver
     when nil
@@ -36,18 +48,21 @@ CrossRuby = Struct.new(:version, :host) do
     end
   end
 
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/CyclomaticComplexity
   def platform
-    @platform ||= case host
+    @platform ||=
+      case host
       when /\Ax86_64.*mingw32/
-        "x64-mingw32"
-      when /\Ai[3-6]86.*mingw32/
-        "x86-mingw32"
+        if ucrt?
+          "x64-mingw-ucrt"
+        else
+          "x64-mingw32"
+        end
       when /\Ax86_64.*linux/
         "x86_64-linux"
       when /\A(arm64|aarch64).*linux/
         "aarch64-linux"
-      when /\Ai[3-6]86.*linux/
-        "x86-linux"
       when /\Ax86_64-darwin/
         "x86_64-darwin"
       when /\Aarm64-darwin/
@@ -58,216 +73,264 @@ CrossRuby = Struct.new(:version, :host) do
   end
 
   def tool(name)
-    (@binutils_prefix ||= case platform
-      when "x64-mingw32"
-        "x86_64-w64-mingw32-"
-      when "x86-mingw32"
-        "i686-w64-mingw32-"
-      when "x86_64-linux"
-        "x86_64-redhat-linux-"
-      when "aarch64-linux"
-        "aarch64-redhat-linux-"
-      when "x86-linux"
-        "i686-redhat-linux-"
-      when /x86_64.*darwin/
-        "x86_64-apple-darwin-"
-      when /a.*64.*darwin/
-        "aarch64-apple-darwin-"
-      else
-        raise "CrossRuby.tool: unmatched platform: #{platform}"
-      end) + name
+    (@binutils_prefix ||=
+       case platform
+       when /x64-mingw(32|-ucrt)/
+         "x86_64-w64-mingw32-"
+       when /(x86_64|aarch64)-linux/
+         # We do believe that we are on Linux and can use native tools
+         ""
+       when /x86_64.*darwin/
+         "x86_64-apple-darwin-"
+       when /a.*64.*darwin/
+         "aarch64-apple-darwin-"
+       else
+         raise "CrossRuby.tool: unmatched platform: #{platform}"
+       end) + name
   end
 
   def target_file_format
     case platform
-    when "x64-mingw32"
+    when /64-mingw(32|-ucrt)/
       "pei-x86-64"
-    when "x86-mingw32"
-      "pei-i386"
     when "x86_64-linux"
       "elf64-x86-64"
     when "aarch64-linux"
-      "elf64-arm64"
-    when "x86-linux"
-      "elf32-i386"
+      "elf64-little"
     when "x86_64-darwin"
-      "Mach-O 64-bit x86-64" # hmm
+      "Mach-O 64-bit x86-64"
     when "arm64-darwin"
       "Mach-O arm64"
     else
       raise "CrossRuby.target_file_format: unmatched platform: #{platform}"
     end
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/CyclomaticComplexity
 
   def dll_ext
     darwin? ? "bundle" : "so"
   end
 
-  def dll_staging_path
-    "tmp/#{platform}/stage/lib/#{GEMSPEC.name}/#{minor_ver}/#{GEMSPEC.name}.#{dll_ext}"
+  def verify_format(dump, dll)
+    format_match = (/file format #{Regexp.quote(target_file_format)}\s/ === dump)
+    format_error = "Unexpected file format for '#{dll}', '#{target_file_format}' required"
+    raise format_error unless format_match
   end
 
-  def libruby_dll
-    case platform
-    when "x64-mingw32"
-      "x64-msvcrt-ruby#{api_ver_suffix}.dll"
-    when "x86-mingw32"
-      "msvcrt-ruby#{api_ver_suffix}.dll"
-    else
-      raise "CrossRuby.libruby_dll: unmatched platform: #{platform}"
+  def verify_entry_windows(dump, dll)
+    unless /Table.*\sInit_express_parser\s/mi === dump
+      raise "Export function Init_express_parser not in dll #{dll}"
     end
   end
 
-  def allowed_dlls
+  def verify_entry_linux(dll)
+    nm = `#{["env", "LANG=C", tool("nm"), "-D", dll].shelljoin}`
+    unless / T Init_express_parser/.match?(nm)
+      raise "Export function Init_express_parser not in dll #{dll}"
+    end
+  end
+
+  def verify_entry_darwin(dll)
+    nm = `#{["env", "LANG=C", tool("nm"), "-g", dll].shelljoin}`
+    unless / T _?Init_express_parser/.match?(nm)
+      raise "Export function Init_express_parser not in dll #{dll}"
+    end
+  end
+
+  def verify_entry(dump, dll)
     case platform
-    when MINGW32_PLATFORM_REGEX
-      [
-        "kernel32.dll",
-        "msvcrt.dll",
-        "ws2_32.dll",
-        "user32.dll",
-        "advapi32.dll",
-        libruby_dll,
-      ]
+    when WINDOWS_PLATFORM_REGEX
+      verify_entry_windows(dump, dll)
     when LINUX_PLATFORM_REGEX
-      [
-        "libm.so.6",
-        *(case
-        when ver < "2.6.0"
-          "libpthread.so.0"
-        end),
-        "libc.so.6",
-        "libdl.so.2", # on old dists only - now in libc
-      ]
+      verify_entry_linux(dll)
     when DARWIN_PLATFORM_REGEX
-      [
-        "/usr/lib/libSystem.B.dylib",
-        "/usr/lib/liblzma.5.dylib",
-        "/usr/lib/libobjc.A.dylib",
-      ]
+      verify_entry_darwin(dll)
     else
-      raise "CrossRuby.allowed_dlls: unmatched platform: #{platform}"
+      raise "CrossRuby.verify_entry: unmatched platform: #{platform}"
     end
   end
 
-  def dll_ref_versions
-    case platform
-    when LINUX_PLATFORM_REGEX
-      { "GLIBC" => "2.17" }
+  # rubocop:disable Metrics/MethodLength
+  def allowed_dlls_ucrt
+    ["kernel32.dll",
+     "api-ms-win-crt-convert-l1-1-0.dll",
+     "api-ms-win-crt-environment-l1-1-0.dll",
+     "api-ms-win-crt-heap-l1-1-0.dll",
+     "api-ms-win-crt-locale-l1-1-0.dll",
+     "api-ms-win-crt-private-l1-1-0.dll",
+     "api-ms-win-crt-runtime-l1-1-0.dll",
+     "api-ms-win-crt-stdio-l1-1-0.dll",
+     "api-ms-win-crt-string-l1-1-0.dll",
+     "api-ms-win-crt-time-l1-1-0.dll",
+     "api-ms-win-crt-filesystem-l1-1-0.dll",
+     "api-ms-win-crt-math-l1-1-0.dll",
+     "libwinpthread-1.dll",
+     "x64-ucrt-ruby310.dll"]
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def allowed_dlls_mingw
+    [
+      "kernel32.dll",
+      "msvcrt.dll",
+      "libwinpthread-1.dll",
+      "x64-msvcrt-ruby#{api_ver_suffix}.dll",
+    ]
+  end
+
+  def allowed_dlls_windows
+    if ucrt?
+      allowed_dlls_ucrt
     else
-      raise "CrossRuby.dll_ref_versions: unmatched platform: #{platform}"
+      allowed_dlls_mingw
     end
   end
-end
 
-CROSS_RUBIES = File.read(".cross_rubies").split("\n").map do |line|
-  case line
-  when /\A([^#]+):([^#]+)/
-    CrossRuby.new($1, $2)
+  def allowed_dlls_linux
+    suffix = (platform == "x86_64-linux" ? "x86-64" : "aarch64")
+    [
+      "ld-linux-#{suffix}.so",
+      "libc.so",
+      "libm.so",
+      "libstdc++.so",
+      "libgcc_s.so",
+    ]
   end
-end.compact
-
-ENV["RUBY_CC_VERSION"] = CROSS_RUBIES.map(&:ver).uniq.join(":")
 
-require "rake_compiler_dock"
+  def allowed_dlls_darwin
+    [
+      "/usr/lib/libSystem.B.dylib",
+      "/usr/lib/libc++.1.dylib",
+    ]
+  end
 
-def verify_dll(dll, cross_ruby)
-  allowed_imports = cross_ruby.allowed_dlls
-  dump = `#{["env", "LANG=C", cross_ruby.tool("objdump"), "-p", dll].shelljoin}`
+  def allowed_dlls
+    case platform
+    when WINDOWS_PLATFORM_REGEX
+      allowed_dlls_windows
+    when LINUX_PLATFORM_REGEX
+      allowed_dlls_linux
+    when DARWIN_PLATFORM_REGEX
+      allowed_dlls_darwin
+    else
+      raise "CrossRuby.allowed_dlls: unmatched platform: #{platform}"
+    end
+  end
 
-  if cross_ruby.windows?
-    raise "unexpected file format for generated dll #{dll}" unless /file format #{Regexp.quote(cross_ruby.target_file_format)}\s/ === dump
-    raise "export function Init_nokogiri not in dll #{dll}" unless /Table.*\sInit_nokogiri\s/mi === dump
+  def actual_dlls_linux(dump)
+    dump.scan(/NEEDED\s+(.*)/).map(&:first).uniq
+  end
 
-    # Verify that the DLL dependencies are all allowed.
-    actual_imports = dump.scan(/DLL Name: (.*)$/).map(&:first).map(&:downcase).uniq
-    if !(actual_imports - allowed_imports).empty?
-      raise "unallowed so imports #{actual_imports.inspect} in #{dll} (allowed #{allowed_imports.inspect})"
-    end
+  def actual_dlls_windows(dump)
+    dump.scan(/DLL Name: (.*)$/).map(&:first).map(&:downcase).uniq
+  end
 
-  elsif cross_ruby.linux?
-    nm = `#{["env", "LANG=C", cross_ruby.tool("nm"), "-D", dll].shelljoin}`
+  def actual_dlls_darwin(dll)
+    ldd = `#{[tool("otool"), "-L", dll].shelljoin}`
+    ldd.scan(/^\t([^ ]+) /).map(&:first).uniq
+  end
 
-    raise "unexpected file format for generated dll #{dll}" unless /file format #{Regexp.quote(cross_ruby.target_file_format)}\s/ === dump
-    raise "export function Init_nokogiri not in dll #{dll}" unless / T Init_nokogiri/ === nm
+  def actual_dlls(dump, dll)
+    case platform
+    when DARWIN_PLATFORM_REGEX
+      actual_dlls_darwin(dll)
+    when LINUX_PLATFORM_REGEX
+      actual_dlls_linux(dump)
+    when WINDOWS_PLATFORM_REGEX
+      actual_dlls_windows(dump)
+    else
+      raise "CrossRuby.actual_dlls: unmatched platform: #{platform}"
+    end
+  end
 
-    # Verify that the DLL dependencies are all allowed.
-    actual_imports = dump.scan(/NEEDED\s+(.*)/).map(&:first).uniq
-    if !(actual_imports - allowed_imports).empty?
-      raise "unallowed so imports #{actual_imports.inspect} in #{dll} (allowed #{allowed_imports.inspect})"
+  def verify_imports(dump, dll)
+    l = actual_dlls(dump, dll)
+    libs = allowed_dlls
+    l.delete_if { |ln| libs.any? { |lib| ln.include?(lib) } }
+    unless l.empty?
+      raise "Unexpected references in '#{dll}' : #{l}"
     end
+  end
 
-    # Verify that the expected so version requirements match the actual dependencies.
-    ref_versions_data = dump.scan(/0x[\da-f]+ 0x[\da-f]+ \d+ (\w+)_([\d\.]+)$/i)
+  def lib_ref_versions(data)
     # Build a hash of library versions like {"LIBUDEV"=>"183", "GLIBC"=>"2.17"}
-    actual_ref_versions = ref_versions_data.each.with_object({}) do |(lib, ver), h|
+    data.each.with_object({}) do |(lib, ver), h|
       if !h[lib] || ver.split(".").map(&:to_i).pack("C*") > h[lib].split(".").map(&:to_i).pack("C*")
         h[lib] = ver
       end
     end
-    if actual_ref_versions != cross_ruby.dll_ref_versions
-      raise "unexpected so version requirements #{actual_ref_versions.inspect} in #{dll}"
-    end
-
-  elsif cross_ruby.darwin?
-    nm = `#{["env", "LANG=C", cross_ruby.tool("nm"), "-g", dll].shelljoin}`
-
-    raise "unexpected file format for generated dll #{dll}" unless /file format #{Regexp.quote(cross_ruby.target_file_format)}\s/ === dump
-    raise "export function Init_nokogiri not in dll #{dll}" unless / T _?Init_nokogiri/ === nm
+  end
 
-    # if liblzma is being referenced, let's make sure it's referring
-    # to the system-installed file and not the homebrew-installed file.
-    ldd = `#{["env", "LANG=C", cross_ruby.tool("otool"), "-L", dll].shelljoin}`
-    if liblzma_refs = ldd.scan(/^\t([^ ]+) /).map(&:first).uniq.grep(/liblzma/)
-      liblzma_refs.each do |ref|
-        new_ref = File.join("/usr/lib", File.basename(ref))
-        sh ["env", "LANG=C", cross_ruby.tool("install_name_tool"), "-change", ref, new_ref, dll].shelljoin
-      end
+  def verify_glibc_version(dump, dll)
+    ref_versions_data = dump.scan(/0x[\da-f]+ 0x[\da-f]+ \d+ (\w+)_([\d.]+)$/i)
+    ref_ver = lib_ref_versions(ref_versions_data)
 
-      # reload!
-      ldd = `#{["env", "LANG=C", cross_ruby.tool("otool"), "-L", dll].shelljoin}`
+    unless ref_ver["GLIBC"].delete(".").to_i <= GLIBC_MIN_VERSION.delete(".").to_i
+      raise "Unexpected GLIBC version #{ref_ver['GLIBC']} for #{dll},  #{GLIBC_MIN_VERSION} or lower is expected"
     end
+  end
+end
 
-    # Verify that the DLL dependencies are all allowed.
-    ldd = `#{["env", "LANG=C", cross_ruby.tool("otool"), "-L", dll].shelljoin}`
-    actual_imports = ldd.scan(/^\t([^ ]+) /).map(&:first).uniq
-    if !(actual_imports - allowed_imports).empty?
-      raise "unallowed so imports #{actual_imports.inspect} in #{dll} (allowed #{allowed_imports.inspect})"
-    end
+CROSS_RUBIES = File.read(".cross_rubies").split("\n").map do |line|
+  case line
+  when /\A([^#]+):([^#]+)/
+    CrossRuby.new($1, $2)
   end
-  puts "verify_dll: #{dll}: passed shared library sanity checks"
+end.compact
+
+ENV["RUBY_CC_VERSION"] = CROSS_RUBIES.map(&:ver).uniq.join(":")
+
+require "rake_compiler_dock"
+
+def verify_dll(dll, cross_ruby)
+  dump = `#{["env", "LANG=C", cross_ruby.tool("objdump"), "-p", dll].shelljoin}`
+  cross_ruby.verify_format(dump, dll)
+  cross_ruby.verify_entry(dump, dll)
+  cross_ruby.verify_imports(dump, dll)
+  #  Not sure if it is required, probably not
+  #  I am keeping related code as a reference for future advances
+  #  cross_ruby.verify_glibc_version(dump, dll) if cross_ruby.linux?
+
+  puts "#{dll}: passed shared library sanity checks"
 end
 
 CROSS_RUBIES.each do |cross_ruby|
-  task cross_ruby.dll_staging_path do |t|
-    verify_dll t.name, cross_ruby
+  unless Rake::Task.task_defined?(cross_ruby.dll_staging_path)
+    task cross_ruby.dll_staging_path do |t|
+      verify_dll t.name, cross_ruby
+    end
   end
 end
 
 def gem_builder(plat)
   # use Task#invoke because the pkg/*gem task is defined at runtime
   Rake::Task["native:#{plat}"].invoke
-  Rake::Task["pkg/#{GEMSPEC.full_name}-#{Gem::Platform.new(plat).to_s}.gem"].invoke
+  Rake::Task["pkg/#{GEMSPEC.full_name}-#{Gem::Platform.new(plat)}.gem"].invoke
+end
+
+REDHAT_PREREQ = "sudo yum install -y git".freeze
+UBUNTU_PREREQ = "sudo apt-get update -y && sudo apt-get install -y automake autoconf libtool build-essential".freeze
+
+def pre_req(plat)
+  case plat
+  when /\linux/
+    "if [[ $(awk -F= '/^NAME/{print $2}' /etc/os-release) == '\"Ubuntu\"' ]]; then #{UBUNTU_PREREQ}; else #{REDHAT_PREREQ}; fi"
+  else
+    UBUNTU_PREREQ.to_s
+  end
 end
 
 namespace "gem" do
-  REDHAT_PREREQ = "sudo yum install -y git"
-  UBUNTU_PREREQ = "sudo apt-get update -y && sudo apt-get install -y automake autoconf libtool build-essential"
   CROSS_RUBIES.find_all { |cr| cr.windows? || cr.linux? || cr.darwin? }.map(&:platform).uniq.each do |plat|
-    pre_req = case plat
-              when /\linux/
-                "if [[ $(awk -F= '/^NAME/{print $2}' /etc/os-release) == '\"Ubuntu\"' ]]; then #{UBUNTU_PREREQ}; else #{REDHAT_PREREQ}; fi"
-              else
-                "#{UBUNTU_PREREQ}"
-              end
     desc "build native gem for #{plat} platform"
     task plat do
-      RakeCompilerDock.sh <<~EOT, platform: plat
-        #{pre_req} &&
+      RakeCompilerDock.sh <<~RCD, platform: plat
+        #{pre_req(plat)} &&
         gem install bundler --no-document &&
         bundle &&
         bundle exec rake gem:#{plat}:builder MAKE='nice make -j`nproc`'
-      EOT
+      RCD
     end
 
     namespace plat do
@@ -275,7 +338,6 @@ namespace "gem" do
       task "builder" do
         gem_builder(plat)
       end
-      task "guest" => "builder" # TODO: remove me after this code is on master, temporary backwards compat for CI
     end
   end
 
@@ -289,28 +351,17 @@ namespace "gem" do
   multitask "darwin" => CROSS_RUBIES.find_all(&:darwin?).map(&:platform).uniq
 end
 
-namespace "native" do
-  plat = "x86_64-darwin"
-  namespace plat do
-    desc "build native gem for #{plat} platform on host OS"
-    task "builder" do
-      gem_builder(plat)
-    end
-    task "guest" => "builder" # TODO: remove me after this code is on master, temporary backwards compat for CI
-  end
-end
-
 require "rake/extensiontask"
 
 Rake::ExtensionTask.new("express_parser", GEMSPEC) do |ext|
   ext.ext_dir = "ext/express-parser"
-  ext.lib_dir = File.join(*['lib', 'expressir', 'express', ENV['FAT_DIR']].compact)
-  ext.config_options << ENV['EXTOPTS']
+  ext.lib_dir = File.join(*["lib", "expressir", "express", ENV.fetch("FAT_DIR", nil)].compact)
+  ext.config_options << ENV.fetch("EXTOPTS", nil)
   ext.cross_compile  = true
   ext.cross_platform = CROSS_RUBIES.map(&:platform).uniq
   ext.cross_config_options << "--enable-cross-build"
   ext.cross_compiling do |spec|
-    spec.files.reject! { |path| File.fnmatch?('ext/*', path) }
-    spec.dependencies.reject! { |dep| dep.name == 'rice' }
+    spec.files.reject! { |path| File.fnmatch?("ext/*", path) }
+    spec.dependencies.reject! { |dep| dep.name == "rice" }
   end
 end

data/spec/acceptance/version_spec.rb

@@ -2,11 +2,26 @@ require "spec_helper"
 
 RSpec.describe "Expressir" do
   describe "version" do
-    it "displays the current verison" do
+    it "has a version number" do |example|
+      print "\n[#{example.description}] "
+      expect(Expressir::VERSION).not_to be nil
+
+      # Validate Object Space
+      GC.start
+      GC.verify_compaction_references
+      GC.verify_internal_consistency
+    end
+
+    it "displays the current verison" do |example|
+      print "\n[#{example.description}] "
       command = %w(version)
       output = capture_stdout { Expressir::Cli.start(command) }
-
       expect(output).to include("Version #{Expressir::VERSION}")
+
+      # Validate Object Space
+      GC.start
+      GC.verify_compaction_references
+      GC.verify_internal_consistency
     end
   end
 end

data/spec/expressir/express/cache_spec.rb

@@ -4,11 +4,12 @@ require "spec_helper"
 require "expressir/express/parser"
 require "expressir/express/cache"
 
-RSpec.describe Expressir::Express::Cache do
-  TEST_VERSION = "0.0.0"
+TEST_VERSION = "0.0.0".freeze
 
+RSpec.describe Expressir::Express::Cache do
   describe ".to_file" do
-    it "exports an object" do
+    it "exports an object" do |example|
+      print "\n[#{example.description}] "
       temp_file = Tempfile.new
 
       repository = Expressir::Model::Repository.new
@@ -23,11 +24,17 @@ RSpec.describe Expressir::Express::Cache do
         temp_file.close
         temp_file.unlink
       end
+
+      # Validate Object Space
+      GC.start
+      GC.verify_compaction_references
+      GC.verify_internal_consistency
     end
   end
 
   describe ".from_file" do
-    it "parses a file" do
+    it "parses a file" do |example|
+      print "\n[#{example.description}] "
       temp_file = Tempfile.new
 
       repository = Expressir::Model::Repository.new
@@ -42,9 +49,15 @@ RSpec.describe Expressir::Express::Cache do
         temp_file.close
         temp_file.unlink
       end
+
+      # Validate Object Space
+      GC.start
+      GC.verify_compaction_references
+      GC.verify_internal_consistency
     end
 
-    it "fails parsing a file from a different Expressir version" do
+    it "fails parsing a file from a different Expressir version" do |example|
+      print "\n[#{example.description}] "
       temp_file = Tempfile.new
 
       repository = Expressir::Model::Repository.new
@@ -59,6 +72,11 @@ RSpec.describe Expressir::Express::Cache do
         temp_file.close
         temp_file.unlink
       end
+
+      # Validate Object Space
+      GC.start
+      GC.verify_compaction_references
+      GC.verify_internal_consistency
     end
   end
 end