pigeonhole-db 1.1.0

data/vendor/bundle/ruby/3.4.0/gems/rake-compiler-1.3.2/lib/rake/javaextensiontask.rb

@@ -0,0 +1,321 @@
+require "rbconfig"
+
+require 'rake/baseextensiontask'
+
+# Define a series of tasks to aid in the compilation of Java extensions for
+# gem developer/creators.
+
+module Rake
+  class JavaExtensionTask < BaseExtensionTask
+
+    attr_accessor :classpath
+    attr_accessor :debug
+
+    # Provide source compatibility with specified release
+    attr_accessor :source_version
+
+    # Generate class files for specific VM version
+    attr_accessor :target_version
+
+    # Compile for oldeer platform version
+    attr_accessor :release
+
+    attr_accessor :encoding
+
+    # Specify lint option
+    attr_accessor :lint_option
+
+    def platform
+      @platform ||= 'java'
+    end
+
+    def java_compiling(&block)
+      @java_compiling = block if block_given?
+    end
+
+    def init(name = nil, gem_spec = nil)
+      super
+      @source_pattern = '**/*.java'
+      @classpath      = nil
+      @debug          = false
+      @source_version = '8'
+      @target_version = '8'
+      @release        = nil
+      @encoding       = nil
+      @java_compiling = nil
+      @lint_option    = nil
+    end
+
+    def define
+      super
+
+      define_java_platform_tasks
+    end
+
+    private
+    def define_compile_tasks(for_platform = nil, ruby_ver = RUBY_VERSION)
+      # platform usage
+      platf = for_platform || platform
+
+      binary_path = binary(platf)
+
+      # lib_path
+      lib_path = lib_dir
+
+      # lib_binary_path
+      lib_binary_path = "#{lib_path}/#{File.basename(binary_path)}"
+
+      # tmp_path
+      tmp_path = "#{@tmp_dir}/#{platf}/#{@name}"
+
+      # cleanup and clobbering
+      CLEAN.include(tmp_path)
+      CLOBBER.include(lib_binary_path)
+      CLOBBER.include("#{@tmp_dir}")
+
+      # directories we need
+      directory tmp_path
+      directory lib_dir
+
+      # copy binary from temporary location to final lib
+      # tmp/extension_name/extension_name.{so,bundle} => lib/
+      task "copy:#{@name}:#{platf}" => [lib_path, "#{tmp_path}/#{binary_path}"] do
+        install "#{tmp_path}/#{binary_path}", lib_binary_path
+      end
+
+      file "#{tmp_path}/#{binary_path}" => "#{tmp_path}/.build" do
+
+        class_files = FileList["#{tmp_path}/**/*.class"].
+          gsub("#{tmp_path}/", '')
+
+        # avoid environment variable expansion using backslash
+        class_files.gsub!('$', '\$') unless windows?
+
+        args = class_files.map { |path|
+          ["-C #{tmp_path}", path]
+        }.flatten
+
+        sh "jar cf #{tmp_path}/#{binary_path} #{args.join(' ')}"
+      end
+
+      file "#{tmp_path}/.build" => [tmp_path] + source_files do
+        not_jruby_compile_msg = <<-EOF
+WARNING: You're cross-compiling a binary extension for JRuby, but are using
+another interpreter. If your Java classpath or extension dir settings are not
+correctly detected, then either check the appropriate environment variables or
+execute the Rake compilation task using the JRuby interpreter.
+(e.g. `jruby -S rake compile:java`)
+        EOF
+        warn_once(not_jruby_compile_msg) unless defined?(JRUBY_VERSION)
+
+        java_home = ENV["JAVA_HOME"]
+        if java_home
+          exeext = RbConfig::CONFIG["EXEEXT"]
+          javac_path = File.join(java_home, "bin", "javac#{exeext}")
+          javac_path = nil unless File.exist?(javac_path)
+        end
+        javac_path ||= "javac"
+
+        javac_command_line = [
+          javac_path,
+          *java_target_args,
+          java_lint_arg,
+          "-d", tmp_path,
+        ]
+        javac_command_line.concat(java_encoding_args)
+        javac_command_line.concat(java_extdirs_args)
+        javac_command_line.concat(java_classpath_args)
+        javac_command_line << "-g" if @debug
+        javac_command_line.concat(source_files)
+        sh(*javac_command_line)
+
+        # Checkpoint file
+        touch "#{tmp_path}/.build"
+      end
+
+      # compile tasks
+      unless Rake::Task.task_defined?('compile') then
+        desc "Compile all the extensions"
+        task "compile"
+      end
+
+      # compile:name
+      unless Rake::Task.task_defined?("compile:#{@name}") then
+        desc "Compile #{@name}"
+        task "compile:#{@name}"
+      end
+
+      # Allow segmented compilation by platform (open door for 'cross compile')
+      task "compile:#{@name}:#{platf}" => ["copy:#{@name}:#{platf}"]
+      task "compile:#{platf}" => ["compile:#{@name}:#{platf}"]
+
+      # Only add this extension to the compile chain if current
+      # platform matches the indicated one.
+      if platf == RUBY_PLATFORM then
+        # ensure file is always copied
+        file lib_binary_path => ["copy:#{name}:#{platf}"]
+
+        task "compile:#{@name}" => ["compile:#{@name}:#{platf}"]
+        task "compile" => ["compile:#{platf}"]
+      end
+    end
+
+    def define_java_platform_tasks
+      # lib_path
+      lib_path = lib_dir
+
+      if @gem_spec && !Rake::Task.task_defined?("java:#{@gem_spec.name}")
+        task "java:#{@gem_spec.name}" do |t|
+          # FIXME: workaround Gem::Specification limitation around cache_file:
+          # http://github.com/rubygems/rubygems/issues/78
+          spec = gem_spec.dup
+          spec.instance_variable_set(:"@cache_file", nil) if spec.respond_to?(:cache_file)
+
+          # adjust to specified platform
+          spec.platform = Gem::Platform.new('java')
+
+          # clear the extensions defined in the specs
+          spec.extensions.clear
+
+          # add the binaries that this task depends on
+          ext_files = []
+
+          # go through native prerequisites and grab the real extension files from there
+          t.prerequisites.each do |ext|
+            ext_files << ext
+          end
+
+          # include the files in the gem specification
+          spec.files += ext_files
+
+          # expose gem specification for customization
+          if @java_compiling
+            @java_compiling.call(spec)
+          end
+
+          # Generate a package for this gem
+          Gem::PackageTask.new(spec) do |pkg|
+            pkg.need_zip = false
+            pkg.need_tar = false
+          end
+        end
+
+        # lib_binary_path
+        lib_binary_path = "#{lib_path}/#{File.basename(binary(platform))}"
+
+        # add binaries to the dependency chain
+        task "java:#{@gem_spec.name}" => [lib_binary_path]
+
+        # ensure the extension get copied
+        unless Rake::Task.task_defined?(lib_binary_path) then
+          file lib_binary_path => ["copy:#{name}:#{platform}"]
+        end
+
+        task 'java' => ["java:#{@gem_spec.name}"]
+      end
+
+      task 'java' do
+        task 'compile' => 'compile:java'
+      end
+    end
+
+    def java_target_args
+      if @release && release_flag_supported?
+        ["--release=#{@release}"]
+      else
+        ["-target", @target_version, "-source", @source_version]
+      end
+    end
+
+    #
+    # Discover Java Extension Directories and build an extdirs arguments
+    #
+    def java_extdirs_args
+      extdirs = Java::java.lang.System.getProperty('java.ext.dirs') rescue nil
+      extdirs ||= ENV['JAVA_EXT_DIR']
+      if extdirs.nil?
+        []
+      else
+        ["-extdirs", extdirs]
+      end
+    end
+
+    #
+    # Build an encoding arguments
+    #
+    def java_encoding_args
+      if @encoding.nil?
+        []
+      else
+        ["-encoding", @encoding]
+      end
+    end
+
+    #
+    # Discover the Java/JRuby classpath and build a classpath arguments
+    #
+    # Copied verbatim from the ActiveRecord-JDBC project. There are a small myriad
+    # of ways to discover the Java classpath correctly.
+    #
+    def java_classpath_args
+      jruby_cpath = nil
+      if RUBY_PLATFORM =~ /java/
+        begin
+          cpath  = Java::java.lang.System.getProperty('java.class.path').split(File::PATH_SEPARATOR)
+          cpath += Java::java.lang.System.getProperty('sun.boot.class.path').split(File::PATH_SEPARATOR)
+          jruby_cpath = cpath.compact.join(File::PATH_SEPARATOR)
+        rescue
+        end
+      end
+
+      # jruby_cpath might not be present from Java-9 onwards as it removes
+      # sun.boot.class.path. Check if JRUBY_HOME is set as env variable and try
+      # to find jruby.jar under JRUBY_HOME
+      unless jruby_cpath
+        jruby_home = ENV['JRUBY_HOME']
+        if jruby_home
+          candidate = File.join(jruby_home, 'lib', 'jruby.jar')
+          jruby_cpath = candidate if File.exist?(candidate)
+        end
+      end
+
+      # JRUBY_HOME is not necessarily set in JRuby-9.x
+      # Find the libdir from RbConfig::CONFIG and find jruby.jar under the
+      # found lib path
+      unless jruby_cpath
+        libdir = RbConfig::CONFIG['libdir']
+        if libdir.start_with?("uri:classloader:")
+          raise 'Cannot build with jruby-complete from Java 9 onwards'
+        end
+        candidate = File.join(libdir, "jruby.jar")
+        jruby_cpath = candidate if File.exist?(candidate)
+      end
+
+      unless jruby_cpath
+        raise "Could not find jruby.jar. Please set JRUBY_HOME or use jruby in rvm"
+      end
+
+      if @classpath and @classpath.size > 0
+        jruby_cpath = [jruby_cpath, *@classpath].join(File::PATH_SEPARATOR)
+      end
+      ["-cp", jruby_cpath]
+    end
+
+    #
+    # Convert a `-Xlint:___` linting option such as `deprecation` into a full javac argument, such as `-Xlint:deprecation`.
+    #
+    # @return [String]              Default: _Simply `-Xlint` is run, which enables recommended warnings.
+    #
+    def java_lint_arg
+      return '-Xlint' unless @lint_option
+
+      "-Xlint:#{@lint_option}"
+    end
+
+    def release_flag_supported?
+      return true unless RUBY_PLATFORM =~ /java/
+
+      Gem::Version.new(Java::java.lang.System.getProperty('java.version')) >= Gem::Version.new("9")
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rake-compiler-1.3.2/tasks/bin/cross-ruby.rake

