ver 2009.10.14

data/lib/ver/keymap.rb

@@ -0,0 +1,96 @@
+module VER
+  class Keymap
+    def self.get(options)
+      name = options.fetch(:name)
+
+      find_and_load(name)
+      send(name, options)
+    end
+
+    def self.find(keymap_name)
+      VER.find_in_loadpath("keymap/#{keymap_name}.rb")
+    end
+
+    def self.find_and_load(keymap_name)
+      if path = find(keymap_name)
+        sane = path.dirname/path.basename(path.extname)
+        require sane.to_s
+      else
+        raise LoadError, "cannot find keymap: %p" % [keymap_name]
+      end
+    end
+
+    attr_accessor :modes, :callback, :widget, :tag
+    attr_reader :mode
+
+    def initialize(options)
+      @callback = options.fetch(:receiver)
+      @widget = options.fetch(:widget, @callback)
+      @modes = {}
+
+      prepare_tag
+      prepare_default_binds
+    end
+
+    def send(*args)
+      @callback.__send__(*args)
+    end
+
+    def enter_key(key)
+      modes[mode].enter_key key
+    end
+
+    def enter_missing(key)
+      modes[mode].enter_missing key
+    end
+
+    def prepare_tag
+      self.tag = TkBindTag.new
+      tags = widget.bindtags
+
+      index = tags.index{|element| element.is_a?(Class) }
+      tags[index - 1, 0] = @tag
+
+      widget.bindtags = tags
+    end
+
+    def prepare_default_binds
+      tag.bind 'Key' do |event|
+        case event.char
+        when ''
+          # enter_missing event.keysym
+          # p event
+        else
+          enter_missing event.char
+        end
+
+        Tk.callback_break
+      end
+
+      0.upto 9 do |n|
+        tag.bind("KeyPress-#{n}") do |key|
+          enter_key n.to_s
+          Tk.callback_break
+        end
+      end
+    end
+
+    def register(key)
+      tag.bind(key){|event|
+        enter_key key
+        Tk.callback_break
+      }
+    end
+
+    # TODO: callbacks
+    def mode=(cm)
+      @mode = cm.to_sym
+    end
+
+    def add_mode(name)
+      @modes[name.to_sym] = mode = VER::Mode.new(name, self)
+      yield mode if block_given?
+      mode
+    end
+  end
+end

data/lib/ver/layout.rb

@@ -0,0 +1,107 @@
+module VER
+  class Layout < Ttk::Frame
+    attr_reader :strategy, :views
+
+    def initialize(parent, options = {})
+      super
+
+      pack(fill: :both, expand: true)
+
+      @views = []
+      self.strategy = Layout::VerticalTiling
+    end
+
+    def strategy=(mod)
+      @strategy = mod
+      apply if @views.any?
+    end
+
+    def create_view
+      view = View.new(self)
+      yield view
+      @views << view
+
+      apply
+    end
+
+    def close_view(view)
+      @views.delete view
+      view.destroy
+
+      if previous = @views.last
+        apply
+        previous.focus
+      else
+        Tk.exit
+      end
+    end
+
+    def focus_next(current)
+      return unless index = @views.index(current)
+
+      found = @views[index + 1] || @views[0]
+      found.focus
+    end
+
+    def focus_prev(current)
+      return unless index = @views.index(current)
+
+      found = @views[index - 1]
+      found.focus
+    end
+
+    def apply(options = {})
+      strategy.apply(self, options)
+    end
+
+    module VerticalTiling
+      DEFAULT = { left: 1, right: -1 }
+
+      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
+
+        tail.each_with_index do |slave, idx|
+          slave.place(relx: 0.5, rely: (tail_step * idx),
+                      relheight: tail_step, relwidth: width)
+        end
+      end
+    end
+
+    module HorizontalTiling
+      DEFAULT = { top: 1, bottom: -1 }
+
+      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)
+        end
+
+        tail.each_with_index do |slave, idx|
+          slave.place(relx: (tail_step * idx), rely: 0.5,
+                      relheight: height, relwidth: tail_step)
+        end
+      end
+    end
+  end
+end

data/lib/ver/methods.rb

@@ -0,0 +1,19 @@
+require 'ver/methods/move'
+require 'ver/methods/views'
+require 'ver/methods/insert'
+require 'ver/methods/control'
+require 'ver/methods/search'
+require 'ver/methods/select'
+require 'ver/methods/completion'
+
+module VER
+  module Methods
+    include Move
+    include Views
+    include Insert
+    include Control
+    include Search
+    include Select
+    include Completion
+  end
+end

data/lib/ver/methods/completion.rb

