howzit 2.1.46 → 2.1.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: daae85713f05d780640619a8ada2291aaa69c0eb3f2d941f6fb9e2964c9247b4
-  data.tar.gz: 5773440b0a9718af5dd0b3e66929bfa74023061b99a85c61d65558b76ac57d4d
+  metadata.gz: 2a6dffed9d9ce31f4704b3388bbf330f87d86f054067444073ea34b8cba13a54
+  data.tar.gz: 87cdb843c109e8f0b88e482634d0f35b676ffcd6e2732009f5a7aa60932f7fff
 SHA512:
-  metadata.gz: 1f688d2e403997a3cf6f3b91c0ebd3746ed51b1d0bc4dfea2be5fd1297a22715d2a7b5672482b2f243dc26b38b56eee2880c9e57df98c55c16178b84eddeb8da
-  data.tar.gz: 934e5ef9e7b71bc0323475ae4c54596d7a6813f552d63fd08dd358f51805c6950780d4435b9cf830aed7712392a5a38d52077dfbcceb69293adf02f9b0970794
+  metadata.gz: 4e278c055f9647bb784cfac2f1fe00616dde57023a5cd08e714097ccc3f32181ad67898da2507fe23c5496a235cdee5143c29918149a0a15d1e70574e3d535d8
+  data.tar.gz: 409df1fe83a7e46ba317d2c9cceb8346ea94c7578376f1836b7d9bb6cb17b83b51020955470d1371a27abb46150ec6af49da1e5b15ac8108eff9b9fccb625cc9

data/CHANGELOG.md

@@ -1,3 +1,36 @@
+### 2.1.48
+
+2026-10-09 07:20
+
+#### CHANGED
+
+- **@before blocks** from a topic, its subtopics, and any included topics are shown together in one box before anything runs, with a single confirmation prompt instead of one prompt per topic
+- **@after blocks** from a topic, its subtopics, and any included topics are shown together in one box at the end of the run instead of after each topic finishes
+
+#### IMPROVED
+
+- **Collected notes** appear in document order: the topic's own block, then included topics in @include order, then subtopics
+- **@after notes from subtopics skipped after a failure** are still shown in the final box
+- **Notes from included topics** render variables with the bracketed arguments passed via @include(Topic [args])
+- **@before blocks** now render ${variables}, matching @after
+- **Topics included more than once** only contribute their notes once
+
+### 2.1.47
+
+2026-09-27 13:20
+
+#### IMPROVED
+
+- **Included topics** receive their bracketed arguments as positional arguments ($1, $2) in shell run blocks for the duration of the include
+
+#### FIXED
+
+- **default: metadata** now splits topics only on commas outside of brackets, so `default: Build, Deploy[prod, fast], Test` passes both arguments to Deploy
+- **Bracketed arguments in default:** (e.g. `Deploy[prod]`) are now bound to the topic's title parameters, so `${target}` and friends render in @run commands instead of coming out empty
+- **@include bracketed arguments** (e.g. `@include(Deploy [staging])`) now bind to the included topic's parameters, and including the same topic multiple times with different arguments works
+- **Unspecified bracketed arguments** fall back to the topic's parameter defaults
+- **Topics that use @include with arguments** no longer lose their own argument definitions
+
 ### 2.1.46
 
 2026-09-27 12:52

data/lib/howzit/buildnote.rb

@@ -1608,7 +1608,7 @@ module Howzit
                            else
                              []
                            end
-        output.push(process_topic(topic_match, Howzit.options[:run], single: true))
+        output.push(process_topic(topic_match.with_arguments(Howzit.arguments), Howzit.options[:run], single: true))
         break if stop_after_failure?(topic_specs[(idx + 1)..].map(&:first))
       end
       finalize_output(output)
@@ -1640,7 +1640,8 @@ module Howzit
     ## @return     [Array] Array of topic specification strings
     ##
     def parse_default_metadata(default_value)
-      default_value.strip.split(/\s*,\s*/).map(&:strip).reject(&:empty?)
+      # Commas inside [bracketed arguments] separate arguments, not topics
+      default_value.strip.split(/\s*,\s*(?![^\[]*\])/).map(&:strip).reject(&:empty?)
     end
 
     ##

data/lib/howzit/directive.rb

@@ -138,7 +138,7 @@ module Howzit
         if title =~ /\[(.*?)\] *$/
           args = Regexp.last_match(1).split(/ *, */).map(&:render_arguments)
           Howzit.arguments = args
