diakonos 0.8.11 → 0.9.9

data/lib/diakonos/display/format.rb

@@ -0,0 +1,75 @@
+module Diakonos
+  module Display
+    def self.to_colour_constant( str )
+      case str.downcase
+      when "black", "0"
+        Curses::COLOR_BLACK
+      when "red", "1"
+        Curses::COLOR_RED
+      when "green", "2"
+        Curses::COLOR_GREEN
+      when "yellow", "brown", "3"
+        Curses::COLOR_YELLOW
+      when "blue", "4"
+        Curses::COLOR_BLUE
+      when "magenta", "purple", "5"
+        Curses::COLOR_MAGENTA
+      when "cyan", "6"
+        Curses::COLOR_CYAN
+      when "white", "7"
+        Curses::COLOR_WHITE
+      else
+        str.to_i
+      end
+    end
+
+    def self.to_formatting( str )
+      formatting = Curses::A_NORMAL
+
+      str.split( /\s+/ ).each do |format|
+        colour_number = format.to_i
+        if colour_number > Curses::COLOR_WHITE
+          formatting |= Curses::color_pair( colour_number )
+        elsif format.downcase == 'normal'
+          formatting = Curses::A_NORMAL
+        else
+          formatting |= case format.downcase
+          when "black", "0"
+            Curses::color_pair( Curses::COLOR_BLACK )
+          when "red", "1"
+            Curses::color_pair( Curses::COLOR_RED )
+          when "green", "2"
+            Curses::color_pair( Curses::COLOR_GREEN )
+          when "yellow", "brown", "3"
+            Curses::color_pair( Curses::COLOR_YELLOW )
+          when "blue", "4"
+            Curses::color_pair( Curses::COLOR_BLUE )
+          when "magenta", "purple", "5"
+            Curses::color_pair( Curses::COLOR_MAGENTA )
+          when "cyan", "6"
+            Curses::color_pair( Curses::COLOR_CYAN )
+          when "white", "7"
+            Curses::color_pair( Curses::COLOR_WHITE )
+          when "standout", "s", "so"
+            Curses::A_STANDOUT
+          when "underline", "u", "un", "ul"
+            Curses::A_UNDERLINE
+          when "reverse", "r", "rev", "inverse", "i", "inv"
+            Curses::A_REVERSE
+          when "blink", "bl", "blinking"
+            Curses::A_BLINK
+          when "dim", "d"
+            Curses::A_DIM
+          when "bold", "b", "bo"
+            Curses::A_BOLD
+          else
+            0
+          end
+        end
+      end
+
+      formatting
+    end
+
+  end
+end

data/lib/diakonos/display.rb

