diakonos 0.8.11 → 0.9.8

data/lib/diakonos/functions/cursor.rb

@@ -0,0 +1,264 @@
+module Diakonos
+
+  CLEAR_STACK_POINTER = true
+  DONT_CLEAR_STACK_POINTER = false
+  DIFFERENT_FILE = true
+  NOT_DIFFERENT_FILE = false
+
+  module Functions
+
+    # @return [true,false] true iff the cursor changed positions
+    def cursor_down
+      buffer_current.cursor_to(
+        buffer_current.last_row + 1,
+        buffer_current.last_col,
+        Buffer::DO_DISPLAY,
+        Buffer::STOPPED_TYPING,
+        DONT_ADJUST_ROW
+      )
+    end
+
+    # @return [true,false] true iff the cursor changed positions
+    def cursor_left( stopped_typing = Buffer::STOPPED_TYPING )
+      buffer_current.cursor_to(
+        buffer_current.last_row,
+        buffer_current.last_col - 1,
+        Buffer::DO_DISPLAY,
+        stopped_typing
+      )
+    end
+
+    # Pops the cursor stack.
+    # @param [Symbol] direction
+    #   Either :backward (default) or :forward.
+    # @param [Boolean] different_file
+    #   Whether to pop just one frame (default), or many frames until a different file is reached.
+    # @see Diakonos::DIFFERENT_FILE
+    # @see Diakonos::NOT_DIFFERENT_FILE
+    def cursor_return( direction = :backward, different_file = NOT_DIFFERENT_FILE )
+      delta = 0
+      if @cursor_stack_pointer.nil?
+        push_cursor_state(
+          buffer_current.top_line,
+          buffer_current.last_row,
+          buffer_current.last_col,
+          DONT_CLEAR_STACK_POINTER
+        )
+        delta = 1
+      end
+
+      orig_ptr = @cursor_stack_pointer
+      case direction
+      when :backward
+        @cursor_stack_pointer = ( @cursor_stack_pointer || @cursor_stack.length ) - 1 - delta
+        while different_file && @cursor_stack[ @cursor_stack_pointer ] && @cursor_stack[ @cursor_stack_pointer ][ :buffer ] == buffer_current
+          @cursor_stack_pointer -= 1
+        end
+      when :forward
+        @cursor_stack_pointer = ( @cursor_stack_pointer || 0 ) + 1
+        while different_file && @cursor_stack[ @cursor_stack_pointer ] && @cursor_stack[ @cursor_stack_pointer ][ :buffer ] == buffer_current
+          @cursor_stack_pointer += 1
+        end
+      end
+      if @cursor_stack[ @cursor_stack_pointer ].nil? && orig_ptr
+        @cursor_stack_pointer = orig_ptr
+      end
+
+      return_pointer = @cursor_stack_pointer
+
+      if @cursor_stack_pointer < 0
+        return_pointer = @cursor_stack_pointer = 0
+      elsif @cursor_stack_pointer >= @cursor_stack.length
+        return_pointer = @cursor_stack_pointer = @cursor_stack.length - 1
+      else
+        cursor_state = @cursor_stack[ @cursor_stack_pointer ]
+        if cursor_state
+          buffer = cursor_state[ :buffer ]
+          switch_to buffer
+          buffer.pitch_view( cursor_state[ :top_line ] - buffer.top_line, Buffer::DONT_PITCH_CURSOR, Buffer::DO_DISPLAY )
+          buffer.cursor_to( cursor_state[ :row ], cursor_state[ :col ] )
+          update_status_line
+        end
+      end
+
+      set_iline "Location: #{return_pointer+1}/#{@cursor_stack.size}"
+    end
+
+    # @return [true,false] true iff the cursor changed positions
+    def cursor_right( stopped_typing = Buffer::STOPPED_TYPING, amount = 1 )
+      buffer_current.cursor_to(
+        buffer_current.last_row,
+        buffer_current.last_col + amount,
+        Buffer::DO_DISPLAY,
+        stopped_typing
+      )
+    end
+
+    # @return [true,false] true iff the cursor changed positions
+    def cursor_up
+      buffer_current.cursor_to(
+        buffer_current.last_row - 1,
+        buffer_current.last_col,
+        Buffer::DO_DISPLAY,
+        Buffer::STOPPED_TYPING,
+        DONT_ADJUST_ROW
+      )
+    end
+
+    # Moves the cursor to the beginning of the current buffer.
+    # @return [true,false] true iff the cursor changed positions
+    def cursor_bof
+      buffer_current.cursor_to( 0, 0, Buffer::DO_DISPLAY )
+    end
+
+    # Moves the cursor to the beginning of the current line.
+    def cursor_bol
+      buffer_current.cursor_to_bol
+    end
+
+    # Moves the cursor to the end of the current line.
+    def cursor_eol
+      buffer_current.cursor_to_eol
+    end
+
+    # Moves the cursor to the end of the current buffer.
+    def cursor_eof
+      buffer_current.cursor_to_eof
+    end
+
+    # Moves the cursor to the top of the viewport of the current buffer.
+    def cursor_tov
+      buffer_current.cursor_to_tov
+    end
+
+    # Moves the cursor to the bottom of the viewport of the current buffer.
+    def cursor_bov
+      buffer_current.cursor_to_bov
+    end
+
+    # Moves the cursor to the beginning of the parent code block.
+    def go_block_outer
+      buffer_current.go_block_outer
+    end
+    # Moves the cursor to the beginning of the first child code block.
+    def go_block_inner
+      buffer_current.go_block_inner
+    end
+    # Moves the cursor to the beginning of the next code block at the same
+    # indentation level as the current one.
+    def go_block_next
+      buffer_current.go_block_next
+    end
+    # Moves the cursor to the beginning of the previous code block at the same
+    # indentation level as the current one.
+    def go_block_previous
+      buffer_current.go_block_previous
+    end
+
+    # Moves the cursor to the next occurrence of the given character.
+    # @param [String] char  The character to go to
+    def go_to_char( after = nil, char = nil )
+      char ||= @interaction_handler.get_char( "Type character to go to..." )
+
+      if char
+        begin
+          moved = buffer_current.go_to_char( char, after == :after ? AFTER_CHAR : ON_CHAR )
+          if ! moved
+            set_iline "'#{char}' not found."
+          end
+        rescue TypeError
+          # User pressed Esc, or Ctrl-C, or similar.
+          # Quietly continue.
+        end
+      end
+    end
+
+    # Moves the cursor to the closest previous occurrence of the given character.
+    # @param [String] char  The character to go to
+    def go_to_char_previous( after = nil, char = nil )
+      char ||= @interaction_handler.get_char( "Type character to go to..." )
+
+      if char
+        begin
+          moved = buffer_current.go_to_char_previous( char, after == :after ? AFTER_CHAR : ON_CHAR )
+          if ! moved
+            set_iline "'#{char}' not found."
+          end
+        rescue TypeError
+          # User pressed Esc, or Ctrl-C, or similar.
+          # Quietly continue.
+        end
+      end
+    end
+
+    # Prompts the user for a line number or line delta, with optional column
+    # number.  Moves the cursor there.
+    def go_to_line_ask
+      input = get_user_input( "Go to [line number|+lines][,column number]: " )
+      if input
+        row = nil
+        col = 0
+
+        if input =~ /([+-]\d+)/
+          row = buffer_current.last_row + $1.to_i
+          col = buffer_current.last_col
+        else
+          input = input.split( /\D+/ ).collect { |n| n.to_i }
+          if input.size > 0
+            if input[ 0 ] == 0
+              row = nil
+            else
+              row = input[ 0 ] - 1
+            end
+            if input[ 1 ]
+              col = input[ 1 ] - 1
+            end
+          end
+        end
+
+        if row
+          buffer_current.go_to_line( row, col )
+        end
+      end
+    end
+
+    # Pitches the current buffer's view one screenful down.
+    def page_down
+      if buffer_current.pitch_view( main_window_height, Buffer::DO_PITCH_CURSOR ) == 0
+        buffer_current.cursor_to_eof
+      end
+      update_status_line
+      update_context_line
+    end
+
+    # Pitches the current buffer's view one screenful up.
+    def page_up
+      if buffer_current.pitch_view( -main_window_height, Buffer::DO_PITCH_CURSOR ) == 0
+        cursor_bof
+      end
+      update_status_line
+      update_context_line
+    end
+
+    # Scrolls the current buffer's view down, as determined by the
+    # view.scroll_amount setting.
+    def scroll_down
+      buffer_current.pitch_view( @settings[ "view.scroll_amount" ] || 1 )
+      update_status_line
+      update_context_line
+    end
+
+    # Scrolls the current buffer's view up, as determined by the
+    # view.scroll_amount setting.
+    def scroll_up
+      if @settings[ "view.scroll_amount" ]
+        buffer_current.pitch_view( -@settings[ "view.scroll_amount" ] )
+      else
+        buffer_current.pitch_view( -1 )
+      end
+      update_status_line
+      update_context_line
+    end
+
+  end
+end

