ver 2009.10.14 → 2009.11.28

data/lib/ver/view/list/ex.rb

@@ -0,0 +1,71 @@
+module VER
+  class View::List::Ex < View::List
+    def initialize(parent, filter, &callback)
+      @filter = filter
+      @previous = ''
+      @propose = nil
+      super(parent, &callback)
+    end
+
+    def update
+      value = entry.value
+
+      if value =~ /\s/
+        completion
+      else
+        list.value = @filter.call(value)
+      end
+    end
+
+    def pick_selection
+      if @propose
+        pick_action(@command, @propose)
+      else
+        pick_action(entry.value)
+      end
+
+      destroy
+    end
+
+    def completion
+      value = entry.value
+      command, arg = value.split(' ', 2)
+      complete_command(command, arg)
+    end
+
+    def complete_command(command, arg)
+      name = "complete_#{command}"
+
+      if respond_to?(name)
+        possible = send(name, arg)
+        list.value = possible
+        completed = complete_arg(arg, possible)
+        @command, @propose = command, completed
+        entry.value = "#{command} #{completed}"
+      end
+    end
+
+    def complete_arg(arg, possible)
+      case possible.size
+      when 0
+        return arg
+      when 1
+        return possible.first
+      else
+        require 'abbrev'
+        abbrev = possible.abbrev
+
+        if found = abbrev[arg]
+          return found
+        else
+          return abbrev.keys.sort_by{|k| k.size }.first[0..-2]
+        end
+      end
+    end
+
+    def complete_e(value)
+      Dir["#{value}*"].map{|f| File.directory?(f) ? "#{f}/" : f }
+    end
+    alias complete_o complete_e
+  end
+end

data/lib/ver/view/list/grep.rb

@@ -0,0 +1,42 @@
+module VER
+  class View::List::Grep < View::List
+    def update
+      list.clear
+
+      grep(entry.value).each do |choice|
+        list.insert(:end, "#{choice[:match]} -- #{choice[:file]} +#{choice[:line]}")
+      end
+    end
+
+    def pick_action(entry)
+      index = list.curselection.first
+      choice = @choices[index]
+      callback.call(*choice.values_at(:file, :line))
+    end
+
+    def grep(input)
+      @choices = []
+
+      input, query = input.split(/ /, 2)
+      input, query = nil, input unless query
+      input ||= '*'
+
+      return [] if !query || query.size < 3 # protect a little
+
+      regex = /#{Regexp.escape(query)}/
+
+      Dir.glob input do |file|
+        next unless ::File.file?(file)
+
+        File.open file do |io|
+          io.each_line.with_index do |line, idx|
+            next unless line =~ regex
+            @choices << {file: file, line: idx, match: line.strip}
+          end
+        end
+      end
+
+      return @choices
+    end
+  end
+end

data/lib/ver/view/list/methods.rb

