diakonos 0.8.6 → 0.8.7

data/lib/diakonos/clipboard.rb

@@ -7,18 +7,18 @@ module Diakonos
     end
     
     def [] ( arg )
-      return @clips[ arg ]
+      @clips[ arg ]
     end
     
     def clip
-      return @clips[ 0 ]
+      @clips[ 0 ]
     end
     
     # text is an array of Strings
     # Returns true iff a clip was added,
     # and only non-nil text can be added.
     def addClip( text )
-      return false if text == nil
+      return false if text.nil?
       @clips.unshift text
       @clips.pop if @clips.length > @max_clips
       true
@@ -40,7 +40,7 @@ module Diakonos
       last_clip = @clips[ 0 ]
       last_clip.pop if last_clip[ -1 ] == ""
       @clips[ 0 ] = last_clip + text
-      return true
+      true
     end
   end
   

data/lib/diakonos/config.rb

@@ -0,0 +1,304 @@
+module Diakonos
+
+  BOL_ZERO           = 0
+  BOL_FIRST_CHAR     = 1
+  BOL_ALT_ZERO       = 2
+  BOL_ALT_FIRST_CHAR = 3
+
+  EOL_END           = 0
+  EOL_LAST_CHAR     = 1
+  EOL_ALT_END       = 2
+  EOL_ALT_LAST_CHAR = 3
+
+  class Diakonos
+    attr_reader :token_regexps, :close_token_regexps, :token_formats, :diakonos_conf
+
+    def fetch_conf( location = "v#{VERSION}" )
+      require 'open-uri'
+      found = false
+      puts "Fetching configuration from #{location}..."
+
+      begin
+        open( "http://github.com/Pistos/diakonos/tree/#{location}/diakonos.conf?raw=true" ) do |http|
+          text = http.read
+          if text =~ /key/ and text =~ /colour/ and text =~ /lang/
+            found = true
+            File.open( @diakonos_conf, 'w' ) do |f|
+              f.puts text
+            end
+          end
+        end
+      rescue OpenURI::HTTPError => e
+        $stderr.puts "Failed to fetch from #{location}."
+      end
+
+      found
+    end
+
+    def loadConfiguration
+      # Set defaults first
+
+      existent = 0
+      conf_dirs = [
+        '/usr/local/etc/diakonos.conf',
+        '/usr/etc/diakonos.conf',
+        '/etc/diakonos.conf',
+        '/usr/local/share/diakonos/diakonos.conf',
+        '/usr/share/diakonos/diakonos.conf'
+      ]
+
+      conf_dirs.each do |conf_dir|
+        @global_diakonos_conf = conf_dir
+        if FileTest.exists? @global_diakonos_conf
+          existent += 1
+          break
+        end
+      end
+
+      @diakonos_conf = ( @config_filename or ( @diakonos_home + '/diakonos.conf' ) )
+      existent += 1 if FileTest.exists? @diakonos_conf
+
+      if existent < 1
+        if @testing
+          File.open( @diakonos_conf, 'w' ) do |f|
+            f.puts File.read( './diakonos.conf' )
+          end
+        else
+          puts "diakonos.conf not found in any of:"
+          conf_dirs.each do |conf_dir|
+            puts "   #{conf_dir}"
+          end
+          puts "   ~/.diakonos/"
+          puts "At least one configuration file must exist."
+          $stdout.puts "Would you like to download one right now from the Diakonos repository? (y/n)"; $stdout.flush
+          answer = $stdin.gets
+
+          case answer
+          when /^y/i
+            if not fetch_conf
+              fetch_conf 'master'
+            end
+          end
+        end
+
+        if not FileTest.exists?( @diakonos_conf )
+          puts "Terminating..."
+          exit 1
+        end
+      end
+
+      @logfilename = @diakonos_home + "/diakonos.log"
+      @keychains           = Hash.new
+      @token_regexps       = Hash.new
+      @close_token_regexps = Hash.new
+      @token_formats       = Hash.new
+      @indenters           = Hash.new
+      @unindenters         = Hash.new
+      @filemasks           = Hash.new
+      @bangmasks           = Hash.new
+      @closers             = Hash.new
+
+      @settings = Hash.new
+      # Setup some defaults
+      @settings[ "context.format" ] = Curses::A_REVERSE
+
+      @keychains[ Curses::KEY_RESIZE ] = [ "redraw", nil ]
+      @keychains[ RESIZE2 ] = [ "redraw", nil ]
+
+      @colour_pairs = Array.new
+
+      begin
+        parseConfigurationFile( @global_diakonos_conf )
+        parseConfigurationFile( @diakonos_conf )
+
+        # Session settings override config file settings.
+
+        @session[ 'settings' ].each do |key,value|
+          @settings[ key ] = value
+        end
+
+        @clipboard = Clipboard.new @settings[ "max_clips" ]
+        @log = File.open( @logfilename, "a" )
+
+        if @buffers
+          @buffers.each_value do |buffer|
+            buffer.configure
+          end
+        end
+      rescue Errno::ENOENT
+        # No config file found or readable
+      end
+    end
+
+    def parseConfigurationFile( filename )
+      return if not FileTest.exists? filename
+
+      lines = IO.readlines( filename ).collect { |l| l.chomp }
+      lines.each do |line|
+        # Skip comments
+        next if line[ 0 ] == ?#
+
+        command, arg = line.split( /\s+/, 2 )
+        next if command.nil?
+        command = command.downcase
+        case command
+        when "include"
+          parseConfigurationFile arg.subHome
+        when "key"
+          if arg
+            if /  / === arg
+              keystrings, function_and_args = arg.split( / {2,}/, 2 )
+            else
+              keystrings, function_and_args = arg.split( /;/, 2 )
+            end
+            keystrokes = Array.new
+            keystrings.split( /\s+/ ).each do |ks_str|
+              code = ks_str.keyCode
+              if code
+                keystrokes.concat code
+              else
+                puts "unknown keystring: #{ks_str}"
+              end
+            end
+            if function_and_args.nil?
+              @keychains.deleteKeyPath( keystrokes )
+            else
+              function, function_args = function_and_args.split( /\s+/, 2 )
+              @keychains.setKeyPath(
+                keystrokes,
+                [ function, function_args ]
+              )
+            end
+          end
+        when /^lang\.(.+?)\.tokens\.([^.]+)(\.case_insensitive)?$/
+          getTokenRegexp( @token_regexps, arg, Regexp.last_match )
+        when /^lang\.(.+?)\.tokens\.([^.]+)\.open(\.case_insensitive)?$/
+          getTokenRegexp( @token_regexps, arg, Regexp.last_match )
+        when /^lang\.(.+?)\.tokens\.([^.]+)\.close(\.case_insensitive)?$/
+          getTokenRegexp( @close_token_regexps, arg, Regexp.last_match )
+        when /^lang\.(.+?)\.tokens\.(.+?)\.format$/
+          language = $1
+          token_class = $2
+          @token_formats[ language ] = ( @token_formats[ language ] or Hash.new )
+          @token_formats[ language ][ token_class ] = arg.toFormatting
+        when /^lang\.(.+?)\.format\..+$/
+          @settings[ command ] = arg.toFormatting
+        when /^colou?r$/
+          number, fg, bg = arg.split( /\s+/ )
+          number = number.to_i
+          fg = fg.toColourConstant
+          bg = bg.toColourConstant
+          @colour_pairs << {
+            :number => number,
+            :fg => fg,
+            :bg => bg
+          }
+        when /^lang\.(.+?)\.indent\.indenters(\.case_insensitive)?$/
+          case_insensitive = ( $2 != nil )
+          if case_insensitive
+            @indenters[ $1 ] = Regexp.new( arg, Regexp::IGNORECASE )
+          else
+            @indenters[ $1 ] = Regexp.new arg
+          end
+        when /^lang\.(.+?)\.indent\.unindenters(\.case_insensitive)?$/
+          case_insensitive = ( $2 != nil )
+          if case_insensitive
+            @unindenters[ $1 ] = Regexp.new( arg, Regexp::IGNORECASE )
+          else
+            @unindenters[ $1 ] = Regexp.new arg
+          end
+        when /^lang\.(.+?)\.indent\.preventers(\.case_insensitive)?$/,
+          /^lang\.(.+?)\.indent\.ignore(\.case_insensitive)?$/,
+          /^lang\.(.+?)\.context\.ignore(\.case_insensitive)?$/
+          case_insensitive = ( $2 != nil )
+          if case_insensitive
+            @settings[ command ] = Regexp.new( arg, Regexp::IGNORECASE )
+          else
+            @settings[ command ] = Regexp.new arg
+          end
+        when /^lang\.(.+?)\.filemask$/
+          @filemasks[ $1 ] = Regexp.new arg
+        when /^lang\.(.+?)\.bangmask$/
+          @bangmasks[ $1 ] = Regexp.new arg
+        when /^lang\.(.+?)\.closers\.(.+?)\.(.+?)$/
+          @closers[ $1 ] ||= Hash.new
+          @closers[ $1 ][ $2 ] ||= Hash.new
+          @closers[ $1 ][ $2 ][ $3.to_sym ] = case $3
+        when 'regexp'
+          Regexp.new arg
+        when 'closer'
+          begin
+            eval( "Proc.new " + arg )
+          rescue Exception => e
+            showException(
+              e,
+              [
+                "Failed to process Proc for #{command}.",
+              ]
+            )
+          end
+        end
+        when "context.visible", "context.combined", "eof_newline", "view.nonfilelines.visible",
+          /^lang\.(.+?)\.indent\.(?:auto|roundup|using_tabs|closers)$/,
+          "found_cursor_start", "convert_tabs", 'delete_newline_on_delete_to_eol',
+          'suppress_welcome', 'strip_trailing_whitespace_on_save',
+          'find.return_on_abort', 'fuzzy_file_find'
+          @settings[ command ] = arg.to_b
+        when "context.format", "context.separator.format", "status.format"
+          @settings[ command ] = arg.toFormatting
+        when "logfile"
+          @logfilename = arg.subHome
+        when "context.separator", "status.left", "status.right", "status.filler",
+          "status.modified_str", "status.unnamed_str", "status.selecting_str",
+          "status.read_only_str", /^lang\..+?\.indent\.ignore\.charset$/,
+          /^lang\.(.+?)\.tokens\.([^.]+)\.change_to$/,
+          /^lang\.(.+?)\.column_delimiters$/,
+          "view.nonfilelines.character",
+          'interaction.blink_string', 'diff_command', 'session.default_session'
+          @settings[ command ] = arg
+        when /^lang\..+?\.comment_(?:close_)?string$/
+          @settings[ command ] = arg.gsub( /^["']|["']$/, '' )
+        when "status.vars"
+          @settings[ command ] = arg.split( /\s+/ )
+        when /^lang\.(.+?)\.indent\.size$/, /^lang\.(.+?)\.(?:tabsize|wrap_margin)$/
+          @settings[ command ] = arg.to_i
+        when "context.max_levels", "context.max_segment_width", "max_clips", "max_undo_lines",
+          "view.margin.x", "view.margin.y", "view.scroll_amount", "view.lookback", 'grep.context'
+          @settings[ command ] = arg.to_i
+        when "view.jump.x", "view.jump.y"
+          value = arg.to_i
+          if value < 1
+            value = 1
+          end
+          @settings[ command ] = value
+        when "bol_behaviour", "bol_behavior"
+          case arg.downcase
+          when "zero"
+            @settings[ "bol_behaviour" ] = BOL_ZERO
+          when "first-char"
+            @settings[ "bol_behaviour" ] = BOL_FIRST_CHAR
+          when "alternating-zero"
+            @settings[ "bol_behaviour" ] = BOL_ALT_ZERO
+          else # default
+            @settings[ "bol_behaviour" ] = BOL_ALT_FIRST_CHAR
+          end
+        when "eol_behaviour", "eol_behavior"
+          case arg.downcase
+          when "end"
+            @settings[ "eol_behaviour" ] = EOL_END
+          when "last-char"
+            @settings[ "eol_behaviour" ] = EOL_LAST_CHAR
+          when "alternating-last-char"
+            @settings[ "eol_behaviour" ] = EOL_ALT_FIRST_CHAR
+          else # default
+            @settings[ "eol_behaviour" ] = EOL_ALT_END
+          end
+        when "context.delay", 'interaction.blink_duration', 'interaction.choice_delay'
+          @settings[ command ] = arg.to_f
+        end
+      end
+    end
+    protected :parseConfigurationFile
+
+  end
+end

data/lib/diakonos/ctag.rb

@@ -11,12 +11,12 @@ class CTag
     end
     
     def to_s
-        return "#{@file}:#{@command} (#{@kind}) #{@rest}"
+        "#{@file}:#{@command} (#{@kind}) #{@rest}"
     end
     
     def == ( other )
-        return (
-            other != nil and
+        (
+            other and
             @file == other.file and
             @command == other.command and
             @kind == other.kind and

data/lib/diakonos/display.rb

@@ -0,0 +1,288 @@
+module Diakonos
+  DO_REDRAW             = true
+  DONT_REDRAW           = false
+
+  class Diakonos
+    attr_reader :win_main, :display_mutex
+
+    def initializeDisplay
+      @win_main.close if @win_main
+      @win_status.close if @win_status
+      @win_interaction.close if @win_interaction
+      @win_context.close if @win_context
+
+      Curses::init_screen
+      Curses::nonl
+      Curses::raw
+      Curses::noecho
+
+      if Curses::has_colors?
+        Curses::start_color
+        Curses::init_pair( Curses::COLOR_BLACK, Curses::COLOR_BLACK, Curses::COLOR_BLACK )
+        Curses::init_pair( Curses::COLOR_RED, Curses::COLOR_RED, Curses::COLOR_BLACK )
+        Curses::init_pair( Curses::COLOR_GREEN, Curses::COLOR_GREEN, Curses::COLOR_BLACK )
+        Curses::init_pair( Curses::COLOR_YELLOW, Curses::COLOR_YELLOW, Curses::COLOR_BLACK )
+        Curses::init_pair( Curses::COLOR_BLUE, Curses::COLOR_BLUE, Curses::COLOR_BLACK )
+        Curses::init_pair( Curses::COLOR_MAGENTA, Curses::COLOR_MAGENTA, Curses::COLOR_BLACK )
+        Curses::init_pair( Curses::COLOR_CYAN, Curses::COLOR_CYAN, Curses::COLOR_BLACK )
+        Curses::init_pair( Curses::COLOR_WHITE, Curses::COLOR_WHITE, Curses::COLOR_BLACK )
+        @colour_pairs.each do |cp|
+          Curses::init_pair( cp[ :number ], cp[ :fg ], cp[ :bg ] )
+        end
+      end
+
+      @win_main = Curses::Window.new( main_window_height, Curses::cols, 0, 0 )
+      @win_main.keypad( true )
+      @win_status = Curses::Window.new( 1, Curses::cols, Curses::lines - 2, 0 )
+      @win_status.keypad( true )
+      @win_status.attrset @settings[ 'status.format' ]
+      @win_interaction = Curses::Window.new( 1, Curses::cols, Curses::lines - 1, 0 )
+      @win_interaction.keypad( true )
+
+      if @settings[ 'context.visible' ]
+        if @settings[ 'context.combined' ]
+          pos = 1
+        else
+          pos = 3
+        end
+        @win_context = Curses::Window.new( 1, Curses::cols, Curses::lines - pos, 0 )
+        @win_context.keypad( true )
+      else
+        @win_context = nil
+      end
+
+      @win_interaction.refresh
+      @win_main.refresh
+
+      @buffers.each_value do |buffer|
+        buffer.reset_win_main
+      end
+    end
+
+    def getTokenRegexp( hash, arg, match )
+      language = match[ 1 ]
+      token_class = match[ 2 ]
+      case_insensitive = ( match[ 3 ] != nil )
+      hash[ language ] = ( hash[ language ] or Hash.new )
+      if case_insensitive
+        hash[ language ][ token_class ] = Regexp.new( arg, Regexp::IGNORECASE )
+      else
+        hash[ language ][ token_class ] = Regexp.new arg
+      end
+    end
+
+    def redraw
+      loadConfiguration
+      initializeDisplay
+      updateStatusLine
+      updateContextLine
+      @current_buffer.display
+    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" ] and not @settings[ "context.combined" ]
+        retval = retval - 1
+      end
+      retval
+    end
+
+    def main_window_width
+      Curses::cols
+    end
+
+    # Display text on the interaction line.
+    def setILine( string = "" )
+      Curses::curs_set 0
+      @win_interaction.setpos( 0, 0 )
+      @win_interaction.addstr( "%-#{Curses::cols}s" % string )
+      @win_interaction.refresh
+      Curses::curs_set 1
+      string.length
+    end
+
+    def set_status_variable( identifier, value )
+      @status_vars[ identifier ] = value
+    end
+
+    def buildStatusLine( truncation = 0 )
+      var_array = Array.new
+      @settings[ "status.vars" ].each do |var|
+        case var
+        when "buffer_number"
+          var_array.push bufferToNumber( @current_buffer )
+        when "col"
+          var_array.push( @current_buffer.last_screen_col + 1 )
+        when "filename"
+          name = @current_buffer.nice_name
+          var_array.push name[ ([ truncation, name.length ].min)..-1 ]
+        when "modified"
+          if @current_buffer.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 @current_buffer.length
+        when "row", "line"
+          var_array.push( @current_buffer.last_row + 1 )
+        when "read_only"
+          if @current_buffer.read_only
+            var_array.push @settings[ "status.read_only_str" ]
+          else
+            var_array.push ""
+          end
+        when "selecting"
+          if @current_buffer.changing_selection
+            var_array.push @settings[ "status.selecting_str" ]
+          else
+            var_array.push ""
+          end
+        when 'session_name'
+          var_array.push @session[ 'name' ]
+        when "type"
+          var_array.push @current_buffer.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 => e
+        str = "%-#{Curses::cols}s" % "(status line configuration error)"
+      end
+      str
+    end
+    protected :buildStatusLine
+
+    def updateStatusLine
+      str = buildStatusLine
+      if str.length > Curses::cols
+        str = buildStatusLine( 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 updateContextLine
+      if @win_context
+        @context_thread.exit if @context_thread
+        @context_thread = Thread.new do ||
+
+          context = @current_buffer.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" ] or 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
+
+          @iline_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( @current_buffer.last_screen_y, @current_buffer.last_screen_x )
+            @win_main.refresh
+          end
+          Curses::curs_set 1
+        end
+
+        @context_thread.priority = -2
+      end
+    end
+
+    def displayEnqueue( buffer )
+      @display_queue_mutex.synchronize do
+        @display_queue = buffer
+      end
+    end
+
+    def displayDequeue
+      @display_queue_mutex.synchronize do
+        if @display_queue
+          Thread.new( @display_queue ) do |b|
+            @display_mutex.lock
+            @display_mutex.unlock
+            b.display
+          end
+          @display_queue = nil
+        end
+      end
+    end
+
+    def showMessage( message, non_interaction_duration = @settings[ 'interaction.choice_delay' ] )
+      terminateMessage
+
+      @message_expiry = Time.now + non_interaction_duration
+      @message_thread = Thread.new do
+        time_left = @message_expiry - Time.now
+        while time_left > 0
+          setILine "(#{time_left.round}) #{message}"
+          @win_main.setpos( @saved_main_y, @saved_main_x )
+          sleep 1
+          time_left = @message_expiry - Time.now
+        end
+        setILine message
+        @win_main.setpos( @saved_main_y, @saved_main_x )
+      end
+    end
+
+    def terminateMessage
+      if @message_thread and @message_thread.alive?
+        @message_thread.terminate
+        @message_thread = nil
+      end
+    end
+
+    def refreshAll
+      @win_main.refresh
+      if @win_context
+        @win_context.refresh
+      end
+      @win_status.refresh
+      @win_interaction.refresh
+    end
+
+  end
+end