ver 2009.12.14 → 2010.02

data/lib/ver/minor_mode.rb

@@ -0,0 +1,204 @@
+module VER
+  def self.minor_mode(name, &block)
+    minor = MinorMode[name]
+    minor.instance_eval(&block)
+    minor
+  end
+
+  # A minor mode contains modifications for major modes.
+  # It supports unidirectional inheritance to form a tree-like structure together
+  # with other instance of MinorMode.
+  # Every minor mode maintains its own keymap and performs lookup within that.
+  # When no match can be found, the parents will be asked until a definite
+  # result is returned.
+  #
+  # A MinorMode is expected to interact with the WidgetMajorMode only, not with
+  # MajorMode directly.
+  #
+  # Modification of a MinorMode will not be fully reflected until the
+  # [WidgetMajorMode#synchronize] method has been called and the minor mode is
+  # 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 Keymap::Results
+
+    MODES = {}
+
+    # Find or create the minor mode for the given name.
+    def self.[](name)
+      name = name.to_sym
+
+      if MODES.key?(name)
+        MODES[name]
+      else
+        new(name)
+      end
+    end
+
+    # Delete all minor modes.
+    def self.clear
+      MODES.clear
+    end
+
+    def initialize(name)
+      self.name = name.to_sym
+      self.parents = []
+      self.keymap = Keymap.new
+      self.receiver = nil
+
+      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
+    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
+      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
+    end
+
+    def map(invocation, *sequences, &block)
+      action = Action.new(receiver, *invocation, &block)
+
+      sequences.each do |sequence|
+        keymap[sequence] = action
+      end
+    end
+
+    def missing(invocation, &block)
+      action = Action.new(receiver, *invocation, &block)
+      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)
+      self.enter_action = action
+    end
+
+    def leave(invocation, &block)
+      action = Action.new(receiver, *invocation, &block)
+      self.leave_action = action
+    end
+
+    def handler(object)
+      self.receiver = object
+    end
+
+    def replace_parent(widget_major, old, new)
+      parents.dup.each do |parent|
+        if parent == old
+          new.replaces widget_major, old do
+            parents[parents.index(old)] = new
+          end
+        else
+          parent.replace_parent(widget_major, old, new)
+        end
+      end
+    end
+
+    def replaces(widget_major, other)
+      other.replaced_by(widget_major, self) if other
+      yield if block_given?
+      self.replacing(widget_major, other)
+    end
+
+    def replaced_by(widget_major, other)
+      return unless widget_major.respond_to?(:widget)
+      widget = widget_major.widget
+      leave_action.call(widget, self, other) if leave_action
+      Tk::Event.generate(widget, "<<LeaveMode>>", data: name)
+      Tk::Event.generate(widget, "<<LeaveMinorMode>>", data: name)
+      Tk::Event.generate(widget, "<<LeaveMinorMode#{to_camel_case}>>", data: name)
+    end
+
+    def replacing(widget_major, other)
+      return unless widget_major.respond_to?(:widget)
+      widget = widget_major.widget
+      enter_action.call(widget, other, self) if enter_action
+      Tk::Event.generate(widget, "<<EnterMinorMode#{to_camel_case}>>", data: name)
+      Tk::Event.generate(widget, "<<EnterMinorMode>>", data: name)
+      Tk::Event.generate(widget, "<<EnterMode>>", data: name)
+    end
+
+    def synchronize_recursively(widget_major)
+      unfold.each do |minor|
+        minor.synchronize(widget_major)
+      end
+    end
+
+    def synchronize(widget_major)
+      keymap.keys.each do |key|
+        widget_major.bind_key(key)
+      end
+    end
+
+    def unfold(all = [self])
+      pending = self.parents.dup
+
+      while current = pending.shift
+        unless all.include?(current)
+          all << current
+          pending.concat(current.unfold(all)).flatten!
+        end
+      end
+
+      all
+    end
+
+    def to_camel_case
+      name.to_s.split('_').map{|e| e.capitalize}.join
+    end
+
+    def actions
+      unfold.map{|minor| minor.keymap.actions }
+    end
+
+    def to_sym
+      name
+    end
+
+    def inspect
+      "#<VER::MinorMode name=%p>" % [name]
+    end
+  end
+end

data/lib/ver/plist.rb

@@ -1,4 +1,30 @@
+# ver: sw=2
+
 require 'nokogiri'
+require 'pp'
+require_relative 'vendor/better_pp_hash'
+
+# Define some magic constants that aren't available but may be returned from
+# Regexp#options so we can make sure that roundtrip via PP works.
+#
+# 1.9.2 actually defines Regexp::FIXEDENCODING, but there's no release yet, so
+# we simply assume the values from the Ruby C source (which means this might not
+# work on any other implementation).
+# Hopefully nobody tries to convert textmate bundles unless they are on MRI 1.9.1 ;)
+class Regexp
+  NO_ENCODING = //n.options
+
+  alias original_inspect inspect
+
+  # Take into account //n option
+  def inspect
+    if options & NO_ENCODING == 0
+      original_inspect
+    else
+      original_inspect << 'n'
+    end
+  end
+end
 
 module VER
   module Plist
