ver 2009.12.14 → 2010.02

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

@@ -1,27 +0,0 @@
-module VER
-  class View::List::Window < View::List
-    def update
-      list.value = sublist(windows.keys)
-    end
-
-    def windows
-      path_view = parent.layout.views.map{|view| [view.filename.to_s, view] }
-      Hash[path_view]
-    end
-
-    def pick_action(filename)
-      view = windows[filename]
-      callback.call(view) if callback && view
-    end
-  end
-
-  class View::List::Buffer < View::List
-    def update
-      list.value = sublist(buffers)
-    end
-
-    def buffers
-      VER.paths.map(&:to_s).select {|b| ! b.empty? }
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-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/fuzzy_file_finder.rb

@@ -1,44 +0,0 @@
-require 'ver/vendor/fuzzy_file_finder'
-
-module VER
-  class View::List::FuzzyFileFinder < View::List
-    FFF = ::FuzzyFileFinder
-
-    def fffinder
-      @fffinder ||= FFF.new(Dir.pwd)
-    rescue FFF::TooManyEntries
-      message "The FuzzyFileFinder is overwhelmed by the amount of files"
-      destroy
-    end
-
-    def update
-      choices = fffinder.find(entry.value.chomp('/'))
-      choices = choices.sort_by{|m| [-m[:score], m[:path]] }
-
-      list.clear
-
-      pwd = Dir.pwd + '/'
-      choices.each do |choice|
-        choice[:path].sub!(pwd, '')
-        insert_choice(choice)
-      end
-    end
-
-    def insert_choice(choice)
-      path, score = choice.values_at(:path, :score)
-      list.insert(:end, path)
-
-      foreground, background =
-        case score
-        when 0          ; ['white',  'black']
-        when 0   ..0.25 ; ['red',    'black']
-        when 0.25..0.75 ; ['yellow', 'black']
-        when 0.75..1    ; ['green',  'black']
-        end
-
-      list.itemconfigure(:end,
-              foreground: foreground,       background: background,
-        selectforeground: background, selectbackground: foreground)
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-module VER
-  class View::List::Grep < View::List
-    def initialize(parent, glob = nil, &block)
-      super(parent, &block)
-
-      @glob = nil
-      @glob = glob.to_s unless glob.nil?
-    end
-
-    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 = []
-
-      if @glob
-        input, query = @glob, input
-      else
-        input, query = input.split(/ /, 2)
-        input, query = nil, input unless query
-        input ||= '*'
-
-        return [] if !query || query.size < 3 # protect a little
-      end
-
-      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

@@ -1,159 +0,0 @@
-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/list/syntax.rb

@@ -1,13 +0,0 @@
-module VER
-  class View::List::Syntax < View::List
-    def update
-      list.value = sublist(syntaxes)
-    end
-
-    def syntaxes
-      VER::Syntax.list.map do |fullpath|
-        File.basename(fullpath, File.extname(fullpath))
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module VER
-  class View::List::Theme < View::List
-    def update
-      list.value = sublist(themes)
-    end
-
-    def themes
-      VER::Theme.list.map do |fullpath|
-        File.basename(fullpath, File.extname(fullpath))
-      end
-    end
-  end
-end

data/lib/ver/view/term.rb

@@ -1,255 +0,0 @@
-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
-  rescue Errno::EIO, PTY::ChildExited
-  ensure
-    @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
-
-        begin
-          loop do
-            c = r_pty.sysread(1 << 15)
-            on_chunk(c) if c
-          end
-        rescue Errno::EIO, PTY::ChildExited
-          destroy
-        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