diakonos 0.8.8 → 0.9.8

data/lib/diakonos/functions/selection.rb

@@ -0,0 +1,98 @@
+module Diakonos
+  module Functions
+
+    # Begins selecting text by anchoring (marking) the start of a selection.
+    def anchor_selection
+      buffer_current.anchor_selection
+      update_status_line
+    end
+
+    # Used for "shift+arrow" style selection.
+    def anchor_unanchored_selection( *method_and_args )
+      buffer_current.anchor_unanchored_selection
+      if method_and_args[0]
+        self.send method_and_args[0], *method_and_args[1..-1]
+      end
+      update_status_line
+    end
+
+    # Removes the highlighting from any text that matches the most recent
+    # search.
+    def clear_matches
+      buffer_current.clear_matches Buffer::DO_DISPLAY
+    end
+
+    # Unselects any current selection (stops selecting).
+    def remove_selection
+      buffer_current.remove_selection
+      update_status_line
+    end
+
+    # Selects the entire buffer contents.
+    def select_all
+      buffer_current.select_all
+    end
+
+    # Selects text between two regexps.
+    def select_block( beginning = nil, ending = nil, including_ending = true )
+      if beginning.nil?
+        input = get_user_input( "Start at regexp: " )
+        if input
+          beginning = Regexp.new input
+        end
+      end
+      if beginning && ending.nil?
+        input = get_user_input( "End before regexp: " )
+        if input
+          ending = Regexp.new input
+        end
+      end
+      if beginning && ending
+        buffer_current.select( beginning, ending, including_ending )
+      end
+    end
+
+    # Changes selection mode to block mode (rectangular selection).
+    def selection_mode_block
+      buffer_current.selection_mode_block
+      update_status_line
+    end
+
+    # Changes selection mode to normal mode (flow selection).
+    def selection_mode_normal
+      buffer_current.selection_mode_normal
+      update_status_line
+    end
+
+    # If currently selecting, stops selecting.
+    # If not currently selecting, begins selecting.
+    def toggle_selection
+      buffer_current.toggle_selection
+      update_status_line
+    end
+
+    # Selects the current line.
+    def select_line
+      buffer_current.select_current_line
+      update_status_line
+    end
+
+    # Selects the code block which wraps the current cursor position.
+    # Execute multiple times in succession to select increasingly outer code blocks.
+    def select_wrapping_block
+      buffer_current.select_wrapping_block
+      update_status_line
+    end
+
+    # Selects the word at the current cursor position.
+    # If the cursor is not on a word character, the first word following the cursor is selected.
+    def select_word
+      buffer_current.select_word
+    end
+
+    def select_word_another
+      buffer_current.select_word_another
+    end
+
+  end
+end

data/lib/diakonos/functions/sessions.rb

@@ -0,0 +1,78 @@
+module Diakonos
+  module Functions
+
+    def merge_session_settings
+      @settings.merge! @session.settings
+    end
+
+    def change_session_setting( key_ = nil, value = nil, do_redraw = DONT_REDRAW )
+      if key_.nil?
+        key = get_user_input( "Setting: " )
+      else
+        key = key_
+      end
+
+      if key
+        if value.nil?
+          value = get_user_input( "Value: " )
+        end
+        case @settings[ key ]
+        when String
+          value = value.to_s
+        when Integer
+          value = value.to_i
+        when TrueClass, FalseClass
+          value = value.to_b
+        end
+        @session.settings[ key ] = value
+        merge_session_settings
+        redraw  if do_redraw
+        set_iline "#{key} = #{value}"
+      end
+    end
+
+    def name_session
+      name = get_user_input( 'Session name: ' )
+      if name
+        @session = Session.new("#{@session_dir}/#{name}")
+        save_session
+      end
+    end
+
+    def set_session_dir
+      path = get_user_input(
+        "Session directory: ",
+        history: @rlh_files,
+        initial_text: @session.dir,
+        do_complete: DONT_COMPLETE,
+        on_dirs: :accept_dirs
+      )
+      if path
+        @session.dir = File.expand_path( path )
+        save_session
+        set_iline "Session dir changed to: #{@session.dir}"
+      else
+        set_iline "(Session dir is: #{@session.dir})"
+      end
+    end
+
+    def toggle_session_setting( key_ = nil, do_redraw = DONT_REDRAW )
+      key = key_ || get_user_input( "Setting: " )
+      return  if key.nil?
+
+      value = nil
+      if @session.settings[ key ].class == TrueClass || @session.settings[ key ].class == FalseClass
+        value = ! @session.settings[ key ]
+      elsif @settings[ key ].class == TrueClass || @settings[ key ].class == FalseClass
+        value = ! @settings[ key ]
+      end
+      if value != nil   # explicitly true or false
+        @session.settings[ key ] = value
+        merge_session_settings
+        redraw  if do_redraw
+        set_iline "#{key} = #{value}"
+      end
+    end
+
+  end
+end

