ver 2009.12.14 → 2010.02

data/lib/ver/vendor/pathname.rb

@@ -0,0 +1,26 @@
+require 'pathname'
+
+# annoying fixes
+class Pathname
+  alias / join
+
+  def cp(dest)
+    FileUtils.copy_file(expand_path.to_s, dest.to_s, preserve = true)
+  end
+
+  def =~(regexp)
+    to_s =~ regexp
+  end
+
+  def glob(&block)
+    if block
+      Dir.glob(to_s){|match| yield(self.class.new(match)) }
+    else
+      Dir.glob(to_s)
+    end
+  end
+
+  def shellescape
+    to_s.shellescape
+  end
+end

data/lib/ver/vendor/textpow.rb

@@ -77,9 +77,9 @@ module Textpow
 
     def proxy
       case @proxy
-      when /^#(?<proxy>.+)/
+      when /^#(.+)/
         return unless @syntax.repository
-        @syntax.repository[$~[:proxy]]
+        @syntax.repository[$1.to_sym]
       when "$self", "$base"
         @syntax
       else
@@ -89,15 +89,8 @@ module Textpow
   end
 
   class SyntaxNode
-    OPTIONS = {} #:options => Oniguruma::OPTION_CAPTURE_GROUP}
-
     @@syntaxes = {}
 
-    attr_accessor :processor, :syntax, :firstLineMatch, :foldingStartMarker,
-      :foldingStopMarker, :match, :begin, :content, :fileTypes, :name,
-      :contentName, :end, :scopeName, :keyEquivalent, :captures,
-      :beginCaptures, :endCaptures, :repository, :patterns
-
     def self.load(filename, name_space = :default)
       filename = filename.to_s
 
@@ -109,6 +102,8 @@ module Textpow
           JSON.load(File.read(filename))
         when /\.ya?ml$/i
           YAML.load_file(filename)
+        when /\.rb$/i
+          eval(File.read(filename))
         else
           raise ArgumentError, "Unknown filename extension"
         end
@@ -116,28 +111,31 @@ module Textpow
       SyntaxNode.new(table, nil, name_space) if table
     end
 
+    LITERAL_KEYS = [:firstLineMatch, :foldingStartMarker, :foldingStopMarker,
+                    :match, :begin, :content, :fileTypes, :name, :contentName,
+                    :end, :scopeName, :keyEquivalent]
+
+    attr_accessor :processor, :syntax, :firstLineMatch, :foldingStartMarker,
+      :foldingStopMarker, :match, :begin, :content, :fileTypes, :name,
+      :contentName, :end, :scopeName, :keyEquivalent, :captures,
+      :beginCaptures, :endCaptures, :repository, :patterns
+
     def initialize(hash, syntax = nil, name_space = :default)
       @name_space = name_space
 
-      prepare_scope_name(hash['scopeName'])
+      prepare_scope_name(hash[:scopeName])
 
       @syntax = syntax || self
 
       hash.each do |key, value|
         case key
-        when "firstLineMatch", "foldingStartMarker", "foldingStopMarker", "match", "begin"
-          begin
-            send("#{key}=", Regexp.new(value))
-          rescue ArgumentError, RegexpError => exception
-            warn "Parsing error in %p => %p: %s" % [key, value, exception]
-          end
-        when "content", "fileTypes", "name", "contentName", "end", "scopeName", "keyEquivalent"
+        when *LITERAL_KEYS
           send("#{key}=", value)
-        when "captures", "beginCaptures", "endCaptures"
+        when :captures, :beginCaptures, :endCaptures
           send("#{key}=", value.sort)
-        when "repository"
+        when :repository
           parse_repository value
-        when "patterns"
+        when :patterns
           create_children value
         else
           $stderr.puts "Ignoring: #{key} => #{value.to_s.gsub("\n", "\n>>")}" if $DEBUG
@@ -173,7 +171,7 @@ module Textpow
       @repository = {}
 
       repository.each do |key, value|
-        if include = value["include"]
+        if include = value[:include]
           @repository[key] = SyntaxProxy.new(include, self.syntax)
         else
           @repository[key] = SyntaxNode.new(value, self.syntax, @name_space)
@@ -186,7 +184,7 @@ module Textpow
       syntax = self.syntax
 
       patterns.each do |pattern|