@@ -0,0 +1,189 @@
+#--
+# Cross-compile ruby, using Rake
+#
+# This source code is released under the MIT License.
+# See LICENSE file for details
+#++
+
+#
+# This code is inspired and based on notes from the following sites:
+#
+# http://tenderlovemaking.com/2008/11/21/cross-compiling-ruby-gems-for-win32/
+# http://github.com/jbarnette/johnson/tree/master/cross-compile.txt
+# http://eigenclass.org/hiki/cross+compiling+rcovrt
+#
+# This recipe only cleanup the dependency chain and automate it.
+# Also opens the door to usage different ruby versions
+# for cross-compilation.
+#
+
+require 'rake'
+require 'rake/clean'
+
+begin
+  require 'psych'
+rescue LoadError
+end
+
+require 'yaml'
+require "rbconfig"
+
+# load compiler helpers
+# add lib directory to the search path
+libdir = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+if RUBY_PLATFORM =~ /mingw|mswin/ then
+  puts "This command is meant to be executed under Linux or OSX, not Windows (is for cross-compilation)"
+  exit(1)
+end
+
+require 'rake/extensioncompiler'
+
+MAKE = ENV['MAKE'] || %w[gmake make].find { |c| system("#{c} -v > /dev/null 2>&1") }
+USER_HOME = File.realpath(File.expand_path("~/.rake-compiler"))
+RUBY_SOURCE = ENV['SOURCE']
+RUBY_BUILD = RbConfig::CONFIG["host"]
+
+# Unset any possible variable that might affect compilation
+["RUBYOPT"].each do |var|
+  ENV.delete(var)
+end
+
+RUBY_CC_VERSIONS = ENV.fetch("VERSION", "1.8.7-p371")
+RUBY_CC_VERSIONS.split(":").each do |ruby_cc_version|
+  ruby_cc_version = "ruby-" + ruby_cc_version
+  # grab the major "1.8" or "1.9" part of the version number
+  major = ruby_cc_version.match(/.*-(\d.\d).\d/)[1]
+
+  # define a location where sources will be stored
+  source_dir = "#{USER_HOME}/sources/#{ruby_cc_version}"
+  directory source_dir
+  # clean intermediate files and folders
+  CLEAN.include(source_dir)
+
+  # remove the final products and sources
+  CLOBBER.include("#{USER_HOME}/sources")
+  CLOBBER.include("#{USER_HOME}/builds")
+  CLOBBER.include("#{USER_HOME}/config.yml")
+
+  # Extract the sources
+  source_file = RUBY_SOURCE ? RUBY_SOURCE.split('/').last : "#{ruby_cc_version}.tar.gz"
+  file source_dir => ["#{USER_HOME}/sources/#{source_file}"] do |t|
+    t.prerequisites.each { |f| sh "tar xf #{File.basename(f)}", chdir: File.dirname(t.name) }
+  end
+
+  # ruby source file should be stored there
+  file "#{USER_HOME}/sources/#{ruby_cc_version}.tar.gz" => ["#{USER_HOME}/sources"] do |t|
+    # download the source file using wget or curl
+    if RUBY_SOURCE
+      url = RUBY_SOURCE
+    else
+      url = "http://cache.ruby-lang.org/pub/ruby/#{major}/#{File.basename(t.name)}"
+    end
+    sh "wget #{url} || curl -O #{url}", chdir: File.dirname(t.name)
+  end
+
+  # Create tasks for each host out of the ":" separated hosts list in the HOST variable.
+  # These tasks are processed in parallel as dependencies to the "install" task.
+  mingw_hosts = ENV['HOST'] || Rake::ExtensionCompiler.mingw_host
+  mingw_hosts.split(":").each do |mingw_host|
+
+    # Use Rake::ExtensionCompiler helpers to find the proper host
+    mingw_target = mingw_host.gsub('msvc', '')
+
+    # define a location where built files for each host will be stored
+    build_dir = "#{USER_HOME}/builds/#{mingw_host}/#{ruby_cc_version}"
+    directory build_dir
+    install_dir = "#{USER_HOME}/ruby/#{mingw_host}/#{ruby_cc_version}"
+
+    # clean intermediate files and folders
+    CLEAN.include(build_dir)
+    CLOBBER.include(install_dir)
+
+    task :mingw32 do
+      unless mingw_host then
+        warn "You need to install mingw32 cross compile functionality to be able to continue."
+        warn "Please refer to your distribution/package manager documentation about installation."
+        fail
+      end
+    end
+
+    # generate the makefile in a clean build location
+    file "#{build_dir}/Makefile" => [build_dir, source_dir] do |t|
+
+      options = [
+        "--host=#{mingw_host}",
+        "--target=#{mingw_target}",
+        "--build=#{RUBY_BUILD}",
+        '--enable-shared',
+        '--disable-install-doc',
+        '--with-ext=',
+      ]
+
+      # Force Winsock2 for Ruby 1.8, 1.9 defaults to it
+      options << "--with-winsock2" if major == "1.8"
+      options << "--prefix=#{install_dir}"
+      sh File.expand_path("#{USER_HOME}/sources/#{ruby_cc_version}/configure"), *options, chdir: File.dirname(t.name)
+    end
+
+    # make
+    file "#{build_dir}/ruby.exe" => ["#{build_dir}/Makefile"] do |t|
+      sh MAKE, chdir: File.dirname(t.prerequisites.first)
+    end
+
+    # make install
+    file "#{USER_HOME}/ruby/#{mingw_host}/#{ruby_cc_version}/bin/ruby.exe" => ["#{build_dir}/ruby.exe"] do |t|
+      sh "#{MAKE} install", chdir: File.dirname(t.prerequisites.first)
+    end
+    multitask :install => ["#{USER_HOME}/ruby/#{mingw_host}/#{ruby_cc_version}/bin/ruby.exe"]
+  end
+end
+
+desc "Update rake-compiler list of installed Ruby versions"
+task 'update-config' do
+  config_file = "#{USER_HOME}/config.yml"
+  if File.exist?(config_file) then
+    puts "Updating #{config_file}"
+    config = YAML.load_file(config_file)
+  else
+    puts "Generating #{config_file}"
+    config = {}
+  end
+
+  files = Dir.glob("#{USER_HOME}/ruby/*/*/**/rbconfig.rb").sort
+
+  files.each do |rbconfig|
+    version, platform = rbconfig.match(/.*-(\d+\.\d+\.\d+).*\/([-\w]+)\/rbconfig/)[1,2]
+    platforms = [platform]
+
+    # fake alternate (binary compatible) i386-mswin32-60 platform
+    platform == "i386-mingw32" and
+      platforms.push "i386-mswin32-60"
+
+    platforms.each do |plat|
+      config["rbconfig-#{plat}-#{version}"] = rbconfig
+
+      # also store RubyGems-compatible version
+      gem_platform = Gem::Platform.new(plat)
+      config["rbconfig-#{gem_platform}-#{version}"] = rbconfig
+    end
+
+    puts "Found Ruby version #{version} for platform #{platform} (#{rbconfig})"
+  end
+
+  when_writing("Saving changes into #{config_file}") {
+    File.open(config_file, 'w') do |f|
+      f.puts config.to_yaml
+    end
+  }
+end
+
+task :default do
+  # Force the display of the available tasks when no option is given
+  Rake.application.options.show_task_pattern = //
+  Rake.application.display_tasks_and_comments
+end
+
+desc "Build rubies suitable for cross-platform development."
+task 'cross-ruby' => [:mingw32, :install, 'update-config']

