benatkin-vimilicious 0.1.5

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 ryan "remi" Taylor
+
+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.

data/README.rdoc

@@ -0,0 +1,26 @@
+= Vimilicious
+
+vimilicious is a gem/library that you can use on top of vim-ruby 
+for easier vim scripting, vim 'app' creation, or whatever you want
+
+i love vim.  i even love vim's built-in scripting ... sometimes.
+
+vim's scripting is pretty shitty for making complex, maintainable applications 
+or complicated scripts, though.  the perfect example is rails.vim.
+as much as i love and adore rails.vim ... have you ever looked at the source?  holy shit!
+
+using ruby for some of your vim scripting or application creation can make your life much easier.
+only those with vim compiled with ruby support will be able to take advantage of vimilicious or 
+Vimilicious based scripts/applications, but that's okay in my book.  
+we don't code in C just because not everyone has ruby installed, do we?
+
+== Install
+
+  $ sudo gem install remi-vimilicious -s http://gems.github.com
+
+== Usage
+
+see Vimilicious RDoc or examples
+
+documentation:: http://code.remi.org/vimilicious
+example:: http://github.com/remi/vimilicious/tree/master/examples

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rake'
+require 'rubygems'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'vimilicious'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Confirm that gemspec is $SAFE'
+task :safe do
+  require 'yaml'
+  require 'rubygems/specification'
+  data = File.read('rackbox.gemspec')
+  spec = nil
+  if data !~ %r{!ruby/object:Gem::Specification}
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  else
+    spec = YAML.load(data)
+  end
+  spec.validate
+  puts spec
+  puts "OK"
+end
+
+task :default => :spec

data/examples/vikir.rb

