diakonos 0.8.4 → 0.8.5

data/lib/diakonos/buffer.rb

@@ -1,7 +1,7 @@
 module Diakonos
 
 class Buffer
-    attr_reader :name, :modified, :original_language, :changing_selection, :read_only,
+    attr_reader :name, :key, :modified, :original_language, :changing_selection, :read_only,
         :last_col, :last_row, :tab_size, :last_screen_x, :last_screen_y, :last_screen_col
     attr_writer :desired_column, :read_only
 
@@ -29,9 +29,10 @@ class Buffer
     DONT_STRIP_LINE = false
 
     # Set name to nil to create a buffer that is not associated with a file.
-    def initialize( diakonos, name, read_only = false )
+    def initialize( diakonos, name, key, read_only = false )
         @diakonos = diakonos
         @name = name
+        @key = key
         @modified = false
         @last_modification_check = Time.now
 
@@ -126,7 +127,8 @@ class Buffer
         @closers = @diakonos.closers[ @language ] || Hash.new
         @auto_indent = @settings[ "lang.#{@language}.indent.auto" ]
         @indent_size = ( @settings[ "lang.#{@language}.indent.size" ] or 4 )
-        @indent_roundup = ( @settings[ "lang.#{@language}.indent.roundup" ] or true )
+        @indent_roundup = @settings[ "lang.#{@language}.indent.roundup" ].nil? ? true : @settings[ "lang.#{@language}.indent.roundup" ]
+        @indent_closers = @settings[ "lang.#{@language}.indent.closers" ].nil? ? true : @settings[ "lang.#{@language}.indent.closers" ]
         @default_formatting = ( @settings[ "lang.#{@language}.format.default" ] or Curses::A_NORMAL )
         @selection_formatting = ( @settings[ "lang.#{@language}.format.selection" ] or Curses::A_REVERSE )
         @indent_ignore_charset = ( @settings[ "lang.#{@language}.indent.ignore.charset" ] or "" )
@@ -139,8 +141,8 @@ class Buffer
     end
     
     def == (other)
-        return false if other == nil
-        return ( name == other.name )
+        return false if other.nil?
+        key == other.key
     end
 
     def length
@@ -709,16 +711,22 @@ class Buffer
     end
     
     def close_code
-        line = @lines[ @last_row ]
-        @closers.each_value do |h|
-            h[ :regexp ] =~ line
-            lm = Regexp.last_match
-            if lm
-                insertString h[ :closer ].call( lm ).to_s
-            else
-                @diakonos.log h[ :regexp ].inspect + " does not match '#{line}'"
-            end
+      line = @lines[ @last_row ]
+      @closers.each_value do |h|
+        h[ :regexp ] =~ line
+        lm = Regexp.last_match
+        if lm
+          str = h[ :closer ].call( lm ).to_s
+          r, c = @last_row, @last_col
+          paste str, @indent_closers
+          cursorTo r, c
+          if /%_/ === str
+            find( [ /%_/ ], :down, '', CHOICE_YES_AND_STOP )
+          end
+        else
+          @diakonos.log h[ :regexp ].inspect + " does not match '#{line}'"
         end
+      end
     end
     
     def collapseWhitespace
@@ -1053,6 +1061,31 @@ class Buffer
         end
         cursorTo( row, col, DO_DISPLAY )
     end
+    
+    def cursorToEOL
+      y = @win_main.cury
+      end_col = lineAt( y ).length
+      last_char_col = lineAt( y ).rstrip.length
+      case @settings[ 'eol_behaviour' ]
+      when EOL_END
+        col = end_col
+      when EOL_LAST_CHAR
+        col = last_char_col
+      when EOL_ALT_LAST_CHAR
+        if @last_col == last_char_col
+          col = end_col
+        else
+          col = last_char_col
+        end
+      else
+        if @last_col == end_col
+          col = last_char_col
+        else
+          col = end_col
+        end
+      end
+      cursorTo( @last_row, col, DO_DISPLAY )
+    end
 
     # Top of view
     def cursorToTOV
@@ -1193,29 +1226,27 @@ class Buffer
     end
 
     def copySelection
-        return selected_text
+      selected_text
     end
     def selected_text