@@ -0,0 +1,336 @@
+require 'curses'
+
+module Diakonos
+  DO_REDRAW             = true
+  DONT_REDRAW           = false
+
+  class Diakonos
+    attr_reader :win_main, :display_mutex, :win_line_numbers
+
+    def cleanup_display
+      return  if @testing
+
+      @win_main.close          if @win_main
+      @win_status.close        if @win_status
+      @win_interaction.close   if @win_interaction
+      @win_context.close       if @win_context
+      @win_line_numbers.close  if @win_line_numbers
+
+      Curses::close_screen
+    end
+
+    def initialize_display
+      if ! @testing
+        cleanup_display
+
+        Curses::init_screen
+        Curses::nonl
+        Curses::raw
+        Curses::noecho
+        if @settings['mouse']
+          Curses::mousemask(Curses::ALL_MOUSE_EVENTS)
+        end
+
+        if Curses::has_colors?
+          Curses::start_color
+          Curses::use_default_colors
+
+          # -1 means use the terminal's current/default background, which may even have some transparency
+          background_colour = settings['colour.background'] || -1
+          Curses::init_pair( Curses::COLOR_BLACK, Curses::COLOR_BLACK, background_colour )
+          Curses::init_pair( Curses::COLOR_RED, Curses::COLOR_RED, background_colour )
+          Curses::init_pair( Curses::COLOR_GREEN, Curses::COLOR_GREEN, background_colour )
+          Curses::init_pair( Curses::COLOR_YELLOW, Curses::COLOR_YELLOW, background_colour )
+          Curses::init_pair( Curses::COLOR_BLUE, Curses::COLOR_BLUE, background_colour )
+          Curses::init_pair( Curses::COLOR_MAGENTA, Curses::COLOR_MAGENTA, background_colour )
+          Curses::init_pair( Curses::COLOR_CYAN, Curses::COLOR_CYAN, background_colour )
+          Curses::init_pair( Curses::COLOR_WHITE, Curses::COLOR_WHITE, background_colour )
+          @colour_pairs.each do |cp|
+            Curses::init_pair( cp[ :number ], cp[ :fg ], cp[ :bg ] )
+          end
+        end
+      end
+
+      if settings[ 'view.line_numbers' ]
+        @win_line_numbers = ::Diakonos::Window.new( main_window_height, settings[ 'view.line_numbers.width' ], 0, 0 )
+        @win_main = ::Diakonos::Window.new( main_window_height, Curses::cols - settings[ 'view.line_numbers.width' ], 0, settings[ 'view.line_numbers.width' ] )
+      else
+        @win_main = ::Diakonos::Window.new( main_window_height, Curses::cols, 0, 0 )
+        @win_line_numbers = nil
+      end
+      @win_status = ::Diakonos::Window.new( 1, Curses::cols, Curses::lines - 2, 0 )
+      @win_status.attrset @settings[ 'status.format' ]
+      @win_interaction = ::Diakonos::Window.new( 1, Curses::cols, Curses::lines - 1, 0 )
+
+      @interaction_handler = InteractionHandler.new(
+        win_main: @win_main,
+        win_interaction: @win_interaction,
+        cursor_manager: self,
+        testing: @testing,
+        choice_delay: @settings['interaction.choice_delay'],
+        blink_string: @settings['interaction.blink_string'],
+        blink_duration: @settings['interaction.blink_duration']
+      )
+
+      if @settings['context.visible']
+        if @settings['context.combined']
+          pos = 1
+        else
+          pos = 3
+        end
+        @win_context = ::Diakonos::Window.new( 1, Curses::cols, Curses::lines - pos, 0 )
+      else
+        @win_context = nil
+      end
+
+      if ! @testing
+        @win_main.keypad( true )
+        @win_status.keypad( true )
+        @win_interaction.keypad( true )
+        if @win_line_numbers
+          @win_line_numbers.keypad( true )
+        end
+        if @win_context
+          @win_context.keypad( true )
+        end
+      end
+
+      @modes[ 'edit' ].window = @win_main
+      @modes[ 'input' ].window = @win_interaction
+
+      @win_interaction.refresh
+      @win_main.refresh
+      if @win_line_numbers
+        @win_line_numbers.refresh
+      end
+
+      if @buffers
+        @buffers.each do |buffer|
+          buffer.reset_display
+        end
+      end
+    end
+
+    def redraw
+      load_configuration
+      initialize_display
+      update_status_line
+      update_context_line
+      display_buffer buffer_current
+    end
+
+    def main_window_height
+      # One line for the status line
+      # One line for the input line
+      # One line for the context line
+      retval = Curses::lines - 2
+      if @settings['context.visible'] && ! @settings['context.combined']
+        retval = retval - 1
+      end
+      retval
+    end
+
+    def main_window_width
+      Curses::cols
+    end
+
+    def set_iline(s = "")
+      @interaction_handler.set_iline s
+    end
+
+    def set_iline_if_empty(s)
+      @interaction_handler.set_iline_if_empty s
+    end
+
+    def set_status_variable( identifier, value )
+      @status_vars[ identifier ] = value
+    end
+
+    def build_status_line( truncation = 0 )
+      var_array = Array.new
+      @settings[ "status.vars" ].each do |var|
+        case var
+        when "buffer_number"
+          var_array.push buffer_to_number( buffer_current )
+        when "col"
+          var_array.push( buffer_current.last_screen_col + 1 )
+        when "filename"
+          name = buffer_current.nice_name
+          var_array.push name[ ([ truncation, name.length ].min)..-1 ]
+        when "modified"
+          if buffer_current.modified?
+            var_array.push @settings[ "status.modified_str" ]
+          else
+            var_array.push ""
+          end
+        when "num_buffers"
+          var_array.push @buffers.length
+        when "num_lines"
+          var_array.push buffer_current.length
+        when "row", "line"
+          var_array.push( buffer_current.last_row + 1 )
+        when "read_only"
+          if buffer_current.read_only
+            var_array.push @settings[ "status.read_only_str" ]
+          else
+            var_array.push ""
+          end
+        when "selecting"
+          if buffer_current.changing_selection
+            var_array.push @settings[ "status.selecting_str" ]
+          else
+            var_array.push ""
+          end
+        when 'selection_mode'
+          case buffer_current.selection_mode
+          when :block
+            var_array.push 'block'
+          else
+            var_array.push ''
+          end
+        when 'session_name'
+          var_array.push @session.name
+        when "type"
+          var_array.push buffer_current.original_language
+        when /^@/
+          var_array.push @status_vars[ var ]
+        end
+      end
+      str = nil
+      begin
+        status_left = @settings[ "status.left" ]
+        field_count = status_left.count "%"
+        status_left = status_left % var_array[ 0...field_count ]
+        status_right = @settings[ "status.right" ] % var_array[ field_count..-1 ]
+        filler_string = @settings[ "status.filler" ]
+        fill_amount = (Curses::cols - status_left.length - status_right.length) / filler_string.length
+        if fill_amount > 0
+          filler = filler_string * fill_amount
+        else
+          filler = ""
+        end
+        str = status_left + filler + status_right
+      rescue ArgumentError, TypeError => e
+        debug_log e
+        debug_log e.backtrace[ 0 ]
+        debug_log "var_array: #{var_array.inspect}"
+        str = "%-#{Curses::cols}s" % "(status line configuration error)"
+      end
+      str
+    end
+    protected :build_status_line
+
+    def update_status_line
+      return  if @testing
+
+      str = build_status_line
+      if str.length > Curses::cols
+        str = build_status_line( str.length - Curses::cols )
+      end
+      Curses::curs_set 0
+      @win_status.setpos( 0, 0 )
+      @win_status.addstr str
+      @win_status.refresh
+      Curses::curs_set 1
+    end
+
+    def update_context_line
+      return  if @testing
+      return  if @win_context.nil?
+
+      @context_thread.exit  if @context_thread
+      @context_thread = Thread.new do
+        context = buffer_current.context
+
+        Curses::curs_set 0
+        @win_context.setpos( 0, 0 )
+        chars_printed = 0
+        if context.length > 0
+          truncation = [ @settings[ "context.max_levels" ], context.length ].min
+          max_length = [
+            ( Curses::cols / truncation ) - @settings[ "context.separator" ].length,
+            ( @settings[ "context.max_segment_width" ] || Curses::cols )
+          ].min
+          line = nil
+          context_subset = context[ 0...truncation ]
+          context_subset = context_subset.collect do |line|
+            line.strip[ 0...max_length ]
+          end
+
+          context_subset.each do |line|
+            @win_context.attrset @settings[ "context.format" ]
+            @win_context.addstr line
+            chars_printed += line.length
+            @win_context.attrset @settings[ "context.separator.format" ]
+            @win_context.addstr @settings[ "context.separator" ]
+            chars_printed += @settings[ "context.separator" ].length
+          end
+        end
+
+        @context_line_mutex.synchronize do
+          @win_context.attrset @settings[ "context.format" ]
+          @win_context.addstr( " " * ( Curses::cols - chars_printed ) )
+          @win_context.refresh
+        end
+        @display_mutex.synchronize do
+          @win_main.setpos( buffer_current.last_screen_y, buffer_current.last_screen_x )
+          @win_main.refresh
+        end
+        Curses::curs_set 1
+      end
+
+      @context_thread.priority = -2
+    end
+
+    def display_buffer( buffer )
+      return  if @testing
+      return  if ! @do_display
+
+      Thread.new do
+
+        if ! @display_mutex.try_lock
+          @display_queue_mutex.synchronize do
+            @display_queue = buffer
+          end
+        else
+          begin
+            Curses::curs_set 0
+            buffer.display
+            Curses::curs_set 1
+          rescue Exception => e
+            $diakonos.log( "Display Exception:" )
+            $diakonos.log( e.message )
+            $diakonos.log( e.backtrace.join( "\n" ) )
+            show_exception e
+          end
+
+          @display_mutex.unlock
+
+          @display_queue_mutex.synchronize do
+            if @display_queue
+              b = @display_queue
+              @display_queue = nil
+              display_buffer b
+            end
+          end
+        end
+
+      end
+
+    end
+
+    def refresh_all
+      @win_main.refresh
+      if @win_context
+        @win_context.refresh
+      end
+      @win_status.refresh
+      @win_interaction.refresh
+      if @win_line_numbers
+        @win_line_numbers.refresh
+      end
+    end
+
+  end
+
+end

