howzit 2.1.18 → 2.1.22

data/lib/howzit/buildnote.rb

@@ -57,7 +57,7 @@ module Howzit
     ## @param      template  [String] The template title
     ##
     def edit_template(template)
-      file = template.sub(/(\.md)?$/i, ".md")
+      file = template.sub(/(\.md)?$/i, '.md')
       file = File.join(Howzit.config.template_folder, file)
       edit_template_file(file)
     end
@@ -70,9 +70,39 @@ module Howzit
     def find_topic(term = nil)
       return @topics if term.nil?
 
+      rx = term.to_rx
+
+      @topics.filter do |topic|
+        title = topic.title.downcase.sub(/ *\(.*?\) *$/, '')
+        match = title =~ rx
+
+        if !match && term =~ /[,:]/
+          normalized = title.gsub(/\s*([,:])\s*/, '\1')
+          match = normalized =~ rx
+        end
+
+        match
+      end
+    end
+
+    ##
+    ## Find a topic with an exact whole-word match
+    ##
+    ## @param      term  [String] The search term
+    ##
+    ## @return     [Array] Array of topics that exactly match the term
+    ##
+    def find_topic_exact(term = nil)
+      return [] if term.nil?
+
       @topics.filter do |topic|
-        rx = term.to_rx
-        topic.title.downcase.sub(/ *\(.*?\) *$/, "") =~ rx
+        title = topic.title.downcase.sub(/ *\(.*?\) *$/, '').strip
+        # Split both the title and search term into words
+        title_words = title.split
+        search_words = term.split
+
+        # Check if all search words match the title words exactly (case-insensitive)
+        search_words.map(&:downcase) == title_words.map(&:downcase)
       end
     end
 
@@ -84,7 +114,7 @@ module Howzit
       title = "#{title} project notes"
       url = "[#{title}](file://#{note_file})"
       Util.os_copy(url)
-      Howzit.console.info("Link copied to clipboard.")
+      Howzit.console.info('Link copied to clipboard.')
     end
 
     ##
@@ -117,9 +147,7 @@ module Howzit
     def list_topics
       @topics.map do |topic|
         title = topic.title
-        unless topic.named_args.empty?
-          title += "(#{topic.named_args.keys.join(", ")})"
-        end
+        title += "(#{topic.named_args.keys.join(', ')})" unless topic.named_args.empty?
         title
       end
     end
@@ -143,13 +171,11 @@ module Howzit
     def list_runnable_completions
       output = []
       @topics.each do |topic|
-        if topic.tasks.count.positive?
-          title = topic.title
-          unless topic.named_args.empty?
-            title += "(#{topic.named_args.keys.join(", ")})"
-          end
-          output.push(title)
-        end
+        next unless topic.tasks.count.positive?
+
+        title = topic.title
+        title += "(#{topic.named_args.keys.join(', ')})" unless topic.named_args.empty?
+        output.push(title)
       end
       output.join("\n")
     end
@@ -172,9 +198,7 @@ module Howzit
         next if s_out.empty?
 
         title = topic.title
-        unless topic.named_args.empty?
-          title += " {dy}({xy}#{topic.named_args.keys.join(", ")}{dy}){x}"
-        end
+        title += " {dy}({xy}#{topic.named_args.keys.join(', ')}{dy}){x}" unless topic.named_args.empty?
 
         output.push("- {g}#{title}{x}".c)
         output.push(s_out.join("\n"))
@@ -199,7 +223,7 @@ module Howzit
     ## @param      prompt  [Boolean] confirm file creation?
     ##
     def create_template_file(file, prompt: false)
-      trap("SIGINT") do
+      trap('SIGINT') do
         Howzit.console.info "\nCancelled"
         exit!
       end
@@ -211,7 +235,7 @@ module Howzit
         Process.exit 0 unless res
       end
 
-      title = File.basename(file, ".md")
+      title = File.basename(file, '.md')
 
       note = <<~EOBUILDNOTES
         # #{title}
@@ -223,12 +247,12 @@ module Howzit
       if File.exist?(file) && !default
         file = "{by}#{file}".c
         unless Prompt.yn("Are you sure you want to overwrite #{file}", default: false)
-          Howzit.console.info("Cancelled")
+          Howzit.console.info('Cancelled')
           Process.exit 0
         end
       end
 
