ver 2009.10.14 → 2009.11.28

data/config/welcome

@@ -110,6 +110,6 @@ Todo:
 
   - [M-s] : Save file under different name
   - [M-x] : Live ruby console (figure out some nice way)
-  - FFI bindings for X11 so we can communicate with it and have a proper clipboard (xclip is weak)
-  - Proper handling of [esc], halfdelay works if it's called later, but makes other control characters send signals.
-  - Handling tabs
+  - Better configuration for tabs.
+  - Easy runtime configuration
+  - Replace that stops after receiving a single char

data/lib/ver.rb

@@ -1,107 +1,202 @@
 # Well begun is half done.
 #             -- Aristotle
 
-# TODO: remove before release
-$LOAD_PATH.unshift File.expand_path('../', __FILE__)
+# lazy stdlib
+autoload :Benchmark, 'benchmark'
+autoload :FileUtils, 'fileutils'
 
-# stdlib
-require 'tk'
-require 'benchmark'
+# 3rd party
+require 'eventmachine'
+
+# eager stdlib
 require 'digest/sha1'
-require 'fileutils'
 require 'json'
-require 'pathname'
-require 'pp'
+# require 'pp'
 require 'securerandom'
 require 'set'
-require 'tmpdir'
-
-class Pathname
-  alias / join
-
-  def cp(dest)
-    FileUtils.copy_file(expand_path.to_s, dest.to_s, preserve = true)
-  end
-
-  def =~(regexp)
-    to_s =~ regexp
-  end
-end
 
 module VER
-  autoload :BufferListView,      'ver/view/buffer_list_view'
   autoload :Entry,               'ver/entry'
-  autoload :FuzzyFileFinderView, 'ver/view/fuzzy_file_finder_view'
+  autoload :Help,                'ver/help'
+  autoload :Font,                'ver/font'
+  autoload :HoverCompletion,     'ver/hover_completion'
   autoload :Keymap,              'ver/keymap'
   autoload :Layout,              'ver/layout'
-  autoload :ListView,            'ver/view/list_view'
   autoload :Methods,             'ver/methods'
   autoload :Mode,                'ver/mode'
   autoload :Status,              'ver/status'
-  autoload :SyntaxListView,      'ver/view/syntax_list_view'
   autoload :Syntax,              'ver/syntax'
   autoload :Text,                'ver/text'
-  autoload :Textpow,             'ver/textpow'
+  autoload :Textpow,             'ver/vendor/textpow'
+  autoload :Levenshtein,         'ver/vendor/levenshtein'
   autoload :Theme,               'ver/theme'
-  autoload :ThemeListView,       'ver/view/theme_list_view'
   autoload :View,                'ver/view'
 
-  home_conf_dir = Pathname('~/.config/ver').expand_path
-  core_conf_dir = Pathname(File.expand_path('../../config/', __FILE__))
-
-  # poor man's option system
-  # p Tk::Tile.themes # a list of available themes
-  #   Linux themes: "classic", "default", "clam", "alt"
-  OPTIONS = {
-    font:          TkFont.new(family: 'Terminus', size: 9),
-    tk_theme:      'clam',
-    theme:         'Blackboard',
-    keymap:        'vim',
-    global_quit:   'Control-q',
-    home_conf_dir: home_conf_dir,
-    core_conf_dir: core_conf_dir,
-    loadpath:      [home_conf_dir, core_conf_dir],
-  }
+  require 'ver/options'
+  @options = Options.new(:ver)
 
   class << self
     attr_reader :root, :layout, :status, :paths, :options
   end
 
+  options.dsl do
+    o "Default Font for all widgets",
+      :font, "TkFixedFont 10"
+
+    o "Internal:External encoding",
+      :encoding, "UTF-8:UTF-8"
+
+    o "Tk Tile Theme",
+      :tk_theme, 'clam'
+
+    o "Syntax highlighting theme",
+      :theme, "Blackboard"
+
+    o "Keymap used",
+      :keymap, 'vim'
+
+    o "Expand all tabs into spaces",
+      :expandtab, true
+
+    o "Use automatic indentation",
+      :autoindent, true
+
+    o "Number of spaces used in autoindent",
+      :shiftwidth, 2
+
+    o "Number of spaces a tab stands for",
+      :tabstop, 8
+
+    o "Number of characters after which wrap commands will wrap",
+      :textwidth, 80
+
+    o "In case of a total failure, this key binding should bail you out",
+      :emergency_exit, "<Control-q>"
+
+    o "Fork off on startup to avoid dying with the terminal",
+      :fork, true
+
+    o "Milliseconds that the cursor is visible when blinking",
+      :insertontime, 500
+
+    o "Milliseconds that the cursor is invisible when blinking",
+      :insertofftime, 0
+
+    o "Width of one tab in pixel",
+      :tabs, 10
+
+    o "Default filetype if no matching syntax can be found",
+      :filetype, "Plain Text"
+
+    o "Location of personal configuration",
+      :home_conf_dir,  Pathname('~/.config/ver').expand_path
+
+    o "Location of system-wide configuration",
+      :core_conf_dir, Pathname(File.expand_path('../../config/', __FILE__))
+
+    o "Locations where we look for configuration",
+      :loadpath, [home_conf_dir, core_conf_dir]
+  end
+
   module_function
 
   def loadpath
