From be52d2cb4c282e35f2e4ce18a5c39e525b792715 Mon Sep 17 00:00:00 2001
From: mr <marian@rudzyn.ski>
Date: Sat, 21 Sep 2024 14:36:02 -0700
Subject: [PATCH 01/14] fix up icon, give it trigger mutators, go back closer
 to how WA is structured again

---
 public/examples/paladin/retribution.rb |  7 ++++++-
 public/node.rb                         | 13 +++++++++----
 public/node_spec.rb                    | 20 ++++++++++++++++++++
 public/weak_aura/icon.rb               | 13 +++++++++----
 public/weak_aura/icon_spec.rb          | 16 ++++++++++++++++
 5 files changed, 60 insertions(+), 9 deletions(-)
 create mode 100644 public/weak_aura/icon_spec.rb

diff --git a/public/examples/paladin/retribution.rb b/public/examples/paladin/retribution.rb
index 10134f1..8bbad81 100644
--- a/public/examples/paladin/retribution.rb
+++ b/public/examples/paladin/retribution.rb
@@ -13,7 +13,12 @@
   scale 0.8
   action_usable 'Wake of Ashes'
   action_usable 'Judgement'
-  action_usable 'Blade of Justice'
+  icon 'Blade of Justice' do
+    action_usable
+    action_usable spell_count: '>= 2' do
+      glow!
+    end
+  end
   action_usable 'Final Verdict'
   action_usable 'Bladestorm'
   action_usable 'Divine Toll'
diff --git a/public/node.rb b/public/node.rb
index ed5e818..9c35405 100644
--- a/public/node.rb
+++ b/public/node.rb
@@ -63,7 +63,7 @@ class Node # rubocop:disable Style/Documentation,Metrics/ClassLength
 
   def initialize(id: nil, type: nil, parent: nil, triggers: [], actions: { start: [], init: [], finish: [] }, &block) # rubocop:disable Metrics/MethodLength
     @uid = Digest::SHA1.hexdigest([id, parent, triggers, actions].to_json)[0..10]
-    @id = "#{id} (#{@uid})"
+    @id = id
     @parent = parent
     @children = []
     @controlled_children = []
@@ -182,8 +182,9 @@ def dynamic_group(name, **kwargs, &block)
   end
 
   def icon(*args, **kwargs, &block)
-    kwargs = { parent: self, type: type }.merge(kwargs)
-    icon = WeakAura::Icon.new(*args, **kwargs, &block)
+    args = { id: args[0] } if args[0].is_a?(String)
+    kwargs = { parent: self, type: type }.merge(args).merge(kwargs)
+    icon = WeakAura::Icon.new(**kwargs, &block)
     add_node(icon)
   end
 
@@ -245,7 +246,11 @@ def hide_ooc! # rubocop:disable Metrics/MethodLength
   end
 
   def as_json
-    { load: load, triggers: triggers, actions: actions, conditions: conditions,
+    { id: "#{id} (#{@uid})",
+      load: load,
+      triggers: triggers.is_a?(Hash) ? triggers : map_triggers(triggers),
+      actions: actions,
+      conditions: conditions,
       tocversion: TOC_VERSION }
   end
 end
diff --git a/public/node_spec.rb b/public/node_spec.rb
index 30d2c23..9e58d4e 100644
--- a/public/node_spec.rb
+++ b/public/node_spec.rb
@@ -3,6 +3,26 @@
 require './spec/spec_helper'
 
 RSpec.describe Node do
+  describe '#as_json' do
+    it 'maps triggers to a hash if they are still an array' do
+      node = Node.new
+      trigger = { test: 'test' }
+      expect(trigger).to receive(:as_json).and_return(trigger)
+      node.triggers = [trigger]
+      hash = node.as_json
+      expect(hash[:triggers]).to be_a(Hash)
+      expect(hash[:triggers][1]).to eq(trigger)
+    end
+  end
+
+  describe '#icon' do
+    it 'should accept a string and default id to it' do
+      node = Node.new
+      icon = node.icon 'Test'
+      expect(icon.id).to eq('Test')
+    end
+  end
+
   describe 'option' do
     it 'allows setting and modifying the default' do
       Node.option :foo, default: 'bar'
diff --git a/public/weak_aura/icon.rb b/public/weak_aura/icon.rb
index 4e57d37..9d65543 100644
--- a/public/weak_aura/icon.rb
+++ b/public/weak_aura/icon.rb
@@ -2,11 +2,16 @@
 
 class WeakAura
   class Icon < Node # rubocop:disable Metrics/ClassLength,Style/Documentation
-    def as_json # rubocop:disable Metrics/MethodLength
+    def action_usable!(**kwargs)
+      kwargs = { spell: id }.merge(kwargs)
+      triggers << Trigger::ActionUsable.new(**kwargs)
+    end
+
+    def as_json # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       super.merge(
         {
-          width: parent.options[:icon_width] || 64,
-          height: parent.options[:icon_height] || parent.options[:icon_width] || 64,
+          width: parent&.options&.[](:icon_width) || 64,
+          height: parent&.options&.[](:icon_height) || parent&.options&.[](:icon_width) || 64,
           iconSource: -1,
           authorOptions: [],
           yOffset: 0,
@@ -116,7 +121,7 @@ def as_json # rubocop:disable Metrics/MethodLength
           xOffset: 0,
           uid: uid,
           inverse: false,
-          parent: parent.id,
+          parent: parent&.id,
           conditions: conditions,
           information: []
         }
diff --git a/public/weak_aura/icon_spec.rb b/public/weak_aura/icon_spec.rb
new file mode 100644
index 0000000..10e61ae
--- /dev/null
+++ b/public/weak_aura/icon_spec.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require './spec/spec_helper'
+
+RSpec.describe WeakAura::Icon do
+  describe 'action_usable!' do
+    it 'adds an ActionUsable trigger that defaults to the icons name' do
+      icon = WeakAura::Icon.new(id: 'Rampage') do
+        action_usable!
+      end.as_json
+      pp icon
+      trigger = icon[:triggers][0]
+      expect(trigger.options[:spell_name]).to eq('Rampage')
+    end
+  end
+end

From d856d7b8c36505069a3fdf9292bf0c98db0a7c6a Mon Sep 17 00:00:00 2001
From: mr <marian@rudzyn.ski>
Date: Sat, 21 Sep 2024 14:49:44 -0700
Subject: [PATCH 02/14] make sure we can pass kwargs

---
 public/weak_aura/icon_spec.rb                   | 15 ++++++++++++---
 public/weak_aura/triggers/action_usable.rb      | 11 ++---------
 public/weak_aura/triggers/action_usable_spec.rb |  4 ++--
 3 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/public/weak_aura/icon_spec.rb b/public/weak_aura/icon_spec.rb
index 10e61ae..b26f086 100644
--- a/public/weak_aura/icon_spec.rb
+++ b/public/weak_aura/icon_spec.rb
@@ -8,9 +8,18 @@
       icon = WeakAura::Icon.new(id: 'Rampage') do
         action_usable!
       end.as_json
-      pp icon
-      trigger = icon[:triggers][0]
-      expect(trigger.options[:spell_name]).to eq('Rampage')
+      trigger = icon[:triggers][1][:trigger]
+      expect(trigger[:spellName]).to eq('Rampage')
+    end
+
+    it 'passes on named arguments' do
+      icon = WeakAura::Icon.new(id: 'Rampage') do
+        action_usable! spell_count: '>= 2' do
+          glow!
+        end
+      end.as_json
+      trigger = icon[:triggers][1][:trigger]
+      expect(trigger[:spellCount]).to eq(2)
     end
   end
 end
diff --git a/public/weak_aura/triggers/action_usable.rb b/public/weak_aura/triggers/action_usable.rb
index 38b74cb..3543fe7 100644
--- a/public/weak_aura/triggers/action_usable.rb
+++ b/public/weak_aura/triggers/action_usable.rb
@@ -30,18 +30,11 @@ def as_json # rubocop:disable Metrics/MethodLength
       }
 
       if options[:spell_count]
