curses_menu 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c2226bebb142878eb4467c0471c3978f683746634acc51e6852f3b9298fbd3cf
+  data.tar.gz: 23f6626cf28f160149106907a307cdc49ce64741f62ffb6053e16ad276267223
+SHA512:
+  metadata.gz: 31d298f6320962b6061936eff73ba7a517f10c0ec0b8b681455ae71df372b8ef5e0ee674d598fe094c76de18531a1d4a3a07b58ae2d405a6112a03b00bfd5275
+  data.tar.gz: 6f49adde82fac8dfd6e7f513184735b3f9e9f0024857b00604b9180bd926659a1a9ddece7ef112ad671f1921d60c236204359c8d6fe361a491c9fe393a31cd4f

data/examples/actions.rb

@@ -0,0 +1,25 @@
+require 'curses_menu'
+
+nbr = 0
+CursesMenu.new 'Items can have several actions. Look at the footer!' do |menu|
+  menu.item "Current number is #{nbr} - Use a or d", actions: {
+    'd' => {
+      name: 'Increase',
+      execute: proc do
+        nbr += 1
+        :menu_refresh
+      end
+    },
+    'a' => {
+      name: 'Decrease',
+      execute: proc do
+        nbr -= 1
+        :menu_refresh
+      end
+    }
+  }
+  menu.item 'Quit' do
+    puts 'Quitting...'
+    :menu_exit
+  end
+end

data/examples/automatic_key_presses.rb

@@ -0,0 +1,49 @@
+require 'curses_menu'
+
+keys = [
+  # Select first
+  CursesMenu::KEY_ENTER,
+  # Select second
+  Curses::KEY_DOWN,
+  'a',
+  'b',
+  # Select third (sub-menu)
+  Curses::KEY_DOWN,
+  CursesMenu::KEY_ENTER,
+  # Select sub-menu first
+  CursesMenu::KEY_ENTER,
+  # Exit sub-menu
+  CursesMenu::KEY_ESCAPE,
+  # Navigate a bit
+  Curses::KEY_NPAGE,
+  Curses::KEY_HOME,
+  # Select last
+  Curses::KEY_END,
+  CursesMenu::KEY_ENTER
+]
+CursesMenu.new('Menu being used automatically', key_presses: keys) do |menu|
+  menu.item 'Simple item' do
+    puts 'Selected a simple item'
+  end
+  menu.item 'Several actions on this item', actions: {
+    'a' => {
+      name: 'Action A',
+      execute: proc { puts 'Selected action A' }
+    },
+    'b' => {
+      name: 'Action B',
+      execute: proc { puts 'Selected action B' }
+    }
+  }
+  menu.item 'Sub-menu' do
+    CursesMenu.new('Sub-menu!', key_presses: keys) do |sub_menu|
+      sub_menu.item 'Simple sub-menu item' do
+        puts 'Selected item from sub-menu'
+      end
+    end
+  end
+  menu.item 'Quit' do
+    puts 'Quitting...'
+    :menu_exit
+  end
+end

data/examples/formatting.rb

