diakonos 0.8.6 → 0.8.7

data/lib/diakonos/grep.rb

@@ -0,0 +1,78 @@
+module Diakonos
+  def self.grep_array( regexp, array, lines_of_context, prefix, filepath )
+    num_lines = array.size
+    line_numbers = []
+    array.each_with_index do |line,index|
+      next if line !~ regexp
+      start_index = [ 0, index - lines_of_context ].max
+      end_index = [ index + lines_of_context, num_lines-1 ].min
+      (start_index..end_index).each do |i|
+        line_numbers << i
+      end
+    end
+
+    line_numbers.uniq!
+    results = []
+    last_i = line_numbers[ 0 ]
+    one_result = []
+    line_numbers.each do |i|
+      if i - last_i > 1
+        results << one_result.join( "\n" )
+        one_result = []
+      end
+      one_result << ( "#{prefix}#{i+1}: " << ( "%-300s | #{filepath}:#{i+1}" % array[ i ] ) )
+      last_i = i
+    end
+    if not one_result.empty?
+      results << one_result.join( "\n" )
+    end
+
+    results
+  end
+
+  class Diakonos
+
+    def grep_( regexp_source, *buffers )
+      original_buffer = @current_buffer
+      if @current_buffer.changing_selection
+        selected_text = @current_buffer.copySelection[ 0 ]
+      end
+      starting_row, starting_col = @current_buffer.last_row, @current_buffer.last_col
+
+      selected = getUserInput(
+        "Grep regexp: ",
+        @rlh_search,
+        regexp_source || selected_text || ""
+      ) { |input|
+        next if input.length < 2
+        begin
+          regexp = Regexp.new( input, Regexp::IGNORECASE )
+          grep_results = buffers.map { |buffer| buffer.grep( regexp ) }.flatten
+          if settings[ 'grep.context' ] == 0
+            join_str = "\n"
+          else
+            join_str = "\n---\n"
+          end
+          with_list_file do |list|
+            list.puts grep_results.join( join_str )
+          end
+          list_buffer = openListBuffer
+          list_buffer.highlightMatches regexp
+          list_buffer.display
+        rescue RegexpError
+          # Do nothing
+        end
+      }
+
+      if selected
+        spl = selected.split( "| " )
+        if spl.size > 1
+          openFile spl[ -1 ]
+        end
+      else
+        original_buffer.cursorTo starting_row, starting_col
+      end
+    end
+
+  end
+end

data/lib/diakonos/hash.rb

@@ -15,10 +15,10 @@ class Hash
         elsif path.length == 1
             delete( path[ 0 ] )
         end
-        
-        return self
+
+        self
     end
-    
+
     def setKeyPath( path, leaf )
         if path.length > 1
             node = self[ path[ 0 ] ]
@@ -29,33 +29,33 @@ class Hash
         elsif path.length == 1
             self[ path[ 0 ] ] = leaf
         end
-        
-        return self
+
+        self
     end
-    
+
     def getNode( path )
         node = self[ path[ 0 ] ]
         if path.length > 1
-            if node != nil and node.respond_to?( :getNode )
+            if node and node.respond_to?( :getNode )
                 return node.getNode( path[ 1..-1 ] )
             end
         elsif path.length == 1
             return node
         end
-        
-        return nil
+
+        nil
     end
-    
+
     def getLeaf( path )
         node = getNode( path )
         if node.respond_to?( :getNode )
             # Only want a leaf node
-            return nil
+            nil
         else
-            return node
+            node
         end
     end
-    
+
     def leaves( _leaves = Set.new )
         each_value do |value|
             if value.respond_to?( :leaves )
@@ -64,10 +64,10 @@ class Hash
                 _leaves << value
             end
         end
-        
-        return _leaves
+
+        _leaves
     end
-    
+
     def paths_and_leaves( path_so_far = [], _paths_and_leaves = Set.new )
         each do |key, value|
             if value.respond_to?( :paths_and_leaves )
@@ -84,10 +84,10 @@ class Hash
                 }
             end
         end
-        
-        return _paths_and_leaves
+
+        _paths_and_leaves
     end
-    
+
     def each_path_and_leaf( path_so_far = [] )
         each do |key, value|
             if value.respond_to?( :each_path_and_leaf )
