rodo 0.1.0

data/lib/rodo/commands.rb

@@ -0,0 +1,29 @@
+
+module Commands
+
+    def initialize
+    @command_prototyp_list = [
+      {
+        description: "p(ostpone) todo by number of n days (p <n>)",
+        regex: /^po?s?t?p?o?n?e?\s*(\d*)\s*$/,
+        prototype: "p ",
+        do_cmd: lambda { |cmd, lines, day|
+          if cmd =~ /^p\s*(\d*)\s*$/
+            postpone(lines, day, $1.to_i)
+          end
+        }
+      },
+      "t(oday): move all unfinished tasks to today's entry",
+      "k(ill): remove the current line",
+      "m(ove): enter movement mode",
+      "a(ppend): insert a new todo after the current line",
+      "i(nsert): insert a new todo before the current line",
+      "w(aiting): move the current todo 7 days into the future",
+      {
+        description: "q(uit): exit and save",
+        prototype: "q"
+      }
+    ]
+  end
+
+end

data/lib/rodo/curses_util.rb

@@ -0,0 +1,287 @@
+require 'curses'
+
+module Curses
+
+  KEY_CTRL_RIGHT = Curses::REQ_SCR_FCHAR
+  KEY_CTRL_LEFT = Curses::REQ_DEL_CHAR
+
+  @@debug_win = nil
+
+  def self.debug_win= debug_win
+    @@debug_win = debug_win
+  end
+
+  def self.debug_win
+    @@debug_win
+  end
+
+  def self.debug message
+    if @@debug_win
+      @@debug_win.puts message
+      @@debug_win.refresh
+    end
+  end
+
+  # Switch on bracketed paste mode
+  # and reset it at end of application
+  def self.bracketed_paste
+    print("\x1b[?2004h")
+    at_exit {
+      print("\x1b[?2004l")
+    }
+  end
+
+  module WindowExtensions
+
+    # Create a subwindow inside this window which is padded by the given number n (lines and characters)
+    def inset(n=1)
+      subwin(maxy - 2 * n, maxx - 2 * n, begy + n, begx + n)
+    end
+
+    # Override box() to call box(0, 0)
+    def box(*args)
+      if args.size == 0
+        super(0, 0)
+      else
+        super(*args)
+      end
+    end
+
+    # Add the given string to this window and put the cursor on the next line
+    def puts(string)
+      if maxx - curx == string.length
+        addstr(string)
+      else
+        addstr(string + "\n")
+      end
+    end
+
+    # Return the current coordinates of the cursor [y,x]
+    def getyx
+      return [cury(), curx()]
+    end
+
+    # Add the given string to the top left borner of a box window
+    def caption(string)
+      p = getyx
+      setpos(0,1)
+      addstr(string)
+      setpos(*p)
+    end
+
+    def addstr_with_cursor(line, cursor_x)
+      line = line + " "
+
+      Curses.debug "Before Cursor: '#{line[...cursor_x]}'"
+      Curses.debug "Cursor_x: '#{cursor_x}'"
+
+      cursor_x = 0 if cursor_x < 0
+      cursor_x = line.size - 1 if cursor_x >= line.size
+
+      addstr line[...cursor_x] if cursor_x > 0
+      attron(Curses::A_REVERSE)
+      addstr line[cursor_x]
+      attroff(Curses::A_REVERSE)
+      addstr(line[(cursor_x+1)..]) if cursor_x < line.size
+      addstr("\n")
+    end
+
+    # Will read until the end of a bracketed paste marker "\x1b[201~"
+    # Requires that the "\x1b[200~" start marker has already been processed.
+    # The returned text does NOT include the end marker "200~"
+    def get_paste_text
+      pasted = ""
+      loop do
+        d = get_char2
+        case d
+        in csi: "201~" # Bracketed paste ended
+          break
+        else
+          pasted += d
+        end
+      end
+      return pasted
+    end
+
+    # Reads a Control Sequence Introducer (CSI) from `get_char`
+    #
+    # Requires that ANSI Control Sequence "\x1b[" has already been consumed.
+    #
+    # Assumes that there are no errors in the CSI.
+    #
+    # For CSI, or "Control Sequence Introducer" commands,
+    # the ESC [ is followed by
+    # 1.) any number (including none) of "parameter bytes" in the range
+    #     0x30–0x3F (ASCII 0–9:;<=>?), then by
+    # 2.) any number of "intermediate bytes" in the range
+    #     0x20–0x2F (ASCII space and !"#$%&'()*+,-./), then finally by
+    # 3.) a single "final byte" in the range
+    #     0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
+    #
+    # From: https://handwiki.org/wiki/ANSI_escape_code
+    def get_csi
+
+      result = "".dup
+      loop do
+        c = get_char
+        result += c
+        if c.ord >= 0x40 && c.ord <= 0x7E
+          return result
+        end
+      end
+
+    end
+
+    # Just like get_char, but will read \x1b[<csi>
+    # return it as a hash { csi: ... }, 
+    # everything else is just returned as-is
+    def get_char2
+      c = get_char
+      case c
+      when "\e" # ESC
+        d = get_char
+        case d
+        when '['
+          return { csi: get_csi }
+        else
+          Curses.unget_char(d)
+          return "\e"
+          # Curses.abort("Unhandled command sequence")
+          # raise "¯\_(ツ)_/¯"
+        end
+      else
+        return c
+      end
+    end
+
+    # Just like get_char2, but will read csi: "200~" as bracketed paste and
+    # return it as a hash { paste: <text> },
+    # everything else is just returned as from get_char2
+    def get_char3
+      c = get_char2
+      case c
+      in csi: "200~" # Bracketed paste started
+        return { paste: get_paste_text }
+      else
+        return c
+      end
+    end
+
+    # Will take care of reading a string from the user, given the start_string
+    def gets(start_string)
+
+      line = start_string
+      cursor_x = line.length
+      start_pos = getyx
+
+      loop do
+
+        clear
+        setpos(*start_pos)
+        addstr_with_cursor(line, cursor_x)
+
+        yield line
+
+        char = get_char
+        case char
+
+        when CTRLC, CTRLC.chr, ESC, ESC.chr
+          return :close
+
+        when "\u0001" # CTRL+A
+          cursor_x = 0
+
+        when "\u0005" # CTRL+E
+          cursor_x = line.length
+
+        when Curses::KEY_LEFT
+          cursor_x -= 1 if cursor_x > 0
+
+        when Curses::KEY_RIGHT
+          cursor_x += 1 if cursor_x < line.length - 1
+
+        when Curses::KEY_DC, "\u0004" # DEL, CTRL+D
+          if cursor_x < line.size
+            line.slice!(cursor_x)
+          end
+
+        when Curses::KEY_BACKSPACE
+          if cursor_x > 0
+            line.slice!(cursor_x - 1)
+            cursor_x -= 1
+          end
+
+        when ENTER, ENTER.chr
+          return line
+
+        when /[[:print:]]/
+
+          line.insert(cursor_x, char)
+          cursor_x += 1
+
+        else
+          Curses.debug "Char not handled: " + Curses::char_info(char)
+        end
+
+      end
+
+    end
+  end
+
+  class Window
+    prepend WindowExtensions
+  end
+
+  def self.cputs(string)
+    w = stdscr.inset
+    w.puts string
+    w.getch
+    w.close
+  end
+
+  # Enable bracketed paste mode and reset it upon exit
+  def bracketed_paste
+    print("\x1b[?2004h")
+    at_exit {
+      print("\x1b[?2004l")
+    }
+  end
+
+  def self.char_info(char)
+
+    case char
+    when Integer
+      key = Curses::ch2key(char)
+      return "Char: #{char} - Class Integer " + (key != nil ? "Constant: #{key}" : "To chr(): #{char.chr}")
+
+    # when String
+
+    else
+      return "Char: #{char.inspect} - Class: #{char.class}"
+    end
+  end
+
+  def self.ch2key(ch)
+
+    if !defined?(@@map)
+      @@map = {}
+      Curses.constants(false).each { |s|
+        c = Curses.const_get(s)
+        @@map[c] ||= []
+        @@map[c] << s
+      }
+    end
+    @@map[ch]
+  end
+
+  def self.abort(msg)
+
+    Curses.close_screen
+    puts "Traceback (most recent call last):"
+    puts caller.each_with_index.map { |s, i| "#{(i+1).to_s.rjust(9)}: from #{s}" }.reverse
+    puts msg
+    Kernel.exit(-1)
+
+  end
+
+end