@@ -0,0 +1,130 @@
+require 'curses_menu'
+
+dynamic_row_1 = CursesMenu::CursesRow.new(
+  first_cell: { text: 'Select to' },
+  second_cell: {
+    text: 'change the',
+    color_pair: CursesMenu::COLORS_GREEN
+  },
+  third_cell: {
+    text: 'cells order',
+    color_pair: CursesMenu::COLORS_RED
+  }
+)
+dynamic_row_2 = CursesMenu::CursesRow.new(
+  first_cell: { text: 'Select to change' },
+  second_cell: {
+    text: 'the cells properties',
+    color_pair: CursesMenu::COLORS_GREEN,
+    fixed_size: 40
+  }
+)
+CursesMenu.new 'Extended formatting available too!' do |menu|
+  menu.item CursesMenu::CursesRow.new(
+    default_cell: {
+      text: 'Simple color change - GREEN!',
+      color_pair: CursesMenu::COLORS_GREEN
+    }
+  )
+  menu.item CursesMenu::CursesRow.new(
+    green_cell: {
+      text: 'Several cells ',
+      color_pair: CursesMenu::COLORS_GREEN
+    },
+    red_cell: {
+      text: 'with different ',
+      color_pair: CursesMenu::COLORS_RED
+    },
+    blue_cell: {
+      text: 'formatting',
+      color_pair: CursesMenu::COLORS_BLUE
+    }
+  )
+  menu.item CursesMenu::CursesRow.new(
+    default_cell: {
+      text: 'Use prefixes and suffixes',
+      begin_with: '[ ',
+      end_with: ' ]'
+    }
+  )
+  menu.item CursesMenu::CursesRow.new(
+    first_cell: {
+      text: 'This will have a fixed size!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!',
+      begin_with: '[ ',
+      end_with: ' ]',
+      fixed_size: 40
+    },
+    second_cell: {
+      text: 'And other cells will be aligned',
+      color_pair: CursesMenu::COLORS_GREEN
+    }
+  )
+  menu.item CursesMenu::CursesRow.new(
+    first_cell: {
+      text: 'Pretty nice',
+      fixed_size: 40
+    },
+    second_cell: {
+      text: 'for alignment',
+      color_pair: CursesMenu::COLORS_GREEN
+    }
+  )
+  menu.item CursesMenu::CursesRow.new(
+    first_cell: {
+      text: 'And you can justify',
+      justify: :right,
+      fixed_size: 40
+    },
+    second_cell: {
+      text: 'your text when size is fixed!',
+      justify: :left,
+      color_pair: CursesMenu::COLORS_GREEN
+    }
+  )
+  menu.item CursesMenu::CursesRow.new(
+    first_cell: {
+      text: 'You can even',
+      justify: :right,
+      fixed_size: 40,
+      pad: '_-'
+    },
+    second_cell: {
+      text: 'pad it!',
+      justify: :left,
+      color_pair: CursesMenu::COLORS_GREEN,
+      fixed_size: 40,
+      pad: '*'
+    }
+  )
+  menu.item CursesMenu::CursesRow.new(
+    {
+      first_cell: { text: 'Use a' },
+      second_cell: {
+        text: 'different separator',
+        color_pair: CursesMenu::COLORS_GREEN
+      },
+      third_cell: { text: 'between cells' }
+    },
+    separator: '|'
+  )
+  menu.item dynamic_row_1 do
+    dynamic_row_1.cells_order([:first_cell, :second_cell, :third_cell].sort_by { rand })
+    :menu_refresh
+  end
+  menu.item dynamic_row_2 do
+    dynamic_row_2.change_cells(
+      first_cell: {
+        color_pair: [CursesMenu::COLORS_GREEN, CursesMenu::COLORS_RED, CursesMenu::COLORS_BLUE].sample
+      },
+      second_cell: {
+        color_pair: [CursesMenu::COLORS_GREEN, CursesMenu::COLORS_RED, CursesMenu::COLORS_BLUE].sample,
+        pad: ['*', ' ', '|', '='].sample
+      }
+    )
+    :menu_refresh
+  end
+  menu.item 'Quit' do
+    puts 'Quitting...'
+    :menu_exit
+  end
+end

data/examples/hello.rb

@@ -0,0 +1,8 @@
+require 'curses_menu'
+
+CursesMenu.new 'My awesome new menu!' do |menu|
+  menu.item 'How\'s life?' do
+    puts 'Couldn\'t be easier'
+    :menu_exit
+  end
+end

data/examples/refresh.rb