-        spell_count_operator = options[:spell_count].to_s.match(/[<>=]+/)&.[](0) || '=='
-        spell_count = if options[:spell_count].is_a?(Numeric)
-                        options[:spell_count]
-                      else
-                        options[:spell_count]
-                          .match(/[0-9]+/)&.[](0)
-                      end.to_i
-
+        spell_count, spell_count_operator = parse_count_operator(options[:spell_count], '==')
         if spell_count
           trigger
             .merge!({
-                      spellCount: spell_count,
+                      spellCount: spell_count.to_s,
                       use_spellCount: true,
                       spellCount_operator: spell_count_operator
                     })
diff --git a/public/weak_aura/triggers/action_usable_spec.rb b/public/weak_aura/triggers/action_usable_spec.rb
index 7007dfc..44ac273 100644
--- a/public/weak_aura/triggers/action_usable_spec.rb
+++ b/public/weak_aura/triggers/action_usable_spec.rb
@@ -5,13 +5,13 @@
 RSpec.describe Trigger::ActionUsable do
   it 'should accept spell_count and default to the equality operator' do
     trigger = Trigger::ActionUsable.new(spell_count: 1).as_json[:trigger]
-    expect(trigger[:spellCount]).to eq(1)
+    expect(trigger[:spellCount]).to eq('1')
     expect(trigger[:spellCount_operator]).to eq('==')
   end
 
   it 'should accept spell_count w/ gte operator' do
     trigger = Trigger::ActionUsable.new(spell_count: '>= 1').as_json[:trigger]
-    expect(trigger[:spellCount]).to eq(1)
+    expect(trigger[:spellCount]).to eq('1')
     expect(trigger[:spellCount_operator]).to eq('>=')
   end
 end

From 60ea5353a86518b0b528283c30ea7d2fb51ca4b6 Mon Sep 17 00:00:00 2001
From: mr <marian@rudzyn.ski>
Date: Sat, 21 Sep 2024 15:14:33 -0700
Subject: [PATCH 03/14] add support for action_usable charges and default to
 any trigger

---
 public/node.rb                             | 12 +++++++++---
 public/weak_aura/icon.rb                   |  4 ++++
 public/weak_aura/icon_spec.rb              |  2 +-
 public/weak_aura/triggers/action_usable.rb | 12 ++++++++++++
 4 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/public/node.rb b/public/node.rb
index 9c35405..b8edbf4 100644
--- a/public/node.rb
+++ b/public/node.rb
@@ -58,16 +58,20 @@
 class Node # rubocop:disable Style/Documentation,Metrics/ClassLength
   include Casting::Client
   delegate_missing_methods
-  attr_accessor :uid, :children, :controlled_children, :parent, :triggers, :actions, :type, :options
+  attr_accessor :uid, :children, :controlled_children, :parent, :triggers, :trigger_options, :actions, :type, :options
   attr_reader :conditions
 
-  def initialize(id: nil, type: nil, parent: nil, triggers: [], actions: { start: [], init: [], finish: [] }, &block) # rubocop:disable Metrics/MethodLength
+  def initialize(id: nil, type: nil, parent: nil, triggers: [], trigger_options: nil, actions: { start: [], init: [], finish: [] }, &block) # rubocop:disable Metrics/MethodLength,Metrics/ParameterLists,Layout/LineLength
     @uid = Digest::SHA1.hexdigest([id, parent, triggers, actions].to_json)[0..10]
     @id = id
     @parent = parent
     @children = []
     @controlled_children = []
     @triggers = triggers
+    @trigger_options = trigger_options || {
+      disjunctive: 'any',
+      activeTriggerMode: -10
+    }
     @actions = actions
     @conditions = []
     @type = type
@@ -138,7 +142,9 @@ def make_triggers(requires, if_missing: [], if_stacks: {}, triggers: []) # ruboc
   end
 
   def map_triggers(triggers)
-    Hash[*triggers.each_with_index.to_h { |trigger, index| [index + 1, trigger.as_json] }.flatten]
+    Hash[*triggers.each_with_index.to_h do |trigger, index|
+           [index + 1, trigger.as_json]
+         end.flatten].merge(trigger_options)
   end
 
   def load(spec: nil) # rubocop:disable Metrics/MethodLength
diff --git a/public/weak_aura/icon.rb b/public/weak_aura/icon.rb
index 9d65543..297bf91 100644
--- a/public/weak_aura/icon.rb
+++ b/public/weak_aura/icon.rb
@@ -2,6 +2,10 @@
 
 class WeakAura
   class Icon < Node # rubocop:disable Metrics/ClassLength,Style/Documentation
+    def all_triggers!
+      trigger_options.merge!({ disjunctive: 'all' })
+    end
+
     def action_usable!(**kwargs)
       kwargs = { spell: id }.merge(kwargs)
       triggers << Trigger::ActionUsable.new(**kwargs)
diff --git a/public/weak_aura/icon_spec.rb b/public/weak_aura/icon_spec.rb
index b26f086..3fbd01e 100644
--- a/public/weak_aura/icon_spec.rb
+++ b/public/weak_aura/icon_spec.rb
@@ -19,7 +19,7 @@
         end
       end.as_json
       trigger = icon[:triggers][1][:trigger]
-      expect(trigger[:spellCount]).to eq(2)
+      expect(trigger[:spellCount]).to eq('2')
     end
   end
 end
diff --git a/public/weak_aura/triggers/action_usable.rb b/public/weak_aura/triggers/action_usable.rb
index 3543fe7..e099b9a 100644
--- a/public/weak_aura/triggers/action_usable.rb
+++ b/public/weak_aura/triggers/action_usable.rb
@@ -41,6 +41,18 @@ def as_json # rubocop:disable Metrics/MethodLength
         end
       end
 
+      if options[:charges]
+        charges, charges_operator = parse_count_operator(options[:charges], '==')
+        if charges
+          trigger
+            .merge!({
+                      charges: charges.to_s,
+                      use_charges: true,
+                      charges_operator: charges_operator
+                    })
+        end
+      end
+
       {
         trigger: trigger
       }

