ver 2010.02 → 2010.08

data/lib/ver/vendor/pathname.rb

@@ -2,7 +2,42 @@ require 'pathname'
 
 # annoying fixes
 class Pathname
+  GUESS_ENCODING_ORDER = [
+    Encoding::US_ASCII,
+    Encoding::UTF_8,
+    Encoding::Shift_JIS,
+    Encoding::EUC_JP,
+    Encoding::EucJP_ms,
+    Encoding::Big5,
+    Encoding::UTF_16BE,
+    Encoding::UTF_16LE,
+    Encoding::UTF_32BE,
+    Encoding::UTF_32LE,
+    Encoding::CP949,
+    Encoding::Emacs_Mule,
+    Encoding::EUC_KR,
+    Encoding::EUC_TW,
+    Encoding::GB18030,
+    Encoding::GBK,
+    Encoding::Stateless_ISO_2022_JP,
+    Encoding::CP51932,
+    Encoding::EUC_CN,
+    Encoding::GB12345,
+    Encoding::Windows_31J,
+    Encoding::MacJapanese,
+    Encoding::UTF8_MAC,
+    Encoding::BINARY,
+  ]
+
   alias / join
+  alias rm unlink
+
+  def rm_f
+    rm
+  rescue Errno::ENOENT
+  rescue => ex
+    VER.error(ex)
+  end
 
   def cp(dest)
     FileUtils.copy_file(expand_path.to_s, dest.to_s, preserve = true)
@@ -23,4 +58,42 @@ class Pathname
   def shellescape
     to_s.shellescape
   end
+
+  def self.tmpdir
+    new(Dir.tmpdir)
+  end
+
+  def readonly?
+    if file?
+      if writable?
+        false
+      else
+        true
+      end
+    else
+      false
+    end
+  end
+
+  def read_encoded_file
+    content = read
+    content.force_encoding('BINARY')
+
+    require 'ver/vendor/open3'
+    encoding, status = Open3.capture2('rchardet', to_s)
+    content.force_encoding(encoding.strip)
+
+    return content, content.encoding
+  rescue ArgumentError, Errno::ENOENT # file or rchardet missing?
+    if content
+      GUESS_ENCODING_ORDER.find{|enc|
+        content.force_encoding(enc)
+        content.valid_encoding?
+      }
+
+      return content, content.encoding
+    else
+      return '', Encoding::UTF_8
+    end
+  end
 end

data/lib/ver/vendor/textpow.rb

@@ -138,7 +138,7 @@ module Textpow
         when :patterns
           create_children value
         else
-          $stderr.puts "Ignoring: #{key} => #{value.to_s.gsub("\n", "\n>>")}" if $DEBUG
+          # $stderr.puts "Ignoring: #{key} => #{value.to_s.gsub("\n", "\n>>")}" if $DEBUG
         end
       end
     end

data/lib/ver/version.rb

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

data/lib/ver/widget_event.rb

@@ -25,9 +25,6 @@ module VER
     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)
@@ -42,8 +39,15 @@ module VER
         RUBY
       end
 
-      result
+      @widget.send(method, *args, &block)
+    end
+
+    def send(method, *args, &block)
+      @widget.send(method, *args, &block)
+    end
+
+    def inspect
+      "#<VER::WidgetEvent widget=%p event=%p>" % [@widget, @event]
     end
-    alias send method_missing
   end
 end

data/lib/ver/widget_major_mode.rb

@@ -1,7 +1,7 @@
 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
+  # It also maintains a stack of the event patterns 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
@@ -17,7 +17,7 @@ module VER
     def initialize(widget, major)
       self.widget = widget
       self.major = MajorMode[major]
-      self.event_history = SizedArray.new(100)
+      self.event_history  = SizedArray.new(500) # this may be too small still
       self.action_history = SizedArray.new(100)
       self.stack = []
       self.minors = []
@@ -25,6 +25,11 @@ module VER
       establish_tag
       use(*self.major.minors)
       listen
+
+      # in case we had some keymap updates, they must have been registered by
+      # now, since otherwise we wouldn't be here.
+      # This will be called around 3 times per startup.
+      Event.done_yet?
     end
 
     def listen
@@ -35,9 +40,9 @@ module VER
       major.bound_keys
     end
 