-    options[:loadpath]
+    options.loadpath
   end
 
   def run(given_options = {})
-    @options = OPTIONS.merge(given_options)
+    @options.merge!(given_options)
+
+    setup_tk
+
+    if Tk::RUN_EVENTLOOP_ON_MAIN_THREAD
+      run_aqua
+    else
+      run_x11
+    end
+  rescue => exception
+    VER.error(exception)
+    exit
+  end
+
+  def run_aqua
+    run_core
+    EM.run{ Tk.mainloop }
+  end
+
+  def run_x11
+    EM.run do
+      EM.defer do
+        run_core
+        Tk.mainloop
+      end
+    end
+  end
 
-    setup
-    first_startup unless options[:home_conf_dir].directory?
+  def run_core
+    first_startup unless options.home_conf_dir.directory?
     load 'rc'
+    sanitize_options
+    setup_widgets
     open_argv || open_welcome
     emergency_bindings
-
-  rescue => exception
-    puts "#{exception.class}: #{exception}", *exception.backtrace
-    Tk.exit
-  else
-    Tk.mainloop
   end
 
-  def setup
+  def setup_tk
+    require 'ffi-tk'
     Thread.abort_on_exception = true
+  end
 
-    Tk::Tile.set_theme options[:tk_theme]
+  def setup_widgets
+    Tk::Tile.set_theme options.tk_theme
 
     @paths = Set.new
-    @root = TkRoot.new
+    @root = Tk.root
+    @root.wm_geometry = '160x80'
     @layout = Layout.new(@root)
     @layout.strategy = Layout::VerticalTiling
+    @status = Entry.new(@root, font: options.font)
+    @status.insert :end, 'For information about VER, type F1'
+    @status.pack(fill: :x)
+  end
+
+  def sanitize_options
+    font = options.font
+
+    unless font.respond_to?(:measure)
+      font = Tk::Font.new(font)
+      actual_hash = font.actual_hash
+      options.font = Font.cache[actual_hash] = font
+    end
+
+    tabs = font.measure('0') * options.tabstop
+    options.tabs = tabs
+
+    encoding = options[:encoding]
+    unless encoding.is_a?(Encoding)
+      external, internal = encoding.to_s.split(':', 2)
+
+      Encoding.default_external = Encoding.find(external) if external
+      Encoding.default_internal = Encoding.find(internal) if internal
+    end
+
+    # We supply a reasonable default in case the platform doesn't have the theme
+    # wished for.
+    unless Tk::Tile::Style.theme_names.include?(options.tk_theme)
+      options.tk_theme = 'default'
+    end
+
+    letter = /[\w\n.-]/
+    space = /[^\w.-]/
+
+    # make sure Tcl already has the vars set
+    Tk.interp.eval('catch {tcl_endOfWord}')
+    Tk.execute('set', 'tcl_wordchars', letter)
+    Tk.execute('set', 'tcl_nonwordchars', space)
   end
 
   def first_startup
-    home, core = options.values_at(:home_conf_dir, :core_conf_dir)
+    home, core = options.home_conf_dir, options.core_conf_dir
     home.mkpath
 
     (core/'rc.rb').cp(home/'rc.rb')
@@ -110,6 +205,12 @@ module VER
     (core/'welcome').cp(home/'welcome')
   end
 
+  def exit
+    Tk.exit rescue nil
+    EM.stop rescue nil
+    Kernel.exit
+  end
+
   def load(name)
     loadpath.each do |path|
       file = File.join(path, name)
@@ -117,7 +218,8 @@ module VER
       begin
         require(file)
         return
-      rescue LoadError
+      rescue LoadError, TypeError => ex
+        # TypeError happens on JRuby sometimes...
       end
     end
   end
@@ -132,11 +234,23 @@ module VER
   end
 
   def open_argv
-    ARGV.each{|arg|
+    argv = ARGV.dup
+    any = false
+
+    while arg = argv.shift
       layout.create_view do |view|
-        view.open_path(arg)
+        if argv.first =~ /\+\d+/
+          line = argv.shift.to_i
+          view.open_path(arg, line)
+        else
+          view.open_path(arg)
+        end
+
+        any = true
       end
-    }.any?
+    end
+
+    any
   end
 
   def open_welcome
@@ -147,10 +261,107 @@ module VER
   end
 
   def emergency_bindings
