ver 2009.10.14

data/lib/ver/view/entry.rb

@@ -0,0 +1,28 @@
+module VER
+  class View
+    # This sucks, should we go method_missing?
+    class Entry < VER::Entry
+      attr_accessor :list_view
+
+      def pick_first
+        list_view.pick_first
+      end
+
+      def pick_selection
+        list_view.pick_selection
+      end
+
+      def cancel
+        list_view.cancel
+      end
+
+      def go_line_up
+        list_view.go_line_up
+      end
+
+      def go_line_down
+        list_view.go_line_down
+      end
+    end
+  end
+end

data/lib/ver/view/list.rb

@@ -0,0 +1,137 @@
+module VER
+  class View::List < Struct.new(:parent, :frame, :list, :entry, :tag, :callback)
+    autoload :Buffer,          'ver/view/list/buffer'
+    autoload :Window,          'ver/view/list/buffer'
+    autoload :FuzzyFileFinder, 'ver/view/list/fuzzy_file_finder'
+    autoload :Syntax,          'ver/view/list/syntax'
+    autoload :Theme,           'ver/view/list/theme'
+
+    def initialize(parent, &block)
+      self.parent, self.callback = parent, block
+
+      setup_widgets
+      setup_keymap
+      setup_events
+      on_update
+    end
+
+    def setup_widgets
+      self.frame = TkFrame.new{
+        pack fill: :both, expand: true
+      }
+
+      self.list = Tk::Listbox.new(frame){
+        setgrid 'yes'
+        width 0
+        background '#000'
+        foreground '#fff'
+        selectforeground '#000'
+        selectbackground '#fff'
+        font VER.options[:font]
+        pack fill: :both, expand: true
+      }
+
+      self.entry = View::Entry.new(frame){
+        pack fill: :x, expand: false
+        font VER.options[:font]
+        focus
+      }
+      entry.list_view = self
+    end
+
+    def setup_keymap
+      keymap_name = VER.options.fetch(:keymap)
+
+      @list_keymap = Keymap.get(
+        name: keymap_name, receiver: self, widget: list, mode: :list_view_list)
+
+      @entry_keymap = Keymap.get(
+        name: keymap_name, receiver: entry, widget: entry, mode: :list_view_entry)
+    end
+
+    # Setup this event, because Keymap gets very confused when you bind 'Key' and
+    # we don't want to break the event-chain anyway
+    def setup_events
+      entry.bind('<Modified>'){ on_update }
+    end
+
+    def on_update
+      update
+      list.selection_set(0)
+      list.activate(0)
+    end
+
+    def quit
+      Tk.exit
+    end
+
+    def go_line_up
+      index = list.curselection.first - 1
+
+      if index >= 0
+        list.selection_clear(0, 'end')
+        select_index(index)
+      end
+    end
+
+    def go_line_down
+      index = list.curselection.first + 1
+      max = list.size
+
+      if index < max
+        list.selection_clear(0, 'end')
+        select_index(index)
+      end
+    end
+
+    def select_index(index)
+      list.selection_set(index)
+      list.activate(index)
+      list.see(index)
+    end
+
+    def cancel
+      destroy
+    end
+
+    def destroy
+      entry.destroy
+      list.destroy
+      frame.destroy
+      parent.focus
+    end
+
+    def sublist(list, input = entry.value)
+      if input == input.downcase
+        list.select{|item| item.to_s.downcase.include?(input) }
+      else
+        list.select{|item| item.to_s.include?(input) }
+      end
+    end
+
+    def pick(item)
+      if list.size > 0
+        pick_action(item)
+        destroy
+      else
+        message "VER is confused, what did you actually want to do?"
+      end
+    end
+
+    def pick_first
+      pick list.get(0)
+    end
+
+    def pick_selection
+      pick TkSelection.get
+    end
+
+    def pick_action(item)
+      callback.call(item) if callback
+    end
+
+    def message(string)
+      parent.status.message(string)
+    end
+  end
+end

data/lib/ver/view/list/buffer.rb

