ver 2009.10.14 → 2009.11.28

data/lib/ver/layout.rb

@@ -1,6 +1,6 @@
 module VER
-  class Layout < Ttk::Frame
-    attr_reader :strategy, :views
+  class Layout < Tk::Tile::Frame
+    attr_reader :strategy, :views, :options
 
     def initialize(parent, options = {})
       super
@@ -8,6 +8,7 @@ module VER
       pack(fill: :both, expand: true)
 
       @views = []
+      @options = {}
       self.strategy = Layout::VerticalTiling
     end
 
@@ -19,89 +20,152 @@ module VER
     def create_view
       view = View.new(self)
       yield view
-      @views << view
+      @views.unshift view
 
       apply
+      view.focus
     end
 
     def close_view(view)
       @views.delete view
       view.destroy
 
-      if previous = @views.last
+      if previous = @views.first
         apply
         previous.focus
       else
-        Tk.exit
+        VER.exit
       end
     end
 
     def focus_next(current)
-      return unless index = @views.index(current)
+      visible = head_tail_hidden.first(2).flatten
+      return unless index = visible.index(current)
 
-      found = @views[index + 1] || @views[0]
+      found = visible[index + 1] || visible[0]
       found.focus
     end
 
     def focus_prev(current)
-      return unless index = @views.index(current)
+      visible = head_tail_hidden.first(2).flatten
+
+      return unless index = visible.index(current)
 
-      found = @views[index - 1]
+      found = visible[index - 1]
       found.focus
     end
 
+    # called on #3
+    # +-----+-----+ > +-----+-----+ > +-----+-----+ > +-----+-----+
+    # |     |  2  | > |     |  3  | > |     |  1  | > |     |  1  |
+    # |  1  +-----+ > |  1  +-----+ > |  3  +-----+ > |  3  +-----+
+    # |     |  3  | > |     |  2  | > |     |  2  | > |     |  2  |
+    # +-----+-----+ > +-----+-----+ > +-----+-----+ > +-----+-----+
+    def push_up(current)
+      return unless index = @views.index(current)
+      previous = @views[index - 1]
+      current.raise(previous)
+      @views[index - 1], @views[index] = current, previous
+
+      apply
+    end
+
+    # called on #3
+    # +-----+-----+ > +-----+-----+ > +-----+-----+ > +-----+-----+
+    # |     |  2  | > |     |  1  | > |     |  3  | > |     |  2  |
+    # |  1  +-----+ > |  3  +-----+ > |  1  +-----+ > |  1  +-----+
+    # |     |  3  | > |     |  2  | > |     |  2  | > |     |  3  |
+    # +-----+-----+ > +-----+-----+ > +-----+-----+ > +-----+-----+
+    def push_down(current)
+      return unless index = @views.index(current)
+      following = @views[index + 1] || @views[0]
+      current.raise(following)
+      @views[@views.index(following)], @views[index] = current, following
+
+      apply
+    end
+
+    def push_top(current)
+      @views.unshift(@views.delete(current))
+      apply
+    end
+
+    def push_bottom(view)
+      @views.push(@views.delete(view))
+      apply
+    end
+
     def apply(options = {})
-      strategy.apply(self, options)
+      @options.merge!(options)
+      strategy.apply(self, @options)
+    end
+
+    def head_tail_hidden(options = {})
+      @options.merge!(options)
+      strategy.prepare(self, @options)
+    end
+
+    module Tiling
+      DEFAULT = { master: 1, stacking: 3 }
+
+      def prepare(layout, options)
+        slaves = layout.views
+        master, stacking = DEFAULT.merge(options).values_at(:master, :stacking)
+        options.merge! master: master, stacking: stacking
+        head, tail, hidden = slaves[0...master], slaves[master..stacking], slaves[stacking..-1]
+      end
+
+      def apply(layout, options = {})
+        masters, stacked, hidden = prepare(layout, options)
+
+        limit = stacked.size == 0 ? 1.0 : 0.5
+
+        apply_hidden(hidden) if hidden
+        apply_masters(masters, limit) if masters
+        apply_stacked(stacked, limit) if stacked
+      end
+
+      def apply_hidden(windows)
+        windows.each(&:place_forget)
+      end
     end
 
     module VerticalTiling