data/lib/diakonos/extension-set.rb

@@ -0,0 +1,49 @@
+module Diakonos
+
+  class ExtensionSet
+
+    def initialize( root_dir )
+      @extensions = Hash.new
+      @root_dir = File.expand_path( root_dir )
+    end
+
+    def scripts
+      @extensions.values.find_all { |e| e }.map { |e| e.scripts }.flatten
+    end
+
+    # @return an Array of configuration filenames to parse
+    def load( dir )
+      @extensions[ dir ] = false
+
+      confs_to_parse = []
+      ext_dir = File.join( @root_dir, dir )
+      info = YAML.load_file( File.join( ext_dir, 'info.yaml' ) )
+
+      if info[ 'requirements' ] && info[ 'requirements' ][ 'diakonos' ]
+        this_version = ::Diakonos.parse_version( ::Diakonos::VERSION )
+        min_version = ::Diakonos.parse_version( info[ 'requirements' ][ 'diakonos' ][ 'minimum' ] )
+        if min_version && this_version >= min_version
+          extension = Extension.new( ext_dir )
+          @extensions[ dir ] = extension
+          confs_to_parse += extension.confs
+        end
+      end
+
+      confs_to_parse
+    end
+
+    def loaded?( ext_dir )
+      @extensions[ ext_dir ]
+    end
+
+    def loaded_extensions
+      @extensions.values.find_all { |e| e }
+    end
+
+    def not_loaded_extensions
+      @extensions.keys.find_all { |e| ! loaded?( e ) }
+    end
+
+  end
+
+end

