dbg_tags 1.1.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaad620ad2b1c43ee4fad44431ff99f22d5fe07f66dbb68eb11247246d99083e
-  data.tar.gz: e33c27bb2b870e18bd4a910ef0918db018174f89eb3aaf95c2619bca74e0dee6
+  metadata.gz: 269e2882bb82fb4a015a17417744067bcbdbd6b98a6f5e799f4f57a332b6eadf
+  data.tar.gz: 288f736d512ba40960086f54413d149b2b7558e5223cbf5ff545e15dab79b8f6
 SHA512:
-  metadata.gz: 660f4307b55f0c7b0ff5e029916b436f000346c31cca80e1956eaada5a71599a2e1e21f654bc0d8cd6dfb086e0489445a4f4385394ec4f558e8f8284a9aaee59
-  data.tar.gz: 5be152c20aa033ba1372d132b7f514a0ddbd5fe5da459148e9790f120ad5c342564e24402c344cfb61aee4e437aa16238380b13f9a86520fe624242f1c4ec00b
+  metadata.gz: 072f1320bae3b4900d895370e17f717f125a721318a6e5a5bc393abef86507b18ca4de3c7b0f39ee4d12aa050dbd6829ceae3eb43bcdd44fe592b39da510114c
+  data.tar.gz: cfa63312d3ed1e16ab82d7e73737f6e87b5fe6df12dac8a11d8cec3ad6f0731c6029d43a223ed2d73e7cd2af9e07299175e2c5662854e6d725afaa51cce694ea

data/lib/dbg_tags.rb

@@ -130,7 +130,7 @@ module Tag
     #
     # enable performs a merge with an existing enable.
     def enable *features, **opts
-      org_enabled = @enabled.dup # to restore the state at the end (unused unless block_given)
+      org_enabled = @enabled.clone # to restore the state at the end (unused unless block_given)
       features.each do |feature|
         case feature
         when 0..5 # not a feature, apply to :generic
@@ -163,6 +163,21 @@ module Tag
       end # block_given?
     end # GlobalState.enable
 
+    # @param state [{Symbol=>0..5}] As returned by Tag.state (aka Tag.enabled)
+    # A block can be given to restore the original state afterwards.
+    # restore_state overwrites any existing enabled feature.
+    def restore_state state
+      org_enabled = @enabled.clone # to restore the state at the end (unused unless block_given)
+      @enabled = state.dup
+      if block_given?
+        begin
+          yield
+        ensure
+          @enabled = org_enabled
+        end # ensure
+      end # block_given?
+    end # GlobalState.restore_state
+
     # @param feature [Symbol]
     # @return [0..5] Current effective level for feature.
     def level feature
@@ -172,14 +187,31 @@ module Tag
 
   class << self
 
+    private # class methods of Tag
+
+    # @param value [Bool] Value to set
+    # Primarily for rspec stuff. Use {disable_fiber_local_state!} instead
+    def no_fiber_local_state= value
+      @no_fiber_local_state = value
+    end # Tag::no_fiber_local_state=
+
     public # class methods of Tag
 
-    # @return [GlobalState] Thread local data 
+    # @return [Bool,nil] True if we should store global state inside the Tag class itself.
+    attr :no_fiber_local_state
+    alias no_fiber_local_state? no_fiber_local_state
+
+    # @return [Bool] True (the default) if we should store global state
+    # in each fiber/thread of the application.
+    def use_fiber_local_state?; !no_fiber_local_state? end
+
+    # @return [GlobalState] Either fiber local data (default) or truly global.
     def global_state
-      if gs = Thread.current[:dbg_tags_global_state]
-        gs
+      if @no_fiber_local_state # testing undefined ivar here. But no warnings... That is good,
+          # at least for performance
+        @global_state ||= GlobalState.new
       else
-        Thread.current[:dbg_tags_global_state] = GlobalState.new
+        Thread.current[:dbg_tags_global_state] ||= GlobalState.new
       end
     end # Tag::global_state
 
@@ -240,8 +272,12 @@ module Tag
     # @see GlobalState.enable
     def enable(...); global_state.enable(...); end
 
+    # @see GlobalState.restore_state
+    def restore_state(...); global_state.restore_state(...); end
+
     # @return [{Symbol=>0..5}] Keys are the features
     def enabled; global_state.enabled; end
+    alias state enabled
 
     # @return [IO] By default this is STDERR
     def stream; global_state.stream; end
@@ -259,5 +295,20 @@ module Tag
     # @return [bool] Reflects explicit enable calls only. The :all feature is IGNORED
     def enabled? feature; (global_state.enabled[feature] || NONE) > NONE; end
 
+    # shortcut for no_fiber_local_state := true
+    # By default fiber local state is enabled but this means that
+    # 'enabling' of tags in some fiber does not work in others.
+    # Or more specific, that changing the Tag state outside of any fiber
+    # does not effect any fibers (already) created.
+    # Now it is possible to transfer data into the fiber using 'resume'
+    # but this is a hassle.
+    # So: when using threads leave this enabled, as it will cause race conditions.
+    # when using fibers, but no threads it is probably convenient to disable it.
+    def disable_fiber_local_state; self.no_fiber_local_state = true end
+
+    # shortcut for no_fiber_local_state := false
+    # For rspec use mostly.
+    def enable_fiber_local_state; self.no_fiber_local_state = false end
+
   end # singleton class Tag
 end # module Tag