@@ -7,6 +33,7 @@ module VER
         @doc = Nokogiri(xml)
         @plist = {}
         @parsed = nil
+        @exceptions = []
       end
 
       def parse
@@ -21,11 +48,13 @@ module VER
         else
           raise ArgumentError, 'This is no XML plist'
         end
+
+        fail "#{@exceptions.size} errors encountered" if @exceptions.any?
+        @parsed
       end
 
       def handle_array(array)
         out = []
-        key = nil
 
         array.children.each do |child|
           child_name = child.name
@@ -35,15 +64,20 @@ module VER
             case child_name
             when 'key'
               raise 'No key allows in array'
-            when 'array';           handle_array(child)
-            when 'dict';            handle_dict(child)
-            when 'false';           false
-            when 'integer', 'real'; child.inner_text.to_i
-            when 'string';          child.inner_text
-            when 'true';            true
+            when 'array'
+              handle_array(child)
+            when 'dict'
+              handle_dict(child)
+            when 'false'
+              false
+            when 'integer', 'real'
+              child.inner_text.to_i
+            when 'string'
+              child.inner_text
+            when 'true'
+              true
             else
-              # $unhandled[child_name] << child
-              raise "%p: %p is not handled" % [child_name, child]
+              raise "unhandled %p: %p" % [child_name, child]
             end
           )
         end
@@ -59,22 +93,41 @@ module VER
           child_name = child.name
 
           case child_name
-          when 'key'; key = child.inner_text
-          when 'text' # ignore
+          when 'key'
+            case key = child.inner_text
+            when /^\d+$/
+              key = key.to_i
+            else
+              key = key.to_sym
+            end
+          when 'text'
+            # ignore
           else
             raise 'No key given' unless key
 
             out[key] =
               case child_name
-              when 'array';           handle_array(child)
-              when 'dict';            handle_dict(child)
-              when 'false';           false
-              when 'integer', 'real'; child.inner_text.to_i
-              when 'string';          child.inner_text
-              when 'true';            true
+              when 'array'
+                handle_array(child)
+              when 'dict'
+                handle_dict(child)
+              when 'integer', 'real'
+                child.inner_text.to_i
+              when 'true'
+                true
+              when 'false'
+                false
+              when 'string'
+                value = child.inner_text
+
+                case key
+                when :begin, :match, :foldingStartMarker, :foldingStopMarker
+                  sanitize_regexp(value)
+                else
+                  value
+                end
               else
-                # $unhandled[child_name] << child
-                raise "%p: %p is not handled" % [child_name, child]
+                raise "unhandled %p: %p" % [child_name, child]
               end
 
             key = nil
@@ -95,6 +148,141 @@ module VER
       def to_hash
         parse
       end
