lazy_record 0.1.0

data/vendor/bundle/gems/thread_safe-0.3.6/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--format progress

data/vendor/bundle/gems/thread_safe-0.3.6/.travis.yml

@@ -0,0 +1,46 @@
+dist: trusty
+sudo: required
+language: ruby
+rvm:
+  - 2.4.0
+  - 2.3.3
+  - 2.2.6
+  - 2.1.9
+  - 2.0.0
+  - 1.9.3
+  - ruby-head
+  - jruby-9.1.5.0
+  - jruby-1.7.26
+  - jruby-head
+  - rubinius-3
+  - rubinius-2
+jdk:
+  - openjdk7
+  - oraclejdk8
+matrix:
+  exclude:
+    - rvm: 2.4.0
+      jdk: oraclejdk8
+    - rvm: 2.3.3
+      jdk: oraclejdk8
+    - rvm: 2.2.6
+      jdk: oraclejdk8
+    - rvm: 2.1.9
+      jdk: oraclejdk8
+    - rvm: 2.0.0
+      jdk: oraclejdk8
+    - rvm: 1.9.3
+      jdk: oraclejdk8
+    - rvm: ruby-head
+      jdk: oraclejdk8
+    - rvm: rubinius-3
+      jdk: oraclejdk8
+    - rvm: rubinius-2
+      jdk: oraclejdk8
+  allow_failures:
+    - rvm: 1.9.3
+    - rvm: ruby-head
+    - rvm: jruby-1.7.26
+    - rvm: jruby-head
+    - rvm: rubinius-2
+script: "bundle exec rake test"

data/vendor/bundle/gems/thread_safe-0.3.6/.yardopts

@@ -0,0 +1,13 @@
+--protected
+--no-private
+--embed-mixins
+--output-dir ./yardoc
+--markup markdown
+--title=Concurrent Ruby
+--template default
+--template-path ./yard-template
+
+./lib/**/*.rb
+-
+README.md
+LICENSE

data/vendor/bundle/gems/thread_safe-0.3.6/Gemfile

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'rspec', '~> 3.2.0'
+  gem 'simplecov', '~> 0.9.2', :require => false
+  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
+    gem 'term-ansicolor', '~> 1.3.2', :require => false
+    gem 'tins', '~> 1.6.0', :require => false
+  end
+  gem 'coveralls', '~> 0.7.11', :require => false
+end
+
+group :documentation do
+  gem 'countloc', '~> 0.4.0', :platforms => :mri, :require => false
+  gem 'yard', '~> 0.8.7.6', :require => false
+  gem 'inch', '~> 0.5.10', :platforms => :mri, :require => false
+  gem 'redcarpet', '~> 3.2.2', platforms: :mri # understands github markdown
+end

data/vendor/bundle/gems/thread_safe-0.3.6/LICENSE

