logstash-output-scalyr 0.1.5 → 0.1.6

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/Rakefile

@@ -1,332 +0,0 @@
-require_relative 'lib/concurrent-ruby/concurrent/version'
-require_relative 'lib/concurrent-ruby-edge/concurrent/edge/version'
-require_relative 'lib/concurrent-ruby/concurrent/utility/engine'
-
-if Concurrent.ruby_version :<, 2, 0, 0
-  # @!visibility private
-  module Kernel
-    def __dir__
-      File.dirname __FILE__
-    end
-  end
-end
-
-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'] && !Concurrent.on_jruby?
-
-Rake::JavaExtensionTask.new('concurrent_ruby', core_gemspec) do |ext|
-  ext.ext_dir = 'ext/concurrent-ruby'
-  ext.lib_dir = 'lib/concurrent-ruby/concurrent'
-end
-
-unless Concurrent.on_jruby?
-  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
-
-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
-      sh 'bundle package'
-
-      # 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
-      RakeCompilerDock.sh 'bundle install --local && bundle exec rake cross native package --trace'
-    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 && !Concurrent.on_jruby?
-Gem::PackageTask.new(edge_gemspec) {} if edge_gemspec
-
-CLEAN.include('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
-                    --tag ~notravis ]
-      t.rspec_opts = [*options].join(' ')
-    end
-
-    desc '* test packaged and installed gems instead of local files'
-    task :installed do
-      Dir.chdir(__dir__) do
-        sh "gem install pkg/concurrent-ruby-#{Concurrent::VERSION}.gem"
-        sh "gem install pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem" if Concurrent.on_cruby?
-        sh "gem install pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem"
-        ENV['NO_PATH'] = 'true'
-        sh 'bundle update'
-        sh 'bundle exec rake spec:ci'
-      end
-    end
-  end
-
-  desc 'executed in CI'
-  task :ci => [:compile, 'spec:ci']
-
-  task :default => [:clobber, :compile, :spec]
-rescue LoadError => e
-  puts 'RSpec is not installed, skipping test task definitions: ' + e.message
-end
-
-current_yard_version_name = Concurrent::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.md',
-                      '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
-
-    define_uptodate_task = -> name do
-      namespace name do
-        desc "** ensure that #{name} generated documentation is matching the source code"
-        task :uptodate do
-          Dir.chdir(__dir__) do
-            begin
-              FileUtils.cp_r 'docs', 'docs-copy', verbose: true
-              Rake::Task["yard:#{name}"].invoke
-              sh 'diff -r docs/ docs-copy/' do |ok, res|
-                unless ok
-                  begin
-                    STDOUT.puts 'Command failed. Continue? (y/n)'
-                    input = STDIN.gets.strip.downcase
-                  end until %w(y n).include?(input)
-                  exit 1 if input == 'n'
-                end
-              end
-            ensure
-              FileUtils.rm_rf 'docs-copy', verbose: true
-            end
-          end
-        end
-      end
-    end
-
-    define_uptodate_task.call current_yard_version_name
-    define_uptodate_task.call 'master'
-  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
-
-  mri_version   = '2.6.5'
-  jruby_version = 'jruby-9.2.9.0'
-
-  task :checks => "yard:#{current_yard_version_name}:uptodate" do
-    Dir.chdir(__dir__) do
-      sh 'test -z "$(git status --porcelain)"' do |ok, res|
-        unless ok
-          begin
-            STDOUT.puts 'Command failed. 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 'Command failed. 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
-    Dir.chdir(__dir__) do
-      old = ENV['RBENV_VERSION']
-
-      ENV['RBENV_VERSION'] = mri_version
-      sh 'rbenv version'
-      sh 'bundle exec rake spec:installed'
-
-      ENV['RBENV_VERSION'] = jruby_version
-      sh 'rbenv version'
-      sh 'bundle exec rake spec:installed'
-
-      puts 'Windows build is untested'
-
-      ENV['RBENV_VERSION'] = old
-    end
-  end
-
-  desc '* do all nested steps'
-  task :publish => ['publish:ask', 'publish:tag', 'publish:rubygems', 'publish:post_steps']
-
-  namespace :publish do
-    publish_edge = false
-
-    task :ask do
-      begin
-        STDOUT.puts 'Do you want to publish anything? (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 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 do
-      Dir.chdir(__dir__) do
-        sh "git tag v#{Concurrent::VERSION}"
-        sh "git push origin v#{Concurrent::VERSION}"
-        sh "git tag edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
-        sh "git push origin edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
-      end
-    end
-
-    desc '** push all *.gem files to rubygems'
-    task :rubygems do
-      Dir.chdir(__dir__) do
-        sh "gem push pkg/concurrent-ruby-#{Concurrent::VERSION}.gem"
-        sh "gem push pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem" if publish_edge
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem"
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x64-mingw32.gem"
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x86-mingw32.gem"
-      end
-    end
-
-    desc '** print post release steps'
-    task :post_steps do
-      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/jruby/2.5.0/gems/concurrent-ruby-1.1.6/ext/concurrent-ruby/ConcurrentRubyService.java

@@ -1,17 +0,0 @@
-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/jruby/2.5.0/gems/concurrent-ruby-1.1.6/ext/concurrent-ruby/com/concurrent_ruby/ext/AtomicReferenceLibrary.java

@@ -1,175 +0,0 @@
-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);
-        }
-    }
-}