-          parent.arguments
+          task_data[:include_args] = args
           title.sub!(/ *\[.*?\] *$/, '')
         end
         title = title.render_arguments if title && !title.empty?

data/lib/howzit/task.rb

@@ -6,7 +6,7 @@ module Howzit
   # Task object
   class Task
     attr_reader :type, :title, :action, :arguments, :parent, :optional, :default, :last_status, :log_level, :source_file,
-                :include_results
+                :include_results, :include_args
 
     ##
     ## Initialize a Task object
@@ -27,6 +27,7 @@ module Howzit
       @prefix = "{bw}\u{25B7}\u{25B7} {x}"
       # arrow = "{bw}\u{279F}{x}"
       @arguments = attributes[:arguments] || []
+      @include_args = attributes[:include_args]
 
       @type = attributes[:type] || :run
       @title = attributes[:title]&.to_s
@@ -171,18 +172,35 @@ module Howzit
       output = []
       action = @action
 
-      matches = Howzit.buildnote.find_topic(action)
+      matches = Howzit.buildnote.find_topic(action.sub(/ *\[.*?\] *$/, ''))
       raise "Topic not found: #{action}" if matches.empty?
 
-      topic = matches[0]
+      topic = matches[0].with_arguments(@include_args)
       Howzit.console.info("#{@prefix}{by}Running tasks from {bw}#{topic.title}{x}".c)
-      output.concat(topic.run(nested: true))
+      output.concat(with_positional_arguments(@include_args) { topic.run(nested: true) })
       Howzit.console.info("{by}End include: #{topic.all_tasks.count} tasks{x}".c)
       @last_status = nil
       @include_results = topic.results.slice(:total, :success, :errors)
       [output, @include_results[:total], @include_results[:errors].zero?]
     end
 
+    ##
+    ## Temporarily set Howzit.arguments (e.g. $1 in included shell blocks)
+    ##
+    ## @param      args  [Array] Positional values, or nil to leave unchanged
+    ##
+    def with_positional_arguments(args)
+      return yield if args.nil? || args.empty?
+
+      previous = Howzit.arguments
+      Howzit.arguments = args
+      begin
+        yield
+      ensure
+        Howzit.arguments = previous
+      end
+    end
+
     ##
     ## Apply log level for this task
     ##

data/lib/howzit/topic.rb

@@ -18,8 +18,11 @@ module Howzit
     ## @param      metadata    [Hash] Optional metadata hash
     ## @param      source_file [String] Optional path to the build note file this topic came from
     ## @param      level       [Integer] Markdown header level (2 for ##, 3 for ###, etc.)
+    ## @param      positional  [Array] Values to bind to the title's (arguments),
+    ##                         overriding CLI arguments
     ##
-    def initialize(title, content, metadata = nil, source_file: nil, level: 2)
+    def initialize(title, content, metadata = nil, source_file: nil, level: 2, positional: nil)
+      @raw_title = title
       @title = title
       @content = content
       @parent = nil
@@ -30,7 +33,7 @@ module Howzit
       @named_args = {}
       @metadata = metadata
       @source_file = source_file
-      arguments(from_cli_snapshot: true)
+      arguments(from_cli_snapshot: positional.nil?, positional: positional)
 
       @directives = parse_directives_with_conditionals
       @tasks = gather_tasks
@@ -71,24 +74,43 @@ module Howzit
       list
     end
 
+    ##
+    ## A copy of this topic with bracketed arguments (e.g.
+    ## `@include(Deploy [prod])` or `default: Deploy[prod]`) bound to the
+    ## title's (arguments). Tasks are rebuilt so commands render with them.
+    ##
+    ## @param      args  [Array] Positional values
+    ##
+    ## @return     [Topic] a new Topic, or self if no args given
+    ##
+    def with_arguments(args)
+      return self if args.nil? || args.empty?
+
+      topic = Topic.new(@raw_title, @content, @metadata, source_file: @source_file, level: @level, positional: args)
+      topic.parent = @parent
+      topic.parent_topic = @parent_topic
+      topic.subtopics.concat(@subtopics)
+      topic
+    end
+
     # Get named arguments from title
     # from_cli_snapshot: use Howzit.cli_topic_positional_args (argv after `--`) so earlier
-    # topics' gather_tasks cannot clobber positional binding. Re-entrant @include [a,b]
-    # calls pass false to use live Howzit.arguments.
-    def arguments(from_cli_snapshot: false)
+    # topics' gather_tasks cannot clobber positional binding. positional: binds
+    # bracketed arguments from @include [a,b] and default: (see #with_arguments).
+    def arguments(from_cli_snapshot: false, positional: nil)
       @arg_definitions = []
       return unless @title =~ /\(.*?\) *$/
 
