howzit 2.1.21 → 2.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6cac91a8b188ff256fa863ad94e134e820ed2aa2eb766a10fea38ee745de750
-  data.tar.gz: 90799282be7a348b595df19a5c09850db8ac4d653bd81063d49f1830e6cb0761
+  metadata.gz: 4c45e148fc771ca280dbf21202a25f3b6192eb0534f88692103630749de801c9
+  data.tar.gz: 2567392e9e6389845be4809aca60ccb347848b2c7575f0c6f4c9232f4a4fe4f0
 SHA512:
-  metadata.gz: 6b98ee5eb923878803f0268080ad1d56f4f9aed7279e6dcb245f13659e3a947348212741b3409861aacff145bc5abb19af7dd9810a854626e6b5067fc33ad954
-  data.tar.gz: 9be180170d36f0f415e3f0977b5b951368f7498fe630cd4f900626bf852c5678b860cea8ac63472dec0c03c41531cf70eb58a5002298a5ed9f5661204aa6d7cb
+  metadata.gz: 9e22a71fee828ebfcd96e2f1ea5d4f27ad5e6a0401cc6a73f8344313006a160b10db160c6eb71b7f528df8b23233871a6c914c8ccdb48d57a88b60fb25d4e287
+  data.tar.gz: 98411cc9c877f08309c26df629c713510514afeb740a85e741700bd8d9f96b373c5b40affe540e371dd93321aeec6c088fd65d6b953550e4b3161829aa7c0a58

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+### 2.1.22
+
+2025-12-13 06:14
+
+#### NEW
+
+- Template selection menu when creating new build notes
+- Prompt for required template variables during note creation
+- Gum support as fallback for menus and text input
+
+#### IMPROVED
+
+- Fuzzy matching for template names when fzf unavailable
+- Text input uses Readline for proper line editing (backspace, ctrl-a/e)
+
 ### 2.1.21
 
 2025-12-13 05:03

data/lib/howzit/buildnote.rb

@@ -293,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
-        printf '{bw}Project summary: {x}'.c
-        input = $stdin.gets.chomp
-        summary = input unless input.empty?
+        summary = Prompt.get_line('{bw}Project summary{x}'.c)
+      end
+
+      # Template selection
+      selected_templates = []
+      template_metadata = {}
+      unless default
+        selected_templates, template_metadata = select_templates_for_note(title)
       end
 
       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}
 
@@ -369,6 +379,68 @@ 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

data/lib/howzit/prompt.rb

@@ -100,6 +100,10 @@ module Howzit
           return fzf_result(res)
         end
 
+        if Util.command_exist?('gum')
+          return gum_choose(matches, query: query, multi: true)
+        end
+
         tty_menu(matches, query: query)
       end
 
@@ -199,6 +203,190 @@ module Howzit
         end
         line == '' ? 1 : line.to_i
       end
