ver 2010.02 → 2010.08

data/lib/ver/minor_mode.rb

@@ -2,6 +2,7 @@ module VER
   def self.minor_mode(name, &block)
     minor = MinorMode[name]
     minor.instance_eval(&block)
+    minor.handler nil
     minor
   end
 
@@ -20,6 +21,8 @@ module VER
   # part of the tree of minors of this major mode.
   class MinorMode < Struct.new(:name, :parents, :keymap, :receiver,
                                :fallback_action, :enter_action, :leave_action)
+    include Platform
+    include ModeResolving
     include Keymap::Results
 
     MODES = {}
@@ -41,7 +44,14 @@ module VER
     end
 
     def initialize(name)
-      self.name = name.to_sym
+      self.name = name = name.to_sym
+
+      if MODES.key?(name)
+        raise ArgumentError, "Duplicate #{self.class}: %p" % [name]
+      else
+        MODES[name] = self
+      end
+
       self.parents = []
       self.keymap = Keymap.new
       self.receiver = nil
@@ -49,74 +59,44 @@ module VER
       MODES[self.name] = self
     end
 
-    # recursively try to find the sequence in the minor mode and its parents.
-    def resolve(sequence)
-      case found = keymap[sequence]
-      when Incomplete
-        parents.each do |parent|
-          next if parent == self
-          case resolved = parent.resolve(sequence)
-          when Incomplete
-            found.merge!(resolved)
-          end
-        end
-      when Impossible
-        parents.find do |parent|
-          next if parent == self
-          found = parent.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
+    # recursively try to find the pattern in the minor mode and its parents.
+    def resolve(pattern)
+      super(pattern, parents)
     end
 
     # Add a parent for this minor mode.
     def inherits(*names)
       names.each do |name|
         minor = self.class[name]
-        self.parents << minor unless minor == self
+        next if minor == self
+        parents << minor
       end
-      self.parents.uniq!
-    end
-
-    def become(other, *sequences)
-      action = Action.new(receiver, :minor_mode, [self, other])
 
-      sequences.each do |sequence|
-        keymap[sequence] = action
-      end
+      parents.uniq!
     end
 
-    def map(invocation, *sequences, &block)
-      action = Action.new(receiver, *invocation, &block)
+    def become(other, *patterns)
+      action = Action.new([:minor_mode, self, other], receiver, self)
+      patterns.each{|pattern| keymap[pattern] = action }
+    end
 
-      sequences.each do |sequence|
-        keymap[sequence] = action
-      end
+    def map(invocation, *patterns)
+      action = Action.new(invocation, receiver, self)
+      patterns.each{|pattern| keymap[pattern] = action }
     end
 
     def missing(invocation, &block)
-      action = Action.new(receiver, *invocation, &block)
+      action = Fallback.new(invocation, receiver, self)
       self.fallback_action = action
-      (KEYSYMS.values - keymap.keys.to_a).each do |name|
-        keymap[name] = action
-      end
     end
 
     def enter(invocation, &block)
-      action = Action.new(receiver, *invocation, &block)
+      action = Action.new(invocation, receiver, self)
       self.enter_action = action
     end
 
     def leave(invocation, &block)
-      action = Action.new(receiver, *invocation, &block)
+      action = Action.new(invocation, receiver, self)
       self.leave_action = action
     end
 
@@ -200,5 +180,14 @@ module VER
     def inspect
       "#<VER::MinorMode name=%p>" % [name]
     end
+
+    def hash
+      name.hash
+    end
+
+    # we assume that name is unique
+    def eql?(other)
+      other.class == self.class && other.name == self.name
+    end
   end
 end

data/lib/ver/mode_resolving.rb

@@ -0,0 +1,71 @@
+module VER
+  module ModeResolving
+    include Keymap::Results
+
+    # recursively try to find the pattern in the major mode and its parent
+    # modes.
+    def resolve(pattern, parents)
+      keymap_result = keymap[pattern]
+
+      case keymap_result
+      when Incomplete # try to find a full or longer match in parents
+        resolve_incomplete(pattern, parents, keymap_result)
+      when Impossible # anything better than that.
+        resolve_impossible(pattern, parents, keymap_result)
+      else
+        # full match from us, so get the action out.
+        return keymap_result
+      end
+    end
+
+    def resolve_incomplete(pattern, parents, result)
+      parents.each do |parent|
+        next if parent == self
+
+        parent_result = parent.resolve(pattern)
+
+        case parent_result
+        when Incomplete # merge and see if there's something better
+          result.merge!(parent_result)
+        when Impossible # even worse than us, skip
+        when Fallback # no match, we are incomplete already
+        else # full match, yay!
+          return parent_result
+        end
+      end
+
+      return result
+    end
+
+    def resolve_impossible(pattern, parents, result)
+      incomplete = nil
+      fallback = nil
+
+      parents.each do |parent|
+        next if parent == self
+
+        parent_result = parent.resolve(pattern)
+
+        case parent_result
+        when Incomplete # better than us, keep it for later
+          if incomplete
+            incomplete.merge!(parent_result)
+          else
+            incomplete = parent_result
+          end
+        when Impossible # just as bad, ignore
+        when Fallback # better than us, keep for later
+          fallback ||= parent_result
+        else
+          # full match, whaoh!
+          return parent_result
+        end
+      end
+
+      return incomplete if incomplete
+      return fallback_action if fallback_action
+      return fallback if fallback
+      return result
+    end
+  end
+end

data/lib/ver/platform.rb