data/vendor/bundle/ruby/3.4.0/gems/rake-compiler-1.3.2/tasks/bootstrap.rake

@@ -0,0 +1,11 @@
+desc 'Ensure all the cross compiled versions are installed'
+task :bootstrap do
+  fail "Sorry, this only works on OSX and Linux" if RUBY_PLATFORM =~ /mswin|mingw/
+
+  versions = %w(1.8.7-p371 1.9.3-p392 2.0.0-p0)
+
+  versions.each do |version|
+    puts "[INFO] Attempt to cross-compile Ruby #{version}"
+    ruby "-Ilib bin/rake-compiler cross-ruby VERSION=#{version}"
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rake-compiler-1.3.2/tasks/common.rake

@@ -0,0 +1,10 @@
+require 'rake/clean'
+
+# common pattern cleanup
+CLOBBER.include('tmp')
+
+# set default task
+task :default => [:spec, :features]
+
+# make packing depend on success of running specs and features
+task :package => [:spec, :features]

data/vendor/bundle/ruby/3.4.0/gems/rake-compiler-1.3.2/tasks/cucumber.rake

@@ -0,0 +1,23 @@
+begin
+  require 'cucumber/rake/task'
+rescue LoadError
+  warn "Cucumber gem is required, please install it. (gem install cucumber)"
+end
+
+if defined?(Cucumber)
+  namespace :cucumber do
+    Cucumber::Rake::Task.new('default', 'Run features testing C extension support') do |t|
+      t.profile       = 'default'
+      t.cucumber_opts = '--format pretty --no-source'
+    end
+    Cucumber::Rake::Task.new('java', 'Run features testing Java extension support') do |t|
+      t.profile       = 'java'
+      t.cucumber_opts = '--format pretty --no-source'
+    end
+
+    desc 'Run all features'
+    task :all => [:default, :java]
+  end
+  desc 'Alias for cucumber:default'
+  task :cucumber => 'cucumber:default'
+end

data/vendor/bundle/ruby/3.4.0/gems/rake-compiler-1.3.2/tasks/gem.rake

@@ -0,0 +1,15 @@
+require "bundler/gem_helper"
+
+base_dir = File.join(__dir__, "..")
+helper = Bundler::GemHelper.new(base_dir)
+helper.install
+
+release_task = Rake.application["release"]
+# We use Trusted Publishing.
+release_task.prerequisites.delete("build")
+release_task.prerequisites.delete("release:rubygem_push")
+release_task_comment = release_task.comment
+if release_task_comment
+  release_task.clear_comments
+  release_task.comment = release_task_comment.gsub(/ and build.*$/, "")
+end

data/vendor/bundle/ruby/3.4.0/gems/rake-compiler-1.3.2/tasks/rspec.rake

@@ -0,0 +1,9 @@
+begin
+  require "rspec/core/rake_task"
+rescue LoadError
+  warn "RSpec gem is required, please install it (gem install rspec)."
+end
+
+if defined?(RSpec::Core::RakeTask)
+  RSpec::Core::RakeTask.new(:spec)
+end