diakonos 0.8.3

data/lib/diakonos/clipboard.rb

@@ -0,0 +1,47 @@
+module Diakonos
+
+class Clipboard
+    def initialize( max_clips )
+        @clips = Array.new
+        @max_clips = max_clips
+    end
+
+    def [] ( arg )
+        return @clips[ arg ]
+    end
+
+    def clip
+        return @clips[ 0 ]
+    end
+
+    # text is an array of Strings
+    # Returns true iff a clip was added,
+    # and only non-nil text can be added.
+    def addClip( text )
+        return false if text == nil
+        @clips.unshift text
+        @clips.pop if @clips.length > @max_clips
+        return true
+    end
+    
+    def each
+        @clips.each do |clip|
+            yield clip
+        end
+    end
+    
+    # text is an array of Strings (lines)
+    # Appends the lines to the current clip.
+    # If no current clip, then a new clip is created.
+    # Returns true iff the text was successfully appended.
+    def appendToClip( text )
+        return false if text.nil?
+        return addClip( text ) if @clips.length == 0
+        last_clip = @clips[ 0 ]
+        last_clip.pop if last_clip[ -1 ] == ""
+        @clips[ 0 ] = last_clip + text
+        return true
+    end
+end
+
+end

data/lib/diakonos/ctag.rb

@@ -0,0 +1,28 @@
+module Diakonos
+
+class CTag
+    attr_reader :file, :command, :kind, :rest
+    
+    def initialize( file, command, kind, rest )
+        @file = file
+        @command = command
+        @kind = kind
+        @rest = rest
+    end
+    
+    def to_s
+        return "#{@file}:#{@command} (#{@kind}) #{@rest}"
+    end
+    
+    def == ( other )
+        return (
+            other != nil and
+            @file == other.file and
+            @command == other.command and
+            @kind == other.kind and
+            @rest == other.rest
+        )
+    end
+end
+
+end

data/lib/diakonos/enumerable.rb

@@ -0,0 +1,15 @@
+module Enumerable
+    # Returns [array-index, string-index, string-index] triples for each match.
+    def grep_indices( regexp )
+        array = Array.new
+        each_with_index do |element,index|
+            element.scan( regexp ) do |match_text|
+                match = Regexp.last_match
+                strindex = match.begin( 0 )
+                array.push [ index, strindex, strindex + match_text.length ]
+            end
+        end
+        return array
+    end
+end
+

data/lib/diakonos/finding.rb

@@ -0,0 +1,32 @@
+module Diakonos
+
+class Finding
+    attr_reader :start_row, :start_col, :end_row, :end_col
+    attr_writer :end_row, :end_col
+    
+    def initialize( start_row, start_col, end_row, end_col )
+        @start_row = start_row
+        @start_col = start_col
+        @end_row = end_row
+        @end_col = end_col
+    end
+    
+    def match( regexps, lines )
+        retval = true
+        
+        i = @start_row + 1
+        regexps[ 1..-1 ].each do |re|
+            if lines[ i ] !~ re
+                retval = false
+                break
+            end
+            @end_row = i
+            @end_col = Regexp.last_match[ 0 ].length
+            i += 1
+        end
+        
+        return retval
+    end
+end
+
+end

data/lib/diakonos/fixnum.rb

@@ -0,0 +1,13 @@
+require 'diakonos/keycode'
+
+class Fixnum
+    include Diakonos::KeyCode
+
+    def fit( min, max )
+        return self if max < min
+        return min if self < min
+        return max if self > max
+        return self
+    end
+end
+

data/lib/diakonos/hash.rb