-        selection = selection_mark
-        if selection == nil
-            text = nil
-        elsif selection.start_row == selection.end_row
-            text = [ @lines[ selection.start_row ][ selection.start_col...selection.end_col ] ]
-        else
-            text = [ @lines[ selection.start_row ][ selection.start_col..-1 ] ] +
-                ( @lines[ (selection.start_row + 1) .. (selection.end_row - 1) ] or [] ) +
-                [ @lines[ selection.end_row ][ 0...selection.end_col ] ]
-        end
-
-        return text
+      selection = selection_mark
+      if selection.nil?
+        nil
+      elsif selection.start_row == selection.end_row
+        [ @lines[ selection.start_row ][ selection.start_col...selection.end_col ] ]
+      else
+        [ @lines[ selection.start_row ][ selection.start_col..-1 ] ] +
+          ( @lines[ (selection.start_row + 1) .. (selection.end_row - 1) ] or [] ) +
+          [ @lines[ selection.end_row ][ 0...selection.end_col ] ]
+      end
     end
     def selected_string
-        lines = selected_text
-        if lines
-            lines.join( "\n" )
-        else
-            nil
-        end
+      lines = selected_text
+      if lines
+        lines.join( "\n" )
+      else
+        nil
+      end
     end
 
     def deleteSelection( do_display = DO_DISPLAY )
@@ -1241,44 +1272,53 @@ class Buffer
         setModified( do_display )
     end
 
-    # text is an array of Strings
-    def paste( text )
-        return if text == nil
-        
-        if not text.kind_of? Array
-            s = text.to_s
-            if s.include?( "\n" )
-                text = s.split( "\n", -1 )
-            else
-                text = [ s ]
-            end
+    # text is an array of Strings, or a String with zero or more newlines ("\n")
+    def paste( text, do_parsed_indent = false )
+      return if text == nil
+      
+      if not text.kind_of? Array
+        s = text.to_s
+        if s.include?( "\n" )
+          text = s.split( "\n", -1 )
+        else
+          text = [ s ]
         end
-
-        takeSnapshot
-
-        deleteSelection( DONT_DISPLAY )
-
-        row = @last_row
-        col = @last_col
-        line = @lines[ row ]
-        if text.length == 1
-            @lines[ row ] = line[ 0...col ] + text[ 0 ] + line[ col..-1 ]
-            cursorTo( @last_row, @last_col + text[ 0 ].length )
-        elsif text.length > 1
-            @lines[ row ] = line[ 0...col ] + text[ 0 ]
-            @lines[ row + 1, 0 ] = text[ -1 ] + line[ col..-1 ]
-            @lines[ row + 1, 0 ] = text[ 1..-2 ]
-            cursorTo( @last_row + text.length - 1, columnOf( text[ -1 ].length ) )
+      end
+      
+      takeSnapshot
+      
+      deleteSelection( DONT_DISPLAY )
+      
+      row = @last_row
+      col = @last_col
+      line = @lines[ row ]
+      if text.length == 1
+        @lines[ row ] = line[ 0...col ] + text[ 0 ] + line[ col..-1 ]
+        if do_parsed_indent
+          parsedIndent row, DONT_DISPLAY
+        end
+        cursorTo( @last_row, @last_col + text[ 0 ].length )
+      elsif text.length > 1
+        @lines[ row ] = line[ 0...col ] + text[ 0 ]
+        @lines[ row + 1, 0 ] = text[ -1 ] + line[ col..-1 ]
+        @lines[ row + 1, 0 ] = text[ 1..-2 ]
+        new_row = @last_row + text.length - 1
+        if do_parsed_indent
+          ( row..new_row ).each do |r|
+            parsedIndent r, DONT_DISPLAY
+          end
         end
-
-        setModified
+        cursorTo( new_row, columnOf( text[ -1 ].length ) )
+      end
+      
+      setModified
     end
 
     # Takes an array of Regexps, which represents a user-provided regexp,
     # split across newline characters.  Once the first element is found,
     # each successive element must match against lines following the first
     # element.
-    def find( regexps, direction = :down, replacement = nil )
+    def find( regexps, direction = :down, replacement = nil, auto_choice = nil )
         return if regexps.nil?
         regexp = regexps[ 0 ]
         return if regexp == nil or regexp == //