@@ -0,0 +1,22 @@
+require 'curses_menu'
+
+nbr = 0
+switch = false
+CursesMenu.new 'Menu being refreshed when selecting things' do |menu|
+  menu.item "Current number is #{nbr} - Select me for +1" do
+    nbr += 1
+    :menu_refresh
+  end
+  menu.item "Current number is #{nbr} - Select me for -1" do
+    nbr -= 1
+    :menu_refresh
+  end
+  menu.item "[#{switch ? '*' : ' '}] Switch me!" do
+    switch = !switch
+    :menu_refresh
+  end
+  menu.item 'Quit' do
+    puts 'Quitting...'
+    :menu_exit
+  end
+end

data/examples/scrolling.rb

@@ -0,0 +1,9 @@
+require 'curses_menu'
+
+CursesMenu.new 'Use all arrows, Page up/down, Home and End keys!' do |menu|
+  menu.item('Quit') { :menu_exit }
+  menu.item 'That\'s a big menu item! ' * 20
+  1000.times do |idx|
+    menu.item "Menu item #{idx}"
+  end
+end

data/examples/several_items.rb

@@ -0,0 +1,18 @@
+require 'curses_menu'
+
+CursesMenu.new 'We have several items, some of them have no action' do |menu|
+  menu.item 'Nothing to do with me'
+  menu.item 'Select me - I\'m option A!' do
+    puts 'You have selected A. Press enter to continue.'
+    $stdin.gets
+  end
+  menu.item 'Or select me - Option B!' do
+    puts 'You have selected B. Press enter to continue.'
+    $stdin.gets
+  end
+  menu.item '---- Separator'
+  menu.item 'Quit' do
+    puts 'Quitting...'
+    :menu_exit
+  end
+end

data/examples/sub_menus.rb

@@ -0,0 +1,20 @@
+require 'curses_menu'
+
+CursesMenu.new 'Top menu' do |menu|
+  menu.item 'Enter menu 1' do
+    CursesMenu.new 'Sub-menu 1' do |sub_menu|
+      sub_menu.item 'We are in sub-menu 1'
+      sub_menu.item('Back') { :menu_exit }
+    end
+  end
+  menu.item 'Enter menu 2' do
+    CursesMenu.new 'Sub-menu 2' do |sub_menu|
+      sub_menu.item 'We are in sub-menu 2'
+      sub_menu.item('Back') { :menu_exit }
+    end
+  end
+  menu.item 'Quit' do
+    puts 'Quitting...'
+    :menu_exit
+  end
+end

data/lib/curses_menu.rb