+
+      ##
+      ## Multi-select menu for templates
+      ##
+      ## @param      matches  [Array] The options list
+      ## @param      prompt_text  [String] The prompt to display
+      ##
+      ## @return     [Array] the selected results (can be empty)
+      ##
+      def choose_templates(matches, prompt_text: 'Select templates')
+        return [] if matches.count.zero?
+        return [] unless $stdout.isatty
+
+        if Util.command_exist?('fzf')
+          height = matches.count + 3
+          settings = fzf_template_options(height, prompt_text: prompt_text)
+
+          # Save terminal state before fzf
+          tty_state = `stty -g`.chomp
+          res = `echo #{Shellwords.escape(matches.join("\n"))} | fzf #{settings.join(' ')}`.strip
+          # Restore terminal state after fzf
+          system("stty #{tty_state}")
+
+          return res.empty? ? [] : res.split(/\n/)
+        end
+
+        if Util.command_exist?('gum')
+          return gum_choose(matches, prompt: prompt_text, multi: true, required: false)
+        end
+
+        text_template_input(matches)
+      end
+
+      ##
+      ## FZF options for template selection
+      ##
+      def fzf_template_options(height, prompt_text: 'Select templates')
+        [
+          '-0',
+          '-m',
+          "--height=#{height}",
+          '--header="Tab: add selection, ctrl-a/d: (de)select all, esc: skip, return: confirm"',
+          '--bind ctrl-a:select-all,ctrl-d:deselect-all,ctrl-t:toggle-all',
+          "--prompt=\"#{prompt_text} > \""
+        ]
+      end
+
+      ##
+      ## Text-based template input with fuzzy matching
+      ##
+      ## @param      available  [Array] Available template names
+      ##
+      ## @return     [Array] Matched template names
+      ##
+      def text_template_input(available)
+        @stty_save = `stty -g`.chomp
+
+        trap('INT') do
+          system('stty', @stty_save)
+          exit
+        end
+
+        puts "\n{bw}Available templates:{x} #{available.join(', ')}".c
+        printf '{bw}Enter templates to include, comma-separated (return to skip):{x} '.c
+        input = Readline.readline('', true).strip
+
+        return [] if input.empty?
+
+        fuzzy_match_templates(input, available)
+      ensure
+        system('stty', @stty_save) if @stty_save
+      end
+
+      ##
+      ## Fuzzy match user input against available templates
+      ##
+      ## @param      input      [String] Comma-separated user input
+      ## @param      available  [Array] Available template names
+      ##
+      ## @return     [Array] Matched template names
+      ##
+      def fuzzy_match_templates(input, available)
+        terms = input.split(',').map(&:strip).reject(&:empty?)
+        matched = []
+
+        terms.each do |term|
+          # Try exact match first (case-insensitive)
+          exact = available.find { |t| t.downcase == term.downcase }
+          if exact
+            matched << exact unless matched.include?(exact)
+            next
+          end
+
+          # Try fuzzy match using the same regex approach as topic matching
+          rx = term.to_rx
+          fuzzy = available.select { |t| t =~ rx }
+
+          # Prefer matches that start with the term
+          if fuzzy.length > 1
+            starts_with = fuzzy.select { |t| t.downcase.start_with?(term.downcase) }
+            fuzzy = starts_with unless starts_with.empty?
+          end
+
+          fuzzy.each { |t| matched << t unless matched.include?(t) }
+        end
+
+        matched
+      end
+
+      ##
+      ## Prompt for a single line of input
+      ##
+      ## @param      prompt_text  [String] The prompt to display
+      ## @param      default      [String] Default value if empty
+      ##
+      ## @return     [String] the entered value
+      ##
+      def get_line(prompt_text, default: nil)
+        return (default || '') unless $stdout.isatty
+
+        if Util.command_exist?('gum')
+          result = gum_input(prompt_text, placeholder: default || '')
+          return result.empty? && default ? default : result
+        end
+
+        prompt_with_default = default ? "#{prompt_text} [#{default}]: " : "#{prompt_text}: "
+        result = Readline.readline(prompt_with_default, true).to_s.strip
+        result.empty? && default ? default : result
+      end
+
+      ##
+      ## Use gum for single or multi-select menu
+      ##
+      ## @param      matches   [Array] The options list
+      ## @param      prompt    [String] The prompt text
+      ## @param      multi     [Boolean] Allow multiple selections
+      ## @param      required  [Boolean] Require at least one selection
+      ## @param      query     [String] The search term for display
+      ##
+      ## @return     [Array] Selected items
+      ##
+      def gum_choose(matches, prompt: nil, multi: false, required: true, query: nil)
+        prompt_text = prompt || (query ? "Select for '#{query}'" : 'Select')
+        args = ['gum', 'choose']
+        args << '--no-limit' if multi
+        args << "--header=#{Shellwords.escape(prompt_text)}"
+        args << '--cursor.foreground=6'
+        args << '--selected.foreground=2'
+
+        tty_state = `stty -g`.chomp
+        res = `echo #{Shellwords.escape(matches.join("\n"))} | #{args.join(' ')}`.strip
+        system("stty #{tty_state}")
+
+        if res.empty?
+          if required
+            Howzit.console.info 'Cancelled'
+            Process.exit 0
+          end
+          return []
+        end
+
+        res.split(/\n/)
+      end
+
+      ##
+      ## Use gum for text input
+      ##
+      ## @param      prompt_text   [String] The prompt to display
+      ## @param      placeholder   [String] Placeholder text
+      ##
+      ## @return     [String] The entered value
+      ##
+      def gum_input(prompt_text, placeholder: '')
+        args = ['gum', 'input']
+        args << "--header=#{Shellwords.escape(prompt_text)}"
+        args << "--placeholder=#{Shellwords.escape(placeholder)}" unless placeholder.empty?
+        args << '--cursor.foreground=6'
+
+        tty_state = `stty -g`.chomp
+        res = `#{args.join(' ')}`.strip
+        system("stty #{tty_state}")
+
+        res
+      end
     end
   end
 end