-      DEFAULT = { left: 1, right: -1 }
+      extend Tiling
 
       module_function
 
-      def apply(layout, options = {})
-        slaves = layout.winfo_children
-        left, right = DEFAULT.merge(options).values_at(:left, :right)
-        head, tail = slaves[0...left], slaves[left..right]
-        width = tail.size == 0 ? 1.0 : 0.5
-        head_step = 1.0 / head.size
-        tail_step = 1.0 / tail.size
-
-        head.each_with_index do |slave, idx|
-          slave.place(relx: 0.0, rely: (head_step * idx),
-                      relheight: head_step, relwidth: width)
-        end
+      def apply_masters(windows, width, step = 1.0 / windows.size)
+        windows.each_with_index{|window, idx|
+          window.place(relx: 0.0, rely: (step * idx),
+                      relheight: step, relwidth: width) }
+      end
 
-        tail.each_with_index do |slave, idx|
-          slave.place(relx: 0.5, rely: (tail_step * idx),
-                      relheight: tail_step, relwidth: width)
-        end
+      def apply_stacked(windows, width, step = 1.0 / windows.size)
+        windows.each_with_index{|window, idx|
+          window.place(relx: 0.5, rely: (step * idx),
+                      relheight: step, relwidth: width) }
       end
     end
 
     module HorizontalTiling
-      DEFAULT = { top: 1, bottom: -1 }
+      extend Tiling
 
       module_function
 
-      def apply(layout, options = {})
-        slaves = layout.winfo_children
-        top, bottom = DEFAULT.merge(options).values_at(:top, :bottom)
-        head, tail = slaves[0...top], slaves[top..bottom]
-        height = tail.size == 0 ? 1.0 : 0.5
-        head_step = 1.0 / head.size
-        tail_step = 1.0 / tail.size
-
-        head.each_with_index do |slave, idx|
-          slave.place(relx: (head_step * idx), rely: 0.0,
-                      relheight: height, relwidth: head_step)
+      def apply_masters(windows, height, step = 1.0 / windows.size)
+        windows.each_with_index do |window, idx|
+          window.place(relx: (step * idx), rely: 0.0,
+                       relheight: height, relwidth: step)
         end
+      end
 
-        tail.each_with_index do |slave, idx|
-          slave.place(relx: (tail_step * idx), rely: 0.5,
-                      relheight: height, relwidth: tail_step)
+      def apply_stacked(windows, height, step = 1.0 / windows.size)
+        windows.each_with_index do |window, idx|
+          window.place(relx: (step * idx), rely: 0.5,
+                       relheight: height, relwidth: step)
         end
       end
     end
   end
-end
+end

data/lib/ver/methods.rb

@@ -1,19 +1,35 @@
-require 'ver/methods/move'
-require 'ver/methods/views'
-require 'ver/methods/insert'
+require 'ver/methods/completion'
+require 'ver/methods/clipboard'
 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/completion'
+require 'ver/methods/views'
+require 'ver/methods/shortcuts'
 
 module VER
   module Methods
-    include Move
-    include Views
-    include Insert
+    include Completion
     include Control
+    include Ctags
+    include Delete
+    include Help
+    include Insert
+    include Move
+    include Open
+    include Preview
+    include Save
     include Search
     include Select
-    include Completion
+    include Shortcuts
+    include Clipboard
+    include Views
   end
 end

data/lib/ver/methods/clipboard.rb