@@ -0,0 +1,241 @@
+require 'curses'
+require 'curses_menu/curses_row'
+
+class CursesMenu
+
+  # Define some color pairs names.
+  # The integer value is meaningless in itself but they all have to be different.
+  COLORS_TITLE = 1
+  COLORS_LINE = 2
+  COLORS_MENU_ITEM = 3
+  COLORS_MENU_ITEM_SELECTED = 4
+  COLORS_INPUT = 5
+  COLORS_GREEN = 6
+  COLORS_RED = 7
+  COLORS_YELLOW = 8
+  COLORS_BLUE = 9
+
+  # curses keys that are not defined by Curses, but that are returned by getch
+  KEY_ENTER = 10
+  KEY_ESCAPE = 27
+
+  # Constructor.
+  # Display a list of choices, ask for user input and execute the choice made.
+  # Repeat the operation unless one of the code returns the :menu_exit symbol.
+  #
+  # Parameters::
+  # * *title* (String): Title of those choices
+  # * *key_presses* (Array<Object>): List of key presses to automatically apply [default: []]
+  #   Can be characters or ascii values, as returned by curses' getch.
+  #   The list is modified in place along with its consumption, so that it can be reused in sub-menus if needed.
+  # * *&menu_items_def* (Proc): Code to be called to get the list of choices. This code can call the following methods to design the menu:
+  #   * Parameters::
+  #     * *menu* (CursesMenu): The CursesMenu instance
+  def initialize(title, key_presses: [], &menu_items_def)
+    @current_menu_items = nil
+    @curses_initialized = false
+    current_items = gather_menu_items(&menu_items_def)
+    selected_idx = 0
+    raise "Menu #{title} has no items to select" if selected_idx.nil?
+    window = curses_menu_initialize
+    begin
+      max_displayed_items = window.maxy - 5
+      display_first_idx = 0
+      display_first_char_idx = 0
+      loop do
+        # TODO: Don't redraw fixed items for performance
+        # Display the title
+        window.setpos(0, 0)
+        print(window, '', default_color_pair: COLORS_TITLE, pad: '=')
+        print(window, "= #{title}", default_color_pair: COLORS_TITLE, pad: ' ', single_line: true)
+        print(window, '', default_color_pair: COLORS_TITLE, pad: '-')
+        # Display the menu
+        current_items[display_first_idx..display_first_idx + max_displayed_items - 1].each.with_index do |item_info, idx|
+          selected = display_first_idx + idx == selected_idx
+          print(
+            window,
+            item_info[:title],
+            from: display_first_char_idx,
+            default_color_pair: item_info.key?(:actions) ? COLORS_MENU_ITEM : COLORS_LINE,
+            force_color_pair: selected ? COLORS_MENU_ITEM_SELECTED : nil,
+            pad: selected ? ' ' : nil,
+            single_line: true
+          )
+        end
+        # Display the footer
+        window.setpos(window.maxy - 2, 0)
+        print(window, '', default_color_pair: COLORS_TITLE, pad: '=')
+        display_actions = {
+          'Arrows/Home/End' => 'Navigate',
+          'Esc' => 'Exit'
+        }
+        if current_items[selected_idx][:actions]
+          display_actions.merge!(Hash[current_items[selected_idx][:actions].map do |action_shortcut, action_info|
+            [
+              case action_shortcut
+              when KEY_ENTER
+                'Enter'
+              else
+                action_shortcut
+              end,
+              action_info[:name]
+            ]
+          end])
+        end
+        print(
+          window,
+          "= #{display_actions.sort.map { |(shortcut, name)| "#{shortcut}: #{name}" }.join(' | ')}",
+          from: display_first_char_idx,
+          default_color_pair: COLORS_TITLE,
+          pad: ' ',
+          add_nl: false,
+          single_line: true
+        )
+        window.refresh
+        user_choice = nil
+        loop do
+          user_choice = key_presses.empty? ? window.getch : key_presses.shift
+          break unless user_choice.nil?
+          sleep 0.01
+        end
+        case user_choice
+        when Curses::KEY_RIGHT
+          display_first_char_idx += 1
+        when Curses::KEY_LEFT
+          display_first_char_idx -= 1
+        when Curses::KEY_UP
+          selected_idx -= 1
+        when Curses::KEY_PPAGE
+          selected_idx -= max_displayed_items - 1
+        when Curses::KEY_DOWN
+          selected_idx += 1
+        when Curses::KEY_NPAGE
+          selected_idx += max_displayed_items - 1
+        when Curses::KEY_HOME
+          selected_idx = 0
+        when Curses::KEY_END
+          selected_idx = current_items.size - 1
+        when KEY_ESCAPE
+          break
+        else
+          # Check actions
+          if current_items[selected_idx][:actions]&.key?(user_choice)
+            curses_menu_finalize
+            result = current_items[selected_idx][:actions][user_choice][:execute].call
+            if result.is_a?(Symbol)
+              case result
+              when :menu_exit
+                break
+              when :menu_refresh
+                current_items = gather_menu_items(&menu_items_def)
+              end
+            end
+            window = curses_menu_initialize
+            window.clear
+          end
+        end
+        # Stay in bounds
+        display_first_char_idx = 0 if display_first_char_idx < 0
+        selected_idx = current_items.size - 1 if selected_idx >= current_items.size
+        selected_idx = 0 if selected_idx < 0
+        if selected_idx < display_first_idx
+          display_first_idx = selected_idx
+        elsif selected_idx >= display_first_idx + max_displayed_items
+          display_first_idx = selected_idx - max_displayed_items + 1
+        end
+      end
+    ensure
+      curses_menu_finalize
+    end
+  end
+
+  # Register a new menu item.
+  # This method is meant to be called from a choose_from call.
+  #
+  # Parameters::
+  # * *title* (String or CursesRow): Text to be displayed for this item
+  # * *actions* (Hash<Object, Hash<Symbol,Object> >): Associated actions to this item, per shortcut [default: {}]
+  #   * *name* (String): Name of this action (displayed at the bottom of the menu)
+  #   * *execute* (Proc): Code called when this action is selected
+  # * *&action* (Proc): Code called if the item is selected (action for the enter key) [optional].
+  #   * Result::
+  #     * Symbol or Object: If the code returns a symbol, the menu will behave in a specific way:
+  #       * *menu_exit*: the menu selection exits.
+  #       * *menu_refresh*: The menu will compute again its items.
+  def item(title, actions: {}, &action)
+    menu_item_def = { title: title }
+    all_actions = action.nil? ? actions : actions.merge(KEY_ENTER => { name: 'Select', execute: action })
+    menu_item_def[:actions] = all_actions unless all_actions.empty?
+    @current_menu_items << menu_item_def
+  end
+
+  private
+
+  # Display a given curses string information.
+  #
+  # Parameters::
+  # * *window* (Window): The curses window in which we display.
+  # * *string* (String or CursesRow): The curses row, or as a single String.
+  # * See CursesRow#print_on for all the other parameters description
+  def print(window, string, from: 0, to: nil, default_color_pair: COLORS_LINE, force_color_pair: nil, pad: nil, add_nl: true, single_line: false)
+    string = CursesRow.new(default: { text: string }) if string.is_a?(String)
+    string.print_on(
+      window,
+      from: from,
+      to: to,
+      default_color_pair: default_color_pair,
+      force_color_pair: force_color_pair,
+      pad: pad,
+      add_nl: add_nl,
+      single_line: single_line
+    )
+  end
+
+  # Initialize and get the curses menu window
+  #
+  # Result::
+  # * Window: The curses menu window
+  def curses_menu_initialize
+    Curses.init_screen
+    # Use non-blocking key read, otherwise using Popen3 later blocks
+    Curses.timeout = 0
+    Curses.start_color
+    Curses.init_pair(COLORS_TITLE, Curses::COLOR_BLACK, Curses::COLOR_CYAN)
+    Curses.init_pair(COLORS_LINE, Curses::COLOR_WHITE, Curses::COLOR_BLACK)
+    Curses.init_pair(COLORS_MENU_ITEM, Curses::COLOR_WHITE, Curses::COLOR_BLACK)
+    Curses.init_pair(COLORS_MENU_ITEM_SELECTED, Curses::COLOR_BLACK, Curses::COLOR_WHITE)
+    Curses.init_pair(COLORS_INPUT, Curses::COLOR_WHITE, Curses::COLOR_BLUE)
+    Curses.init_pair(COLORS_GREEN, Curses::COLOR_GREEN, Curses::COLOR_BLACK)
+    Curses.init_pair(COLORS_RED, Curses::COLOR_RED, Curses::COLOR_BLACK)
+    Curses.init_pair(COLORS_YELLOW, Curses::COLOR_YELLOW, Curses::COLOR_BLACK)
+    Curses.init_pair(COLORS_BLUE, Curses::COLOR_BLUE, Curses::COLOR_BLACK)
+    window = Curses.stdscr
+    window.keypad = true
+    @curses_initialized = true
+    window
+  end
+
+  # Finalize the curses menu window
+  def curses_menu_finalize
+    Curses.close_screen if @curses_initialized
+    @curses_initialized = false
+  end
+
+  # Get menu items.
+  #
+  # Parameters::
+  # * Proc: Code defining the menu items
+  #   * *menu* (CursesMenu): The menu for which we gather items.
+  # Result::
+  # * Array< Hash<Symbol,Object> >: List of items to be displayed
+  #   * *title* (String): Item title to display
+  #   * *actions* (Hash<Object, Hash<Symbol,Object> >): Associated actions to this item, per shortcut [optional]
+  #     * *name* (String): Name of this action (displayed at the bottom of the menu)
+  #     * *execute* (Proc): Code called when this action is selected
+  def gather_menu_items
+    @current_menu_items = []
+    yield self
+    @current_menu_items
+  end
+
+end