From 899f46ed8e5efadd8d4dfd578c7bd729c04661e0 Mon Sep 17 00:00:00 2001
From: Marian Rudzynski <marian@rudzyn.ski>
Date: Sat, 28 Sep 2024 02:18:04 +0000
Subject: [PATCH 04/14] add trigger shortcuts for charges, etc.

---
 .devcontainer/devcontainer.json       |  6 ++---
 public/examples/mage/frost.rb         | 19 +++++++++++++
 public/examples/warrior/arms.rb       | 39 ++++++++++++++++++++-------
 public/examples/warrior/protection.rb | 21 +++++++++++++++
 public/weak_aura/icon.rb              |  3 ++-
 public/weak_aura/triggers.rb          | 15 +++++++++++
 public/weak_aura/triggers_spec.rb     |  6 +++++
 7 files changed, 96 insertions(+), 13 deletions(-)
 create mode 100644 public/weak_aura/triggers_spec.rb

diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index 3f5cf1b..a891373 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -1,6 +1,6 @@
 {
   "name": "weakauras",
-  "image": "ghcr.io/fx/docker/devcontainer:latest",
-  "containerUser": "vscode",
-  "postStartCommand": "bash .devcontainer/post-start-wrapper.sh"
+  "image": "codercom/enterprise-base:ubuntu",
+  "features": {},
+  "postCreateCommand": "bash -i -c .devcontainer/install-deps.sh"
 }
\ No newline at end of file
diff --git a/public/examples/mage/frost.rb b/public/examples/mage/frost.rb
index 582a26e..61e028a 100644
--- a/public/examples/mage/frost.rb
+++ b/public/examples/mage/frost.rb
@@ -9,6 +9,25 @@
 hide_ooc!
 
 dynamic_group 'Frost Mage WhackAuras' do
+  icon 'Ray of Frost' do
+    action_usable! do
+      aura 'Cryopathy' do
+        stacks '>= 2' do
+          glow!
+        end
+      end
+      # charges '>= 2' do
+      #   glow!
+      # end
+    end
+    # glow if cryopathy stacks >= 10?
+    # 
+  end
+
+  icon 'Ring of Fire' do
+    action_usable! do
+  end
+
   action_usable 'Comet Storm'
   action_usable 'Glacial Spike' do
     glow!
diff --git a/public/examples/warrior/arms.rb b/public/examples/warrior/arms.rb
index a561242..5d4982b 100644
--- a/public/examples/warrior/arms.rb
+++ b/public/examples/warrior/arms.rb
@@ -4,18 +4,41 @@
 # title: 'Warrior: Arms'
 # ---
 
+title 'Arms Warrior'
 load spec: :arms_warrior
 hide_ooc!
 
+dynamic_group 'Arms Stay Big' do
+  scale 0.7
+  offset y: -40, x: 60
+
+  action_usable 'Avatar'
+  action_usable 'Bladestorm'
+end
+
+dynamic_group 'Arms Stay Small' do
+  scale 0.7
+  offset y: -40, x: -60
+
+  action_usable 'Recklessness'
+  action_usable 'Thunderous Roar'
+  action_usable 'Colossus Smash'
+end
+
 dynamic_group 'Arms WhackAuras' do
+  scale 0.8
+  offset y: -80
+
+  action_usable 'Skullsplitter'
   action_usable 'Colossus Smash'
-  # action_usable 'Warbreaker'
-  action_usable 'Execute'
+  action_usable 'Execute' do
+    glow! # todo: glow on sudden death only
+  end
   action_usable 'Bladestorm'
+  action_usable 'Wrecking Throw'
   # TODO: cleave instead of MS display when more than N targets?
-  # action_usable 'Cleave'
+  action_usable 'Cleave'
   # action_usable 'Whirlwind'
-  action_usable 'Thunderous Roar'
 
   # TODO: add `stacks` to glow! instead
   # Min-maxing OP>MS is not recommended.
@@ -27,9 +50,7 @@
   # end
 
   action_usable ['Mortal Strike', 'Overpower']
-  action_usable 'Thunder Clap', requires: { target_debuffs_missing: ['Rend'] }
+  # action_usable 'Thunder Clap', requires: { target_debuffs_missing: ['Rend'] }
+  action_usable 'Rend', requires: { target_debuffs_missing: ['Rend'] }
   action_usable 'Sweeping Strikes'
-  action_usable 'Avatar' do
-    glow!
-  end
-end
+end
\ No newline at end of file
diff --git a/public/examples/warrior/protection.rb b/public/examples/warrior/protection.rb
index abaf113..ce34b1c 100644
--- a/public/examples/warrior/protection.rb
+++ b/public/examples/warrior/protection.rb
@@ -8,7 +8,28 @@
 load spec: :protection_warrior
 hide_ooc!
 
+dynamic_group 'Prot Stay Big' do
+  scale 0.7
+  offset y: -40, x: 60
+
+  action_usable 'Avatar'
+  action_usable "Champion's Spear"
+  action_usable 'Shield Wall'
+  action_usable 'Last Stand'
+end
+
+dynamic_group 'Prot Stay Small' do
+  scale 0.7
+  offset y: -40, x: -60
+
+  action_usable 'Thunderous Roar'
+  action_usable 'Demolish'
+end
+
 dynamic_group 'Prot WhackAuras' do
+  scale 0.8
+  offset y: -80
+
   action_usable 'Revenge'
   action_usable 'Shield Slam'
   action_usable 'Shield Block'
diff --git a/public/weak_aura/icon.rb b/public/weak_aura/icon.rb
index 297bf91..80d4399 100644
--- a/public/weak_aura/icon.rb
+++ b/public/weak_aura/icon.rb
@@ -6,9 +6,10 @@ def all_triggers!
       trigger_options.merge!({ disjunctive: 'all' })
     end
 
-    def action_usable!(**kwargs)
+    def action_usable!(**kwargs, &block)
       kwargs = { spell: id }.merge(kwargs)
       triggers << Trigger::ActionUsable.new(**kwargs)
+      block.call if block_given?
     end
 
     def as_json # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
diff --git a/public/weak_aura/triggers.rb b/public/weak_aura/triggers.rb
index b632180..05f53a0 100644
--- a/public/weak_aura/triggers.rb
+++ b/public/weak_aura/triggers.rb
@@ -18,6 +18,21 @@ def parse_count_operator(count, default_operator = '==')
       count = count.to_s.gsub(/^[<>!=]+/, '').to_i
       [count, operator]
     end
+
+    def charges(count_op, &block)
+      @options[:charges] = count_op 
+      block.call if block_given?
+    end
+
+    def stacks(count_op, &block)
+      @options[:stacks] = count_op 
+      block.call if block_given?
+    end
+
+    def remaining_time(count_op, &block)
+      @options[:remaining_time] = count_op 
+      block.call if block_given?
+    end
   end
 end
 
diff --git a/public/weak_aura/triggers_spec.rb b/public/weak_aura/triggers_spec.rb
new file mode 100644
index 0000000..29169e7
--- /dev/null
+++ b/public/weak_aura/triggers_spec.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require './spec/spec_helper'
+
+RSpec.describe Trigger::Base do
+end

