diakonos 0.8.11 → 0.9.9

data/lib/diakonos/readline/functions.rb

@@ -0,0 +1,82 @@
+module Diakonos
+
+  class Readline
+
+    def abort
+      @input = nil
+      @done = true
+    end
+
+    def accept( item )
+      if item && @on_dirs == :go_into_dirs && File.directory?( item )
+        complete_input
+      else
+        @done = true
+      end
+    end
+
+    def backspace
+      if cursor_left
+        delete
+      end
+    end
+
+    def cursor_bol
+      @input_cursor = 0
+      sync
+    end
+
+    def cursor_eol
+      @input_cursor = @input.length
+      sync
+    end
+
+    def cursor_left
+      return false  if @input_cursor < 1
+      @input_cursor -= 1
+      sync
+      true
+    end
+
+    def cursor_right
+      return  if @input_cursor >= @input.length
+      @input_cursor += 1
+      sync
+    end
+
+    def delete
+      return  if @input_cursor >= @input.length
+      @input = @input[ 0...@input_cursor ] + @input[ (@input_cursor + 1)..-1 ]
+      sync
+    end
+
+    def delete_line
+      @input = ""
+      sync
+    end
+
+    def delete_word
+      head = @input[ 0...@input_cursor ]
+      chopped = head.sub( /\w+\W*$/, '' )
+      @input = chopped + @input[ @input_cursor..-1 ]
+      @input_cursor -= head.length - chopped.length
+      sync
+    end
+
+    def history_up
+      return  if @history_index < 1
+      @history[ @history_index ] = @input
+      @history_index -= 1
+      @input = @history[ @history_index ]
+    end
+
+    def history_down
+      return  if @history_index > @history.length - 2
+      @history[ @history_index ] = @input
+      @history_index += 1
+      @input = @history[ @history_index ]
+    end
+
+  end
+
+end

data/lib/diakonos/readline.rb