@@ -0,0 +1,27 @@
+module VER
+  class View::List::Window < View::List
+    def update
+      list.value = sublist(windows.keys)
+    end
+
+    def windows
+      path_view = parent.layout.views.map{|view| [view.filename.to_s, view] }
+      Hash[path_view]
+    end
+
+    def pick_action(filename)
+      view = windows[filename]
+      callback.call(view) if callback && view
+    end
+  end
+
+  class View::List::Buffer < View::List
+    def update
+      list.value = sublist(buffers)
+    end
+
+    def buffers
+      VER.paths.map(&:to_s).select {|b| ! b.empty? }
+    end
+  end
+end

data/lib/ver/view/list/fuzzy_file_finder.rb

@@ -0,0 +1,44 @@
+require 'ver/vendor/fuzzy_file_finder'
+
+module VER
+  class View::List::FuzzyFileFinder < View::List
+    FFF = ::FuzzyFileFinder
+
+    def fffinder
+      @fffinder ||= FFF.new(Dir.pwd)
+    rescue FFF::TooManyEntries
+      message "The FuzzyFileFinder is overwhelmed by the amount of files"
+      destroy
+    end
+
+    def update
+      choices = fffinder.find(entry.value.chomp('/'))
+      choices = choices.sort_by{|m| [-m[:score], m[:path]] }
+
+      list.clear
+
+      pwd = Dir.pwd + '/'
+      choices.each do |choice|
+        choice[:path].sub!(pwd, '')
+        insert_choice(choice)
+      end
+    end
+
+    def insert_choice(choice)
+      path, score = choice.values_at(:path, :score)
+      list.insert(:end, path)
+
+      foreground, background =
+        case score
+        when 0          ; ['white',  'black']
+        when 0   ..0.25 ; ['red',    'black']
+        when 0.25..0.75 ; ['yellow', 'black']
+        when 0.75..1    ; ['green',  'black']
+        end
+
+      list.itemconfigure(:end,
+              foreground: foreground,       background: background,
+        selectforeground: background, selectbackground: foreground)
+    end
+  end
+end

data/lib/ver/view/list/syntax.rb

@@ -0,0 +1,13 @@
+module VER
+  class View::List::Syntax < View::List
+    def update
+      list.value = sublist(syntaxes)
+    end
+
+    def syntaxes
+      VER::Syntax.list.map do |fullpath|
+        File.basename(fullpath, File.extname(fullpath))
+      end
+    end
+  end
+end

data/lib/ver/view/list/theme.rb

@@ -0,0 +1,13 @@
+module VER
+  class View::List::Theme < View::List
+    def update
+      list.value = sublist(themes)
+    end
+
+    def themes
+      VER::Theme.list.map do |fullpath|
+        File.basename(fullpath, File.extname(fullpath))
+      end
+    end
+  end
+end

data/spec/keymap.rb

