ver 2010.02 → 2010.08

data/lib/ver/major_mode.rb

@@ -2,6 +2,7 @@ module VER
   def self.major_mode(name, &block)
     major = MajorMode[name]
     major.instance_eval(&block)
+    major.handler nil
     major
   end
 
@@ -11,14 +12,17 @@ module VER
   # specialize it.
   # The inherited keymap is duplicated upon inheritance and the original will
   # not be modified, the duplicate is merged in a manner that will not replace
-  # existing sequences.
+  # existing patterns.
   #
   # The bound_keys property acts as a cache of the keys bound to the tag, so we
   # don't have to query the tag, as the bound proc is the same for all keys.
   class MajorMode < Struct.new(:name, :minors, :keymap, :receiver,
                                :fallback_action, :tag, :bound_keys)
 
+    include Platform
+    include ModeResolving
     include Keymap::Results
+
     MODES = {}
 
     def self.[](name)
@@ -36,16 +40,21 @@ module VER
     end
 
     def initialize(name)
-      self.name = name.to_sym
+      self.name = name = name.to_sym
+
+      if MODES.key?(name)
+        raise ArgumentError, "Duplicate #{self.class}: %p" % [name]
+      else
+        MODES[name] = self
+      end
+
       self.minors = []
       self.keymap = Keymap.new
       self.bound_keys = Set.new
       self.tag = Tk::BindTag.new("#{name}-mode")
 
-      KEYSYMS.each{|key, sym| bind_key(sym) }
-      bind_key('<Escape>')
-
-      MODES[self.name] = self
+      # and now register all we didn't have yet.
+      Event.each{|event| bind_key(event) }
     end
 
     def destroy
@@ -57,29 +66,25 @@ module VER
       self.receiver = object
     end
 
-    def map(invocation, *sequences, &block)
-      action = Action.new(receiver, *invocation, &block)
-
-      sequences.each do |sequence|
-        keymap[sequence] = action
-      end
+    def map(invocation, *patterns)
+      action = Action.new(invocation, receiver, self)
+      patterns.each{|pattern| keymap[pattern] = action }
     end
 
-    def missing(invocation, &block)
-      action = Action.new(receiver, *invocation, &block)
+    def missing(invocation)
+      action = Fallback.new(invocation, receiver, self)
       self.fallback_action = action
-      keymap['<Key>'] = action
     end
 
-    def enter(invocation, &block)
-      action = Action.new(receiver, *invocation, &block)
+    def enter(invocation)
+      action = Action.new(invocation, receiver, self)
       tag.bind "<<EnterMajorMode#{to_camel_case}>>" do |event|
         action.call(WidgetEvent.new(event.widget, event))
       end
     end
 
-    def leave(invocation, &block)
-      action = Action.new(receiver, *invocation, &block)
+    def leave(invocation)
+      action = Action.new(invocation, receiver, self)
       tag.bind "<<LeaveMajorMode#{to_camel_case}>>" do |event|
         action.call(WidgetEvent.new(event.widget, event))
       end
@@ -93,41 +98,18 @@ module VER
     def use(*minors)
       minors.each do |name|
         minor = MinorMode[name]
+        next if self.minors.any?{|m| m.name == minor.name }
         self.minors << minor
       end
-
-      self.minors.uniq!
     end
 
     def forget(*minors)
       self.minors -= minors.map{|name| MinorMode[name] }
     end
 
-    # recursively try to find the sequence in the major mode and its minor
-    # modes.
-    def resolve(sequence, minors = [])
-      case found = keymap[sequence]
-      when Incomplete
-        minors.each do |minor|
-          case resolved = minor.resolve(sequence)
-          when Incomplete
-            found.merge!(resolved)
-          end
-        end
-      when Impossible
-        minors.find do |minor|
-          found = minor.resolve(sequence)
-          !found.kind_of?(Impossible)
-        end
-      else
-        found = [self, found]
-      end
-
-      if found.kind_of?(Impossible) && fa = self.fallback_action
-        return self, fa
-      else
-        return found
-      end
+    # recursively try to find the pattern in the major mode and its minors.
+    def resolve(pattern, minors = [])
+      super
     end
 
     def replace_minor(old, new)
@@ -137,14 +119,23 @@ module VER
     end
 
     def bind_key(key)
-      return if bound_keys.include?(key)
+      case key
+      when Event
+        pattern = key.pattern
+      when String
+        pattern = Event[key].pasttern
+      else
+        raise ArgumentError, "Invalid key: %p" % [key]
+      end
 
-      tag.bind(key) do |event|
+      return if bound_keys.include?(pattern)
+
+      tag.bind(pattern) do |event|
         event.widget.major_mode.on_event(event)
         Tk.callback_break
       end
 