data/spec/01_tag_spec.rb

@@ -1,6 +1,8 @@
 
-require 'simplecov'
-SimpleCov.start
+if t = ENV['USE_SIMPLECOV'] and !t.empty?
+  require 'simplecov'
+  SimpleCov.start { add_filter '/spec/' }
+end
 
 require_relative '../lib/dbg_tags'
 
@@ -9,7 +11,7 @@ class Pathological
     Tag.trc { "HERE in #{self}!" }
     super
   end # to_s
-end 
+end # class Pathological
 
 describe 'tag' do
   before :each do
@@ -253,6 +255,7 @@ describe 'tag' do
   end # context 'Nested levels'
 
   it 'has thread local data to prevent mix ups (tag_300)' do
+    Tag.enable_fiber_local_state # NOTE enabled by default, but other examples may botch it
     t1 = Thread.new do
       Tag.enable threads: :trc do
         Tag.trc(:threads) {
@@ -272,22 +275,108 @@ describe 'tag' do
   end # it
 
   it 'each thread has a private tag system (tag_301)' do
+    Tag.enable_fiber_local_state # NOTE enabled by default, but other examples may botch it
+    executed = false
     Tag.enable threads: :trc do
-      expect(Tag.enabled).to eq({threads: 3})
+      expect(Tag.enabled).to eq({threads: Tag::TRC})
       t1 = Thread.new do
         expect(Tag.enabled).to eq({})
         Tag.enable threads: :log do
-          expect(Tag.enabled).to eq({threads: 2})
-          Tag.trc(:threads) {
+          expect(Tag.enabled).to eq({threads: Tag::LOG})
+          Tag.log(:threads) {
             expect(Tag.inside?).to be true
             sleep 1
+            executed = true
             nil
           }
         end
       end 
       t1.join
-      expect(Tag.enabled).to eq({threads: 3})
+      expect(Tag.enabled).to eq({threads: Tag::TRC})
     end
+    expect(executed).to be true
+  end # it
+
+  it 'each fiber has a private tag system (tag_302)' do
+    Tag.enable_fiber_local_state # NOTE enabled by default, but other examples may botch it
+    executed = false
+    Tag.enable threads: :trc do
+      expect(Tag.enabled).to eq({threads: Tag::TRC})
+      t1 = Fiber.new do
+        expect(Tag.enabled).to eq({})
+        Tag.enable threads: :log do
+          expect(Tag.enabled).to eq({threads: Tag::LOG})
+          Tag.log(:threads) {
+            expect(Tag.inside?).to be true
+            executed = true
+            nil
+          }
+        end
+      end 
+      t1.resume
+      expect(Tag.enabled).to eq({threads: Tag::TRC})
+    end
+    expect(executed).to be true
+  end # it
+
+  it 'allows to disable fiber local state (tag_305)' do
+    Tag.disable_fiber_local_state
+    executed = false
+    Tag.enable threads: :trc do
+      expect(Tag.enabled).to eq({threads: Tag::TRC})
+      t1 = Fiber.new do
+        expect(Tag.enabled).to eq({threads: Tag::TRC})
+        Tag.enable threads: :log do
+          expect(Tag.enabled).to eq({threads: Tag::LOG})
+          Tag.log(:threads) {
+            expect(Tag.inside?).to be true
+            executed = true
+            nil
+          }
+        end
+      end 
+      t1.resume
+      expect(Tag.enabled).to eq({threads: Tag::TRC})
+      expect(executed).to be true
+    end
+  end # it
+
+  it 'does allow restore_state to transfer state through a Fiber barrier (tag_310)' do
+    Tag.enable_fiber_local_state
+    did_something = false
+    Tag.enable example: :dtl, fiber: :trc do
+      state = Tag.state # same as Tag.enabled
+      expect(state).to eq({example: Tag::DTL, fiber: Tag::TRC})
+      t1 = Fiber.new do
+        expect(Tag.state).to eq({})
+        Tag.enable foo: :trc
+        Tag.restore_state state do
+          expect(Tag.state).to eq({example: Tag::DTL, fiber: Tag::TRC})
+          did_something = true
+        end
+      end
+      t1.resume
+      expect(Tag.state).to eq({example: Tag::DTL, fiber: Tag::TRC})
+    end # enable
+    expect(did_something).to be true
+  end # it
+
+  it 'does allow a nil-state to transfer state through a Fiber barrier (tag_311)' do
+    Tag.enable_fiber_local_state
+    did_something = false
+    state = Tag.state
+    expect(state).to eq({})
+    t1 = Fiber.new do
+      expect(Tag.state).to eq({})
+      Tag.enable foo: :trc
+      Tag.restore_state state do
+        expect(Tag.state).to eq({})
+        did_something = true
+      end
+    end
+    t1.resume
+    expect(Tag.state).to eq({})
+    expect(did_something).to be true
   end # it
 
   it 'does not allow levels out of range (tag_900)' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dbg_tags
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.2
 platform: ruby
 authors:
 - Eugene Brazwick
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-06 00:00:00.000000000 Z
+date: 2024-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec