ver 2009.12.14 → 2010.02

data/lib/ver/layout/tiling/common.rb

@@ -0,0 +1,34 @@
+module VER
+  class TilingLayout
+    module CommonTiling
+      DEFAULT = { master: 1, stacking: 3, center: 0.5 }
+
+      def prepare(layout, given_options)
+        options = DEFAULT.merge(given_options)
+        slaves = layout.stack
+        master, stacking = options.values_at(:master, :stacking)
+        given_options.merge!(options)
+        head, tail, hidden = slaves[0...master], slaves[master..stacking], slaves[(stacking + 1)..-1]
+        return head, tail, hidden, options
+      end
+
+      def apply(layout, given_options = {})
+        masters, stacked, hidden, options = prepare(layout, given_options)
+
+        center = stacked.size == 0 ? 1.0 : options[:center]
+
+        apply_hidden(hidden) if hidden
+        apply_masters(masters, center) if masters
+        apply_stacked(stacked, center) if stacked
+      end
+
+      def apply_hidden(windows)
+        windows.each(&:place_forget)
+      end
+
+      def evolve(window, target)
+        window.place(target)
+      end
+    end
+  end
+end

data/lib/ver/layout/tiling/horizontal.rb

@@ -0,0 +1,25 @@
+module VER
+  class TilingLayout
+    module HorizontalTiling
+      extend CommonTiling
+
+      module_function
+
+      def apply_masters(windows, center, step = 1.0 / windows.size)
+        windows.each_with_index do |window, idx|
+          evolve(window, relx: (step * idx), rely: 0.0,
+                 relheight: center, relwidth: step)
+        end
+      end
+
+      def apply_stacked(windows, center, step = 1.0 / windows.size)
+        relheight = 1.0 - center
+
+        windows.each_with_index do |window, idx|
+          evolve(window, relx: (step * idx), rely: center,
+                 relheight: relheight, relwidth: step)
+        end
+      end
+    end
+  end
+end

data/lib/ver/layout/tiling/vertical.rb

@@ -0,0 +1,25 @@
+module VER
+  class TilingLayout
+    module VerticalTiling
+      extend CommonTiling
+
+      module_function
+
+      def apply_masters(windows, center, step = 1.0 / windows.size)
+        windows.each_with_index do |window, idx|
+          evolve(window, relx: 0.0, rely: (step * idx),
+                 relheight: step, relwidth: center)
+        end
+      end
+
+      def apply_stacked(windows, center, step = 1.0 / windows.size)
+        relwidth = 1.0 - center
+
+        windows.each_with_index do |window, idx|
+          evolve(window, relx: center, rely: (step * idx),
+                 relheight: step, relwidth: relwidth)
+        end
+      end
+    end
+  end
+end

data/lib/ver/major_mode.rb

@@ -0,0 +1,162 @@
+module VER
+  def self.major_mode(name, &block)
+    major = MajorMode[name]
+    major.instance_eval(&block)
+    major
+  end
+
+  # This mode is responsible for maintaining a keymap of its own and a list of
+  # minor modes that are immediately queried.
+  # A major mode can inherit the keymap of another major mode in order to
+  # 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.
+  #
+  # 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 Keymap::Results
+    MODES = {}
+
+    def self.[](name)
+      name = name.to_sym
+
+      if MODES.key?(name)
+        MODES[name]
+      else
+        new(name)
+      end
+    end
+
+    def self.clear
+      MODES.each_value(&:destroy)
+    end
+
+    def initialize(name)
+      self.name = name.to_sym
+      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
+    end
+
+    def destroy
+      tag.bind.each{|key| tag.unbind(key) }
+      MODES.delete(name)
+    end
+
+    def handler(object)
+      self.receiver = object
+    end
+
+    def map(invocation, *sequences, &block)
+      action = Action.new(receiver, *invocation, &block)
+
+      sequences.each do |sequence|
+        keymap[sequence] = action
+      end
+    end
+
+    def missing(invocation, &block)
+      action = Action.new(receiver, *invocation, &block)
+      self.fallback_action = action
+      keymap['<Key>'] = action
+    end
+
+    def enter(invocation, &block)
+      action = Action.new(receiver, *invocation, &block)
+      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)
+      tag.bind "<<LeaveMajorMode#{to_camel_case}>>" do |event|
+        action.call(WidgetEvent.new(event.widget, event))
+      end
+    end
+
+    def inherits(name)
+      mode = self.class[name]
+      keymap.merge!(mode.keymap)
+    end
+
+    def use(*minors)
+      minors.each do |name|
+        minor = MinorMode[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
+    end
+
+    def replace_minor(old, new)
+      minors.each do |minor|
+        minor.replace_parent(self, MinorMode[old], MinorMode[new])
+      end
+    end
+
+    def bind_key(key)
+      return if bound_keys.include?(key)
+
+      tag.bind(key) do |event|
+        event.widget.major_mode.on_event(event)
+        Tk.callback_break
+      end
+
+      bound_keys << key
+    end
+
+    def actions
+      keymap.actions
+    end
+
+    def to_sym
+      name
+    end
+
+    def inspect
+      "#<VER::MajorMode name=%p>" % [name]
+    end
+  end
+end

data/lib/ver/methods.rb

@@ -1,26 +1,25 @@
-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/move'
-require 'ver/methods/open'
-require 'ver/methods/preview'
-require 'ver/methods/save'
-require 'ver/methods/search'
-require 'ver/methods/select'
-require 'ver/methods/undo'
-require 'ver/methods/views'
-require 'ver/methods/shortcuts'
-
 module VER
   module Methods
-    include(Completion, Control, Ctags, Delete, Help, Insert, Move, Open,
-            Preview, Save, Search, Select, Clipboard, Bookmarks::Methods,
-            Views, Undo)
-    include Shortcuts
+    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

data/lib/ver/methods/autofill.rb

@@ -0,0 +1,23 @@
+module VER
+  module Methods
+    module AutoFill
+      module_function
+
+      def auto_fill_space(text)
+        enabled = text.store(self, :enable)
+        return text.insert(:insert, ' ') unless enabled
+
+        from, to = 'insert linestart', 'insert lineend'
+        line = text.get(from, to)
+
+        if line.size < (text.options.auto_fill_width || 78)
+          text.insert(:insert, ' ')
+        else
+          chunks = line.scan(/(.{1,78}[^\s])(?:\s|$)/)
+          lines = chunks.join("\n") << ' '
+          text.replace(from, to, lines)
+        end
+      end
+    end
+  end
+end

data/lib/ver/methods/basic.rb

@@ -0,0 +1,53 @@
+module VER
+  module Methods
+    module Basic
+      module_function
+
+      def quit(text)
+        Save.quit(text)
+      end
+
+      def source_buffer(text)
+        VER.message "Source #{text.filename}"
+        TOPLEVEL_BINDING.eval(text.value.to_s)
+      end
+
+      def status_evaluate(text)
+        text.ask 'Eval expression: ' do |answer, action|
+          case action
+          when :attempt
+            begin
+              result = text.instance_eval(answer)
+              VER.message result.inspect
+            rescue Exception => ex
+              VER.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)
+      end
+
+      def open_console(text)
+        Buffer::Console.new(text)
+      end
+    end
+  end
+end

data/lib/ver/methods/bookmark.rb

@@ -1,4 +1,110 @@
 module VER
+  module Methods
+    module Bookmark
+      module_function
+
+      def ask(text)
+        text.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'
+            end
+          end
+        end
+      end
+
+      def visit_char(text, name = nil)
+        if name
+          visit_named(text, name)
+        else
+          ask(text){|answer| visit_named(text, answer) }
+        end
+      end
+
+      def add_char(text, name = nil)
+        if name
+          add_named(text, name)
+        else
+          ask(text){|answer| add_named(text, answer) }
+        end
+      end
+
+      def add_named(text, name = nil)
+        if name
+          bm = bookmarks.add_named(name, value(text))
+          VER.message("Added bookmark [%s|%s:%d,%d]." % bm.to_a)
+        else
+          ask(text){|answer| add_named(text, answer) }
+        end
+      end
+
+      def remove_named(text, name = nil)
+        if name
+          if bm = bookmarks.delete(name)
+            VER.message("Removed bookmark [%s|%s:%d,%d]." % bm.to_a)
+          else
+            VER.message("No Bookmark named %p." % [name])
+          end
+        else
+          ask(text){|answer| remove_named(text, answer) }
+        end
+      end
+
+      def visit_named(text, name = nil)
+        if name
+          if bm = bookmarks[name]
+            open(text, bm)
+          else
+            VER.message("No Bookmark named %p." % [name])
+          end
+        else
+          ask(text){|answer| visit_named(text, answer) }
+        end
+      end
+
+      def toggle(text)
+        pos = value(text)
+
+        if bm = bookmarks.at(pos)
+          bookmarks.delete(bm)
+          message("Removed bookmark [%s|%s:%d,%d]." % bm.to_a)
+        else
+          bm = bookmarks.add_unnamed(pos)
+          message("Added bookmark [%s|%s:%d,%d]." % bm.to_a)
+        end
+      rescue => ex
+        VER.error(ex)
+      end
+
+      def next(text)
+        open(text, bookmarks.next_from(value(text)))
+      end
+
+      def prev(text)
+        open(text, bookmarks.prev_from(value(text)))
+      end
+
+      def bookmarks
+        VER.bookmarks
+      end
+
+      def value(text)
+        [text.filename, *text.index(:insert).split]
+      end
+
+      def open(text, bookmark, use_col = true)
+        return unless bookmark.respond_to?(:file) && bookmark.respond_to?(:index)
+
+        line, col = use_col ? bookmark.index : [bookmark.line, 0]
+        VER.find_or_create_buffer(bookmark.file, line, col)
+      end
+    end # Bookmark
+  end # Methods
+
   class Bookmarks
     include Enumerable
 