data/lib/howzit/version.rb

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

data/spec/buildnote_spec.rb

@@ -134,4 +134,106 @@ describe Howzit::BuildNote do
       expect(how.send(:topic_search_terms_from_cli)).to eq(['release, deploy', 'topic balogna'])
     end
   end
+
+  describe "#collect_topic_matches" do
+    before do
+      Howzit.options[:multiple_matches] = :first
+    end
+
+    it "collects matches for multiple search terms" do
+      search_terms = ['topic tropic', 'topic banana']
+      output = []
+      matches = how.send(:collect_topic_matches, search_terms, output)
+      expect(matches.count).to eq 2
+      expect(matches.map(&:title)).to include('Topic Tropic', 'Topic Banana')
+    end
+
+    it "prefers exact matches over fuzzy matches" do
+      # 'Topic Banana' should exact-match, not fuzzy match to multiple
+      search_terms = ['topic banana']
+      output = []
+      matches = how.send(:collect_topic_matches, search_terms, output)
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Topic Banana'
+    end
+
+    it "falls back to fuzzy match when no exact match" do
+      Howzit.options[:matching] = 'fuzzy'
+      search_terms = ['trpc']  # fuzzy for 'tropic'
+      output = []
+      matches = how.send(:collect_topic_matches, search_terms, output)
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Topic Tropic'
+    end
+
+    it "adds error message for unmatched terms" do
+      search_terms = ['nonexistent topic xyz']
+      output = []
+      matches = how.send(:collect_topic_matches, search_terms, output)
+      expect(matches.count).to eq 0
+      expect(output.join).to match(/no topic match found/i)
+    end
+
+    it "collects multiple topics from comma-separated input" do
+      Howzit.cli_args = ['topic tropic,topic banana']
+      search_terms = how.send(:topic_search_terms_from_cli)
+      output = []
+      matches = how.send(:collect_topic_matches, search_terms, output)
+      expect(matches.count).to eq 2
+      Howzit.cli_args = []
+    end
+  end
+
+  describe "#smart_split_topics" do
+    it "splits on comma when not part of topic title" do
+      result = how.send(:smart_split_topics, 'topic tropic,topic banana')
+      expect(result).to eq(['topic tropic', 'topic banana'])
+    end
+
+    it "preserves comma when part of topic title" do
+      result = how.send(:smart_split_topics, 'release, deploy,topic banana')
+      expect(result).to eq(['release, deploy', 'topic banana'])
+    end
+
+    it "preserves colon when part of topic title" do
+      result = how.send(:smart_split_topics, 'git:clean,blog:update post')
+      expect(result).to eq(['git:clean', 'blog:update post'])
+    end
+
+    it "handles mixed separators correctly" do
+      result = how.send(:smart_split_topics, 'git:clean:topic tropic')
+      expect(result).to eq(['git:clean', 'topic tropic'])
+    end
+  end
+
+  describe "#parse_template_required_vars" do
+    let(:template_with_required) do
+      Tempfile.new(['template', '.md']).tap do |f|
+        f.write("required: repo_url, author\n\n# Template\n\n## Section")
+        f.close
+      end
+    end
+
+    let(:template_without_required) do
+      Tempfile.new(['template', '.md']).tap do |f|
+        f.write("# Template\n\n## Section")
+        f.close
+      end
+    end
+
+    after do
+      template_with_required.unlink
+      template_without_required.unlink
+    end
+
+    it "parses required variables from template metadata" do
+      vars = how.send(:parse_template_required_vars, template_with_required.path)
+      expect(vars).to eq(['repo_url', 'author'])
+    end
+
+    it "returns empty array when no required metadata" do
+      vars = how.send(:parse_template_required_vars, template_without_required.path)
+      expect(vars).to eq([])
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 2.1.21
+  version: 2.1.22
 platform: ruby
 authors:
 - Brett Terpstra