diakonos 0.8.11 → 0.9.9

data/lib/diakonos/functions-deprecated.rb

@@ -0,0 +1,77 @@
+module Diakonos
+
+  class Diakonos
+    alias_method :loadConfiguration,      :load_configuration
+  end
+
+  module Functions
+    alias_method :addNamedBookmark,       :add_named_bookmark
+    alias_method :anchorSelection,        :anchor_selection
+    alias_method :carriageReturn,         :carriage_return
+    alias_method :changeSessionSetting,   :change_session_setting
+    alias_method :clearMatches,           :clear_matches
+    alias_method :closeFile,              :close_buffer
+    alias_method :close_file,             :close_buffer
+    alias_method :collapseWhitespace,     :collapse_whitespace
+    alias_method :copySelection,          :copy_selection
+    alias_method :cursorDown,             :cursor_down
+    alias_method :cursorLeft,             :cursor_left
+    alias_method :cursorRight,            :cursor_right
+    alias_method :cursorUp,               :cursor_up
+    alias_method :cursorBOF,              :cursor_bof
+    alias_method :cursorBOL,              :cursor_bol
+    alias_method :cursorEOL,              :cursor_eol
+    alias_method :cursorEOF,              :cursor_eof
+    alias_method :cursorTOV,              :cursor_tov
+    alias_method :cursorBOV,              :cursor_bov
+    alias_method :cursorReturn,           :cursor_return
+    alias_method :cutSelection,           :cut_selection
+    alias_method :deleteAndStoreLine,     :delete_and_store_line
+    alias_method :deleteLine,             :delete_line
+    alias_method :deleteToEOL,            :delete_to_eol
+    alias_method :findAgain,              :find_again
+    alias_method :findAndReplace,         :search_and_replace
+    alias_method :findExact,              :find_exact
+    alias_method :goToLineAsk,            :go_to_line_ask
+    alias_method :goToNamedBookmark,      :go_to_named_bookmark
+    alias_method :goToNextBookmark,       :go_to_next_bookmark
+    alias_method :goToPreviousBookmark,   :go_to_previous_bookmark
+    alias_method :goToTag,                :go_to_tag
+    alias_method :goToTagUnderCursor,     :go_to_tag_under_cursor
+    alias_method :insertSpaces,           :insert_spaces
+    alias_method :insertTab,              :insert_tab
+    alias_method :joinLines,              :join_lines
+    alias_method :loadScript,             :load_script
+    alias_method :newFile,                :open_file
+    alias_method :openFile,               :open_file
+    alias_method :openFileAsk,            :open_file_ask
+    alias_method :operateOnString,        :operate_on_string
+    alias_method :operateOnLines,         :operate_on_lines
+    alias_method :operateOnEachLine,      :operate_on_each_line
+    alias_method :pageUp,                 :page_up
+    alias_method :pageDown,               :page_down
+    alias_method :parsedIndent,           :parsed_indent
+    alias_method :playMacro,              :play_macro
+    alias_method :popTag,                 :pop_tag
+    alias_method :printKeychain,          :print_keychain
+    alias_method :removeNamedBookmark,    :remove_named_bookmark
+    alias_method :removeSelection,        :remove_selection
+    alias_method :repeatLast,             :repeat_last
+    alias_method :saveFile,               :save_file
+    alias_method :saveFileAs,             :save_file_as
+    alias_method :scrollDown,             :scroll_down
+    alias_method :scrollUp,               :scroll_up
+    alias_method :searchAndReplace,       :search_and_replace
+    alias_method :setBufferType,          :set_buffer_type
+    alias_method :setReadOnly,            :set_read_only
+    alias_method :showClips,              :show_clips
+    alias_method :pasteShellResult,       :paste_shell_result
+    alias_method :toggleMacroRecording,   :toggle_macro_recording
+    alias_method :switchToBufferNumber,   :switch_to_buffer_number
+    alias_method :switchToNextBuffer,     :switch_to_next_buffer
+    alias_method :switchToPreviousBuffer, :switch_to_previous_buffer
+    alias_method :toggleBookmark,         :toggle_bookmark
+    alias_method :toggleSelection,        :toggle_selection
+    alias_method :toggleSessionSetting,   :toggle_session_setting
+  end
+end

data/lib/diakonos/functions.rb