@@ -0,0 +1,223 @@
+module Diakonos
+
+  class Readline
+
+    attr_reader :input
+
+    # completion_array is the array of strings that tab completion can use
+    # The block returns true if a refresh is needed?
+    # @param options :initial_text, :completion_array, :history, :do_complete, :on_dirs
+    def initialize(
+      list_manager:,
+      keystroke_processor:,
+      testing: false,
+      window:,
+      start_pos:,
+      options: {},
+      &block
+    )
+      @list_manager = list_manager
+      @keystroke_processor = keystroke_processor
+      @testing = testing
+      @window = window
+      @start_pos = start_pos
+      @window.setpos( 0, start_pos )
+      @initial_text = options[ :initial_text ] || ''
+      @completion_array = options[ :completion_array ]
+      @list_filename = @list_manager.list_filename
+
+      @history = options[ :history ] || []
+      @history << @initial_text
+      @history_index = [ @history.length - 1, 0 ].max
+
+      @do_complete = options[ :do_complete ] || ::Diakonos::DONT_COMPLETE
+      @on_dirs = options[ :on_dirs ] || :go_into_dirs
+      @numbered_list = options[ :numbered_list ]
+
+      @block = block
+
+      # ---
+
+      @input = @initial_text.dup
+      if ! @input.empty?
+        call_block
+      end
+
+      @icurx = @window.curx
+      @icury = @window.cury
+      @view_y = 0
+      if ! @testing
+        @window.addstr @initial_text
+      end
+      @input_cursor = @initial_text.length
+      @opened_list_file = false
+
+      if @do_complete
+        complete_input
+      end
+    end
+
+    def get_input
+      while ! done?
+        @keystroke_processor.process_keystroke(Array.new, 'input')
+      end
+      input
+    end
+
+    def call_block
+      if @block
+        @block.call( @input )
+        @window.refresh
+      end
+    end
+
+    def set_input( input = '' )
+      if numbered_list? && input =~ /^\w  /
+        input = input[ 3..-1 ]
+      end
+      @input = input
+    end
+
+    def done?
+      @done
+    end
+
+    def finish
+      @done = true
+    end
+
+    def list_sync( line )
+      return  if line.nil?
+      set_input line
+      cursor_write_input
+    end
+
+    def numbered_list?
+      @numbered_list
+    end
+
+    def sync
+      if @input_cursor > @input.length
+        @input_cursor = @input.length
+      elsif @input_cursor < @view_y
+        @view_y = @input_cursor
+      end
+
+      diff = ( @input_cursor - @view_y ) + 1 - ( Curses::cols - @start_pos )
+      if diff > 0
+        @view_y += diff
+      end
+
+      @window.setpos( @window.cury, @start_pos + @input_cursor - @view_y )
+      redraw_input
+      call_block
+    end
+
+    def paste( s )
+      @input = @input[ 0...@input_cursor ] + s + @input[ @input_cursor..-1 ]
+      @input_cursor += s.length
+      sync
+    end
+
+    def redraw_input
+      # TODO: Gracefully handle when `input` is nil
+      input = @input[ @view_y...(@view_y + Curses::cols) ]
+
+      curx = @window.curx
+      cury = @window.cury
+      @window.setpos( @icury, @icurx )
+      @window.addstr "%-#{ Curses::cols - curx }s%s" % [
+        input,
+        " " * [ ( Curses::cols - input.length ), 0 ].max
+      ]
+      @window.setpos( cury, curx )
+      @window.refresh
+    end
+
+    # Redisplays the input text starting at the start of the user input area,
+    # positioning the cursor at the end of the text.
+    def cursor_write_input
+      if @input
+        @input_cursor = @input.length
+        @window.setpos( @window.cury, @icurx + @input.length )
+        redraw_input
+      end
+    end
+
+    def complete_input
+      if @completion_array && @input.length > 0
+        len = @input.length
+        matches = @completion_array.find_all { |el| el[ 0...len ] == @input && len <= el.length }
+      else
+        path = File.expand_path( @input || '.' )
+        if FileTest.directory? path
+          path << '/'
+        end
+        matches = Dir.glob( ( path + "*" ).gsub( /\*\*/, "*" ) )
+        if @on_dirs == :accept_dirs
+          matches = matches.select { |m| File.directory? m }
+        end
+      end
+      matches.sort!
+
+      if matches.length == 1
+        @input = matches[ 0 ]
+        cursor_write_input
+        File.open( @list_filename, "w" ) do |f|
+          if @completion_array.nil?
+            f.puts "(unique)"
+          else
+            f.puts @input
+          end
+        end
+        if @completion_array.nil? && FileTest.directory?( @input )
+          @input << "/"
+          cursor_write_input
+          if @on_dirs != :accept_dirs
+            complete_input
+          end
+        end
+      elsif matches.length > 1
+        common = matches[ 0 ]
+        File.open( @list_filename, "w" ) do |f|
+          i = nil
+          matches.each do |match|
+            f.print match
+            if FileTest.directory?( match )
+              f.print '/'
+            end
+            f.puts
+
+            if match[ 0 ] != common[ 0 ]
+              common = nil
+              break
+            end
+
+            up_to = [ common.length - 1, match.length - 1 ].min
+            i = 1
+            while ( i <= up_to ) && ( match[ 0..i ] == common[ 0..i ] )
+              i += 1
+            end
+            common = common[ 0...i ]
+          end
+        end
+        if common.nil?
+          File.open( @list_filename, "w" ) do |f|
+            f.puts "(no matches)"
+          end
+        else
+          @input = common
+          cursor_write_input
+        end
+      else
+        File.open( @list_filename, "w" ) do |f|
+          f.puts "(no matches)"
+        end
+      end
+      @list_manager.open_list_buffer
+      @window.setpos( @window.cury, @window.curx )
+    end
+
+  end
+
+end

data/lib/diakonos/search.rb

@@ -0,0 +1,58 @@
+module Diakonos
+  class Diakonos
+
+    # @return [Integer] the number of replacements made
+    def find_( options = {} )
+      regexp_source, replacement = options.values_at( :regexp_source, :replacement )
+      return  if regexp_source.nil? || regexp_source.empty?
+
+      rs_array = regexp_source.newline_split
+      regexps = Array.new
+      exception_thrown = nil
+
+      rs_array.each do |source|
+        begin
+          warning_verbosity = $VERBOSE
+          $VERBOSE = nil
+          regexps << Regexp.new(
+            source,
+            options[:case_sensitive] ? nil : Regexp::IGNORECASE
+          )
+          $VERBOSE = warning_verbosity
+        rescue RegexpError => e
+          if ! exception_thrown
+            exception_thrown = e
+            source = Regexp.escape( source )
+            retry
+          else
+            raise e
+          end
+        end
+      end
+
+      if replacement == ASK_REPLACEMENT
+        replacement = get_user_input( "Replace with: ", history: @rlh_search )
+      end
+
+      if exception_thrown && ! options[:quiet]
+        set_iline "Searching literally; #{exception_thrown.message}"
+      end
+
+      # The execution order of the #find and the @last_search_regexps assignment is likely deliberate
+      num_replacements = buffer_current.find(
+        regexps,
+        :direction          => options[:direction],
+        :replacement        => replacement,
+        :starting_row       => options[:starting_row],
+        :starting_col       => options[:starting_col],
+        :quiet              => options[:quiet],
+        :show_context_after => @settings[ 'find.show_context_after' ],
+        :starting           => true
+      )
+      @last_search_regexps = regexps
+
+      num_replacements
+    end
+
+  end
+end