-      File.open(file, "w") do |f|
+      File.open(file, 'w') do |f|
         f.puts note
         Howzit.console.info("{by}Template {bw}#{title}{by} written to {bw}#{file}{x}".c)
       end
@@ -243,7 +267,7 @@ module Howzit
 
     # Create a buildnotes skeleton
     def create_note(prompt: false)
-      trap("SIGINT") do
+      trap('SIGINT') do
         Howzit.console.info "\nCancelled"
         exit!
       end
@@ -251,7 +275,7 @@ module Howzit
       default = !$stdout.isatty || Howzit.options[:default]
 
       if prompt && !default
-        res = Prompt.yn("No build notes file found, create one?", default: true)
+        res = Prompt.yn('No build notes file found, create one?', default: true)
         Process.exit 0 unless res
       end
 
@@ -269,27 +293,37 @@ module Howzit
       if default
         input = title
       else
-        # title = prompt.ask("{bw}Project name:{x}".c, default: title)
-        printf "{bw}Project name {xg}[#{title}]{bw}: {x}".c
-        input = $stdin.gets.chomp
-        title = input unless input.empty?
+        title = Prompt.get_line('{bw}Project name{x}'.c, default: title)
+      end
+      summary = ''
+      unless default
+        summary = Prompt.get_line('{bw}Project summary{x}'.c)
       end
-      summary = ""
+
+      # Template selection
+      selected_templates = []
+      template_metadata = {}
       unless default
-        printf "{bw}Project summary: {x}".c
-        input = $stdin.gets.chomp
-        summary = input unless input.empty?
+        selected_templates, template_metadata = select_templates_for_note(title)
       end
 
-      fname = "buildnotes.md"
+      fname = 'buildnotes.md'
       unless default
-        printf "{bw}Build notes filename (must begin with 'howzit' or 'build')\n{xg}[#{fname}]{bw}: {x}".c
-        input = $stdin.gets.chomp
-        fname = input unless input.empty?
+        fname = Prompt.get_line("{bw}Build notes filename{x}\n(must begin with 'howzit' or 'build')".c, default: fname)
       end
 
+      # Build metadata section
+      metadata_lines = []
+      unless selected_templates.empty?
+        metadata_lines << "template: #{selected_templates.join(',')}"
+      end
+      template_metadata.each do |key, value|
+        metadata_lines << "#{key}: #{value}"
+      end
+      metadata_section = metadata_lines.empty? ? '' : "#{metadata_lines.join("\n")}\n\n"
+
       note = <<~EOBUILDNOTES
-        # #{title}
+        #{metadata_section}# #{title}
 
         #{summary}
 
@@ -316,12 +350,12 @@ module Howzit
       if File.exist?(fname) && !default
         file = "{by}#{fname}".c
         unless Prompt.yn("Are you absolutely sure you want to overwrite #{file}", default: false)
-          Howzit.console.info("Canceled")
+          Howzit.console.info('Canceled')
           Process.exit 0
         end
       end
 
-      File.open(fname, "w") do |f|
+      File.open(fname, 'w') do |f|
         f.puts note
         Howzit.console.info("{by}Build notes for {bw}#{title}{by} written to {bw}#{fname}{x}".c)
       end
@@ -345,6 +379,132 @@ module Howzit
 
     private
 