@@ -0,0 +1,292 @@
+module Diakonos
+
+  # The Diakonos::Functions module contains all the methods that can be mapped
+  # to keys in Diakonos.  New methods can be added to this module by
+  # extensions.
+
+  module Functions
+
+    # Shows the About page, which gives information on Diakonos.
+    def about
+      about_write
+      open_file @about_filename
+    end
+
+    # Deletes characters up to, but not including, a given character.
+    # Also puts the deleted text into the clipboard.
+    def delete_to( char = nil )
+      if char.nil?
+        set_iline "Type character to delete to..."
+        char = @win_main.getch
+        set_iline
+      end
+      if char
+        removed_text = buffer_current.delete_to char
+        if removed_text
+          @clipboard.add_clip removed_text
+        else
+          set_iline "'#{char}' not found."
+        end
+      end
+    end
+
+    # Deletes characters starting from (but not including) a given character
+    # up to (but not including) the current cursor position.
+    # Also puts the deleted text into the clipboard.
+    def delete_from( char = nil )
+      if char.nil?
+        set_iline "Type character to delete from..."
+        char = @win_main.getch
+        set_iline
+      end
+      if char
+        removed_text = buffer_current.delete_from(char)
+        if removed_text
+          @clipboard.add_clip removed_text
+        else
+          set_iline "'#{char}' not found."
+        end
+      end
+    end
+
+    # Deletes characters between, but not including, a given pair of
+    # characters.  Also puts the deleted text into the clipboard.
+    # Brace characters are intelligently matched with their opposite-side
+    # counterparts if the left-side brace is given (e.g. '[').
+    def delete_to_and_from( inclusive = nil, char = nil )
+      if char.nil?
+        set_iline "Type character to delete to and from..."
+        char = @win_main.getch
+        set_iline
+      end
+      if char
+        removed_text = buffer_current.delete_to_and_from(
+          char,
+          inclusive == :inclusive ? INCLUSIVE : NOT_INCLUSIVE
+        )
+        if removed_text
+          @clipboard.add_clip( [ removed_text ] )
+        else
+          set_iline "'#{char}' not found."
+        end
+      end
+    end
+
+    # Evaluates (executes) Ruby code.
+    def evaluate( code_ = nil )
+      if code_.nil?
+        if buffer_current.changing_selection
+          selected_text = buffer_current.copy_selection[ 0 ]
+        end
+        code = get_user_input(
+          "Ruby code: ",
+          history: @rlh_general,
+          initial_text: selected_text || "",
+          completion_array: ::Diakonos::Functions.public_instance_methods.map { |m| m.to_s }
+        )
+      else
+        code = code_
+      end
+
+      if code
+        begin
+          eval code
+        rescue Exception => e
+          show_exception(
+            e,
+            [
+              "The code given to evaluate has a syntax error.",
+              "The code given to evaluate refers to a Diakonos command which does not exist, or is misspelled.",
+              "The code given to evaluate refers to a Diakonos command with missing arguments.",
+              "The code given to evaluate refers to a variable or method which does not exist.",
+            ]
+          )
+        end
+      end
+    end
+
+    # Starts the interactive help system.
+    def help( prefill = '' )
+      if ! File.exist?( @help_dir ) || Dir[ "#{@help_dir}/*" ].size == 0
+        set_iline 'There are no help files installed.'
+        return
+      end
+
+      open_help_buffer
+      matching_docs = nil
+
+      selected = get_user_input(
+        "Search terms: ",
+        history: @rlh_help,
+        initial_text: prefill,
+        completion_array: @help_tags
+      ) { |input|
+        next if input.length < 3 && input[ 0..0 ] != '/'
+
+        matching_docs = matching_help_documents( input )
+        with_list_file do |list|
+          list.puts matching_docs.join( "\n" )
+        end
+
+        open_list_buffer
+      }
+
+      close_help_buffer
+
+      case selected
+      when /\|/
+        open_help_document selected
+      when nil
+        # Help search aborted; do nothing
+      else
+        # Not a selected help document
+        if matching_docs.nil? || matching_docs.empty?
+          matching_docs = matching_help_documents( selected )
+        end
+
+        case matching_docs.size
+        when 1
+          open_help_document matching_docs[ 0 ]
+        when 0
+          File.open( @error_filename, 'w' ) do |f|
+            f.puts "There were no help documents matching your search."
+            f.puts "(#{selected.strip})"
+            f.puts "Close this message with Ctrl-W (default keychord)."
+          end
+          error_file = open_file( @error_filename )
+        else
+          help selected
+        end
+      end
+    end
+
+    # Loads Ruby code from file using Kernel#load.
+    def load_script( name_ = nil )
+      if name_.nil?
+        name = get_user_input( "File to load as script: ", history: @rlh_files )
+      else
+        name = name_
+      end
+
+      if name
+        thread = Thread.new( name ) do |f|
+          begin
+            load( f )
+          rescue Exception => e
+            show_exception(
+              e,
+              [
+                "The filename given does not exist.",
+                "The filename given is not accessible or readable.",
+                "The loaded script does not reference Diakonos commands as members of the global Diakonos object.  e.g. cursor_bol instead of $diakonos.cursor_bol",
+                "The loaded script has syntax errors.",
+                "The loaded script references objects or object members which do not exist."
+              ]
+            )
+          end
+          set_iline "Loaded script '#{name}'."
+        end
+
+        loop do
+          if thread.status != "run"
+            break
+          else
+            sleep 0.1
+          end
+        end
+        thread.join
+      end
+    end
+
+    def play_macro( name = nil )
+      macro, input_history = @macros[ name ]
+      if input_history
+        @macro_input_history = input_history.deep_clone
+        if macro
+          @playing_macro = true
+          macro.each do |command|
+            eval command
+          end
+          @playing_macro = false
+          @macro_input_history = nil
+        end
+      end
+    end
+
+    def print_mapped_function
+      @capturing_mapping = true
+      set_iline "Type any chain of keystrokes or key chords, or press Enter to stop."
+    end
+
+    def print_keychain
+      @capturing_keychain = true
+      set_iline "Type any chain of keystrokes or key chords, then press Enter..."
+    end
+
+    # Quits Diakonos (gracefully).
+    def quit
+      @quitting = true
+      to_all = nil
+      save_session
+      @buffers.each do |buffer|
+        next  if ! buffer.modified?
+        switch_to buffer
+        closure_choice = close_buffer( buffer, to_all: to_all )
+        case closure_choice
+        when CHOICE_CANCEL
+          @quitting = false
+          break
+        when CHOICE_YES_TO_ALL, CHOICE_NO_TO_ALL
+          to_all = closure_choice
+        end
+      end
+    end
+
+    def repeat_last
+      eval @functions_last[ -1 ] if ! @functions_last.empty?
+    end
+
+    # Send the Diakonos job to background, as if with Ctrl-Z
+    def suspend
+      Curses::close_screen
+      Process.kill( "SIGSTOP", $PID )
+      Curses::init_screen
+      refresh_all
+    end
+
+    # Starts or stops macro recording.
+    def toggle_macro_recording( name = nil )
+      if @macro_history
+        stop_recording_macro
+      else
+        start_recording_macro name
+      end
+    end
+
+    # Undoes the latest change made to the current buffer,
+    # or reopens the file that was just closed.
+    def undo( buffer = buffer_current )
+      if @functions_last[-1] == 'close_buffer'
+        open_file(
+          @buffer_closed.name,
+          'cursor' => {
+            'row' => @buffer_closed.last_row,
+            'col' => @buffer_closed.last_col,
+          },
+          'display' => {
+            'top_line' => @buffer_closed.top_line,
+            'left_col' => @buffer_closed.left_column,
+          }
+        )
+      else
+        buffer.undo
+      end
+    end
+
+    # Redoes the latest change undone on the current buffer.
+    def unundo( buffer = buffer_current )
+      buffer.unundo
+    end
+
+  end
+end

