diakonos 0.8.3

data/lib/diakonos/regexp.rb

@@ -0,0 +1,6 @@
+class Regexp
+    def uses_bos
+        return ( source[ 0 ] == ?^ )
+    end
+end
+

data/lib/diakonos/sized-array.rb

@@ -0,0 +1,48 @@
+class SizedArray < Array
+    attr_reader :capacity
+    
+    def initialize( capacity = 10, *args )
+        @capacity = capacity
+        super( *args )
+    end
+    
+    def resize
+        if size > @capacity
+            slice!( (0...-@capacity) )
+        end
+    end
+    private :resize
+    
+    def concat( other_array )
+        super( other_array )
+        resize
+        return self
+    end
+    
+    def fill( *args )
+        retval = super( *args )
+        resize
+        return self
+    end
+    
+    def <<( item )
+        retval = super( item )
+        if size > @capacity
+            retval = shift
+        end
+        return retval
+    end
+    
+    def push( item )
+        self << item
+    end
+    
+    def unshift( item )
+        retval = super( item )
+        if size > @capacity
+            retval = pop
+        end
+        return retval
+    end
+end
+

data/lib/diakonos/string.rb

@@ -0,0 +1,318 @@
+class String
+    def subHome
+        return gsub( /~/, ENV[ "HOME" ] )
+    end
+
+    def keyCode
+        retval = nil
+        case downcase
+            when "down"
+                retval = Curses::KEY_DOWN
+            when "up"
+                retval = Curses::KEY_UP
+            when "left"
+                retval = Curses::KEY_LEFT
+            when "right"
+                retval = Curses::KEY_RIGHT
+            when "home"
+                retval = Curses::KEY_HOME
+            when "end"
+                retval = Curses::KEY_END
+            when "insert", "ins"
+                retval = Curses::KEY_IC
+            when "delete", "del"
+                retval = Curses::KEY_DC
+            when "backspace"
+                retval = Diakonos::BACKSPACE
+            when "tab"
+                retval = 9
+            when "pageup", "page-up"
+                retval = Curses::KEY_PPAGE
+            when "pagedown", "page-down"
+                retval = Curses::KEY_NPAGE
+            when "enter", "return"
+                retval = Diakonos::ENTER
+            when "numpad7", "keypad7", "kp-7"
+                retval = Curses::KEY_A1
+            when "numpad9", "keypad9", "kp-9"
+                retval = Curses::KEY_A3
+            when "numpad5", "keypad5", "kp-5"
+                retval = Curses::KEY_B2
+            when "numpad1", "keypad1", "kp-1"
+                retval = Curses::KEY_C1
+            when "numpad3", "keypad3", "kp-3"
+                retval = Curses::KEY_C3
+            when "escape", "esc"
+                retval = Diakonos::ESCAPE
+            when "space"
+                retval = 32
+            when "ctrl+space"
+                retval = 0
+            when "find"
+                retval = Curses::KEY_FIND
+            when "select"
+                retval = Curses::KEY_SELECT
+            when "suspend"
+                retval = Curses::KEY_SUSPEND
+            when /^f(\d\d?)$/
+                retval = Curses::KEY_F0 + $1.to_i
+            when /^ctrl\+[a-gi-z]$/
+                retval = downcase[ -1 ] - 96
+            when /^ctrl\+h$/
+                retval = Diakonos::CTRL_H
+            when /^alt\+(.)$/
+                retval = [ Diakonos::ESCAPE, $1[ 0 ] ]
+            when /^ctrl\+alt\+(.)$/, /^alt\+ctrl\+(.)$/
+                retval = [ Diakonos::ESCAPE, downcase[ -1 ] - 96 ]
+            when /^keycode(\d+)$/
+                retval = $1.to_i
+            when /^.$/
+                retval = self[ 0 ]
+        end
+        if retval.class != Array
+            retval = [ retval ]
+        end
+        return retval
+    end
+
+    def toFormatting
+        formatting = Curses::A_NORMAL
+        split( /\s+/ ).each do |format|
+            case format.downcase
+                when "normal"
+                    formatting = Curses::A_NORMAL
+                when "black", "0"
+                    formatting = formatting | Curses::color_pair( Curses::COLOR_BLACK )
+                when "red", "1"
+                    formatting = formatting | Curses::color_pair( Curses::COLOR_RED )
+                when "green", "2"
+                    formatting = formatting | Curses::color_pair( Curses::COLOR_GREEN )
+                when "yellow", "brown", "3"
+                    formatting = formatting | Curses::color_pair( Curses::COLOR_YELLOW )
+                when "blue", "4"
+                    formatting = formatting | Curses::color_pair( Curses::COLOR_BLUE )
+                when "magenta", "purple", "5"
+                    formatting = formatting | Curses::color_pair( Curses::COLOR_MAGENTA )
+                when "cyan", "6"
+                    formatting = formatting | Curses::color_pair( Curses::COLOR_CYAN )
+                when "white", "7"
+                    formatting = formatting | Curses::color_pair( Curses::COLOR_WHITE )
+                when "standout", "s", "so"
+                    formatting = formatting | Curses::A_STANDOUT
+                when "underline", "u", "un", "ul"
+                    formatting = formatting | Curses::A_UNDERLINE
+                when "reverse", "r", "rev", "inverse", "i", "inv"
+                    formatting = formatting | Curses::A_REVERSE
+                when "blink", "bl", "blinking"
+                    formatting = formatting | Curses::A_BLINK
+                when "dim", "d"
+                    formatting = formatting | Curses::A_DIM
+                when "bold", "b", "bo"
+                    formatting = formatting | Curses::A_BOLD
+                else
+                    if ( colour_number = format.to_i ) > Curses::COLOR_WHITE
+                        formatting = formatting | Curses::color_pair( colour_number )
+                    end
+            end
+        end
+        return formatting
+    end
+
+    def toColourConstant
+        retval = Curses::COLOR_WHITE
+        case downcase
+            when "black", "0"
+                retval = Curses::COLOR_BLACK
+            when "red", "1"
+                retval = Curses::COLOR_RED
+            when "green", "2"
+                retval = Curses::COLOR_GREEN
+            when "yellow", "brown", "3"
+                retval = Curses::COLOR_YELLOW
+            when "blue", "4"
+                retval = Curses::COLOR_BLUE
+            when "magenta", "purple", "5"
+                retval = Curses::COLOR_MAGENTA
+            when "cyan", "6"
+                retval = Curses::COLOR_CYAN
+            when "white", "7"
+                retval = Curses::COLOR_WHITE
+        end
+    end
+    
+    def toDirection( default = :down )
+        direction = nil
+        case self
+            when "up"
+                direction = :up
+            when /other/
+                direction = :opposite
+            when "down"
+                direction = :down
+            when "forward"
+                direction = :forward
+            when "backward"
+                direction = :backward
+            else
+                direction = default
+        end
+        return direction
+    end
+    
+    def to_a
+        return [ self ]
+    end
+
+    def to_b
+        retval = false
+        case downcase
+            when "true", "t", "1", "yes", "y", "on", "+"
+                retval = true
+        end
+        return retval
+    end
+
+    def indentation_level( indent_size, indent_roundup, tab_size = Diakonos::DEFAULT_TAB_SIZE, indent_ignore_charset = nil )
+        if indent_ignore_charset == nil
+            level = 0
+            if self =~ /^([\s]+)/
+                #whitespace = $1.gsub( /\t/, ' ' * tab_size )
+                whitespace = $1.expandTabs( tab_size )
+                level = whitespace.length / indent_size
+                if indent_roundup and ( whitespace.length % indent_size > 0 )
+                    level += 1
+                end
+            end
+        else
+            if self =~ /^[\s#{indent_ignore_charset}]*$/ or self == ""
+                level = -1
+            elsif self =~ /^([\s#{indent_ignore_charset}]+)/
+                #whitespace = $1.gsub( /\t/, ' ' * tab_size )
+                whitespace = $1.expandTabs( tab_size )
+                level = whitespace.length / indent_size
+                if indent_roundup and ( whitespace.length % indent_size > 0 )
+                    level += 1
+                end
+            else
+                level = 0
+            end
+        end
+        
+        return level
+    end
+    
+    def expandTabs( tab_size = Diakonos::DEFAULT_TAB_SIZE )
+        s = dup
+        while s.sub!( /\t/ ) { |match_text|
+                match = Regexp.last_match
+                index = match.begin( 0 )
+                # Return value for block:
+                " " * ( tab_size - ( index % tab_size ) )
+            }
+        end
+        return s
+    end
+    
+    def newlineSplit
+        retval = split( /\\n/ )
+        if self =~ /\\n$/
+            retval << ""
+        end
+        if retval.length > 1
+            retval[ 0 ] << "$"
+            retval[ 1..-2 ].collect do |el|
+                "^" << el << "$"
+            end
+            retval[ -1 ] = "^" << retval[ -1 ]
+        end
+        return retval
+    end
+    
+    # Works like normal String#index except returns the index
+    # of the first matching regexp group if one or more groups are specified
+    # in the regexp. Both the index and the matched text are returned.
+    def group_index( regexp, offset = 0 )
+        if regexp.class != Regexp
+            return index( regexp, offset )
+        end
+        
+        i = nil
+        match_text = nil
+        working_offset = 0
+        loop do
+            index( regexp, working_offset )
+            match = Regexp.last_match
+            if match
+                i = match.begin( 0 )
+                match_text = match[ 0 ]
+                if match.length > 1
+                    # Find first matching group
+                    1.upto( match.length - 1 ) do |match_item_index|
+                        if match[ match_item_index ] != nil
+                            i = match.begin( match_item_index )
+                            match_text = match[ match_item_index ]
+                            break
+                        end
+                    end
+                end
+                
+                break if i >= offset
+            else
+                i = nil
+                break
+            end
+            working_offset += 1
+        end
+        
+        return i, match_text
+    end
+    
+    # Works like normal String#rindex except returns the index
+    # of the first matching regexp group if one or more groups are specified
+    # in the regexp. Both the index and the matched text are returned.
+    def group_rindex( regexp, offset = length )
+        if regexp.class != Regexp
+            return rindex( regexp, offset )
+        end
+        
+        i = nil
+        match_text = nil
+        working_offset = length
+        loop do
+            rindex( regexp, working_offset )
+            match = Regexp.last_match
+            if match
+                i = match.end( 0 ) - 1
+                match_text = match[ 0 ]
+                if match.length > 1
+                    # Find first matching group
+                    1.upto( match.length - 1 ) do |match_item_index|
+                        if match[ match_item_index ] != nil
+                            i = match.end( match_item_index ) - 1
+                            match_text = match[ match_item_index ]
+                            break
+                        end
+                    end
+                end
+                
+                if match_text == ""
+                    # Assume that an empty string means that it matched $
+                    i += 1
+                end
+                
+                break if i <= offset
+            else
+                i = nil
+                break
+            end
+            working_offset -= 1
+        end
+        
+        return i, match_text
+    end
+    
+    def movement?
+        return ( ( self =~ /^((cursor|page|scroll)(Up|Down|Left|Right)|find)/ ) != nil )
+    end
+end
+

data/lib/diakonos/text-mark.rb

@@ -0,0 +1,19 @@
+module Diakonos
+
+class TextMark
+    attr_reader :formatting, :start_row, :start_col, :end_row, :end_col
+
+    def initialize( start_row, start_col, end_row, end_col, formatting )
+        @start_row = start_row
+        @start_col = start_col
+        @end_row = end_row
+        @end_col = end_col
+        @formatting = formatting
+    end
+
+    def to_s
+        return "(#{start_row},#{start_col})-(#{end_row},#{end_col}) #{formatting}"
+    end
+end
+
+end

data/lib/diakonos/window.rb

@@ -0,0 +1,32 @@
+class Curses::Window
+    def puts( string = "" )
+        addstr( string + "\n" )
+    end
+    
+    # setpos, but with some boundary checks
+    def setpos_( y, x )
+        $diakonos.debugLog "setpos: y < 0 (#{y})" if y < 0
+        $diakonos.debugLog "setpos: x < 0 (#{x})" if x < 0
+        $diakonos.debugLog "setpos: y > lines (#{y})" if y > Curses::lines
+        $diakonos.debugLog "setpos: x > cols (#{x})" if x > Curses::cols
+        setpos( y, x )
+    end
+    
+    def addstr_( string )
+        x = curx
+        y = cury
+        x2 = curx + string.length
+        
+        if y < 0 or x < 0 or y > Curses::lines or x > Curses::cols or x2 < 0 or x2 > Curses::cols
+            begin
+                raise Exception
+            rescue Exception => e
+                $diakonos.debugLog e.backtrace[ 1 ]
+                $diakonos.debugLog e.backtrace[ 2 ]
+            end
+        end
+        
+        addstr( string )
+    end
+end
+

data/test/buffer-test.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'diakonos'
+
+class TC_Buffer < Test::Unit::TestCase
+    SAMPLE_FILE = File.dirname( File.expand_path( __FILE__ ) ) + '/sample-file.rb'
+    
+    def setup
+        @d = Diakonos::Diakonos.new [ '-e', 'quit' ]
+        @d.start
+    end
+    
+    def teardown
+        system "reset"
+    end
+    
+    def test_selected_text
+        @d.openFile( SAMPLE_FILE )
+        b = Diakonos::Buffer.new( @d, SAMPLE_FILE )
+        @d.anchorSelection
+        @d.cursorDown
+        @d.cursorDown
+        @d.cursorDown
+        @d.copySelection
+        assert_equal(
+            [
+                "#!/usr/bin/env ruby",
+                "",
+                "# This is only a sample file used in the tests.",
+                ""
+            ],
+            @d.clipboard.clip
+        )
+    end
+    
+end