diakonos 0.8.7 → 0.8.8

data/lib/diakonos/grep.rb

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

@@ -1,108 +0,0 @@
-class Hash
-    # path is an array of hash keys
-    # This method deletes a path of hash keys, with each step in the path
-    # being a recursively deeper key in a hash tree.
-    # Returns the possibly modified hash.
-    def deleteKeyPath( path )
-        if path.length > 1
-            subtree = self[ path[ 0 ] ]
-            if subtree.respond_to?( :deleteKeyPath )
-                subtree.deleteKeyPath( path[ 1..-1 ] )
-                if subtree.empty?
-                    delete( path[ 0 ] )
-                end
-            end
-        elsif path.length == 1
-            delete( path[ 0 ] )
-        end
-
-        self
-    end
-
-    def setKeyPath( path, leaf )
-        if path.length > 1
-            node = self[ path[ 0 ] ]
-            if not node.respond_to?( :setKeyPath )
-                node = self[ path[ 0 ] ] = Hash.new
-            end
-            node.setKeyPath( path[ 1..-1 ], leaf )
-        elsif path.length == 1
-            self[ path[ 0 ] ] = leaf
-        end
-
-        self
-    end
-
-    def getNode( path )
-        node = self[ path[ 0 ] ]
-        if path.length > 1
-            if node and node.respond_to?( :getNode )
-                return node.getNode( path[ 1..-1 ] )
-            end
-        elsif path.length == 1
-            return node
-        end
-
-        nil
-    end
-
-    def getLeaf( path )
-        node = getNode( path )
-        if node.respond_to?( :getNode )
-            # Only want a leaf node
-            nil
-        else
-            node
-        end
-    end
-
-    def leaves( _leaves = Set.new )
-        each_value do |value|
-            if value.respond_to?( :leaves )
-                _leaves.merge value.leaves( _leaves )
-            else
-                _leaves << value
-            end
-        end
-
-        _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 )
-                _paths_and_leaves.merge(
-                    value.paths_and_leaves(
-                        path_so_far + [ key ],
-                        _paths_and_leaves
-                    )
-                )
-            else
-                _paths_and_leaves << {
-                    :path => path_so_far + [ key ],
-                    :leaf => value
-                }
-            end
-        end
-
-        _paths_and_leaves
-    end
-
-    def each_path_and_leaf( path_so_far = [] )
-        each do |key, value|
-            if value.respond_to?( :each_path_and_leaf )
-                value.each_path_and_leaf( path_so_far + [ key ] ) { |path, leaf| yield( path, leaf ) }
-            else
-                yield( path_so_far + [ key ], value )
-            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

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

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

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

@@ -1,110 +0,0 @@
-module Diakonos
-
-module KeyCode
-    KEYSTRINGS = [
-        "ctrl+space",   # 0
-        "ctrl+a",       # 1
-        "ctrl+b",       # 2
-        "ctrl+c",       # 3
-        "ctrl+d",       # 4
-        "ctrl+e",       # 5
-        "ctrl+f",       # 6
-        "ctrl+g",       # 7
-        nil,            # 8
-        "tab",          # 9
-        "ctrl+j",       # 10
-        "ctrl+k",       # 11
-        "ctrl+l",       # 12
-        "enter",        # 13
-        "ctrl+n",       # 14
-        "ctrl+o",       # 15
-        "ctrl+p",       # 16
-        "ctrl+q",       # 17
-        "ctrl+r",       # 18
-        "ctrl+s",       # 19
-        "ctrl+t",       # 20
-        "ctrl+u",       # 21
-        "ctrl+v",       # 22
-        "ctrl+w",       # 23
-        "ctrl+x",       # 24
-        "ctrl+y",       # 25
-        "ctrl+z",       # 26
-        "esc",          # 27
-        nil,            # 28
-        nil,            # 29
-        nil,            # 30
-        nil,            # 31
-        "space",        # 32
-        33.chr, 34.chr, 35.chr, 36.chr, 37.chr, 38.chr, 39.chr,
-        40.chr, 41.chr, 42.chr, 43.chr, 44.chr, 45.chr, 46.chr, 47.chr, 48.chr, 49.chr,
-        50.chr, 51.chr, 52.chr, 53.chr, 54.chr, 55.chr, 56.chr, 57.chr, 58.chr, 59.chr,
-        60.chr, 61.chr, 62.chr, 63.chr, 64.chr, 65.chr, 66.chr, 67.chr, 68.chr, 69.chr,
-        70.chr, 71.chr, 72.chr, 73.chr, 74.chr, 75.chr, 76.chr, 77.chr, 78.chr, 79.chr,
-        80.chr, 81.chr, 82.chr, 83.chr, 84.chr, 85.chr, 86.chr, 87.chr, 88.chr, 89.chr,
-        90.chr, 91.chr, 92.chr, 93.chr, 94.chr, 95.chr, 96.chr, 97.chr, 98.chr, 99.chr,
-        100.chr, 101.chr, 102.chr, 103.chr, 104.chr, 105.chr, 106.chr, 107.chr, 108.chr, 109.chr,
-        110.chr, 111.chr, 112.chr, 113.chr, 114.chr, 115.chr, 116.chr, 117.chr, 118.chr, 119.chr,
-        120.chr, 121.chr, 122.chr, 123.chr, 124.chr, 125.chr, 126.chr,
-        "backspace"    # 127
-    ]
-
-    def keyString
-        if self.class == Fixnum
-            retval = KEYSTRINGS[ self ]
-        end
-        if retval.nil?
-            case self
-                when Curses::KEY_DOWN
-                    retval = "down"
-                when Curses::KEY_UP
-                    retval = "up"
-                when Curses::KEY_LEFT
-                    retval = "left"
-                when Curses::KEY_RIGHT
-                    retval = "right"
-                when Curses::KEY_HOME
-                    retval = "home"
-                when Curses::KEY_END
-                    retval = "end"
-                when Curses::KEY_IC
-                    retval = "insert"
-                when Curses::KEY_DC
-                    retval = "delete"
-                when Curses::KEY_PPAGE
-                    retval = "page-up"
-                when Curses::KEY_NPAGE
-                    retval = "page-down"
-                when Curses::KEY_A1
-                    retval = "numpad7"
-                when Curses::KEY_A3
-                    retval = "numpad9"
-                when Curses::KEY_B2
-                    retval = "numpad5"
-                when Curses::KEY_C1
-                    retval = "numpad1"
-                when Curses::KEY_C3
-                    retval = "numpad3"
-                when Curses::KEY_FIND
-                    retval = "find"
-                when Curses::KEY_SELECT
-                    retval = "select"
-                when Curses::KEY_SUSPEND
-                    retval = "suspend"
-                when Curses::KEY_F0..(Curses::KEY_F0 + 24)
-                    retval = "f" + (self - Curses::KEY_F0).to_s
-                when CTRL_H
-                    retval = "ctrl+h"
-                when Curses::KEY_RESIZE
-                    retval = "resize"
-                when RESIZE2
-                    retval = "resize2"
-            end
-        end
-        if retval.nil? and self.class == Fixnum
-            retval = "keycode#{self}"
-        end
-        retval
-    end
-end
-
-end