-      positional = if from_cli_snapshot
-                     # Specs / non-CLI: leave unset to keep using Howzit.arguments
-                     if Howzit.cli_topic_positional_args.nil?
-                       Howzit.arguments || []
+      positional ||= if from_cli_snapshot
+                       # Specs / non-CLI: leave unset to keep using Howzit.arguments
+                       if Howzit.cli_topic_positional_args.nil?
+                         Howzit.arguments || []
+                       else
+                         Howzit.cli_topic_positional_args
+                       end
                      else
-                       Howzit.cli_topic_positional_args
+                       Howzit.arguments || []
                      end
-                   else
-                     Howzit.arguments || []
-                   end
 
       a = @title.match(/\((?<args>.*?)\) *$/)
       args = a['args'].split(/ *, */).each(&:strip)
@@ -143,34 +165,58 @@ module Howzit
     ## @return     [Array] output lines
     ##
     def run(nested: false, as_subtopic: false)
-      @results = { total: 0, success: 0, errors: 0, message: ''.c }
-      output = []
-      cols = check_cols
+      # The outermost run shows @before/@after notes for the whole tree
+      return run_topic(nested: nested, as_subtopic: as_subtopic) if Howzit.topic_run_active
 
-      confirm_prereqs(cols) if !@prereqs.empty? && (all_tasks.any? || sequential?)
-
-      if sequential?
-        run_sequential(output: output)
-      elsif @tasks.any?
-        run_tasks(output)
-      elsif all_tasks.empty? && !as_subtopic && !directives?
-        Howzit.console.warn "{r}--run: No {br}@directive{xr} found in {bw}#{@title}{x}".c
-      end
-
-      if halted?
-        log_skipped_tasks(@subtopics.flat_map(&:all_tasks))
-      else
-        run_subtopics(output)
+      Howzit.topic_run_active = true
+      begin
+        cols = check_cols
+        confirm_prereqs(cols) if all_tasks.any? || sequential?
+        output = run_topic(nested: nested, as_subtopic: as_subtopic)
+        show_postreqs(cols)
+        output
+      ensure
+        Howzit.topic_run_active = false
       end
+    end
 
-      if @results[:total].positive? || (all_tasks.any? && !sequential?)
-        @results[:message] += results_message
-        output.push(@results[:message]) if Howzit.options[:log_level] < 2 && !nested && !Howzit.options[:run]
-      end
+    ##
+    ## @before notes for this topic, the topics it includes, and its
+    ## subtopics, in document order
+    ##
+    ## @return     [Array] rendered notes
+    ##
+    def all_prereqs
+      collect_notes(:prereqs)
+    end
 
-      show_postreqs(cols)
+    ##
+    ## @after notes for this topic, the topics it includes, and its
+    ## subtopics, in document order
+    ##
+    ## @return     [Array] rendered notes
+    ##
+    def all_postreqs
+      collect_notes(:postreqs)
+    end
 
-      output
+    ##
+    ## Gather notes recursively through @include tasks and subtopics
+    ##
+    ## @param      kind  [Symbol] :prereqs or :postreqs
+    ## @param      args  [Array] Bracketed arguments from an @include
+    ## @param      seen  [Array] Titles of topics already collected
+    ##
+    def collect_notes(kind, args = nil, seen = [])
+      return [] if seen.include?(@title)
+
+      seen << @title
+      notes = render_notes(kind == :prereqs ? @prereqs : @postreqs, args)
+      @tasks.select { |task| task.type == :include }.each do |task|
+        topic = Howzit.buildnote.find_topic(task.action.sub(/ *\[.*?\] *$/, ''))[0]
+        notes.concat(topic.collect_notes(kind, task.include_args, seen)) if topic
+      end
+      notes + @subtopics.flat_map { |sub| sub.collect_notes(kind, nil, seen) }
     end
 
     ##
@@ -193,8 +239,11 @@ module Howzit
     end
 
     def confirm_prereqs(cols)
+      prereqs = all_prereqs
+      return if prereqs.empty?
+
       begin
-        puts TTY::Box.frame("{by}#{@prereqs.join("\n\n").wrap(cols - 4)}{x}".c, width: cols)
+        puts TTY::Box.frame("{by}#{prereqs.join("\n\n").wrap(cols - 4)}{x}".c, width: cols)
       rescue Errno::EPIPE
         # Pipe closed, ignore
       end