@@ -97,5 +97,12 @@ class Hash
             end
         end
     end
+
+    # Implement Ruby 1.9's Hash#key for Ruby 1.8
+    if ! method_defined?( :key )
+        def key( *args )
+            index( *args )
+        end
+    end
 end
 

data/lib/diakonos/help.rb

@@ -0,0 +1,92 @@
+module Diakonos
+  class Diakonos
+    def init_help
+      @base_help_dir = "#{@diakonos_home}/help"
+      mkdir @base_help_dir
+
+      @help_dir = "#{@diakonos_home}/help/#{VERSION}"
+      if not File.exist?( @help_dir ) or Dir[ "#{@help_dir}/*" ].size == 0
+        if @testing
+          `cp -r ./help #{@help_dir}`
+        else
+          puts "Help files for this Diakonos version were not found (#{@help_dir})."
+          puts "Would you like to download the help files right now from the Diakonos website? (y/n)"
+          answer = $stdin.gets
+          case answer
+          when /^y/i
+            if not fetch_help
+              $stderr.puts "Failed to get help for version #{VERSION}."
+              sleep 2
+            end
+          end
+        end
+      end
+
+      @help_tags = `grep -h Tags #{@help_dir}/* | cut -d ' ' -f 2-`.split.uniq
+    end
+
+    def fetch_help
+      require 'open-uri'
+      success = false
+      puts "Fetching help documents for version #{VERSION}..."
+
+      filename = "diakonos-help-#{VERSION}.tar.gz"
+      uri = "http://purepistos.net/diakonos/#{filename}"
+      tarball = "#{@base_help_dir}/#{filename}"
+      begin
+        open( uri ) do |http|
+          bytes = http.read
+          File.open( tarball, 'w' ) do |f|
+            f.print bytes
+          end
+        end
+        mkdir @help_dir
+        `tar zxf #{tarball} -C #{@base_help_dir}`
+        success = true
+      rescue OpenURI::HTTPError => e
+        $stderr.puts "Failed to fetch from #{uri} ."
+      end
+
+      success
+    end
+
+    def open_help_buffer
+      @help_buffer = openFile( @help_filename )
+    end
+    def close_help_buffer
+      closeFile @help_buffer
+      @help_buffer = nil
+    end
+
+    def matching_help_documents( str )
+      docs = []
+
+      if str =~ %r{^/(.+)$}
+        regexp = $1
+        files = Dir[ "#{@help_dir}/*" ].select{ |f|
+          File.open( f ) { |io| io.grep( /#{regexp}/i ) }.any?
+        }
+      else
+        terms = str.gsub( /[^a-zA-Z0-9-]/, ' ' ).split.join( '|' )
+        file_grep = `egrep -i -l '^Tags.*\\b(#{terms})\\b' #{@help_dir}/*`
+        files = file_grep.split( /\s+/ )
+      end
+
+      files.each do |file|
+        File.open( file ) do |f|
+          docs << ( "%-300s | %s" % [ f.gets.strip, file ] )
+        end
+      end
+
+      docs.sort { |a,b| a.gsub( /^# (?:an?|the) */i, '# ' ) <=> b.gsub( /^# (?:an?|the) */i, '# ' ) }
+    end
+
+    def open_help_document( selected_string )
+      help_file = selected_string.split( "| " )[ -1 ]
+      if File.exist? help_file
+        openFile help_file
+      end
+    end
+
+  end
+end

data/lib/diakonos/hooks.rb

@@ -0,0 +1,13 @@
+module Diakonos
+  class Diakonos
+    def register_proc( the_proc, hook_name, priority = 0 )
+      @hooks[ hook_name ] << { :proc => the_proc, :priority => priority }
+    end
+    
+    def runHookProcs( hook_id, *args )
+      @hooks[ hook_id ].each do |hook_proc|
+        hook_proc[ :proc ].call( *args )
+      end
+    end
+  end
+end

data/lib/diakonos/interaction.rb

@@ -0,0 +1,139 @@
+module Diakonos
+
+  TAB       = 9
+  ENTER     = 13
+  ESCAPE    = 27
+  BACKSPACE = 127
+  CTRL_C    = 3
+  CTRL_D    = 4
+  CTRL_K    = 11
+  CTRL_Q    = 17
+  CTRL_H    = 263
+  RESIZE2   = 4294967295
+
+  DO_COMPLETE   = true
+  DONT_COMPLETE = false
+
+  CHOICE_NO           = 0
+  CHOICE_YES          = 1
+  CHOICE_ALL          = 2
+  CHOICE_CANCEL       = 3
+  CHOICE_YES_TO_ALL   = 4
+  CHOICE_NO_TO_ALL    = 5
+  CHOICE_YES_AND_STOP = 6
+  CHOICE_DELETE       = 7
+  CHOICE_KEYS = [
+    [ "n".ord, "N".ord ],
+    [ "y".ord, "Y".ord ],
+    [ "a".ord, "A".ord ],
+    [ "c".ord, "C".ord, ESCAPE, CTRL_C, CTRL_D, CTRL_Q ],
+    [ "e".ord ],
+    [ "o".ord ],
+    [ "s".ord ],
+    [ "d".ord ],
+  ]
+  CHOICE_STRINGS = [ '(n)o', '(y)es', '(a)ll', '(c)ancel', 'y(e)s to all', 'n(o) to all', 'yes and (s)top', '(d)elete' ]
+
+  class Diakonos
+    # completion_array is the array of strings that tab completion can use
+    def getUserInput( prompt, history = @rlh_general, initial_text = "", completion_array = nil, do_complete = DONT_COMPLETE, on_dirs = :go_into_dirs, &block )
+      if @playing_macro
+        retval = @macro_input_history.shift
+      else
+        retval = Readline.new( self, @win_interaction, prompt, initial_text, completion_array, history, do_complete, on_dirs, &block ).readline
+        if @macro_history
+          @macro_input_history.push retval
+        end
+        setILine
+      end
+      retval
+    end
+
+    def interactionBlink( message = nil )
+      terminateMessage
+      setILine @settings[ 'interaction.blink_string' ]
+      sleep @settings[ 'interaction.blink_duration' ]
+      setILine message if message
+    end
+
+    # choices should be an array of CHOICE_* constants.
+    # default is what is returned when Enter is pressed.
+    def getChoice( prompt, choices, default = nil )
+      retval = @iterated_choice
+      if retval
+        @choice_iterations -= 1
+        if @choice_iterations < 1
+          @iterated_choice = nil
+          @do_display = true
+        end
+        return retval
+      end
+
+      @saved_main_x = @win_main.curx
+      @saved_main_y = @win_main.cury
+
+      msg = prompt + " "
+      choice_strings = choices.collect do |choice|
+        CHOICE_STRINGS[ choice ]
+      end
+      msg << choice_strings.join( ", " )
+
+      if default.nil?
+        showMessage msg
+      else
+        setILine msg
+      end
+
+      c = nil
+      while retval.nil?
+        c = @win_interaction.getch.ord
+
+        case c
+        when Curses::KEY_NPAGE
+          pageDown
+        when Curses::KEY_PPAGE
+          pageUp
+        else
+          if @message_expiry and Time.now < @message_expiry
+            interactionBlink
+            showMessage msg
+          else
+            case c
+            when ENTER
+              retval = default
+            when ?0..?9
+              if @choice_iterations < 1
+                @choice_iterations = ( c - ?0 )
+              else
+                @choice_iterations = @choice_iterations * 10 + ( c - ?0 )
+              end
+            else
+              choices.each do |choice|
+                if CHOICE_KEYS[ choice ].include? c
+                  retval = choice
+                  break
+                end
+              end
+            end
+
+            if retval.nil?
+              interactionBlink( msg )
+            end
+          end
+        end
+      end
+
+      terminateMessage
+      setILine
+
+      if @choice_iterations > 0
+        @choice_iterations -= 1
+        @iterated_choice = retval
+        @do_display = false
+      end
+
+      retval
+    end
+
+  end
+end

data/lib/diakonos/keycode.rb

@@ -52,7 +52,7 @@ module KeyCode
         if self.class == Fixnum
             retval = KEYSTRINGS[ self ]
         end
-        if retval == nil
+        if retval.nil?
             case self
                 when Curses::KEY_DOWN
                     retval = "down"
@@ -100,10 +100,10 @@ module KeyCode
                     retval = "resize2"
             end
         end
-        if retval == nil and self.class == Fixnum
+        if retval.nil? and self.class == Fixnum
             retval = "keycode#{self}"
         end
-        return retval
+        retval
     end
 end
 

data/lib/diakonos/keying.rb

@@ -0,0 +1,124 @@
+module Diakonos
+  class Diakonos
+    def capture_keychain( c, context )
+      if c == ENTER
+        @capturing_keychain = false
+        @current_buffer.deleteSelection
+        str = context.to_keychain_s.strip
+        @current_buffer.insertString str
+        cursorRight( Buffer::STILL_TYPING, str.length )
+      else
+        keychain_pressed = context.concat [ c ]
+
+        function_and_args = @keychains.getLeaf( keychain_pressed )
+
+        if function_and_args
+          function, args = function_and_args
+        end
+
+        partial_keychain = @keychains.getNode( keychain_pressed )
+        if partial_keychain
+          setILine( "Part of existing keychain: " + keychain_pressed.to_keychain_s + "..." )
+        else
+          setILine keychain_pressed.to_keychain_s + "..."
+        end
+        processKeystroke( keychain_pressed )
+      end
+    end
+
+    def capture_mapping( c, context )
+      if c == ENTER
+        @capturing_mapping = false
+        @current_buffer.deleteSelection
+        setILine
+      else
+        keychain_pressed = context.concat [ c ]
+
+        function_and_args = @keychains.getLeaf( keychain_pressed )
+
+        if function_and_args
+          function, args = function_and_args
+          setILine "#{keychain_pressed.to_keychain_s.strip}  ->  #{function}( #{args} )"
+        else
+          partial_keychain = @keychains.getNode( keychain_pressed )
+          if partial_keychain
+            setILine( "Several mappings start with: " + keychain_pressed.to_keychain_s + "..." )
+            processKeystroke( keychain_pressed )
+          else
+            setILine "There is no mapping for " + keychain_pressed.to_keychain_s
+          end
+        end
+      end
+    end
+
+    # context is an array of characters (bytes) which are keystrokes previously
+    # typed (in a chain of keystrokes)
+    def processKeystroke( context = [] )
+      c = @win_main.getch.ord
+
+      if @capturing_keychain
+        capture_keychain c, context
+      elsif @capturing_mapping
+        capture_mapping c, context
+      else
+
+        if context.empty?
+          if c > 31 and c < 255 and c != BACKSPACE
+            if @macro_history
+              @macro_history.push "typeCharacter #{c}"
+            end
+            @there_was_non_movement = true
+            typeCharacter c
+            return
+          end
+        end
+        keychain_pressed = context.concat [ c ]
+
+        function_and_args = @keychains.getLeaf( keychain_pressed )
+
+        if function_and_args
+          function, args = function_and_args
+          setILine if not @settings[ "context.combined" ]
+
+          if args
+            to_eval = "#{function}( #{args} )"
+          else
+            to_eval = function
+          end
+
+          if @macro_history
+            @macro_history.push to_eval
+          end
+
+          begin
+            eval to_eval, nil, "eval"
+            @last_commands << to_eval unless to_eval == "repeatLast"
+            if not @there_was_non_movement
+              @there_was_non_movement = ( not to_eval.movement? )
+            end
+          rescue Exception => e
+            debugLog e.message
+            debugLog e.backtrace.join( "\n\t" )
+            showException e
+          end
+        else
+          partial_keychain = @keychains.getNode( keychain_pressed )
+          if partial_keychain
+            setILine( keychain_pressed.to_keychain_s + "..." )
+            processKeystroke( keychain_pressed )
+          else
+            setILine "Nothing assigned to #{keychain_pressed.to_keychain_s}"
+          end
+        end
+      end
+    end
+    protected :processKeystroke
+
+    def typeCharacter( c )
+      @current_buffer.deleteSelection( Buffer::DONT_DISPLAY )
+      @current_buffer.insertChar c
+      cursorRight( Buffer::STILL_TYPING )
+    end
+
+  end
+end