-        if include = pattern["include"]
+        if include = pattern[:include]
           @patterns << SyntaxProxy.new(include, syntax)
         else
           @patterns << SyntaxNode.new(pattern, syntax, @name_space)
@@ -234,13 +232,13 @@ module Textpow
 
       if captures = send(name)
         captures.each do |key, value|
-          if key =~ /^\d*$/
-            key = key.to_i
-            matches << [key, match.offset(key), value["name"]] if key < match.size
-          else
+          if Symbol === key
             key = key.to_sym
             match_to_key = match.to_index(key)
-            matches << [match_to_key, match.offset(key), value["name"]] if match_to_key
+            matches << [match_to_key, match.offset(key), value[:name]] if match_to_key
+          else
+            key = key.to_i
+            matches << [key, match.offset(key), value[:name]] if key < match.size
           end
         end
       end
@@ -319,8 +317,8 @@ module Textpow
           top_contentName = top.contentName
           processor.close_tag top_contentName, start_pos if top_contentName
 
-          parse_captures "captures", top, pattern_match, processor
-          parse_captures "endCaptures", top, pattern_match, processor
+          parse_captures :captures, top, pattern_match, processor
+          parse_captures :endCaptures, top, pattern_match, processor
 
           top_name = top.name
           processor.close_tag top_name, end_pos if top_name
@@ -336,8 +334,8 @@ module Textpow
 
           if pattern.begin
             processor.open_tag pattern_name, start_pos if pattern_name
-            parse_captures "captures", pattern, pattern_match, processor
-            parse_captures "beginCaptures", pattern, pattern_match, processor
+            parse_captures :captures, pattern, pattern_match, processor
+            parse_captures :beginCaptures, pattern, pattern_match, processor
 
             pattern_contentName = pattern.contentName
             processor.open_tag pattern_contentName, end_pos if pattern_contentName
@@ -347,7 +345,7 @@ module Textpow
             stack << [top, match]
           elsif pattern.match
             processor.open_tag pattern_name, start_pos if pattern_name
-            parse_captures "captures", pattern, pattern_match, processor
+            parse_captures :captures, pattern, pattern_match, processor
             processor.close_tag pattern_name, end_pos if pattern_name
           end
         end

data/lib/ver/version.rb

@@ -1,3 +1,3 @@
 module VER
-  VERSION = "2009.12.14"
+  VERSION = "2010.02"
 end

data/lib/ver/widget_event.rb

@@ -0,0 +1,49 @@
+module VER
+  # This class acts as a proxy for the widget.
+  # it forwards all methods, except for [event], which points to the event
+  # currently invoked.
+  #
+  # This is done to allow methods operating on the widget to obtain information
+  # about the event, so they can act intelligently.
+  #
+  # The usage of [method_missing] might make it a bit slower right after
+  # startup, but should be next to no difference to a direct reference of widget
+  # as we dynamically define the methods handled.
+  #
+  # Due to the dynamic nature of ruby, what widget is underneath will not make
+  # any difference, and WidgetEvent will be more or less invisible outside of
+  # backtraces.
+  class WidgetEvent < BasicObject
+    attr_reader :widget, :event
+
+    def initialize(widget, event)
+      @widget, @event = widget, event
+    end
+
+    def respond_to?(method)
+      method.to_sym == :event || @widget.respond_to?(method)
+    end
+
+    def method_missing(method, *args, &block)
+      # ::Kernel.p([@widget, @event] => [method, args])
+      result = @widget.send(method, *args, &block)
+
+      if method =~ /=/
+        ::VER::WidgetEvent.class_eval(<<-RUBY, __FILE__, __LINE__)
+          def #{method}(arg)
+            @widget.#{method} arg
+          end
+        RUBY
+      else
+        ::VER::WidgetEvent.class_eval(<<-RUBY, __FILE__, __LINE__)
+          def #{method}(*args, &block)
+            @widget.#{method}(*args, &block)
+          end
+        RUBY
+      end
+
+      result
+    end
+    alias send method_missing
+  end
+end

data/lib/ver/widget_major_mode.rb

