persistent-dmnd 2.0.2 → 2.0.3

data/lib/persistent_dmnd/version.rb

@@ -2,13 +2,13 @@
 # typed: strong
 
 # Persistent-💎: Ruby gem for easily creating immutable data structures
-# Copyright (c) 2017 Ivo Anjo <ivo.anjo@ist.utl.pt>
+# Copyright (c) 2017-2021 Ivo Anjo <ivo@ivoanjo.me>
 #
 # This file is part of Persistent-💎.
 #
 # MIT License
 #
-# Copyright (c) 2017 Ivo Anjo
+# Copyright (c) 2017-2021 Ivo Anjo
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -31,5 +31,5 @@
 # frozen_string_literal: true
 
 module Persistent💎
-  VERSION = '2.0.2'
+  VERSION = "2.0.3"
 end

data/persistent-dmnd.gemspec

@@ -1,13 +1,13 @@
 # encoding: UTF-8
 
 # Persistent-💎: Ruby gem for easily creating immutable data structures
-# Copyright (c) 2017 Ivo Anjo <ivo.anjo@ist.utl.pt>
+# Copyright (c) 2017-2021 Ivo Anjo <ivo@ivoanjo.me>
 #
 # This file is part of Persistent-💎.
 #
 # MIT License
 #
-# Copyright (c) 2017 Ivo Anjo
+# Copyright (c) 2017-2021 Ivo Anjo
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -29,37 +29,40 @@
 
 # frozen_string_literal: true
 
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'persistent_dmnd/version'
+require "persistent_dmnd/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'persistent-dmnd'
-  spec.version       = Persistent💎::VERSION
-  spec.authors       = 'Ivo Anjo'
-  spec.email         = 'ivo@ivoanjo.me'
+  spec.name = "persistent-dmnd"
+  spec.version = Persistent💎::VERSION
+  spec.authors = "Ivo Anjo"
+  spec.email = "ivo@ivoanjo.me"
 
-  spec.summary       = 'Persistent-💎: Because Immutable Data Is Forever'
-  spec.description   = 'A tiny ruby gem that gives you a beautiful short-hand syntax for creating immutable arrays, hashes and sets'
-  spec.homepage      = 'https://gitlab.com/ivoanjo/persistent-dmnd/'
-  spec.license       = 'MIT'
+  spec.summary = "Persistent-💎: Because Immutable Data Is Forever"
+  spec.description = "A tiny ruby gem that gives you a beautiful short-hand syntax for creating immutable arrays, hashes and sets"
+  spec.homepage = "https://gitlab.com/ivoanjo/persistent-dmnd/"
+  spec.license = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 1.9.3'
+  spec.required_ruby_version = ">= 1.9.3"
 
-  spec.add_development_dependency 'bundler', '~> 1.16' if RUBY_VERSION < '2.7'
-  spec.add_development_dependency 'rake', '~> 12.2' # Note: Rake 12.2 is the last that supports Ruby 1.9
-  spec.add_development_dependency 'rspec', '~> 3.8'
-  spec.add_development_dependency 'concurrent-ruby', '~> 1.1'
-  spec.add_development_dependency 'rufo', '~> 0.7' if RUBY_VERSION >= '2.4.5'
-  spec.add_development_dependency 'pry' if RUBY_VERSION >= '2.0.0'
-  spec.add_development_dependency 'pry-byebug' if RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '2.4'
-  spec.add_development_dependency 'pry-debugger-jruby' if RUBY_ENGINE == 'jruby' && !JRUBY_VERSION.start_with?('1.7.')
-  spec.add_development_dependency 'sorbet' if RUBY_VERSION < '2.7'
+  spec.add_development_dependency "bundler", "~> 1.16" if RUBY_VERSION < "2.6"
+  spec.add_development_dependency "rake", "~> 12.2" # Note: Rake 12.2 is the last that supports Ruby 1.9
+  spec.add_development_dependency "rspec", "~> 3.8"
+  spec.add_development_dependency "concurrent-ruby", "~> 1.1"
+  spec.add_development_dependency "rufo", "~> 0.13" if RUBY_VERSION >= "2.6.0"
+  spec.add_development_dependency "pry" if RUBY_VERSION >= "2.0.0"
+  spec.add_development_dependency "pry-byebug" if RUBY_ENGINE == "ruby" && RUBY_VERSION >= "2.4"
+  spec.add_development_dependency "pry-debugger-jruby" if RUBY_ENGINE == "jruby" && !JRUBY_VERSION.start_with?("1.7.")
+  unless RUBY_ENGINE == "truffleruby"
+    spec.add_development_dependency "sorbet"
+    spec.add_development_dependency "spoom", "~> 1.1" if RUBY_VERSION >= "2.3.7"
+  end
 
-  spec.add_dependency 'hamster', '~> 3.0'
+  spec.add_dependency "hamster", "~> 3.0"
 end

data/sorbet/rbi/gems/concurrent-ruby.rbi

@@ -7,7 +7,8 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/concurrent-ruby/all/concurrent-ruby.rbi
 #