@@ -0,0 +1,41 @@
+module VER
+  module Platform
+    module_function
+
+    def x11?
+      windowingsystem == :x11
+    end
+
+    def win32?
+      windowingsystem == :win32
+    end
+
+    def aqua?
+      windowingsystem == :aqua
+    end
+
+    def windowingsystem
+      @windowingsystem ||= Tk::TkCmd.windowingsystem
+    end
+
+    def bsd?
+      FFI::Platform.bsd?
+    end
+
+    def windows?
+      FFI::Platform.windows?
+    end
+
+    def mac?
+      FFI::Platform.mac?
+    end
+
+    def unix?
+      FFI::Platform.unix?
+    end
+
+    def operatingsystem
+      FFI::Platform::OS
+    end
+  end
+end

data/lib/ver/plist.rb

@@ -258,16 +258,28 @@ module VER
           value.gsub!(pattern, replacement)
         end
 
-        Regexp.new(value)
+        value2 = ''
+        group_index = 0
+        value.scan(/((?:[^\\(]+|\\[^\d])+)|(\\\d+)|(\(\??)/m) do |content, backref, capture|
+          if capture == '('
+            value2 << "(?<_#{group_index += 1}>"
+          elsif backref
+            value2 << "\\k<_#{backref[/\d+/]}>"
+          else
+            value2 << (content || capture)
+          end
+        end
+
+        Regexp.new(value2)
       rescue RegexpError => ex
         if ex.message =~ /^invalid multibyte escape:/
           begin
-            /#{value.force_encoding(Encoding::BINARY)}/n
+            /#{value2.force_encoding(Encoding::BINARY)}/n
           rescue RegexpError => ex
-            error(ex, original, value)
+            error(ex, original, value2)
           end
         else
-          error(ex, original, value)
+          error(ex, original, value2)
         end
       end
 

data/lib/ver/register.rb

@@ -0,0 +1,86 @@
+module VER
+  class Register < Struct.new(:name, :value)
+    REGISTERS = {}
+
+    def self.[](name)
+      name = name.to_str
+      REGISTERS[name] ||= new(name)
+    end
+
+    # Assign given value to register of given name
+    def self.[]=(name, value)
+      self[name].value = value
+    end
+
+    def self.each(&block)
+      REGISTERS.values.each(&block)
+    end
+
+    def self.fetch(name)
+      REGISTERS.fetch(name.to_str)
+    end
+
+    def inspect
+      "#<VER::Register name=%p, value=%p>" % [name, value]
+    end
+
+    # Special register for clipboard, found in Register['*']
+    class Clipboard < Register
+      def value=(object)
+        VER::Clipboard.dwim = object
+      end
+
+      def value
+        VER::Clipboard.dwim
+      end
+
+      def inspect
+        "#<VER::Register::Clipboard name=%p, value=%p>" % [name, value]
+      end
+    end
+
+    REGISTERS['*'] = Clipboard.new('*')
+  end
+
+  class RegisterList < Tk::Tile::Frame
+    def self.open(buffer)
+      new(buffer)
+    end
+
+    def self.show(buffer)
+      buffer.ask ':register ' do |answer, action|
+        case action
+        when :modified
+          begin
+            buffer.warn ""
+            register = Register.fetch(answer)
+            buffer.message '"%s: %p' % [register.name, register.value]
+            :abort
+          rescue KeyError => ex
+            buffer.warn "#{ex}: #{answer}"
+          end
+        end
+      end
+    end
+
+    def initialize(*args)
+      super
+      pack fill: :x
+
+      bind '<FocusOut>' do
+        destroy
+      end
+
+      Register.each do |register|
+        frame = Tk::Tile::Frame.new(self)
+        label = Tk::Label.new(frame, text: register.name)
+        entry = Tk::Tile::Entry.new(frame)
+        entry.insert(0, register.value)
+
+        frame.pack side: :top, fill: :x
+        label.pack side: :left
+        entry.pack side: :right, fill: :x, expand: true
+      end
+    end
+  end
+end

data/lib/ver/status.rb

@@ -27,6 +27,16 @@ module VER
           Encoding.new(status),
         ]
       },
+      emacs: lambda{|status|
+        [
+          ShortFilename.new(status, weight: 1),
+          Position.new(status),
+          Percent.new(status),
+          Mode.new(status),
+          Syntax.new(status),
+          Encoding.new(status),
+        ]
+      },
       nano: lambda{|status|
         [
           NanoPosition.new(status, row: 0, column: 0, weight: 1, anchor: :center),
@@ -48,10 +58,29 @@ module VER
       }
     }
 
+    module LabelToggle
+      def toggle
+        info = grid_info
+
+        if info.empty?
+          grid_configure(@last_grid_info)
+          status.show
+          true
+        else
+          @last_grid_info = info
+          grid_forget
+          unless status.winfo_children.any?{|child| Tk::Winfo.ismapped(child) }
+            status.hide
+          end
+          false
+        end
+      end
+    end
+
     attr_accessor :buffer, :widgets, :notify
 
-    def initialize(buffer, options = {})
-      super
+    def initialize(parent, buffer, options = {})
+      super(parent, options)
       self.buffer = buffer
       self.notify = Hash.new{|hash, key| hash[key] = Set.new }
 
@@ -82,12 +111,21 @@ module VER
       events.each{|event| notify[event] << widget }
     end
 
-    def text
-      buffer.text
-    end
-
     def style=(config)
       Tk::After.idle{ @widgets.each{|widget| widget.style = config } }
     end
+
+    def show
+      return if winfo_ismapped
+      grid_configure(@last_grid_info)
+      true
+    end
+
+    def hide
+      return unless winfo_ismapped
+      @last_grid_info = grid_info
+      grid_forget
+      true
+    end
   end
 end

data/lib/ver/status/battery.rb

@@ -79,7 +79,7 @@ module VER
           @battery_value = battery_build(format)
         end
       rescue => ex
-        puts ex, *ex.backtrace
+        VER.error(ex)
         ex.message
       end