ver 2009.10.14

data/lib/ver/methods/insert.rb

@@ -0,0 +1,6 @@
+module VER
+  module Methods
+    module Insert
+    end
+  end
+end

data/lib/ver/methods/move.rb

@@ -0,0 +1,65 @@
+module VER
+  module Methods
+    module Move
+      def go_char_left(count = 1)
+        mark_set :insert, "insert - #{count} char"
+      end
+
+      def go_char_right(count = 1)
+        mark_set :insert, "insert + #{count} char"
+      end
+
+      def go_line_up(count = 1)
+        mark_set :insert, "insert - #{count} line"
+      end
+
+      def go_line_down(count = 1)
+        mark_set :insert, "insert + #{count} line"
+      end
+
+      def go_word_left
+        mark_set :insert, 'insert - 1 char'
+        mark_set :insert, 'insert wordstart'
+      end
+
+      def go_word_right
+        mark_set :insert, 'insert + 1 char'
+        mark_set :insert, 'insert wordend'
+      end
+
+      def go_beginning_of_line
+        mark_set :insert, 'insert linestart'
+      end
+
+      def go_end_of_line
+        mark_set :insert, 'insert lineend'
+      end
+
+      def go_line(number = 0)
+        mark_set :insert, "#{number}.0"
+      end
+
+      def go_end_of_file
+        mark_set :insert, :end
+      end
+
+      def go_page_up
+        height = Tk.root.winfo_height
+        linespace = cget(:font).metrics(:linespace)
+        diff = height / linespace
+
+        mark_set :insert, "insert - #{diff} line"
+        see :insert
+      end
+
+      def go_page_down
+        height = Tk.root.winfo_height
+        linespace = cget(:font).metrics(:linespace)
+        diff = height / linespace
+
+        mark_set :insert, "insert + #{diff} line"
+        see :insert
+      end
+    end
+  end
+end

data/lib/ver/methods/search.rb

@@ -0,0 +1,33 @@
+module VER
+  module Methods
+    module Search
+      def status_search
+        status_ask 'Search term: ' do |term|
+          tag_all_matching(:search, Regexp.new(term))
+        end
+      end
+
+      def search_next
+        from, to = tag_nextrange('search', 'insert + 1 chars', 'end')
+        mark_set(:insert, from) if from
+      end
+
+      def search_prev
+        from, to = tag_prevrange('search', 'insert - 1 chars', '0.0')
+        mark_set(:insert, from) if from
+      end
+
+      def search_next_word_under_cursor
+        word = get('insert wordstart', 'insert wordend')
+        tag_all_matching(:search, word)
+        search_next
+      end
+
+      def search_prev_word_under_cursor
+        word = get('insert wordstart', 'insert wordend')
+        tag_all_matching(:search, word)
+        search_prev
+      end
+    end
+  end
+end

data/lib/ver/methods/select.rb