@@ -0,0 +1,101 @@
+class Hash
+    # path is an array of hash keys
+    # This method deletes a path of hash keys, with each step in the path
+    # being a recursively deeper key in a hash tree.
+    # Returns the possibly modified hash.
+    def deleteKeyPath( path )
+        if path.length > 1
+            subtree = self[ path[ 0 ] ]
+            if subtree.respond_to?( :deleteKeyPath )
+                subtree.deleteKeyPath( path[ 1..-1 ] )
+                if subtree.empty?
+                    delete( path[ 0 ] )
+                end
+            end
+        elsif path.length == 1
+            delete( path[ 0 ] )
+        end
+        
+        return self
+    end
+    
+    def setKeyPath( path, leaf )
+        if path.length > 1
+            node = self[ path[ 0 ] ]
+            if not node.respond_to?( :setKeyPath )
+                node = self[ path[ 0 ] ] = Hash.new
+            end
+            node.setKeyPath( path[ 1..-1 ], leaf )
+        elsif path.length == 1
+            self[ path[ 0 ] ] = leaf
+        end
+        
+        return self
+    end
+    
+    def getNode( path )
+        node = self[ path[ 0 ] ]
+        if path.length > 1
+            if node != nil and node.respond_to?( :getNode )
+                return node.getNode( path[ 1..-1 ] )
+            end
+        elsif path.length == 1
+            return node
+        end
+        
+        return nil
+    end
+    
+    def getLeaf( path )
+        node = getNode( path )
+        if node.respond_to?( :getNode )
+            # Only want a leaf node
+            return nil
+        else
+            return node
+        end
+    end
+    
+    def leaves( _leaves = Set.new )
+        each_value do |value|
+            if value.respond_to?( :leaves )
+                _leaves.merge value.leaves( _leaves )
+            else
+                _leaves << value
+            end
+        end
+        
+        return _leaves
+    end
+    
+    def paths_and_leaves( path_so_far = [], _paths_and_leaves = Set.new )
+        each do |key, value|
+            if value.respond_to?( :paths_and_leaves )
+                _paths_and_leaves.merge(
+                    value.paths_and_leaves(
+                        path_so_far + [ key ],
+                        _paths_and_leaves
+                    )
+                )
+            else
+                _paths_and_leaves << {
+                    :path => path_so_far + [ key ],
+                    :leaf => value
+                }
+            end
+        end
+        
+        return _paths_and_leaves
+    end
+    
+    def each_path_and_leaf( path_so_far = [] )
+        each do |key, value|
+            if value.respond_to?( :each_path_and_leaf )
+                value.each_path_and_leaf( path_so_far + [ key ] ) { |path, leaf| yield( path, leaf ) }
+            else
+                yield( path_so_far + [ key ], value )
+            end
+        end
+    end
+end
+

data/lib/diakonos/keycode.rb