+    ##
+    ## Select templates for a new build note
+    ##
+    ## @param      project_title  [String] The project title for prompts
+    ##
+    ## @return     [Array<Array, Hash>] Array of [selected_template_names, required_vars_hash]
+    ##
+    def select_templates_for_note(project_title)
+      template_dir = Howzit.config.template_folder
+      template_glob = File.join(template_dir, '*.md')
+      template_files = Dir.glob(template_glob)
+
+      return [[], {}] if template_files.empty?
+
+      # Get basenames without extension for menu
+      template_names = template_files.map { |f| File.basename(f, '.md') }.sort
+
+      # Show multi-select menu
+      selected = Prompt.choose_templates(template_names, prompt_text: 'Select templates to include')
+      return [[], {}] if selected.empty?
+
+      # Prompt for required variables from each template
+      required_vars = {}
+      selected.each do |template_name|
+        template_path = File.join(template_dir, "#{template_name}.md")
+        next unless File.exist?(template_path)
+
+        vars = parse_template_required_vars(template_path)
+        vars.each do |var|
+          next if required_vars.key?(var)
+
+          value = Prompt.get_line("{bw}[#{template_name}] requires {by}#{var}{x}".c)
+          required_vars[var] = value unless value.empty?
+        end
+      end
+
+      [selected, required_vars]
+    end
+
+    ##
+    ## Parse a template file for required variables
+    ##
+    ## @param      template_path  [String] Path to the template file
+    ##
+    ## @return     [Array] Array of required variable names
+    ##
+    def parse_template_required_vars(template_path)
+      content = File.read(template_path)
+
+      # Look for required: in the metadata at the top of the file
+      # Metadata is before the first # heading
+      meta_section = content.split(/^#/)[0]
+      return [] if meta_section.nil? || meta_section.strip.empty?
+
+      # Find the required: line
+      match = meta_section.match(/^required:\s*(.+)$/i)
+      return [] unless match
+
+      # Split by comma and strip whitespace
+      match[1].split(',').map(&:strip).reject(&:empty?)
+    end
+
+    def topic_search_terms_from_cli
+      args = Howzit.cli_args || []
+      raw = args.join(' ').strip
+      return [] if raw.empty?
+
+      smart_split_topics(raw).map { |term| term.strip.downcase }.reject(&:empty?)
+    end
+
+    def smart_split_topics(raw)
+      segments, separators = segments_and_separators_for(raw)
+      return segments if separators.empty?
+
+      combined = []
+      current = segments.shift || ''
+
+      separators.each_with_index do |separator, idx|
+        next_segment = segments[idx] || ''
+        if keep_separator_with_current?(current, separator, next_segment)
+          current = "#{current}#{separator}#{next_segment}"
+        else
+          combined << current
+          current = next_segment
+        end
+      end
+
+      combined << current
+      combined
+    end
+
+    def segments_and_separators_for(raw)
+      segments = []
+      separators = []
+      current = String.new
+
+      raw.each_char do |char|
+        if char =~ /[,:]/
+          segments << current
+          separators << char
+          current = String.new
+        else
+          current << char
+        end
+      end
+
+      segments << current
+      [segments, separators]
+    end
+
+    def keep_separator_with_current?(current, separator, next_segment)
+      candidate = "#{current}#{separator}#{next_segment}"
+      normalized_candidate = normalize_separator_string(candidate)
+      return false if normalized_candidate.empty?
+
+      @topics.any? do |topic|
+        normalize_separator_string(topic.title).start_with?(normalized_candidate)
+      end
+    end
+
+    def normalize_separator_string(string)
+      return '' if string.nil?
+
+      string.downcase.gsub(/\s+/, ' ').strip.gsub(/\s*([,:])\s*/, '\1')
+    end
+
     ##
     ## Import the contents of a filename as new topics
     ##
@@ -357,15 +517,15 @@ module Howzit
       return mtch[0] unless File.exist?(file)
 
       content = Util.read_file(file)
-      home = ENV["HOME"]
-      short_path = File.dirname(file.sub(/^#{home}/, "~"))
+      home = ENV['HOME']
+      short_path = File.dirname(file.sub(/^#{home}/, '~'))
       prefix = "#{short_path}/#{File.basename(file)}:"
       parts = content.split(/^##+/)
       parts.shift
       if parts.empty?
         content
       else
-        "## #{parts.join("## ")}".gsub(/^(##+ *)(?=\S)/, "\\1#{prefix}")
+        "## #{parts.join('## ')}".gsub(/^(##+ *)(?=\S)/, "\\1#{prefix}")
       end
     end
 
@@ -382,15 +542,15 @@ module Howzit
 
       t_meta = t_leader.metadata
 
-      return unless t_meta.key?("required")
+      return unless t_meta.key?('required')
 
-      required = t_meta["required"].strip.split(/\s*,\s*/)
+      required = t_meta['required'].strip.split(/\s*,\s*/)
       required.each do |req|
         next if @metadata.keys.include?(req.downcase)
 
         Howzit.console.error %({bRw}ERROR:{xbr} Missing required metadata key from template '{bw}#{File.basename(
-                               template, ".md"
-                             )}{xr}'{x}).c
+          template, '.md'
+        )}{xr}'{x}).c
         Howzit.console.error %({br}Please define {by}#{req.downcase}{xr} in build notes{x}).c
         Process.exit 1
       end
@@ -408,8 +568,8 @@ module Howzit
       subtopics = nil
 
       if template =~ /\[(.*?)\]$/
-        subtopics = Regexp.last_match[1].split(/\s*\|\s*/).map { |t| t.gsub(/\*/, ".*?") }
-        template.sub!(/\[.*?\]$/, "").strip
+        subtopics = Regexp.last_match[1].split(/\s*\|\s*/).map { |t| t.gsub(/\*/, '.*?') }
+        template.sub!(/\[.*?\]$/, '').strip
       end
 
       [template, subtopics]
@@ -429,7 +589,7 @@ module Howzit
       templates.each do |template|
         template, subtopics = detect_subtopics(template)
 
-        file = template.sub(/(\.md)?$/i, ".md")
+        file = template.sub(/(\.md)?$/i, '.md')
         file = File.join(Howzit.config.template_folder, file)
 
         next unless File.exist?(file)
@@ -493,7 +653,7 @@ module Howzit
       buildnotes = []
       filename = nil
 
-      while dir != "/" && (dir =~ %r{[A-Z]:/}).nil?
+      while dir != '/' && (dir =~ %r{[A-Z]:/}).nil?
         Dir.chdir(dir)
         filename = glob_note
         unless filename.nil?
@@ -516,7 +676,7 @@ module Howzit
     ## @return     [String] file path
     ##
     def glob_note
-      Dir.glob("*.{txt,md,markdown}").select(&:build_note?).sort[0]
+      Dir.glob('*.{txt,md,markdown}').select(&:build_note?).sort[0]
     end
 
     ##
@@ -529,9 +689,9 @@ module Howzit
     def find_note_file
       filename = glob_note
 
-      if filename.nil? && "git".available?
+      if filename.nil? && 'git'.available?
         proj_dir = `git rev-parse --show-toplevel 2>/dev/null`.strip
-        unless proj_dir == ""
+        unless proj_dir == ''
           Dir.chdir(proj_dir)
           filename = glob_note
         end
@@ -575,8 +735,8 @@ module Howzit
 
       data = leader.metadata
 
-      if data.key?("template")
-        templates = data["template"].strip.split(/\s*,\s*/)
+      if data.key?('template')
+        templates = data['template'].strip.split(/\s*,\s*/)
 
         template_topics.concat(gather_templates(templates))
       end
@@ -618,13 +778,13 @@ module Howzit
 
         lines = sect.split(/\n/)
         title = lines.slice!(0).strip
-        prefix = ""
+        prefix = ''
         if path && path != note_file
           if path =~ /#{Howzit.config.template_folder}/
-            short_path = File.basename(path, ".md")
+            short_path = File.basename(path, '.md')
           else
-            home = ENV["HOME"]
-            short_path = File.dirname(path.sub(/^#{home}/, "~"))
+            home = ENV['HOME']
+            short_path = File.dirname(path.sub(/^#{home}/, '~'))
             prefix = "_from #{short_path}_\n\n"
           end
           title = "#{short_path}:#{title}"
@@ -636,7 +796,7 @@ module Howzit
       end
 
       template_topics.each do |topic|
-        topics.push(topic) unless find_topic(topic.title.sub(/^.+:/, "")).count.positive?
+        topics.push(topic) unless find_topic(topic.title.sub(/^.+:/, '')).count.positive?
       end
 
       topics
@@ -655,7 +815,7 @@ module Howzit
         upstream_topics = read_upstream
 
         upstream_topics.each do |topic|
-          @topics.push(topic) unless find_topic(topic.title.sub(/^.+:/, "")).count.positive?
+          @topics.push(topic) unless find_topic(topic.title.sub(/^.+:/, '')).count.positive?
         end
         Howzit.has_read_upstream = true
       end
@@ -670,11 +830,11 @@ module Howzit
     ## Open build note in editor
     ##
     def edit_note
-      editor = Howzit.options.fetch(:editor, ENV["EDITOR"])
+      editor = Howzit.options.fetch(:editor, ENV['EDITOR'])
 
       editor = Howzit.config.update_editor if editor.nil?
 
-      raise "No editor defined" if editor.nil?
+      raise 'No editor defined' if editor.nil?
 
       raise "Invalid editor (#{editor})" unless Util.valid_command?(editor)
 
@@ -688,7 +848,7 @@ module Howzit
     ## @param      template  [String] The template name
     ##
     def create_template(template)
-      file = template.sub(/(\.md)?$/i, ".md")
+      file = template.sub(/(\.md)?$/i, '.md')
       file = File.join(Howzit.config.template_folder, file)
       create_template_file(file, prompt: false)
     end
@@ -697,11 +857,11 @@ module Howzit
     ## Open template in editor
     ##
     def edit_template_file(file)
-      editor = Howzit.options.fetch(:editor, ENV["EDITOR"])
+      editor = Howzit.options.fetch(:editor, ENV['EDITOR'])
 
       editor = Howzit.config.update_editor if editor.nil?
 
-      raise "No editor defined" if editor.nil?
+      raise 'No editor defined' if editor.nil?
 
       raise "Invalid editor (#{editor})" unless Util.valid_command?(editor)
 
@@ -722,12 +882,12 @@ module Howzit
       new_topic = topic.is_a?(String) ? find_topic(topic)[0] : topic.dup
 
       output = if run
-          new_topic.run
-        else
-          new_topic.print_out({ single: single })
-        end
+                 new_topic.run
+               else
+                 new_topic.print_out({ single: single })
+               end
 
-      output.nil? ? "" : output.join("\n\n")
+      output.nil? ? '' : output.join("\n\n")
     end
 
     ##
@@ -735,6 +895,10 @@ module Howzit
     ##
     def process
       output = []
+      if Howzit.options[:run]
+        Howzit.run_log = []
+        Howzit.multi_topic_run = false
+      end
 
       unless note_file
         Process.exit 0 if Howzit.options[:list_runnable_titles] || Howzit.options[:list_topic_titles]
@@ -748,7 +912,7 @@ module Howzit
         Process.exit(0)
       elsif Howzit.options[:output_title] && !Howzit.options[:run]
         if @title && !@title.empty?
-          header = @title.format_header({ hr: "\u{2550}", color: "{bwK}" })
+          header = @title.format_header({ hr: "\u{2550}", color: '{bwK}' })
           output.push("#{header}\n")
         end
       end
@@ -774,62 +938,139 @@ module Howzit
         Process.exit(0)
       end
 
-      topic_matches = []
-
+      # Handle grep and choose modes (batch all results)
       if Howzit.options[:grep]
+        topic_matches = []
         matches = grep(Howzit.options[:grep])
         case Howzit.options[:multiple_matches]
         when :all
           topic_matches.concat(matches.sort_by(&:title))
         else
-          topic_matches.concat(Prompt.choose(matches.map(&:title), height: :max))
+          topic_matches.concat(Prompt.choose(matches.map(&:title), height: :max, query: Howzit.options[:grep]))
         end
+        process_topic_matches(topic_matches, output)
       elsif Howzit.options[:choose]
+        topic_matches = []
         titles = Prompt.choose(list_topics, height: :max)
         titles.each { |title| topic_matches.push(find_topic(title)[0]) }
-        # If there are arguments use those to search for a matching topic
+        process_topic_matches(topic_matches, output)
       elsif !Howzit.cli_args.empty?
-        search = Howzit.cli_args.join(" ").strip.downcase.split(/ *, */).map(&:strip)
+        # Collect all topic matches first (showing menus as needed)
+        search = topic_search_terms_from_cli
+        topic_matches = collect_topic_matches(search, output)
+        process_topic_matches(topic_matches, output)
+      else
+        # No arguments - show all topics
+        if Howzit.options[:run]
+          Howzit.run_log = []
+          Howzit.multi_topic_run = topics.length > 1
+        end
+        topics.each { |k| output.push(process_topic(k, false, single: false)) }
+        finalize_output(output)
+      end
+    end
 
-        search.each do |s|
-          matches = find_topic(s)
+    ##
+    ## Collect all topic matches from search terms, showing menus as needed
+    ## but not displaying/running until all selections are made
+    ##
+    ## @param      search_terms  [Array] Array of search term strings
+    ## @param      output        [Array] Output array for error messages
+    ##
+    ## @return     [Array] Array of all matched topics
+    ##
+    def collect_topic_matches(search_terms, output)
+      all_matches = []
 
-          if matches.empty?
-            output.push(%({bR}ERROR:{xr} No topic match found for {bw}#{s}{x}\n).c)
-          else
-            case Howzit.options[:multiple_matches]
-            when :first
-              topic_matches.push(matches[0])
-            when :best
-              topic_matches.push(matches.sort_by { |a| [a.title.comp_distance(s), a.title.length] })
-            when :all
-              topic_matches.concat(matches)
-            else
-              titles = matches.map(&:title)
-              res = Prompt.choose(titles)
-              old_matching = Howzit.options[:matching]
-              Howzit.options[:matching] = "exact"
-              res.each { |title| topic_matches.concat(find_topic(title)) }
-              Howzit.options[:matching] = old_matching
-            end
-          end
-        end
+      search_terms.each do |s|
+        # First check for exact whole-word matches
+        exact_matches = find_topic_exact(s)
+
+        topic_matches = if !exact_matches.empty?
+                          exact_matches
+                        else
+                          resolve_fuzzy_matches(s, output)
+                        end
 
-        if topic_matches.empty? && !Howzit.options[:show_all_on_error]
-          Util.show(output.join("\n"), { color: true, highlight: false, paginate: false, wrap: 0 })
-          Process.exit 1
+        if topic_matches.empty?
+          output.push(%({bR}ERROR:{xr} No topic match found for {bw}#{s}{x}\n).c)
+        else
+          all_matches.concat(topic_matches)
         end
       end
 
+      all_matches
+    end
+
+    ##
+    ## Resolve fuzzy matches for a search term
+    ##
+    ## @param      search_term  [String] The search term
+    ## @param      output       [Array] Output array for errors
+    ##
+    ## @return     [Array] Array of matched topics
+    ##
+    def resolve_fuzzy_matches(search_term, output)
+      matches = find_topic(search_term)
+
+      return [] if matches.empty?
+
+      case Howzit.options[:multiple_matches]
+      when :first
+        [matches[0]]
+      when :best
+        [matches.sort_by { |a| [a.title.comp_distance(search_term), a.title.length] }.first]
+      when :all
+        matches
+      else
+        titles = matches.map(&:title)
+        res = Prompt.choose(titles, query: search_term)
+        old_matching = Howzit.options[:matching]
+        Howzit.options[:matching] = 'exact'
+        selected = res.flat_map { |title| find_topic(title) }
+        Howzit.options[:matching] = old_matching
+        selected
+      end
+    end
+
+    ##
+    ## Process collected topic matches and display output
+    ##
+    ## @param      topic_matches  [Array] Array of matched topics
+    ## @param      output         [Array] Output array
+    ##
+    def process_topic_matches(topic_matches, output)
+      if topic_matches.empty? && !Howzit.options[:show_all_on_error]
+        Util.show(output.join("\n"), { color: true, highlight: false, paginate: false, wrap: 0 })
+        Process.exit 1
+      end
+
+      if Howzit.options[:run]
+        Howzit.run_log = []
+        Howzit.multi_topic_run = topic_matches.length > 1
+      end
+
       if !topic_matches.empty?
-        # If we found a match
         topic_matches.map! { |topic| topic.is_a?(String) ? find_topic(topic)[0] : topic }
         topic_matches.each { |topic_match| output.push(process_topic(topic_match, Howzit.options[:run], single: true)) }
       else
-        # If there's no argument or no match found, output all
         topics.each { |k| output.push(process_topic(k, false, single: false)) }
       end
-      Howzit.options[:paginate] = false if Howzit.options[:run]
+
+      finalize_output(output)
+    end
+
+    ##
+    ## Finalize and display output with run summary if applicable
+    ##
+    ## @param      output  [Array] Output array
+    ##
+    def finalize_output(output)
+      if Howzit.options[:run]
+        Howzit.options[:paginate] = false
+        summary = Howzit::RunReport.format
+        output.push(summary) unless summary.empty?
+      end
       Util.show(output.join("\n").strip, Howzit.options)
     end
   end