@@ -0,0 +1,145 @@
+module VER
+  module Methods
+    module Select
+      def start_selection_mode(name)
+        self.mode = name
+        @selection_start = index(:insert).split('.').map(&:to_i)
+        refresh_selection
+      end
+
+      def switch_selection_mode(name)
+        self.mode = name
+        refresh_selection
+      end
+
+      %w[char line block].each do |suffix|
+        name = "select_#{suffix}"
+        define_method "start_#{name}_mode" do
+          start_selection_mode name
+        end
+
+        define_method "switch_#{name}_mode" do
+          switch_selection_mode name
+        end
+      end
+
+      def delete_selection
+        queue = tag_ranges(:sel).flatten
+        delete(*queue)
+        mark_set(:insert, queue.first)
+
+        clear_selection
+        start_control_mode
+      end
+
+      def indent_selection
+        each_selected_line do |y, fx, tx|
+          tx = fx + 2
+          next if get("#{y}.#{fx}", "#{y}.#{tx}").empty?
+          insert("#{y}.#{fx}", '  ')
+        end
+
+        edit_separator
+        refresh_selection
+      end
+
+      def unindent_selection
+        queue = []
+
+        each_selected_line do |y, fx, tx|
+          tx = fx + 2
+          left, right = "#{y}.#{fx}", "#{y}.#{tx}"
+          next unless get(left, right) == '  '
+          queue << left << right
+        end
+
+        delete(*queue)
+        edit_separator
+        refresh_selection
+      end
+
+      def selection_evaluate
+        tag_ranges(:sel).each do |from, to|
+          code = get(from, to)
+
+          begin
+            result = eval(code)
+            insert("#{to} lineend", "\n%p" % [result])
+          rescue => exception
+            insert("#{to} lineend", "\n%p" % [exception])
+          end
+        end
+      end
+
+      def copy_selection
+        chunks = tag_ranges(:sel).map{|sel| get(*sel) }
+        copy(chunks.size == 1 ? chunks.first : chunks)
+        clear_selection
+        start_control_mode
+      end
+
+      def pipe_selection
+        status_ask 'Pipe command: ' do |cmd|
+          pipe_selection_execute(cmd)
+          clear_selection
+          start_control_mode
+        end
+      end
+
+      def comment_selection
+        each_selected_line do |y, fx, tx|
+          insert("#{y}.0 linestart", '# ')
+        end
+
+        edit_separator
+        refresh_selection
+      end
+
+      def uncomment_selection
+        each_selected_line do |y, fx, tx|
+          delete("#{y}.0 linestart", "#{y}.0 linestart + 2 chars")
+        end
+
+        edit_separator
+        refresh_selection
+      end
+
+      private
+
+      def each_selection
+        tag_ranges(:sel).each do |sel|
+          (fy, fx), (ty, tx) = sel.map{|pos| pos.split('.').map(&:to_i) }
+          yield fy, fx, ty, tx
+        end
+      end
+
+      def each_selected_line
+        each_selection do |fy, fx, ty, tx|
+          fy.upto(ty) do |y|
+            yield y, fx, tx
+          end
+        end
+      end
+
+      def pipe_selection_execute(*cmd)
+        require 'open3'
+
+        Open3.popen3(*cmd) do |si, sose, thread|
+          queue = []
+          tag_ranges(:sel).each do |from, to|
+            si.write(get(from, to))
+            queue << from << to
+          end
+
+          si.close
+          output = sose.read
+
+          return if queue.empty?
+
+          delete(*queue)
+          insert(queue.first, output)
+        end
+      end
+    end
+  end
+end

data/lib/ver/methods/views.rb

@@ -0,0 +1,21 @@
+module VER
+  module Methods
+    module Views
+      def view_create
+        view.create
+      end
+
+      def view_close
+        view.close
+      end
+
+      def view_focus_next
+        view.focus_next
+      end
+
+      def view_focus_prev
+        view.focus_prev
+      end
+    end
+  end
+end

data/lib/ver/mode.rb

