diakonos 0.8.11 → 0.9.9

data/lib/diakonos/buffer/selection.rb

@@ -0,0 +1,360 @@
+module Diakonos
+
+  class Buffer
+
+    # @mark_start[ "col" ] is inclusive,
+    # @mark_end[ "col" ] is exclusive.
+    def record_mark_start_and_end
+      if @mark_anchor.nil?
+        @text_marks[ :selection ] = nil
+        return
+      end
+
+      crow = @last_row
+      ccol = @last_col
+      arow = @mark_anchor[ 'row' ]
+      acol = @mark_anchor[ 'col' ]
+
+      case @selection_mode
+      when :normal
+        anchor_first = true
+
+        if crow < arow
+          anchor_first = false
+        elsif crow > arow
+          anchor_first = true
+        else
+          if ccol < acol
+            anchor_first = false
+          end
+        end
+
+        if anchor_first
+          @text_marks[ :selection ] = TextMark.new( ::Diakonos::Range.new(arow, acol, crow, ccol), @selection_formatting )
+        else
+          @text_marks[ :selection ] = TextMark.new( ::Diakonos::Range.new(crow, ccol, arow, acol), @selection_formatting )
+        end
+      when :block
+        if crow < arow
+          if ccol < acol # Northwest
+            @text_marks[ :selection ] = TextMark.new( ::Diakonos::Range.new(crow, ccol, arow, acol), @selection_formatting )
+          else           # Northeast
+            @text_marks[ :selection ] = TextMark.new( ::Diakonos::Range.new(crow, acol, arow, ccol), @selection_formatting )
+          end
+        else
+          if ccol < acol  # Southwest
+            @text_marks[ :selection ] = TextMark.new( ::Diakonos::Range.new(arow, ccol, crow, acol), @selection_formatting )
+          else            # Southeast
+            @text_marks[ :selection ] = TextMark.new( ::Diakonos::Range.new(arow, acol, crow, ccol), @selection_formatting )
+          end
+        end
+      end
+    end
+
+    def selection_mark
+      @text_marks[:selection]
+    end
+
+    def selecting?
+      !! selection_mark
+    end
+
+    def select_current_line
+      selection_mode_normal
+      anchor_selection( @last_row, 0, DONT_DISPLAY )
+      if @last_row == @lines.size - 1
+        row = @last_row
+        col = @lines[ @last_row ].size
+      else
+        row = @last_row + 1
+        col = 0
+      end
+      cursor_to( row, col, DO_DISPLAY )
+    end
+
+    def set_selection_current_line
+      @text_marks[ :selection ] = TextMark.new(
+        ::Diakonos::Range.new(@last_row, 0, @last_row, @lines[ @last_row ].size),
+        @selection_formatting
+      )
+      @lines[ @last_row ]
+    end
+
+    def select_all
+      selection_mode_normal
+      anchor_selection( 0, 0, DONT_DISPLAY )
+      cursor_to( @lines.length - 1, @lines[ -1 ].length, DO_DISPLAY )
+    end
+
+    def select_wrapping_block
+      block_level = indentation_level( @last_row )
+      if selecting?
+        block_level -= 1
+      end
+      if block_level <= 0
+        return select_all
+      end
+
+      end_row = start_row = @last_row
+
+      # Find block end
+      ( @last_row...@lines.size ).each do |row|
+        next  if @lines[ row ].strip.empty?
+        if indentation_level( row ) < block_level
+          end_row = row
+          break
+        end
+      end
+
+      # Go to block beginning
+      ( 0...@last_row ).reverse_each do |row|
+        next  if @lines[ row ].strip.empty?
+        if indentation_level( row ) < block_level
+          start_row = row + 1
+          break
+        end
+      end
+
+      anchor_selection( end_row, 0 )
+      cursor_to( start_row, 0, DO_DISPLAY )
+    end
+
+    def select_word
+      coords = word_under_cursor_pos( or_after: true )
+      if coords.nil?
+        remove_selection
+      else
+        cursor_to *coords[0]
+        anchor_selection
+        cursor_to *coords[1]
+        display
+      end
+    end
+
+    def select_word_another
+      m = selection_mark
+      if m.nil?
+        select_word
+      else
+        row, col, _ = pos_of_next( /\w\b/, @last_row, @last_col )
+        if row && col
+          cursor_to row, col+1, DO_DISPLAY
+        end
+      end
+    end
+
+    def select( from_regexp, to_regexp, include_ending = true )
+      start_row = nil
+
+      @lines[ 0..@last_row ].reverse.each_with_index do |line,index|
+        if line =~ from_regexp
+          start_row = @last_row - index
+          break
+        end
+      end
+      if start_row
+        end_row = nil
+        @lines[ start_row..-1 ].each_with_index do |line,index|
+          if line =~ to_regexp
+            end_row = start_row + index
+            break
+          end
+        end
+        if end_row
+          if include_ending
+            end_row += 1
+          end
+          anchor_selection( start_row, 0, DONT_DISPLAY )
+          cursor_to( end_row, 0 )
+          display
+        end
+      end
+    end
+
+    def set_selection( start_row, start_col, end_row, end_col )
+      @text_marks[ :selection ] = TextMark.new( ::Diakonos::Range.new(start_row, start_col, end_row, end_col), @selection_formatting )
+      @changing_selection = false
+    end
+
+    def anchor_selection( row = @last_row, col = @last_col, do_display = DO_DISPLAY )
+      @mark_anchor = ( @mark_anchor || Hash.new )
+      @mark_anchor[ "row" ] = row
+      @mark_anchor[ "col" ] = col
+      record_mark_start_and_end
+      @changing_selection = true
+      @auto_anchored = false
+      display  if do_display
+    end
+
+    def anchor_unanchored_selection(*args)
+      if @mark_anchor.nil?
+        anchor_selection *args
+        @changing_selection = false
+      end
+      @auto_anchored = true
+    end
+
+    def remove_selection( do_display = DO_DISPLAY )
+      return  if selection_mark.nil?
+      @mark_anchor = nil
+      record_mark_start_and_end
+      @changing_selection = false
+      @last_finding = nil
+      display  if do_display
+    end
+
+    def toggle_selection
+      if @changing_selection
+        remove_selection
+      else
+        anchor_selection
+      end
+    end
+
+    def copy_selection
+      selected_text
+    end
+
+    # @return [Array<String>, nil]
+    def selected_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
+        if @selection_mode == :block
+          @lines[ selection.start_row .. selection.end_row ].collect { |line|
+            line[ selection.start_col ... selection.end_col ]
+          }
+        else
+          [ @lines[ selection.start_row ][ selection.start_col..-1 ] ] +
+            ( @lines[ (selection.start_row + 1) .. (selection.end_row - 1) ] || [] ) +
+            [ @lines[ selection.end_row ][ 0...selection.end_col ] ]
+        end
+      end
+    end
+
+    def selected_string
+      lines = selected_text
+      if lines
+        lines.join( "\n" )
+      else
+        nil
+      end
+    end
+
+    def selected_lines
+      selection = selection_mark
+      if selection
+        if selection.end_col == 0
+          end_row = selection.end_row - 1
+        else
+          end_row = selection.end_row
+        end
+        @lines[ selection.start_row..end_row ]
+      else
+        [ @lines[ @last_row ] ]
+      end
+    end
+
+    def selection_mode_block
+      @selection_mode = :block
+    end
+    def selection_mode_normal
+      @selection_mode = :normal
+    end
+
+    def delete_selection( do_display = DO_DISPLAY )
+      return  if @text_marks[ :selection ].nil?
+
+      take_snapshot
+
+      selection  = @text_marks[ :selection ]
+      start_row  = selection.start_row
+      start_col  = selection.start_col
+      end_row    = selection.end_row
+      end_col    = selection.end_col
+      start_line = @lines[ start_row ]
+
+      if end_row == selection.start_row
+        @lines[ start_row ] = start_line[ 0...start_col ] + start_line[ end_col..-1 ]
+      else
+        case @selection_mode
+        when :normal
+          end_line = @lines[ end_row ]
+          @lines[ start_row ] = start_line[ 0...start_col ] + end_line[ end_col..-1 ]
+          @lines = @lines[ 0..start_row ] + @lines[ (end_row + 1)..-1 ]
+        when :block
+          @lines[ start_row..end_row ] = @lines[ start_row..end_row ].collect { |line|
+            line[ 0...start_col ] + ( line[ end_col..-1 ] || '' )
+          }
+        end
+      end
+
+      cursor_to start_row, start_col
+      remove_selection DONT_DISPLAY
+      set_modified do_display
+    end
+
+    # text is an array of Strings, or a String with zero or more newlines ("\n")
+    def paste( text, typing = ! TYPING, do_parsed_indent = false )
+      return  if text.nil?
+
+      if ! text.kind_of?(Array)
+        s = text.to_s
+        if s.include?( "\n" )
+          text = s.split( "\n", -1 )
+        else
+          text = [ s ]
+        end
+      end
+
+      take_snapshot typing
+
+      delete_selection DONT_DISPLAY
+
+      row = @last_row
+      col = @last_col
+      new_col = nil
+      line = @lines[ row ]
+      if text.length == 1
+        @lines[ row ] = line[ 0...col ] + text[ 0 ] + line[ col..-1 ]
+        if do_parsed_indent
+          parsed_indent  row: row, do_display: false
+        end
+        cursor_to( @last_row, @last_col + text[ 0 ].length, DONT_DISPLAY, ! typing )
+      elsif text.length > 1
+
+        case @selection_mode
+        when :normal
+          @lines[ row ] = line[ 0...col ] + text[ 0 ]
+          @lines[ row + 1, 0 ] = text[ -1 ] + line[ col..-1 ]
+          @lines[ row + 1, 0 ] = text[ 1..-2 ]
+          new_col = column_of( text[ -1 ].length )
+        when :block
+          @lines += [ '' ] * [ 0, ( row + text.length - @lines.length ) ].max
+          @lines[ row...( row + text.length ) ] = @lines[ row...( row + text.length ) ].collect.with_index { |line,index|
+            pre = line[ 0...col ].ljust( col )
+            post = line[ col..-1 ]
+            "#{pre}#{text[ index ]}#{post}"
+          }
+          new_col = col + text[ -1 ].length
+        end
+
+        new_row = @last_row + text.length - 1
+        if do_parsed_indent
+          ( row..new_row ).each do |r|
+            parsed_indent  row: r, do_display: false
+          end
+        end
+        cursor_to( new_row, new_col )
+
+      end
+
+      set_modified
+    end
+
+  end
+
+end