@@ -0,0 +1,224 @@
+require 'bacon'
+Bacon.summary_on_exit
+
+module VER
+  class Keyboard
+  end
+
+  class Keymap
+    attr_accessor :modes, :current_mode
+
+    def initialize
+      @modes = {}
+    end
+
+    def send(*args)
+      @callback.__send__(*args)
+    end
+
+    def enter_key(key)
+      modes[current_mode].enter_key key
+    end
+
+    # TODO: callbacks
+    def current_mode=(cm)
+      @current_mode = cm.to_sym
+    end
+
+    def add_mode(name)
+      @modes[name.to_sym] = mode = Mode.new(self)
+      yield mode if block_given?
+      mode
+    end
+  end
+
+  class Mode
+    def initialize(callback = nil)
+      @callback = callback
+      @stack = []
+      @map = {}
+      @ancestors = []
+    end
+
+    def inherit(other)
+      @ancestors.delete other
+      @ancestors.unshift other
+    end
+
+    def ancestors(&block)
+      ([self] + @ancestors).find(&block)
+    end
+
+    def map(sym, *keychain)
+      bind(*keychain.flatten){|*arg| @callback.send(sym, *arg) }
+    end
+
+    def bind(*keychain, &block)
+      keychain = keychain.dup
+      total = hash = {}
+
+      while key = keychain.shift
+        if keychain.empty?
+          hash[key] = block
+        else
+          hash = hash[key] = {}
+        end
+      end
+
+      @map.replace @map.merge(total, &MERGER)
+    end
+
+    def enter_keys(*keys)
+      keys.flatten.each{|key| enter_key(key) }
+    end
+
+    def enter_key(key)
+      @stack << key
+      ancestors{|ancestor| ancestor.attempt_execute(@stack) }
+    end
+
+    def attempt_execute(original_stack)
+      stack, arg = Mode.split_stack(original_stack)
+      return false if stack.empty?
+
+      executable = stack.inject(@map){|keys, key| keys.fetch(key) }
+
+      if execute(executable, *arg)
+        original_stack.clear
+        return true
+      end
+
+      false
+    rescue KeyError
+      false
+    end
+
+    def execute(executable, *arg)
+      case executable
+      when Proc
+        executable.call(*arg)
+        true
+      when Symbol
+        @callback.send(executable, *arg)
+      else
+        false
+      end
+    end
+
+    def self.split_stack(stack)
+      return stack, nil if stack[0] == '0'
+
+      pivot = stack.index{|c| c !~ /\d/ }
+
+      if pivot == 0
+        return stack, nil
+      elsif pivot
+        return stack[pivot..-1], stack[0..pivot].join.to_i
+      else
+        return [], nil
+      end
+    end
+
+    MERGER = proc{|key,v1,v2|
+      Hash === v1 && Hash === v2 ? v1.merge(v2, &MERGER) : v2
+    }
+  end
+end
+
+describe Mode = VER::Mode do
+  it 'splits stack into argument and keychain' do
+    Mode.split_stack(['4', 'a']).should == [['a'], 4]
+    Mode.split_stack(['4', '2', 'a']).should == [['a'], 42]
+    Mode.split_stack(['4', '2', 'a', 'b']).should == [['a', 'b'], 42]
+    Mode.split_stack(['a', 'b']).should == [['a', 'b'], nil]
+  end
+
+  it 'executes action assigned to key' do
+    done = false
+    mode = Mode.new
+    mode.bind('a'){ done = true }
+    mode.enter_keys 'a'
+    done.should == true
+  end
+
+  it 'executes action assigned to key chain (immediately)' do
+    done = false
+    mode = Mode.new
+    mode.bind('a', 'b', 'c'){ done = true }
+    mode.enter_keys 'a', 'b', 'c'
+    done.should == true
+  end
+
+  it 'executes action assigned to key chain (delayed)' do
+    done = false
+    mode = Mode.new
+    mode.bind('a', 'b', 'c'){ done = true }
+    mode.enter_key 'a'
+    mode.enter_key 'b'
+    mode.enter_key 'c'
+    done.should == true
+  end
+
+  it 'executes action with numeric argument' do
+    done = false
+    mode = Mode.new
+    mode.bind('a', 'b', 'c'){|arg| done = arg }
+    mode.enter_keys '4', '2', 'a', 'b', 'c'
+    done.should == 42
+  end
+
+  it 'executes action on callback' do
+    done = false
+    callback = Class.new{
+      attr_accessor :done
+
+      def foo
+        @done = true
+      end
+    }.new
+
+    mode = Mode.new(callback)
+    mode.map :foo, %w[a b c]
+    mode.enter_keys %w[a b c]
+    callback.done.should == true
+  end
+
+  it 'inherits another mode but executes actions itself' do
+    first_done = second_done = false
+    first, second = Mode.new, Mode.new
+    second.inherit(first)
+    second.bind('a', 'b', 'c'){|arg| second_done = arg }
+    second.enter_keys %w[4 2 a b c]
+    second_done.should == 42
+  end
+
+  it 'inherits another mode that also executes actions' do
+    first_done = second_done = false
+    first, second = Mode.new, Mode.new
+    second.inherit(first)
+
+    first.bind('first-key'){|arg| first_done = arg }
+    second.bind('second-key'){|arg| second_done = arg }
+
+    second.enter_keys %w[4 2 first-key]
+    first_done.should == 42
+
+    second.enter_keys %w[2 4 second-key]
+    second_done.should == 24
+  end
+end
+
+describe Keymap = VER::Keymap do
+  it 'adds a mode into the keymap' do
+    done = false
+
+    keymap = Keymap.new
+    keymap.add_mode :test do |mode|
+      mode.bind('a'){ done = true }
+    end
+    keymap.current_mode = :test
+
+    keymap.enter_key 'a'
+    done.should == true
+  end
+end