@@ -0,0 +1,144 @@
+Apache License
+
+Version 2.0, January 2004
+
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as 
+defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that 
+is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that 
+control, are controlled by, or are under common control with that entity. For the purposes 
+of this definition, "control" means (i) the power, direct or indirect, to cause the 
+direction or management of such entity, whether by contract or otherwise, or (ii) ownership 
+of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of 
+such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by 
+this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not 
+limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of 
+a Source form, including but not limited to compiled object code, generated documentation, 
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available 
+under the License, as indicated by a copyright notice that is included in or attached to the 
+work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on 
+(or derived from) the Work and for which the editorial revisions, annotations, elaborations, 
+or other modifications represent, as a whole, an original work of authorship. For the 
+purposes of this License, Derivative Works shall not include works that remain separable 
+from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works 
+thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work 
+and any modifications or additions to that Work or Derivative Works thereof, that is 
+intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by 
+an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the 
+purposes of this definition, "submitted" means any form of electronic, verbal, or written 
+communication sent to the Licensor or its representatives, including but not limited to 
+communication on electronic mailing lists, source code control systems, and issue tracking 
+systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and 
+improving the Work, but excluding communication that is conspicuously marked or otherwise 
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a 
+Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each 
+Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, 
+royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, 
+publicly display, publicly perform, sublicense, and distribute the Work and such Derivative 
+Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each 
+Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, 
+royalty-free, irrevocable (except as stated in this section) patent license to make, have 
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license 
+applies only to those patent claims licensable by such Contributor that are necessarily 
+infringed by their Contribution(s) alone or by combination of their Contribution(s) with the 
+Work to which such Contribution(s) was submitted. If You institute patent litigation against 
+any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or 
+a Contribution incorporated within the Work constitutes direct or contributory patent 
+infringement, then any patent licenses granted to You under this License for that Work shall 
+terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works 
+thereof in any medium, with or without modifications, and in Source or Object form, provided 
+that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of this License; 
+and
+
+You must cause any modified files to carry prominent notices stating that You changed the 
+files; and
+
+You must retain, in the Source form of any Derivative Works that You distribute, all 
+copyright, patent, trademark, and attribution notices from the Source form of the Work, 
+excluding those notices that do not pertain to any part of the Derivative Works; and
+
+If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative 
+Works that You distribute must include a readable copy of the attribution notices contained 
+within such NOTICE file, excluding those notices that do not pertain to any part of the 
+Derivative Works, in at least one of the following places: within a NOTICE text file 
+distributed as part of the Derivative Works; within the Source form or documentation, if 
+provided along with the Derivative Works; or, within a display generated by the Derivative 
+Works, if and wherever such third-party notices normally appear. The contents of the NOTICE 
+file are for informational purposes only and do not modify the License. You may add Your own 
+attribution notices within Derivative Works that You distribute, alongside or as an addendum 
+to the NOTICE text from the Work, provided that such additional attribution notices cannot 
+be construed as modifying the License. You may add Your own copyright statement to Your 
+modifications and may provide additional or different license terms and conditions for use, 
+reproduction, or distribution of Your modifications, or for any such Derivative Works as a 
+whole, provided Your use, reproduction, and distribution of the Work otherwise complies with 
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution 
+intentionally submitted for inclusion in the Work by You to the Licensor shall be under the 
+terms and conditions of this License, without any additional terms or conditions. 
+Notwithstanding the above, nothing herein shall supersede or modify the terms of any 
+separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, 
+service marks, or product names of the Licensor, except as required for reasonable and 
+customary use in describing the origin of the Work and reproducing the content of the NOTICE 
+file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, 
+Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" 
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, 
+without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, 
+MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for 
+determining the appropriateness of using or redistributing the Work and assume any risks 
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort 
+(including negligence), contract, or otherwise, unless required by applicable law (such as 
+deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be 
+liable to You for damages, including any direct, indirect, special, incidental, or 
+consequential damages of any character arising as a result of this License or out of the use 
+or inability to use the Work (including but not limited to damages for loss of goodwill, 
+work stoppage, computer failure or malfunction, or any and all other commercial damages or 
+losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative 
+Works thereof, You may choose to offer, and charge a fee for, acceptance of support, 
+warranty, indemnity, or other liability obligations and/or rights consistent with this 
+License. However, in accepting such obligations, You may act only on Your own behalf and on 
+Your sole responsibility, not on behalf of any other Contributor, and only if You agree to 
+indemnify, defend, and hold each Contributor harmless for any liability incurred by, or 
+claims asserted against, such Contributor by reason of your accepting any such warranty or 
+additional liability.
+
+END OF TERMS AND CONDITIONS

data/vendor/bundle/gems/thread_safe-0.3.6/README.md

@@ -0,0 +1,60 @@
+# Threadsafe (Inactive, code moved to concurrent-ruby gem and repo.)
+
+[![Gem Version](https://badge.fury.io/rb/thread_safe.svg)](http://badge.fury.io/rb/thread_safe) [![Build Status](https://travis-ci.org/ruby-concurrency/thread_safe.svg?branch=master)](https://travis-ci.org/ruby-concurrency/thread_safe) [![Coverage Status](https://img.shields.io/coveralls/ruby-concurrency/thread_safe/master.svg)](https://coveralls.io/r/ruby-concurrency/thread_safe) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/thread_safe.svg)](https://codeclimate.com/github/ruby-concurrency/thread_safe) [![Dependency Status](https://gemnasium.com/ruby-concurrency/thread_safe.svg)](https://gemnasium.com/ruby-concurrency/thread_safe) [![License](https://img.shields.io/badge/license-apache-green.svg)](http://opensource.org/licenses/MIT) [![Gitter chat](http://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg)](https://gitter.im/ruby-concurrency/concurrent-ruby)
+
+A collection of thread-safe versions of common core Ruby classes.
+
+__This code base is now part of the concurrent-ruby gem
+at https://github.com/ruby-concurrency/concurrent-ruby.
+The code in this repository is no longer maintained.__
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'thread_safe'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install thread_safe
+
+## Usage
+
+```ruby
+require 'thread_safe'
+
+sa = ThreadSafe::Array.new # supports standard Array.new forms
+sh = ThreadSafe::Hash.new # supports standard Hash.new forms
+```
+
+`ThreadSafe::Cache` also exists, as a hash-like object, and should have
+much better performance characteristics esp. under high concurrency than
+`ThreadSafe::Hash`. However, `ThreadSafe::Cache` is not strictly semantically
+equivalent to a ruby `Hash` -- for instance, it does not necessarily retain
+ordering by insertion time as `Hash` does. For most uses it should do fine
+though, and we recommend you consider `ThreadSafe::Cache` instead of
+`ThreadSafe::Hash` for your concurrency-safe hash needs. It understands some
+options when created (depending on your ruby platform) that control some of the
+internals - when unsure just leave them out:
+
+
+```ruby
+require 'thread_safe'
+
+cache = ThreadSafe::Cache.new
+```
+
+## Contributing
+
+1. Fork it
+2. Clone it (`git clone git@github.com:you/thread_safe.git`)
+3. Create your feature branch (`git checkout -b my-new-feature`)
+4. Build the jar (`rake jar`) NOTE: Requires JRuby
+5. Install dependencies (`bundle install`)
+6. Commit your changes (`git commit -am 'Added some feature'`)
+7. Push to the branch (`git push origin my-new-feature`)
+8. Create new Pull Request

data/vendor/bundle/gems/thread_safe-0.3.6/Rakefile

@@ -0,0 +1,62 @@
+require 'bundler/gem_tasks'
+require 'rspec'
+require 'rspec/core/rake_task'
+
+## safely load all the rake tasks in the `tasks` directory
+def safe_load(file)
+  begin
+    load file
+  rescue LoadError => ex
+    puts "Error loading rake tasks from '#{file}' but will continue..."
+    puts ex.message
+  end
+end
+
+Dir.glob('tasks/**/*.rake').each do |rakefile|
+  safe_load rakefile
+end
+
+task :default => :test
+
+if defined?(JRUBY_VERSION)
+  require 'ant'
+
+  directory 'pkg/classes'
+  directory 'pkg/tests'
+
+  desc "Clean up build artifacts"
+  task :clean do
+    rm_rf "pkg/classes"
+    rm_rf "pkg/tests"
+    rm_rf "lib/thread_safe/jruby_cache_backend.jar"
+  end
+
+  desc "Compile the extension"
+  task :compile => "pkg/classes" do |t|
+    ant.javac :srcdir => "ext", :destdir => t.prerequisites.first,
+      :source => "1.5", :target => "1.5", :debug => true,
+      :classpath => "${java.class.path}:${sun.boot.class.path}"
+  end
+
+  desc "Build the jar"
+  task :jar => :compile do
+    ant.jar :basedir => "pkg/classes", :destfile => "lib/thread_safe/jruby_cache_backend.jar", :includes => "**/*.class"
+  end
+
+  desc "Build test jar"
+  task 'test-jar' => 'pkg/tests' do |t|
+    ant.javac :srcdir => 'spec/src', :destdir => t.prerequisites.first,
+      :source => "1.5", :target => "1.5", :debug => true
+
+    ant.jar :basedir => 'pkg/tests', :destfile => 'spec/package.jar', :includes => '**/*.class'
+  end
+
+  task :package => [ :clean, :compile, :jar, 'test-jar' ]
+else
+  # No need to package anything for non-jruby rubies
+  task :package
+end
+
+RSpec::Core::RakeTask.new :test => :package do |t|
+  t.rspec_opts = '--color --backtrace --tag ~unfinished --seed 1 --format documentation ./spec'
+end

data/vendor/bundle/gems/thread_safe-0.3.6/examples/bench_cache.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby -wKU
+
+require "benchmark"
+require "thread_safe"
+
+hash  = {}
+cache = ThreadSafe::Cache.new
+
+ENTRIES = 10_000
+
+ENTRIES.times do |i|
+  hash[i]  = i
+  cache[i] = i
+end
+
+TESTS = 40_000_000
+Benchmark.bmbm do |results|
+  key = rand(10_000)
+
+  results.report('Hash#[]') do
+    TESTS.times { hash[key] }
+  end
+
+  results.report('Cache#[]') do
+    TESTS.times { cache[key] }
+  end
+
+  results.report('Hash#each_pair') do
+    (TESTS / ENTRIES).times { hash.each_pair {|k,v| v} }
+  end
+
+  results.report('Cache#each_pair') do
+    (TESTS / ENTRIES).times { cache.each_pair {|k,v| v} }
+  end
+end

data/vendor/bundle/gems/thread_safe-0.3.6/ext/org/jruby/ext/thread_safe/JRubyCacheBackendLibrary.java

@@ -0,0 +1,245 @@
+package org.jruby.ext.thread_safe;
+
+import org.jruby.*;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.ext.thread_safe.jsr166e.ConcurrentHashMap;
+import org.jruby.ext.thread_safe.jsr166e.ConcurrentHashMapV8;
+import org.jruby.ext.thread_safe.jsr166e.nounsafe.*;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+
+import java.io.IOException;
+import java.util.Map;
+
+import static org.jruby.runtime.Visibility.PRIVATE;
+
+/**
+ * Native Java implementation to avoid the JI overhead.
+ *
+ * @author thedarkone
+ */
+public class JRubyCacheBackendLibrary implements Library {
+    public void load(Ruby runtime, boolean wrap) throws IOException {
+        RubyClass jrubyRefClass = runtime.defineClassUnder("JRubyCacheBackend", runtime.getObject(), BACKEND_ALLOCATOR, runtime.getModule("ThreadSafe"));
+        jrubyRefClass.setAllocator(BACKEND_ALLOCATOR);
+        jrubyRefClass.defineAnnotatedMethods(JRubyCacheBackend.class);
+    }
+
+    private static final ObjectAllocator BACKEND_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JRubyCacheBackend(runtime, klazz);
+        }
+    };
+
+    @JRubyClass(name="JRubyCacheBackend", parent="Object")
+    public static class JRubyCacheBackend extends RubyObject {
+        // Defaults used by the CHM
+        static final int DEFAULT_INITIAL_CAPACITY = 16;
+        static final float DEFAULT_LOAD_FACTOR = 0.75f;
+
+        public static final boolean CAN_USE_UNSAFE_CHM = canUseUnsafeCHM();
+
+        private ConcurrentHashMap<IRubyObject, IRubyObject> map;
+
+        private static ConcurrentHashMap<IRubyObject, IRubyObject> newCHM(int initialCapacity, float loadFactor) {
+            if (CAN_USE_UNSAFE_CHM) {
+                return new ConcurrentHashMapV8<IRubyObject, IRubyObject>(initialCapacity, loadFactor);
+            } else {
+                return new org.jruby.ext.thread_safe.jsr166e.nounsafe.ConcurrentHashMapV8<IRubyObject, IRubyObject>(initialCapacity, loadFactor);
+            }
+        }
+
+        private static ConcurrentHashMap<IRubyObject, IRubyObject> newCHM() {
+            return newCHM(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
+        }
+
+        private static boolean canUseUnsafeCHM() {
+            try {
+                new org.jruby.ext.thread_safe.jsr166e.ConcurrentHashMapV8(); // force class load and initialization
+                return true;
+            } catch (Throwable t) { // ensuring we really do catch everything
+                // Doug's Unsafe setup errors always have this "Could not ini.." message
+                if (isCausedBySecurityException(t)) {
+                    return false;
+                }
+                throw (t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t));
+            }
+        }
+
+        private static boolean isCausedBySecurityException(Throwable t) {
+            while (t != null) {
+                if ((t.getMessage() != null && t.getMessage().contains("Could not initialize intrinsics")) || t instanceof SecurityException) {
+                    return true;
+                }
+                t = t.getCause();
+            }
+            return false;
+        }
+
+        public JRubyCacheBackend(Ruby runtime, RubyClass klass) {
+            super(runtime, klass);
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context) {
+            map = newCHM();
+            return context.getRuntime().getNil();
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context, IRubyObject options) {
+            map = toCHM(context, options);
+            return context.getRuntime().getNil();
+        }
+
+        private ConcurrentHashMap<IRubyObject, IRubyObject> toCHM(ThreadContext context, IRubyObject options) {
+            Ruby runtime = context.getRuntime();
+            if (!options.isNil() && options.respondsTo("[]")) {
+                IRubyObject rInitialCapacity = options.callMethod(context, "[]", runtime.newSymbol("initial_capacity"));
+                IRubyObject rLoadFactor      = options.callMethod(context, "[]", runtime.newSymbol("load_factor"));
+                int initialCapacity = !rInitialCapacity.isNil() ? RubyNumeric.num2int(rInitialCapacity.convertToInteger()) : DEFAULT_INITIAL_CAPACITY;
+                float loadFactor    = !rLoadFactor.isNil() ?      (float)RubyNumeric.num2dbl(rLoadFactor.convertToFloat()) : DEFAULT_LOAD_FACTOR;
+                return newCHM(initialCapacity, loadFactor);
+            } else {
+                return newCHM();
+            }
+        }
+
+        @JRubyMethod(name = "[]", required = 1)
+        public IRubyObject op_aref(ThreadContext context, IRubyObject key) {
+            IRubyObject value;
+            return ((value = map.get(key)) == null) ? context.getRuntime().getNil() : value;
+        }
+
+        @JRubyMethod(name = {"[]="}, required = 2)
+        public IRubyObject op_aset(IRubyObject key, IRubyObject value) {
+            map.put(key, value);
+            return value;
+        }
+
+        @JRubyMethod
+        public IRubyObject put_if_absent(IRubyObject key, IRubyObject value) {
+            IRubyObject result = map.putIfAbsent(key, value);
+            return result == null ? getRuntime().getNil() : result;
+        }
+
+        @JRubyMethod
+        public IRubyObject compute_if_absent(final ThreadContext context, final IRubyObject key, final Block block) {
+            return map.computeIfAbsent(key, new ConcurrentHashMap.Fun<IRubyObject, IRubyObject>() {
+                @Override
+                public IRubyObject apply(IRubyObject key) {
+                    return block.yieldSpecific(context);
+                }
+            });
+        }
+
+        @JRubyMethod
+        public IRubyObject compute_if_present(final ThreadContext context, final IRubyObject key, final Block block) {
+            IRubyObject result = map.computeIfPresent(key, new ConcurrentHashMap.BiFun<IRubyObject, IRubyObject, IRubyObject>() {
+                @Override
+                public IRubyObject apply(IRubyObject key, IRubyObject oldValue) {
+                    IRubyObject result = block.yieldSpecific(context, oldValue == null ? context.getRuntime().getNil() : oldValue);
+                    return result.isNil() ? null : result;
+                }
+            });
+            return result == null ? context.getRuntime().getNil() : result;
+        }
+
+        @JRubyMethod
+        public IRubyObject compute(final ThreadContext context, final IRubyObject key, final Block block) {
+            IRubyObject result = map.compute(key, new ConcurrentHashMap.BiFun<IRubyObject, IRubyObject, IRubyObject>() {
+                @Override
+                public IRubyObject apply(IRubyObject key, IRubyObject oldValue) {
+                    IRubyObject result = block.yieldSpecific(context, oldValue == null ? context.getRuntime().getNil() : oldValue);
+                    return result.isNil() ? null : result;
+                }
+            });
+            return result == null ? context.getRuntime().getNil() : result;
+        }
+
+        @JRubyMethod
+        public IRubyObject merge_pair(final ThreadContext context, final IRubyObject key, final IRubyObject value, final Block block) {
+            IRubyObject result = map.merge(key, value, new ConcurrentHashMap.BiFun<IRubyObject, IRubyObject, IRubyObject>() {
+                @Override
+                public IRubyObject apply(IRubyObject oldValue, IRubyObject newValue) {
+                    IRubyObject result = block.yieldSpecific(context, oldValue == null ? context.getRuntime().getNil() : oldValue);
+                    return result.isNil() ? null : result;
+                }
+            });
+            return result == null ? context.getRuntime().getNil() : result;
+        }
+
+        @JRubyMethod
+        public RubyBoolean replace_pair(IRubyObject key, IRubyObject oldValue, IRubyObject newValue) {
+            return getRuntime().newBoolean(map.replace(key, oldValue, newValue));
+        }
+
+        @JRubyMethod(name = "key?", required = 1)
+        public RubyBoolean has_key_p(IRubyObject key) {
+            return map.containsKey(key) ? getRuntime().getTrue() : getRuntime().getFalse();
+        }
+
+        @JRubyMethod
+        public IRubyObject key(IRubyObject value) {
+            final IRubyObject key = map.findKey(value);
+            return key == null ? getRuntime().getNil() : key;
+        }
+
+        @JRubyMethod
+        public IRubyObject replace_if_exists(IRubyObject key, IRubyObject value) {
+            IRubyObject result = map.replace(key, value);
+            return result == null ? getRuntime().getNil() : result;
+        }
+
+        @JRubyMethod
+        public IRubyObject get_and_set(IRubyObject key, IRubyObject value) {
+            IRubyObject result = map.put(key, value);
+            return result == null ? getRuntime().getNil() : result;
+        }
+
+        @JRubyMethod
+        public IRubyObject delete(IRubyObject key) {
+            IRubyObject result = map.remove(key);
+            return result == null ? getRuntime().getNil() : result;
+        }
+
+        @JRubyMethod
+        public RubyBoolean delete_pair(IRubyObject key, IRubyObject value) {
+            return getRuntime().newBoolean(map.remove(key, value));
+        }
+
+        @JRubyMethod
+        public IRubyObject clear() {
+            map.clear();
+            return this;
+        }
+
+        @JRubyMethod
+         public IRubyObject each_pair(ThreadContext context, Block block) {
+            for (Map.Entry<IRubyObject,IRubyObject> entry : map.entrySet()) {
+                block.yieldSpecific(context, entry.getKey(), entry.getValue());
+            }
+            return this;
+        }
+
+        @JRubyMethod
+        public RubyFixnum size(ThreadContext context) {
+            return context.getRuntime().newFixnum(map.size());
+        }
+
+        @JRubyMethod
+        public IRubyObject get_or_default(IRubyObject key, IRubyObject defaultValue) {
+            return map.getValueOrDefault(key, defaultValue);
+        }
+
+        @JRubyMethod(visibility = PRIVATE)
+        public JRubyCacheBackend initialize_copy(ThreadContext context, IRubyObject other) {
+            map = newCHM();
+            return this;
+        }
+    }
+}