data/lib/diakonos/buffer/undo.rb

@@ -0,0 +1,73 @@
+module Diakonos
+
+  class Buffer
+
+    DO_USE_MD5 = true
+    DONT_USE_MD5 = false
+
+    def take_snapshot( typing = false )
+      do_it = false
+
+      if ! @modified && file_modified? && file_different?
+        return  if $diakonos.revert( "File has been altered externally.  Load on-disk version?" )
+      end
+
+      if @typing != typing
+        @typing = typing
+        # If we just started typing, take a snapshot, but don't continue
+        # taking snapshots for every keystroke
+        if typing
+          do_it = true
+        end
+      end
+      if ! @typing
+        do_it = true
+      end
+
+      if do_it
+        undo_size = 0
+        @buffer_states[ 1..-1 ].each do |state|
+          undo_size += state.length
+        end
+        while ( ( undo_size + @lines.length ) >= @settings[ "max_undo_lines" ] ) && @buffer_states.length > 1
+          @cursor_states.pop
+          popped_state = @buffer_states.pop
+          undo_size = undo_size - popped_state.length
+        end
+
+        if @current_buffer_state > 0
+          @buffer_states.unshift @lines.deep_clone
+          @cursor_states.unshift [ @last_row, @last_col ]
+        end
+
+        @buffer_states.unshift @lines.deep_clone
+        @cursor_states.unshift [ @last_row, @last_col ]
+        @current_buffer_state = 0
+        @lines = @buffer_states[ @current_buffer_state ]
+      end
+    end
+
+    def undo
+      return  if @current_buffer_state >= @buffer_states.length - 1
+
+      @current_buffer_state += 1
+      @lines = @buffer_states[ @current_buffer_state ]
+      cursor_to( @cursor_states[ @current_buffer_state - 1 ][ 0 ], @cursor_states[ @current_buffer_state - 1 ][ 1 ] )
+      $diakonos.set_iline "Undo level: #{@current_buffer_state} of #{@buffer_states.length - 1}"
+      set_modified DO_DISPLAY, DO_USE_MD5
+    end
+
+    # Since redo is a Ruby keyword...
+    def unundo
+      return  if @current_buffer_state <= 0
+
+      @current_buffer_state += -1
+      @lines = @buffer_states[ @current_buffer_state ]
+      cursor_to( @cursor_states[ @current_buffer_state ][ 0 ], @cursor_states[ @current_buffer_state ][ 1 ] )
+      $diakonos.set_iline "Undo level: #{@current_buffer_state} of #{@buffer_states.length - 1}"
+      set_modified DO_DISPLAY, DO_USE_MD5
+    end
+
+  end
+
+end

