Hello community, here is the log from the commit of package rubygem-concurrent-ruby for openSUSE:Factory checked in at 2017-03-14 10:06:16 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/rubygem-concurrent-ruby (Old) and /work/SRC/openSUSE:Factory/.rubygem-concurrent-ruby.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "rubygem-concurrent-ruby" Tue Mar 14 10:06:16 2017 rev:5 rq:479069 version:1.0.5 Changes: -------- --- /work/SRC/openSUSE:Factory/rubygem-concurrent-ruby/rubygem-concurrent-ruby.changes 2017-01-15 11:18:12.397311814 +0100 +++ /work/SRC/openSUSE:Factory/.rubygem-concurrent-ruby.new/rubygem-concurrent-ruby.changes 2017-03-14 10:07:12.550751476 +0100 @@ -1,0 +2,7 @@ +Mon Mar 13 12:12:16 UTC 2017 - hvogel@suse.com + +- Update to 1.0.5 + see installed CHANGELOG.md and + https://github.com/ruby-concurrency/concurrent-ruby/releases/tag/v1.0.5 + +------------------------------------------------------------------- Old: ---- concurrent-ruby-1.0.4.gem New: ---- concurrent-ruby-1.0.5.gem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ rubygem-concurrent-ruby.spec ++++++ --- /var/tmp/diff_new_pack.dUd5EM/_old 2017-03-14 10:07:13.010686349 +0100 +++ /var/tmp/diff_new_pack.dUd5EM/_new 2017-03-14 10:07:13.014685782 +0100 @@ -1,7 +1,7 @@ # # spec file for package rubygem-concurrent-ruby # -# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -24,7 +24,7 @@ # Name: rubygem-concurrent-ruby -Version: 1.0.4 +Version: 1.0.5 Release: 0 %define mod_name concurrent-ruby %define mod_full_name %{mod_name}-%{version} ++++++ concurrent-ruby-1.0.4.gem -> concurrent-ruby-1.0.5.gem ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/CHANGELOG.md new/CHANGELOG.md --- old/CHANGELOG.md 2016-12-27 03:03:31.000000000 +0100 +++ new/CHANGELOG.md 2017-02-26 18:03:11.000000000 +0100 @@ -1,4 +1,20 @@ -## Current Release v1.0.4 (27 Dec 2016) +## Release v1.0.5, edge v0.3.1 (26 Feb 2017) + +concurrent-ruby: + +* Documentation for Event and Semaphore +* Use Unsafe#fullFence and #loadFence directly since the shortcuts were removed in JRuby +* Do not depend on org.jruby.util.unsafe.UnsafeHolder + +concurrent-ruby-edge: + +* (#620) Actors on Pool raise an error +* (#624) Delayed promises did not interact correctly with flatting + * Fix arguments yielded by callback methods +* Overridable default executor in promises factory methods +* Asking actor to terminate will always resolve to `true` + +## Release v1.0.4, edge v0.3.0 (27 Dec 2016) concurrent-ruby: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/README.md new/README.md --- old/README.md 2016-12-27 03:03:31.000000000 +0100 +++ new/README.md 2017-02-26 18:03:11.000000000 +0100 @@ -84,7 +84,7 @@ Thread-safe variables: -* [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A way to manage shared, mutable, *asynchronous*, independent, state. Based on Clojure's [Agent](http://clojure.org/agents). +* [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A way to manage shared, mutable, *asynchronous*, independent state. Based on Clojure's [Agent](http://clojure.org/agents). * [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, mutable, *synchronous*, independent state. Based on Clojure's [Atom](http://clojure.org/atoms). * [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.h...) A boolean value that can be updated atomically. * [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.ht...) A numeric value that can be updated atomically. Binary files old/checksums.yaml.gz and new/checksums.yaml.gz differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/concurrent/atomic/abstract_thread_local_var.rb new/lib/concurrent/atomic/abstract_thread_local_var.rb --- old/lib/concurrent/atomic/abstract_thread_local_var.rb 2016-12-27 03:03:31.000000000 +0100 +++ new/lib/concurrent/atomic/abstract_thread_local_var.rb 2017-02-26 18:03:11.000000000 +0100 @@ -15,7 +15,9 @@ if block_given? @default_block = default_block + @default = nil else + @default_block = nil @default = default end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/concurrent/atomic/atomic_boolean.rb new/lib/concurrent/atomic/atomic_boolean.rb --- old/lib/concurrent/atomic/atomic_boolean.rb 2016-12-27 03:03:31.000000000 +0100 +++ new/lib/concurrent/atomic/atomic_boolean.rb 2017-02-26 18:03:11.000000000 +0100 @@ -112,5 +112,11 @@ # # @!macro atomic_boolean_public_api class AtomicBoolean < AtomicBooleanImplementation + # @return [String] Short string representation. + def to_s + format '<#%s:0x%x value:%s>', self.class, object_id << 1, value + end + + alias_method :inspect, :to_s end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/concurrent/atomic/atomic_fixnum.rb new/lib/concurrent/atomic/atomic_fixnum.rb --- old/lib/concurrent/atomic/atomic_fixnum.rb 2016-12-27 03:03:31.000000000 +0100 +++ new/lib/concurrent/atomic/atomic_fixnum.rb 2017-02-26 18:03:11.000000000 +0100 @@ -131,7 +131,9 @@ class AtomicFixnum < AtomicFixnumImplementation # @return [String] Short string representation. def to_s - format '<#%s:0x%x value:%s>', self.class, object_id << 1, get + format '<#%s:0x%x value:%s>', self.class, object_id << 1, value end + + alias_method :inspect, :to_s end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/concurrent/atomic/atomic_reference.rb new/lib/concurrent/atomic/atomic_reference.rb --- old/lib/concurrent/atomic/atomic_reference.rb 2016-12-27 03:03:31.000000000 +0100 +++ new/lib/concurrent/atomic/atomic_reference.rb 2017-02-26 18:03:11.000000000 +0100 @@ -46,4 +46,6 @@ def to_s format '<#%s:0x%x value:%s>', self.class, object_id << 1, get end + + alias_method :inspect, :to_s end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/concurrent/atomic/event.rb new/lib/concurrent/atomic/event.rb --- old/lib/concurrent/atomic/event.rb 2016-12-27 03:03:31.000000000 +0100 +++ new/lib/concurrent/atomic/event.rb 2017-02-26 18:03:11.000000000 +0100 @@ -13,6 +13,26 @@ # `#reset` at any time once it has been set. # # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms682655.aspx + # @example + # event = Concurrent::Event.new + # + # t1 = Thread.new do + # puts "t1 is waiting" + # event.wait(1) + # puts "event ocurred" + # end + # + # t2 = Thread.new do + # puts "t2 calling set" + # event.set + # end + # + # [t1, t2].each(&:join) + # + # # prints: + # # t2 calling set + # # t1 is waiting + # # event ocurred class Event < Synchronization::LockableObject # Creates a new `Event` in the unset state. Threads calling `#wait` on the diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/concurrent/atomic/semaphore.rb new/lib/concurrent/atomic/semaphore.rb --- old/lib/concurrent/atomic/semaphore.rb 2016-12-27 03:03:31.000000000 +0100 +++ new/lib/concurrent/atomic/semaphore.rb 2017-02-26 18:03:11.000000000 +0100 @@ -108,6 +108,38 @@ # count of the number available and acts accordingly. # # @!macro semaphore_public_api + # @example + # semaphore = Concurrent::Semaphore.new(2) + # + # t1 = Thread.new do + # semaphore.acquire + # puts "Thread 1 acquired semaphore" + # end + # + # t2 = Thread.new do + # semaphore.acquire + # puts "Thread 2 acquired semaphore" + # end + # + # t3 = Thread.new do + # semaphore.acquire + # puts "Thread 3 acquired semaphore" + # end + # + # t4 = Thread.new do + # sleep(2) + # puts "Thread 4 releasing semaphore" + # semaphore.release + # end + # + # [t1, t2, t3, t4].each(&:join) + # + # # prints: + # # Thread 3 acquired semaphore + # # Thread 2 acquired semaphore + # # Thread 4 releasing semaphore + # # Thread 1 acquired semaphore + # class Semaphore < SemaphoreImplementation end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/concurrent/edge.rb new/lib/concurrent/edge.rb --- old/lib/concurrent/edge.rb 2016-12-27 03:03:31.000000000 +0100 +++ new/lib/concurrent/edge.rb 2017-02-26 18:03:11.000000000 +0100 @@ -15,10 +15,6 @@ # features should remain in this module until merged into the core gem. This # will prevent namespace collisions. # - # This file should *never* be used as a global `require` for all files within - # the edge gem. Because these features are experimental users should always - # explicitly require only what they need. - # # @!macro [attach] edge_warning # @api Edge # @note **Edge Feature:** Edge features are under active development and may change frequently. They are expected not to diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/concurrent/synchronization/condition.rb new/lib/concurrent/synchronization/condition.rb --- old/lib/concurrent/synchronization/condition.rb 2016-12-27 03:03:32.000000000 +0100 +++ new/lib/concurrent/synchronization/condition.rb 2017-02-26 18:03:11.000000000 +0100 @@ -1,9 +1,12 @@ module Concurrent module Synchronization + # TODO (pitr-ch 04-Dec-2016): should be in edge class Condition < LockableObject safe_initialization! # TODO (pitr 12-Sep-2015): locks two objects, improve + # TODO (pitr 26-Sep-2015): study + # http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/8-b13... singleton_class.send :alias_method, :private_new, :new private_class_method :new diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/concurrent/synchronization/lock.rb new/lib/concurrent/synchronization/lock.rb --- old/lib/concurrent/synchronization/lock.rb 2016-12-27 03:03:32.000000000 +0100 +++ new/lib/concurrent/synchronization/lock.rb 2017-02-26 18:03:11.000000000 +0100 @@ -1,5 +1,6 @@ module Concurrent module Synchronization + # TODO (pitr-ch 04-Dec-2016): should be in edge class Lock < LockableObject # TODO use JavaReentrantLock on JRuby diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/concurrent/synchronization/object.rb new/lib/concurrent/synchronization/object.rb --- old/lib/concurrent/synchronization/object.rb 2016-12-27 03:03:32.000000000 +0100 +++ new/lib/concurrent/synchronization/object.rb 2017-02-26 18:03:11.000000000 +0100 @@ -22,6 +22,7 @@ # - volatile instance variables see {Object.attr_volatile} # - volatile instance variables see {Object.attr_atomic} class Object < ObjectImplementation + # TODO make it a module if possible # @!method self.attr_volatile(*names) # Creates methods for reading and writing (as `attr_accessor` does) to a instance variable with diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/concurrent/version.rb new/lib/concurrent/version.rb --- old/lib/concurrent/version.rb 2016-12-27 03:03:32.000000000 +0100 +++ new/lib/concurrent/version.rb 2017-02-26 18:03:11.000000000 +0100 @@ -1,4 +1,4 @@ module Concurrent - VERSION = '1.0.4' - EDGE_VERSION = '0.3.0' + VERSION = '1.0.5' + EDGE_VERSION = '0.3.1' end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/metadata new/metadata --- old/metadata 2016-12-27 03:03:31.000000000 +0100 +++ new/metadata 2017-02-26 18:03:11.000000000 +0100 @@ -1,7 +1,7 @@ --- !ruby/object:Gem::Specification name: concurrent-ruby version: !ruby/object:Gem::Version - version: 1.0.4 + version: 1.0.5 platform: ruby authors: - Jerry D'Antonio @@ -10,14 +10,12 @@ autorequire: bindir: bin cert_chain: [] -date: 2016-12-27 00:00:00.000000000 Z +date: 2017-02-26 00:00:00.000000000 Z dependencies: [] description: | Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more. Inspired by Erlang, Clojure, Go, JavaScript, actors, and classic concurrency patterns. -email: -- jerry.dantonio@gmail.com -- concurrent-ruby@googlegroups.com +email: concurrent-ruby@googlegroups.com executables: [] extensions: [] extra_rdoc_files: @@ -171,7 +169,7 @@ version: '0' requirements: [] rubyforge_project: -rubygems_version: 2.5.1 +rubygems_version: 2.6.8 signing_key: specification_version: 4 summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,