@@ -0,0 +1,160 @@
+module VER
+  class Mode
+    MERGER = proc{|key, v1, v2|
+      if v1.respond_to?(:merge) && v2.respond_to?(:merge)
+        v1.merge(v2, &MERGER)
+      else
+        v2
+      end
+    }
+
+    attr_accessor :callback, :name, :arguments
+
+    def initialize(name, callback)
+      @name, @callback = name, callback
+      @stack = []
+      @map = {}
+      @ancestors = []
+      @missing = nil
+      @arguments = true
+    end
+
+    def inherits(*others)
+      others.flatten.each do |other|
+        ancestor = find_ancestor(other.to_sym)
+        @ancestors.delete ancestor
+        @ancestors.unshift ancestor
+      end
+    end
+
+    def find_ancestor(name)
+      callback.modes[name.to_sym]
+    end
+
+    def ancestors(*done, &block)
+      yield self
+
+      @ancestors.each do |ancestor|
+        next if done.include?(ancestor)
+        yield ancestor
+        ancestor.ancestors(done + [self], &block)
+      end
+    end
+
+    def missing(sym)
+      @missing = sym
+    end
+
+    def map(sym, *keychains)
+      keychains.each do |keychain|
+        bind(keychain.flatten, sym)
+      end
+    end
+    alias to map
+
+    def bind(keychain, action_name = nil, &block)
+      keychain = keychain.dup
+      total = hash = {}
+
+      while key = keychain.shift
+        register key
+
+        if keychain.empty?
+          hash[key] = block || action_name
+        else
+          hash = hash[key] = {}
+        end
+      end
+
+      @map.replace @map.merge(total, &MERGER)
+    end
+
+    def register(key)
+      callback.register(key)
+    end
+
+    def enter_keys(*keys)
+      keys.flatten.each{|key| enter_key(key) }
+    end
+
+    def enter_key(key)
+      @stack << key
+
+      ancestors do |ancestor|
+        result = ancestor.attempt_execute(@stack)
+
+        case result
+        when nil # nothing matched yet, but possible in future
+          return nil
+        when false # nothing possible
+          # try next one
+        when true # executed
+          @stack.clear
+          return true
+        else
+          raise "%p is not a valid result" % [result]
+        end
+      end
+
+      # no ancestors or all failed
+      @stack.clear
+      enter_missing(key)
+    rescue => ex
+      puts ex, *ex.backtrace
+      @stack.clear
+    end
+
+    def enter_missing(key)
+      execute(@missing, key) if @missing
+    end
+
+    def attempt_execute(original_stack)
+      if arguments
+        stack, arg = Mode.split_stack(original_stack)
+      else
+        stack, arg = original_stack, nil
+      end
+
+      if stack.empty?
+        arg ? nil : false
+      else
+        executable = stack.inject(@map){|keys, key| keys.fetch(key) }
+
+        execute(executable, *arg)
+      end
+    rescue KeyError
+      false
+    end
+
+    def execute(executable, *arg)
+      case executable
+      when Hash
+        return nil
+      when Symbol
+        callback.send(executable, *arg)
+      when Array
+        callback.send(*executable, *arg)
+      when Proc
+        executable.call(*arg)
+      else
+        return false
+      end
+
+      true
+    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 [], stack.join.to_i
+      end
+    end
+  end
+end

data/lib/ver/options.rb