-    Tk.bind :all, options[:global_quit], proc{ exit }
+    Tk::Bind.bind(:all, options.emergency_exit){ exit }
   end
 
   def opened_file(text)
     @paths << text.filename
   end
+
+  def error(exception)
+    @status.value = exception.message if @status
+    error_tree(exception) if @root
+    $stderr.puts("#{exception.class}: #{exception}", *exception.backtrace)
+  rescue Errno::EIO
+    # The original terminal has disappeared, the $stderr pipe was closed on the
+    # other side.
+    [$stderr, $stdout, $stdin].each(&:close)
+  rescue IOError
+    # Our pipes are closed, maybe put some output to a file logger here, or display
+    # in a nicer way, maybe let it bubble up to Tk handling.
+  end
+
+  def error_tree(exception)
+    @tree ||= Tk::Tile::Treeview.new(@root)
+    @tree.clear
+
+    @tree.configure(
+      columns:        %w[line method],
+      displaycolumns: %w[line method]
+    )
+    @tree.heading('#0',     text: 'File')
+    @tree.heading('line',   text: 'Line')
+    @tree.heading('method', text: 'Method')
+    @tree.tag_configure('error', background: '#f88')
+    @tree.tag_configure('backtrace', background: '#8f8')
+
+    context_size = 7
+    frames = {}
+    error_tags = ['error']
+    backtrace_tags = ['backtrace']
+
+    # from Rack::ShowExceptions
+    exception.backtrace.each do |line|
+      next unless line =~ /(.*?):(\d+)(:in `(.*)')?/
+      filename, lineno, function = $1, $2.to_i, $4
+
+      item = @tree.insert(nil, :end,
+        text: filename, values: [lineno, function], tags: error_tags)
+
+      begin
+        lines = ::File.readlines(filename)
+        _lineno = lineno - 1
+
+        first_lineno = [_lineno - context_size, 0].max
+        last_lineno  = [_lineno + context_size, lines.size].min
+        context = lines[first_lineno..last_lineno]
+
+        frames[item.id] = {
+          filename: filename,
+          lineno: lineno,
+          function: function,
+          first_lineno: first_lineno,
+          last_lineno: last_lineno,
+          context: context,
+        }
+      rescue => ex
+        puts ex, ex.backtrace
+      end
+    end
+
+    @tree.focus
+    @tree.pack expand: true, fill: :both
+
+    @tree.bind('<<TreeviewOpen>>'){|event|
+      begin
+        item = @tree.focus_item
+        frame = frames[item.id]
+
+        case frame
+        when Hash
+          filename, lineno, first_lineno, context =
+            frame.values_at(:filename, :lineno, :first_lineno, :context)
+
+          context.each_with_index{|line, idx|
+            line_lineno = first_lineno + idx + 1
+            tags = line_lineno == lineno ? error_tags : backtrace_tags
+            line_item = item.insert(:end,
+              text: line, values: [line_lineno], tags: tags)
+            frames[line_item.id] = [filename, lineno]
+          }
+        when Array
+          filename, lineno = frame
+          @layout.views.first.find_or_create(filename, lineno){|view|
+            @tree.pack_forget
+          }
+        end
+      rescue => ex
+        puts ex, ex.backtrace
+      end
+    }
+    @tree.bind('<Escape>'){
+      @tree.pack_forget
+      @layout.views.first.focus
+    }
+  end
 end

data/lib/ver/entry.rb

@@ -1,14 +1,21 @@
 module VER
   # A custom widget for easier integration
   #
-  # The style related things are needed for Tk versions around 8.5.7, which is what everybody is using currently.
-  # It doesn't GC styles of widgets that are no longer used, so if we simply keep using new style names, we would eventually run out of memory.
+  # The style related things are needed for Tk versions around 8.5.7, which is
+  # what everybody is using currently.
+  # It doesn't GC styles of widgets that are no longer used, so if we simply keep
+  # using new style names, we would eventually run out of memory.
   # A small leak, but better we cover this now than tracking it down later.
-  # Tk should get some user states, called like 'user1', 'user2', 'user3', that would allow some flexibility, but still won't be able to represent every mode.
+  # Tk should get some user states, called like 'user1', 'user2', 'user3', that
+  # would allow some flexibility, but still won't be able to represent every mode.
   class Entry < Tk::Tile::Entry
     STYLE_NAME_REGISTER = []
     STYLE_NAME_POOL = []
 
+    space, word = /[^[:alnum:]]+/, /[[:alnum:]]/
+    FORWARD_WORD = /#{space}+#{word}|#{word}+#{space}+#{word}/
+    BACKWARD_WORD = /#{word}+/
+
     def self.obtain_style_name
       unless style_name = STYLE_NAME_POOL.shift
         begin
@@ -31,22 +38,26 @@ module VER
     end
 
     def quit
-      Tk.exit
+      VER.exit
     end
 
     def value=(string)
-      super
-      Tk.event_generate(self, '<Modified>')
+      execute_only(:delete, 0, :end)
+      execute_only(:insert, 0, string)
+      Tk::Event.generate(self, '<<Replaced>>')
+      Tk::Event.generate(self, '<<Modified>>')
     end
 
     def delete(*args)
       super
-      Tk.event_generate(self, '<Modified>')
+      Tk::Event.generate(self, '<<Deleted>>')
+      Tk::Event.generate(self, '<<Modified>>')
     end
 
     def insert(*args)
       super
-      Tk.event_generate(self, '<Modified>')
+      Tk::Event.generate(self, '<<Inserted>>')
+      Tk::Event.generate(self, '<<Modified>>')
     end
 
     def message(string)
@@ -61,37 +72,142 @@ module VER
       insert cursor, string
     end
 
-    def delete_char_left
-      delete(cursor - 1)
+    def noop(*args)
     end
 
-    def delete_char_right
-      delete(cursor)
+    # Move to the start of the current line.
+    def beginning_of_line
+      self.cursor = 0
+    end
+
+    # Move to the end of the line.
+    def end_of_line
+      self.cursor = :end
+    end
+
+    # Move forward a character.
+    def forward_char(count = 1)
+      self.cursor += count
+    end
+
+    # Move back a character.
+    def backward_char(count = 1)
+      self.cursor -= count
+    end
+
+    # Move forward to the end of the next word.
+    # Words are composed of alphanumeric characters (letters and digits).
+    def forward_word(count = 1)
+      count.times do
+        return unless md = get.match(FORWARD_WORD, cursor)
+        self.cursor = md.offset(0).last
+      end
     end
 
-    def go_char_left
-      self.cursor = cursor - 1
+    # Move back to the start of the current or previous word.
+    # Words are composed of alphanumeric characters (letters and digits).
+    def backward_word(count = 1)
+      line = get.reverse
+      count.times do
+        pos = get.size - cursor
+
+        return unless md = line.match(BACKWARD_WORD, pos)
+        self.cursor = (line.size - md.offset(0).last)
+      end
     end
 
-    def go_char_right
-      self.cursor = cursor + 1
+    # Accept the line regardless of where the cursor is.
+    # If this line is non-empty, it will be added to the history list.
+    # If the line is a modified history line, the history line is restored to
+    # its original state.
+    def accept_line
+      line = get
+      @history.unshift(line) unless line.empty?
+      @history_index = nil
+      Event.generate(self, '<<AcceptLine>>')
+      delete 0, :end
     end
 
-    def go_word_left
-      if index = value.rindex(/.\b\s/, cursor - 1)
-        self.cursor = index
+    # Fetch the previous command from the history list, moving back in the list.
+    def previous_history
+      history_size = @history.size
+
+      if @history_index && @history_index < history_size
+        @history_index = [@history_index + 1, history_size - 1].min
       else
-        self.cursor = 0
+        @history_index = 0
+      end
+
+      self.value = @history[@history_index]
+    end
+
+    # Fetch the next command from the history list, moving forward in the list.
+    def next_history
+      if @history_index && @history_index > 0
+        @history_index -= 1
+      else
+        @history_index = @history.size - 1
+      end
+
+      self.value = @history[@history_index]
+    end
+
+    def beginning_of_history
+      @history_index = @history.size - 1
+      self.value = @history[@history_index]
+    end
+
+    def end_of_history
+      @history_index = 0
+      self.value = @history[@history_index]
+    end
+
+    def delete_char
+      delete(cursor)
+    end
+
+    def backward_delete_char(yank = nil)
+      return if cursor == 0
+
+      if yank
+        @killring.unshift get[cursor - 2]
       end
+
+      delete(cursor - 1)
     end
 
-    def go_word_right
-      if match = value.match(/\s\b/, cursor)
-        offset_from, offset_to = match.offset(0)
-        self.cursor = offset_to
+    # Delete the character under the cursor, unless the cursor is at the end of
+    # the line, in which case the character behind the cursor is deleted.
+    def forward_backward_delete_char
+      pos = cursor
+
+      if index(:end) == pos
+        delete(cursor - 1)
       else
-        self.cursor = :end
+        delete(cursor)
       end
     end
+
+    def transpose_chars
+      char = get[cursor]
+      delete(cursor)
+      insert(cursor - 1, char)
+    end
+
+    def delete_motion(motion, count = 1)
+      delete(*virtual_movement(motion, count))
+    end
+
+    private
+
+    def virtual_movement(name, count = 1)
+      pos = cursor
+      __send__(name, count)
+      mark = cursor
+      self.cursor = pos
+      return [pos, mark].sort
+    rescue => ex
+      VER.error(ex)
+    end
   end
-end
+end