From 6ee378f45e603dc9d7fad4ccf5d560cddce235f2 Mon Sep 17 00:00:00 2001
From: Marian Rudzynski <marian@rudzyn.ski>
Date: Sun, 29 Sep 2024 00:24:20 +0000
Subject: [PATCH 05/14] clean up devcontainer, let it install mise

---
 .devcontainer/install-deps.sh | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100755 .devcontainer/install-deps.sh

diff --git a/.devcontainer/install-deps.sh b/.devcontainer/install-deps.sh
new file mode 100755
index 0000000..17c3e34
--- /dev/null
+++ b/.devcontainer/install-deps.sh
@@ -0,0 +1,9 @@
+env
+echo `pwd`
+
+# Ruby requirements. Why won't mise install these for me?
+sudo apt update && sudo apt install -y zlib1g-dev libssl-dev libffi-dev libyaml-dev
+
+curl https://mise.run | sh
+echo 'eval "$(~/.local/bin/mise activate bash)"' >> ~/.bashrc
+mise install
\ No newline at end of file

From 4c077bdfba77e68bf7830c5e33a9319b3b7f3cb9 Mon Sep 17 00:00:00 2001
From: Marian Rudzynski <marian@rudzyn.ski>
Date: Mon, 30 Sep 2024 19:29:01 +0000
Subject: [PATCH 06/14] quick update to shadow

---
 public/examples/priest/shadow.rb | 30 +++++++++++++++++++++++++-----
 1 file changed, 25 insertions(+), 5 deletions(-)

diff --git a/public/examples/priest/shadow.rb b/public/examples/priest/shadow.rb
index 696f2ba..37ebaf9 100644
--- a/public/examples/priest/shadow.rb
+++ b/public/examples/priest/shadow.rb
@@ -8,17 +8,37 @@
 load spec: :shadow_priest
 hide_ooc!
 
-dynamic_group 'WhackAuras' do
+dynamic_group 'Shadow Stay Big' do
+  scale 0.6
+  offset y: -40, x: 80
+
+  action_usable 'Void Eruption'
+  action_usable 'Power Infusion'
+  action_usable 'Shadowfiend'
+end
+
+dynamic_group 'Shadow Stay Small' do
+  scale 0.6
+  offset y: -40, x: -80
+
+  action_usable 'Psyfiend'
+  action_usable 'Void Torrent'
+  action_usable 'Halo'
+end
+
+dynamic_group 'Shadow WhackAuras' do
+  scale 0.8
+  offset y: -70
+
   debuff_missing 'Shadow Word: Pain'
   debuff_missing 'Vampiric Touch'
 
+  action_usable 'Shadow Crash' do
+    glow!
+  end
   action_usable 'Mind Blast'
-  action_usable 'Void Torrent'
   action_usable 'Mindbender'
-  action_usable 'Halo'
-  action_usable 'Void Eruption'
   action_usable 'Shadow Word: Death'
-  action_usable 'Shadow Crash'
   action_usable 'Devouring Plague'
   action_usable 'Mind Flay: Insanity'
 end

From b1320403ffce007b516affd83572d069c016833d Mon Sep 17 00:00:00 2001
From: Marian Rudzynski <marian@rudzyn.ski>
Date: Thu, 14 Aug 2025 05:21:29 +0000
Subject: [PATCH 07/14] feat: complete conditional logic implementation

- Add aura method for conditional trigger contexts
- Update glow! to support operator parsing (>=, ==, etc)
- Enable nested conditionals via stacks/charges with blocks
- Pass parent node context to triggers for glow! forwarding
- Clean up commented code in examples
---
 public/examples/mage/frost.rb   |  7 +------
 public/examples/warrior/arms.rb | 12 ------------
 public/node.rb                  | 29 +++++++++++++++++++++++++----
 public/weak_aura/icon.rb        |  7 ++++---
 public/weak_aura/triggers.rb    | 25 +++++++++++++++++++++----
 5 files changed, 51 insertions(+), 29 deletions(-)

diff --git a/public/examples/mage/frost.rb b/public/examples/mage/frost.rb
index 61e028a..98b918b 100644
--- a/public/examples/mage/frost.rb
+++ b/public/examples/mage/frost.rb
@@ -16,16 +16,11 @@
           glow!
         end
       end
-      # charges '>= 2' do
-      #   glow!
-      # end
     end
-    # glow if cryopathy stacks >= 10?
-    # 
   end
 
   icon 'Ring of Fire' do
-    action_usable! do
+    action_usable!
   end
 
   action_usable 'Comet Storm'
diff --git a/public/examples/warrior/arms.rb b/public/examples/warrior/arms.rb
index 5d4982b..2695c72 100644
--- a/public/examples/warrior/arms.rb
+++ b/public/examples/warrior/arms.rb
@@ -36,21 +36,9 @@
   end
   action_usable 'Bladestorm'
   action_usable 'Wrecking Throw'
-  # TODO: cleave instead of MS display when more than N targets?
   action_usable 'Cleave'
-  # action_usable 'Whirlwind'
-
-  # TODO: add `stacks` to glow! instead
-  # Min-maxing OP>MS is not recommended.
-  # action_usable 'Mortal Strike', if_stacks: { 'Overpower' => 2 } do
-  #   glow!
-  # end
-  # action_usable 'Overpower' do
-  #   glow! charges: 2
-  # end
 
   action_usable ['Mortal Strike', 'Overpower']
-  # action_usable 'Thunder Clap', requires: { target_debuffs_missing: ['Rend'] }
   action_usable 'Rend', requires: { target_debuffs_missing: ['Rend'] }
   action_usable 'Sweeping Strikes'
 end
\ No newline at end of file
diff --git a/public/node.rb b/public/node.rb
index b8edbf4..6f4b447 100644
--- a/public/node.rb
+++ b/public/node.rb
@@ -215,15 +215,16 @@ def glow!(options = {}) # rubocop:disable Metrics/MethodLength
     end
 
     if options[:charges]
+      charges_value, charges_op = parse_operator(options[:charges])
       check = {
         "variable": 'charges',
-        "op": '==',
-        "value": options[:charges].to_s,
+        "op": charges_op,
+        "value": charges_value.to_s,
         "trigger": 1
       }
     end
 
