make_menu 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fde049dc673ab7e43c9254d5b394b9ed592a9d9799e46046c1d935a1d55e4774
+  data.tar.gz: 0b289aa24e021fa1ba4f2add414978de9783827fac12e028d38ebb39adcbf80f
+SHA512:
+  metadata.gz: 443c5ad6a9eb87e424e7e693ea3e618ecafdbf1d979c03cdbe4c0c31782b6ca3905648fe01a950901b39b7706d3f7ff9870c3cd854f9d5a99218bcd1688553b8
+  data.tar.gz: eaf82c95dc0df11c6422c76ed49d634501bcc7ed9a0894d08ca77cb091887766c1767b6bb525a112e067925f3cb8f73647343bb6ff27858800e3a530a5c38d95

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,17 @@
+PATH
+  remote: .
+  specs:
+    make_menu (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  make_menu!
+
+BUNDLED WITH
+   2.3.26

data/lib/make_menu/color_string.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module MakeMenu
+  # Monkeypatch for `String`, adds methods to change console text colo(u)r
+  module ColorString
+    COLORS = {
+      white: 0,
+      normal: 0,
+      bold: 1,
+      dark: 2,
+      underline: 4,
+      blink: 5,
+      invert: 7,
+
+      black: 30,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      magenta: 35,
+      cyan: 36,
+      grey: 37,
+
+      black_bg: 40,
+      red_bg: 41,
+      green_bg: 42,
+      yellow_bg: 43,
+      blue_bg: 44,
+      magenta_bg: 45,
+      cyan_bg: 46,
+      grey_bg: 47,
+
+      dark_grey: 90,
+      light_red: 91,
+      light_green: 92,
+      light_yellow: 93,
+      light_blue: 94,
+      light_magenta: 95,
+      light_cyan: 96,
+      light_grey: 97,
+
+      dark_grey_bg: 100,
+      light_red_bg: 101,
+      light_green_bg: 102,
+      light_yellow_bg: 103,
+      light_blue_bg: 104,
+      light_magenta_bg: 105,
+      light_cyan_bg: 106,
+      light_grey_bg: 107
+    }.freeze
+
+    COLORS.each do |name, code|
+      define_method name do
+        color(code)
+      end
+    end
+
+    # Apply specified color code to the String
+    # @param [Array, Symbol, Integer] color_code Can be a key in the COLORS array,
+    #     an integer ANSI code for text color, or an array of either to be applied in order
+    # @return [String] String enclosed by formatting characters
+    def color(color_code)
+      case color_code
+      when Array
+        color_code.inject(self) { |string, code| string.color(code) }
+      when Symbol
+        color(COLORS[color_code])
+      else
+        "\e[#{color_code}m#{self}\e[0m"
+      end
+    end
+
+    # Changes all occurrences of a specified character to one color,
+    # and all other characters to another
+    # @param [String] char Character to highlight
+    # @param [Symbol] fore_color Key of color to use for highlighted character
+    # @param [Symbol] back_color Key of color to use for other characters
+    # @return [String] Highlighted text
+    # @example "==$$==".highlight('$', :light_yellow, :red)
+    # rubocop:disable Metrics/MethodLength
+    def highlight(char, fore_color, back_color)
+      inside_highlight = false
+      output = ''
+      buffer = ''
+      each_char do |c|
+        if c == char
+          unless inside_highlight
+            output += buffer.color(COLORS[back_color.to_sym])
+            buffer = ''
+            inside_highlight = true
+          end
+        elsif inside_highlight
+          output += buffer.color(COLORS[fore_color.to_sym]).bold
+          buffer = ''
+          inside_highlight = false
+        end
+        buffer += c
+      end
+
+      output += if inside_highlight
+                  buffer.color(COLORS[fore_color.to_sym]).bold
+                else
+                  buffer.color(COLORS[back_color.to_sym])
+                end
+
+      output
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Remove color codes from the string
+    # @return [String] The modified string
+    def decolor
+      gsub(/\e\[\d+m/, '')
+    end
+
+    # Align the string, ignoring color code characters which would otherwise mess up String#center, etc.
+    # @param [Symbol] alignment :left, :center, or :right
+    # @param [Integer] width The number of characters to spread the string over (default to terminal width)
+    # @param [String] char The character to use for padding
+    # @param [Boolean] pad_right Set true to include trailing spaces when aligning to :center
+    # @return [String] The padded string
+    # rubocop:disable Metrics/MethodLength
+    def align(alignment = :left, width: nil, char: ' ', pad_right: false)
+      width = ::TTY::Screen.cols unless width
+
+      case alignment
+      when :left
+        right_pad = width - decolor.length
+        "#{self}#{char * right_pad}"
+      when :center
+        left_pad = [(width - decolor.length) / 2, 0].max
+        right_pad = width - left_pad - decolor.length
+        "#{char * left_pad}#{self}#{pad_right ? char * right_pad : ''}"
+      when :right
+        left_pad = width - decolor.length
+        "#{char * left_pad}#{self}"
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/make_menu/menu.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative 'menu_item_group'
+require_relative 'color_string'
+require_relative 'text_table'
+
+module MakeMenu
+  # This class builds and displays a number-selection menu from a Makefile
+  # then prompts for a number and executes the target.
+  class Menu
+    # @param [String] makefile Makefile name
+    def initialize(makefile)
+      @groups = []
+      @items = []
+      @status_present = false
+      build makefile
+    end
+
+    attr_reader :groups, :items
+    attr_accessor :status_present
+
+    # Display menu and prompt for command
+    # rubocop:disable Metrics/MethodLength
+    def run
+      running = true
+
+      while running
+        system 'clear' if clear_screen?
+
+        display_header
+
+        puts colorize(TextTable.new(groups).to_s)
+        puts
+        puts 'Press ENTER to quit'.align(:center).bold
+        puts
+        print 'Select option: '.align(:center)
+
+        running = false unless execute_option(gets.strip)
+      end
+
+      puts
+
+      system 'clear' if clear_screen?
+    end
+
+    # rubocop:enable Metrics/MethodLength
+
+    # Display the company logo and the status bar (if set)
+    def display_header
+      puts formatted_logo if logo
+      puts `make status` if status_present
+    end
+
+    private
+
+    # Build a menu from the specified Makefile
+    # @param [String] makefile Filename
+    # rubocop:disable Metrics/MethodLength
+    def build(makefile)
+      File.open(makefile, 'r') do |file|
+        option_number = 1
+        current_group = nil
+
+        file.each_line do |line|
+          if line.start_with? '###'
+            # Group header
+            group_title = line.gsub(/###\s+/, '').strip
+            current_group = MenuItemGroup.new(group_title.color(group_title_color))
+            groups << current_group
+
+          elsif line.match(/^[a-zA-Z_-]+:.*?## .*$$/)
+            # Menu item
+            target = line.split(':').first.strip
+            description = line.split('##').last.strip
+
+            # Target 'menu' should not appear
+            next if target == 'menu'
+
+            # Target 'status' should not appear, but is run automatically when the menu is rendered
+            if target == 'status'
+              self.status_present = true
+              next
+            end
+
+            unless current_group
+              current_group = MenuItemGroup.new
+              groups << current_group
+            end
+
+            items << current_group.add_item(
+              MenuItem.new(option_number, target, description)
+            )
+
+            option_number += 1
+          end
+        end
+      end
+    end
+
+    # rubocop:enable Metrics/MethodLength
+
+    # Execute the selected menu item
+    # @param [String] selected Value entered by user
+    # @return [Boolean] False to signify that menu should exit
+    def execute_option(selected)
+      return false if selected.empty?
+
+      selected = selected.to_i
+
+      items.each do |item|
+        next unless item.option_number == selected
+
+        system 'clear' if clear_screen?
+        item.execute
+        return true
+      end
+
+      true
+    end
+
+    # Apply word colorings
+    # @param [String] string
+    # @return [String]
+    def colorize(string)
+      return string unless Object.const_defined?("#{self.class.name}::HIGHLIGHTS")
+
+      Object.const_get("#{self.class.name}::HIGHLIGHTS").each do |word, color|
+        case color
+        when Array
+          color.each { |c| string.gsub!(word, word.send(c)) }
+        else
+          string.gsub!(word, word.send(color))
+        end
+      end
+      string
+    end
+
+    # Center each line of the logo across the screen
+    def formatted_logo
+      logo.split("\n")
+          .map { |line| line.align(:center) }
+          .join("\n")
+    end
+
+    # Get the menu logo from the LOGO constant
+    def logo
+      return "\n#{' make '.black_bg.light_yellow}#{' menu '.light_yellow_bg.black}\n".bold unless Object.const_defined?("#{self.class.name}::LOGO")
+
+      Object.const_get("#{self.class.name}::LOGO")
+    end
+
+    protected
+
+    # Override the following methods to customise the menu display
+
+    # @return [Symbol] Color for group title
+    def group_title_color
+      :light_green
+    end
+
+    # Clean screen before and after each command
+    def clear_screen?
+      true
+    end
+  end
+end

data/lib/make_menu/menu_item.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MakeMenu
+  # This class represents an option in the menu which runs a target from the Makefile
+  class MenuItem
+    INDENT = 6
+
+    # @param [Integer] option_number Number user enters for this command
+    # @param [String] target Name of target defined in Makefile
+    # @param [String] description Text to display for this command, taken from Makefile comment
+    def initialize(option_number = nil, target = nil, description = nil)
+      @option_number = option_number
+      @target = target
+      @description = description || target
+    end
+
+    attr_reader :option_number, :target, :description
+
+    # Run the make target
+    def execute
+      cmd = ['make', target]
+      puts "> #{cmd.join(' ').cyan}\n"
+      unless system(*cmd)
+        # Indicates the command failed, so we pause to allow user to see error message
+        puts "\nPress ENTER key to continue....\n"
+        gets
+      end
+    rescue StandardError => _e
+      # ignore CTRL+C from within Make target
+    end
+
+    # @return [Integer] Number of characters required to display the item
+    def width
+      description.size + INDENT + 1
+    end
+
+    # @return [String] Text to display for this item
+    def to_s
+      "#{option_number.to_s.rjust(INDENT, ' ').bold}.  #{description}"
+    end
+  end
+end

data/lib/make_menu/menu_item_group.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'menu_item'
+
+module MakeMenu
+  # This class represents a group of menu items, with a title line
+  class MenuItemGroup
+    INDENT = 2
+
+    # @param [String] title The title text to display at the top of the group
+    def initialize(title = 'Commands')
+      @title = title
+      @items = []
+    end
+
+    attr_reader :title, :items
+
+    # Add a new item to the group
+    # @param [MenuItem] item The item to add
+    # @return [MenuItem] The added item
+    def add_item(item)
+      items << item
+      item
+    end
+
+    # @return [Integer] Number of characters needed to display the widest item
+    def width
+      [items.map(&:width).max, title.length + INDENT].max
+    end
+
+    # @return [Integer] Number of rows needed to display the group
+    def height
+      items.size + 2
+    end
+
+    # @return [String] Text representation of group
+    def to_s
+      result = "#{' ' * INDENT}#{title}\n"
+
+      items.each do |item|
+        result += "#{item}\n"
+      end
+
+      "#{result} "
+    end
+  end
+end

data/lib/make_menu/status_panel.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative 'color_string'
+require 'readline'
+
+module MakeMenu
+  # A panel above the menu displaying the status of Docker containers.
+  # The mapping of TextLabel => ContainerName must be defined in a constant called CONTAINERS
+  class StatusPanel
+    String.include(ColorString)
+
+    # Print panel
+    def display
+      return if containers.empty?
+
+      puts "\n#{panel}"
+    end
+
+    protected
+
+    # Return a hash mapping label to container name
+    # This is assumed to be provided as a constant called CONTAINERS
+    # @return [Hash{String=>String}]
+    def containers
+      Object.const_get "#{self.class.name}::CONTAINERS"
+    rescue NameError
+      {}
+    end
+
+    # Override this to change the colors for running / not running
+    def colors_if_running
+      {
+        true => %i[green_bg bold white],
+        false => %i[red_bg bold dark]
+      }.freeze
+    end
+
+    # Override this to limit each row to a maximum number of labels
+    def max_labels_per_line
+      containers.size
+    end
+
+    private
+
+    # @return [String] Text representation of the panel
+    # rubocop:disable Metrics/MethodLength
+    def panel
+      return @panel if @panel
+
+      @panel = ''
+      labels_on_this_line = 0
+      line_buffer = ''
+
+      containers.each do |label, container|
+        if (labels_on_this_line + 1) > labels_per_line
+          @panel += "#{left_indent(labels_on_this_line)}#{line_buffer}\n\n"
+          labels_on_this_line = 0
+          line_buffer = ''
+        end
+
+        text = label.align(:center, width: max_label_width, pad_right: true)
+                    .color(colors_if_running[running?(container)])
+
+        line_buffer += " #{text} "
+
+        labels_on_this_line += 1
+      end
+
+      @panel += "#{left_indent(labels_on_this_line)}#{line_buffer}\n\n"
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # @return [String] List of Docker containers and information
+    def docker_ps
+      @docker_ps ||= `docker compose ps`
+    end
+
+    # @return [Boolean] whether specified container is running
+    def running?(container)
+      docker_ps.include? container
+    end
+
+    # Return the left indent for this line of labels
+    # @param [Integer] number_of_labels Number of labels on this line
+    # @return [String]
+    def left_indent(number_of_labels)
+      spaces = (::TTY::Screen.cols - (number_of_labels * (max_label_width + 2))) / 2
+      spaces = [spaces, 0].max
+      ' ' * spaces
+    end
+
+    # @return [Integer] Maximum label width, with padding
+    def max_label_width
+      @max_label_width ||= containers.map do |label, _container|
+        label.length
+      end.max + 2
+    end
+
+    # @return [Integer] Number of labels that can fit on one line
+    def labels_per_line
+      @labels_per_line ||= [
+        (::TTY::Screen.cols / max_label_width) - 1,
+        max_labels_per_line
+      ].min
+    end
+  end
+end

data/lib/make_menu/text_column.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MakeMenu
+  # A column of text with a fixed with
+  class TextColumn
+    # @param [Integer] width Width of the column, in characters
+    def initialize(width)
+      @width = width
+      @rows = []
+      @row_index = 0
+    end
+
+    attr_reader :width
+
+    attr_accessor :rows, :row_index
+
+    # Add a block of text to the column. Each row will be padded to the column width
+    # @param [String] text The text to add, may be multi-line
+    def add(text)
+      self.rows += text.split("\n").map do |row|
+        row.gsub("\r", '')
+      end
+      self.row_index += text.lines.size
+    end
+
+    # Return the specified row of text
+    # @param [Integer] index The index of the row
+    # @return [String] The row at the specified index
+    def row(index)
+      (rows[index] || '').align(width: width)
+    end
+
+    # @return [Integer] The number of rows in the column
+    def height
+      row_index
+    end
+
+    # @return [Boolean] True if the column is empty
+    def empty?
+      row_index.zero?
+    end
+  end
+end

data/lib/make_menu/text_table.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'text_column'
+
+module MakeMenu
+  # This class displays the menu groups in columns across the screen.
+  # Each group is kept together in a column, and once a column has exceeded the
+  # calculated height a new column is added.
+  class TextTable
+    MAX_COLUMNS = 4
+
+    # @param [Array<MenuItemGroup>] groups
+    def initialize(groups)
+      @groups = groups
+      @columns = []
+      calculate_table_dimensions
+      build_table
+    end
+
+    # @return [String] The entire table, centered on the screen
+    def to_s
+      buffer = ''
+
+      max_height.times do |i|
+        row = ''
+        columns.each do |column|
+          row += column.row(i) unless column.empty?
+        end
+        buffer += "#{row.align(:center)}\n"
+      end
+
+      buffer
+    end
+
+    private
+
+    attr_reader :groups, :columns, :column_width, :column_height
+
+    attr_accessor :current_column
+
+    # Calculate width and minimum height of columns
+    def calculate_table_dimensions
+      @column_width = groups.map(&:width).max + 5
+      total_rows = groups.map(&:height).sum
+      column_count = (::TTY::Screen.cols / column_width).clamp(1, MAX_COLUMNS)
+      @column_height = total_rows / column_count
+    end
+
+    # Build columns from groups
+    def build_table
+      column_break
+      groups.each do |group|
+        add_text_block group.to_s
+      end
+    end
+
+    # Add a block of text to the current column. If the column is now larger than
+    # the minimum height, a new column is added
+    def add_text_block(text)
+      current_column.add(text)
+      column_break if current_column.height >= column_height
+    end
+
+    # Add a new column to the table
+    def column_break
+      self.current_column = TextColumn.new(column_width)
+      columns << current_column
+    end
+
+    # @return [Integer] Maximum column height (rows)
+    def max_height
+      columns.map(&:height).max
+    end
+  end
+end

data/lib/make_menu/version.rb

@@ -0,0 +1,3 @@
+module MakeMenu
+  VERSION = '0.0.1'
+end

data/lib/make_menu.rb

@@ -0,0 +1,32 @@
+require_relative 'make_menu/color_string'
+require_relative 'make_menu/menu'
+require_relative 'make_menu/status_panel'
+
+require 'tty-screen'
+
+module MakeMenu
+  String.include MakeMenu::ColorString
+
+  def self.run
+    # Allows CTRL+C to return to the menu instead of exiting the script
+    trap('SIGINT') { throw StandardError }
+
+    makefile = ENV.fetch('MAKEFILE', './Makefile')
+
+    if (menu_name = ENV.fetch('MENU', nil))
+      require "./#{menu_name.downcase}_menu.rb"
+      Object.const_get("#{menu_name.capitalize}Menu").new(makefile).run
+    else
+      MakeMenu::Menu.new(makefile).run
+    end
+  end
+
+  def self.status
+    if (menu_name = ENV.fetch('MENU', nil))
+      require "./#{menu_name.downcase}_status_panel.rb"
+      Object.const_get("#{menu_name.capitalize}StatusPanel").new.display
+    else
+      MakeMenu::StatusPanel.new.display
+    end
+  end
+end

data/make_menu.gemspec

@@ -0,0 +1,59 @@
+require File.expand_path('lib/make_menu/version', __dir__)
+
+Gem::Specification.new do |s|
+  s.name = "make_menu"
+  s.version = MakeMenu::VERSION
+  s.summary = "Generates an interactive menu from a Makefile"
+  s.authors = ["Barri Mason"]
+  s.email = "loki@amarantha.net"
+  s.files = Dir[
+    'lib/**/*.rb',
+    'make_menu.gemspec',
+    'Gemfile',
+    'Gemfile.lock'
+  ]
+  s.homepage =
+    "https://rubygems.org/gems/make_menu"
+  s.license = "MIT"
+  s.add_dependency 'tty-screen', '~> 0.8.2'
+  s.description = %(
+Creates a number-selection menu from a Makefile. The menu will attempt to fill the width of the terminal window.
+
+- Any targets in the Makefile with a double-hash comment will be displayed, e.g.:
+    serve: ## Start Rails server in background
+  This will display a line such as '1. Start Rails server in background' which runs the command `make serve`.
+
+- A line that starts with a triple-hash will create a new menu group, e.g.:
+    ### Docker Commands
+  This will begin a new group with the header 'Docker Commands'
+
+- The environment variable MENU can be used to specify a custom menu class, e.g.:
+    export MENU=Accounts
+  This assumes that a class `AccountsMenu` is defined in the file `accounts_menu.rb`
+
+  You can define two constants in your custom class:
+    LOGO (String) text or ASCII art to display above the menu
+    HIGHLIGHTS (Hash{String=>[Symbol,Array<Symbol>]}) Add coloring to specific words or phrases
+
+- The environment variable MAKEFILE can specify a Makefile. The default is './Makefile'.
+
+The menu will not display any targets called 'menu' or 'status'. The latter, if present, is called each
+time the menu displays.
+
+-----------------------------
+Docker Container Status Panel
+-----------------------------
+
+Displays a color-coded panel indicating whether or not a Docker container is running.
+
+You must define a custom class inheriting from `MakeMenu::StatusPanel` and indicate this using
+the environment variable MENU, e.g.:
+    export MENU=Accounts
+This assumes that a class `AccountsStatusPanel` is defined in the file `accounts_status_panel.rb`
+
+You can define a constant CONTAINERS {String=>String} in this custom class to map the displayed
+label to the container name, e.g.:
+    CONTAINERS = { 'Backend' => 'myapp-backend-1' }
+
+)
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: make_menu
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Barri Mason
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tty-screen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+description: |2+
+
+  Creates a number-selection menu from a Makefile. The menu will attempt to fill the width of the terminal window.
+
+  - Any targets in the Makefile with a double-hash comment will be displayed, e.g.:
+      serve: ## Start Rails server in background
+    This will display a line such as '1. Start Rails server in background' which runs the command `make serve`.
+
+  - A line that starts with a triple-hash will create a new menu group, e.g.:
+      ### Docker Commands
+    This will begin a new group with the header 'Docker Commands'
+
+  - The environment variable MENU can be used to specify a custom menu class, e.g.:
+      export MENU=Accounts
+    This assumes that a class `AccountsMenu` is defined in the file `accounts_menu.rb`
+
+    You can define two constants in your custom class:
+      LOGO (String) text or ASCII art to display above the menu
+      HIGHLIGHTS (Hash{String=>[Symbol,Array<Symbol>]}) Add coloring to specific words or phrases
+
+  - The environment variable MAKEFILE can specify a Makefile. The default is './Makefile'.
+
+  The menu will not display any targets called 'menu' or 'status'. The latter, if present, is called each
+  time the menu displays.
+
+  -----------------------------
+  Docker Container Status Panel
+  -----------------------------
+
+  Displays a color-coded panel indicating whether or not a Docker container is running.
+
+  You must define a custom class inheriting from `MakeMenu::StatusPanel` and indicate this using
+  the environment variable MENU, e.g.:
+      export MENU=Accounts
+  This assumes that a class `AccountsStatusPanel` is defined in the file `accounts_status_panel.rb`
+
+  You can define a constant CONTAINERS {String=>String} in this custom class to map the displayed
+  label to the container name, e.g.:
+      CONTAINERS = { 'Backend' => 'myapp-backend-1' }
+
+email: loki@amarantha.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- lib/make_menu.rb
+- lib/make_menu/color_string.rb
+- lib/make_menu/menu.rb
+- lib/make_menu/menu_item.rb
+- lib/make_menu/menu_item_group.rb
+- lib/make_menu/status_panel.rb
+- lib/make_menu/text_column.rb
+- lib/make_menu/text_table.rb
+- lib/make_menu/version.rb
+- make_menu.gemspec
+homepage: https://rubygems.org/gems/make_menu
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Generates an interactive menu from a Makefile
+test_files: []
+...