-# concurrent-ruby-1.1.5
+# concurrent-ruby-1.1.9
+
 module Concurrent
   def abort_transaction; end
   def atomically; end
@@ -44,6 +45,7 @@ module Concurrent
   def self.processor_counter; end
   def self.use_simple_logger(level = nil, output = nil); end
   def self.use_stdlib_logger(level = nil, output = nil); end
+  extend Concurrent::Concern::Deprecation
   extend Concurrent::Concern::Logging
   extend Concurrent::Utility::EngineDetector
   extend Concurrent::Utility::NativeExtensionLoader
@@ -139,6 +141,7 @@ module Concurrent::Synchronization::ConditionSignalling
 end
 class Concurrent::Synchronization::MutexLockableObject < Concurrent::Synchronization::AbstractLockableObject
   def initialize(*defaults); end
+  def initialize_copy(other); end
   def ns_wait(timeout = nil); end
   def self.new(*args, &block); end
   def synchronize; end
@@ -146,6 +149,7 @@ class Concurrent::Synchronization::MutexLockableObject < Concurrent::Synchroniza
 end
 class Concurrent::Synchronization::MonitorLockableObject < Concurrent::Synchronization::AbstractLockableObject
   def initialize(*defaults); end
+  def initialize_copy(other); end
   def ns_wait(timeout = nil); end
   def self.new(*args, &block); end
   def synchronize; end
@@ -153,6 +157,7 @@ class Concurrent::Synchronization::MonitorLockableObject < Concurrent::Synchroni
 end
 class Concurrent::Synchronization::RbxLockableObject < Concurrent::Synchronization::AbstractLockableObject
   def initialize(*defaults); end
+  def initialize_copy(other); end
   def ns_broadcast; end
   def ns_signal; end
   def ns_wait(timeout = nil); end
@@ -353,10 +358,12 @@ class Concurrent::AbstractThreadLocalVar
 end
 class Concurrent::RubyThreadLocalVar < Concurrent::AbstractThreadLocalVar
   def allocate_storage; end
-  def default_for(thread); end
+  def get_default; end
   def get_threadlocal_array(thread = nil); end
-  def self.thread_finalizer(array); end
-  def self.threadlocal_finalizer(index); end
+  def next_index; end
+  def self.semi_sync(&block); end
+  def self.thread_finalizer(id); end
+  def self.thread_local_finalizer(index); end
   def set_threadlocal_array(array, thread = nil); end
   def value; end
   def value=(value); end
@@ -438,6 +445,12 @@ module Concurrent::Concern::Logging
   def log(level, progname, message = nil, &block); end
   include Logger::Severity
 end
+module Concurrent::Concern::Deprecation
+  def deprecated(message, strip = nil); end
+  def deprecated_method(old_name, new_name); end
+  extend Concurrent::Concern::Deprecation
+  include Concurrent::Concern::Logging
+end
 module Concurrent::ExecutorService
   def <<(task); end
   def can_overflow?; end
@@ -445,28 +458,14 @@ module Concurrent::ExecutorService
   def serialized?; end
   include Concurrent::Concern::Logging
 end
-class Concurrent::AtExitImplementation < Concurrent::Synchronization::LockableObject
-  def add(handler_id = nil, &handler); end
-  def delete(handler_id); end
-  def enabled=(value); end
-  def enabled?; end
-  def handler?(handler_id); end
-  def handlers; end
-  def initialize(*args); end
-  def install; end
-  def ns_initialize(enabled = nil); end
-  def run; end
-  def runner; end
-  include Logger::Severity
-end
 class Concurrent::AbstractExecutorService < Concurrent::Synchronization::LockableObject
   def auto_terminate=(value); end
   def auto_terminate?; end
   def fallback_policy; end
   def handle_fallback(*args); end
-  def initialize(*args, &block); end
+  def initialize(opts = nil, &block); end
   def kill; end
-  def ns_auto_terminate=(value); end
+  def name; end
   def ns_auto_terminate?; end
   def ns_execute(*args, &task); end
   def ns_kill_execution; end
@@ -475,8 +474,9 @@ class Concurrent::AbstractExecutorService < Concurrent::Synchronization::Lockabl
   def shutdown; end
   def shutdown?; end
   def shuttingdown?; end
-  def terminate_at_exit; end
+  def to_s; end
   def wait_for_termination(timeout = nil); end
+  include Concurrent::Concern::Deprecation
   include Concurrent::ExecutorService
 end
 module Concurrent::SerialExecutorService
@@ -547,6 +547,7 @@ class Concurrent::RubyThreadPoolExecutor < Concurrent::RubyExecutorService
   def remaining_capacity; end
   def remove_busy_worker(worker); end
   def scheduled_task_count; end
+  def synchronous; end
   def worker_died(worker); end
   def worker_not_old_enough(worker); end
   def worker_task_completed; end
@@ -554,7 +555,7 @@ end
 class Concurrent::RubyThreadPoolExecutor::Worker
   def <<(message); end
   def create_worker(queue, pool, idletime); end
