diakonos 0.8.7 → 0.8.8

data/lib/diakonos/clipboard.rb

@@ -1,47 +0,0 @@
-module Diakonos
-  
-  class Clipboard
-    def initialize( max_clips )
-      @clips = Array.new
-      @max_clips = max_clips
-    end
-    
-    def [] ( arg )
-      @clips[ arg ]
-    end
-    
-    def clip
-      @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?
-      @clips.unshift text
-      @clips.pop if @clips.length > @max_clips
-      true
-    end
-    
-    def each
-      @clips.each do |clip|
-        yield clip
-      end
-    end
-    
-    # text is an array of Strings (lines)
-    # Appends the lines to the current clip.
-    # If no current clip, then a new clip is created.
-    # Returns true iff the text was successfully appended.
-    def appendToClip( text )
-      return false if text.nil?
-      return addClip( text ) if @clips.length == 0
-      last_clip = @clips[ 0 ]
-      last_clip.pop if last_clip[ -1 ] == ""
-      @clips[ 0 ] = last_clip + text
-      true
-    end
-  end
-  
-end

data/lib/diakonos/config.rb

@@ -1,304 +0,0 @@
-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

@@ -1,28 +0,0 @@
-module Diakonos
-
-class CTag
-    attr_reader :file, :command, :kind, :rest
-    
-    def initialize( file, command, kind, rest )
-        @file = file
-        @command = command
-        @kind = kind
-        @rest = rest
-    end
-    
-    def to_s
-        "#{@file}:#{@command} (#{@kind}) #{@rest}"
-    end
-    
-    def == ( other )
-        (
-            other and
-            @file == other.file and
-            @command == other.command and
-            @kind == other.kind and
-            @rest == other.rest
-        )
-    end
-end
-
-end

data/lib/diakonos/display.rb

@@ -1,288 +0,0 @@
-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