data/lib/diakonos/extension.rb

@@ -0,0 +1,34 @@
+module Diakonos
+
+  class Extension
+
+    attr_reader :dir, :scripts, :confs
+
+    def initialize( dir )
+      @scripts = []
+      @confs = []
+      @dir = File.basename( dir )
+      @info = YAML.load_file( File.join( dir, 'info.yaml' ) )
+
+      Dir[ File.join( dir, '**', '*.rb' ) ].each do |ext_file|
+        @scripts << ext_file
+      end
+
+      Dir[ File.join( dir, "*.conf" ) ].each do |conf_file|
+        @confs << conf_file
+      end
+    end
+
+    def []( key )
+      @info[ key ]
+    end
+
+    [ 'name', 'description', 'version' ].each do |m|
+      define_method( m ) do
+        @info[ m ]
+      end
+    end
+
+  end
+
+end

data/lib/diakonos/finding.rb

@@ -0,0 +1,40 @@
+module Diakonos
+
+  class Finding
+    include RangeDelegator
+
+    def self.confirm(range_, regexps, lines, search_area, regexp_match)
+      matches = true
+      range = range_.dup
+
+      i = range.start_row + 1
+      regexps[1..-1].each do |re|
+        if lines[i] !~ re
+          matches = false
+          break
+        end
+        range.end_row = i
+        range.end_col = Regexp.last_match[0].length
+        i += 1
+      end
+
+      if (
+        matches &&
+        search_area.contains?( range.start_row, range.start_col ) &&
+        search_area.contains?( range.end_row, range.end_col - 1 )
+      )
+        Finding.new(range, regexp_match)
+      end
+    end
+
+    def initialize(range, regexp_match)
+      @range = range
+      @regexp_match = regexp_match
+    end
+
+    def captured_group(index)
+      @regexp_match[index]
+    end
+  end
+
+end

data/lib/diakonos/functions/basics.rb

@@ -0,0 +1,34 @@
+module Diakonos
+  module Functions
+
+    # Move one character left, then delete one character.
+    #
+    # @see Diakonos::Buffer#delete
+    def backspace
+      if( buffer_current.changing_selection || cursor_left( Buffer::STILL_TYPING ) )
+        delete
+      end
+    end
+
+    # Insert a carriage return (newline) at the current cursor location.
+    # Deletes any currently selected text.
+    def carriage_return
+      buffer_current.carriage_return
+      buffer_current.delete_selection
+    end
+
+    # Calls Buffer#delete on the current buffer.
+    def delete
+      buffer_current.delete
+    end
+
+    # Deletes the current line and adds it to the clipboard.
+    def delete_line
+      removed_text = buffer_current.delete_line
+      if removed_text
+        @clipboard.add_clip( [ removed_text, "" ] )
+      end
+    end
+
+  end
+end

data/lib/diakonos/functions/bookmarking.rb

@@ -0,0 +1,61 @@
+module Diakonos
+  module Functions
+
+    def add_named_bookmark( name_ = nil )
+      if name_.nil?
+        name = get_user_input "Bookmark name: "
+      else
+        name = name_
+      end
+
+      if name
+        @bookmarks[ name ] = Bookmark.new( buffer_current, buffer_current.current_row, buffer_current.current_column, name )
+        set_iline "Added bookmark #{@bookmarks[ name ].to_s}."
+      end
+    end
+
+    def go_to_named_bookmark( name_ = nil )
+      if name_.nil?
+        name = get_user_input "Bookmark name: "
+      else
+        name = name_
+      end
+
+      if name
+        bookmark = @bookmarks[ name ]
+        if bookmark
+          switch_to( bookmark.buffer )
+          bookmark.buffer.cursor_to( bookmark.row, bookmark.col, Buffer::DO_DISPLAY )
+        else
+          set_iline "No bookmark named '#{name}'."
+        end
+      end
+    end
+
+    def go_to_next_bookmark
+      buffer_current.go_to_next_bookmark
+    end
+
+    def go_to_previous_bookmark
+      buffer_current.go_to_previous_bookmark
+    end
+
+    def remove_named_bookmark( name_ = nil )
+      if name_.nil?
+        name = get_user_input "Bookmark name: "
+      else
+        name = name_
+      end
+
+      if name
+        bookmark = @bookmarks.delete name
+        set_iline "Removed bookmark #{bookmark.to_s}."
+      end
+    end
+
+    def toggle_bookmark
+      buffer_current.toggle_bookmark
+    end
+
+  end
+end