data/lib/diakonos/functions/shell.rb

@@ -0,0 +1,250 @@
+module Diakonos
+  module Functions
+
+    # Change the current working directory (CWD) of the Diakonos process.
+    # @param [String] dir  The directory to change to
+    def chdir( dir = nil )
+      dir ||= get_user_input( "Change to directory: ", initial_text: Dir.pwd )
+      if dir
+        Dir.chdir dir
+      end
+    end
+
+    # Substitutes Diakonos shell variables in a String.
+    # - $f: The current buffer's filename
+    # - $d: The current buffer's directory
+    # - $F: A space-separated list of all buffer filenames
+    # - $i: A string acquired from the user with a prompt
+    # - $c: The current clipboard text
+    # - $s: The currently selected text
+    # @param [String] string
+    #   The string containing variables to substitute
+    # @return [String]
+    #   A new String with values substituted for all variables
+    def sub_shell_variables( string )
+      return  if string.nil?
+
+      retval = string.dup
+
+      # Current buffer filename
+      retval.gsub!( /\$f/, ( $1 || "" ) + File.expand_path( buffer_current.name || "" ) )
+      # Current buffer dir
+      retval.gsub!( /\$d/, ( $1 || "" ) + File.dirname( File.expand_path( buffer_current.name || '' ) ) )
+
+      # space-separated list of all buffer filenames
+      name_array = Array.new
+      @buffers.each do |b|
+        name_array.push b.name
+      end
+      retval.gsub!( /\$F/, ( $1 || "" ) + ( name_array.join(' ') || "" ) )
+
+      # Get user input, sub it in
+      if retval =~ /\$i/
+        user_input = get_user_input(
+          "Argument: ",
+          history: @rlh_shell,
+          initial_text: buffer_current.selected_string
+        )
+        retval.gsub!( /\$i/, user_input )
+      end
+
+      # Current clipboard text
+      if retval =~ /\$[ck]/
+        clip_filename = @diakonos_home + "/clip.txt"
+        File.open( clip_filename, "w" ) do |clipfile|
+          if @clipboard.clip
+            clipfile.puts( @clipboard.clip.join( "\n" ) )
+          end
+        end
+        retval.gsub!( /\$[ck]/, clip_filename )
+      end
+
+      # Currently selected text
+      if retval =~ /\$s/
+        text_filename = @diakonos_home + "/selected.txt"
+
+        File.open( text_filename, "w" ) do |textfile|
+          selected_text = buffer_current.selected_text
+          if selected_text
+            textfile.puts( selected_text.join( "\n" ) )
+          end
+        end
+        retval.gsub!( /\$s/, text_filename )
+      end
+
+      retval
+    end
+
+    # Executes a command in a shell, captures the results, and displays them
+    # (if any) in a new buffer.  Substitutes Diakonos shell variables.
+    # Interaction with Diakonos is not possible while the shell is running.
+    # For asynchronous shelling, use #spawn.  The shell function does not
+    # allow interaction with applications run in the shell.  Use #execute
+    # for interactivity.
+    #
+    # @param [String] command_
+    #   The shell command to execute
+    # @param [String] result_filename
+    #   The name of the temporary file to write the shell results to
+    # @see #sub_shell_variables
+    # @see #execute
+    # @see #spawn
+    # @see #paste_shell_result
+    def shell( command_ = nil, result_filename = 'shell-result.txt' )
+      command = command_ || get_user_input( "Command: ", history: @rlh_shell )
+
+      return  if command.nil?
+
+      command = sub_shell_variables( command )
+
+      completed = false
+      result_file = "#{@diakonos_home}/#{result_filename}"
+      File.open( result_file , "w" ) do |f|
+        Curses::close_screen
+
+        stdin, stdout, stderr = Open3.popen3( command )
+
+        t1 = Thread.new do
+          stdout.each_line do |line|
+            f.puts line
+          end
+        end
+        t2 = Thread.new do
+          stderr.each_line do |line|
+            f.puts line
+          end
+        end
+
+        catch :stop do
+          loop do
+            begin
+              Timeout::timeout( 5 ) do
+                t1.join
+                t2.join
+                Curses::init_screen
+                refresh_all
+                completed = true
+                throw :stop
+              end
+            rescue Timeout::Error => e
+              choice = get_choice(
+                "Keep waiting for shell results?",
+                [ CHOICE_YES, CHOICE_NO ],
+                CHOICE_YES
+              )
+              if choice != CHOICE_YES
+                t1.terminate
+                t2.terminate
+                throw :stop
+              end
+            end
+          end
+        end
+
+      end
+      if File.size?( result_file )
+        open_file result_file
+        set_iline "#{completed ? '' : '(interrupted) '}Results for: #{command}"
+      else
+        set_iline "Empty result for: #{command}"
+      end
+    end
+
+    # Executes a command in a shell, and displays the exit code.
+    # Results of the shell command are discarded.
+    # Substitutes Diakonos shell variables.
+    # Interaction with Diakonos is not possible while the shell is running.
+    # For asynchronous shelling, use #spawn.  The #execute function allows
+    # interaction with shell programs that accept keyboard interaction.
+    #
+    # @param [String] command_
+    #   The shell command to execute
+    # @see #sub_shell_variables
+    # @see #shell
+    # @see #spawn
+    # @see #paste_shell_result
+    def execute( command_ = nil )
+      command = command_ || get_user_input( "Command: ", history: @rlh_shell )
+
+      return  if command.nil?
+
+      command = sub_shell_variables( command )
+
+      Curses::close_screen
+
+      success = system( command )
+      if ! success
+        result = "Could not execute: #{command}"
+      else
+        result = "Exit code: #{$?}"
+      end
+
+      Curses::init_screen
+      refresh_all
+
+      set_iline result
+    end
+
+    # Executes a command in a shell, captures the results, and pastes them
+    # in the current buffer at the current cursor location.
+    # Substitutes Diakonos shell variables.
+    # Interaction with Diakonos is not possible while the shell is running.
+    # For asynchronous shelling, use #spawn.
+    #
+    # @param [String] command_
+    #   The shell command to execute
+    # @see #sub_shell_variables
+    # @see #execute
+    # @see #shell
+    # @see #spawn
+    def paste_shell_result( command_ = nil )
+      command = command_ || get_user_input( "Command: ", history: @rlh_shell )
+
+      return  if command.nil?
+
+      command = sub_shell_variables( command )
+
+      Curses::close_screen
+
+      begin
+        buffer_current.paste( `#{command} 2<&1`.split( /\n/, -1 ) )
+      rescue Exception => e
+        debug_log e.message
+        debug_log e.backtrace.join( "\n\t" )
+        show_exception e
+      end
+
+      Curses::init_screen
+      refresh_all
+    end
+
+    # Executes a command in a shell, captures the results, and pastes them
+    # in the current buffer at the current cursor location.
+    # Substitutes Diakonos shell variables.
+    # The shell is executed in a separate thread, so interaction with Diakonos
+    # is possible during execution.
+    #
+    # @param [String] command_
+    #   The shell command to execute
+    # @see #sub_shell_variables
+    # @see #execute
+    # @see #shell
+    # @see #paste_shell_result
+    def spawn( command_ = nil )
+      command = command_ || get_user_input( "Command: ", history: @rlh_shell )
+
+      return  if command.nil?
+
+      command = sub_shell_variables( command )
+
+      Thread.new do
+        if system( command )
+          set_iline "Return code #{$?} from '#{command}'"
+        else
+          set_iline "Error code #{$?} executing '#{command}'"
+        end
+      end
+    end
+
+  end
+end