data/lib/diakonos/functions/grepping.rb

@@ -0,0 +1,83 @@
+module Diakonos
+  module Functions
+
+    def grep( regexp_source = nil )
+      grep_( regexp_source, buffer_current )
+    end
+
+    def grep_buffers( regexp_source = nil )
+      grep_( regexp_source, *@buffers )
+    end
+
+    def grep_session_dir( regexp_source = nil )
+      grep_dir regexp_source, @session.dir
+    end
+
+    def grep_dir( regexp_source = nil, dir = nil )
+      if dir.nil?
+        dir = get_user_input(
+          "Grep directory: ",
+          history: @rlh_files,
+          initial_text: @session.dir,
+          do_complete: DONT_COMPLETE,
+          on_dirs: :accept_dirs
+        )
+        return if dir.nil?
+      end
+      dir = File.expand_path( dir )
+
+      original_buffer = buffer_current
+      if buffer_current.changing_selection
+        selected_text = buffer_current.copy_selection[ 0 ]
+      end
+      starting_row, starting_col = buffer_current.last_row, buffer_current.last_col
+
+      selected = get_user_input(
+        "Grep regexp: ",
+        history: @rlh_search,
+        initial_text: regexp_source || selected_text || ""
+      ) { |input|
+        next if input.length < 2
+        escaped_input = input.gsub( /'/ ) { "\\047" }
+        matching_files = `egrep '#{escaped_input}' -rniIl #{dir}`.split( /\n/ )
+
+        grep_results = matching_files.map { |f|
+          ::Diakonos.grep_array(
+            Regexp.new( input ),
+            File.read( f ).split( /\n/ ),
+            settings[ 'grep.context' ],
+            "#{File.basename( f )}:",
+            f
+          )
+        }.flatten
+        if settings[ 'grep.context' ] == 0
+          join_str = "\n"
+        else
+          join_str = "\n---\n"
+        end
+        with_list_file do |list|
+          list.puts grep_results.join( join_str )
+        end
+
+        list_buffer = open_list_buffer
+        regexp = nil
+        begin
+          list_buffer.highlight_matches Regexp.new( input )
+        rescue RegexpError => e
+          # ignore
+        end
+        display_buffer list_buffer
+      }
+
+      if selected
+        spl = selected.split( "| " )
+        if spl.size > 1
+          open_file spl[ -1 ]
+        end
+      else
+        original_buffer.cursor_to starting_row, starting_col
+      end
+    end
+
+  end
+end

data/lib/diakonos/functions/indentation.rb

@@ -0,0 +1,71 @@
+module Diakonos
+  module Functions
+
+    def indent
+      if ! buffer_current.changing_selection
+        buffer_current.indent
+      else
+        @do_display = false
+        mark = buffer_current.selection_mark
+        if mark.end_col > 0
+          end_row = mark.end_row
+        else
+          end_row = mark.end_row - 1
+        end
+        (mark.start_row..end_row).each do |row|
+          buffer_current.indent row, Buffer::DONT_DISPLAY
+        end
+        @do_display = true
+        display_buffer buffer_current
+      end
+    end
+
+    def insert_spaces( num_spaces )
+      if num_spaces > 0
+        buffer_current.delete_selection
+        buffer_current.insert_string( " " * num_spaces )
+        cursor_right( Buffer::STILL_TYPING, num_spaces )
+      end
+    end
+
+    def insert_tab
+      type_character "\t"
+    end
+
+    def parsed_indent
+      if( buffer_current.changing_selection )
+        @do_display = false
+        mark = buffer_current.selection_mark
+        (mark.start_row..mark.end_row).each do |row|
+          buffer_current.parsed_indent  row: row, do_display: false
+        end
+        @do_display = true
+        display_buffer buffer_current
+      else
+        buffer_current.parsed_indent
+      end
+      update_status_line
+      update_context_line
+    end
+
+    def unindent
+      if( buffer_current.changing_selection )
+        @do_display = false
+        mark = buffer_current.selection_mark
+        if mark.end_col > 0
+          end_row = mark.end_row
+        else
+          end_row = mark.end_row - 1
+        end
+        (mark.start_row..end_row).each do |row|
+          buffer_current.unindent row, Buffer::DONT_DISPLAY
+        end
+        @do_display = true
+        display_buffer buffer_current
+      else
+        buffer_current.unindent
+      end
+    end
+
+  end
+end

data/lib/diakonos/functions/readline.rb

@@ -0,0 +1,93 @@
+module Diakonos
+  module Functions
+
+    def readline_abort
+      @readline.abort
+    end
+
+    def readline_accept
+      @readline.accept current_list_item
+    end
+
+    def readline_backspace
+      @readline.backspace
+    end
+
+    def readline_complete_input
+      @readline.complete_input
+    end
+
+    def readline_cursor_left
+      @readline.cursor_left
+    end
+
+    def readline_cursor_right
+      @readline.cursor_right
+    end
+
+    def readline_cursor_bol
+      @readline.cursor_bol
+    end
+
+    def readline_cursor_eol
+      @readline.cursor_eol
+    end
+
+    def readline_cursor_up
+      if showing_list?
+        if list_item_selected?
+          previous_list_item
+        end
+        @readline.set_input select_list_item
+      else
+        @readline.history_up
+      end
+      @readline.cursor_write_input
+    end
+
+    def readline_cursor_down
+      if showing_list?
+        if list_item_selected?
+          next_list_item
+        end
+        @readline.set_input select_list_item
+      else
+        @readline.history_down
+      end
+      @readline.cursor_write_input
+    end
+
+    def readline_delete
+      @readline.delete
+    end
+
+    def readline_delete_line
+      @readline.delete_line
+    end
+
+    def readline_delete_word
+      @readline.delete_word
+    end
+
+    def readline_grep_context_decrease
+      decrease_grep_context
+      @readline.call_block
+    end
+
+    def readline_grep_context_increase
+      increase_grep_context
+      @readline.call_block
+    end
+
+    def readline_page_down
+      page_down
+      @readline.list_sync select_list_item
+    end
+
+    def readline_page_up
+      page_up
+      @readline.list_sync select_list_item
+    end
+
+  end
+end

data/lib/diakonos/functions/search.rb

@@ -0,0 +1,179 @@
+module Diakonos
+  module Functions
+
+    # Searches for matches of a regular expression in the current buffer.
+    # @param [String] regexp_source_
+    #   The regular expression to search for.
+    # @param [Hash] options
+    #   Options that alter how the search is performed
+    # @option options [Symbol] :direction (:down)
+    #   The direction to search; :down or :up.
+    # @option options [Boolean] :case_sensitive (false)
+    #   Whether or not the search should be case_sensitive.
+    # @option options [String] replacement
+    #   If provided, do a find and replace, and replace matches with replacement.
+    # @option options [Boolean] :word_only (false)
+    #   Whether or not to search with word boundaries
+    # @see #find_exact
+    # @see #find_again
+    # @see #find_clip
+    def find( regexp_source_ = nil, options = {} )
+      direction = options[:direction] || :down
+      case_sensitive = options[:case_sensitive]
+      replacement = options[:replacement]
+      word_only = options[:word_only]
+
+      if regexp_source_
+        regexp_source = regexp_source_
+      else
+        buffer_current.clear_search_area
+        m = buffer_current.selection_mark
+        if m
+          if m.start_row != m.end_row
+            buffer_current.set_search_area buffer_current.selection_mark
+            buffer_current.remove_selection
+          else
+            selected_text = buffer_current.copy_selection[ 0 ]
+          end
+        end
+        starting_row, starting_col = buffer_current.last_row, buffer_current.last_col
+
+        regexp_source = get_user_input(
+          "Search regexp: ",
+          history: @rlh_search,
+          initial_text: selected_text || ""
+        ) { |input|
+          if input.length > 1
+            regexp_source = word_only ? "\\b#{input}\\b" : input
+            find_(
+              direction: direction,
+              case_sensitive: case_sensitive,
+              regexp_source: regexp_source,
+              starting_row: starting_row,
+              starting_col: starting_col,
+              quiet: true
+            )
+          else
+            buffer_current.remove_selection Buffer::DONT_DISPLAY
+            buffer_current.clear_matches Buffer::DO_DISPLAY
+          end
+        }
+      end
+
+      if regexp_source
+        if word_only
+          regexp_source = "\\b#{regexp_source}\\b"
+        end
+        num_replacements = find_(
+          direction: direction,
+          case_sensitive: case_sensitive,
+          regexp_source: regexp_source,
+          replacement: replacement,
+          starting_row: starting_row,
+          starting_col: starting_col,
+          quiet: false
+        )
+        show_number_of_matches_found( replacement ? num_replacements : nil )
+      elsif starting_row && starting_col
+        buffer_current.clear_matches
+        if @settings[ 'find.return_on_abort' ]
+          buffer_current.cursor_to starting_row, starting_col, Buffer::DO_DISPLAY
+        end
+      end
+    end
+
+    # Searches for matches of the latest clipboard item in the current buffer.
+    # Note that the clipboard item is interpreted as a regular expression.
+    # Only the last line of multi-line clipboard items is used.
+    # @param [String] direction
+    #   The direction to search.  :down (default) or :up.
+    # @param [Boolean] case_sensitive
+    #   Whether or not the search should be case_sensitive.  Default is insensitive.
+    # @see #find
+    def find_clip( direction = :down, case_sensitive = CASE_INSENSITIVE )
+      find @clipboard.clip[-1], direction: direction, case_sensitive: case_sensitive
+    end
+
+    # Search again for the most recently sought search term.
+    # @param [String] direction
+    #   The direction to search; :down or :up.
+    # @see #find
+    # @see #find_exact
+    def find_again( direction = :down )
+      if direction
+        buffer_current.find_again( @last_search_regexps, direction )
+      else
+        buffer_current.find_again( @last_search_regexps )
+      end
+      show_number_of_matches_found
+    end
+
+    # Search for an exact string (not a regular expression).
+    # @param [Symbol] direction
+    #   The direction to search; :down (default) or :up.
+    # @param [String] search_term_
+    #   The thing to search for.
+    # @see #find
+    # @see #find_again
+    def find_exact( direction = :down, search_term_ = nil )
+      buffer_current.clear_search_area
+      if search_term_.nil?
+        if buffer_current.changing_selection
+          selected_text = buffer_current.copy_selection[ 0 ]
+        end
+        search_term = get_user_input(
+          "Search for: ",
+          history: @rlh_search,
+          initial_text: selected_text || ""
+        )
+      else
+        search_term = search_term_
+      end
+      if search_term
+        regexp = [ Regexp.new( Regexp.escape( search_term ) ) ]
+        buffer_current.find( regexp, :direction => direction )
+        @last_search_regexps = regexp
+      end
+    end
+
+    # Moves the cursor to the pair match of the current character, if any.
+    def go_to_pair_match
+      buffer_current.go_to_pair_match
+    end
+
+    # Wrapper method for calling #find for search and replace.
+    # @see #find
+    def search_and_replace( case_sensitive = CASE_INSENSITIVE )
+      find nil, case_sensitive: case_sensitive, replacement: ASK_REPLACEMENT
+    end
+    alias_method :find_and_replace, :search_and_replace
+
+    # Immediately moves the cursor to the next match of a regular expression.
+    # The user is not prompted for any value.
+    # @param [String] regexp_source
+    #   The regular expression to search for.
+    # @param [Symbol] direction
+    #   The direction to search; :down (default) or :up.
+    def seek( regexp_source, direction = :down )
+      if regexp_source
+        regexp = Regexp.new( regexp_source )
+        buffer_current.seek( regexp, direction )
+      end
+    end
+
+    def show_number_of_matches_found( num_replacements = nil )
+      return  if buffer_current.num_matches_found.nil?
+
+      num_found = buffer_current.num_matches_found
+      if num_found != 1
+        plural = 'es'
+      end
+      if num_replacements
+        set_iline_if_empty "#{num_replacements} out of #{num_found} match#{plural} replaced"
+      else
+        set_iline_if_empty "#{num_found} match#{plural} found"
+      end
+    end
+
+  end
+end