@@ -72,118 +178,24 @@ module VER
       @bm.find{|bm| needle == bm }
     end
 
-    class Bookmark < Struct.new(:name, :file, :index)
+    class Bookmark < Struct.new(:name, :file, :line, :column)
       include Comparable
 
       def <=>(other)
         [file, index] <=> [other.file, other.index]
       end
 
-      def to_a
-        [name, file, index.y, index.x]
-      end
-    end
-
-    module Methods
-      def char_bookmark_visit(name = nil)
-        if name
-          named_bookmark_visit(name)
-        else
-          status_ask 'Bookmark name: ', take: 1 do |bm_name|
-            named_bookmark_visit(bm_name)
-          end
-        end
-      end
-
-      def char_bookmark_add(name = nil)
-        if name
-          named_bookmark_add(name)
-        else
-          status_ask 'Bookmark name: ', take: 1 do |bm_name|
-            named_bookmark_add(bm_name)
-          end
-        end
-      end
-
-      def named_bookmark_add(name = nil)
-        if name
-          bm = bookmarks.add_named(name, bookmark_value)
-          message("Added bookmark [%s|%s:%d,%d]." % bm.to_a)
-        else
-          status_ask 'Bookmark name: ' do |bm_name|
-            named_bookmark_add(bm_name)
-          end
-        end
-      end
-
-      def named_bookmark_remove(name = nil)
-        if name
-          if bm = bookmarks.delete(name)
-            message("Removed bookmark [%s|%s:%d,%d]." % bm.to_a)
-          else
-            message("No Bookmark named %p." % [name])
-          end
-        else
-          status_ask 'Bookmark name: ' do |bm_name|
-            named_bookmark_remove(bm_name)
-          end
-        end
-      end
-
-      def named_bookmark_visit(name = nil)
-        if name
-          if bm = bookmarks[name]
-            bookmark_open(bm)
-          else
-            message("No Bookmark named %p." % [name])
-          end
-        else
-          status_ask 'Bookmark name: ' do |bm_name|
-            named_bookmark_visit(bm_name)
-          end
-        end
-      end
-
-      def bookmark_toggle
-        pos = bookmark_value
-
-        if bm = bookmarks.at(pos)
-          bookmarks.delete(bm)
-          message("Removed bookmark [%s|%s:%d,%d]." % bm.to_a)
-        else
-          bm = bookmarks.add_unnamed(bookmark_value)
-          message("Added bookmark [%s|%s:%d,%d]." % bm.to_a)
-        end
-      rescue => ex
-        VER.error(ex)
-      end
-
-      def next_bookmark
-        bookmark_open(bookmarks.next_from(bookmark_value))
-      end
-
-      def prev_bookmark
-        bookmark_open(bookmarks.prev_from(bookmark_value))
+      def index
+        [line, column]
       end
 
-      private
-
-      def bookmarks
-        VER.bookmarks
+      def index=(index)
+        self.line, self.column = *index
       end
 
-      def bookmark_value
-        [filename, index(:insert)]
-      end
-
-      def bookmark_open(bookmark, use_x = true)
-        return unless bookmark.respond_to?(:file) && bookmark.respond_to?(:index)
-
-        view.find_or_create(bookmark.file) do |view|
-          y, x = use_x ? bookmark.index.split : [bookmark.index.y, 0]
-          view.text.mark_set(:insert, "#{y}.#{x}")
-        end
+      def to_a
+        [name, file, *index]
       end
-    end
-  end
-end
+    end # Bookmark
+  end # Bookmarks
+end # VER