pangea-core 0.1.0 → 0.3.0

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/Rakefile

@@ -0,0 +1,344 @@
+version = File.read("#{__dir__}/lib/concurrent-ruby/concurrent/version.rb")[/'(.+)'/, 1] or raise
+edge_version = File.read("#{__dir__}/lib/concurrent-ruby-edge/concurrent/edge/version.rb")[/'(.+)'/, 1] or raise
+
+core_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby.gemspec')
+ext_gemspec  = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-ext.gemspec')
+edge_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-edge.gemspec')
+
+require 'rake/javaextensiontask'
+
+ENV['JRUBY_HOME'] = ENV['CONCURRENT_JRUBY_HOME'] if ENV['CONCURRENT_JRUBY_HOME'] && RUBY_ENGINE != 'jruby'
+
+Rake::JavaExtensionTask.new('concurrent_ruby', core_gemspec) do |ext|
+  ext.ext_dir = 'ext/concurrent-ruby'
+  ext.lib_dir = 'lib/concurrent-ruby/concurrent'
+  ext.source_version = '8'
+  ext.target_version = '8'
+end
+
+if RUBY_ENGINE == 'ruby'
+  require 'rake/extensiontask'
+
+  Rake::ExtensionTask.new('concurrent_ruby_ext', ext_gemspec) do |ext|
+    ext.ext_dir        = 'ext/concurrent-ruby-ext'
+    ext.lib_dir        = 'lib/concurrent-ruby/concurrent'
+    ext.source_pattern = '*.{c,h}'
+
+    ext.cross_compile  = true
+    ext.cross_platform = ['x86-mingw32', 'x64-mingw32']
+  end
+end
+
+def which?(executable)
+  !`which #{executable} 2>/dev/null`.empty?
+end
+
+require 'rake_compiler_dock'
+namespace :repackage do
+  desc '* with Windows fat distributions'
+  task :all do
+    Dir.chdir(__dir__) do
+      # store gems in vendor cache for docker
+      Bundler.with_original_env do
+        sh 'bundle package'
+      end
+
+      # build only the jar file not the whole gem for java platform, the jar is part the concurrent-ruby-x.y.z.gem
+      Rake::Task['lib/concurrent-ruby/concurrent/concurrent_ruby.jar'].invoke
+
+      # build all gem files
+      rack_compiler_dock_kwargs = {}
+      if which?('podman') and (!which?('docker') || `docker --version`.include?('podman'))
+        # podman and only podman available, so RakeCompilerDock will use podman, otherwise it uses docker
+        rack_compiler_dock_kwargs = {
+          options: ['--privileged'], # otherwise the directory in the image is empty
+          runas: false
+        }
+      end
+      %w[x86-mingw32 x64-mingw32].each do |plat|
+        RakeCompilerDock.sh(
+          "bundle install --local && bundle exec rake native:#{plat} gem --trace",
+          platform: plat,
+          **rack_compiler_dock_kwargs)
+      end
+    end
+  end
+end
+
+require 'rubygems'
+require 'rubygems/package_task'
+
+Gem::PackageTask.new(core_gemspec) {} if core_gemspec
+Gem::PackageTask.new(ext_gemspec) {} if ext_gemspec && RUBY_ENGINE != 'jruby'
+Gem::PackageTask.new(edge_gemspec) {} if edge_gemspec
+
+CLEAN.include(
+  'lib/concurrent-ruby/concurrent/concurrent_ruby_ext.*',
+  'lib/concurrent-ruby/concurrent/2.*',
+  'lib/concurrent-ruby/concurrent/*.jar')
+
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  namespace :spec do
+    desc '* Configured for ci'
+    RSpec::Core::RakeTask.new(:ci) do |t|
+      options      = %w[ --color
+                    --backtrace
+                    --order defined
+                    --format documentation ]
+      t.rspec_opts = [*options].join(' ')
+    end
+
+    desc '* test packaged and installed gems instead of local files'
+    task :installed do
+      Bundler.with_original_env do
+        Dir.chdir(__dir__) do
+          sh "gem install pkg/concurrent-ruby-#{version}.gem"
+          sh "gem install pkg/concurrent-ruby-ext-#{version}.gem" if RUBY_ENGINE == 'ruby'
+          sh "gem install pkg/concurrent-ruby-edge-#{edge_version}.gem"
+          ENV['NO_PATH'] = 'true'
+          sh 'bundle update'
+          sh 'bundle exec rake spec:ci'
+        end
+      end
+    end
+  end
+
+  desc 'executed in CI'
+  task :ci => [:compile, 'spec:ci']
+
+  desc 'run each spec file in a separate process to help find missing requires'
+  task 'spec:isolated' do
+    glob = "#{ENV['DIR'] || 'spec'}/**/*_spec.rb"
+    from = ENV['FROM']
+    env = { 'ISOLATED' => 'true' }
+    Dir[glob].each do |spec|
+      next if from and from != spec
+      from = nil if from == spec
+
+      sh env, 'rspec', spec
+    end
+  end
+
+  task :default => [:clobber, :compile, :spec]
+rescue LoadError => e
+  puts 'RSpec is not installed, skipping test task definitions: ' + e.message
+end
+
+current_yard_version_name = version
+
+begin
+  require 'yard'
+  require 'md_ruby_eval'
+  require_relative 'support/yard_full_types'
+
+  common_yard_options = ['--no-yardopts',
+                         '--no-document',
+                         '--no-private',
+                         '--embed-mixins',
+                         '--markup', 'markdown',
+                         '--title', 'Concurrent Ruby',
+                         '--template', 'default',
+                         '--template-path', 'yard-template',
+                         '--default-return', 'undocumented']
+
+  desc 'Generate YARD Documentation (signpost, master)'
+  task :yard => ['yard:signpost', 'yard:master']
+
+  namespace :yard do
+
+    desc '* eval markdown files'
+    task :eval_md do
+      Dir.chdir File.join(__dir__, 'docs-source') do
+        sh 'bundle exec md-ruby-eval --auto'
+      end
+    end
+
+    task :update_readme do
+      Dir.chdir __dir__ do
+        content = File.read(File.join('README.md')).
+          gsub(/\[([\w ]+)\]\(http:\/\/ruby-concurrency\.github\.io\/concurrent-ruby\/master\/.*\)/) do |_|
+          case $1
+          when 'LockFreeLinkedSet'
+            "{Concurrent::Edge::#{$1} #{$1}}"
+          when '.dataflow'
+            '{Concurrent.dataflow Concurrent.dataflow}'
+          when 'thread pool'
+            '{file:thread_pools.md thread pool}'
+          else
+            "{Concurrent::#{$1} #{$1}}"
+          end
+        end
+        FileUtils.mkpath 'tmp'
+        File.write 'tmp/README.md', content
+      end
+    end
+
+    define_yard_task = -> name do
+      output_dir = "docs/#{name}"
+
+      removal_name = "remove.#{name}"
+      task removal_name do
+        Dir.chdir __dir__ do
+          FileUtils.rm_rf output_dir
+        end
+      end
+
+      desc "* of #{name} into subdir #{name}"
+      YARD::Rake::YardocTask.new(name) do |yard|
+        yard.options.push(
+          '--output-dir', output_dir,
+          '--main', 'tmp/README.md',
+          *common_yard_options)
+        yard.files = ['./lib/concurrent-ruby/**/*.rb',
+                      './lib/concurrent-ruby-edge/**/*.rb',
+                      './ext/concurrent_ruby_ext/**/*.c',
+                      '-',
+                      'docs-source/thread_pools.md',
+                      'docs-source/promises.out.md',
+                      'docs-source/medium-example.out.rb',
+                      'LICENSE.txt',
+                      'CHANGELOG.md']
+      end
+      Rake::Task[name].prerequisites.push removal_name,
+                                          # 'yard:eval_md',
+                                          'yard:update_readme'
+    end
+
+    define_yard_task.call current_yard_version_name
+    define_yard_task.call 'master'
+
+    desc "* signpost for versions"
+    YARD::Rake::YardocTask.new(:signpost) do |yard|
+      yard.options.push(
+        '--output-dir', 'docs',
+        '--main', 'docs-source/signpost.md',
+        *common_yard_options)
+      yard.files = ['no-lib']
+    end
+  end
+
+rescue LoadError => e
+  puts 'YARD is not installed, skipping documentation task definitions: ' + e.message
+end
+
+desc 'build, test, and publish the gem'
+task :release => ['release:checks', 'release:build', 'release:test', 'release:publish']
+
+namespace :release do
+  # Depends on environment of @pitr-ch
+
+  task :checks do
+    raise '$CONCURRENT_JRUBY_HOME must be set' unless ENV['CONCURRENT_JRUBY_HOME']
+
+    Dir.chdir(__dir__) do
+      sh 'test -z "$(git status --porcelain)"' do |ok, res|
+        unless ok
+          begin
+            status = `git status --porcelain`
+            STDOUT.puts 'There are local changes that you might want to commit.', status, 'Continue? (y/n)'
+            input = STDIN.gets.strip.downcase
+          end until %w(y n).include?(input)
+          exit 1 if input == 'n'
+        end
+      end
+      sh 'git fetch'
+      sh 'test $(git show-ref --verify --hash refs/heads/master) = ' +
+           '$(git show-ref --verify --hash refs/remotes/origin/master)' do |ok, res|
+        unless ok
+          begin
+            STDOUT.puts 'Local master branch is not pushed to origin.', 'Continue? (y/n)'
+            input = STDIN.gets.strip.downcase
+          end until %w(y n).include?(input)
+          exit 1 if input == 'n'
+        end
+      end
+    end
+  end
+
+  desc '* build all *.gem files necessary for release'
+  task :build => [:clobber, 'repackage:all']
+
+  desc '* test actual installed gems instead of cloned repository on MRI and JRuby'
+  task :test do
+    raise '$CONCURRENT_JRUBY_HOME must be set' unless ENV['CONCURRENT_JRUBY_HOME']
+
+    Dir.chdir(__dir__) do
+      puts "Testing with the installed gem"
+
+      Bundler.with_original_env do
+        sh 'ruby -v'
+        sh 'bundle install'
+        sh 'bundle exec rake spec:installed'
+
+        env = { "PATH" => "#{ENV.fetch('CONCURRENT_JRUBY_HOME')}/bin:#{ENV['PATH']}" }
+        sh env, 'ruby -v'
+        sh env, 'bundle install'
+        sh env, 'bundle exec rake spec:installed'
+      end
+
+      puts 'Windows build is untested'
+    end
+  end
+
+  desc '* do all nested steps'
+  task :publish => ['publish:ask', 'publish:tag', 'publish:rubygems', 'publish:post_steps']
+
+  namespace :publish do
+    publish_base = nil
+    publish_edge = nil
+
+    task :ask do
+      begin
+        STDOUT.puts 'Do you want to publish anything now? (y/n)'
+        input = STDIN.gets.strip.downcase
+      end until %w(y n).include?(input)
+      exit 1 if input == 'n'
+
+      begin
+        STDOUT.puts 'Do you want to publish `concurrent-ruby`? (y/n)'
+        input = STDIN.gets.strip.downcase
+      end until %w(y n).include?(input)
+      publish_base = input == 'y'
+
+      begin
+        STDOUT.puts 'Do you want to publish `concurrent-ruby-edge`? (y/n)'
+        input = STDIN.gets.strip.downcase
+      end until %w(y n).include?(input)
+      publish_edge = input == 'y'
+    end
+
+    desc '** tag HEAD with current version and push to github'
+    task :tag => :ask do
+      Dir.chdir(__dir__) do
+        sh "git tag v#{version}" if publish_base
+        sh "git push origin v#{version}" if publish_base
+        sh "git tag edge-v#{edge_version}" if publish_edge
+        sh "git push origin edge-v#{edge_version}" if publish_edge
+      end
+    end
+
+    desc '** push all *.gem files to rubygems'
+    task :rubygems => :ask do
+      Dir.chdir(__dir__) do
+        sh "gem push pkg/concurrent-ruby-#{version}.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-edge-#{edge_version}.gem" if publish_edge
+        sh "gem push pkg/concurrent-ruby-ext-#{version}.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-ext-#{version}-x64-mingw32.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-ext-#{version}-x86-mingw32.gem" if publish_base
+      end
+    end
+
+    desc '** print post release steps'
+    task :post_steps do
+      # TODO: (petr 05-Jun-2021) automate and renew the process
+      puts 'Manually: create a release on GitHub with relevant changelog part'
+      puts 'Manually: send email same as release with relevant changelog part'
+      puts 'Manually: tweet'
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/ext/concurrent-ruby/ConcurrentRubyService.java