data/lib/diakonos/buffer-hash.rb

@@ -0,0 +1,60 @@
+# A Hash which is iterated in insertion order.
+# Keys are assumed to be paths; these paths are expanded on read and write.
+class BufferHash < Hash
+  def initialize
+    @keys_ = []
+  end
+
+  def [] ( key )
+    super File.expand_path( key.to_s )
+  end
+
+  def []= ( key, value )
+    key = File.expand_path( key.to_s )
+    if ! @keys_.include?( key )
+      @keys_ << key
+    end
+    super key, value
+  end
+
+  def each
+    @keys_.each do |key|
+      yield key, self[ key ]
+    end
+  end
+
+  def each_key
+    @keys_.each do |key|
+      yield key
+    end
+  end
+
+  def each_value
+    @keys_.each do |key|
+      yield self[ key ]
+    end
+  end
+
+  def clear
+    @keys_ = []
+    super
+  end
+
+  def delete( key )
+    @keys_.delete key
+    super
+  end
+
+  def keys
+    @keys_.dup
+  end
+
+  def values
+    @keys_.map { |key| self[ key ] }
+  end
+
+  def length
+    @keys_.length
+  end
+end
+

data/lib/diakonos/buffer-management.rb

@@ -0,0 +1,59 @@
+module Diakonos
+  class Diakonos
+    attr_reader :buffer_current
+
+    # @param [Buffer] the Buffer to switch to
+    # @option opts [Boolean] :do_display
+    #   Whether or not to update the display after closure
+    # @return [Boolean] true iff the buffer was successfully switched to
+    def switch_to( buffer, opts = {} )
+      return false  if buffer.nil?
+      do_display = opts.fetch( :do_display, true )
+
+      @buffer_stack -= [ @buffer_current ]
+      if @buffer_current
+        @buffer_stack.push @buffer_current
+      end
+      @buffer_current = buffer
+      @session.buffer_current = buffer_to_number( buffer )
+      run_hook_procs( :after_buffer_switch, buffer )
+      if do_display
+        update_status_line
+        update_context_line
+        display_buffer buffer
+      end
+
+      true
+    end
+
+    # @param [Integer] buffer_number should be 1-based, not zero-based.
+    # @return nil if no such buffer exists.
+    def buffer_number_to_name( buffer_number )
+      return nil  if buffer_number < 1
+
+      b = @buffers[ buffer_number - 1 ]
+      if b
+        b.name
+      end
+    end
+
+    # @return [Integer] 1-based, not zero-based.
+    # @return nil if no such buffer exists.
+    def buffer_to_number( buffer )
+      i = @buffers.index( buffer )
+      if i
+        i + 1
+      end
+    end
+
+    def show_buffer_file_diff( buffer = @buffer_current )
+      current_text_file = @diakonos_home + '/current-buffer'
+      buffer.save_copy( current_text_file )
+      `#{@settings[ 'diff_command' ]} #{current_text_file} #{buffer.name} > #{@diff_filename}`
+      diff_buffer = open_file( @diff_filename )
+      yield diff_buffer
+      close_buffer diff_buffer
+    end
+
+  end
+end