@@ -0,0 +1,91 @@
+module VER
+  module Methods
+    module Clipboard
+      def copy_line
+        copy get('insert linestart', 'insert lineend + 1 chars')
+      end
+
+      def copy_right_word
+        copy get('insert', 'insert wordend')
+      end
+
+      def copy_left_word
+        copy get('insert', 'insert wordstart')
+      end
+
+      def copy(text)
+        if text.respond_to?(:to_str)
+          copy_string(text)
+        elsif text.respond_to?(:to_ary)
+          copy_array(text)
+        else
+          copy_fallback(text)
+        end
+      end
+
+      def copy_string(text)
+        clipboard_set(text = text.to_str, type: 'STRING')
+
+        copy_message text.count("\n"), text.size
+      end
+
+      def copy_array(text)
+        array = text.to_ary
+        string = array.map(&:to_tcl).join(' ')
+        clipboard_set(string, type: 'ARRAY')
+
+        copy_message text.size, text.reduce(0){|s,v| s + v.size }
+      end
+
+      def copy_fallback(text)
+        clipboard_set(text)
+
+        message "Copied unkown entity of class %p" % [text.class]
+      end
+
+      def copy_message(lines, chars)
+        lines_desc = lines == 1 ? 'line' : 'lines'
+        chars_desc = chars == 1 ? 'character' : 'characters'
+
+        msg = "copied %d %s of %d %s" % [lines, lines_desc, chars, chars_desc]
+        message msg
+      end
+
+      def paste_continous(text)
+        if text =~ /\A([^\n]*)\n\Z/
+          mark_set :insert, 'insert lineend'
+          insert :insert, "\n#{$1}"
+        elsif text =~ /\n/
+          mark_set :insert, 'insert lineend'
+          insert :insert, "\n"
+          text.each_line{|line| insert(:insert, line) }
+        else
+          insert :insert, text
+        end
+      end
+
+      def paste_tk_array(chunks)
+        insert_y, insert_x = index(:insert).split
+
+        chunks.each_with_index do |chunk, idx|
+          y = insert_y + idx
+          insert "#{y}.#{insert_x}", chunk
+        end
+      end
+
+      # FIXME: nasty hack or neccesary?
+      def paste
+        text = clipboard_get
+        paste_continous text.to_s
+
+      rescue RuntimeError => ex
+        if ex.message =~ /form "STRING" not defined/
+          array = clipboard_get('ARRAY')
+          paste_tk_array array.to_a
+        else
+          Kernel.raise ex
+        end
+      end
+    end
+  end
+end

data/lib/ver/methods/completion.rb

@@ -1,26 +1,156 @@
 module VER
   module Methods
     module Completion