@@ -0,0 +1,116 @@
+module VER
+  module Methods
+    module Completion
+      def complete_file
+        files = file_completions
+        complete(files)
+      end
+
+      def complete_aspell
+        words = aspell_completions
+        complete(words)
+      end
+
+      def file_completions
+        word = get('insert wordstart', 'insert wordend')
+
+        glob = "#{word}*{**/*,/**/*}"
+        p glob
+        Dir[glob].uniq
+      end
+
+      def aspell_completions
+        word = get('insert wordstart', 'insert wordend')
+
+        if result = aspell_execute(word)[word]
+          result[:suggestions]
+        else
+          [word]
+        end
+      end
+
+      ASPELL_PARSE = /^& (.*?) (\d+) (\d+): (.*)$/
+
+      def aspell_execute(word)
+        require 'open3'
+        results = {}
+
+        Open3.popen3("aspell pipe") do |stdin, stdout, stderr|
+          stdin.print("^#{word}")
+          stdin.close
+          result = stdout.read
+
+          result.scan(ASPELL_PARSE) do |original, count, offset, suggestions|
+            results[original] = {
+              count: count.to_i,
+              offset: offset.to_i,
+              suggestions: suggestions.split(/\s*,\s*/),
+            }
+          end
+        end
+
+        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
+        }
+      end
+    end
+  end
+end

data/lib/ver/methods/control.rb