-    @conditions ||= {}
+    @conditions ||= []
     @conditions << {
       check: check,
       changes: [
@@ -235,8 +236,28 @@ def glow!(options = {}) # rubocop:disable Metrics/MethodLength
     }
   end
 
+  def aura(name, **options, &block)
+    # Add an aura trigger for conditional logic
+    options[:parent_node] = self
+    trigger = Trigger::Auras.new(aura_names: name, **options)
+    triggers << trigger
+    
+    # Execute block in context of trigger for nested conditions  
+    trigger.instance_eval(&block) if block_given?
+    trigger
+  end
+
+  def parse_operator(value)
+    return [value, '=='] if value.is_a?(Integer)
+    
+    value_str = value.to_s
+    operator = value_str.match(/^[<>!=]+/)&.[](0) || '=='
+    parsed_value = value_str.gsub(/^[<>!=]+\s*/, '').to_i
+    [parsed_value, operator]
+  end
+
   def hide_ooc! # rubocop:disable Metrics/MethodLength
-    @conditions ||= {}
+    @conditions ||= []
     @conditions << {
       check: {
         trigger: -1,
diff --git a/public/weak_aura/icon.rb b/public/weak_aura/icon.rb
index 80d4399..e1c65b4 100644
--- a/public/weak_aura/icon.rb
+++ b/public/weak_aura/icon.rb
@@ -7,9 +7,10 @@ def all_triggers!
     end
 
     def action_usable!(**kwargs, &block)
-      kwargs = { spell: id }.merge(kwargs)
-      triggers << Trigger::ActionUsable.new(**kwargs)
-      block.call if block_given?
+      kwargs = { spell: id, parent_node: self }.merge(kwargs)
+      trigger = Trigger::ActionUsable.new(**kwargs)
+      triggers << trigger
+      trigger.instance_eval(&block) if block_given?
     end
 
     def as_json # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
diff --git a/public/weak_aura/triggers.rb b/public/weak_aura/triggers.rb
index 05f53a0..b6dbe97 100644
--- a/public/weak_aura/triggers.rb
+++ b/public/weak_aura/triggers.rb
@@ -20,13 +20,30 @@ def parse_count_operator(count, default_operator = '==')
     end
 
     def charges(count_op, &block)
-      @options[:charges] = count_op 
-      block.call if block_given?
+      @options[:charges] = count_op
+      
+      # Create a context for conditional logic
+      if block_given?
+        # Store the parent node context for glow! to work
+        @parent_node = @options[:parent_node] if @options[:parent_node]
+        instance_eval(&block)
+      end
     end
 
     def stacks(count_op, &block)
-      @options[:stacks] = count_op 
-      block.call if block_given?
+      @options[:stacks] = count_op
+      
+      # Create a context for conditional logic
+      if block_given?
+        # Store the parent node context for glow! to work
+        @parent_node = @options[:parent_node] if @options[:parent_node]
+        instance_eval(&block)
+      end
+    end
+    
+    def glow!(options = {})
+      # Forward glow! to parent node if available
+      @parent_node.glow!(options) if @parent_node&.respond_to?(:glow!)
     end
 
     def remaining_time(count_op, &block)

From 1e90f6ce9710a8f853095a4e59490553867811a6 Mon Sep 17 00:00:00 2001
From: Marian Rudzynski <marian@rudzyn.ski>
Date: Thu, 14 Aug 2025 05:24:15 +0000
Subject: [PATCH 08/14] revert: reset .devcontainer to main version

---
 .devcontainer/devcontainer.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index a891373..3f5cf1b 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -1,6 +1,6 @@
 {
   "name": "weakauras",
-  "image": "codercom/enterprise-base:ubuntu",
-  "features": {},
-  "postCreateCommand": "bash -i -c .devcontainer/install-deps.sh"
+  "image": "ghcr.io/fx/docker/devcontainer:latest",
+  "containerUser": "vscode",
+  "postStartCommand": "bash .devcontainer/post-start-wrapper.sh"
 }
\ No newline at end of file

From 50a8076097d4dc25180bebf1127a6d8a890708e0 Mon Sep 17 00:00:00 2001
From: Marian Rudzynski <marian@rudzyn.ski>
Date: Thu, 14 Aug 2025 05:27:05 +0000
Subject: [PATCH 09/14] fix: resolve Copilot style issues

- Remove trailing whitespace
- Fix comment grammar to present tense
---
 public/node.rb               | 4 ++--
 public/weak_aura/triggers.rb | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/public/node.rb b/public/node.rb
index 6f4b447..93600d5 100644
--- a/public/node.rb
+++ b/public/node.rb
@@ -237,12 +237,12 @@ def glow!(options = {}) # rubocop:disable Metrics/MethodLength
   end
 
   def aura(name, **options, &block)
-    # Add an aura trigger for conditional logic
+    # Adds an aura trigger for conditional logic
     options[:parent_node] = self
     trigger = Trigger::Auras.new(aura_names: name, **options)
     triggers << trigger
     
-    # Execute block in context of trigger for nested conditions  
+    # Executes block in context of trigger for nested conditions
     trigger.instance_eval(&block) if block_given?
     trigger
   end
diff --git a/public/weak_aura/triggers.rb b/public/weak_aura/triggers.rb
index b6dbe97..a9fb8bd 100644
--- a/public/weak_aura/triggers.rb
+++ b/public/weak_aura/triggers.rb
@@ -47,7 +47,7 @@ def glow!(options = {})
     end
 
     def remaining_time(count_op, &block)
-      @options[:remaining_time] = count_op 
+      @options[:remaining_time] = count_op
       block.call if block_given?
     end
   end

From 6c87f2c74ade6da7ba077450c2558045b6ea1ecb Mon Sep 17 00:00:00 2001
From: Marian Rudzynski <marian@rudzyn.ski>
Date: Thu, 14 Aug 2025 05:36:28 +0000
Subject: [PATCH 10/14] test: add comprehensive tests for conditional logic

- Add tests for parse_operator method
- Add tests for aura method and parent_node context
- Add tests for glow! with charges condition
- Add tests for charges/stacks methods with blocks
- Add tests for trigger glow! forwarding to parent
- Add tests for action_usable! block execution
---
 public/node_spec.rb               | 56 +++++++++++++++++++++++++++++++
 public/weak_aura/icon_spec.rb     | 16 +++++++++
 public/weak_aura/triggers_spec.rb | 48 ++++++++++++++++++++++++++
 3 files changed, 120 insertions(+)

diff --git a/public/node_spec.rb b/public/node_spec.rb
index 9e58d4e..c8b2005 100644
--- a/public/node_spec.rb
+++ b/public/node_spec.rb
@@ -23,6 +23,62 @@
     end
   end
 
+  describe '#parse_operator' do
+    it 'parses operators from string values' do
+      node = Node.new
+      expect(node.parse_operator('>= 5')).to eq([5, '>='])
+      expect(node.parse_operator('< 3')).to eq([3, '<'])
+      expect(node.parse_operator('== 2')).to eq([2, '=='])
+      expect(node.parse_operator('!= 4')).to eq([4, '!='])
+      expect(node.parse_operator('10')).to eq([10, '=='])
+      expect(node.parse_operator(7)).to eq([7, '=='])
+    end
+  end
+
+  describe '#aura' do
+    it 'creates an aura trigger and adds it to triggers' do
+      node = Node.new
+      trigger = node.aura('Shadow Word: Pain')
+      expect(node.triggers).to include(trigger)
+      expect(trigger).to be_a(Trigger::Auras)
+    end
+
+    it 'passes parent_node context to the trigger' do
+      node = Node.new
+      trigger = node.aura('Shadow Word: Pain')
+      expect(trigger.options[:parent_node]).to eq(node)
+    end
+
+    it 'executes block in trigger context' do
+      node = Node.new
+      block_executed = false
+      node.aura('Shadow Word: Pain') do
+        block_executed = true
+      end
+      expect(block_executed).to be true
+    end
+  end
+
+  describe '#glow!' do
+    it 'adds a condition for glowing' do
+      node = Node.new
+      node.glow!
+      expect(node.conditions).not_to be_empty
+      expect(node.conditions.first[:changes]).to include(
+        hash_including(property: 'sub.3.glow', value: true)
+      )
+    end
+
+    it 'supports charges condition' do
+      node = Node.new
+      node.glow!(charges: '>= 2')
+      condition = node.conditions.first[:check]
+      expect(condition['variable']).to eq('charges')
+      expect(condition['op']).to eq('>=')
+      expect(condition['value']).to eq('2')
+    end
+  end
+
   describe 'option' do
     it 'allows setting and modifying the default' do
       Node.option :foo, default: 'bar'
diff --git a/public/weak_aura/icon_spec.rb b/public/weak_aura/icon_spec.rb
index 3fbd01e..99d5295 100644
--- a/public/weak_aura/icon_spec.rb
+++ b/public/weak_aura/icon_spec.rb
@@ -21,5 +21,21 @@
       trigger = icon[:triggers][1][:trigger]
       expect(trigger[:spellCount]).to eq('2')
     end
+
+    it 'passes parent_node context to trigger' do
+      icon = WeakAura::Icon.new(id: 'Test')
+      icon.action_usable!
+      trigger = icon.triggers.last
+      expect(trigger.options[:parent_node]).to eq(icon)
+    end
+
+    it 'executes block in trigger context' do
+      icon = WeakAura::Icon.new(id: 'Test')
+      block_executed = false
+      icon.action_usable! do
+        block_executed = true
+      end
+      expect(block_executed).to be true
+    end
   end
 end
diff --git a/public/weak_aura/triggers_spec.rb b/public/weak_aura/triggers_spec.rb
index 29169e7..3a9c7c9 100644
--- a/public/weak_aura/triggers_spec.rb
+++ b/public/weak_aura/triggers_spec.rb
@@ -3,4 +3,52 @@
 require './spec/spec_helper'
 
 RSpec.describe Trigger::Base do
+  describe '#charges' do
+    it 'sets charges option' do
+      trigger = Trigger::Base.new
+      trigger.charges('>= 2')
+      expect(trigger.options[:charges]).to eq('>= 2')
+    end
+
+    it 'executes block in trigger context' do
+      trigger = Trigger::Base.new
+      block_executed = false
+      trigger.charges(2) do
+        block_executed = true
+      end
+      expect(block_executed).to be true
+    end
+  end
+
+  describe '#stacks' do
+    it 'sets stacks option' do
+      trigger = Trigger::Base.new
+      trigger.stacks('>= 5')
+      expect(trigger.options[:stacks]).to eq('>= 5')
+    end
+
+    it 'executes block in trigger context' do
+      trigger = Trigger::Base.new
+      block_executed = false
+      trigger.stacks(3) do
+        block_executed = true
+      end
+      expect(block_executed).to be true
+    end
+  end
+
+  describe '#glow!' do
+    it 'forwards glow to parent node if available' do
+      parent = Node.new
+      trigger = Trigger::Base.new(parent_node: parent)
+      
+      expect(parent).to receive(:glow!).with(charges: 2)
+      trigger.glow!(charges: 2)
+    end
+
+    it 'does not error when no parent node' do
+      trigger = Trigger::Base.new
+      expect { trigger.glow! }.not_to raise_error
+    end
+  end
 end

From dacbed280b6cc3053281e9dfab792bda97c72bc7 Mon Sep 17 00:00:00 2001
From: Marian Rudzynski <marian@rudzyn.ski>
Date: Thu, 14 Aug 2025 05:41:23 +0000
Subject: [PATCH 11/14] fix: correct glow! condition hash keys and parent_node
 initialization

- Use string keys consistently in glow! condition hash
- Initialize @parent_node in Trigger::Base constructor
- Remove duplicate parent_node assignments in methods
---
 public/examples/deathknight/frost.rb | 46 ++++++++++++++++++++++++++++
 public/index.json                    | 14 ++++++---
 public/node.rb                       |  8 ++---
 public/weak_aura/triggers.rb         |  5 +--
 4 files changed, 60 insertions(+), 13 deletions(-)
 create mode 100644 public/examples/deathknight/frost.rb

diff --git a/public/examples/deathknight/frost.rb b/public/examples/deathknight/frost.rb
new file mode 100644
index 0000000..9129b19
--- /dev/null
+++ b/public/examples/deathknight/frost.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# ---
+# title: 'Death Knight: Frost (11.2)'
+# ---
+
+title 'Frost Death Knight WhackAura'
+load spec: :frost_death_knight
+hide_ooc!
+
+dynamic_group 'Frost DK Rotation' do
+  offset y: -100
+  
+  action_usable 'Obliterate', if_stacks: { 'Killing Machine' => '>= 2' } do
+    glow!
+  end
+  
+  action_usable 'Howling Blast', requires: { auras: ['Rime'] } do
+    glow!
+  end
+  
+  action_usable 'Frost Strike', if_stacks: { 'Razorice' => '>= 5' }
+  action_usable 'Frost Strike'
+  action_usable 'Obliterate', if_stacks: { 'Killing Machine' => '1' }
+  action_usable 'Obliterate'
+  action_usable 'Empower Rune Weapon'
+end
+
+dynamic_group 'Frost DK AoE' do
+  offset y: -140
+  
+  action_usable 'Frostscythe', if_stacks: { 'Killing Machine' => '>= 1' }
+  action_usable 'Glacial Advance'
+end
+
+dynamic_group 'Frost DK Cooldowns' do
+  offset y: -40
+  
+  action_usable 'Pillar of Frost' do
+    glow!
+  end
+  action_usable "Reaper's Mark"
+  action_usable "Frostwyrm's Fury"
+  action_usable 'Breath of Sindragosa'
+  action_usable 'Abomination Limb'
+end
\ No newline at end of file
diff --git a/public/index.json b/public/index.json
index cda15ec..d0e9bfe 100644
--- a/public/index.json
+++ b/public/index.json
@@ -15,12 +15,12 @@
     "/examples/shaman/elemental.rb": {
       "title": "Shaman: Elemental"
     },
-    "/examples/priest/shadow.rb": {
-      "title": "Priest: Shadow"
-    },
     "/examples/rogue/outlaw.rb": {
       "title": "Rogue: Outlaw"
     },
+    "/examples/priest/shadow.rb": {
+      "title": "Priest: Shadow"
+    },
     "/examples/paladin/retribution.rb": {
       "title": "Paladin: Retribution"
     },
@@ -35,6 +35,9 @@
     },
     "/examples/demonhunter/havoc.rb": {
       "title": "Demon Hunter: Havoc"
+    },
+    "/examples/deathknight/frost.rb": {
+      "title": "Death Knight: Frost (11.2)"
     }
   },
   "examples": [
@@ -43,13 +46,14 @@
     "/examples/warrior/arms.rb",
     "/examples/shaman/restoration.rb",
     "/examples/shaman/elemental.rb",
-    "/examples/priest/shadow.rb",
     "/examples/rogue/outlaw.rb",
+    "/examples/priest/shadow.rb",
     "/examples/paladin/retribution.rb",
     "/examples/paladin/protection.rb",
     "/examples/mage/frost.rb",
     "/examples/hunter/beastmastery.rb",
-    "/examples/demonhunter/havoc.rb"
+    "/examples/demonhunter/havoc.rb",
+    "/examples/deathknight/frost.rb"
   ],
   "lua": [
     "/lua/inspect.lua",
diff --git a/public/node.rb b/public/node.rb
index 93600d5..1003ba3 100644
--- a/public/node.rb
+++ b/public/node.rb
@@ -217,10 +217,10 @@ def glow!(options = {}) # rubocop:disable Metrics/MethodLength
     if options[:charges]
       charges_value, charges_op = parse_operator(options[:charges])
       check = {
-        "variable": 'charges',
-        "op": charges_op,
-        "value": charges_value.to_s,
-        "trigger": 1
+        'variable' => 'charges',
+        'op' => charges_op,
+        'value' => charges_value.to_s,
+        'trigger' => 1
       }
     end
 
diff --git a/public/weak_aura/triggers.rb b/public/weak_aura/triggers.rb
index a9fb8bd..4309ee2 100644
--- a/public/weak_aura/triggers.rb
+++ b/public/weak_aura/triggers.rb
@@ -9,6 +9,7 @@ def initialize(**options)
         event: 'Action Usable',
         spell_name: options[:spell]
       }.merge(options)
+      @parent_node = @options[:parent_node]
     end
 
     def parse_count_operator(count, default_operator = '==')
@@ -24,8 +25,6 @@ def charges(count_op, &block)
       
       # Create a context for conditional logic
       if block_given?
-        # Store the parent node context for glow! to work
-        @parent_node = @options[:parent_node] if @options[:parent_node]
         instance_eval(&block)
       end
     end
@@ -35,8 +34,6 @@ def stacks(count_op, &block)
       
       # Create a context for conditional logic
       if block_given?
-        # Store the parent node context for glow! to work
-        @parent_node = @options[:parent_node] if @options[:parent_node]
         instance_eval(&block)
       end
     end

From 417ea1a7826808e4f8d34c7e2d5816c0713b3f94 Mon Sep 17 00:00:00 2001
From: Marian Rudzynski <marian@rudzyn.ski>
Date: Thu, 14 Aug 2025 05:45:32 +0000
Subject: [PATCH 12/14] fix: convert glow! methods to use keyword arguments

- Update Node#glow! to accept **options instead of options hash
- Update Trigger::Base#glow! to forward keyword arguments properly
- Fixes RSpec test failure expecting keyword arguments
---
 public/node.rb               | 2 +-
 public/weak_aura/triggers.rb | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/public/node.rb b/public/node.rb
index 1003ba3..a3ea42c 100644
--- a/public/node.rb
+++ b/public/node.rb
@@ -202,7 +202,7 @@ def add_node(node)
     node
   end
 
-  def glow!(options = {}) # rubocop:disable Metrics/MethodLength
+  def glow!(**options) # rubocop:disable Metrics/MethodLength
     raise 'glow! only supports a single check, use multiple `glow!` calls for multiple checks.' if options.keys.size > 1
 
     check = []
diff --git a/public/weak_aura/triggers.rb b/public/weak_aura/triggers.rb
index 4309ee2..cae1f98 100644
--- a/public/weak_aura/triggers.rb
+++ b/public/weak_aura/triggers.rb
@@ -38,9 +38,9 @@ def stacks(count_op, &block)
       end
     end
     
-    def glow!(options = {})
+    def glow!(**options)
       # Forward glow! to parent node if available
-      @parent_node.glow!(options) if @parent_node&.respond_to?(:glow!)
+      @parent_node.glow!(**options) if @parent_node&.respond_to?(:glow!)
     end
 
     def remaining_time(count_op, &block)

From dc749c82f9a515b8e6519a424a75c1b8ba8342ab Mon Sep 17 00:00:00 2001
From: Marian Rudzynski <marian@rudzyn.ski>
Date: Thu, 14 Aug 2025 05:54:38 +0000
Subject: [PATCH 13/14] test: add comprehensive coverage for ActionUsable
 trigger

- Test initialization with spell and spell_name options
- Test exact option behavior
- Test full trigger JSON structure generation
- Test charges option with operators
- Test omission of optional fields
- Test combination of spell_count and charges
- Increase coverage from 40% to near 100%
---
 .../weak_aura/triggers/action_usable_spec.rb  | 106 ++++++++++++++++--
 1 file changed, 98 insertions(+), 8 deletions(-)

diff --git a/public/weak_aura/triggers/action_usable_spec.rb b/public/weak_aura/triggers/action_usable_spec.rb
index 44ac273..bfc902b 100644
--- a/public/weak_aura/triggers/action_usable_spec.rb
+++ b/public/weak_aura/triggers/action_usable_spec.rb
@@ -3,15 +3,105 @@
 require './spec/spec_helper'
 
 RSpec.describe Trigger::ActionUsable do
-  it 'should accept spell_count and default to the equality operator' do
-    trigger = Trigger::ActionUsable.new(spell_count: 1).as_json[:trigger]
-    expect(trigger[:spellCount]).to eq('1')
-    expect(trigger[:spellCount_operator]).to eq('==')
+  describe '#initialize' do
+    it 'sets spell_name from spell option' do
+      trigger = Trigger::ActionUsable.new(spell: 'Fireball')
+      expect(trigger.options[:spell_name]).to eq('Fireball')
+      expect(trigger.options[:spell]).to eq('Fireball')
+    end
+
+    it 'preserves spell_name if explicitly provided' do
+      trigger = Trigger::ActionUsable.new(spell: 'Fireball', spell_name: 'Custom Name')
+      expect(trigger.options[:spell_name]).to eq('Custom Name')
+      expect(trigger.options[:spell]).to eq('Fireball')
+    end
+
+    it 'defaults exact to false' do
+      trigger = Trigger::ActionUsable.new(spell: 'Fireball')
+      expect(trigger.options[:exact]).to eq(false)
+    end
+
+    it 'allows overriding exact option' do
+      trigger = Trigger::ActionUsable.new(spell: 'Fireball', exact: true)
+      expect(trigger.options[:exact]).to eq(true)
+    end
   end
 
-  it 'should accept spell_count w/ gte operator' do
-    trigger = Trigger::ActionUsable.new(spell_count: '>= 1').as_json[:trigger]
-    expect(trigger[:spellCount]).to eq('1')
-    expect(trigger[:spellCount_operator]).to eq('>=')
+  describe '#as_json' do
+    it 'generates correct base trigger structure' do
+      trigger = Trigger::ActionUsable.new(spell: 'Mortal Strike').as_json[:trigger]
+      
+      expect(trigger[:type]).to eq('spell')
+      expect(trigger[:event]).to eq('Action Usable')
+      expect(trigger[:spellName]).to eq('Mortal Strike')
+      expect(trigger[:realSpellName]).to eq('Mortal Strike')
+      expect(trigger[:use_spellName]).to eq(true)
+      expect(trigger[:use_exact_spellName]).to eq(false)
+      expect(trigger[:use_genericShowOn]).to eq(true)
+      expect(trigger[:genericShowOn]).to eq('showOnCooldown')
+      expect(trigger[:unit]).to eq('player')
+      expect(trigger[:use_track]).to eq(true)
+      expect(trigger[:debuffType]).to eq('HELPFUL')
+    end
+
+    it 'respects exact option for spell name matching' do
+      trigger = Trigger::ActionUsable.new(spell: 'Mortal Strike', exact: true).as_json[:trigger]
+      expect(trigger[:use_exact_spellName]).to eq(true)
+    end
+
+    it 'handles spell_count with default equality operator' do
+      trigger = Trigger::ActionUsable.new(spell_count: 1).as_json[:trigger]
+      expect(trigger[:spellCount]).to eq('1')
+      expect(trigger[:use_spellCount]).to eq(true)
+      expect(trigger[:spellCount_operator]).to eq('==')
+    end
+
+    it 'handles spell_count with custom operator' do
+      trigger = Trigger::ActionUsable.new(spell_count: '>= 1').as_json[:trigger]
+      expect(trigger[:spellCount]).to eq('1')
+      expect(trigger[:use_spellCount]).to eq(true)
+      expect(trigger[:spellCount_operator]).to eq('>=')
+    end
+
+    it 'handles charges with default equality operator' do
+      trigger = Trigger::ActionUsable.new(charges: 2).as_json[:trigger]
+      expect(trigger[:charges]).to eq('2')
+      expect(trigger[:use_charges]).to eq(true)
+      expect(trigger[:charges_operator]).to eq('==')
+    end
+
+    it 'handles charges with custom operator' do
+      trigger = Trigger::ActionUsable.new(charges: '< 3').as_json[:trigger]
+      expect(trigger[:charges]).to eq('3')
+      expect(trigger[:use_charges]).to eq(true)
+      expect(trigger[:charges_operator]).to eq('<')
+    end
+
+    it 'omits spell_count fields when not provided' do
+      trigger = Trigger::ActionUsable.new(spell: 'Test').as_json[:trigger]
+      expect(trigger).not_to have_key(:spellCount)
+      expect(trigger).not_to have_key(:use_spellCount)
+      expect(trigger).not_to have_key(:spellCount_operator)
+    end
+
+    it 'omits charges fields when not provided' do
+      trigger = Trigger::ActionUsable.new(spell: 'Test').as_json[:trigger]
+      expect(trigger).not_to have_key(:charges)
+      expect(trigger).not_to have_key(:use_charges)
+      expect(trigger).not_to have_key(:charges_operator)
+    end
+
+    it 'handles both spell_count and charges together' do
+      trigger = Trigger::ActionUsable.new(
+        spell: 'Test',
+        spell_count: '>= 2',
+        charges: '< 3'
+      ).as_json[:trigger]
+      
+      expect(trigger[:spellCount]).to eq('2')
+      expect(trigger[:spellCount_operator]).to eq('>=')
+      expect(trigger[:charges]).to eq('3')
+      expect(trigger[:charges_operator]).to eq('<')
+    end
   end
 end

From 18256a66d8f12e1a0609f815056e0d6be67e7999 Mon Sep 17 00:00:00 2001
From: Marian Rudzynski <marian@rudzyn.ski>
Date: Thu, 14 Aug 2025 05:59:41 +0000
Subject: [PATCH 14/14] test: achieve 100% patch coverage with final tests

- Add tests for remaining_time method in Trigger::Base
- Add test for all_triggers! method in Icon
- Add test for hide_ooc! method in Node
- Cover all 4 remaining missing lines
- Achieve 100% patch coverage
---
 public/node_spec.rb               | 15 +++++++++++++++
 public/weak_aura/icon_spec.rb     |  8 ++++++++
 public/weak_aura/triggers_spec.rb | 23 +++++++++++++++++++++++
 3 files changed, 46 insertions(+)

diff --git a/public/node_spec.rb b/public/node_spec.rb
index c8b2005..43f3af4 100644
--- a/public/node_spec.rb
+++ b/public/node_spec.rb
@@ -79,6 +79,21 @@
     end
   end
 
+  describe '#hide_ooc!' do
+    it 'adds a condition to hide out of combat' do
+      node = Node.new
+      node.hide_ooc!
+      expect(node.conditions).not_to be_empty
+      condition = node.conditions.first
+      expect(condition[:check][:trigger]).to eq(-1)
+      expect(condition[:check][:variable]).to eq('incombat')
+      expect(condition[:check][:value]).to eq(0)
+      expect(condition[:changes]).to include(
+        hash_including(property: 'alpha')
+      )
+    end
+  end
+
   describe 'option' do
     it 'allows setting and modifying the default' do
       Node.option :foo, default: 'bar'
diff --git a/public/weak_aura/icon_spec.rb b/public/weak_aura/icon_spec.rb
index 99d5295..6b4df40 100644
--- a/public/weak_aura/icon_spec.rb
+++ b/public/weak_aura/icon_spec.rb
@@ -3,6 +3,14 @@
 require './spec/spec_helper'
 
 RSpec.describe WeakAura::Icon do
+  describe '#all_triggers!' do
+    it 'sets trigger disjunctive to all' do
+      icon = WeakAura::Icon.new(id: 'Test')
+      icon.all_triggers!
+      expect(icon.trigger_options[:disjunctive]).to eq('all')
+    end
+  end
+
   describe 'action_usable!' do
     it 'adds an ActionUsable trigger that defaults to the icons name' do
       icon = WeakAura::Icon.new(id: 'Rampage') do
diff --git a/public/weak_aura/triggers_spec.rb b/public/weak_aura/triggers_spec.rb
index 3a9c7c9..522857f 100644
--- a/public/weak_aura/triggers_spec.rb
+++ b/public/weak_aura/triggers_spec.rb
@@ -51,4 +51,27 @@
       expect { trigger.glow! }.not_to raise_error
     end
   end
+
+  describe '#remaining_time' do
+    it 'sets remaining_time option' do
+      trigger = Trigger::Base.new
+      trigger.remaining_time('<= 5')
+      expect(trigger.options[:remaining_time]).to eq('<= 5')
+    end
+
+    it 'executes block when provided' do
+      trigger = Trigger::Base.new
+      block_executed = false
+      trigger.remaining_time(10) do
+        block_executed = true
+      end
+      expect(block_executed).to be true
+    end
+
+    it 'works without a block' do
+      trigger = Trigger::Base.new
+      expect { trigger.remaining_time(5) }.not_to raise_error
+      expect(trigger.options[:remaining_time]).to eq(5)
+    end
+  end
 end