@@ -1296,6 +1336,7 @@ class Buffer
         
         finding = nil
         wrapped = false
+        match = nil
         
         catch :found do
         
@@ -1303,26 +1344,28 @@ class Buffer
                 # Check the current row first.
                 
                 if index = @lines[ @last_row ].index( regexp, ( @last_finding ? @last_finding.start_col : @last_col ) + 1 )
-                    found_text = Regexp.last_match[ 0 ]
-                    finding = Finding.new( @last_row, index, @last_row, index + found_text.length )
-                    if finding.match( regexps, @lines )
-                        throw :found
-                    else
-                        finding = nil
-                    end
+                  match = Regexp.last_match
+                  found_text = match[ 0 ]
+                  finding = Finding.new( @last_row, index, @last_row, index + found_text.length )
+                  if finding.match( regexps, @lines )
+                    throw :found
+                  else
+                    finding = nil
+                  end
                 end
                 
                 # Check below the cursor.
                 
                 ( (@last_row + 1)...@lines.length ).each do |i|
                     if index = @lines[ i ].index( regexp )
-                        found_text = Regexp.last_match[ 0 ]
-                        finding = Finding.new( i, index, i, index + found_text.length )
-                        if finding.match( regexps, @lines )
-                            throw :found
-                        else
-                            finding = nil
-                        end
+                      match = Regexp.last_match
+                      found_text = match[ 0 ]
+                      finding = Finding.new( i, index, i, index + found_text.length )
+                      if finding.match( regexps, @lines )
+                        throw :found
+                      else
+                        finding = nil
+                      end
                     end
                 end
                 
@@ -1332,13 +1375,14 @@ class Buffer
                 
                 ( 0...@last_row ).each do |i|
                     if index = @lines[ i ].index( regexp )
-                        found_text = Regexp.last_match[ 0 ]
-                        finding = Finding.new( i, index, i, index + found_text.length )
-                        if finding.match( regexps, @lines )
-                            throw :found
-                        else
-                            finding = nil
-                        end
+                      match = Regexp.last_match
+                      found_text = match[ 0 ]
+                      finding = Finding.new( i, index, i, index + found_text.length )
+                      if finding.match( regexps, @lines )
+                        throw :found
+                      else
+                        finding = nil
+                      end
                     end
                 end
                 
@@ -1347,13 +1391,14 @@ class Buffer
                 #if index = @lines[ @last_row ].index( regexp, ( @last_finding ? @last_finding.start_col : @last_col ) - 1 )
                 if index = @lines[ @last_row ].index( regexp )
                     if index <= ( @last_finding ? @last_finding.start_col : @last_col )
-                        found_text = Regexp.last_match[ 0 ]
-                        finding = Finding.new( @last_row, index, @last_row, index + found_text.length )
-                        if finding.match( regexps, @lines )
-                            throw :found
-                        else
-                            finding = nil
-                        end
+                      match = Regexp.last_match
+                      found_text = match[ 0 ]
+                      finding = Finding.new( @last_row, index, @last_row, index + found_text.length )
+                      if finding.match( regexps, @lines )
+                        throw :found
+                      else
+                        finding = nil
+                      end
                     end
                 end
                 
@@ -1362,26 +1407,28 @@ class Buffer
                 
                 col_to_check = ( @last_finding ? @last_finding.end_col : @last_col ) - 1
                 if ( col_to_check >= 0 ) and ( index = @lines[ @last_row ][ 0...col_to_check ].rindex( regexp ) )
-                    found_text = Regexp.last_match[ 0 ]
-                    finding = Finding.new( @last_row, index, @last_row, index + found_text.length )
-                    if finding.match( regexps, @lines )
-                        throw :found
-                    else
-                        finding = nil
-                    end
+                  match = Regexp.last_match
+                  found_text = match[ 0 ]
+                  finding = Finding.new( @last_row, index, @last_row, index + found_text.length )
+                  if finding.match( regexps, @lines )
+                    throw :found
+                  else
+                    finding = nil
+                  end
                 end
                 
                 # Check above the cursor.
                 
                 (@last_row - 1).downto( 0 ) do |i|
                     if index = @lines[ i ].rindex( regexp )