@@ -203,11 +252,11 @@ module Howzit
     end
 
     def show_postreqs(cols)
-      return if @postreqs.empty?
+      postreqs = all_postreqs
+      return if postreqs.empty?
 
-      # Apply variable substitution to postreqs content, then wrap each line individually to preserve structure
-      postreqs_content = @postreqs.join("\n\n").render_arguments
-      wrapped_content = postreqs_content.split(/\n/).map { |line| line.wrap(cols - 4) }.join("\n")
+      # Wrap each line individually to preserve structure
+      wrapped_content = postreqs.join("\n\n").split(/\n/).map { |line| line.wrap(cols - 4) }.join("\n")
       puts TTY::Box.frame("{bw}#{wrapped_content}{x}".c, width: cols)
     rescue Errno::EPIPE
       # Pipe closed, ignore
@@ -538,7 +587,7 @@ module Howzit
         if title =~ /\[(.*?)\] *$/
           args = Regexp.last_match(1).split(/ *, */).map(&:render_arguments)
           Howzit.arguments = args
-          arguments
+          task_args[:include_args] = args
           title.sub!(/ *\[.*?\] *$/, '')
         end
         # Apply variable substitution to title after bracket processing
@@ -571,6 +620,55 @@ module Howzit
 
     private
 
+    def run_topic(nested:, as_subtopic:)
+      @results = { total: 0, success: 0, errors: 0, message: ''.c }
+      output = []
+
+      if sequential?
+        run_sequential(output: output)
+      elsif @tasks.any?
+        run_tasks(output)
+      elsif all_tasks.empty? && !as_subtopic && !directives?
+        Howzit.console.warn "{r}--run: No {br}@directive{xr} found in {bw}#{@title}{x}".c
+      end
+
+      if halted?
+        log_skipped_tasks(@subtopics.flat_map(&:all_tasks))
+      else
+        run_subtopics(output)
+      end
+
+      if @results[:total].positive? || (all_tasks.any? && !sequential?)
+        @results[:message] += results_message
+        output.push(@results[:message]) if Howzit.options[:log_level] < 2 && !nested && !Howzit.options[:run]
+      end
+
+      output
+    end
+
+    ##
+    ## Render notes with this topic's variables, plus any bracketed
+    ## @include arguments bound to its title parameters
+    ##
+    def render_notes(notes, args)
+      return [] if notes.empty?
+
+      previous = Howzit.named_arguments
+      begin
+        Howzit.named_arguments = (previous || {}).merge(@named_args.compact).merge(bound_arguments(args))
+        notes.map(&:render_arguments)
+      ensure
+        Howzit.named_arguments = previous
+      end
+    end
+
+    def bound_arguments(args)
+      return {} if args.nil? || args.empty?
+
+      names = @arg_definitions.map { |definition| definition.split(':', 2).first }
+      names.zip(args).to_h.compact
+    end
+
     ##
     ## Collect all directives in the topic content
     ##

data/lib/howzit/version.rb

@@ -3,5 +3,5 @@
 # Primary module for this gem.
 module Howzit
   # Current Howzit version.
-  VERSION = '2.1.46'
+  VERSION = '2.1.48'
 end

data/lib/howzit.rb

@@ -60,7 +60,8 @@ require 'tty/box'
 # Main module for howzit
 module Howzit
   class << self
-    attr_accessor :arguments, :named_arguments, :cli_topic_positional_args, :cli_args, :run_log, :multi_topic_run
+    attr_accessor :arguments, :named_arguments, :cli_topic_positional_args, :cli_args, :run_log, :multi_topic_run,
+                  :topic_run_active
 
     ##
     ## Holds a Configuration object with methods and a @settings hash