data/lib/diakonos/sessions.rb

@@ -0,0 +1,257 @@
+module Diakonos
+  class Session
+    attr_reader :filename, :settings, :name, :dir, :buffers, :readline_histories
+    attr_accessor :buffer_current
+
+    def initialize(filepath, data = nil)
+      if data.nil?
+        @filename = File.expand_path(filepath)
+        @settings = Hash.new
+
+        basename = File.basename(filepath)
+        if ! Session.pid_session?(filepath)
+          @name = basename
+        end
+
+        @buffers = []
+        @buffer_current = 1
+        self.dir = Dir.getwd
+      else
+        @filename = data['filename']
+        @settings = data['settings']
+        @name = data['name']
+        @buffers = data['buffers']
+        @buffer_current = data['buffer_current'] || 1
+        self.dir = data['dir']
+      end
+    end
+
+    def to_yaml
+      {
+        'filename' => @filename,
+        'settings' => @settings,
+        'name' => @name,
+        'buffer_current' => @buffer_current,
+        'dir' => @dir,
+        'buffers' => @buffers,
+        'readline_histories' => @readline_histories
+      }.to_yaml
+    end
+
+    def set_buffers(buffers)
+      @buffers = buffers.reject { |buffer|
+        buffer.name.nil?
+      }.collect { |buffer|
+        {
+          'filepath' => buffer.name,
+          'read_only' => buffer.read_only,
+          'cursor'   => {
+            'row' => buffer.last_row,
+            'col' => buffer.last_col,
+          },
+          'display'  => {
+            'top_line'    => buffer.top_line,
+            'left_column' => buffer.left_column
+          },
+          'last_search_regexps' => buffer.last_search_regexps.map { |r| r.to_s },
+        }
+      }.compact
+    end
+
+    def set_readline_histories(rlh_general, rlh_files, rlh_search, rlh_shell, rlh_help, rlh_sessions)
+      @readline_histories = {
+        'general'  => rlh_general,
+        'files'    => rlh_files,
+        'search'   => rlh_search,
+        'shell'    => rlh_shell,
+        'help'     => rlh_help,
+        'sessions' => rlh_sessions,
+      }
+    end
+
+    def dir=(new_dir)
+      @dir = new_dir
+      Dir.chdir new_dir
+    end
+
+    # @return [Session] The Session created from the YAML data in the specified file
+    #   or nil on failure to load
+    def self.from_yaml_file(yaml_filename)
+      return nil  if ! File.exist?(yaml_filename)
+      session = nil
+
+      File.open(yaml_filename) do |f|
+        loaded = YAML::load(f) or break
+
+        if(
+          loaded[ 'filename' ] &&
+          loaded[ 'settings' ] &&
+          loaded[ 'settings' ].respond_to?( :values ) &&
+          loaded.has_key?( 'name' ) &&
+          (
+            loaded[ 'files' ] &&
+            loaded[ 'files' ].respond_to?( :each ) ||
+            loaded[ 'buffers' ] &&
+            loaded[ 'buffers' ].respond_to?( :each )
+          )
+        )
+          # Convert old sessions
+          if loaded[ 'files' ]
+            loaded[ 'buffers' ] = loaded[ 'files' ].map { |f|
+              Session.file_hash_for f
+            }
+            loaded.delete 'files'
+          end
+
+          session = Session.new(loaded['filename'], loaded)
+        end
+      end
+
+      session
+    end
+
+    def self.pid_session?(path)
+      %r{/\d+$} === path
+    end
+
+    def self.file_hash_for(filepath)
+      filepath, line_number = ::Diakonos.parse_filename_and_line_number(filepath)
+      {
+        'filepath'  => filepath,
+        'read_only' => false,
+        'cursor'    => {
+          'row' => line_number || 0,
+          'col' => 0,
+        },
+        'display'   => {
+          'top_line'    => 0,
+          'left_column' => 0
+        },
+      }
+    end
+
+  end
+
+  class Diakonos
+    attr_reader :session
+
+    def initialize_session
+      @session_dir = "#{@diakonos_home}/sessions"
+      mkdir @session_dir
+      @session = Session.new("#{@session_dir}/#{Process.pid}")
+    end
+
+    def load_session( session_file )
+      cleanup_session
+      @session = Session.from_yaml_file(session_file)
+      if @session
+        @files.concat @session.buffers
+        rlh = @session.readline_histories
+        if rlh
+          @rlh_general  = rlh['general'] || @rlh_general
+          @rlh_files    = rlh['files'] || @rlh_files
+          @rlh_search   = rlh['search'] || @rlh_search
+          @rlh_shell    = rlh['shell'] || @rlh_shell
+          @rlh_help     = rlh['help'] || @rlh_help
+          @rlh_sessions = rlh['sessions'] || @rlh_sessions
+        end
+        merge_session_settings
+      end
+    end
+
+    def save_session( session_file = @session.filename )
+      return  if session_file.nil?
+      return  if @testing && Session.pid_session?(session_file)
+
+      @session.set_buffers(@buffers)
+      @session.set_readline_histories(@rlh_general, @rlh_files, @rlh_search, @rlh_shell, @rlh_help, @rlh_sessions)
+
+      File.open( session_file, 'w' ) do |f|
+        f.puts @session.to_yaml
+      end
+    end
+
+    def session_filepath_for( session_id )
+      if session_id && session_id !~ %r{/}
+        "#{@session_dir}/#{session_id}"
+      else
+        session_id
+      end
+    end
+
+    def session_startup
+      @stale_session_files = []
+
+      if @session_to_load
+        pid_session = @session
+        @session = nil
+        session_path = session_filepath_for( @session_to_load )
+        load_session session_path
+        if ! @session
+          @session = Session.new(session_path)
+        end
+      else
+        session_files = Dir[ "#{@session_dir}/*" ].grep( %r{/\d+$} )
+        session_files.each do |sf|
+          pid = sf[ %r{/(\d+)$}, 1 ].to_i
+
+          # Check if the process is still alive
+          begin
+            Process.kill 0, pid
+          rescue Errno::ESRCH, Errno::EPERM
+            if Session.pid_session?(sf)
+              @stale_session_files << sf
+            end
+          end
+        end
+      end
+    end
+
+    # We have to do this separately and later (as opposed to inside #session_startup)
+    # because we have to wait for the display to get initialized in order to
+    # prompt the user for input, etc.
+    def handle_stale_session_files
+      return  if @testing
+      return  if @stale_session_files.empty?
+
+      session_buffers = []
+      @stale_session_files.each_with_index do |session_file,index|
+        session_buffers << open_file( session_file )
+
+        choice = get_choice(
+          "#{@stale_session_files.size} unclosed session(s) found.  Open the above files?  (session #{index+1} of #{@stale_session_files.size})",
+          [ CHOICE_YES, CHOICE_NO, CHOICE_DELETE ],
+          index > 0 ?  CHOICE_NO : nil
+        )
+
+        case choice
+        when CHOICE_YES
+          load_session session_file
+          if @session
+            File.delete session_file
+            break
+          end
+        when CHOICE_DELETE
+          File.delete session_file
+        end
+      end
+
+      if session_buffers.empty? && @files.empty? && @settings[ 'session.default_session' ]
+        session_file = session_filepath_for( @settings[ 'session.default_session' ] )
+        if File.exist? session_file
+          load_session session_file
+        end
+      end
+
+      session_buffers.each do |buffer|
+        close_buffer buffer
+      end
+    end
+
+    def cleanup_session
+      if @session && Session.pid_session?(@session.filename) && File.exist?(@session.filename)
+        File.delete @session.filename
+      end
+    end
+  end
+end