-                        found_text = Regexp.last_match[ 0 ]
-                        finding = Finding.new( i, index, i, index + found_text.length )
-                        if finding.match( regexps, @lines )
-                            throw :found
-                        else
-                            finding = nil
-                        end
+                      match = Regexp.last_match
+                      found_text = match[ 0 ]
+                      finding = Finding.new( i, index, i, index + found_text.length )
+                      if finding.match( regexps, @lines )
+                        throw :found
+                      else
+                        finding = nil
+                      end
                     end
                 end
                 
@@ -1391,13 +1438,14 @@ class Buffer
                 
                 (@lines.length - 1).downto(@last_row + 1) do |i|
                     if index = @lines[ i ].rindex( regexp )
-                        found_text = Regexp.last_match[ 0 ]
-                        finding = Finding.new( i, index, i, index + found_text.length )
-                        if finding.match( regexps, @lines )
-                            throw :found
-                        else
-                            finding = nil
-                        end
+                      match = Regexp.last_match
+                      found_text = match[ 0 ]
+                      finding = Finding.new( i, index, i, index + found_text.length )
+                      if finding.match( regexps, @lines )
+                        throw :found
+                      else
+                        finding = nil
+                      end
                     end
                 end
                 
@@ -1406,19 +1454,20 @@ class Buffer
                 search_col = ( @last_finding ? @last_finding.start_col : @last_col ) + 1
                 if index = @lines[ @last_row ].rindex( regexp )
                     if index > search_col
-                        found_text = Regexp.last_match[ 0 ]
-                        finding = Finding.new( @last_row, index, @last_row, index + found_text.length )
-                        if finding.match( regexps, @lines )
-                            throw :found
-                        else
-                            finding = nil
-                        end
+                      match = Regexp.last_match
+                      found_text = match[ 0 ]
+                      finding = Finding.new( @last_row, index, @last_row, index + found_text.length )
+                      if finding.match( regexps, @lines )
+                        throw :found
+                      else
+                        finding = nil
+                      end
                     end
                 end
             end
         end
         
-        if finding != nil
+        if finding
             @diakonos.setILine( "(search wrapped around BOF/EOF)" ) if wrapped
             
             removeSelection( DONT_DISPLAY )
@@ -1441,26 +1490,37 @@ class Buffer
             end
             display
             
-            if replacement != nil
-                choice = @diakonos.getChoice(
-                    "Replace?",
-                    [ CHOICE_YES, CHOICE_NO, CHOICE_ALL, CHOICE_CANCEL, CHOICE_YES_AND_STOP ],
-                    CHOICE_YES
-                )
-                case choice
-                    when CHOICE_YES
-                        paste [ replacement ]
-                        find( regexps, direction, replacement )
-                    when CHOICE_ALL
-                        replaceAll( regexp, replacement )
-                    when CHOICE_NO
-                        find( regexps, direction, replacement )
-                    when CHOICE_CANCEL
-                        # Do nothing further.
-                    when CHOICE_YES_AND_STOP
-                        paste [ replacement ]
-                        # Do nothing further.
+            if replacement
+              # Substitute placeholders (e.g. \1) in str for the group matches of the last match.
+              actual_replacement = replacement.dup
+              actual_replacement.gsub!( /\\(\\|\d+)/ ) { |m|
+                ref = $1
+                if ref == "\\"
+                  "\\"
+                else
+                  match[ ref.to_i ]
                 end
+              }
+              
+              choice = auto_choice || @diakonos.getChoice(
+                "Replace?",
+                [ CHOICE_YES, CHOICE_NO, CHOICE_ALL, CHOICE_CANCEL, CHOICE_YES_AND_STOP ],
+                CHOICE_YES
+              )
+              case choice
+              when CHOICE_YES
+                paste [ actual_replacement ]
+                find( regexps, direction, replacement )
+              when CHOICE_ALL
+                replaceAll( regexp, replacement )
+              when CHOICE_NO
+                find( regexps, direction, replacement )
+              when CHOICE_CANCEL
+                # Do nothing further.
+              when CHOICE_YES_AND_STOP
+                paste [ actual_replacement ]
+                # Do nothing further.
+              end
             end
         else
             @diakonos.setILine "/#{regexp.source}/ not found."