@@ -0,0 +1,340 @@
+module VER
+  module Methods
+    module Control
+      def status_theme_select
+        return unless @syntax
+
+        status_ask 'Theme name: ' do |name|
+          load_theme(name) || "No theme called #{name} found"
+        end
+      end
+
+      def theme_switch
+        return unless @syntax
+
+        View::List::Theme.new(self){|name| load_theme(name) }
+      end
+
+      def syntax_switch
+        return unless @syntax
+
+        View::List::Syntax.new(self){|name| load_syntax(name) }
+      end
+
+      def status_evaluate
+        status_ask 'Eval expression: ' do |term|
+          eval(term)
+        end
+      end
+
+      def status_ask(prompt, &callback)
+        @status.ask(prompt){|*args|
+          begin
+            callback.call(*args)
+          rescue => ex
+            p ex
+            status.message ex.message
+          ensure
+            focus
+          end
+        }
+      end
+
+      def smart_evaluate
+        from, to = tag_ranges(:sel).first
+
+        if from && to
+          selection_evaluate
+        else
+          line_evaluate
+        end
+      end
+
+      def line_evaluate
+        text = get('insert linestart', 'insert lineend')
+        result = eval(text)
+        insert("insert lineend", "\n#{result.inspect}\n")
+      end
+
+      def buffer_switch
+        View::List::Buffer.new self do |file|
+
+          # VER.resume_buffer file_path
+          open_path file if File.exists? file
+        end
+      end
+
+      def window_switch(count = nil)
+        if count
+          p count: count
+        else
+          View::List::Window.new self do |view|
+            view.focus
+            # open_path(path)
+          end
+        end
+      end
+
+      def file_save
+        save_to(filename)
+      end
+
+      def file_save_popup
+        filetypes = [
+          ['ALL Files',  '*'    ],
+          ['Text Files', '*.txt'],
+        ]
+
+        filename  = ::File.basename @filename
+        extension = ::File.extname  @filename
+        directory = ::File.dirname  @filename
+
+        fpath = Tk.getSaveFile(
+          initialfile: filename,
+          initialdir: directory,
+          defaultextension: extension,
+          filetypes: filetypes
+        )
+
+        return if fpath.empty?
+
+        save_to(fpath)
+      end
+
+      # Some strategies are discussed at:
+      #
+      # http://bitworking.org/news/390/text-editor-saving-routines
+      #
+      # I try another, "wasteful" approach, copying the original file to a
+      # temporary location, overwriting the contents in the copy, then moving the
+      # file to the location of the original file.
+      #
+      # This way all permissions should be kept identical without any effort, but
+      # it will take up additional disk space.
+      #
+      # If there is some failure during the normal saving procedure, we will
+      # simply overwrite the original file in place, make sure you have good insurance ;)
+      def save_to(to)
+        save_smart(filename, to)
+      rescue => ex
+        puts "#{ex.class}: #{ex}", *ex.backtrace
+        save_dumb(filename, to)
+      end
+
+      def save_smart(from, to)
+        sha1 = Digest::SHA1.hexdigest([from, to].join)
+        temp_path = File.join(Dir.tmpdir, 'ver', sha1)
+        temp_dir = File.dirname(temp_path)
+
+        FileUtils.mkdir_p(temp_dir)
+        FileUtils.copy_file(from, temp_path, preserve = true)
+        File.open(temp_path, 'w+') do |io|
+          io.write(self.value)
+        end
+        FileUtils.mv(temp_path, to)
+
+        status.message "Saved to #{to}"
+      rescue Errno::ENOENT
+        save_dumb(to)
+      end
+
+      def save_dumb(to)
+        File.open(to, 'w+') do |io|
+          io.write(self.value)
+        end
+
+        status.message "Saved to #{to}"
+      end
+
+      def file_open_popup
+        filetypes = [
+          ['ALL Files',  '*'    ],
+          ['Text Files', '*.txt'],
+        ]
+
+        fpath = Tk.getOpenFile(filetypes: filetypes)
+
+        return if fpath.empty?
+
+        open_path(fpath)
+      end
+
+      def file_open_fuzzy
+        View::List::FuzzyFileFinder.new self do |path|
+          open_path(path)
+        end
+      end
+
+      def delete_char_left
+        delete 'insert - 1 char'
+      end
+
+      def delete_char_right
+        delete 'insert'
+      end
+
+      def delete_word_right
+        delete 'insert', 'insert wordend'
+      end
+
+      def delete_word_left
+        delete 'insert wordstart', 'insert'
+      end
+
+      def delete_line
+        delete 'insert linestart', 'insert lineend + 1 char'
+      end
+
+      def delete_to_eol
+        delete 'insert', 'insert lineend'
+      end
+
+      def delete_to_eol_then_insert
+        delete_to_eol
+        start_insert_mode
+      end
+
+      def join_lines
+        start_of_next_line = search(/\S/, 'insert lineend')
+        replace('insert lineend', start_of_next_line, ' ')
+      rescue RuntimeError => exception
+        return if exception.message =~ /Index "\d+\.\d+" before "insert lineend" in the text/
+        raise exception
+      end
+
+      def insert_string(string)
+        # puts "Insert %p in mode %p" % [string, keymap.mode]
+        insert :insert, string unless string.empty?
+      end
+
+      def ignore_string(string)
+        status.message "Ignore %p in mode %p" % [string, keymap.mode]
+      end
+
+      def replace_char
+        status_ask 'Replace with: ' do |string|
+          replace('insert', 'insert + 1 chars', string)
+        end
+      end
+
+      def indent_line
+        insert('insert linestart', '  ')
+      end
+
+      def unindent_line
+       line = get('insert linestart', 'insert lineend')
+
+       return unless line =~ /^(\s\s?)/
+
+       replace(
+         'insert linestart',
+         "insert linestart + #{$1.size} chars",
+         ''
+       )
+      end
+
+      def insert_indented_newline_below
+        line = get('insert linestart', 'insert lineend')
+
+        indent = line.empty? ? "" : (line[/^\s+/] || '')
+        mark_set :insert, 'insert lineend'
+        insert :insert, "\n#{indent}"
+
+        start_insert_mode
+      end
+
+      def insert_indented_newline_above
+        y, x = index(:insert).split('.').map(&:to_i)
+
+        if y > 1
+          go_line_up
+          insert_indented_newline_below
+        else
+          insert('insert linestart', "\n")
+          mark_set(:insert, 'insert - 1 line')
+        end
+      end
+
+      def insert_newline
+        insert :insert, "\n"
+      end
+
+      def insert_indented_newline
+        line1 = get('insert linestart', 'insert lineend')
+        indentation1 = line1[/^\s+/] || ''
+        insert :insert, "\n"
+
+        line2 = get('insert linestart', 'insert lineend')
+        indentation2 = line2[/^\s+/] || ''
+
+        replace(
+          'insert linestart',
+          "insert linestart + #{indentation2.size} chars",
+          indentation1
+        )
+      end
+
+      def insert_tab
+        insert :insert, "\t"
+      end
+
+      def eol_then_insert_mode
+        go_end_of_line
+        start_insert_mode
+      end
+
+      def sol_then_insert_mode
+        go_beginning_of_line
+        start_insert_mode
+      end
+
+      def start_insert_mode
+        self.mode = :insert
+      end
+
+      def start_control_mode
+        self.mode = :control
+      end
+
+      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
+
+      # FIXME: nasty hack or neccesary?
+      def paste
+        text = TkClipboard.get
+        paste_continous text
+
+      rescue RuntimeError => ex
+        if ex.message =~ /form "STRING" not defined/
+          array = TkClipboard.get type: Array
+          paste_tk_array array
+        else
+          Kernel.raise ex
+        end
+      end
+
+      def undo
+        edit_undo
+        touch!
+      rescue RuntimeError => ex
+        status.value = ex.message
+      end
+
+      def redo
+        edit_redo
+        touch!
+      rescue RuntimeError => ex
+        status.value = ex.message
+      end
+    end
+  end
+end