data/lib/curses_menu/curses_row.rb

@@ -0,0 +1,150 @@
+class CursesMenu
+
+  # Definition of a row that stores for each cell the string and color information to be displayed
+  class CursesRow
+
+    # Constructor
+    #
+    # Parameters::
+    # * *cells* (Hash< Symbol, Hash<Symbol,Object> >): For each cell id (ordered), the cell info:
+    #   * *text* (String): Text associated to this cell
+    #   * *color_pair* (Integer): Associated color pair [optional]
+    #   * *begin_with* (String): String to prepend to the text [default: '']
+    #   * *end_with* (String): String to append to the text [default: '']
+    #   * *fixed_size* (Integer): Number of characters this cell will take, or nil if no limit. [default: nil]
+    #   * *justify* (Symbol): Text justification (only used when fixed_size is not nil). Values can be: [default: :left]
+    #     * *left*: Left justified
+    #     * *right*: Right justified
+    #   * *pad* (String): Text to be used to pad the cell content (only used when fixed_size is not nil) [default: ' ']
+    # * *separator* (String): Separator used between cells [default: ' ']
+    def initialize(cells, separator: ' ')
+      @cells = cells
+      @separator = separator
+    end
+
+    # Change the cells order
+    #
+    # Parameters::
+    # * *cells* (Array<Symbol>): The ordered list of cells to filter
+    # * *unknown_cells* (String or Hash<Symbol,Object>): Content to put in unknown cells (as a String or properties like in #initialize), or nil to not add them. [default: nil]
+    def cells_order(cells, unknown_cells: nil)
+      new_cells = {}
+      cells.each do |cell_id|
+        if @cells.key?(cell_id)
+          new_cells[cell_id] = @cells[cell_id]
+        elsif !unknown_cells.nil?
+          new_cells[cell_id] = unknown_cells.is_a?(String) ? { text: unknown_cells } : unknown_cells
+        end
+      end
+      @cells = new_cells
+    end
+
+    # Change properties of a set of cells
+    #
+    # Parameters::
+    # * *cells* (Hash<Symbol, Hash<Symbol,Object> >): The cells properties to change, per cell id. Possible properties are the ones given in the #initialize method.
+    def change_cells(cells)
+      cells.each do |cell_id, cell_info|
+        raise "Unknown cell #{cell_id}" unless @cells.key?(cell_id)
+        @cells[cell_id].merge!(cell_info)
+        @cells[cell_id].delete(:cache_rendered_text)
+      end
+    end
+
+    # Get the size of the total string of such row.
+    #
+    # Parameters::
+    # * *cells* (Array<Symbol>): The list of cells to consider for the size [default: @cells.keys]
+    # Result::
+    # * Integer: Row size
+    def size(cells: @cells.keys)
+      result = @separator.size * (cells.size - 1)
+      cells.each do |cell_id|
+        result += cell_text(cell_id).size
+      end
+      result
+    end
+
+    # Print this row into a window
+    #
+    # Parameters::
+    # * *window* (Window): Curses window to print on
+    # * *from* (Integer): From index to be displayed [default: 0]
+    # * *to* (Integer): To index to be displayed [default: total size]
+    # * *default_color_pair* (Integer): Default color pair to use if no color information is provided [default: COLORS_LINE]
+    # * *force_color_pair* (Integer): Force color pair to use, or nil to not force [default: nil]
+    # * *pad* (String or nil): Pad the line to the row extent with the given string, or nil for no padding. [default: nil]
+    # * *add_nl* (Boolean): If true, then add a new line at the end [default: true]
+    # * *single_line* (Boolean): If true, then make sure the print does not exceed the line [default: false]
+    def print_on(window, from: 0, to: nil, default_color_pair: COLORS_LINE, force_color_pair: nil, pad: nil, add_nl: true, single_line: false)
+      text_size = size
+      from = text_size if from > text_size
+      to = text_size - 1 if to.nil?
+      to = window.maxx - window.curx + from - 2 if single_line && window.curx + to - from >= window.maxx - 1
+      current_idx = 0
+      @cells.each.with_index do |(cell_id, cell_info), cell_idx|
+        text = cell_text(cell_id)
+        full_substring_size = text.size + @separator.size
+        if from < current_idx + full_substring_size
+          # We have something to display from this substring
+          window.color_set(
+            if force_color_pair.nil?
+              cell_info[:color_pair] ? cell_info[:color_pair] : default_color_pair
+            else
+              force_color_pair
+            end
+          )
+          window << "#{text}#{cell_idx == @cells.size - 1 ? '' : @separator}"[(from < current_idx ? 0 : from - current_idx)..to - current_idx]
+        end
+        current_idx += full_substring_size
+        break if current_idx > to
+      end
+      window.color_set(force_color_pair.nil? ? default_color_pair : force_color_pair)
+      if pad && window.curx < window.maxx
+        nbr_chars = window.maxx - window.curx - 1
+        window << (pad * nbr_chars)[0..nbr_chars - 1]
+      end
+      window << "\n" if add_nl
+    end
+
+    private
+
+    # Get a cell's text.
+    # Cache it to not compute it several times.
+    #
+    # Parameters::
+    # * *cell_id* (Symbol): Cell id to get text for
+    # Result::
+    # * String: The cell's text
+    def cell_text(cell_id, cell_decorator: nil)
+      unless @cells[cell_id].key?(:cache_rendered_text)
+        begin_str = "#{@cells[cell_id][:begin_with] || ''}#{@cells[cell_id][:text]}"
+        end_str = @cells[cell_id][:end_with] || ''
+        @cells[cell_id][:cache_rendered_text] =
+          if @cells[cell_id][:fixed_size]
+            text = "#{begin_str[0..@cells[cell_id][:fixed_size] - end_str.size - 1]}#{end_str}"
+            remaining_size = @cells[cell_id][:fixed_size] - text.size
+            if remaining_size > 0
+              padding = ((@cells[cell_id][:pad] || ' ') * remaining_size)[0..remaining_size - 1]
+              justify = @cells[cell_id][:justify] || :left
+              case justify
+              when :left
+                "#{text}#{padding}"
+              when :right
+                "#{padding}#{text}"
+              else
+                raise "Unknown justify decorator: #{justify}"
+              end
+            else
+              text[0..@cells[cell_id][:fixed_size] - 1]
+            end
+          else
+            "#{begin_str}#{end_str}"
+          end
+      end
+      @cells[cell_id][:cache_rendered_text]
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: curses_menu
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Muriel Salvan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: 
+email:
+- muriel@x-aeon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- examples/actions.rb
+- examples/automatic_key_presses.rb
+- examples/formatting.rb
+- examples/hello.rb
+- examples/refresh.rb
+- examples/scrolling.rb
+- examples/several_items.rb
+- examples/sub_menus.rb
+- lib/curses_menu.rb
+- lib/curses_menu/curses_row.rb
+homepage: http://x-aeon.com
+licenses:
+- BSD-3-Clause
+metadata:
+  homepage_uri: http://x-aeon.com
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Simple menu offering choices with navigation keys using curses
+test_files: []