data/lib/diakonos/functions/tags.rb

@@ -0,0 +1,65 @@
+module Diakonos
+  module Functions
+
+    def go_to_tag( tag_ = nil )
+      load_tags
+
+      # If necessary, prompt for tag name.
+
+      if tag_.nil?
+        if buffer_current.changing_selection
+          selected_text = buffer_current.copy_selection[ 0 ]
+        end
+        tag_name = get_user_input(
+          "Tag name: ",
+          history: @rlh_general,
+          initial_text: selected_text || "",
+          completion_array: @tags.keys
+        )
+      else
+        tag_name = tag_
+      end
+
+      tag_array = @tags[ tag_name ]
+      if tag_array && tag_array.length > 0
+        if i = tag_array.index( @last_tag )
+          tag = ( tag_array[ i + 1 ] || tag_array[ 0 ] )
+        else
+          tag = tag_array[ 0 ]
+        end
+        @last_tag = tag
+        @tag_stack.push [ buffer_current.name, buffer_current.last_row, buffer_current.last_col ]
+        if switch_to( @buffers.find { |b| b.name == tag.file } )
+          #buffer_current.go_to_line( 0 )
+        else
+          open_file tag.file
+        end
+        line_number = tag.command.to_i
+        if line_number > 0
+          buffer_current.go_to_line( line_number - 1 )
+        else
+          find tag.command case_sensitive: true
+        end
+      elsif tag_name
+        set_iline "No such tag: '#{tag_name}'"
+      end
+    end
+
+    def go_to_tag_under_cursor
+      go_to_tag buffer_current.word_under_cursor
+    end
+
+    def pop_tag
+      tag = @tag_stack.pop
+      if tag
+        if ! switch_to( @buffers.find { |b| b.name == tag[ 0 ] } )
+          open_file tag[ 0 ]
+        end
+        buffer_current.cursor_to( tag[ 1 ], tag[ 2 ], Buffer::DO_DISPLAY )
+      else
+        set_iline "Tag stack empty."
+      end
+    end
+
+  end
+end

