terminal-notes 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3a0256e2d1947621a55db84286b5a621e6acc0711a0861b41ca95b04622871c6
+  data.tar.gz: b9af1e67c2f847cb0b2c56e889ae4e31cf5a63ccd1185972d045d017f0cf070c
+SHA512:
+  metadata.gz: 98dda1f386c2e92b67d9cf81fb5132c0a2388ab4fbd802482000578f050836ab06a816d14ee0a3f461bf6c79a1c5a5829b372e36c7ad9c79a34b7440caafa0a8
+  data.tar.gz: aa8dfc344c7618dd2190398b2d253946e4d5fa4386d7244dfd29d16e148baf3b6e9deab51cf3624d309f4d1d7134c747d9f855eca9b86a1ece2c56be02a427a7

data/README.md

@@ -0,0 +1,69 @@
+# Note Transpose
+[![Gem Version](https://badge.fury.io/rb/terminal-notes.svg)](https://badge.fury.io/rb/terminal-notes)
+[![Build Status](https://travis-ci.org/vyder/terminal-notes.svg?branch=master)](https://travis-ci.org/vyder/terminal-notes)
+[![Inline docs](http://inch-ci.org/github/vyder/terminal-notes.svg?branch=master)](http://inch-ci.org/github/vyder/terminal-notes)
+
+Searchable notes in your terminal! What's not to like?
+
+## Table of Contents
+
+- [Install](#install)
+- [Usage](#usage)
+- [Documentation](#documentation)
+- [Roadmap](#roadmap)
+- [Support](#support)
+- [Contributing](#contributing)
+
+## Install
+
+    ❯ gem install terminal-notes
+
+On first run, you will be asked to confirm the destination of your install. It defaults to `~/.notesrc/`.
+
+The main configuration file is located at `~/.notesrc/config`. It's a YAML file.
+
+All your notes are saved in `~/.notesrc/db` as text files.
+
+Additionally, I like to symlink the binary to my `~/bin` folder for ease of access. You can do that with:
+
+    ❯ ln -sn $(which terminal-notes) ~/bin/notes
+
+Make sure you have your `~/bin` in your `PATH` for this to work.
+
+## Usage
+
+    ❯ terminal-notes
+
+TODO: Write this section
+
+## Documentation
+
+You can find the documentation [here](https://vyder.github.io/terminal-notes/)
+
+## Roadmap
+
+Here is my planned roadmap:
+
+(Last updated Aug 26th, 2020)
+
+- [ ] Draw a shortcuts info bar like `nano` has
+- [ ] Draw a title bar at the top
+- [ ] Implement `.notesrc` and database
+- [ ] Create an install flow (as described in the README)
+- [ ] Implement responsive layout
+- [ ] Implement a better file matcher
+- [ ] Create a non fancy mode which works better in smaller terminal screens
+- [ ] Update status line to display:
+    - Matcher
+- [ ] Abstract out UI work to Layout module that is stateful and tracks x,y widget positions
+
+Future:
+- Implement file previews with `tty-markdown` when in full screen mode
+
+## Support
+
+Please [open an issue](https://github.com/vyder/terminal-notes/issues/new) for support.
+
+## Contributing
+
+Please contribute using [Github Flow](https://guides.github.com/introduction/flow/). Create a branch, add commits, and [open a pull request](https://github.com/vyder/terminal-notes/compare/).

data/bin/terminal-notes

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'terminal-notes'
+
+unless ARGV.size == 1
+  puts "usage: #{$0} folder"
+  exit
+end
+
+# TODO: Parse a ~/.notesrc
+config = {
+    directory: ARGV[0]
+}
+
+app = TerminalNotes::App.new
+app.start(config)

data/lib/terminal-notes.rb

@@ -0,0 +1,175 @@
+require_relative 'terminal-notes/rurses'
+
+require_relative 'terminal-notes/cursor'
+require_relative 'terminal-notes/widget'
+require_relative 'terminal-notes/text_field'
+require_relative 'terminal-notes/search_field'
+require_relative 'terminal-notes/file_list'
+require_relative 'terminal-notes/info_bar'
+
+module TerminalNotes
+    class App
+        @has_initialized = false
+
+        def start(config)
+            directory = config[:directory]
+
+            Rurses.program(modes: %i[c_break no_echo keypad]) do |screen|
+                @screen = screen
+
+                @widgets = []
+
+                @search_field = SearchField.new(parent: @screen)
+                @widgets << @search_field
+
+                @info_bar = InfoBar.new(parent: @screen) { get_context }
+                @widgets << @info_bar
+
+                padding = 2
+
+                # file_list_height = screen.size[:lines]
+                #                     - @search_field.height
+                #                     - @info_bar.height
+                #                     - padding
+                file_list_height = 40
+                @file_list = FileList.new(parent: @screen,
+                                          height: file_list_height,
+                                          y: @search_field.height + padding,
+                                          directory: directory)
+                @widgets << @file_list
+
+                # Register the text_field filter as a delegate
+                # of the search field
+                @search_field.on_text_changed do |pattern|
+                    @file_list.filter(pattern)
+                end
+
+                # Register file open handler
+                @file_list.on_file_opened do |file|
+                    open_file(file)
+                end
+
+                # A PanelStack handles how windows are drawn
+                # over each other - i.e. overlapping
+                #
+                # I'm not really using this ability, however, in
+                # Rurses, the PanelStack seems to be the only way
+                # to delete/deallocate a window completely
+                #
+                @panels = Rurses::PanelStack.new
+                @widgets.each { |widget| @panels.add(widget.window) }
+                @panels.refresh_in_memory
+
+                # Events
+                # watch_for_resize
+
+                # Set initial state
+                set_context :search
+
+                # Actually draw the screen
+                # @panels.refresh_in_memory
+                Rurses.update_screen
+
+                @has_initialized = true
+
+                loop do
+                    key = Rurses.get_key
+
+                    if @context == :browse
+                        case key
+                        when "q", :CTRL_X
+                            break # quit
+                        when "m"
+                            @file_list.toggle_matcher
+                            @file_list.filter(@search_field.text)
+
+                        when "\t", "/"
+                            set_context :search
+                        else
+                            @file_list.on_key(key)
+                        end
+                    else
+                        case key
+                        when :CTRL_X
+                            break # quit
+                        when "\t", :ENTER
+                            set_context :browse
+                        else
+                            @search_field.on_key(key)
+                        end
+                    end
+
+                    # When all the downstream widgets are done updating
+                    # in-memory, actually redraw the screen
+                    # @panels.refresh_in_memory
+                    Rurses.update_screen
+                end
+
+                @screen.move_cursor(x: 0, y: 0)
+            end
+        end
+
+        def set_context context
+            @context = context
+
+            if @context == :browse
+                Rurses.curses.curs_set(0)
+                @search_field.unfocus
+                @file_list.focus
+
+            elsif @context == :search
+                Rurses.curses.curs_set(1)
+                @file_list.unfocus
+                @search_field.focus
+
+            end
+
+            @info_bar.draw
+        end
+
+        def get_context
+            { mode: @context }
+        end
+
+        def open_file(file)
+            system(editor, file)
+            redraw
+
+            # Hack to redraw focus correctly
+            # TODO: Figure out why this works
+            set_context :search
+            set_context :browse
+        end
+
+        def editor
+            ENV['EDITOR'] || DEFAULT_EDITOR
+        end
+
+        # This method can be invoked independent of the wait for
+        # keyboard input loop, so explicitly call for a screen
+        # update after widgets have been drawn
+        def redraw(resize: false)
+            return unless @has_initialized
+
+            @widgets.each(&:redraw)
+            # @widgets.each do |widget|
+                # widget.window.clear
+                # @panels.remove(widget.window)
+                # widget.draw(resize: resize)
+                # @panels.add(widget.window)
+            # end
+
+            set_context @context
+
+            @panels.refresh_in_memory
+            Rurses.update_screen
+        end
+
+        def watch_for_resize
+            # SIGWINCH
+            #   The SIGWINCH signal is sent to a process when its
+            #   controlling terminal changes its size (a window change).
+            Signal.trap(:SIGWINCH) { redraw(resize: true) }
+        end
+    end
+end

data/lib/terminal-notes/cursor.rb

@@ -0,0 +1,26 @@
+module TerminalNotes
+    class Cursor
+        attr_reader :x, :y
+
+        def initialize(x: 0, y: 0)
+            @x = x.to_i
+            @y = y.to_i
+        end
+
+        def moveBy(deltaX = 0, deltaY = 0)
+            @x += deltaX
+            @y += deltaY
+            self
+        end
+
+        def moveTo(x: nil, y: nil)
+            @x = x unless x.nil?
+            @y = y unless y.nil?
+            self
+        end
+
+        def to_hash
+            { x: @x, y: @y }
+        end
+    end
+end

data/lib/terminal-notes/file_list.rb

@@ -0,0 +1,217 @@
+require 'fuzzy_match'
+
+module TerminalNotes
+    class FileList < Widget
+        WIDTH  = 1
+
+        EXTENSIONS     = ['.md', '.txt']
+        DEFAULT_EDITOR = "nano"
+
+        CONTENT_PADDING = 2
+        FILE_INDICATOR  = "❯ "
+        INTER_COL_GAP   = "  "
+
+        MATCHERS = [:regex, :fuzzy]
+
+        def initialize(parent:, height:, y:, directory:,
+                       extensions: EXTENSIONS)
+            super(parent: parent, title: "Files",
+                  width: WIDTH, height: height, y: y)
+
+            @content_start = Cursor.new(x: 0, y: CONTENT_PADDING)
+
+            # Find all the files that match specified extensions
+            @all_files = Dir.glob("#{directory}/*")
+            @all_files = @all_files.find_all do |f|
+                f.match /(#{EXTENSIONS.join("|")})$/
+            end
+            @all_files = @all_files.map do |f|
+                {
+                    name: f.gsub("#{directory}/", ''),
+                    path: f,
+                    date: "Jun 24, 2012",
+                    time: "05:32pm"
+                }
+            end
+            @filtered_files = @all_files
+
+            @fuzzy_matcher = FuzzyMatch.new(@all_files, read: :name)
+            @curr_matcher  = 0
+
+            @current_line = 0
+            @has_focus    = false
+
+            @on_file_opened_delegates = []
+
+            draw
+        end
+
+        # TODO
+        def focus
+            @has_focus = true
+            draw
+        end
+
+        def unfocus
+            @has_focus = false
+            draw
+        end
+
+        def draw
+            super do
+                # Calculate where to start drawing the table
+                #
+                table_width = 0
+
+                # Calculate NAME col width
+                longest_file = @all_files.max { |a, b| a[:name].size <=> b[:name].size }
+                if longest_file.nil?
+                    name_col_width = 10
+                else
+                    name_col_width = 2 + longest_file[:name].size
+                end
+
+                # Calculate DATE col width, e.g. Jun 24, 2012
+                date_col_width = 12
+
+                # Calculate TIME col width, e.g. 05:24pm
+                time_col_width = 7
+
+                table_width += name_col_width + INTER_COL_GAP.size
+                table_width += date_col_width + INTER_COL_GAP.size
+                table_width += time_col_width
+
+                # Move cursor to center the table
+                cursor = @content_start.dup
+                cursor.moveTo(x: (@parent.size[:columns] - table_width) / 2)
+                @window.move_cursor(cursor)
+
+                # Start actually drawing
+                #
+
+                # Draw header
+                line  = "NAME".ljust(name_col_width) + INTER_COL_GAP
+                line += "DATE".ljust(date_col_width) + INTER_COL_GAP
+                line += "TIME".ljust(time_col_width)
+                @window.draw_string(line)
+
+                # Move cursor back to accomodate the file indicator
+                cursor.moveBy(-FILE_INDICATOR.size, 1)
+                @window.move_cursor(cursor)
+
+                no_indicator = " " * FILE_INDICATOR.size
+
+                index = 0
+                @filtered_files.each do |file|
+                    line  = no_indicator
+                    line += file[:name].ljust(name_col_width) + INTER_COL_GAP
+                    line += file[:date].rjust(date_col_width) + INTER_COL_GAP
+                    line += file[:time].rjust(time_col_width)
+
+                    @window.draw_string(line)
+
+                    # Draw the arrow
+                    if @has_focus && index == @current_line
+                        @window.move_cursor(cursor)
+                        @window.draw_string(FILE_INDICATOR)
+                    end
+
+                    cursor.moveBy(0, 1)
+                    @window.move_cursor(cursor)
+
+                    index += 1
+                end
+
+                clear_line = no_indicator + " " * table_width
+                while index < @all_files.size
+                    @window.draw_string(clear_line)
+                    cursor.moveBy(0, 1)
+                    @window.move_cursor(cursor)
+
+                    index += 1
+                end
+
+            end
+        end
+
+        def on_key key
+            return unless @has_focus
+
+            case key
+            when "j"
+                scroll_down
+            when "k"
+                scroll_up
+            when :ENTER
+                open_current
+            else
+            end
+
+            draw
+        end
+
+        def filter pattern
+            old_file_list = @filtered_files
+
+            if pattern.empty?
+                @filtered_files = @all_files
+            else
+                matcher_type = MATCHERS[@curr_matcher]
+                case matcher_type
+                when :regex
+                    @filtered_files = @all_files.find_all do |f|
+                        f[:name].match /#{pattern}/
+                    end
+                when :fuzzy
+                    @filtered_files = @fuzzy_matcher.find_all(pattern)
+                else
+                    raise "Unknown Matcher! '#{matcher_type}'"
+                end
+            end
+
+            # If the file list has changed, reset current line marker
+            @current_line = 0 unless old_file_list == @filtered_files
+
+            draw
+        end
+
+        def toggle_matcher
+            @curr_matcher += 1
+            @curr_matcher  = 0 if @curr_matcher >= MATCHERS.size
+        end
+
+        def on_file_opened &block
+            @on_file_opened_delegates << block
+        end
+
+        def notify_file_opened(file)
+            @on_file_opened_delegates.each do |delegate|
+                delegate.call(file)
+            end
+        end
+
+        private
+
+        def open_current
+            file = @filtered_files[@current_line]
+            notify_file_opened(file[:path])
+        end
+
+        def editor
+            # %x(echo $EDITOR).chomp || DEFAULT_EDITOR
+            ENV['EDITOR'] || DEFAULT_EDITOR
+        end
+
+        def scroll_down
+            if @current_line < (@filtered_files.size - 1)
+                @current_line += 1
+            end
+        end
+
+        def scroll_up
+            if @current_line > 0
+                @current_line -= 1
+            end
+        end
+    end
+end

data/lib/terminal-notes/info_bar.rb

@@ -0,0 +1,25 @@
+module TerminalNotes
+    class InfoBar < Widget
+        HEIGHT = 3
+
+        def initialize(config: {}, parent:, &block)
+            super(parent: parent, title: "", height: HEIGHT,
+                  y: (parent.size[:lines] - HEIGHT), border: false)
+
+            @get_context = block
+            draw
+        end
+
+        def draw
+            super do
+                context = @get_context.call
+                title = "Mode: #{context[:mode].to_s.capitalize}"
+
+                cursor = Cursor.new(x: (@parent.size[:columns] - title.size) / 2,
+                                    y: 0)
+                @window.move_cursor(cursor)
+                @window.draw_string(title)
+            end
+        end
+    end
+end

data/lib/terminal-notes/rurses.rb

@@ -0,0 +1,66 @@
+require "ffi-ncurses"
+
+require_relative "rurses/version"
+require_relative "rurses/panel_stack"
+require_relative "rurses/window"
+
+module Rurses
+  SPECIAL_KEYS = Hash[
+    FFI::NCurses::KeyDefs
+      .constants
+      .select { |name| name.to_s.start_with?("KEY_") }
+      .map    { |name|
+        [ FFI::NCurses::KeyDefs.const_get(name),
+          name.to_s.sub(/\AKEY_/, "").to_sym ]
+      }
+  ]
+
+  module_function
+
+  def curses
+    FFI::NCurses
+  end
+
+  def program(modes: [ ])
+    @stdscr = Window.new(curses_ref: curses.initscr, standard_screen: true)
+    @stdscr.change_modes(modes)
+    yield(@stdscr)
+  ensure
+    curses.endwin
+  end
+
+  def stdscr
+    @stdscr
+  end
+
+  def get_key
+    case (char = curses.getch)
+    when curses::KeyDefs::KEY_CODE_YES..curses::KeyDefs::KEY_MAX
+      SPECIAL_KEYS[char]
+    when curses::ERR
+      nil
+    when 1
+      :CTRL_A
+    when 5
+      :CTRL_E
+    when 10
+      :ENTER
+    when 11
+      :CTRL_K
+    when 14
+      :CTRL_N
+    when 23
+      :CTRL_W
+    when 24
+      :CTRL_X
+    when 127
+      :BACKSPACE
+    else
+      char.chr
+    end
+  end
+
+  def update_screen
+    curses.doupdate
+  end
+end

data/lib/terminal-notes/rurses/panel_stack.rb

@@ -0,0 +1,35 @@
+module Rurses
+  class PanelStack
+    def initialize
+      @window_to_panel_map = { }
+    end
+
+    attr_reader :window_to_panel_map
+    private     :window_to_panel_map
+
+    def add(window, add_subwindows: true)
+      window_to_panel_map[window] = Rurses.curses.new_panel(window.curses_ref)
+      if add_subwindows
+        window.subwindows.each_value do |subwindow|
+          add(subwindow, add_subwindows: add_subwindows)
+        end
+      end
+    end
+    alias_method :<<, :add
+
+    def remove(window, remove_subwindows: true)
+      if remove_subwindows
+        window.subwindows.each_value do |subwindow|
+          remove(subwindow, remove_subwindows: remove_subwindows)
+        end
+      end
+      window.clear
+      Rurses.curses.del_panel(window_to_panel_map[window])
+      Rurses.curses.delwin(window.curses_ref)
+    end
+
+    def refresh_in_memory
+      Rurses.curses.update_panels
+    end
+  end
+end

data/lib/terminal-notes/rurses/version.rb

@@ -0,0 +1,3 @@
+module Rurses
+  VERSION = "0.1.0"
+end

data/lib/terminal-notes/rurses/window.rb

@@ -0,0 +1,148 @@
+module Rurses
+  class Window
+    MODE_NAMES = {
+      c_break:      :cbreak,
+      no_echo:      :noecho,
+      keypad:       [:keypad, :window, true],
+      hide_cursor:  [:curs_set, 0],
+      non_blocking: [:timeout, 0]
+    }
+    ATTRIBUTES = Hash.new { |all, name|
+      all[name] = Rurses.curses.const_get("A_#{name.upcase}")
+    }
+
+    def initialize(**details)
+      @curses_ref      = details.fetch(:curses_ref) {
+        Rurses.curses.newwin(
+          details.fetch(:lines),
+          details.fetch(:columns),
+          details.fetch(:y),
+          details.fetch(:x)
+        )
+      }
+      @standard_screen = details.fetch(:standard_screen) { false }
+      @subwindows      = { }
+    end
+
+    attr_reader :curses_ref, :subwindows
+
+    def standard_screen?
+      @standard_screen
+    end
+
+    def cursor_x
+      Rurses.curses.getcurx(curses_ref)
+    end
+
+    def cursor_y
+      Rurses.curses.getcury(curses_ref)
+    end
+
+    def cursor_xy
+      y, x = Rurses.curses.getyx(curses_ref)
+      {x: x, y: y}
+    end
+
+    def columns
+      Rurses.curses.getmaxx(curses_ref)
+    end
+
+    def lines
+      Rurses.curses.getmaxy(curses_ref)
+    end
+
+    def size
+      {columns: columns, lines: lines}
+    end
+
+    def resize(lines: , columns: )
+      Rurses.curses.resizeterm(lines, columns) if standard_screen?
+      Rurses.curses.wresize(curses_ref, lines, columns)
+    end
+
+    def change_modes(modes)
+      modes.each do |name|
+        mode = Array(MODE_NAMES[name] || name)
+        Rurses.curses.send(*mode.map { |arg| arg == :window ? curses_ref : arg })
+      end
+    end
+
+    def draw_border( left:     0, right:     0, top:         0, bottom:       0,
+                     top_left: 0, top_right: 0, bottom_left: 0, bottom_right: 0 )
+      args = [
+        left,     right,     top,         bottom,
+        top_left, top_right, bottom_left, bottom_right
+      ].map { |c| c.is_a?(String) ? c.encode("UTF-8").codepoints.first : c }
+      if args.any? { |c| c >= 128 }
+        Rurses.curses.wborder_set(
+          curses_ref,
+          *args.map { |c|
+            char            = Rurses.curses::WinStruct::CCharT.new
+            char[:chars][0] = c
+          }
+        )
+      else
+        Rurses.curses.wborder(curses_ref, *args)
+      end
+    end
+
+    def move_cursor(x: , y: )
+      Rurses.curses.wmove(curses_ref, y, x)
+    end
+
+    def draw_string(content)
+      Rurses.curses.waddstr(curses_ref, content)
+    end
+
+    def draw_string_on_a_line(content)
+      old_y = cursor_y
+      draw_string(content)
+      new_y = cursor_y
+      move_cursor(x: 0, y: new_y + 1) if new_y == old_y
+    end
+
+    def skip_line
+      move_cursor(x: 0, y: cursor_y + 1)
+    end
+
+    def style(*attributes)
+      attributes.each do |attribute|
+        Rurses.curses.wattron(curses_ref, ATTRIBUTES[attribute])
+      end
+      yield
+    ensure
+      attributes.each do |attribute|
+        Rurses.curses.wattroff(curses_ref, ATTRIBUTES[attribute])
+      end
+    end
+
+    def clear(reset_cursor: true)
+      Rurses.curses.wclear(curses_ref)
+      move_cursor(x: 0, y: 0) if reset_cursor
+    end
+
+    def refresh_in_memory
+      Rurses.curses.wnoutrefresh(curses_ref)
+    end
+
+    def create_subwindow( name: , top_padding:   0, left_padding:   0,
+                                  right_padding: 0, bottom_padding: 0 )
+      s                = size
+      xy               = cursor_xy
+      subwindows[name] =
+        self.class.new(
+          curses_ref: Rurses.curses.derwin(
+            curses_ref,
+            s[:lines]   - (top_padding  + bottom_padding),
+            s[:columns] - (left_padding + right_padding),
+            xy[:y]      + top_padding,
+            xy[:x]      + left_padding
+          )
+        )
+    end
+
+    def subwindow(name)
+      subwindows[name]
+    end
+  end
+end

data/lib/terminal-notes/search_field.rb

@@ -0,0 +1,46 @@
+module TerminalNotes
+    class SearchField < Widget
+        WIDTH  = 0.5
+        HEIGHT = 5
+        POS_X = 0
+        POS_Y = 1
+        ALIGN = :center
+
+        def initialize(parent:)
+            super(parent: parent, title: "Search",
+                  width: WIDTH, height: HEIGHT,
+                  x: POS_X, y: POS_Y,
+                  align: ALIGN)
+
+            @text_field = TextField.new(@parent,
+                position: @position.dup.moveBy(2, 2),
+                width:    @width - 4)
+
+            @has_focus = false
+
+            draw
+        end
+
+        def text
+            @text_field.text
+        end
+
+        def focus
+            @has_focus = true
+            @text_field.draw
+        end
+
+        def unfocus
+            @has_focus = false
+        end
+
+        def on_text_changed &delegate
+            @text_field.on_text_changed { |p| delegate.call(p) }
+        end
+
+        def on_key key
+            return unless @has_focus
+            @text_field.on_key(key)
+        end
+    end
+end

data/lib/terminal-notes/text_field.rb

@@ -0,0 +1,89 @@
+module TerminalNotes
+    class TextField
+        attr_reader :text
+
+        DEFAULT_WIDTH = 10
+        BREAK_CHARS   = " -_+=".split('')
+
+        def initialize(screen, position: Cursor.new, width: DEFAULT_WIDTH)
+            @screen = screen
+            @start  = position.dup
+            @end    = @start.dup.moveBy(width, 0)
+            @width  = width
+            @cursor = @start.dup
+
+            @clear_text = " " * @width
+            @text = ""
+
+            @on_text_changed_delegates = []
+        end
+
+        def on_text_changed &block
+            @on_text_changed_delegates << block
+        end
+
+        def notify_text_changed
+            @on_text_changed_delegates.each do |delegate|
+                delegate.call(@text)
+            end
+        end
+
+        def on_key(key)
+            old_text = @text
+            case key
+            when :BACKSPACE
+                @text = @text[0...-1]
+                @cursor.moveBy(-1) unless @text.size == (@width - 1)
+
+            when :UP, :DOWN
+            when :LEFT
+                @cursor.moveBy(-1)
+
+            when :RIGHT
+                @cursor.moveBy(1)
+
+            when :CTRL_K
+                @text = ""
+
+            when :CTRL_W
+                last = @text.size - 2
+                while last >= 0
+                    break if BREAK_CHARS.include? @text[last]
+                    last -= 1
+                end
+                @text = @text[0...(last+1)]
+
+            when :CTRL_E
+                @cursor.moveTo(x: @end.x)
+
+            when :CTRL_A
+                @cursor.moveTo(x: @start.x)
+
+            else
+                if !key.nil? && !key.is_a?(Symbol) && @text.size < @width
+                    @text += key
+                    @cursor.moveBy(1)
+                end
+            end
+
+            # Make sure we don't move cursor too far left
+            @cursor.moveTo(x: @start.x) if @cursor.x < @start.x
+
+            # Make sure we don't move cursor too far right
+            max_x = @start.x + @text.size
+            max_x -= 1 if @text.size == @width
+            @cursor.moveTo(x: max_x) if @cursor.x > max_x
+
+            draw
+
+            notify_text_changed if old_text != @text
+        end
+
+        def draw
+            @screen.move_cursor(@start.to_hash)
+            @screen.draw_string(@text.ljust(@width))
+
+            @screen.move_cursor(@cursor.to_hash)
+        end
+    end
+end

data/lib/terminal-notes/widget.rb

@@ -0,0 +1,96 @@
+module TerminalNotes
+  class Widget
+    attr_reader :window, :width, :height
+
+    TITLE_PADDING = 4
+
+    def initialize(parent:, title:, width: 1, height: 1,
+                   x: 0, y: 0, align: :center, valign: :center,
+                   border: true)
+      @parent = parent
+      @title  = title || ""
+
+      @width  = width
+      @height = height
+
+      parent_size = @parent.size
+
+      # Relative layout calculation
+      remaining_width = @width
+      if @width <= 1
+        remaining_width = parent_size[:columns] - x
+        @width = (@width * remaining_width).to_i
+      end
+
+      remaining_height = @height
+      if @height <= 1
+        remaining_height = parent_size[:lines] - y
+        @height = (@height * remaining_height).to_i
+      end
+
+      if align == :center
+        pos_x = x + (remaining_width - @width) / 2
+        @title_x = (@width - @title.size) / 2
+      elsif align == :right
+        pos_x = (remaining_width - @width)
+        @title_x = @width - @title.size - TITLE_PADDING
+      else
+        pos_x = x # do nothing
+        @title_x = TITLE_PADDING
+      end
+
+      if valign == :center
+        pos_y = y + (remaining_height - @height) / 2
+      elsif valign == :bottom
+        pos_y = y + (remaining_height - @height)
+      else
+        pos_y = y # do nothing
+      end
+
+      @position = Cursor.new(x: pos_x, y: pos_y)
+
+      @window = Rurses::Window.new(
+        lines: @height, columns: @width,
+        x: @position.x, y: @position.y)
+
+      @has_border = border
+
+      # @window.refresh_in_memory
+    end
+
+    def redraw
+      @window.clear
+      draw
+    end
+
+    def draw
+      old_cursor = @window.cursor_xy
+
+      # Draw title
+      if @has_border || !@title.empty?
+        @window.draw_border
+        @window.move_cursor(x: @title_x, y: 0)
+        @window.draw_string(" #{@title} ")
+      end
+
+      yield if block_given?
+
+      @window.move_cursor(old_cursor)
+      @window.refresh_in_memory
+    end
+
+    def focus
+    end
+
+    def resize
+      calculate_and_draw
+    end
+
+    private
+
+    def calculate_and_draw(new_window: false)
+      @window.clear
+      @window.refresh_in_memory
+    end
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: terminal-notes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Vidur Murali
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi-ncurses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: fuzzy_match
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.25
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.25
+description:
+email:
+- vidur@monkeychai.com
+executables:
+- terminal-notes
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/terminal-notes
+- lib/terminal-notes.rb
+- lib/terminal-notes/cursor.rb
+- lib/terminal-notes/file_list.rb
+- lib/terminal-notes/info_bar.rb
+- lib/terminal-notes/rurses.rb
+- lib/terminal-notes/rurses/panel_stack.rb
+- lib/terminal-notes/rurses/version.rb
+- lib/terminal-notes/rurses/window.rb
+- lib/terminal-notes/search_field.rb
+- lib/terminal-notes/text_field.rb
+- lib/terminal-notes/widget.rb
+homepage: https://github.com/vyder/terminal-notes
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://vyder.github.io/terminal-notes
+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.1.4
+signing_key:
+specification_version: 4
+summary: Searchable notes in your terminal! What's not to like?
+test_files: []