data/lib/diakonos/grep.rb

@@ -0,0 +1,98 @@
+module Diakonos
+  def self.grep_array( regexp, array, lines_of_context, prefix, filepath )
+    num_lines = array.size
+    line_numbers = []
+    array.each_with_index do |line,index|
+      next if line !~ regexp
+      start_index = [ 0, index - lines_of_context ].max
+      end_index = [ index + lines_of_context, num_lines-1 ].min
+      (start_index..end_index).each do |i|
+        line_numbers << i
+      end
+    end
+
+    line_numbers.uniq!
+    results = []
+    last_i = line_numbers[ 0 ]
+    one_result = []
+    line_numbers.each do |i|
+      if i - last_i > 1
+        results << one_result.join( "\n" )
+        one_result = []
+      end
+      one_result << ( "#{prefix}#{i+1}: " << ( "%-300s | #{filepath}:#{i+1}" % array[ i ] ) )
+      last_i = i
+    end
+    if ! one_result.empty?
+      results << one_result.join( "\n" )
+    end
+
+    results
+  end
+
+  class Diakonos
+
+    def actually_grep( regexp_source, *buffers )
+      begin
+        regexp = Regexp.new( regexp_source, Regexp::IGNORECASE )
+        grep_results = buffers.map { |buffer| buffer.grep(regexp) }.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
+        list_buffer.highlight_matches regexp
+        display_buffer list_buffer
+      rescue RegexpError
+        # Do nothing
+      end
+    end
+
+    def grep_( regexp_source, *buffers )
+      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 || "",
+        will_display_after_select: true
+      ) { |input|
+        next  if input.length < 2
+        actually_grep input, *buffers
+      }
+
+      if selected
+        spl = selected.split( "| " )
+        if spl.size > 1
+          open_file spl[-1]
+        else
+          original_buffer.cursor_to starting_row, starting_col
+        end
+      else
+        original_buffer.cursor_to starting_row, starting_col
+      end
+    end
+
+    def increase_grep_context
+      current = settings['grep.context']
+      @session.settings['grep.context'] = current + 1
+      merge_session_settings
+    end
+    def decrease_grep_context
+      current = settings['grep.context']
+      if current > 0
+        @session.settings['grep.context'] = current - 1
+        merge_session_settings
+      end
+    end
+
+  end
+end