@@ -0,0 +1,110 @@
+module Diakonos
+
+module KeyCode
+    KEYSTRINGS = [
+        "ctrl+space",   # 0
+        "ctrl+a",       # 1
+        "ctrl+b",       # 2
+        "ctrl+c",       # 3
+        "ctrl+d",       # 4
+        "ctrl+e",       # 5
+        "ctrl+f",       # 6
+        "ctrl+g",       # 7
+        nil,            # 8
+        "tab",          # 9
+        "ctrl+j",       # 10
+        "ctrl+k",       # 11
+        "ctrl+l",       # 12
+        "enter",        # 13
+        "ctrl+n",       # 14
+        "ctrl+o",       # 15
+        "ctrl+p",       # 16
+        "ctrl+q",       # 17
+        "ctrl+r",       # 18
+        "ctrl+s",       # 19
+        "ctrl+t",       # 20
+        "ctrl+u",       # 21
+        "ctrl+v",       # 22
+        "ctrl+w",       # 23
+        "ctrl+x",       # 24
+        "ctrl+y",       # 25
+        "ctrl+z",       # 26
+        "esc",          # 27
+        nil,            # 28
+        nil,            # 29
+        nil,            # 30
+        nil,            # 31
+        "space",        # 32
+        33.chr, 34.chr, 35.chr, 36.chr, 37.chr, 38.chr, 39.chr,
+        40.chr, 41.chr, 42.chr, 43.chr, 44.chr, 45.chr, 46.chr, 47.chr, 48.chr, 49.chr,
+        50.chr, 51.chr, 52.chr, 53.chr, 54.chr, 55.chr, 56.chr, 57.chr, 58.chr, 59.chr,
+        60.chr, 61.chr, 62.chr, 63.chr, 64.chr, 65.chr, 66.chr, 67.chr, 68.chr, 69.chr,
+        70.chr, 71.chr, 72.chr, 73.chr, 74.chr, 75.chr, 76.chr, 77.chr, 78.chr, 79.chr,
+        80.chr, 81.chr, 82.chr, 83.chr, 84.chr, 85.chr, 86.chr, 87.chr, 88.chr, 89.chr,
+        90.chr, 91.chr, 92.chr, 93.chr, 94.chr, 95.chr, 96.chr, 97.chr, 98.chr, 99.chr,
+        100.chr, 101.chr, 102.chr, 103.chr, 104.chr, 105.chr, 106.chr, 107.chr, 108.chr, 109.chr,
+        110.chr, 111.chr, 112.chr, 113.chr, 114.chr, 115.chr, 116.chr, 117.chr, 118.chr, 119.chr,
+        120.chr, 121.chr, 122.chr, 123.chr, 124.chr, 125.chr, 126.chr,
+        "backspace"    # 127
+    ]
+
+    def keyString
+        if self.class == Fixnum
+            retval = KEYSTRINGS[ self ]
+        end
+        if retval == nil
+            case self
+                when Curses::KEY_DOWN
+                    retval = "down"
+                when Curses::KEY_UP
+                    retval = "up"
+                when Curses::KEY_LEFT
+                    retval = "left"
+                when Curses::KEY_RIGHT
+                    retval = "right"
+                when Curses::KEY_HOME
+                    retval = "home"
+                when Curses::KEY_END
+                    retval = "end"
+                when Curses::KEY_IC
+                    retval = "insert"
+                when Curses::KEY_DC
+                    retval = "delete"
+                when Curses::KEY_PPAGE
+                    retval = "page-up"
+                when Curses::KEY_NPAGE
+                    retval = "page-down"
+                when Curses::KEY_A1
+                    retval = "numpad7"
+                when Curses::KEY_A3
+                    retval = "numpad9"
+                when Curses::KEY_B2
+                    retval = "numpad5"
+                when Curses::KEY_C1
+                    retval = "numpad1"
+                when Curses::KEY_C3
+                    retval = "numpad3"
+                when Curses::KEY_FIND
+                    retval = "find"
+                when Curses::KEY_SELECT
+                    retval = "select"
+                when Curses::KEY_SUSPEND
+                    retval = "suspend"
+                when Curses::KEY_F0..(Curses::KEY_F0 + 24)
+                    retval = "f" + (self - Curses::KEY_F0).to_s
+                when CTRL_H
+                    retval = "ctrl+h"
+                when Curses::KEY_RESIZE
+                    retval = "resize"
+                when RESIZE2
+                    retval = "resize2"
+            end
+        end
+        if retval == nil and self.class == Fixnum
+            retval = "keycode#{self}"
+        end
+        return retval
+    end
+end
+
+end

data/lib/diakonos/object.rb

@@ -0,0 +1,6 @@
+class Object
+    def deep_clone
+        Marshal::load( Marshal.dump( self ) )
+    end
+end
+

data/lib/diakonos/readline.rb