data/lib/rodo/rodolib.rb

@@ -0,0 +1,438 @@
+
+require 'date'
+
+class Command
+
+  def redo()
+
+  end
+
+  def undo()
+
+  end
+
+end
+
+
+class Processor
+
+
+  def command(c, line, verb)
+
+  end
+
+
+end
+
+#
+# Journal is the datastore class for the todo list managed by rodolib.
+#
+# Responsible for:
+#   - Parsing a md file into a rodolib Journal
+#   - Serialization into a md file
+#   - Splitting into days
+#
+class Journal
+
+  attr_accessor :days
+  def self.from_s(s)
+
+    j = Journal.new
+    j.days = []
+
+    next_day = []
+    s.each_line { |line|
+      if line =~ /^\s*\#\s*(\d\d\d\d-\d\d-\d\d)/ && next_day.size > 0
+        j.days << TodoDay.new(next_day)
+        next_day = []
+      end
+      next_day << line.rstrip if next_day.size > 0 || line.strip.length > 0 # Skip leading empty lines
+    }
+    if (next_day.size > 0 && next_day.any? { |line| line.strip.length > 0 })
+      j.days << TodoDay.new(next_day)
+    end
+
+    return j
+  end
+
+  def to_s
+    days.map { |day| day.to_s }.join("\n\n") + (days.empty? ? "" : "\n")
+  end
+
+  # Returns the TodoDay for the given date creating it if it doesn't exist
+  def ensure_day(target_date)
+    index = days.find_index { |x| x.date <= target_date } || -1
+
+    if index < 0 || days[index].date != target_date
+      days.insert(index, TodoDay.new(["# #{target_date.strftime("%Y-%m-%d")}"]))
+    end
+    return days[index]
+  end
+
+  # Returns the day, number of days in the future from the given day, but at never before today
+  def postpone_day(day, number_of_days_to_postpone=1)
+
+    number_of_days_to_postpone = 1 if number_of_days_to_postpone < 1
+
+    target_date = (day.date || Date.today).next_day(number_of_days_to_postpone)
+
+    # target_date shouldn't be in the past
+    target_date = Date.today if target_date.to_date < Date.today
+
+    return ensure_day(target_date)
+  end
+
+  # Postpone the given line on the given day by the given number of days, default=1
+  #
+  # Returns false, if there is no todo which can be postponed on the given line
+  # Returns the target date to which the line was moved if successful.
+  def postpone_line(day, line_index, number_of_days_to_postpone=1)
+
+    line = day.lines[line_index]
+
+    # Postpone only works for todos
+    return false if !(line =~ /^\s*(-\s+)?\[(.)\]/)
+
+    # Postpone only works for unfinished todos
+    return false if $2 != " "
+
+    # First create the target day
+    target_day = postpone_day(day, number_of_days_to_postpone)
+
+    # Determine all affected lines
+    unfinished_lines = [nil] * day.lines.size
+
+    # Copy all unfinished tasks and...
+    unfinished_lines[line_index] = line.dup
+
+    # ...their parent entries (recursively)
+    parent_index = line_index
+    while (parent_index = day.parent_index(parent_index)) != nil
+      unfinished_lines[parent_index] ||= day.lines[parent_index].dup
+    end
+
+    # Copy up to 1 whitespace line preceeding
+    unfinished_lines.each_with_index { |e, i|
+      if e != nil && i != 0 && day.indent_depth(i - 1) == nil
+        unfinished_lines[i-1] = ""
+      end
+    }
+
+    # ...and the children as well!
+    # TODO
+
+    # Mark line itself as postponed
+    line.sub!(/\[\s\]/, "[>]")
+
+    # Get rid of primary header
+    if unfinished_lines[0] =~ /^\s*\#\s*(\d\d\d\d-\d\d-\d\d)/
+      unfinished_lines.shift
+    end
+
+    # Only append non-empty lines
+    unfinished_lines.select! { |l| l != nil }
+
+    target_day.merge_lines(unfinished_lines)
+
+    return target_day
+  end
+
+  # Postpones all unfinished todos to today's date
+  # Returns the index of the target date to which things were postponed
+  def close(day)
+
+    unfinished_lines = [nil] * day.lines.size
+
+    day.lines.each_with_index { |line, index|
+      if line =~ /^\s*(-\s+)?\[(.)\]/
+
+        if $2 == " "
+          # Copy all unfinished tasks and...
+          unfinished_lines[index] = line.dup
+
+          # ...their parent entries (recursively)
+          parent_index = index
+          while (parent_index = day.parent_index(parent_index)) != nil
+            unfinished_lines[parent_index] ||= day.lines[parent_index].dup
+          end
+          line.sub!(/\[\s\]/, "[>]")
+        end
+
+      # Copy top level structure:
+      elsif !(line =~ /^\s*[-*]\s+/ || line =~ /^\s*#\s/)
+        unfinished_lines[index] = line.dup
+      end
+    }
+
+    if unfinished_lines[0] =~ /^\s*\#\s*(\d\d\d\d-\d\d-\d\d)/
+      unfinished_lines.shift
+    end
+
+    target_day = ensure_day(Date.today)
+    if target_day == day
+      # When closing on the same day: append hour and minutes
+      newDate = "# #{Time.now.strftime("%Y-%m-%d %a %H:%M")}"
+      target_day = TodoDay.new([newDate])
+      insertion_index = days.index { |d| target_day.date >= d.date } || 0
+      days.insert(insertion_index, target_day)
+    end
+
+    # Only append non-empty lines
+    unfinished_lines.select! { |l| l != nil }
+
+    target_day.merge_lines(unfinished_lines)
+
+    return days.find_index(target_day)
+  end
+
+  def most_recent_index
+    today = Date.today
+    return days.find_index { |x| x.date <= today } || 0
+  end
+
+end
+
+#
+# Encapsulates the position of the cursor in the following dimensions:
+#
+#  - which *x* position the cursor is on, on a particular *line*
+#  - which *line* the cursor is on, on a particular *day*
+#  - which *day* is currently shown on the main screen
+#  - which *x* position would be on ('shadow x'), if the line would be longer
+#  - which *line* the cursor would be on ('shadow line'), if the current day would have more lines
+#
+class Cursor
+
+  attr_accessor :journal
+  attr_accessor :day
+
+  def initialize(journal)
+    @journal = journal
+    @shadow_line = 0
+    @shadow_x = 0
+    self.day = @journal.most_recent_index
+    # self.line = 0
+    # self.x = 0
+  end
+
+  def day=(day)
+    @day = [[0, day].max, @journal.days.size - 1].min
+    @line = [@journal.days[@day].lines.size - 1, @shadow_line].min
+    @x = [@journal.days[@day].lines[@line].size, @shadow_x].min
+  end
+
+  def line=(line)
+    line = [[0, line].max, @journal.days[@day].lines.size - 1].min
+    @line = @shadow_line = line
+    @x = [@journal.days[@day].lines[@line].size, @shadow_x].min
+  end
+
+  def x=(x)
+    # note x is clamped 1 character beyond the length of the line
+    x = [[0, x].max, @journal.days[@day].lines[@line].size].min
+    @x = @shadow_x = x
+  end
+
+  def line
+    @line
+  end
+
+  def x
+    @x
+  end
+
+end
+
+# Encapsulate a single date of todo information
+class TodoDay
+
+  attr_accessor :date
+  attr_accessor :lines
+
+  def initialize(lines)
+    self.lines = lines
+
+    if lines.size > 0 && lines[0] =~ /^\s*\#\s*(\d\d\d\d-\d\d-\d\d)/
+      self.date = Date.parse($1)
+      raise "Date couldn't be parsed on line #{lines[0]}" if self.date == nil
+    end
+  end
+
+  def date_name
+    return date.strftime("%Y-%m-%d") if date
+    return "undefined"
+  end
+
+  def to_s
+    lines.join("\n").rstrip
+  end
+
+  def line_prototype(line_index)
+    line = lines[line_index]
+    if /^(?<lead>\s+[*-])(?<option>\s\[.\]\s?)?(?<rest>.*?)$/ =~ line
+      if option =~ /^\s\[.\]/
+        option = " [ ]"
+      end
+    else
+      lead = " -"
+      option = " [ ]"
+    end
+
+    option = "" if !option
+    return lead + option.rstrip + " "
+  end
+
+  # Returns the number of leading spaces of the given line
+  def indent_depth(line_index)
+    return nil if !lines[line_index] || lines[line_index].strip.length == 0
+
+    lines[line_index][/\A\s*/].length
+  end
+
+  # Returns the line index of the parent line if any or nil
+  # The parent line is the line with a reduced indentation or the section header in case there no reduced indented line
+  def parent_index(line_index)
+    j = line_index - 1
+    my_indent = indent_depth(line_index)
+    return nil if !my_indent
+    while j > 0 # Day header does not count as parent
+      other_indent = indent_depth(j)
+      if other_indent && other_indent < my_indent
+        return j
+      end
+      j -= 1
+    end
+    return nil
+  end
+
+  # Turns the linear list of lines of this TodoDay into a nested structure of the form
+  # [{text: "text", children: [...]}, ...]
+  # where ... is the same hash structure {text: "text", children: [...]}
+  def structure
+
+    indents = [nil] * lines.size
+    (lines.size - 1).downto(0).each { |i|
+      indents[i] = indent_depth(i) || (i+1 < indents.size ? indents[i+1] : 0)
+    }
+
+    stack = [{depth: -1, children: []}]
+    lines.each_with_index { |s, i|
+      indent = indents[i]
+      new_child = {depth: indent, text: s, index: i, children: []}
+      while indent <= stack.last[:depth]
+        stack.pop
+      end
+      stack.last[:children] << new_child
+      stack << new_child
+    }
+
+    return stack.first[:children]
+  end
+
+  def close
+
+    unfinished_lines = []
+    lines.each { |line|
+      if line =~ /^\s*(-\s+)?\[(.)\]/
+
+        if $2 == " "
+          unfinished_lines << line.dup
+          line.sub!(/\[\s\]/, "[>]")
+        end
+
+      # Copy structure:
+      elsif !(line =~ /^\s*[-*]\s+/ || line =~ /^\s*#\s/)
+        unfinished_lines << line.dup
+      end
+    }
+
+    if unfinished_lines[0] =~ /^\s*\#\s*(\d\d\d\d-\d\d-\d\d)/
+      unfinished_lines.shift
+    end
+
+    # When closing on the same day: append hour and minutes
+    newDate = "# #{Time.now.strftime("%Y-%m-%d %a")}"
+    if lines.size > 0 && lines[0].start_with?(newDate)
+      newDate = "# #{Time.now.strftime("%Y-%m-%d %a %H:%M")}"
+    end
+
+    return TodoDay.new([newDate, *unfinished_lines])
+
+  end
+
+
+  # Merge alls entries from source into target
+  def self.merge_structures(target, source)
+    # Attempt 1.3:
+    to_prepend = []
+    source.each { |new_block|
+      existing_block_index = target.find_index { |existing_block|
+        new_block != nil && existing_block != nil && new_block[:text] != "" && new_block[:text] == existing_block[:text]
+      }
+
+      if existing_block_index
+        existing_block = target[existing_block_index]
+
+        # Insert everything in the to_prepend queue at the given position...
+
+        # ... but merge whitespace now
+        whitespace_check_index = existing_block_index - 1
+        while whitespace_check_index >=0 && to_prepend.size > 0 && to_prepend[0][:text] == "" && target[whitespace_check_index][:text] = ""
+          to_prepend.shift
+          whitespace_check_index -= 1
+        end
+
+        target.insert(existing_block_index, *to_prepend)
+
+        # Start queue from scratch
+        to_prepend = []
+        merge_structures(existing_block[:children], new_block[:children])
+      else
+        to_prepend << new_block.dup
+      end
+    }
+    # Everything that couldn't be matched, goes to the end
+    # TODO Whitespace merging
+    target.concat(to_prepend)
+
+    TodoDay::structure_reindex(target)
+
+    return target
+  end
+
+  def self.structure_to_a(structure)
+    result = []
+    structure.each { |block|
+      result << block[:text]
+      result.concat(structure_to_a(block[:children]))
+    }
+    return result
+  end
+
+  # Will traverse the given structure and update all indices to be in increasing order
+  def self.structure_reindex(structure, index = 0)
+    structure.each { |block|
+      block[:index] = index
+      index = structure_reindex(block[:children], index + 1)
+    }
+    return index
+  end
+
+  def merge_lines(lines_to_append)
+
+    return if lines_to_append.empty?
+
+    end_lines = []
+    end_lines << lines.pop while lines.last.strip.size == 0
+
+    my_structure = structure
+    ap_structure = TodoDay.new(lines_to_append).structure
+
+    TodoDay::merge_structures(my_structure, ap_structure)
+
+    @lines = TodoDay::structure_to_a(my_structure)
+
+    lines.concat(end_lines)
+  end
+
+end