data/lib/diakonos/functions/text-manipulation.rb

@@ -0,0 +1,196 @@
+require 'diakonos/line-mover'
+
+module Diakonos
+  module Functions
+
+    def close_code
+      buffer_current.close_code
+    end
+
+    def collapse_whitespace
+      buffer_current.collapse_whitespace
+    end
+
+
+    def columnize( delimiter = nil, num_spaces_padding = 0 )
+      delimiter ||= get_user_input(
+        "Column delimiter (regexp): ",
+        history: @rlh_general,
+        initial_text: @settings[ "lang.#{buffer_current.original_language}.column_delimiters" ] || ''
+      )
+      if delimiter && num_spaces_padding
+        buffer_current.columnize Regexp.new( delimiter ), num_spaces_padding
+      end
+    end
+
+    def comment_out
+      buffer_current.comment_out
+    end
+
+    def complete_word( direction = :down )
+      b = buffer_current
+      if b.selecting?
+        old_word = b.word_before_cursor
+        b.delete_selection
+      end
+      partial = b.word_before_cursor
+      return  if partial.nil?
+
+      all_words = @buffers.find_all { |b_|
+        b_.original_language == b.original_language
+      }.collect { |b_|
+        b_.words( /^#{Regexp.escape(partial)}./ )
+      }.flatten
+      if all_words.any?
+        words = all_words.uniq.sort
+        if old_word
+          i = (
+            ( direction == :up ? words.size - 1 : 1 ) +
+            words.find_index { |w|
+              w == old_word
+            }
+          ) % words.size
+        else
+          freq_word = words.sort_by { |word|
+            all_words.find_all { |w| w == word }.size
+          }[ -1 ]
+          i = words.find_index { |w| w == freq_word }
+        end
+        word = words[ i ]
+        b.insert_string word[ partial.length..-1 ]
+        r, c = b.last_row, b.last_col
+        b.cursor_to( b.last_row, b.last_col + word.length - partial.length )
+        b.set_selection( r, c, r, c + word.length - partial.length )
+        n = words.size
+        middle_word = words[ i ].center( Curses::cols / 4, ' ' )
+        shown_words = [
+          words[ ( n+i-2 ) % n ],
+          words[ ( n+i-1 ) % n ],
+          middle_word,
+          words[ ( n+i+1 ) % n ],
+          words[ ( n+i+2 ) % n ],
+        ].compact.uniq.reject { |w| w == middle_word.strip }.join( ' ' )
+        mi = shown_words.index( middle_word )
+        padding = " " * ( Curses::cols / 2 - mi - ( middle_word.length / 2 ) )
+        set_iline padding + shown_words
+      end
+    end
+
+    def join_lines_upward
+      buffer_current.join_lines_upward( buffer_current.current_row, Buffer::STRIP_LINE )
+    end
+
+    def join_lines
+      buffer_current.join_lines( buffer_current.current_row, Buffer::STRIP_LINE )
+    end
+
+    def move_lines(direction:)
+      mover = LineMover.new(buffer: buffer_current)
+      mover.move_selected_lines(direction: direction)
+    end
+
+    def operate_on_string(
+      ruby_code = get_user_input(
+        'Ruby code: ',
+        history: @rlh_general,
+        initial_text: 'str.'
+      )
+    )
+      if ruby_code
+        str = buffer_current.selected_string
+        if str && ! str.empty?
+          buffer_current.paste eval( ruby_code )
+        end
+      end
+    end
+
+    def operate_on_lines(
+      ruby_code = get_user_input(
+        'Ruby code: ',
+        history: @rlh_general,
+        initial_text: 'lines.collect { |l| l }'
+      )
+    )
+      if ruby_code
+        lines = buffer_current.selected_text
+        if lines && ! lines.empty?
+          if lines[ -1 ].empty?
+            lines.pop
+            popped = true
+          end
+          new_lines = eval( ruby_code )
+          if popped
+            new_lines << ''
+          end
+          buffer_current.paste new_lines
+        end
+      end
+    end
+
+    def operate_on_each_line(
+      ruby_code = get_user_input(
+        'Ruby code: ',
+        history: @rlh_general,
+        initial_text: 'line.'
+      )
+    )
+      if ruby_code
+        lines = buffer_current.selected_text
+        if lines && ! lines.empty?
+          if lines[ -1 ].empty?
+            lines.pop
+            popped = true
+          end
+          new_lines = eval( "lines.collect { |line| #{ruby_code} }" )
+          if popped
+            new_lines << ''
+          end
+          buffer_current.paste new_lines
+        end
+      end
+    end
+
+    def surround_line( envelope = nil )
+      buffer_current.set_selection_current_line
+      surround_selection envelope
+    end
+
+    def surround_paragraph( envelope = nil )
+      ( first, _ ), ( last, length ) = buffer_current.paragraph_under_cursor_pos
+      buffer_current.set_selection( first, 0, last, length+1 )
+      surround_selection envelope
+    end
+
+    def surround_selection( parenthesis = nil )
+      if ! buffer_current.selecting?
+        set_iline "Nothing selected."
+        return
+      end
+
+      parenthesis ||= get_user_input( "Surround with: " )
+      if parenthesis
+        text = buffer_current.surround( buffer_current.selected_text, parenthesis )
+        if text
+          buffer_current.paste text
+        end
+      end
+    end
+
+    def surround_word( envelope = nil )
+      ( start_row, start_col ), ( end_row, end_col ) = buffer_current.word_under_cursor_pos
+      if start_row && start_col && end_row && end_col
+        buffer_current.set_selection( start_row, start_col, end_row, end_col )
+        surround_selection envelope
+      end
+    end
+
+    def uncomment
+      buffer_current.uncomment
+    end
+
+    def wrap_paragraph
+      buffer_current.wrap_paragraph
+    end
+
+  end
+end