+      # TODO: use the tag names at the location to customize completion choices
+      # the textmate bundles have quite some stuff for that.
+      def smart_tab
+        context = get('insert - 1 chars', 'insert + 1 chars')
+
+        if context =~ /^\S\W/
+          if @complete_last_used
+            complete_again
+          else
+            complete_word
+          end
+        else
+          indent = ' ' * VER.options.shiftwidth
+          insert :insert, indent
+        end
+      end
+
+      def complete_again
+        send(@complete_last_used) if @complete_last_used
+      end
+
+      def complete_tm
+        return unless load_preferences
+        require 'set'
+        require 'tempfile'
+
+        @complete_last_used = :complete_tm
+
+        from, to = 'insert - 1 chars wordstart', 'insert - 1 chars wordend'
+
+        complete{ [from, to, tm_completions(from, to)] }
+      end
+
+      def tm_completions(from, to)
+        tags  = Set.new(tag_names(to))
+        completions = []
+
+        @preferences.each do |key, value|
+          name, scope, settings, uuid =
+            value.values_at('name', 'scope', 'settings', 'uuid')
+          scopes = Set.new(scope.split(/\s*,\s*|\s+/))
+
+          next unless completion_command = settings['completionCommand']
+          next unless scope_compare(tags, scopes)
+
+          current_word = get(from, to).strip
+          ENV['TM_CURRENT_WORD'] = current_word
+
+          tmp = Tempfile.new('ver/complete_tm')
+          tmp.print(completion_command)
+          tmp.close
+          begin
+            FileUtils.chmod(0700, tmp.path)
+            result = `exec '#{tmp.path}'`
+            completions = result.scan(/[^\r\n]+/)
+          ensure
+            tmp.close!
+          end
+        end
+
+        completions
+      rescue => ex
+        VER.error(ex)
+      end
+
+      def scope_compare(tags, scopes)
+        scopes.all?{|scope| tags.any?{|tag| scope.start_with?(tag) }}
+      end
+
+      def complete_line
+        @complete_last_used = :complete_line
+
+        from, to = 'insert linestart', 'insert lineend'
+        lines = line_completions(from, to)
+
+        complete{ [from, to, lines] }
+      end
+
+      def line_completions(from, to)
+        line = get(from, to).to_s.strip
+
+        return [] if line.empty?
+        needle = Regexp.escape(line)
+        search_all(/^.*#{needle}.*$/).map{|match, *_| match }.uniq
+      end
+
       def complete_file
-        files = file_completions
-        complete(files)
+        @complete_last_used = :complete_file
+
+        complete continue: true do
+          file_completions('insert linestart', 'insert')
+        end
       end
 
-      def complete_aspell
-        words = aspell_completions
-        complete(words)
+      def file_completions(from, to)
+        y = index(from).y
+        line = get(from, to)
+
+        return [] unless match = line.match(/(?<pre>.*?)(?<path>\/[^\s"'{}()\[\]]*)(?<post>.*?)/)
+        from, to = match.offset(:path)
+        path = match[:path]
+
+        path.sub!(/\/*$/, '/') if File.directory?(path)
+
+        list = Dir["#{path}*"].uniq - [path]
+
+        list.map! do |item|
+          item << '/' if File.directory?(item)
+          item.sub(path, '/')
+        end
+
+        return "#{y}.#{to - 1}", "#{y}.#{to}", list
+      end
+
+      def complete_word
+        @complete_last_used = :complete_word
+
+        y, x = index('insert').split
+        x = (x - 1).abs
+        from, to = index("#{y}.#{x} wordstart"), index("#{y}.#{x} wordend")
+
+        words = word_completions(from, to)
+
+        complete{ [from, to, words] }
+      end
+
+      def word_completions(from, to)
+        prefix = get(from, to).strip
+        return [] if prefix.empty?
+        prefix = Regexp.escape(prefix)
+
+        found = search_all(/(^|\W)(#{prefix}[\w-]*)/).
+          sort_by{|match, mf, mt| [Text::Index.new(self, mf).delta(from), match] }.
+          map{|match, *_| match.strip[/[\w-]+/] }.uniq
+        found.delete prefix
+        found
       end
 
-      def file_completions
-        word = get('insert wordstart', 'insert wordend')
+      def complete_aspell
+        @complete_last_used = :complete_aspell
 
-        glob = "#{word}*{**/*,/**/*}"
-        p glob
-        Dir[glob].uniq
+        complete do
+          pos = index('insert - 1 chars')
+          from, to = pos.wordstart, pos.wordend
+          [from, to, aspell_completions(from, to)]
+        end
       end
 
-      def aspell_completions
-        word = get('insert wordstart', 'insert wordend')
+      def aspell_completions(from, to)
+        word = get(from, to)
 
         if result = aspell_execute(word)[word]
           result[:suggestions]
@@ -52,65 +182,10 @@ module VER
         return results
       end
 
-      def complete(words)
-        return if words.empty?
-
-        x, y = caret.values_at('x', 'y')
-        longest_word = words.map{|word| word.size }.max
-
-        list = Tk::Listbox.new(self){
-          borderwidth 0
-          width longest_word + 2
-          height words.size
-          place x: x, y: y
-          focus
-        }
-
-        list.value = words
-        list.selection_set 0
-
-        # go down
-        list.bind('j'){|event|
-          index = list.curselection.first + 1
-          max = list.size
-
-          if index < max
-            list.selection_clear(0, 'end')
-            list.selection_set(index)
-            list.activate(index)
-          end
-
-          Tk.callback_break
-        }
-
-				# go up
-        list.bind('k'){|event|
-          index = list.curselection.first - 1
-
-          if index >= 0
-            list.selection_clear(0, 'end')
-            list.selection_set(index)
-            list.activate(index)
-          end
-
-          Tk.callback_break
-        }
-
-        list.bind('Return'){|event|
-          index = list.curselection.first
-          replacement = list.get(index)
-          replace('insert wordstart', 'insert wordend', replacement)
-          focus
-          list.destroy
-          Tk.callback_break
-        }
-
-        list.bind('Escape'){|event|
-          focus
-          list.destroy
-          Tk.callback_break
-        }
+      def complete(options = {}, &block)
+        edit_separator
+        HoverCompletion.new(self, options, &block)
       end
     end
   end
-end
+end