-    # Shortcut to bind a sequence on the associated widget.
-    def bind(sequence, &block)
-      widget.bind(sequence, &block)
+    # Shortcut to bind a pattern on the associated widget.
+    def bind(pattern, &block)
+      widget.bind(pattern, &block)
     end
 
     def bind_key(key)
@@ -47,10 +52,10 @@ module VER
     def use(*minors)
       minors.each do |name|
         minor = MinorMode[name]
+        next if self.minors.any?{|m| m.name == minor.name }
         self.minors << minor
       end
 
-      self.minors.uniq!
       synchronize
     end
 
@@ -58,43 +63,80 @@ module VER
       self.minors -= minors.map{|name| MinorMode[name] }
     end
 
+    def fake(input)
+      input.scan(/<[\w-]+>|[^<>]/) do |name|
+        # get the widget that currently has focus, this might not be self.
+        path = Tk::Focus.focus
+        widget = Tk.pathname_to_widget(path)
+
+        if widget == self.widget
+          on_event(Event[name])
+          Tk.update
+        else
+          widget.type(name)
+        end
+      end
+    end
+
     def on_event(event)
-      stack << event.sequence
-      event_history << {
-        sequence: event.sequence,
-        keysym: event.keysym,
-        unicode: event.unicode
-      }
+      VER.touch
+      stack << event.pattern
+
+      # replace with our subset
+      event = Event.new(event.pattern, event.keysym, event.unicode)
+      event_history << event
 
       return handle_reader(event) if reader && read_amount
 
-      case result = resolve(stack)
+      result = resolve(stack)
+      case result
       when Incomplete
-        VER.message result.to_s
+        message result.to_s(widget)
         # don't do anything yet...
       when Impossible
-        VER.message result.to_s
+        warn result.to_s
         stack.clear
       else
         stack.clear
-        mode, action = result
+        message ''
+        mode, action = *result
         widget_event = WidgetEvent.new(widget, event)
         action.call(widget_event)
         action_history << [widget_event, *result]
       end
     end
 
+    def message(*args)
+      if widget.respond_to?(:message)
+        widget.message(*args)
+      else
+        VER.message(*args)
+      end
+    end
+
+    def warn(*args)
+      if widget.respond_to?(:warn)
+        widget.warn(*args)
+      else
+        VER.warn(*args)
+      end
+    end
+
     # ignore event for now, it might be needed later
     def handle_reader(event)
+      read_amount = self.read_amount
+
       if stack.size >= read_amount
         stack.clear
-        handled = true
+
+        # before we call, we reset the state in case the reader adds a new reader.
+        reader = self.reader
+        self.reader = self.read_amount = nil
         reader.call(*event_history.last(read_amount))
+        true
       else
-        handled = false
+        false
       end
-    ensure
-      self.read_amount = self.reader = nil if handled
     end
 
     def read(amount, &reader)
@@ -104,8 +146,8 @@ module VER
       self.reader = reader
     end
 
-    def resolve(sequence)
-      major.resolve(sequence, minors)
+    def resolve(pattern)
+      major.resolve(pattern, minors)
     end
 
     def replaces(other)
@@ -156,6 +198,10 @@ module VER
       major.actions + minors.map{|minor| minor.actions }.flatten
     end
 
+    def to_hash
+      [major.keymap, *minors].inject{|h, m| h.merge(m.keymap) }
+    end
+
     def name
       major.name
     end
@@ -176,7 +222,7 @@ module VER
       out = ['#<Ver::WidgetMajorMode']
       { major: major.name,
         minors: minors.map{|m| m.to_sym },
-        event_history: event_history.map{|h| h[:keysym] },
+        event_history: event_history.map(&:keysym),
         stack: stack,
       }.each{|k,v| out << "#{k}=#{v.inspect}" }
       out.join(' ') << '>'

data/spec/helper.rb

@@ -11,14 +11,14 @@ module VER
       instance_eval(&block)
     end
 
-    def run
+    def run(options = {})
       if context = @contexts.shift
         Tk::After.idle do
           context.run
-          run
+          run(options)
         end
       else
-        Tk::After.idle{ bacon_summary }
+        bacon_summary
       end
     end
 
@@ -27,6 +27,7 @@ module VER
     end
 
     def bacon_summary
+      Tk.update # finish all pending events first
       Bacon.handle_summary
 
       if $!
@@ -38,6 +39,7 @@ module VER
       end
     ensure
       $stdout.flush