@@ -0,0 +1,192 @@
+module Diakonos
+
+class Readline
+
+    # completion_array is the array of strings that tab completion can use
+    def initialize( diakonos, window, initial_text = "", completion_array = nil, history = [] )
+        @window = window
+        @diakonos = diakonos
+        @initial_text = initial_text
+        @completion_array = completion_array
+        @list_filename = @diakonos.list_filename
+        
+        @history = history
+        @history << initial_text
+        @history_index = @history.length - 1
+    end
+
+    # Returns nil on cancel.
+    def readline
+        @input = @initial_text
+        @icurx = @window.curx
+        @icury = @window.cury
+        @window.addstr @initial_text
+        @input_cursor = @initial_text.length
+        @opened_list_file = false
+
+        loop do
+            c = @window.getch
+
+            case c
+                when Curses::KEY_DC
+                    if @input_cursor < @input.length
+                        @window.delch
+                        @input = @input[ 0...@input_cursor ] + @input[ (@input_cursor + 1)..-1 ]
+                    end
+                when BACKSPACE, CTRL_H
+                    # Curses::KEY_LEFT
+                    if @input_cursor > 0
+                        @input_cursor += -1
+                        @window.setpos( @window.cury, @window.curx - 1 )
+                        
+                        # Curses::KEY_DC
+                        if @input_cursor < @input.length
+                            @window.delch
+                            @input = @input[ 0...@input_cursor ] + @input[ (@input_cursor + 1)..-1 ]
+                        end
+                    end
+                when ENTER
+                    break
+                when ESCAPE, CTRL_C, CTRL_D, CTRL_Q
+                    @input = nil
+                    break
+                when Curses::KEY_LEFT
+                    if @input_cursor > 0
+                        @input_cursor += -1
+                        @window.setpos( @window.cury, @window.curx - 1 )
+                    end
+                when Curses::KEY_RIGHT
+                    if @input_cursor < @input.length
+                        @input_cursor += 1
+                        @window.setpos( @window.cury, @window.curx + 1 )
+                    end
+                when Curses::KEY_HOME
+                    @input_cursor = 0
+                    @window.setpos( @icury, @icurx )
+                when Curses::KEY_END
+                    @input_cursor = @input.length
+                    @window.setpos( @window.cury, @icurx + @input.length )
+                when TAB
+                    completeInput
+                when Curses::KEY_NPAGE
+                    @diakonos.pageDown
+                when Curses::KEY_PPAGE
+                    @diakonos.pageUp
+                when Curses::KEY_UP
+                    if @history_index > 0
+                        @history[ @history_index ] = @input
+                        @history_index -= 1
+                        @input = @history[ @history_index ]
+                        cursorWriteInput
+                    end
+                when Curses::KEY_DOWN
+                    if @history_index < @history.length - 1
+                        @history[ @history_index ] = @input
+                        @history_index += 1
+                        @input = @history[ @history_index ]
+                        cursorWriteInput
+                    end
+                when CTRL_K
+                    @input = ""
+                    cursorWriteInput
+                else
+                    if c > 31 and c < 255 and c != BACKSPACE
+                        if @input_cursor == @input.length
+                            @input << c
+                            @window.addch c
+                        else
+                            @input = @input[ 0...@input_cursor ] + c.chr + @input[ @input_cursor..-1 ]
+                            @window.setpos( @window.cury, @window.curx + 1 )
+                            redrawInput
+                        end
+                        @input_cursor += 1
+                    else
+                        @diakonos.log "Other input: #{c}"
+                    end
+            end
+        end
+        
+        @diakonos.closeListBuffer
+
+        @history[ -1 ] = @input
+        
+        return @input
+    end
+
+    def redrawInput
+        curx = @window.curx
+        cury = @window.cury
+        @window.setpos( @icury, @icurx )
+        @window.addstr "%-#{ Curses::cols - curx }s%s" % [ @input, " " * ( Curses::cols - @input.length ) ]
+        @window.setpos( cury, curx )
+        @window.refresh
+    end
+
+    # Redisplays the input text starting at the start of the user input area,
+    # positioning the cursor at the end of the text.
+    def cursorWriteInput
+        if @input != nil
+            @input_cursor = @input.length
+            @window.setpos( @window.cury, @icurx + @input.length )
+            redrawInput
+        end
+    end
+
+    def completeInput
+        if @completion_array != nil and @input.length > 0
+            len = @input.length
+            matches = @completion_array.find_all { |el| el[ 0...len ] == @input and len < el.length }
+        else
+            matches = Dir.glob( ( @input.subHome() + "*" ).gsub( /\*\*/, "*" ) )
+        end
+        
+        if matches.length == 1
+            @input = matches[ 0 ]
+            cursorWriteInput
+            File.open( @list_filename, "w" ) do |f|
+                f.puts "(unique)"
+            end
+            if @completion_array == nil and FileTest.directory?( @input )
+                @input << "/"
+                cursorWriteInput
+                completeInput
+            end
+        elsif matches.length > 1
+            common = matches[ 0 ]
+            File.open( @list_filename, "w" ) do |f|
+                i = nil
+                matches.each do |match|
+                    f.puts match
+                    
+                    if match[ 0 ] != common[ 0 ]
+                        common = nil
+                        break
+                    end
+                    
+                    up_to = [ common.length - 1, match.length - 1 ].min
+                    i = 1
+                    while ( i <= up_to ) and ( match[ 0..i ] == common[ 0..i ] )
+                        i += 1
+                    end
+                    common = common[ 0...i ]
+                end
+            end
+            if common == nil
+                File.open( @list_filename, "w" ) do |f|
+                    f.puts "(no matches)"
+                end
+            else
+                @input = common
+                cursorWriteInput
+            end
+        else
+            File.open( @list_filename, "w" ) do |f|
+                f.puts "(no matches)"
+            end
+        end
+        @diakonos.openListBuffer
+        @window.setpos( @window.cury, @window.curx )
+    end
+end
+
+end