data/lib/diakonos/help.rb

@@ -0,0 +1,47 @@
+module Diakonos
+  class Diakonos
+    def init_help
+      @help_dir = INSTALL_SETTINGS[ :help_dir ]
+      @help_tags = `grep -h Tags #{@help_dir}/* | cut -d ' ' -f 2-`.split.uniq
+    end
+
+    def open_help_buffer
+      @help_buffer = open_file( @help_filename )
+    end
+    def close_help_buffer
+      close_buffer @help_buffer
+      @help_buffer = nil
+    end
+
+    def matching_help_documents( str )
+      docs = []
+
+      if str =~ %r{^/(.+)$}
+        regexp = $1
+        files = Dir[ "#{@help_dir}/*" ].select{ |f|
+          File.open( f ) { |io| io.grep( /#{regexp}/i ) }.any?
+        }
+      else
+        terms = str.gsub( /[^a-zA-Z0-9-]/, ' ' ).split.join( '|' )
+        file_grep = `egrep -i -l '^Tags.*\\b(#{terms})\\b' #{@help_dir}/*`
+        files = file_grep.split( /\s+/ )
+      end
+
+      files.each do |file|
+        File.open( file ) do |f|
+          docs << ( "%-300s | %s" % [ f.gets.strip, file ] )
+        end
+      end
+
+      docs.sort { |a,b| a.gsub( /^# (?:an?|the) */i, '# ' ) <=> b.gsub( /^# (?:an?|the) */i, '# ' ) }
+    end
+
+    def open_help_document( selected_string )
+      help_file = selected_string.split( "| " )[ -1 ]
+      if File.exist? help_file
+        open_file help_file
+      end
+    end
+
+  end
+end

data/lib/diakonos/hooks.rb

@@ -0,0 +1,13 @@
+module Diakonos
+  class Diakonos
+    def register_proc( the_proc, hook_name, priority = 0 )
+      @hooks[ hook_name ] << { :proc => the_proc, :priority => priority }
+    end
+
+    def run_hook_procs( hook_id, *args )
+      @hooks[ hook_id ].each do |hook_proc|
+        hook_proc[ :proc ].call( *args )
+      end
+    end
+  end
+end

data/lib/diakonos/installation.rb

@@ -0,0 +1,19 @@
+# This file is completely overwritten by install.rb upon installation.
+# This copy is here to permit the tests to execute.
+
+module Diakonos
+  root = File.expand_path("../..", __dir__)
+
+  INSTALL_SETTINGS = {
+    :prefix   => root,
+    :bin_dir  => File.join(root, "bin"),
+    :doc_dir  => root,
+    :help_dir => File.join(root, "help"),
+    :conf_dir => root,
+    :lib_dir  => File.join(root, "lib"),
+    :installed => {
+      :files => [],
+      :dirs => [],
+    },
+  }
+end