@@ -0,0 +1,110 @@
+# vikir.rb
+#
+# VI Wiki In Ruby
+
+# Usage:          (assumes <Leader> is /, and all else is default)
+#
+#        \v h     goto HomePage
+#        \v i     goto Index of all Wiki Pages
+#        \v r     refresh highlighting (or apply to any file to see valid wiki pages)
+#        \v f     follow word under cursor (regardless of whether or not it exists)
+#        \v o     open word under cursor (same as follow but will open in window 2, if available)
+#        \v s     follow in split (horizontal)
+#        \v v     follow in split (vertical)
+#        \v e     open explorer (vertical split with index on left)
+#        \v m     render as markdown and preview in browser (requires 'markdown' in path to do the work)
+#
+# Highlights:
+#
+#        SIMPLE
+#
+#        \v r applies highlighting on *top* of any currently displayed highlighting
+#
+
+require 'rubygems'
+require 'vimilicious'
+
+## -- CONSTANTS -- ##
+WIKI_DIR = '~/wiki'.gsub '~', ENV['HOME']
+HOME_PAGE = 'HomePage'
+COMMAND_PREFIX = '<Leader>v'
+HIGHLIGHT_AS = 'Identifier'
+DEFAULT_FILETYPE = 'mkd'
+
+## -- HELPER METHODS -- ##
+def page name
+   File.join WIKI_DIR, name
+end
+def in_wiki? location=current_file
+  location.include?WIKI_DIR if location
+end
+def pages
+  Dir[File.join(WIKI_DIR,'*')]
+end
+  
+## -- ACTION METHODS -- ##
+def goto place
+  cmd "cd #{WIKI_DIR}"
+  cmd "e #{page place}"
+  highlight unless File.directory?page(place)
+end
+def index
+  goto ''
+end
+def home
+  goto HOME_PAGE
+end
+def follow place=current_word
+  goto place
+end
+def follow_in_split place=current_word, open_below=true
+  cmd 'sp'
+  exec '<C-w>' + (open_below ? 'j' : 'k')
+  follow place
+end
+def follow_in_vsplit place=current_word, open_right_of=true
+  cmd 'vsp'
+  exec '<C-w>' + (open_right_of ? 'l' : 'h')
+  follow place
+end
+def explorer
+  follow_in_vsplit '', false
+  exec '40<C-w><'
+end
+def open place=current_word
+  exec '<C-w>l' if VIM::Window.count > 1 # assume window is on right (for now)
+  follow place
+  exec '<C-w>h^' # more back to left (feels right)
+end
+def highlight
+  if File.directory?current_file # assume this is the wiki dir and simple reload it
+    goto ''; return
+  end
+  cmd "set ft=#{DEFAULT_FILETYPE}" unless DEFAULT_FILETYPE.empty?
+  pages.each do |file|
+    cmd "syntax match VikirPage '#{File.basename file}'"
+  end
+end
+def markdown
+  Thread.new { `markdown '#{current_file}'` }
+end
+
+## -- COMMAND MAPPING -- ##
+commands = { 
+  :h => :home,
+  :i => :index,
+  :r => :highlight,
+  :f => :follow,
+  :s => :follow_in_split,
+  :v => :follow_in_vsplit,
+  :e => :explorer,
+  :o => :open,
+  :m => :markdown
+}
+commands.each do |command, method|
+  cmd %{ map #{COMMAND_PREFIX}#{command} :ruby #{method}<CR>  }
+end
+
+## -- SYNTAX HIGHLIGHTING -- ##
+cmd "hi def link VikirPage #{HIGHLIGHT_AS}"
+highlight if in_wiki?

data/examples/vikir.vim

@@ -0,0 +1,32 @@
+" vikir.vim
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Name:             vikir
+" Description:      vi wiki in ruby
+" Author:           remi Taylor  <remi@remitaylor.com>
+" Maintainer:       -- '' --
+"
+" Licence:          This program is free software; you can redistribute it
+"                   and/or modify it under the terms of the GNU General Public
+"                   License.  See http://www.gnu.org/copyleft/gpl.txt
+"
+" Credits:          
+"
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+" hello angry vim hacker
+"
+" you wanna see lots and lots and lots and lots and lots
+" of jazz here with things like <unique> <silent> <SID> 
+" all over the place
+"
+" well, sorry to disappoint you ... 
+"
+" this and vikir.rb are all you'll find here!
+
+if &cp || (exists("g:loaded_vikir") && g:loaded_vikir)
+	finish
+endif
+
+rubyf ~/.vim/plugin/vikir.rb
+
+let g:loaded_vikir = 1

data/lib/vimilicious.rb

@@ -0,0 +1,330 @@
+# common methods for vim-ruby scripts
+module Vimilicious
+
+  # run vim command
+  #
+  #   :ruby puts cmd("echo 'hello!'")
+  def cmd vim_ex_command
+    VIM::command vim_ex_command
+  end
+
+  # runs a system command in vim, by calling :! command
+  #
+  #   :ruby run 'ls'
+  def run system_command
+    cmd "! #{ system_command }"
+  end
+
+  # evaluate vim expression
+  #
+  #   :ruby puts 'x = ' + vim_eval('x')
+  def vim_eval vim_expression
+    VIM::evaluate vim_expression
+  end
+
+  # execute 'normal' command
+  #
+  #   :ruby exec '<ESC>ihello there!<ESC>'
+  def exec normal_vim_command
+    cmd %[exec "normal #{normal_vim_command}"].gsub('<','\<')
+  end
+
+  # alias 'puts' to vim 'print' method
+  #
+  #   :ruby puts 'hello!'
+  def puts message
+    print message
+  end
+
+  # check to see if a vim variable is defined
+  #
+  #   :ruby puts 'x is defined? ' + vim_defined?'x'
+  def vim_defined? var 
+    vim_eval("exists('#{var}')") == '1' 
+  end
+
+  # get the value of a vim variable (else nil)
+  #
+  #   :ruby x = vim_var('x'); puts "x = #{x}"
+  def vim_var var 
+    vim_eval(var) if vim_defined?var
+  end
+
+  # get the current buffer
+  #
+  #   :ruby puts "the current line says: #{current_buffer.line}"
+  def current_buffer
+    VIM::Buffer.current # $curbuf
+  end
+
+  # get the current window
+  #
+  #   :ruby puts "the cursor is at: #{current_window.cursor.inspect}"
+  def current_window
+    VIM::Window.current # $curwin
+  end
+
+  # get the name of the current file
+  #
+  #   :ruby puts "currently editing: #{current_file}"
+  def current_file
+    current_buffer.name
+  end
+
+  # get the current cursor location (as array [line_number,position])
+  #
+  #   :ruby puts "the cursor is at: #{cursor.inspect}"
+  def cursor
+    current_window.cursor
+  end
+
+  # get the text of the currently selected line
+  #
+  #   :ruby puts "the current line says: #{current_line}"
+  def current_line
+    current_buffer.line
+  end
+
+  # set the text of the currently selected line
+  #
+  # we're not using the more conventional current_line= because
+  # that simply creates a local variable named current_line
+  #
+  #   :ruby set_current_line 'hi there'
+  def set_current_line text
+    current_buffer[ current_buffer.line_number ] = text.to_s
+  end
+
+  # deletes the current buffer (closes the file) but keeps the current layout
+  #
+  #   :ruby clear
+  def clear
+    cmd 'let kwbd_bn= bufnr("%")|enew|exe "bdel ".kwbd_bn|unlet kwbd_bn'
+    clear_buffer
+  end
+
+  # forcefully deletes the current buffer and clears the wholelayout
+  #
+  #   :ruby clear!
+  def clear!
+    cmd 'bd!'
+    clear_buffer
+  end
+
+  # deletes all lines in the current_buffer
+  def clear_buffer
+    exec 'gg'
+    current_buffer.length.times { current_buffer.delete(1) }
+  end
+
+  # append text to the end of the current_buffer
+  #
+  #   :ruby append 'hello there'
+  def append text
+    current_buffer.append current_buffer.length, text
+  end
+
+  # prompts user for input
+  #
+  #   :ruby prompt('username')
+  def prompt name = 'input', format = lambda { |name| "#{name}: " }
+    input = vim_eval("inputdialog('#{ format.call(name) }')")
+    puts '' # clear statusline thinger
+    input
+  end
+
+  # ruby method for mapping keyboard shortcuts to something
+  #
+  # this is a ruby wrapper around vim's map functions
+  #
+  # ==== VIM Modes
+  #
+  # map::  Normal, Visual, Operator-pending 
+  # map!:: Insert, Command-line 
+  # nmap:: Normal 
+  # vmap:: Visual 
+  # omap:: Operator-pending 
+  # cmap:: Command-line 
+  # imap:: Insert 
+  # lmap:: Insert, Command-line, Lang-Arg 
+  #
+  # references:
+  # - http://www.vim.org/htmldoc/map.html
+  # - http://howto.wikia.com/wiki/Howto_map_keys_in_vim
+  #
+  # === Usage
+  #
+  #   map :normal, '<C-v>', do
+  #     # some code that will run whenever
+  #     # Control-V is pressed in Normal mode
+  #   end
+  #
+  #   map '<F5>', ":echo 'hello from F5'<Enter>"
+  #
+  # ==== Parameters
+  # modes::
+  #   optional. either a single mode, eg. :normal or an Array of 
+  #   multiple modes, eg. %w( visual command ). default: 'normal'
+  #
+  #   valid mode names: normal, visual, insert, command, operator, lang
+  #
+  # shortcut::
+  #   a shortcut just like VIM normally understands, eg. <C-v>
+  #
+  # vim_command::
+  #   optional.  this is a string command that we'll map 
+  #   this shortcut to.  if this is passed, the &block 
+  #   parameter is ignored and vim_command is run instead!
+  #   you can still run ruby with this parameter by 
+  #   passing something like '<Esc>:ruby puts 'hi'<Enter>' 
+  #
+  # &block::
+  #   a block of code to run whenever the code is pressed
+  #
+  # TODO allow #map('<C-r>'){ ... } and use default mode
+  # TODO allow #map('<C-r>', 'vim command')
+  #
+  def map modes, shortcut = nil, vim_command = nil, &block
+    
+    # first argument isn't a mode, it's a shortcut!
+    unless modes.is_a?(Symbol) or modes.is_a?(Array)
+      vim_command = shortcut
+      shortcut    = modes
+      modes       = :normal # default
+    end
+
+    modes_to_use = map_commands_for *modes
+    raise "Don't know how to map #{ modes.inspect }" if modes_to_use.empty?
+
+    if vim_command
+      modes_to_use.each do |mode|
+        cmd "#{ mode } #{ shortcut } #{ vim_command }"
+      end
+
+    elsif block
+      unique_key = "#{ shortcut.inspect } #{ modes.inspect } #{ Time.now }"
+      @mapped_blocks ||= { }
+      @mapped_blocks[unique_key] = block
+      modes_to_use.each do |mode|
+        cmd "#{ mode } #{ shortcut } <Esc>:ruby @mapped_blocks[%{#{ unique_key }}].call<Enter>"
+      end
+
+    else
+      raise "Not sure what you want to map to ... no vim_command or block passed."
+    end 
+  end
+
+  # returns the map command(s) you should use if you want 
+  # to map with the mode(s) given
+  #
+  # see spec/mapping_spec.rb
+  #
+  #   >> map_commands_for(:normal)
+  #   => :nmap
+  #
+  def map_commands_for *modes
+    @mapmodes ||= {
+      :map  => [ :normal, :visual, :operator ],
+      :map! => [ :insert, :command ],
+      :nmap => [ :normal ],
+      :vmap => [ :visual ], 
+      :omap => [ :operator ], 
+      :cmap => [ :command ], 
+      :imap => [ :insert ], 
+      :lmap => [ :insert, :command, :lang ]
+    }
+
+    # symbolize
+    modes = modes.map {|mode| mode.to_s.downcase.to_sym }
+    
+    # first, see if there's a mode that has the modes we want and nothing more
+    mode_that_has_everything_we_want_and_nothing_else = @mapmodes.find do |mode_command, available_modes|
+      match = true
+      match = false unless available_modes.length == modes.length
+      modes.each {|mode| match = false unless available_modes.include?(mode) }
+      match
+    end
+
+    return [ mode_that_has_everything_we_want_and_nothing_else[0] ] if mode_that_has_everything_we_want_and_nothing_else
+
+    # see if the modes we're looking for have a 1 <=> 1 mapping with available modes
+    one_to_one_mapping_modes = modes.map do |mode|
+      @mapmodes.find do |mode_command, available_modes|
+        available_modes == [mode]
+      end
+    end
+
+    return one_to_one_mapping_modes.map {|mode_command, available_modes| 
+      mode_command
+    } unless one_to_one_mapping_modes.include? nil
+
+    # hmm, regardless of whether it'll have more than we want, see if we can find a mode 
+    # that has all of the modes we're looking for
+    modes_that_have_everything_we_want_and_some_more = @mapmodes.select do |mode_command, available_modes|
+      match = true
+      modes.each {|mode| match = false unless available_modes.include?(mode) }
+      match
+    end
+
+    if modes_that_have_everything_we_want_and_some_more.length == 1
+      return [ modes_that_have_everything_we_want_and_some_more[0][0] ]
+    else
+      [] # couldn't find anything  :/
+    end
+
+  end
+
+  # create a vim user command that calls a ruby method or block
+  #
+  #   :ruby create_command :test                # creates a :Test command that calls a 'test' method
+  #   :ruby create_command 'test', :hi          # creates a :Test command that calls a 'hi' method
+  #   :ruby create_command(:test){ puts 'hi' }  # creates a :Test command that calls the block passed in
+  #
+  #   :ruby create_command(:foo){|*args| puts "called foo with args: #{ args.inspect }" }
+  #
+  #   :Foo 'hello', 'there', 1, 2, 3
+  #   called foo with args: ["hi", "there", 1, 2, 3]
+  #
+  # ==== Notes
+  #
+  # the name of the command will be capitalized, so :test is callable as :Test
+  #
+  def create_command name, method = nil, &block
+    name          = name.to_s
+    command_name  = name[0..0] + name[1..name.length]
+    method_name   = (method.nil?) ? name.to_s : method.to_s
+    function_name = command_name + 'AutoGeneratedFunction'
+    
+    # create a function that calls method (or block)
+    if block.nil?
+      cmd %[fu! #{ function_name }(...)\n  ruby #{ method_name } *eval("\#{ vim_eval('string(a:000)') }")\nendfu]
+    else
+      generated_method = command_name + '_auto_generated_method'
+      Kernel.module_eval { define_method generated_method, block }
+      cmd %[fu! #{ function_name }(...)\n  ruby #{ generated_method } *eval("\#{ vim_eval('string(a:000)') }")\nendfu]
+    end
+
+    # create a vim command that calls the vim function
+    cmd %{command! -nargs=* #{ command_name } call #{ function_name }(<args>)}
+  end
+
+  # get the word under the cursor
+  #
+  #   :ruby puts "the cursor is on top of the word: #{current_word}"
+  def current_word filter=/[,'`\.:\(\)\[\]\}\{]/, replace_with=''
+    line, index = current_line, cursor[1]
+    word_start, word_end = line.rindex(' ',index) || 0, line.index(' ',index)
+    word_start += 1 if word_start > 0 
+    word_end = line.length if word_end.nil?
+    word = line[word_start, word_end-word_start] || ''
+    word.gsub!(filter,replace_with) unless word.empty?
+    word
+  end
+
+end
+
+include Vimilicious
+
+### COMMANDS ###
+
+create_command('InspectArgs'){ |*args| puts "passed: #{args.inspect}" }