data/spec/collected_notes_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fileutils'
+require 'tmpdir'
+require 'stringio'
+
+describe 'collected @before/@after notes' do
+  let(:temp_dir) { File.expand_path(Dir.mktmpdir('howzit_notes_test')) }
+  let(:out_file) { File.join(temp_dir, 'out.txt') }
+  let(:child_two_command) { 'false' }
+  let(:buildnote) do
+    note = Howzit::BuildNote.new
+    allow(note).to receive(:finalize_output)
+    note
+  end
+
+  before do
+    File.write(
+      File.join(temp_dir, 'buildnotes.md'),
+      <<~NOTE
+        # Notes Project
+
+        ## Parent
+
+        @before
+        Parent before
+        @end
+
+        @run(echo "parent" >> "#{out_file}") Parent task
+
+        @include(Shared [prod])
+
+        @after
+        Parent after
+        @end
+
+        ### Child One
+
+        @before
+        Child before
+        @end
+
+        @run(echo "child" >> "#{out_file}") Child task
+
+        @after
+        Child after
+        @end
+
+        ### Child Two
+
+        @run(#{child_two_command}) Child two task
+
+        ### Child Three
+
+        @run(echo "three" >> "#{out_file}") Three task
+
+        @after
+        Three after
+        @end
+
+        ## Shared (target)
+
+        @run(echo "shared ${target}" >> "#{out_file}") Shared task
+
+        @after
+        Shared after ${target}
+        @end
+      NOTE
+    )
+
+    Dir.chdir(temp_dir)
+    Howzit.instance_variable_set(:@buildnote, buildnote)
+    Howzit.options[:stack] = false
+    Howzit.options[:include_upstream] = false
+    Howzit.options[:run] = true
+    Howzit.options[:force] = false
+    Howzit.options[:log_level] = 3
+    Howzit.cli_args = ['parent']
+    Howzit.run_log = []
+    allow(Howzit::Prompt).to receive(:yn).and_return(true)
+  end
+
+  after do
+    Howzit.options[:run] = false
+    Howzit.options[:log_level] = 1
+    Howzit.cli_args = []
+    Howzit.run_log = []
+    Dir.chdir(Dir.tmpdir)
+    FileUtils.rm_rf(temp_dir) if Dir.exist?(temp_dir)
+    Howzit.instance_variable_set(:@buildnote, nil)
+  end
+
+  def run_and_capture
+    original = $stdout
+    $stdout = StringIO.new
+    buildnote.run
+    $stdout.string.gsub(/\e\[[\d;]*m/, '')
+  ensure
+    $stdout = original
+  end
+
+  def positions(text, notes)
+    notes.map { |note| text.index(note) }
+  end
+
+  it 'asks once for all prerequisites before running anything' do
+    text = run_and_capture
+
+    expect(Howzit::Prompt).to have_received(:yn).once
+    expect(positions(text, ['Parent before', 'Child before'])).to all(be_a(Integer))
+    expect(text.scan('Parent before').count).to eq 1
+  end
+
+  it 'shows all @after notes together in document order, including included topics' do
+    text = run_and_capture
+
+    notes = ['Parent after', 'Shared after prod', 'Child after', 'Three after']
+    found = positions(text, notes)
+    expect(found).to all(be_a(Integer))
+    expect(found).to eq(found.sort)
+    expect(text.scan('Child after').count).to eq 1
+  end
+
+  it 'shows notes from subtopics skipped after a failure' do
+    text = run_and_capture
+
+    expect(File.read(out_file).lines.map(&:strip)).to eq(['parent', 'shared prod', 'child'])
+    expect(text).to include('Three after')
+  end
+
+  context 'when nothing fails' do
+    let(:child_two_command) { 'true' }
+
+    it 'shows the combined @after box after all tasks have run' do
+      text = run_and_capture
+
+      expect(File.read(out_file).lines.map(&:strip)).to eq(['parent', 'shared prod', 'child', 'three'])
+      expect(text.scan('Parent after').count).to eq 1
+    end
+  end
+end

data/spec/default_metadata_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fileutils'
+require 'tmpdir'
+
+describe 'default: metadata' do
+  let(:temp_dir) { File.expand_path(Dir.mktmpdir('howzit_default_test')) }
+  let(:out_file) { File.join(temp_dir, 'out.txt') }
+  let(:default_line) { 'default: Build, Deploy[prod, fast], Test' }
+  let(:buildnote) do
+    note = Howzit::BuildNote.new
+    allow(note).to receive(:finalize_output)
+    note
+  end
+
+  before do
+    File.write(
+      File.join(temp_dir, 'buildnotes.md'),
+      <<~NOTE
+        #{default_line}
+
+        # Default Project
+
+        ## Build
+
+        @run(echo "build" >> "#{out_file}") Build it
+
+        ## Deploy (target, speed:slow)
+
+        @run(echo "deploy ${target} ${speed}" >> "#{out_file}") Deploy it
+
+        ## Test
+
+        @run(echo "test" >> "#{out_file}") Test it
+
+        ## Broken
+
+        @run(false) Fail
+
+        ## Release
+
+        @include(Deploy [staging])
+        @include(Deploy [prod, fast])
+      NOTE
+    )
+
+    Dir.chdir(temp_dir)
+    Howzit.instance_variable_set(:@buildnote, buildnote)
+    Howzit.options[:stack] = false
+    Howzit.options[:include_upstream] = false
+    Howzit.options[:run] = true
+    Howzit.options[:force] = false
+    Howzit.options[:log_level] = 3
+    Howzit.cli_args = []
+    Howzit.run_log = []
+  end
+
+  after do
+    Howzit.options[:run] = false
+    Howzit.options[:log_level] = 1
+    Howzit.cli_args = []
+    Howzit.run_log = []
+    Dir.chdir(Dir.tmpdir)
+    FileUtils.rm_rf(temp_dir) if Dir.exist?(temp_dir)
+    Howzit.instance_variable_set(:@buildnote, nil)
+  end
+
+  def output_lines
+    File.read(out_file).lines.map(&:strip)
+  end
+
+  describe 'parsing' do
+    it 'splits topics on commas outside of brackets' do
+      expect(buildnote.send(:parse_default_metadata, 'Build, Deploy[prod, fast],Test')).to eq(
+        ['Build', 'Deploy[prod, fast]', 'Test']
+      )
+    end
+
+    it 'separates bracketed arguments from the topic name' do
+      expect(buildnote.send(:parse_topic_with_args, 'Deploy[prod, fast]')).to eq(['Deploy', 'prod, fast'])
+      expect(buildnote.send(:parse_topic_with_args, 'Build')).to eq(['Build', nil])
+    end
+  end
+
+  describe 'running' do
+    it 'runs the default topics in order with howzit -r' do
+      buildnote.run
+
+      expect(output_lines).to eq(['build', 'deploy prod fast', 'test'])
+    end
+
+    it 'runs the default topics with howzit -r default' do
+      Howzit.cli_args = ['default']
+      buildnote.run
+
+      expect(output_lines).to eq(['build', 'deploy prod fast', 'test'])
+    end
+
+    context 'with fewer arguments than the topic accepts' do
+      let(:default_line) { 'default: Deploy[prod]' }
+
+      it 'uses the topic defaults for the rest' do
+        buildnote.run
+
+        expect(output_lines).to eq(['deploy prod slow'])
+      end
+    end
+
+    context 'with a missing topic' do
+      let(:default_line) { 'default: Build, Nonexistent, Test' }
+
+      it 'runs the topics that match' do
+        buildnote.run
+
+        expect(output_lines).to eq(%w[build test])
+      end
+    end
+
+    context 'with a failing topic' do
+      let(:default_line) { 'default: Build, Broken, Test' }
+
+      it 'stops after the failure and skips the remaining topics' do
+        buildnote.run
+
+        expect(output_lines).to eq(['build'])
+        expect(Howzit.run_log.map { |e| [e[:task], e[:skipped] ? :skipped : e[:success]] }).to eq(
+          [['Build it', true], ['Fail', false], ['Test it', :skipped]]
+        )
+      end
+    end
+  end
+
+  describe '@include with bracketed arguments' do
+    it 'binds the arguments to the included topic for each include' do
+      Howzit.cli_args = ['release']
+      buildnote.run
+
+      expect(output_lines).to eq(['deploy staging slow', 'deploy prod fast'])
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 2.1.46
+  version: 2.1.48
 platform: ruby
 authors:
 - Brett Terpstra
@@ -317,9 +317,11 @@ files:
 - scripts/runtests.sh
 - spec/buildnote_spec.rb
 - spec/cli_spec.rb
+- spec/collected_notes_spec.rb
 - spec/condition_evaluator_spec.rb
 - spec/conditional_blocks_integration_spec.rb
 - spec/conditional_content_spec.rb
+- spec/default_metadata_spec.rb
 - spec/includes_metadata_spec.rb
 - spec/log_level_spec.rb
 - spec/prompt_spec.rb
@@ -366,9 +368,11 @@ summary: Provides a way to access Markdown project notes by topic with query cap
 test_files:
 - spec/buildnote_spec.rb
 - spec/cli_spec.rb
+- spec/collected_notes_spec.rb
 - spec/condition_evaluator_spec.rb
 - spec/conditional_blocks_integration_spec.rb
 - spec/conditional_content_spec.rb
+- spec/default_metadata_spec.rb
 - spec/includes_metadata_spec.rb
 - spec/log_level_spec.rb
 - spec/prompt_spec.rb