-  def initialize(pool); end
+  def initialize(pool, id); end
   def kill; end
   def run_task(pool, task, args); end
   def stop; end
@@ -579,7 +580,7 @@ end
 class Concurrent::SimpleExecutorService < Concurrent::RubyExecutorService
   def <<(task); end
   def kill; end
-  def ns_initialize; end
+  def ns_initialize(*args); end
   def post(*args, &task); end
   def running?; end
   def self.<<(task); end
@@ -847,12 +848,78 @@ end
 module Concurrent::ThreadSafe
 end
 module Concurrent::ThreadSafe::Util
+  def self.make_synchronized_on_cruby(klass); end
+  def self.make_synchronized_on_rbx(klass); end
+  def self.make_synchronized_on_truffleruby(klass); end
 end
 class Concurrent::Array < Array
 end
 class Concurrent::Hash < Hash
 end
-class Concurrent::Set < Set
+class Concurrent::CRubySet < Set
+  def &(*args); end
+  def +(*args); end
+  def -(*args); end
+  def <(*args); end
+  def <<(*args); end
+  def <=(*args); end
+  def ==(*args); end
+  def ===(*args); end
+  def >(*args); end
+  def >=(*args); end
+  def ^(*args); end
+  def add(*args); end
+  def add?(*args); end
+  def classify(*args); end
+  def clear(*args); end
+  def collect!(*args); end
+  def compare_by_identity(*args); end
+  def compare_by_identity?(*args); end
+  def delete(*args); end
+  def delete?(*args); end
+  def delete_if(*args); end
+  def difference(*args); end
+  def disjoint?(*args); end
+  def divide(*args); end
+  def each(*args); end
+  def empty?(*args); end
+  def eql?(*args); end
+  def filter!(*args); end
+  def flatten!(*args); end
+  def flatten(*args); end
+  def flatten_merge(*args); end
+  def freeze(*args); end
+  def hash(*args); end
+  def include?(*args); end
+  def initialize(*args, &block); end
+  def initialize_copy(other); end
+  def inspect(*args); end
+  def intersect?(*args); end
+  def intersection(*args); end
+  def keep_if(*args); end
+  def length(*args); end
+  def map!(*args); end
+  def member?(*args); end
+  def merge(*args); end
+  def pretty_print(*args); end
+  def pretty_print_cycle(*args); end
+  def proper_subset?(*args); end
+  def proper_superset?(*args); end
+  def reject!(*args); end
+  def replace(*args); end
+  def reset(*args); end
+  def select!(*args); end
+  def size(*args); end
+  def subset?(*args); end
+  def subtract(*args); end
+  def superset?(*args); end
+  def to_a(*args); end
+  def to_s(*args); end
+  def to_set(*args); end
+  def union(*args); end
+  def |(*args); end
+end
+class Concurrent::Set < Concurrent::CRubySet
 end
 class Concurrent::Collection::NonConcurrentMapBackend
   def [](key); end
@@ -895,6 +962,7 @@ class Concurrent::Collection::MriMapBackend < Concurrent::Collection::NonConcurr
 end
 class Concurrent::Map < Concurrent::Collection::MriMapBackend
   def [](key); end
+  def []=(key, value); end
   def each; end
   def each_key; end
   def each_pair; end
@@ -946,6 +1014,7 @@ class Concurrent::Async::AsyncDelegator < Concurrent::Synchronization::LockableO
   def initialize(delegate); end
   def method_missing(method, *args, &block); end
   def perform; end
+  def reset_if_forked; end
   def respond_to_missing?(method, include_private = nil); end
 end
 class Concurrent::Async::AwaitDelegator
@@ -1025,6 +1094,7 @@ module Concurrent::Synchronization::AbstractStruct
   def ns_each_pair; end
   def ns_equality(other); end
   def ns_get(member); end
+  def ns_initialize_copy; end
   def ns_inspect; end
   def ns_merge(other, &block); end
   def ns_select; end
@@ -1040,6 +1110,7 @@ module Concurrent::ImmutableStruct
   def [](member); end
   def each(&block); end
   def each_pair(&block); end
+  def initialize_copy(original); end
   def inspect; end
   def merge(other, &block); end
   def select(&block); end
@@ -1058,6 +1129,7 @@ module Concurrent::MutableStruct
   def []=(member, value); end
   def each(&block); end
   def each_pair(&block); end
+  def initialize_copy(original); end
   def inspect; end
   def merge(other, &block); end
   def select(&block); end
@@ -1128,6 +1200,7 @@ module Concurrent::SettableStruct
   def []=(member, value); end
   def each(&block); end
   def each_pair(&block); end
+  def initialize_copy(original); end
   def inspect; end
   def merge(other, &block); end
   def select(&block); end

data/sorbet/rbi/gems/hamster.rbi

@@ -8,6 +8,7 @@
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/hamster/all/hamster.rbi
 #
 # hamster-3.0.0
+
 module Hamster
   def self.enumerate(enum); end
   def self.from(obj); end