niklas-vimmate 0.8.0.1

data/lib/filtered_file_tree_store.rb

@@ -0,0 +1,34 @@
+class FilteredFileTreeStore < ActiveWindow::FilteredActiveTreeStore
+  # Fuzzy search by String
+  # 'foo'     => matches la/lu/foo, f/lala/o/gaga/o
+  # 'foo/bar' => matches la/afoo/gnarz/barz, but not the above
+  def iter_visible?(iter)
+    case iter[OBJECT]
+    when ListedDirectory; false
+    when ListedFile
+      iter[filter_column] =~ filter_regexp
+    else
+      false
+    end
+  end
+
+  def filter_string=(new_filter_string)
+    @filter_regexp = nil
+    @filter_column = nil
+    super
+  end
+
+
+  def filter_regexp
+    @filter_regexp ||= Regexp.new(
+      filter_string.split('/').map { |t| 
+        Regexp.escape(t).split(//).join('.*') 
+      }.join('.*/.*')
+    )
+  end
+
+  def filter_column
+    @filter_column ||= filter_string =~ %r~/~ ? FULL_PATH : NAME
+  end
+
+end

data/lib/gtk_thread_helper.rb

@@ -0,0 +1,73 @@
+# From http://ruby-gnome2.sourceforge.jp/hiki.cgi?tips_threads
+#
+# This is a crucial "tip," and in fact qualifies, I believe, as a major warning
+# or fix for using Ruby with the Gtk library.
+# 
+# The warning is this: If you call Gtk methods from outside of Gtk's main thread,
+# there is a chance that the Ruby interpreter (not merely your Ruby application!)
+# will crash with a segmentation fault (seg fault) error, seemingly at random.
+# This is not an exception you can catch. It is fatal and crippling, and very
+# difficult to debug.
+# 
+# You might be using Ruby threads even without knowing! For example, if you
+# receive events or callbacks to your Ruby methods or blocks from another library
+# or service, these calls may very well be occurring on other threads. If that's
+#   the case, and you call Gtk from within your callbacks, you risk a seg fault.
+# 
+# Otherwise you might have your own worker thread in the background doing some
+#   work, which occasionally needs to call Gtk to update a widget. 
+#     
+#     (Side note: If you are using Ruby threads, be sure to protect your
+#      thread-shared resources with either a Monitor or a Mutex! The difference:
+#        monitors are safer, in that they are re-entrable from the same thread;
+#      mutexes aren't, but perform better.)
+#
+# Usage is very simple:
+
+# Start your Gtk application by calling Gtk.main_with_queue rather than
+# Gtk.main. The "timeout" argument is in milliseconds, and it is the maximum
+# time that can pass until queued blocks get called: 100 should be fine. 
+# 
+# Whenever you need to queue a call, use Gtk.queue. For example:
+# def my_event_callback
+#   Gtk.queue do
+#     @image.pixbuf = Gdk::Pixbuf.new @image_path, width, height
+#   end
+# end
+#
+# Issues:
+#   1. Keep your queued blocks lean. Do all your CPU-intensive work outside of
+#      the queued block. This will help keep Gtk responsive.
+
+require 'monitor'
+module Gtk
+  GTK_PENDING_BLOCKS = []
+  GTK_PENDING_BLOCKS_LOCK = ::Monitor.new
+
+  GTK_MAX_PENDING_BLOCKS_PER_ITERATION = 42
+
+  def Gtk.queue &block
+    if Thread.current == Thread.main
+      block.call
+    else
+      GTK_PENDING_BLOCKS_LOCK.synchronize do
+        GTK_PENDING_BLOCKS << block
+      end
+    end
+  end
+
+  def Gtk.main_with_queue timeout = 100
+    Gtk.timeout_add timeout do
+      GTK_PENDING_BLOCKS_LOCK.synchronize do
+        length = GTK_PENDING_BLOCKS.length
+        if length > GTK_MAX_PENDING_BLOCKS_PER_ITERATION
+          GTK_PENDING_BLOCKS.shift(GTK_MAX_PENDING_BLOCKS_PER_ITERATION).each(&:call)
+        elsif length > 0
+          GTK_PENDING_BLOCKS.each(&:call).clear
+        end
+      end
+      true
+    end
+    Gtk.main
+  end
+end

data/lib/listed_directory.rb

@@ -0,0 +1,43 @@
+  class ListedDirectory < ListedFile
+    def sort
+      "1-#{name}-1"
+    end
+    def icon_name
+      'folder'
+    end
+    def file?
+      false # yeah..!
+    end
+    def directory?
+      true
+    end
+    def exists?
+      full_path && ::File.directory?(full_path)
+    end
+    def refresh
+      super
+      #remove_not_existing_files
+      add_new_files
+    end
+
+    def children_paths
+      children_names.map {|n| File.join(full_path, n)}
+    end
+
+    def children_names
+      Dir.entries(full_path).select {|p| p !~ /^\./ }
+    end
+
+    
+    # Find files to add
+    def add_new_files
+      begin
+        children_paths.each do |file_path|
+          tree << file_path
+        end
+      rescue Errno::ENOENT
+      end
+      @traversed = true
+    end
+
+  end

data/lib/listed_file.rb

@@ -0,0 +1,67 @@
+  class ListedFile < ActiveWindow::ListedItem
+    attr_accessor :full_path, :name, :status
+
+    def self.create(opts = {})
+      if fp = opts[:full_path]
+        if File.directory?(fp)
+          ListedDirectory.new opts
+        elsif File.file?(fp)
+          ListedFile.new opts
+        else
+          raise ArgumentError, "does not exist: #{fp}"
+        end
+      else
+        raise ArgumentError, "please give a :full_path, not only #{opts.inspect}"
+      end
+    end
+
+    def initialize(opts = {})
+      super
+      if fp = opts[:full_path]
+        self.full_path = fp
+        self.status = "normal" if VimMate::Config[:files_show_status]
+      end
+    end
+    def icon_name
+      'file'
+    end
+    def refresh
+      Gtk.queue do
+        self.icon = VimMate::Icons.by_name icon_name
+        self.status = "normal" if VimMate::Config[:files_show_status]
+      end
+    end
+
+    # sets #name AND #fullpath
+    def full_path=(new_full_path)
+      unless new_full_path.empty?
+        @full_path = File.expand_path new_full_path
+        self.name  = File.basename new_full_path
+      end
+    end
+    def sort
+      "2-#{name}-1"
+    end
+    def file?
+      true
+    end
+    def directory?
+      false
+    end
+    def exists?
+      full_path && ::File.file?(full_path)
+    end
+    def file_or_directory?
+      file? || directory?
+    end
+
+    def show!
+      i = iter
+      while i = i.parent
+        i[VISIBLE] = true
+      end
+      super
+    end
+
+  end
+

data/lib/try.rb

@@ -0,0 +1,9 @@
+class Object
+  ##
+  #   @person.name unless @person.nil?
+  # vs
+  #   @person.try(:name)
+  def try(method)
+    self.send(method) unless self.nil?
+  end
+end

data/lib/vim/buffers.rb

@@ -0,0 +1,18 @@
+  module Vim
+    module Buffers
+
+      def buffers
+        @buffers ||= [ nil ]
+      end
+      def new_buffer(path=nil)
+        buffers << path
+        buffers.length - 1
+      end
+
+      def last_buffer
+        @buffers.length - 1
+      end
+
+    end
+  end
+

data/lib/vim/integration.rb

@@ -0,0 +1,36 @@
+require 'socket'
+
+module Vim
+  module Integration
+
+    Password = 'donthasslethehoff'
+
+    include Buffers
+    include Netbeans
+
+    private
+    def listen
+      Thread.new do
+        while true
+          send_function(0, 'getCursor')
+          sleep 1
+        end
+      end
+      Thread.new do
+        while true
+          if data = vim.gets
+            interpret_message(data)
+          end
+        end
+      end
+    end
+
+    def exec_gvim(command)
+      `gvim --servername #{@vim_server_name} #{command}`
+    end
+
+    def remote_send(command)
+      exec_gvim %Q~--remote-send '#{command.gsub(%q~'~,%q~\\'~)}'~
+    end
+  end
+end

data/lib/vim/netbeans.rb

@@ -0,0 +1,156 @@
+  module Vim
+    module Netbeans
+
+      SERVER_MUTEX = Mutex.new
+
+      class Message
+        attr_reader :message
+        def initialize(message)
+          @message = message
+        end
+
+        def to_s
+          @message
+        end
+      end
+      class Event < Message
+        attr_reader :buffer, :name, :value, :rest
+        def initialize(message)
+          super
+          if match = message.match(/^(\d+):(\w+)=(\d)\s*/)
+            @buffer = match[1].to_i
+            @name =   match[2]
+            @value =  match[3]
+            @rest =   match.post_match.split(/\s/)
+            @rest = @rest.map do |arg|
+              case arg
+              when /^"(.*)"$/
+                $1
+              when 'T'
+                true
+              when 'F'
+                false
+              when /^\d+$/
+                arg.to_i
+              else
+                arg
+              end
+            end
+          end
+        end
+        def to_s
+          %Q~#{@buffer}:#{@name}=#{@value} #{@rest.inspect}~
+        end
+      end
+      class Reply < Message
+        attr_reader :seqno, :value
+        def initialize(message)
+          super
+          @seqno, @value = message.split(/\s/)
+          @seqno = @seqno.to_i
+        end
+      end
+
+      def replies
+        @replies ||= {}
+      end
+
+      def remember_reply(reply)
+        replies[reply.seqno] = reply
+      end
+
+      def interpret_message(mess)
+        if mess.index ':'
+          event = Event.new(mess)
+          case event.name
+          when 'fileOpened'
+            path = event.rest.first
+            if event.buffer == 0
+              send_command(new_buffer(path), 'putBufferNumber', path)
+              send_command(last_buffer, 'startDocumentListen')
+            else
+              @buffers[event.buffer] = path
+              send_command(event.buffer, 'startDocumentListen')
+            end
+          else
+            mess
+          end
+          event
+        else
+          reply = Reply.new(mess)
+          remember_reply reply
+          reply
+        end
+      end
+
+      attr_reader :port
+      def server
+        if @server
+          @server
+        else
+          @server = TCPServer.open('localhost', 0)
+          @port = @server.addr[1]
+          @server
+        end
+      end
+
+      def vim
+        begin 
+          @vim_session ||= server.accept_nonblock
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR
+          IO.select([server])
+          retry
+        end
+        return @vim_session
+      end
+
+      attr_reader :seqno
+      def new_seqno
+        if @seqno
+          @seqno += 1
+        else
+          @seqno = 1
+        end
+      end
+      def send_command(buf,name,*args)
+        command = %Q~#{buf}:#{name}!#{new_seqno}~
+        unless args.empty?
+          command << ' ' + args.map do |arg|
+            case arg
+            when String
+              %Q~"#{arg.gsub('"','\\"')}"~
+            when Array # lnum/col
+              arg.length == 2 ? arg.join('/') : arg.join('-')
+            when true
+              'T'
+            when false
+              'F'
+            else
+              arg
+            end
+          end.join(' ')
+        end
+        send_message command
+      end
+
+      # TODO timeout
+      def send_function(buf,name)
+        seq = new_seqno
+        send_message %Q~#{buf}:#{name}/#{seq}~
+        while not reply = replies[seq]
+          sleep 0.005
+        end
+        replies.delete(seq)
+        reply
+      end
+
+      def send_message(message)
+        STDERR.puts "--- NOT sending #{message}"
+        return
+        SERVER_MUTEX.synchronize do
+          vim.puts message
+        end
+      end
+
+    end
+  end