-      bound_keys << key
+      bound_keys << pattern
     end
 
     def actions
@@ -158,5 +149,14 @@ module VER
     def inspect
       "#<VER::MajorMode name=%p>" % [name]
     end
+
+    def hash
+      name.hash
+    end
+
+    # we assume that name is unique
+    def eql?(other)
+      other.class == self.class && other.name == self.name
+    end
   end
 end

data/lib/ver/methods.rb

@@ -1,25 +1,22 @@
-module VER
-  module Methods
-    autoload :AutoFill,         'ver/methods/autofill'
-    autoload :Basic,            'ver/methods/basic'
-    autoload :Bookmark,         'ver/methods/bookmark'
-    autoload :CTags,            'ver/methods/ctags'
-    autoload :Clipboard,        'ver/methods/clipboard'
-    autoload :Completion,       'ver/methods/completion'
-    autoload :Control,          'ver/methods/control'
-    autoload :Delete,           'ver/methods/delete'
-    autoload :Help,             'ver/methods/help'
-    autoload :Insert,           'ver/methods/insert'
-    autoload :Layout,           'ver/methods/layout'
-    autoload :Move,             'ver/methods/move'
-    autoload :Nano,             'ver/methods/nano'
-    autoload :Open,             'ver/methods/open'
-    autoload :Preview,          'ver/methods/preview'
-    autoload :Save,             'ver/methods/save'
-    autoload :Search,           'ver/methods/search'
-    autoload :SearchAndReplace, 'ver/methods/search_and_replace'
-    autoload :Selection,        'ver/methods/selection'
-    autoload :Snippet,          'ver/methods/snippet'
-    autoload :Undo,             'ver/methods/undo'
-  end
-end
+require 'ver/methods/autofill'
+require 'ver/methods/basic'
+require 'ver/methods/bookmark'
+require 'ver/methods/clipboard'
+require 'ver/methods/completion'
+require 'ver/methods/control'
+require 'ver/methods/ctags'
+require 'ver/methods/delete'
+require 'ver/methods/help'
+require 'ver/methods/insert'
+require 'ver/methods/layout'
+require 'ver/methods/macro'
+require 'ver/methods/move'
+require 'ver/methods/nano'
+require 'ver/methods/open'
+require 'ver/methods/preview'
+require 'ver/methods/save'
+require 'ver/methods/search'
+require 'ver/methods/search_and_replace'
+require 'ver/methods/selection'
+require 'ver/methods/snippet'
+require 'ver/methods/undo'

data/lib/ver/methods/basic.rb

@@ -1,15 +1,57 @@
 module VER
+  class Buffer
+    # Eval the value of {Buffer} in toplevel binding.
+    # So while hacking VER you can dynamically reload parts of it.
+    def eval_buffer
+      message "Source #{uri}"
+      TOPLEVEL_BINDING.eval(value.to_s)
+    end
+
+    # Display a tooltip for the tags the insert cursor is on.
+    # Also generates a status message.
+    # Hides the tooltip after 5 seconds unless a seconds +count+ is given.
+    def tags_tooltip(count = prefix_arg)
+      index = at_insert
+      value = index.tag_names.join(', ')
+
+      message(value)
+      tooltip(value, count || 5)
+    end
+
+    def tooltip(string, timeout = 5)
+      require 'ver/tooltip'
+
+      tooltip = Tk::Tooltip.new(string)
+      tooltip.show_on(self)
+      Tk::After.ms(timeout * 1000){ tooltip.destroy }
+    end
+  end
+
   module Methods
     module Basic
       module_function
 
-      def quit(text)
-        Save.quit(text)
+      def minibuf_eval(buffer)
+        bind = buffer.binding
+
+        buffer.ask 'Eval: ' do |answer, action|
+          case action
+          when :attempt
+            begin
+              buffer.message(eval(answer, bind).inspect)
+            rescue Exception => ex
+              buffer.warn("#{ex.class}: #{ex}")
+            end
+
+            :abort
+          when :complete
+            EvalCompleter.complete(answer, bind)
+          end
+        end
       end
 
-      def source_buffer(text)
-        VER.message "Source #{text.filename}"
-        TOPLEVEL_BINDING.eval(text.value.to_s)
+      def quit(text)
+        text.quit
       end
 
       def status_evaluate(text)
@@ -18,28 +60,15 @@ module VER
           when :attempt
             begin
               result = text.instance_eval(answer)
-              VER.message result.inspect
+              text.message result.inspect
             rescue Exception => ex
-              VER.message("#{ex.class}: #{ex}")
+              text.message("#{ex.class}: #{ex}")
             end
             :abort
           end
         end
       end
 