+
+      private
+
+      SANITIZE_REGEXP = {}
+      r = lambda{|string, replacement|
+        pattern =
+          if string.is_a? Regexp
+            string
+          else
+            Regexp.new(Regexp.escape(string))
+          end
+        replacement.force_encoding Encoding::BINARY
+        SANITIZE_REGEXP[pattern] = replacement
+      }
+
+      # found in newLisp.tmbundle
+      r['(?<!(?:\{|\"|]))(?:[\s\n]*)?(;+.*?)$', '(?<!(?:\{|"|\]))(?:\s*)(;+.*)$']
+
+      # found in Movable Type.tmbundle
+      r['(<)(\$[mM][tT]:?(?:\w+)?:?\w+)(.*?)(\$)?(>)', '(<)(\$[mM][tT]:?(?:\w*):?\w+)(.*?)(\$)?(>)']
+      r['(</?)([mM][tT]:?(?:\w+)?:?\w+)(.*?)>', '(</?)([mM][tT]:?(?:\w*):?\w+)(.*?)>']
+      r['\b([a-zA-Z-_:]+)', '\b([a-zA-Z_:-]+)']
+
+      # found in OCaml.tmbundle
+      r['(?=(\[<)(?![^\[]+?[^>]]))(.*?)(>])', '(?=(\[<)(?![^\[]+?[^>\]]))(.*?)(>\])']
+      r['(\')(.*?)(;)(?=\s*\')|(?=\s*>])', '(\')(.*?)(;)(?=\s*\')|(?=\s*>\])']
+      r['(\[)(?!\||<|>)(.*?)(?<!\||>)(])', '(\[)(?!\||<|>)(.*?)(?<!\||>)(\])']
+      r['(\[)(\^?)(.*?)(])(?!\\\')', '(\[)(\^?)(.*?)(\])(?!\\\')']
+      r['(\[<)(?=.*?>])(.*?)(?=>])', '(\[<)(?=.*?>\])(.*?)(?=>\])']
+      r['(\[\|)(.*?)(\|])', '(\[\|)(.*?)(\|\])']
+      r['\[<|>]', '\[<|>\]']
+
+      # found in Txt2tags.tmbundle
+      r['|[^]]+', '|[^\]]+']
+
+      # found in Perl Template Toolkit.tmbundle
+      r['\b([a-zA-Z-_:]+)\s*(=)', '\b([a-zA-Z_:-]+)\s*(=)']
+
+      # found in Property List.tmbundle
+      r['<!\[CDATA\[(.*?)]]>', '<!\[CDATA\[(.*?)\]\]>']
+      r['(<!\[CDATA\[)(.*?)(]]>)', '(<!\[CDATA\[)(.*?)(\]\]>)']
+
+      # found in SWeave.tmbundle and a few others
+      # warning: nested repeat operator ? and * was replaced with '*'
+      r[/\.\?\*/, '.*']
+
+      # Found in Textile.tmbundle
+      r[/\\\[\[\^\]\]/, '\[[^\]]']
+
+      # found in Twiki.tmbundle
+      r['(\[)([^]]*)(\]) *(\[)(.*?)(\])', '(\[)([^\]]*)(\]) *(\[)(.*?)(\])']
+
+      # found in XML.tmbundle
+      r['<!\[CDATA\[(.*?)]]>', '<!\[CDATA\[(.*?)\]\]>']
+
+      # '\b\u\w+\u\w+' => '\b\\u\w+\\u\w+'
+      r[/\\(u)/i, '\\\\\1']
+
+      # found in MEL.tmbundle/Syntaxes/MEL.plist
+      r['(\$)[a-zA-Z_\x{7f}-\x{ff}][a-zA-Z0-9_\x{7f}-\x{ff}]*?\b', '(\$)\w\w*?\b']
+
+      # "[\x{7f}-\x{ff}]" => "[\x7f-\xff]"
+      r[/\\x\{(\h+)\}/, '\\\\x\1']
+
+      # remove lots of tabs at line start
+      r[/^\t+/, "\t"]
+
+      # Escape #@ #$ #{ because they have special meaning in ruby literal regexps
+      r[/([^\\]|$)#([$@{])/, '\1\#\2']
+
+      # '(?=#)' => '(?=\#)'
+      r['(?=#)', '(?=\#)']
+
+      # found in Nemerle
+      r['(\{|(|<\[)', '(\{|\(|<\[)']
+      r['(\}|)|]>)',  '(\}|\)|\]>)']
+
+      # found in HTML (Active4D)
+      r['\b([a-zA-Z-:]+)','\b([a-zA-Z:-]+)']
+      r['\[CDATA\[(.*?)]](?=>)', '\[CDATA\[(.*?)\]\](?=>)']
+
+      # found in Bulletin Board.tmbundle
+      r['[\[]]+', '[\[\]]+']
+
+      # found in C.tmbundle
+      r['\bdelete\b(\s*\[\])?|\bnew\b(?!])', '\bdelete\b(\s*\[\])?|\bnew\b(?!\])']
+
+      # found in reStructuredText.tmbundle
+      r['(\.\.)\s[A-z][A-z0-9-_]+(::)\s*$', '(\.\.)\s[A-z][A-z0-9_-]+(::)\s*$']
+      r['^(\.\.)\s+((\[)(((#?)[^]]*?)|\*)(\]))\s+(.*)', '^(\.\.)\s+((\[)(((#?)[^\]]*?)|\*)(\]))\s+(.*)']
+
+      # Fix invalid regular expressions so we can write them out as Ruby code.
+      #
+      # NOTE:
+      #   Yeah, it's weird to fix regular expressions with regular expressions.
+      #   But it seems like the people writing syntax files slept all through
+      #   regexp class and textmate must be working _very_ hard to allow all
+      #   this without giving any warnings (maybe error messages are just not
+      #   hip in osx).
+      #   Also, there seems to be a lot of copy&pasting between syntax files, as
+      #   soon as someone comes up with a horrible way to match things,
+      #   everybody else is eager to use it in their files as well.
+      #   </rant>
+      def sanitize_regexp(value)
+        original = value.dup
+
+        SANITIZE_REGEXP.each do |pattern, replacement|
+          value.gsub!(pattern, replacement)
+        end
+
+        Regexp.new(value)
+      rescue RegexpError => ex
+        if ex.message =~ /^invalid multibyte escape:/
+          begin
+            /#{value.force_encoding(Encoding::BINARY)}/n
+          rescue RegexpError => ex
+            error(ex, original, value)
+          end
+        else
+          error(ex, original, value)
+        end
+      end
+
+      def error(exception, original, modified)
+        puts ' [ exception ] '.center(80, '-')
+        puts exception, *exception.backtrace
+        puts ' [ original regexp ] '.center(80, '-')
+        p original
+        puts original
+        puts ' [ modified regexp ] '.center(80, '-')
+        p modified
+        puts modified
+        puts '-' * 80
+        @exceptions << exception
+      end
     end
 
     module_function
@@ -103,4 +291,4 @@ module VER
       XML.new(File.read(filename)).parse
     end
   end
-end
+end