@@ -0,0 +1,192 @@
+module VER
+  # The WidgetMajorMode associates a widget with a major mode.
+  # It keeps a limited history of the events that arrive at [on_event].
+  # It also maintains a stack of the event sequences and tries to match
+  # against the keymaps of the major and minor modes.
+  #
+  # This class has its own list of minor modes, which can be modified and may
+  # differ from the minor modes of the original major mode.
+  #
+  # It is responsible to keep the keymaps of major and minor modes functioning
+  # by ensuring that they are actually bound to the tag of the major mode.
+  class WidgetMajorMode < Struct.new(:widget, :major, :minors, :stack,
+                                     :event_history, :action_history, :reader,
+                                     :read_amount)
+    include Keymap::Results
+
+    def initialize(widget, major)
+      self.widget = widget
+      self.major = MajorMode[major]
+      self.event_history = SizedArray.new(100)
+      self.action_history = SizedArray.new(100)
+      self.stack = []
+      self.minors = []
+
+      establish_tag
+      use(*self.major.minors)
+      listen
+    end
+
+    def listen
+      VER.root.bind('<<PluginLoaded>>'){|event| synchronize }
+    end
+
+    def bound_keys
+      major.bound_keys
+    end
+
+    # Shortcut to bind a sequence on the associated widget.
+    def bind(sequence, &block)
+      widget.bind(sequence, &block)
+    end
+
+    def bind_key(key)
+      major.bind_key(key)
+    end
+
+    def use(*minors)
+      minors.each do |name|
+        minor = MinorMode[name]
+        self.minors << minor
+      end
+
+      self.minors.uniq!
+      synchronize
+    end
+
+    def forget(*minors)
+      self.minors -= minors.map{|name| MinorMode[name] }
+    end
+
+    def on_event(event)
+      stack << event.sequence
+      event_history << {
+        sequence: event.sequence,
+        keysym: event.keysym,
+        unicode: event.unicode
+      }
+
+      return handle_reader(event) if reader && read_amount
+
+      case result = resolve(stack)
+      when Incomplete
+        VER.message result.to_s
+        # don't do anything yet...
+      when Impossible
+        VER.message result.to_s
+        stack.clear
+      else
+        stack.clear
+        mode, action = result
+        widget_event = WidgetEvent.new(widget, event)
+        action.call(widget_event)
+        action_history << [widget_event, *result]
+      end
+    end
+
+    # ignore event for now, it might be needed later
+    def handle_reader(event)
+      if stack.size >= read_amount
+        stack.clear
+        handled = true
+        reader.call(*event_history.last(read_amount))
+      else
+        handled = false
+      end
+    ensure
+      self.read_amount = self.reader = nil if handled
+    end
+
+    def read(amount, &reader)
+      amount = amount.to_int
+      raise ArgumentError, "amount must be greater than 0" unless amount > 0
+      self.read_amount = amount
+      self.reader = reader
+    end
+
+    def resolve(sequence)
+      major.resolve(sequence, minors)
+    end
+
+    def replaces(other)
+      other.replaced_by(self) if other
+      yield if block_given?
+      self.replacing(other)
+    end
+
+    def replaced_by(other)
+      Tk::Event.generate(widget, "<<LeaveMode>>", data: name)
+      Tk::Event.generate(widget, "<<LeaveMajorMode>>", data: name)
+      Tk::Event.generate(widget, "<<LeaveMajorMode#{to_camel_case}>>", data: name)
+    end
+
+    def replacing(other)
+      Tk::Event.generate(widget, "<<EnterMajorMode#{to_camel_case}>>", data: name)
+      Tk::Event.generate(widget, "<<EnterMajorMode>>", data: name)
+      Tk::Event.generate(widget, "<<EnterMode>>", data: name)
+    end
+
+    def replace_minor(old, new)
+      old, new = MinorMode[old], MinorMode[new]
+
+      minors.dup.each do |minor|
+        if minor == old
+          new.replaces self, old do
+            minors[minors.index(old)] = new
+          end
+        else
+          minor.replace_parent(self, old, new)
+        end
+      end
+
+      synchronize
+    end
+
+    def synchronize
+      major.keymap.keys.each do |key|
+        major.bind_key(key)
+      end
+
+      minors.each do |minor|
+        minor.synchronize_recursively(self)
+      end
+    end
+
+    def actions
+      major.actions + minors.map{|minor| minor.actions }.flatten
+    end
+
+    def name
+      major.name
+    end
+
+    def tag
+      major.tag
+    end
+
+    def to_tcl
+      widget.tk_pathname
+    end
+
+    def to_camel_case
+      major.name.to_s.split('_').map{|e| e.capitalize}.join
+    end
+
+    def inspect
+      out = ['#<Ver::WidgetMajorMode']
+      { major: major.name,
+        minors: minors.map{|m| m.to_sym },
+        event_history: event_history.map{|h| h[:keysym] },
+        stack: stack,
+      }.each{|k,v| out << "#{k}=#{v.inspect}" }
+      out.join(' ') << '>'
+    end
+
+    def establish_tag
+      tags = widget.bindtags
+      specific = tags[0, 1]
+      general = tags[-3..-1]
+      widget.bindtags(*specific, major.tag, *general)
+    end
+  end
+end