@@ -0,0 +1,159 @@
+require 'ver/vendor/levenshtein'
+
+module VER
+  # Show methods based on patterns.
+  #
+  # TODO: Handle C and evaled methods.
+  #       Once 1.9.2 is out, use Method#parameters.
+  class View::List::Methods < View::List
+    def update
+      list.value = update_choices.map{|choice|
+        method, score = choice.values_at(:method, :score)
+        " #{score} #{method.owner}.#{method.name}"
+      }
+    end
+
+    def pick_action(entry)
+      index = list.curselection.first
+      choice = @choices[index]
+
+      return unless method = choice[:method]
+
+      if location = method.source_location
+        filename, line = location
+
+        if ::File.file?(filename)
+          callback.call(filename, line)
+        else
+          # defined by clumsy eval
+        end
+      else
+        # C method?
+      end
+    end
+
+    def insert_choice(choice)
+      method, score = choice.values_at(:method, :score)
+      owner, name = method.owner, method.name
+
+      list.insert :end, " #{score} #{owner}.#{name}"
+      return
+
+      owner, name, parameters = method.owner, method.name, method.parameters
+
+      params = []
+
+      method.parameters.each do |param|
+        case param.first
+        when :req
+          params << param.last
+        when :opt
+          params << "?#{param.last}"
+        when :block
+          params << "&#{param.last}"
+        end
+      end
+
+      params = params.join(', ')
+
+      list.insert :end, " #{score} #{owner}.#{name}(#{params})"
+    end
+
+    # Intelligent method grepper, tries to find matching methods for a wide
+    # range of input, by distributing scores.
+    #
+    # Possible input might be:
+    #
+    #   Window.y
+    #   Window y
+    #   Window::y
+    #   Window#y
+    #   VER y
+    #   VER::View::File#copy
+    #   VER::View::File.copy
+    #   VER::View::File::copy
+    #
+    # The matching is very tolerant, so you can search for methods in
+    # completely different namespaces but still get good results:
+    #
+    #   VER.delta
+    #   # => VER::Buffer.apply_delta
+    #   # => VER::Buffer.apply_deltas
+    #   # => VER::Cursor.delta
+    #
+    #   sort
+    #   # => VER::Cursor.boundary_sort
+    #
+    #   VER.ask
+    #   # => #<Class:VER>.ask
+    #   # => VER::View::File::Methods.buffer_ask
+    #   # => VER::View::File::Methods.execute_ask
+    #   # => VER::View::File::Methods.execute_ask_context
+    #   # => VER::View::File::Methods.filter_selection_ask
+    #   # => VER::View::File::Methods.goto_line_ask
+    #   # => #<Class:FFI::NCurses>.mousemask
+    #   # => VER::View::File::Methods.save_as_ask
+    #   # => VER::View::File::Methods.search_ask
+    #   # => VER::View::File::Methods.search_ask_context
+    #
+    # We are only using string comparisions to find matches, so input is
+    # never interpreted as a regular expression and can include anything
+    # without having to worry about special meaning within a regexp.
+    #
+    # There are some improvments possible (as usual).
+    # In particular the scoring should become more accurate for short
+    # methods, for example making adjustments when a method starts or ends
+    # with the search string.
+    def update_choices
+      @choices = []
+
+      needle = entry.value.split(/::|[#.\s]+/)
+      owner = needle.join('::')
+      name = needle.last.to_s
+
+      methods_of VER do |namespace, method|
+        mnamespace = namespace.to_s
+        mowner, mname = method.owner.to_s, method.name.to_s
+        smowner = mowner.split('::')
+
+        score = 0
+        score += (needle & smowner).size
+        if mname.include?(name)
+          distance = Levenshtein.distance(mname, name)
+          score += ([mname, name].max_by{|n| n.size }.size - distance)
+        end
+
+        next if score == 0
+
+        @choices << {namespace: namespace, method: method, score: score}
+      end
+
+      @choices = @choices.sort_by{|hash| [-hash[:score], hash[:method].name] }
+    end
+
+    def methods_of(namespace, seen = [], &block)
+      return if seen.include?(namespace)
+      seen << namespace
+
+      if namespace.respond_to?(:instance_methods)
+        namespace.instance_methods(false).each do |name|
+          yield namespace, namespace.instance_method(name)
+        end
+      end
+
+      if namespace.respond_to?(:singleton_methods)
+        namespace.singleton_methods(false).each do |name|
+          yield namespace, namespace.method(name)
+        end
+      end
+
+      if namespace.respond_to?(:constants)
+        namespace.constants.each do |name|
+          methods_of(namespace.const_get(name), seen, &block)
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/ver/view/term.rb

@@ -0,0 +1,249 @@
+require 'thread'
+require 'strscan'
+require 'pty'
+
+class VER::View::Terminal
+  def initialize(parent)
+    @parent = parent
+    setup_widgets
+    pty
+  end
+
+  def bench(name, &block)
+    require 'benchmark'
+    p name => Benchmark.realtime(&block)
+  end
+
+  def setup_widgets
+    Tk.set_palette('black') # maybe use themes instead?
+
+    @option_cache ||= {}
+    @font ||= VER.options[:font]
+    @font_actual ||= @font.actual_hash
+
+    @text = Tk::Text.new(font: @font, insertofftime: 1)
+    @text.pack expand: true, fill: :both
+    @text.focus
+
+    @text.bind('<Key>'){|event|
+      @pty_queue << event.unicode
+      Tk.callback_break
+    }
+
+    @text.bind('<Return>'){|event|
+      @pty_queue << event.unicode
+      # Tk.callback_break
+    }
+  end
+
+  def destroy
+    @text.destroy
+    @parent.focus
+  end
+
+  def pty
+    @pty_queue = queue = Queue.new
+
+    Thread.new do
+      shell = ENV['SHELL'] || 'bash'
+
+      PTY.spawn(shell) do |r_pty, w_pty, pid|
+        Thread.new do
+          while chunk = queue.shift
+            w_pty.print chunk
+            w_pty.flush
+          end
+        end
+
+        loop do
+          c = r_pty.sysread(1 << 15)
+          on_chunk(c) if c
+        end
+      end
+    end
+  rescue Errno::EIO, PTY::ChildExited
+    destroy
+  end
+
+  ANSI_CODES = []
+  ANSI_CODES[0]  = :reset
+  ANSI_CODES[1]  = :bold
+  ANSI_CODES[2]  = :dark
+  ANSI_CODES[3]  = :italic
+  ANSI_CODES[4]  = :underline
+  ANSI_CODES[5]  = :blink
+  ANSI_CODES[6]  = :rapid_blink
+  ANSI_CODES[7]  = :reverse
+  ANSI_CODES[8]  = :concealed
+  ANSI_CODES[9]  = :strikethrough
+  ANSI_CODES[30] = :black
+  ANSI_CODES[31] = :red
+  ANSI_CODES[32] = :green
+  ANSI_CODES[33] = :yellow
+  ANSI_CODES[34] = :blue
+  ANSI_CODES[35] = :magenta
+  ANSI_CODES[36] = :cyan
+  ANSI_CODES[37] = :white
+  ANSI_CODES[40] = :on_black
+  ANSI_CODES[41] = :on_red
+  ANSI_CODES[42] = :on_green
+  ANSI_CODES[43] = :on_yellow
+  ANSI_CODES[44] = :on_blue
+  ANSI_CODES[45] = :on_magenta
+  ANSI_CODES[46] = :on_cyan
+  ANSI_CODES[47] = :on_white
+
+  # Trying to build a little dictionary of escape sequences:
+  #
+  # | Sequence       | Meaning         |
+  # | \e]0;          | reset fg/bg     |
+  # | \e[?1034h      | ???             |
+  # | \e[01;34mbin\e | fg: 1, bg: 34   |
+
+  def on_chunk(chunk)
+    @buffer ||= ''
+    @buffer << chunk
+    s = StringScanner.new(@buffer)
+
+    until s.eos?
+      pos = s.pos
+
+      case s.peek(1)
+      when "\e"
+        if    s.scan(/\e\](\d+);/)
+          color s[1]
+        elsif s.scan(/\e\[(\d+)([A-Z])/)
+          color s[1]
+        elsif s.scan(/\e\[\?(\d+h)/)
+          color s[1]
+        elsif s.scan(/\e\[(\d+);(\d+)m/) # \e[01;34m
+          color s[1], s[2]
+        elsif s.scan(/\e\[(\d+)m/)
+          color s[1]
+        elsif s.scan(/\e\[([A-Z])/)
+          color s[1]
+        elsif s.scan(/\e\[m/)
+          # nothing?
+        elsif s.scan(/\e=\r/)
+          delete 'insert linestart', 'insert lineend'
+        else
+          p s.rest
+        end
+      when "\r"
+        if s.scan(/\r\n/)
+          insert :end, "\n"
+        elsif s.scan(/\r\r/)
+          delete 'insert linestart', 'insert lineend'
+        elsif s.scan(/\r[^\n\r]/)
+          p :no_rn => s.matched
+        else
+          p :r_fail => s.rest
+        end
+      when "\x07"
+        s.pos += 1
+        delete 'insert linestart', 'insert lineend'
+      when "\x08"
+        s.pos += 1
+        delete 'insert - 1 chars'
+      else
+        if s.scan(/\A[^\e\r\x08\x07]+/)
+          insert :end, s.matched
+        end
+      end
+     #  p s.matched
+
+      if s.pos == pos
+        warn("Scanner stopped at: %p" % [s])
+        @buffer = s.rest
+        return
+      end
+    end
+
+    @buffer = ''
+    @text.see :end
+  rescue StringScanner::Error => ex
+    VER.error(ex)
+  rescue => ex
+    puts "#{ex.class}: #{ex}", *ex.backtrace
+    @buffer = ''
+    destroy
+  end
+
+  def color(fg, bg = nil)
+    if bg
+      fg, bg = ANSI_CODES[fg.to_i], ANSI_CODES[bg.to_i]
+
+      @tag = [:ansi, fg, bg].join('_')
+      @text.tag_configure @tag, options_for(@tag, fg, bg)
+    else
+      fg = ANSI_CODES[fg.to_i]
+
+      @tag = [:ansi, fg].join('_')
+      @text.tag_configure @tag, options_for(@tag, fg)
+    end
+  end
+
+  FG_COLORS = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
+  BG_COLORS = [:on_black, :on_red, :on_green, :on_yellow, :on_blue, :on_magenta, :on_cyan, :on_white]
+
+  def options_for(tag, fg, bg = nil)
+
+    if found = @option_cache[tag]
+      return found
+    end
+
+    options = {}
+
+    case fg
+    when nil
+    when :reset
+      options[:font] = @font
+      options[:background] = nil
+      options[:foreground] = nil
+    when :bold
+      options[:font] = font_for(@font_actual.merge(weight: :bold))
+    when *FG_COLORS
+      options[:foreground] = fg
+    when *BG_COLORS
+      options[:background] = bg.to_s.sub(/on_/, '')
+    else
+      p fg: fg
+    end
+
+    case bg
+    when nil
+    when :reset
+      options[:font] = @font
+      options[:background] = nil
+      options[:foreground] = nil
+    when *FG_COLORS
+      options[:foreground] = bg
+    when *BG_COLORS
+      options[:background] = bg.to_s.sub(/on_/, '')
+    else
+      p bg: bg
+    end
+
+    @option_cache[options] = options
+    options
+  end
+
+  def font_for(options)
+    @fonts ||= {}
+    @fonts[options] ||= Tk::Font.new(options)
+  end
+
+  def ansi2sym(ansi)
+    COLORS[ansi.to_i]
+  end
+
+  def insert(index, chars)
+    # p insert: [index, chars]
+    @text.insert(index, chars, @tag)
+  end
+
+  def delete(*indices)
+    # p delete: indices
+    @text.delete(*indices)
+  end
+end