@@ -0,0 +1,207 @@
+module VER
+  # Provides a minimal DSL to describe options with defaults and metadata.
+  #
+  # The example below should demonstrate the major features, note that key
+  # lookup wanders up the hierarchy until there is a match found or the parent
+  # of the Options class is itself, in which case nil will be returned.
+  #
+  # Usage:
+  #
+  #   class Calculator
+  #     @options = Options.new(:foo)
+  #     def self.options; @options; end
+  #
+  #     options.dsl do
+  #       o "Which method to use", :method, :plus
+  #       o "Default arguments", :args, [1, 2]
+  #       sub(:minus){ o("Default arguments", :args, [4, 3]) }
+  #     end
+  #
+  #     def self.calculate(method = nil, *args)
+  #       method ||= options[:method]
+  #       args = args.empty? ? options[method, :args] : args
+  #       self.send(method, *args)
+  #     end
+  #
+  #     def self.plus(n1, n2)
+  #       n1 + n2
+  #     end
+  #
+  #     def self.minus(n1, n2)
+  #       n1 - n2
+  #     end
+  #   end
+  #
+  #   Calculator.calculate
+  #   # => 3
+  #   Calculator.options[:method] = :minus
+  #   # => :minus
+  #   Calculator.calculate
+  #   # => 1
+  #   Calculator.calculate(:plus, 4, 5)
+  #   # => 9
+  #
+  class Options
+    def initialize(name, parent = self)
+      @name, @parent, = name, parent
+      @hash = {}
+      yield(self) if block_given?
+    end
+
+    # Shortcut for instance_eval
+    def dsl(&block)
+      instance_eval(&block) if block
+      self
+    end
+
+    # Create a new Options instance with +name+ and pass +block+ on to its #dsl.
+    # Assigns the new instance to the +name+ Symbol on current instance.
+    def sub(name, &block)
+      name = name.to_sym
+
+      case found = @hash[name]
+      when Options
+        found.dsl(&block)
+      else
+        found = @hash[name] = Options.new(name, self).dsl(&block)
+      end
+
+      found
+    end
+
+    # Store an option in the Options instance.
+    #
+    # @param [#to_s]   doc   describing the purpose of this option
+    # @param [#to_sym] key   used to access
+    # @param [Object]  value may be anything
+    # @param [Hash]    other optional Hash containing meta-data
+    #                        :doc, :value keys will be ignored
+    def option(doc, key, value, other = {}, &block)
+      trigger = block || other[:trigger]
+      convert = {:doc => doc.to_s, :value => value}
+      convert[:trigger] = trigger if trigger
+      @hash[key.to_sym] = other.merge(convert)
+    end
+    alias o option
+
+    # To avoid lookup on the parent, we can set a default to the internal Hash.
+    # Parameters as in {Options#o}, but without the +key+.
+    def default(doc, value, other = {})
+      @hash.default = other.merge(:doc => doc, :value => value)
+    end
+
+    # Add a block that will be called when a new value is set.
+    def trigger(key, &block)
+      @hash[key.to_sym][:trigger] = block
+    end
+
+    # Try to retrieve the corresponding Hash for the passed keys, will try to
+    # retrieve the key from a parent if no match is found on the current
+    # instance. If multiple keys are passed it will try to find a matching
+    # child and pass the request on to it.
+    def get(key, *keys)
+      if keys.empty?
+        if value = @hash[key.to_sym]
+          value
+        elsif @parent != self
+          @parent.get(key)
+        else
+          nil
+        end
+      elsif sub_options = get(key)
+        sub_options.get(*keys)
+      end
+    end
+
+    # @param [Array] keys
+    # @param [Object] value
+    def set_value(keys, value)
+      got = get(*keys)
+      return got[:value] = value if got
+      raise(IndexError, "There is no option available for %p" % [keys])
+    end
+
+    # Retrieve only the :value from the value hash if found via +keys+.
+    def [](*keys)
+      if value = get(*keys)
+        value.is_a?(Hash) ? value[:value] : value
+      end
+    end
+
+    # Assign new :value to the value hash on the current instance.
+    #
+    # TODO: allow arbitrary assignments
+    def []=(key, value)
+      ks = key.to_sym
+      if @hash.has_key? ks
+        ns = @hash[ks]
+        ns[:value] = value
+        ns[:trigger].call(value) if ns[:trigger].respond_to?(:call)
+      elsif existing = get(key)
+        option(existing[:doc].to_s.dup, key, value)
+      else
+        raise(ArgumentError, "No key for %p exists" % [key])
+      end
+    end
+
+    def method_missing(meth, *args)
+      case meth.to_s
+      when /^(.*)=$/
+        self[$1] = args.first
+      else
+        self[meth]
+      end
+    end
+
+    def merge!(hash)
+      hash.each_pair do |key, value|
+        set_value(key.to_s.split('.'), value)
+      end
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def each_option(&block)
+      @hash.each(&block)
+    end
+
+    def each_pair
+      @hash.each do |key, values|
+        yield(key, self[key])
+      end
+    end
+
+    def inspect
+      @hash.inspect
+    end
+
+    def pretty_print(q)
+      q.pp_hash @hash
+    end
+  end
+
+  # extend your class with this
+  module Optioned
+    def self.included(into)
+      into.extend(SingletonMethods)
+
+      snaked = into.name.split('::').last
+      snaked = snaked.gsub(/\B[A-Z][^A-Z]/, '_\&').downcase.gsub(' ', '_')
+
+      options = VER.options.sub(snaked)
+      into.instance_variable_set(:@options, options)
+    end
+
+    module SingletonMethods
+      attr_reader :options
+    end
+
+    private
+
+    def options
+      self.class.options
+    end
+  end
+end