@@ -0,0 +1,17 @@
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import java.io.IOException;
+
+public class ConcurrentRubyService implements BasicLibraryService {
+
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        new com.concurrent_ruby.ext.AtomicReferenceLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JavaAtomicBooleanLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JavaAtomicFixnumLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JavaSemaphoreLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.SynchronizationLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JRubyMapBackendLibrary().load(runtime, false);
+        return true;
+    }
+}

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/ext/concurrent-ruby/com/concurrent_ruby/ext/AtomicReferenceLibrary.java

@@ -0,0 +1,175 @@
+package com.concurrent_ruby.ext;
+
+import java.lang.reflect.Field;
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+
+/**
+ * This library adds an atomic reference type to JRuby for use in the atomic
+ * library. We do a native version to avoid the implicit value coercion that
+ * normally happens through JI.
+ * 
+ * @author headius
+ */
+public class AtomicReferenceLibrary implements Library {
+    public void load(Ruby runtime, boolean wrap) throws IOException {
+        RubyModule concurrentMod = runtime.defineModule("Concurrent");
+        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaAtomicReference", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
+        try {
+            sun.misc.Unsafe.class.getMethod("getAndSetObject", Object.class);
+            atomicCls.setAllocator(JRUBYREFERENCE8_ALLOCATOR);
+        } catch (Exception e) {
+            // leave it as Java 6/7 version
+        }
+        atomicCls.defineAnnotatedMethods(JRubyReference.class);
+    }
+    
+    private static final ObjectAllocator JRUBYREFERENCE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JRubyReference(runtime, klazz);
+        }
+    };
+    
+    private static final ObjectAllocator JRUBYREFERENCE8_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JRubyReference8(runtime, klazz);
+        }
+    };
+
+    @JRubyClass(name="JRubyReference", parent="Object")
+    public static class JRubyReference extends RubyObject {
+        volatile IRubyObject reference;
+        
+        static final sun.misc.Unsafe UNSAFE;
+        static final long referenceOffset;
+
+        static {
+            try {
+                UNSAFE = UnsafeHolder.U;
+                Class k = JRubyReference.class;
+                referenceOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("reference"));
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        public JRubyReference(Ruby runtime, RubyClass klass) {
+            super(runtime, klass);
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context) {
+            UNSAFE.putObject(this, referenceOffset, context.nil);
+            return context.nil;
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context, IRubyObject value) {
+            UNSAFE.putObject(this, referenceOffset, value);
+            return context.nil;
+        }
+
+        @JRubyMethod(name = {"get", "value"})
+        public IRubyObject get() {
+            return reference;
+        }
+
+        @JRubyMethod(name = {"set", "value="})
+        public IRubyObject set(IRubyObject newValue) {
+            UNSAFE.putObjectVolatile(this, referenceOffset, newValue);
+            return newValue;
+        }
+
+        @JRubyMethod(name = {"compare_and_set", "compare_and_swap"})
+        public IRubyObject compare_and_set(ThreadContext context, IRubyObject expectedValue, IRubyObject newValue) {
+            Ruby runtime = context.runtime;
+            
+            if (expectedValue instanceof RubyNumeric) {
+                // numerics are not always idempotent in Ruby, so we need to do slower logic
+                return compareAndSetNumeric(context, expectedValue, newValue);
+            }
+            
+            return runtime.newBoolean(UNSAFE.compareAndSwapObject(this, referenceOffset, expectedValue, newValue));
+        }
+
+        @JRubyMethod(name = {"get_and_set", "swap"})
+        public IRubyObject get_and_set(ThreadContext context, IRubyObject newValue) {
+            // less-efficient version for Java 6 and 7
+            while (true) {
+                IRubyObject oldValue = get();
+                if (UNSAFE.compareAndSwapObject(this, referenceOffset, oldValue, newValue)) {
+                    return oldValue;
+                }
+            }
+        }
+        
+        private IRubyObject compareAndSetNumeric(ThreadContext context, IRubyObject expectedValue, IRubyObject newValue) {
+            Ruby runtime = context.runtime;
+            
+            // loop until:
+            // * reference CAS would succeed for same-valued objects
+            // * current and expected have different values as determined by #equals
+            while (true) {
+                IRubyObject current = reference;
+
+                if (!(current instanceof RubyNumeric)) {
+                    // old value is not numeric, CAS fails
+                    return runtime.getFalse();
+                }
+
+                RubyNumeric currentNumber = (RubyNumeric)current;
+                if (!currentNumber.equals(expectedValue)) {
+                    // current number does not equal expected, fail CAS
+                    return runtime.getFalse();
+                }
+
+                // check that current has not changed, or else allow loop to repeat
+                boolean success = UNSAFE.compareAndSwapObject(this, referenceOffset, current, newValue);
+                if (success) {
+                    // value is same and did not change in interim...success
+                    return runtime.getTrue();
+                }
+            }
+        }
+    }
+
+    private static final class UnsafeHolder {
+	private UnsafeHolder(){}
+	    
+	public static final sun.misc.Unsafe U = loadUnsafe();
+	
+	private static sun.misc.Unsafe loadUnsafe() {
+	    try {
+		Class unsafeClass = Class.forName("sun.misc.Unsafe");
+		Field f = unsafeClass.getDeclaredField("theUnsafe");
+		f.setAccessible(true);
+		return (sun.misc.Unsafe) f.get(null);
+	    } catch (Exception e) {
+		return null;
+	    }
+	}
+    }
+    
+    public static class JRubyReference8 extends JRubyReference {
+        public JRubyReference8(Ruby runtime, RubyClass klass) {
+            super(runtime, klass);
+        }
+
+        @Override
+        public IRubyObject get_and_set(ThreadContext context, IRubyObject newValue) {
+            // efficient version for Java 8
+            return (IRubyObject)UNSAFE.getAndSetObject(this, referenceOffset, newValue);
+        }
+    }
+}