vimmate 0.8.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=(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.index('/') ? 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,45 @@
+  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)}
+    rescue Errno::ENOENT, Errno::EACCES
+      []
+    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, Errno::EACCES
+      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,38 @@
+require 'socket'
+
+module Vim
+  module Integration
+
+    Executable = 'gvim'
+    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(cmd)
+      command = %Q[#{Executable} --servername #{@vim_server_name} #{cmd}]
+      system(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,154 @@
+  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)
+        SERVER_MUTEX.synchronize do
+          vim.puts message
+        end
+      end
+
+    end
+  end

data/lib/vim/source.vim

@@ -0,0 +1,18 @@
+            function! GetOpenBufferPaths()                                                  
+                let tablist = []
+                let pathlist = []
+                let cwd = getcwd()
+                for i in range(tabpagenr('$'))
+                    call extend(tablist, tabpagebuflist(i + 1))
+                endfor
+                for i in tablist
+                    let bufn = bufname(i)
+                    if (bufn =~ '^/')==0
+                      call add(pathlist, cwd . '/' . bufn)
+                    else
+                      call add(pathlist, bufn)
+                    end
+                endfor
+                call filter(pathlist, "v:val != cwd.'/'" )
+                return pathlist
+            endfunction

data/lib/vim_mate/config.rb

@@ -0,0 +1,132 @@
+=begin
+= VimMate: Vim graphical add-on
+Copyright (c) 2006 Guillaume Benny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+=end
+
+require 'yaml'
+
+module VimMate
+
+  # Holds the configurations for VimMate. Also read and write this
+  # configuration so the user can change it.
+  class Config
+    include NiceSingleton
+
+    BASE_FILENAME = '.vimmaterc'
+    DEFAULT_CONFIG = {
+      :window_title => 'VimMate',
+      :window_width => 950,
+      :window_height => 600,
+      :layout_big_terminals => false,
+      :files_opened_width => 250,
+      :files_closed_width => 25,
+      :files_expanded => true,
+      :file_headers_visible => false,
+      :file_hover_selection => false,
+      :file_directory_separator => true,
+      :files_filter_active => true,
+      :files_auto_expand_on_filter => false,
+      :files_refresh_interval => 10,
+      :files_default_open_in_tabs => true,
+      :files_use_ellipsis => true,
+      :files_use_search => true,
+      :files_search_ignore_case => true,
+      :files_search_separator_position => 400,
+      :files_warn_too_many_files => 300,
+      :files_warn_too_many_files_each_step => true,
+      :files_show_status => true,
+      :tags_refresh_interval => 5,
+      :terminals_enabled => true,
+      :terminals_height => 50,
+      :terminals_font => "10",
+      :terminals_foreground_color => "#000000",
+      :terminals_background_color => "#FFFFDD",
+      :terminals_audible_bell => false,
+      :terminals_visible_bell => false,
+      :terminals_autoexec => "",
+      :terminals_login_shell => false,      
+      :subversion_enabled => true,
+    }.freeze
+
+    # Create the Config class. Cannot be called directly
+    def initialize
+      # Set the full path to the configuration file. In the user's
+      # HOME or the current directory
+      if ENV['HOME']
+        self.class.const_set(:FILENAME, File.join(ENV['HOME'], BASE_FILENAME))
+      else
+        self.class.const_set(:FILENAME, BASE_FILENAME)
+      end
+      @config = DEFAULT_CONFIG.dup
+    end
+
+    # Access the configuration hash
+    def config
+      read_config
+      #@config.freeze
+      # Once read, we only need a simple reader
+      self.class.send(:attr_reader, :config)
+      config
+    end
+
+    # Easy access to the configuration hash
+    def [](symbol)
+      config[symbol.to_sym]
+    end
+
+    # Get the lib path
+    def lib_path
+      File.dirname(File.expand_path(__FILE__))
+    end
+
+    def images_path
+       File.expand_path(File.dirname(__FILE__) + '/../../images')
+    end
+    
+    private
+
+    # Read the configuration file
+    def read_config
+      # Write the default if it doesn't exist
+      unless File.exist? FILENAME
+        write_config
+        return
+      end
+      # Read the configuration file and merge it with the default
+      # so if the user doesn't specify an option, it's set to the default
+      @config.merge!(YAML.load_file(FILENAME))
+      write_config
+    rescue StandardError => e
+      $stderr.puts e.to_s
+      $stderr.puts "Problem reading config file #{FILENAME}, using default"
+    end
+
+    # Write the configuration file
+    def write_config
+      File.open(FILENAME, 'w') do |file|
+        YAML.dump(@config, file)
+      end
+    rescue StandardError => e
+      $stderr.puts e.to_s
+      $stderr.puts "Problem writing config file #{FILENAME}"
+    end
+  end
+end

data/lib/vim_mate/dummy_window.rb

@@ -0,0 +1,14 @@
+module VimMate
+
+  # Represents a dummy window used when a feature is missing
+  class DummyWindow
+
+    attr_reader :gtk_window
+
+    # Create a DummyWindow
+    def initialize
+      @gtk_window = Gtk::EventBox.new
+    end
+  end
+end
+