+      $stderr.flush
       Tk.exit
     end
   end
@@ -55,11 +57,125 @@ module VER
   #       end
   #     end
   #   end
-  def self.spec(&block)
-    specs = Spec.new(&block)
+  def self.spec(options = {}, &block)
+    options = {
+      fork:    false,
+      hidden:  true,
+      load_rc: false,
+      welcome: false
+    }.merge(options)
 
-    VER.run fork: false do
-      specs.run
-    end
+    VER.run(options){ Spec.new(&block).run(options) }
+  end
+
+  # this is called when no buffers are left, make sure we finish all pending
+  # events and output the summary first.
+  def self.exit
+    Tk.update
+  end
+end
+
+BUFFER_VALUE = <<'VALUE'.chomp.freeze
+Inventore voluptatibus dolorem assumenda.
+Voluptates officiis quidem nemo est.
+Qui similique quia voluptatem.
+Sit pariatur vel aperiam et ab.
+Quam dolorem dignissimos perferendis.
+Nostrum cumque quaerat nobis ut repudiandae vitae autem perferendis.
+Quasi beatae sunt est et quo.
+Et eum qui perferendis excepturi molestias reiciendis.
+Sed voluptatum quis eaque vitae sed a et.
+Velit earum eius cupiditate saepe blanditiis aspernatur dolorem voluptas.
+In quam quo repellat.
+Iusto repudiandae delectus omnis ut autem.
+Fugiat tempore officiis ab.
+  Aut culpa accusantium consequatur laboriosam pariatur.
+    Cum autem explicabo dignissimos nemo.
+      Omnis vero rerum et in fugiat et eos.
+Ipsum commodi beatae maxime deserunt aut.
+Maxime earum harum officiis libero laborum.
+Aut et porro nam voluptas praesentium quaerat.
+Enim blanditiis delectus voluptate aliquid placeat.
+Repudiandae quae corrupti quaerat quisquam omnis ratione.
+Tempore dicta rem maxime nam aperiam consequatur nobis.
+Aut nam omnis ullam.
+Quia at quas minima quis.
+Numquam dolore similique et autem porro alias asperiores.
+Culpa neque qui unde voluptas.
+Sed id minus ut consequatur nihil aut itaque dolore.
+Alias maiores officiis quasi facilis dolor inventore.
+Omnis provident itaque neque.
+Rerum vel tenetur qui dicta sit omnis modi aut.
+Rerum laudantium et ipsa id natus dolores qui.
+Nulla est nihil eius et.
+Sint quibusdam est molestiae.
+Praesentium non quo omnis aliquam eaque est.
+Culpa sunt voluptatem ut dolores porro eius molestias esse.
+Nesciunt quo dignissimos debitis illo est omnis maiores.
+Sint cupiditate quo id perspiciatis voluptas qui quo.
+Suscipit ut incidunt atque animi minus optio esse harum.
+Molestiae sint iusto quasi.
+Quo delectus ipsa quia iste ullam corporis.
+Perferendis ut dolores error voluptatem.
+VALUE
+
+shared :with_buffer do
+  before do
+    create_buffer
+    buffer.insert = '1.0'
+    buffer.major_mode = VER::MajorMode[:Fundamental]
+    @insert = buffer.at_insert
+    Tk.update
+  end
+
+  def create_buffer
+    return if $ver_spec_buffer
+    $ver_spec_buffer = VER.layout.create_buffer
+    VER.layout.add_buffer(buffer)
+    buffer.value = BUFFER_VALUE
+  end
+
+  def buffer
+    $ver_spec_buffer
+  end
+
+  def insert
+    @insert
+  end
+
+  def reset
+    buffer.value = BUFFER_VALUE
+  end
+
+  def type(*keys)
+    Tk.update
+    buffer.type(keys.join)
+    Tk.update
+  end
+
+  def minibuf
+    buffer.minibuf
+  end
+
+  def range(*args)
+    buffer.range(*args)
+  end
+
+  def clipboard
+    VER::Clipboard.dwim
+  end
+
+  def clipboard_set(string)
+    VER::Clipboard.dwim = string
+  end
+end
+
+shared :destructive_mode do
+  behaves_like :with_buffer
+
+  before do
+    buffer.value = BUFFER_VALUE
+    buffer.insert = '1.0'
+    VER::Clipboard.clear
   end
 end