xezat 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6183648a65f69a1fc1c1a85779066ba529614681aeb56fa78979ba9d9536c625
-  data.tar.gz: 20589012624b3e1690014d2b03ad2dda3fe01c464f5c3fb03223572a856a8dc4
+  metadata.gz: 44f20fb8c8d53290ca2aa712f0305df3a64fa92b5fd495e74d9c251cea4bd38c
+  data.tar.gz: 43aa81a90789ba5ab3d9c64b7b8aa4b93bf04d96cde0c51ceba7a35238623771
 SHA512:
-  metadata.gz: e94a00970240eb104ba88a2126a4fbd04d97820977a383a0498e584b3373b69e8dd98260c30cb59853e36f792949c5fa527a910345b19582ea1332541f2b2a48
-  data.tar.gz: b01a34f4cc54b8967e765045048d8759612de6653602c0833ff6b252b8302563ea286fcfde36eefb4d1ab58f623a3c32f299aedb5b741aef681363840f719e63
+  metadata.gz: fde0d1e68848308d416fe1e06749bfcaec89a558a40454fc8924a0038103ddbbc07db8900894d48b825a21633e112c83ce72899e40133b8766f082749a3a2f12
+  data.tar.gz: 0cbca3957598e70390bdb6c87bddfe94585d5d1afe85b97057158b23dae17a2ab1555c7b63410595417cf996382124e42907dd42f1aa1e43831710f26295184d

data/.github/workflows/ruby.yml

@@ -0,0 +1,45 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: true
+    - name: Install native libraries
+      run: sudo apt-get install cmake libicu-dev
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '3.2.2' # Not needed with a .ruby-version file
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run rubocop
+      run: bundle exec rubocop --format simple
+    - name: Run fasterer
+      run: bundle exec fasterer
+    - name: Run tests
+      run: bundle exec rspec
+    - name: Formatting coverage results
+      uses: 5monkeys/cobertura-action@master
+      with:
+        path: tmp/coverage/coverage.xml
+        minimum_coverage: 75
+        show_branch: true
+        show_missing: true
+        show_class_names: true
+        link_missing_lines: true
+        report_name: code coverage results

data/.gitignore

@@ -1,12 +1,11 @@
 /.bundle/
-/.yardoc
 /Gemfile.lock
-/_yardoc/
 /coverage/
 /doc/
 /pkg/
 /spec/reports/
 /tmp/
+/vendor/
 
 # rspec failure tracking
-.rspec_status
+# .rspec_status

data/.rubocop.yml

@@ -3,16 +3,19 @@ require: rubocop-performance
 AllCops:
   NewCops: enable
   SuggestExtensions: false
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.2
   Exclude:
     - 'spec/cygport/**/*'
     - 'vendor/**/*'
 
+Gemspec/DevelopmentDependencies:
+  EnforcedStyle: gemspec
+
 Layout/LineLength:
   Max: 160
 
 Metrics/AbcSize:
-  Max: 40
+  Max: 45
 Metrics/BlockLength:
   Exclude:
     - '*.gemspec'

data/.ruby-version

@@ -1 +1 @@
-2.6.4
+3.2.2

data/README.md

@@ -1,6 +1,6 @@
 # Xezat
 