data/lib/diakonos/sized-array.rb

@@ -0,0 +1,48 @@
+class SizedArray < Array
+    attr_reader :capacity
+
+    def initialize( capacity = 10, *args )
+        @capacity = capacity
+        super( *args )
+    end
+
+    def resize
+        if size > @capacity
+            slice!( (0...-@capacity) )
+        end
+    end
+    private :resize
+
+    def concat( other_array )
+        super( other_array )
+        resize
+        self
+    end
+
+    def fill( *args )
+        retval = super( *args )
+        resize
+        self
+    end
+
+    def <<( item )
+        retval = super( item )
+        if size > @capacity
+            retval = shift
+        end
+        retval
+    end
+
+    def push( item )
+        self << item
+    end
+
+    def unshift( item )
+        retval = super( item )
+        if size > @capacity
+            retval = pop
+        end
+        retval
+    end
+end
+

data/lib/diakonos/text-mark.rb

@@ -0,0 +1,19 @@
+require 'diakonos/range'
+
+module Diakonos
+
+  class TextMark
+    attr_reader :formatting
+    include RangeDelegator
+
+    def initialize( range, formatting )
+      @range = range
+      @formatting = formatting
+    end
+
+    def to_s
+      "(#{@range.start_row},#{@range.start_col})-(#{@range.end_row},#{@range.end_col}) #{formatting}"
+    end
+  end
+
+end