-      def tags_at(text, index = :insert)
-        index = text.index(index)
-        tags = text.tag_names(index)
-        VER.message tags.inspect
-
-        require 'ver/tooltip'
-
-        tooltip = Tk::Tooltip.new(tags.inspect)
-        tooltip.show_on(text)
-
-        Tk::After.ms(5000){ tooltip.destroy }
-      end
-
       def open_terminal(text)
         require 'ver/buffer/term'
         Buffer::Terminal.new(text)

data/lib/ver/methods/bookmark.rb

@@ -3,71 +3,71 @@ module VER
     module Bookmark
       module_function
 
-      def ask(text)
-        text.ask 'Bookmark name: ' do |answer, action|
+      def ask(buffer)
+        buffer.ask 'Bookmark name: ' do |answer, action|
           case action
           when :modified, :attempt
             if name = answer[0]
               yield name
               :abort
             else
-              VER.message 'Need a bookmark name'
+              buffer.message 'Need a bookmark name'
             end
           end
         end
       end
 
-      def visit_char(text, name = nil)
+      def visit_char(buffer, name = nil)
         if name
-          visit_named(text, name)
+          visit_named(buffer, name)
         else
-          ask(text){|answer| visit_named(text, answer) }
+          ask(buffer){|answer| visit_named(buffer, answer) }
         end
       end
 
-      def add_char(text, name = nil)
+      def add_char(buffer, name = nil)
         if name
-          add_named(text, name)
+          add_named(buffer, name)
         else
-          ask(text){|answer| add_named(text, answer) }
+          ask(buffer){|answer| add_named(buffer, answer) }
         end
       end
 
-      def add_named(text, name = nil)
+      def add_named(buffer, name = nil)
         if name
-          bm = bookmarks.add_named(name, value(text))
-          VER.message("Added bookmark [%s|%s:%d,%d]." % bm.to_a)
+          bm = bookmarks.add_named(name, value(buffer))
+          buffer.message("Added bookmark [%s|%s:%d,%d]." % bm.to_a)
         else
-          ask(text){|answer| add_named(text, answer) }
+          ask(buffer){|answer| add_named(buffer, answer) }
         end
       end
 
-      def remove_named(text, name = nil)
+      def remove_named(buffer, name = nil)
         if name
           if bm = bookmarks.delete(name)
-            VER.message("Removed bookmark [%s|%s:%d,%d]." % bm.to_a)
+            buffer.message("Removed bookmark [%s|%s:%d,%d]." % bm.to_a)
           else
-            VER.message("No Bookmark named %p." % [name])
+            buffer.message("No Bookmark named %p." % [name])
           end
         else
-          ask(text){|answer| remove_named(text, answer) }
+          ask(buffer){|answer| remove_named(buffer, answer) }
         end
       end
 
-      def visit_named(text, name = nil)
+      def visit_named(buffer, name = nil)
         if name
           if bm = bookmarks[name]
-            open(text, bm)
+            open(buffer, bm)
           else
-            VER.message("No Bookmark named %p." % [name])
+            buffer.message("No Bookmark named %p." % [name])
           end
         else
-          ask(text){|answer| visit_named(text, answer) }
+          ask(buffer){|answer| visit_named(buffer, answer) }
         end
       end
 
-      def toggle(text)
-        pos = value(text)
+      def toggle(buffer)
+        pos = value(buffer)
 
         if bm = bookmarks.at(pos)
           bookmarks.delete(bm)
@@ -80,23 +80,23 @@ module VER
         VER.error(ex)
       end
 
-      def next(text)
-        open(text, bookmarks.next_from(value(text)))
+      def next(buffer)
+        open(buffer, bookmarks.next_from(value(buffer)))
       end
 
-      def prev(text)
-        open(text, bookmarks.prev_from(value(text)))
+      def prev(buffer)
+        open(buffer, bookmarks.prev_from(value(buffer)))
       end
 
       def bookmarks
         VER.bookmarks
       end
 
-      def value(text)
-        [text.filename, *text.index(:insert).split]
+      def value(buffer)
+        [buffer.filename, *buffer.index(:insert)]
       end
 
-      def open(text, bookmark, use_col = true)
+      def open(buffer, bookmark, use_col = true)
         return unless bookmark.respond_to?(:file) && bookmark.respond_to?(:index)
 
         line, col = use_col ? bookmark.index : [bookmark.line, 0]
@@ -178,7 +178,7 @@ module VER
       @bm.find{|bm| needle == bm }
     end
 
-    class Bookmark < Struct.new(:name, :file, :line, :column)
+    class Bookmark < Struct.new(:name, :file, :line, :char)
       include Comparable
 
       def <=>(other)
@@ -186,11 +186,11 @@ module VER
       end
 
       def index
-        [line, column]
+        [line, char]
       end
 
       def index=(index)
-        self.line, self.column = *index
+        self.line, self.char = *index
       end
 
       def to_a