data/spec/helper.rb

@@ -1,94 +1,65 @@
 require 'bacon'
-Bacon.summary_at_exit
-
-require 'pathname'
-
-# annoying fixes
-class Pathname
-  alias / join
-
-  def cp(dest)
-    FileUtils.copy_file(expand_path.to_s, dest.to_s, preserve = true)
-  end
-
-  def =~(regexp)
-    to_s =~ regexp
-  end
-end
+# Bacon.summary_at_exit
 
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
 require 'lib/ver'
 
-VER.run fork: false do
-  Tk::After.idle do
-    describe 'startup' do
-      text = VER.layout.views.first.text
-
-      should 'start with welcome buffer' do
-        text.filename.to_s.should.end_with '.config/ver/welcome'
-      end
-
-      should 'be at start of buffer' do
-        text.index(:insert).to_s.should == "1.0"
-      end
+module VER
+  class Spec
+    def initialize(&block)
+      @contexts = []
+      instance_eval(&block)
     end
-  end
-
-  Tk::After.idle do
-    describe VER::Methods::Move do
-      text = VER.layout.views.first.text
-
-      moving = lambda{|from, to, *args|
-        from, to = text.index(from), text.index(to)
-        $DEBUG = true
-        text.mark_set(:insert, from)
-        text.send(*args)
-        text.index(:insert).should == to
-        $DEBUG = false
-      }
-
-      should 'go a char forward' do
-        moving['1.0', '1.1', :forward_char]
-        moving['1.1', '1.2', :forward_char]
-      end
 
-      should 'go multiple chars forward' do
-        moving['1.0', '1.10', :forward_char, 10]
-      end
-
-      should 'go a char backward' do
-        moving['1.2', '1.1', :backward_char]
-        moving['1.1', '1.0', :backward_char]
-      end
-
-      should 'go multiple chars backward' do
-        moving['1.11', '1.1', :backward_char, 10]
-      end
-
-      should 'go to the beginning of a lines' do
-        moving['2.20', '2.0', :beginning_of_line]
+    def run
+      if context = @contexts.shift
+        Tk::After.idle do
+          context.run
+          run
+        end
+      else
+        Tk::After.idle{ bacon_summary }
       end
+    end
 
-      should 'go to the end of a line' do
-        moving['2.0', '2.0 lineend', :end_of_line]
-      end
+    def describe(*args, &block)
+      @contexts << Bacon::Context.new(args.join(' '), &block)
+    end
 
-      should 'go to a line number' do
-        moving['2.0', '10.0', :go_line, 10]
-      end
+    def bacon_summary
+      Bacon.handle_summary
 
-      should 'go to the end of a file' do
-        moving['2.0', 'end - 1 chars', :end_of_file]
+      if $!
+        Kernel.raise $!
+      elsif Bacon::Counter[:errors] + Bacon::Counter[:failed] > 0
+        Kernel.exit 1
+      else
+        Kernel.exit 0
       end
+    ensure
+      $stdout.flush
+      Tk.exit
+    end
+  end
 
-      should 'go a page down' do
-        moving['2.0', '2.1', :page_down]
-      end
 
-      should 'go a page up' do
-        moving['2.0', '1.51', :page_up]
-      end
+  # Schedule all describe blocks in a 'after idle' block that is scheduled by tcl.
+  # The last 'after idle' will output the bacon summary and call [Tk.exit].
+  # Not sure how well this handles nested describe blocks, but it might just work?
+  #
+  # @example usgage
+  #   VER.spec do
+  #     describe 'number of open buffers' do
+  #       it 'should open one buffer by default' do
+  #         VER.buffers.size.should == 1
+  #       end
+  #     end
+  #   end
+  def self.spec(&block)
+    specs = Spec.new(&block)
+
+    VER.run fork: false do
+      specs.run
     end
-
-    EM.stop
   end
 end