-[![CircleCI](https://circleci.com/gh/fd00/xezat/tree/master.svg?style=svg)](https://circleci.com/gh/fd00/xezat/tree/master)
+[![Actions](https://github.com/fd00/xezat/actions/workflows/ruby.yml/badge.svg)](https://github.com/fd00/xezat/)
 
 xezat helps you win at cygport.
 

data/lib/xezat/command/bump/compiler.rb

@@ -7,17 +7,17 @@ module Xezat
     class Bump
       def get_compilers(languages, _variables)
         Xezat.logger.debug('  Collect compilers')
-        compiler_file = File.expand_path(File.join(DATA_DIR, 'compilers.json'))
-        compiler_candidates = JSON.parse(File.read(compiler_file))
+        compiler_file = File.expand_path(File.join(DATA_DIR, 'compilers.yaml'))
+        compiler_candidates = YAML.safe_load(File.open(compiler_file), symbolize_names: true, permitted_classes: [Symbol])
         compilers = []
         languages.uniq.each do |language|
           next unless compiler_candidates.key?(language)
 
           compiler_candidate = compiler_candidates[language]
-          compilers << compiler_candidate['package'].intern
-          next unless compiler_candidate.key?('dependencies')
+          compilers << compiler_candidate[:package].intern
+          next unless compiler_candidate.key?(:dependencies)
 
-          compiler_candidate['dependencies'].each do |dependency|
+          compiler_candidate[:dependencies].each do |dependency|
             compilers << dependency.intern
           end
         end

data/lib/xezat/command/bump/cygport_dep.rb

@@ -14,8 +14,8 @@ module Xezat
         additional_path = candidate_files.map do |file|
           File.dirname(file)
         end.sort.uniq.join(':')
-        command = ['bash', File.expand_path(File.join(DATA_DIR, 'invoke_cygport_dep.sh')), cygport]
-        result, error, status = Open3.capture3({ 'PATH' => "#{ENV['PATH']}:#{additional_path}" }, command.join(' '))
+        command = ['bash', File.expand_path(File.join(DATA_DIR, 'cygport_dep.sh')), cygport]
+        result, error, status = Open3.capture3({ 'PATH' => "#{ENV.fetch('PATH')}:#{additional_path}" }, command.join(' '))
         raise CygportProcessError, error unless status.success?
 
         result

data/lib/xezat/command/bump/development_package.rb

@@ -8,17 +8,42 @@ require 'xezat/command/bump/tool'
 module Xezat
   module Command
     class Bump
-      def get_development_packages(variables, packages)
+      def get_development_packages(variables, packages, runtimes, pkg2files)
         Xezat.logger.debug('  Collect development packages')
         compilers = get_compilers(get_languages(variables[:S]), variables)
         tools = get_tools(variables)
         build_requires = variables[:BUILD_REQUIRES].nil? ? [] : variables[:BUILD_REQUIRES].split.map(&:to_sym)
-        development_packages = (compilers + tools + build_requires + [:cygport]).uniq.sort
-        development_packages.delete(:'libssl-devel') if development_packages.include?(:'libssl1.0-devel')
+        development_packages = (compilers + tools + build_requires + [:cygport]).uniq
+
+        resolve_development_package(development_packages)
+
+        # Check gcc-gfortran
+        if runtimes.grep(/^libgfortran/).empty?
+          delete_fortran = true
+          pkg2files.each_value do |files|
+            delete_fortran = false unless files.grep(/\.mod$/).empty?
+          end
+          development_packages.delete(:'gcc-fortran') if delete_fortran
+        end
+
+        development_packages.sort!
+
         development_packages.map! do |package|
-          packages[package] || ''
+          pkg = packages[package]
+          raise "Package #{package} is not installed in your system" if pkg.nil?
+
+          pkg
         end
       end
+
+      def resolve_development_package(development_packages)
+        # Check libssl duplication
+        development_packages.delete(:'libssl-devel') if development_packages.include?(:'libssl1.0-devel')
+
+        # Check lua duplication
+        development_packages.delete(:lua) if development_packages.include?(:'lua5.1-devel')
+        development_packages.delete(:lua) if development_packages.include?(:'luajit-devel')
+      end
     end
   end
 end

data/lib/xezat/command/bump/language.rb

@@ -8,20 +8,24 @@ module Xezat
     class Bump
       def get_languages(top_src_dir)
         Xezat.logger.debug('  Collect languages')
-        languages_file = File.expand_path(File.join(DATA_DIR, 'languages.json'))
-        languages_candidates = JSON.parse(File.read(languages_file))
+        languages_file = File.expand_path(File.join(DATA_DIR, 'languages.yaml'))
+        languages_candidates = YAML.safe_load(File.open(languages_file), symbolize_names: true, permitted_classes: [Symbol])
         languages = []
         Find.find(top_src_dir) do |path|
           next if FileTest.directory?(path)
 
-          name = languages_candidates[File.extname(path)]
+          extname = File.extname(path)
+          next if extname == '.inc' # ambiguous
+
+          name = languages_candidates[extname.to_sym]
           if name.nil?
+
             language = Xezat::Linguist::FileBlob.new(path).language
             next if language.nil?
 
             name = language.name
           end
-          languages << name
+          languages << name.to_sym
         end
         languages.uniq
       end

data/lib/xezat/command/bump/runtime_package.rb

@@ -13,10 +13,11 @@ module Xezat
         runtime_packages = result.gsub(/^.*\*\*\*.*$/, '').split($INPUT_RECORD_SEPARATOR).map(&:lstrip)
         build_requires = variables[:BUILD_REQUIRES].nil? ? [] : variables[:BUILD_REQUIRES].split.map(&:to_sym)
         runtime_packages.delete(pkgs[:'libssl-devel']) if build_requires.include?(:'libssl1.0-devel')
+        runtime_packages.map! { |pkg| pkg == 'python3' ? pkgs[:python39] : pkg }
         variables[:REQUIRES]&.split&.each do |req|
           runtime_packages << pkgs[req.to_sym]
         end
-        runtime_packages.sort
+        runtime_packages.sort.uniq
       end
     end
   end

data/lib/xezat/command/bump.rb

@@ -30,13 +30,12 @@ module Xezat
         vars = variables(@cygport)
         readme_file = File.expand_path(File.join(vars[:C], 'README'))
 
-        info = {
-          src_uri: get_src_uri(vars),
-          runtimes: get_runtime_packages(vars, pkgs, @cygport),
-          developments: get_development_packages(vars, pkgs),
-          files: get_files(vars),
-          changelog: get_changelog(vars, @options, readme_file)
-        }
+        info = {}
+        info[:src_uri] = get_src_uri(vars)
+        info[:runtimes] = get_runtime_packages(vars, pkgs, @cygport)
+        info[:files] = get_files(vars)
+        info[:developments] = get_development_packages(vars, pkgs, info[:runtimes], info[:files])
+        info[:changelog] = get_changelog(vars, @options, readme_file)
 
         Xezat.logger.debug('  Write ChangeLog atomically')
         File.atomic_write(readme_file) do |f|

data/lib/xezat/command/generate.rb

@@ -5,8 +5,9 @@ require 'thor'
 module Xezat
   module Command
     class Generate < Thor
-      desc 'generate pkgconfig cygport', 'Generate *.pc'
+      desc 'pkgconfig cygport', 'Generate *.pc'
       option :overwrite, type: :boolean, aliases: '-o', desc: 'overwrite *.pc'
+      option :srcdir, type: :string, aliases: '-s', desc: 'relative path to Makefile.am / CMakeLists.txt'
 
       def pkgconfig(cygport)
         require 'xezat/generator/pkgconfig'

data/lib/xezat/command/init.rb

@@ -41,10 +41,10 @@ module Xezat
 
       def get_repository_variables(repository)
         if repository
-          repository_file = File.expand_path(File.join(REPOSITORY_DIR, "#{repository}.json"))
+          repository_file = File.expand_path(File.join(REPOSITORY_DIR, "#{repository}.yaml"))
           raise NoSuchRepositoryError, "No such repository: #{template}" unless FileTest.exist?(repository_file) || FileTest.readable?(repository_file)
 
-          JSON.parse(File.read(repository_file), symbolize_names: true)
+          YAML.safe_load(File.open(repository_file), symbolize_names: true, permitted_classes: [Symbol])
         else
           {
             HOMEPAGE: '',

data/lib/xezat/command/port.rb

@@ -26,15 +26,13 @@ module Xezat
         readme = File.expand_path(File.join(vars[:C], 'README'))
         src_patch = File.expand_path(File.join(vars[:patchdir], "#{vars[:PF]}.src.patch"))
 
-        fuo = {
-          noop: @options[:noop],
-          verbose: @options[:noop] || @options[:verbose]
-        }
-
-        FileUtils.mkdir_p(d, fuo)
-        FileUtils.cp(cygport, d, fuo)
-        FileUtils.cp(readme, d, fuo)
-        FileUtils.cp(src_patch, d, fuo) unless FileTest.zero?(src_patch)
+        noop = @options[:noop]
+        verbose = @options[:noop] || @options[:verbose]
+
+        FileUtils.mkdir_p(d, noop:, verbose:)
+        FileUtils.cp(cygport, d, noop:, verbose:)
+        FileUtils.cp(readme, d,  noop:, verbose:)
+        FileUtils.cp(src_patch, d, noop:, verbose:) unless FileTest.empty?(src_patch)
         Xezat.logger.debug('End porting')
       end
 

data/lib/xezat/command/validate/config.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'pkg-config'
+require 'xezat'
+
+module Xezat
+  module Command
+    class Validate
+      def validate_config(variables, gcc_version)
+        configs = Dir.glob(File.join(variables[:D], '/usr/bin/*-config'))
+        configs.each do |config|
+          basename = File.basename(config)
+          Xezat.logger.debug("    #{basename} found")
+
+          result, _, status = Open3.capture3("#{config} --cflags")
+          if status.success?
+            Xezat.logger.debug("      cflags = #{result.strip}")
+          else
+            Xezat.logger.warn('       cflags not supported')
+          end
+
+          result, _, status = Open3.capture3("#{config} --cxxflags")
+          if status.success?
+            Xezat.logger.debug("      cxxflags = #{result.strip}")
+          else
+            Xezat.logger.warn('       cxxflags not supported')
+          end
+
+          result, _, status = Open3.capture3("#{config} --libs")
+          if status.success?
+            Xezat.logger.debug("      libs = #{result.strip}")
+            validate_libs(variables, result.strip, gcc_version)
+          else
+            Xezat.logger.warn('       libs not supported')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xezat/command/validate/license.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spdx'
+require 'xezat'
+
+module Xezat
+  module Command
+    class Validate
+      def validate_license(vars)
+        license = vars[:LICENSE]
+        if license.nil? || license.empty?
+          Xezat.logger.warn('     LICENSE is not defined')
+        elsif Spdx.valid?(license)
+          Xezat.logger.debug("    LICENSE = #{license}")
+        else
+          Xezat.logger.error("    LICENSE = #{license} (invalid)")
+        end
+
+        license_uri = vars[:LICENSE_URI]
+        if license_uri.nil? || license_uri.empty?
+          Xezat.logger.warn('     LICENSE_URI is not defined')
+        elsif File.exist?(File.join(vars[:S], license_uri))
+          Xezat.logger.debug("    LICENSE_URI = #{license_uri}")
+        else
+          Xezat.logger.error("    LICENSE_URI = #{license_uri} (not found)")
+        end
+      end
+    end
+  end
+end

data/lib/xezat/command/validate/pkgconfig.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'pkg-config'
+require 'xezat'
+
+module Xezat
+  module Command
+    class Validate
+      def validate_pkgconfig(variables, gcc_version)
+        pkgconfig_path = File.join(variables[:D], 'usr', 'lib', 'pkgconfig')
+        PKGConfig.add_path(pkgconfig_path)
+        Dir.glob('*.pc', 0, base: pkgconfig_path).each do |pc|
+          Xezat.logger.debug("    #{pc} found")
+          basename = File.basename(pc, '.pc')
+
+          modversion = PKGConfig.modversion(basename)
+          Xezat.logger.debug("      modversion = #{modversion}")
+          pv = variables[:PV][0].gsub(/\+.+$/, '')
+          Xezat.logger.error("        modversion differs from $PN = #{pv}") unless modversion == pv
+
+          prefix = PKGConfig.variable(basename, 'prefix')
+          if prefix.nil? || prefix.empty? || prefix.eql?('/usr')
+            Xezat.logger.debug("      prefix = #{prefix}")
+          else
+            Xezat.logger.warn("       prefix = #{prefix} (not standard)")
+          end
+
+          Xezat.logger.debug("      cflags = #{PKGConfig.cflags(basename)}")
+
+          libs = PKGConfig.libs(basename)
+          Xezat.logger.debug("      libs = #{libs}")
+          validate_libs(variables, libs, gcc_version)
+        end
+      end
+    end
+  end
+end

data/lib/xezat/command/validate.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 require 'net/http'
-require 'pkg-config'
 require 'uri'
+require 'xezat/command/validate/config'
+require 'xezat/command/validate/license'
+require 'xezat/command/validate/pkgconfig'
+require 'xezat/cygversion'
 require 'xezat/packages'
 require 'xezat/variables'
 
@@ -21,6 +24,8 @@ module Xezat
         vars = variables(@cygport)
         pkgs = packages
 
+        gcc_version = Cygversion.new(pkgs[:'gcc-core'].gsub(/^gcc-core-/, '')).version.split('.')[0]
+
         Xezat.logger.debug('  Validate .cygport')
         validate_cygport(@cygport)
 
@@ -30,11 +35,17 @@ module Xezat
         Xezat.logger.debug('  Validate homepage')
         validate_homepage(vars[:HOMEPAGE])
 
+        Xezat.logger.debug('  Validate licenses')
+        validate_license(vars)
+
         Xezat.logger.debug('  Validate BUILD_REQUIRES')
         validate_build_requires(vars[:BUILD_REQUIRES], pkgs)
 
         Xezat.logger.debug('  Validate *.pc')
-        validate_pkgconfig(vars)
+        validate_pkgconfig(vars, gcc_version)
+
+        Xezat.logger.debug('  Validate *-config')
+        validate_config(vars, gcc_version)
 
         Xezat.logger.debug('End validating')
       end
@@ -47,21 +58,22 @@ module Xezat
 
       def validate_category(category)
         categories_file = File.expand_path(File.join(DATA_DIR, 'categories.yaml'))
-        Xezat.logger.error("    Category is invalid : #{category}") unless YAML.safe_load(File.open(categories_file), [Symbol]).include?(category.downcase)
+        Xezat.logger.error("    Category is invalid : #{category}") unless
+          YAML.safe_load(File.open(categories_file), symbolize_names: true, permitted_classes: [Symbol]).include?(category.downcase)
       end
 
       def validate_homepage(homepage)
         response = Net::HTTP.get_response(URI.parse(homepage))
         code = response.code
         if code == '200'
-          Xezat.logger.debug("    code = #{response.code}")
+          Xezat.logger.debug("    code = #{code}")
         else
-          Xezat.logger.error("    code = #{response.code}")
+          Xezat.logger.error("    code = #{code}")
         end
       rescue OpenSSL::SSL::SSLError => e
         raise e unless @options[:ignore]
 
-        Xezat.logger.error('    Ignore SSLError')
+        Xezat.logger.warn('    Ignore SSLError')
       end
 
       def validate_build_requires(build_requires, pkgs)
@@ -77,25 +89,8 @@ module Xezat
         end
       end
 
-      def validate_pkgconfig(variables)
-        pkgconfig_path = File.join(variables[:D], 'usr', 'lib', 'pkgconfig')
-        PKGConfig.add_path(pkgconfig_path)
-        Dir.glob('*.pc', 0, base: pkgconfig_path).each do |pc|
-          basename = File.basename(pc, '.pc')
-          Xezat.logger.debug("    #{basename}.pc found")
-          modversion = PKGConfig.modversion(basename)
-          Xezat.logger.debug("      modversion = #{modversion}")
-          pv = variables[:PV][0].gsub(/\+.+$/, '')
-          Xezat.logger.error("        modversion differs from $PN = #{pv}") unless modversion == pv
-          Xezat.logger.debug("      cflags = #{PKGConfig.cflags(basename)}")
-          libs = PKGConfig.libs(basename)
-          Xezat.logger.debug("      libs = #{libs}")
-          validate_libs(variables, libs)
-        end
-      end
-
-      def validate_libs(variables, libs)
-        lib_dirs = [File.join(variables[:D], '/usr/lib'), '/usr/lib', '/usr/lib/w32api', '/usr/lib/gcc/x86_64-pc-cygwin/11']
+      def validate_libs(variables, libs, gcc_version)
+        lib_dirs = [File.join(variables[:D], '/usr/lib'), '/usr/lib', '/usr/lib/w32api', "/usr/lib/gcc/x86_64-pc-cygwin/#{gcc_version}"]
         libs.split do |option|
           if option.start_with?('-l')
             lib_name = option[2, 255] # Assume file length limit

data/lib/xezat/config.rb

@@ -8,8 +8,7 @@ module Xezat
     config['cygwin'] = {
       'cygclassdir' => '/usr/share/cygport/cygclass'
     }
-    config['xezat'] = {
-    }
+    config['xezat'] = {}
     config.merge!(YAML.load_file(filepath)) if filepath
     config
   end

data/lib/xezat/cygchangelog.rb

@@ -49,11 +49,11 @@ module Xezat
       @changelogs.key?(key)
     end
 
-    def each(&block)
+    def each(&)
       logs = @changelogs.sort do |a, b|
         -(Cygversion.new(a[0].to_s) <=> Cygversion.new(b[0].to_s))
       end
-      logs.each(&block)
+      logs.each(&)
     end
 
     def length

data/lib/xezat/cygversion.rb

@@ -4,6 +4,8 @@ require 'rubygems'
 
 module Xezat
   class Cygversion
+    attr_reader :version
+
     def initialize(str)
       matched = str.match(/(.+)-(.+)/)
       version = matched[1]

data/lib/xezat/debugger/linguist.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'find'
-require 'pp'
 require 'xezat/ext/linguist/file_blob'
 require 'xezat/variables'
 

data/lib/xezat/debugger/variable.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'pp'
 require 'xezat/variables'
 
 module Xezat

data/lib/xezat/detector/autoconf.rb

@@ -6,6 +6,24 @@ module Xezat
   module Detector
     class Autoconf
       def detect(variables)
+        return false unless variables.keys.index do |key|
+          %i[_cmake_CYGCLASS_ _meson_CYGCLASS_ _ninja_CYGCLASS_].include?(key)
+        end.nil?
+
+        cygautoreconf = false
+        File.foreach(File.join(variables[:top], variables[:cygportfile])) do |line|
+          if line.index('cygautoreconf')
+            cygautoreconf = true
+            return true
+          end
+        end
+
+        unless cygautoreconf
+          File.foreach(File.join(variables[:top], variables[:cygportfile])) do |line|
+            return false if line.index('src_compile')
+          end
+        end
+
         Find.find(variables[:S]) do |file|
           return true if file.end_with?("#{File::SEPARATOR}configure.ac", "#{File::SEPARATOR}configure.in")
         end

data/lib/xezat/detector/automake.rb

@@ -6,6 +6,24 @@ module Xezat
   module Detector
     class Automake
       def detect(variables)
+        return false unless variables.keys.index do |key|
+          %i[_cmake_CYGCLASS_ _meson_CYGCLASS_ _ninja_CYGCLASS_].include?(key)
+        end.nil?
+
+        cygautoreconf = false
+        File.foreach(File.join(variables[:top], variables[:cygportfile])) do |line|
+          if line.index('cygautoreconf')
+            cygautoreconf = true
+            return true
+          end
+        end
+
+        unless cygautoreconf
+          File.foreach(File.join(variables[:top], variables[:cygportfile])) do |line|
+            return false if line.index('src_compile')
+          end
+        end
+
         Find.find(variables[:S]) do |file|
           return true if file.end_with?('.am')
         end

data/lib/xezat/detector/cmake.rb

@@ -6,10 +6,7 @@ module Xezat
   module Detector
     class Cmake
       def detect(variables)
-        Find.find(variables[:S]) do |file|
-          return true if file.end_with?("#{File::SEPARATOR}CMakeLists.txt")
-        end
-        false
+        variables.key?(:_cmake_CYGCLASS_)
       end
     end
   end

data/lib/xezat/detector/{python38-docutils.rb → python39-docutils.rb}

@@ -4,7 +4,7 @@ require 'find'
 
 module Xezat
   module Detector
-    class Python38Docutils
+    class Python39Docutils
       def detect(variables)
         Find.find(variables[:S]) do |file|
           next unless file.end_with?("#{File::SEPARATOR}configure.ac", "#{File::SEPARATOR}configure.in")

data/lib/xezat/detectors.rb

@@ -8,7 +8,7 @@ module Xezat
     def initialize(detector_dir = File.expand_path(File.join(File.dirname(__FILE__), 'detector')))
       Xezat.logger.debug('  Load detectors')
       @detectors = {}
-      Dir.glob(File.join(detector_dir, '*.rb')).sort.each do |rb|
+      Dir.glob(File.join(detector_dir, '*.rb')).each do |rb|
         require rb
         @detectors[File.basename(rb, '.rb').intern] = Object.const_get("Xezat::Detector::#{File.basename(rb, '.rb').camelize}").new
       end