vimjar 0.3.0

data/lib/vim-jar/config.rb

@@ -0,0 +1,126 @@
+module Vim
+  module Jar 
+    class Config 
+      require 'singleton'
+      include Singleton
+
+      def vim_jar_root 
+        Pathname.new(File.expand_path("../../",File.dirname(__FILE__)))
+      end
+
+      def vim_jar_lib 
+        Pathname.new(vim_jar_root.join("lib"))
+      end
+
+      def user_home 
+        Pathname.new(ENV['VIM_JAR_USER_HOME'] || ::Gem.user_home)
+      end
+
+      def vim_home 
+        Pathname.new(user_home.join(".vim"))
+      end
+
+      def vimrc_path
+        user_home.join(".vimrc")
+      end
+
+      def under_git?
+        @under_git ||= File.exist?(vim_home.join(".git"))
+      end
+
+      def gitmodules_file_path
+        vim_home.join(".gitmodules")
+      end
+
+      def gitconfig_file_path
+        vim_home.join(".git",'config')
+      end
+
+      def bundle_home 
+        Pathname.new(vim_home.join("bundle"))
+      end
+
+
+      def autoload_home 
+        Pathname.new(vim_home.join("autoload"))
+      end
+
+      def pathogen_path
+        Pathname.new(vim_home.join("autoload",'pathogen.vim'))
+      end
+
+      def pathogen_vim_path(version="1.2") 
+        vim_jar_lib.join("vim-jar","pathogen","pathogen_v#{version}.vim")
+      end
+
+      def bundle_file_path
+        vim_home.join("BundleFile")
+      end
+
+      def bundle_template_file_path 
+        vim_jar_lib.join("templates", "BundleFile")
+      end
+
+      def check 
+        check_vim_pathes!
+        self.init_git_repo unless under_git?
+        self.setup_pathogen unless File.exist?(self.pathogen_path)
+        self.create_bundle_home unless File.exist?(self.bundle_home)
+        self.init_bundle_file unless File.exists?(self.bundle_file_path)
+      end
+
+      def check_vim_pathes!
+        %w[vim_home vimrc_path].each do |method_name|
+          path = self.send(method_name)
+          raise InitError.new("#{path} doesn't exist") unless File.exist?(path)
+        end
+      end
+
+      def init_git_repo
+        Dir.chdir(self.vim_home) do 
+          message = <<-EOF
+  your .vim folder is not a git repository.  we'll init git repository for you.
+
+    You can make use of git submodule to manage your plugins.
+    Futher more you can push your git repository to www.github.com.
+          EOF
+          STDOUT.puts message
+          system("git init")
+        end
+      end
+
+      def create_bundle_home 
+        FileUtils.mkdir_p(bundle_home) 
+        STDOUT.puts "create folder for pathogen in #{bundle_home}"
+      end
+
+      def setup_pathogen
+        self.install_pathogen
+        STDOUT.puts <<-EOF
+
+  Pathogen is installed into #{self.pathogen_path}. 
+
+  NOTICE: you need copy line below into #{self.vimrc_path}.
+
+  call pathogen#runtime_append_all_bundles() 
+
+        EOF
+      end
+
+      def install_pathogen
+        FileUtils.mkdir_p(autoload_home) if !File.exist?(autoload_home)
+        FileUtils.cp pathogen_vim_path, pathogen_path
+      end
+
+      def init_bundle_file
+        FileUtils.cp bundle_template_file_path, bundle_file_path
+        STDOUT.puts <<-EOF
+
+  Writing new BundleFile to #{self.bundle_file_path}. 
+
+  You can add more plugins by modify this file
+        EOF
+      end
+    end 
+  end
+end

data/lib/vim-jar/installer/base.rb

@@ -0,0 +1,9 @@
+module Vim
+  module Jar 
+    module Installer  
+      class Base 
+      end
+    end
+  end
+end
+

data/lib/vim-jar/installer/git.rb

@@ -0,0 +1,66 @@
+module Vim
+  module Jar
+    module Installer
+      module Git
+        extend self
+
+        def install_to(source, output_path)
+          Dir.chdir(config.vim_home) do
+            system("git submodule add #{source} #{Pathname.new(output_path).relative_path_from(config.vim_home)}")
+            system("git submodule init")
+          end
+        end
+
+        def uninstall_for(name)
+          remove_ref_from_gitmodules(name)
+          remove_ref_from_git_config(name)
+          remove_from_cache(name)
+        end
+
+        def remove_from_cache(name)
+          Dir.chdir(config.vim_home) do
+            system("git rm -r --cached bundle/#{name}")
+          end
+        end
+
+        def remove_ref_from_gitmodules(name)
+          #TODO bundle name is different to submodule name
+          f     = File.new(config.gitmodules_file_path)
+          lines = f.lines.to_a
+          lines.delete_if do |x|
+            x =~ /bundle\/#{name}/ || x =~ /#{name}\.git$/
+          end
+          f.close
+
+          File.open(config.gitmodules_file_path, "w") do |ff|
+            lines.each do |l|
+              ff.puts l
+            end
+          end
+        end
+
+        def remove_ref_from_git_config(name)
+          #TODO bundle name is different to submodule name
+          f     = File.new(config.gitconfig_file_path)
+          lines = f.lines.to_a
+          lines.delete_if do |x|
+            x =~ /bundle\/#{name}/ || x =~ /#{name}\.git$/
+          end
+          f.close
+
+          File.open(config.gitconfig_file_path, "w") do |ff|
+            lines.each do |l|
+              ff.puts l
+            end
+          end
+        end
+
+        def config
+          ::Vim::Jar::Config.instance
+        end
+      end
+    end
+  end
+end
+
+

data/lib/vim-jar/installer.rb

@@ -0,0 +1,7 @@
+module Vim
+  module Jar 
+     module Installer 
+      autoload :Git, 'vim-jar/installer/git'
+     end
+  end
+end

data/lib/vim-jar/loader.rb

@@ -0,0 +1,32 @@
+module Vim
+  module Jar
+    class Loader 
+
+      def execute
+        self.instance_eval read_bundle_file
+      end
+
+      def read_bundle_file
+        if File.exist? config.bundle_file_path
+          File.read config.bundle_file_path
+        else
+          raise Vim::Jar::InstallError.new("Can not find BundleFile in #{config.bundle_file_path}")
+        end
+      end
+
+      def plugin(repo_url, args={}) 
+        p = Plugin::Git.new(repo_url)
+        p.install
+      end
+
+      def theme(repo_url, args={})
+
+      end
+
+      def config
+        ::Vim::Jar::Config.instance
+      end
+
+    end
+  end
+end

data/lib/vim-jar/pathogen/pathogen_v1.2.vim

@@ -0,0 +1,139 @@
+" pathogen.vim - path option manipulation
+" Maintainer:   Tim Pope <vimNOSPAM@tpope.org>
+" Version:      1.2
+
+" Install in ~/.vim/autoload (or ~\vimfiles\autoload).
+"
+" API is documented below.
+
+if exists("g:loaded_pathogen") || &cp
+  finish
+endif
+let g:loaded_pathogen = 1
+
+" Split a path into a list.
+function! pathogen#split(path) abort " {{{1
+  if type(a:path) == type([]) | return a:path | endif
+  let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
+  return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
+endfunction " }}}1
+
+" Convert a list to a path.
+function! pathogen#join(...) abort " {{{1
+  if type(a:1) == type(1) && a:1
+    let i = 1
+    let space = ' '
+  else
+    let i = 0
+    let space = ''
+  endif
+  let path = ""
+  while i < a:0
+    if type(a:000[i]) == type([])
+      let list = a:000[i]
+      let j = 0
+      while j < len(list)
+        let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g')
+        let path .= ',' . escaped
+        let j += 1
+      endwhile
+    else
+      let path .= "," . a:000[i]
+    endif
+    let i += 1
+  endwhile
+  return substitute(path,'^,','','')
+endfunction " }}}1
+
+" Convert a list to a path with escaped spaces for 'path', 'tag', etc.
+function! pathogen#legacyjoin(...) abort " {{{1
+  return call('pathogen#join',[1] + a:000)
+endfunction " }}}1
+
+" Remove duplicates from a list.
+function! pathogen#uniq(list) abort " {{{1
+  let i = 0
+  let seen = {}
+  while i < len(a:list)
+    if has_key(seen,a:list[i])
+      call remove(a:list,i)
+    else
+      let seen[a:list[i]] = 1
+      let i += 1
+    endif
+  endwhile
+  return a:list
+endfunction " }}}1
+
+" Returns a hash indicating which filetype features are enabled.
+function! pathogen#filetype() abort " {{{1
+  redir => output
+  silent filetype
+  redir END
+  let result = {}
+  let result.detection = match(output,'detection:ON') >= 0
+  let result.indent = match(output,'indent:ON') >= 0
+  let result.plugin = match(output,'plugin:ON') >= 0
+  return result
+endfunction " }}}1
+
+" \ on Windows unless shellslash is set, / everywhere else.
+function! pathogen#separator() abort " {{{1
+  return !exists("+shellslash") || &shellslash ? '/' : '\'
+endfunction " }}}1
+
+" Convenience wrapper around glob() which returns a list.
+function! pathogen#glob(pattern) abort " {{{1
+  let files = split(glob(a:pattern),"\n")
+  return map(files,'substitute(v:val,"[".pathogen#separator()."/]$","","")')
+endfunction "}}}1
+
+" Like pathogen#glob(), only limit the results to directories.
+function! pathogen#glob_directories(pattern) abort " {{{1
+  return filter(pathogen#glob(a:pattern),'isdirectory(v:val)')
+endfunction "}}}1
+
+" Prepend all subdirectories of path to the rtp, and append all after
+" directories in those subdirectories.
+function! pathogen#runtime_prepend_subdirectories(path) " {{{1
+  let sep    = pathogen#separator()
+  let before = pathogen#glob_directories(a:path.sep."*[^~]")
+  let after  = pathogen#glob_directories(a:path.sep."*[^~]".sep."after")
+  let rtp = pathogen#split(&rtp)
+  let path = expand(a:path)
+  call filter(rtp,'v:val[0:strlen(path)-1] !=# path')
+  let &rtp = pathogen#join(pathogen#uniq(before + rtp + after))
+  return &rtp
+endfunction " }}}1
+
+" For each directory in rtp, check for a subdirectory named dir.  If it
+" exists, add all subdirectories of that subdirectory to the rtp, immediately
+" after the original directory.  If no argument is given, 'bundle' is used.
+" Repeated calls with the same arguments are ignored.
+function! pathogen#runtime_append_all_bundles(...) " {{{1
+  let sep = pathogen#separator()
+  let name = a:0 ? a:1 : 'bundle'
+  let list = []
+  for dir in pathogen#split(&rtp)
+    if dir =~# '\<after$'
+      let list +=  pathogen#glob_directories(substitute(dir,'after$',name.sep.'*[^~]'.sep.'after','')) + [dir]
+    else
+      let list +=  [dir] + pathogen#glob_directories(dir.sep.name.sep.'*[^~]')
+    endif
+  endfor
+  let &rtp = pathogen#join(pathogen#uniq(list))
+  return 1
+endfunction
+
+" }}}1
+
+" Invoke :helptags on all non-$VIM doc directories in runtimepath.
+function! pathogen#helptags() " {{{1
+  for dir in pathogen#split(&rtp)
+    if dir[0 : strlen($VIM)-1] !=# $VIM && isdirectory(dir.'/doc') && (!filereadable(dir.'/doc/tags') || filewritable(dir.'/doc/tags'))
+      helptags `=dir.'/doc'`
+    endif
+  endfor
+endfunction " }}}1
+
+" vim:set ft=vim ts=8 sw=2 sts=2:

data/lib/vim-jar/plugin/git.rb

@@ -0,0 +1,41 @@
+module Vim
+  module Jar 
+    module Plugin
+      class Git
+        include ::Vim::Jar::Installer::Git
+
+        attr_reader :name, :url, :target_path
+
+        def initialize(url, args={}) 
+          if url !~ /(https|git):\/\/github\.com/
+            raise InstallError.new("Not support this git repository #{url}.")
+          end
+          if url !~ /\.git$/ 
+            raise InstallError.new("#{url} is not a valid github repository url.")
+          end
+          if url.split("/").last =~ /(.+?)\.git$/
+            @name = $1
+          else
+            raise InstallError.new("#{url} is not a valid github repository url.")
+          end
+          @url = url
+          @target_path = config.bundle_home.join(name)
+        end
+
+        def install
+          if !File.exist?(target_path) 
+            install_to(url, target_path) 
+          end
+        end
+
+        def uninstall
+          uninstall_for(self.name)
+        end
+
+        def config 
+          ::Vim::Jar::Config.instance
+        end
+      end
+    end
+  end
+end

data/lib/vim-jar/plugin.rb

@@ -0,0 +1,23 @@
+module Vim
+  module Jar
+    module Plugin
+      autoload :Git, 'vim-jar/plugin/git.rb'
+
+      def self.update 
+        Dir.chdir(config.vim_home) do 
+          system("git submodule update")
+        end
+      end
+
+      def self.installed
+        @installed ||= Dir[config.bundle_home.join("*")].map { |bundle_path| File.basename(bundle_path) }
+      end
+
+      def self.config
+        ::Vim::Jar::Config.instance
+      end
+    end
+  end
+end
+
+

data/lib/vim-jar/version.rb

@@ -0,0 +1,5 @@
+module Vim
+  module Jar
+    VERSION = "0.3.0"
+  end
+end

data/lib/vim-jar.rb

@@ -0,0 +1,24 @@
+require 'pathname'
+require 'fileutils'
+require 'yaml'
+require 'thor'
+
+module Vim
+  module Jar
+    autoload :Config, 'vim-jar/config' 
+    autoload :Plugin, 'vim-jar/plugin' 
+    autoload :Installer, 'vim-jar/installer' 
+    autoload :Loader, 'vim-jar/Loader' 
+
+    class InitError < RuntimeError; end
+    class InstallError < RuntimeError; end
+    class ImportError < RuntimeError; end
+
+    class << self 
+      def config 
+        @config ||= Config.instance
+      end
+
+    end    
+  end
+end

data/script/github_crawler.rb

@@ -0,0 +1,76 @@
+require File.expand_path("../lib/vim-jar.rb", File.dirname(__FILE__)) 
+repo_urls = (101..110).map do |n|
+  "https://github.com/vim-scripts/repositories?page=#{n.to_s}"
+end
+
+plugin_urls = []
+CONCURRENY = 20
+curl_repo = Curl::Multi.new
+#curl_plugin = Curl::Multi.new
+
+on_failure_repo = lambda do |ex|
+  puts 'Failure.'
+  puts ex
+end
+
+on_success_repo = lambda do |body|
+  puts "finish "
+  config = ::Vim::Jar::Config.instance
+  body.scan(/<a href=\"(\/vim-scripts\/[\w-]+?)\">/).each do |path|
+    puts "import plugin https://github.com#{path} into #{config.yaml_path}"
+    url = "https://github.com#{path}"
+    name_home_page = ::Vim::Jar::Importer.extract_from_url(url)
+    if !::Vim::Jar::Plugin.exist? name_home_page["name"]
+      other_info = ::Vim::Jar::Importer.extract_from_page_source(url)
+      ::Vim::Jar::Plugin.insert name_home_page.merge!(other_info)
+    end
+  end
+  File.open(config.yaml_path, "w+") do |f|
+    f.puts ::Vim::Jar::Plugin.plugins.to_yaml
+  end
+  repo_urls.pop(CONCURRENY - curl_repo.requests.length).each do |url|
+    c = Curl::Easy.new(url) do|curl|
+      curl.on_body{|data| on_success_repo.call(data) }
+      curl.on_success {|easy| puts "success, add more easy handles" }
+    end
+
+    curl_repo.add(c)
+
+  end
+end
+
+repo_urls.pop(CONCURRENY).each do |url|
+  c = Curl::Easy.new(url) do|curl|
+    curl.on_body{|data| on_success_repo.call(data) }
+    curl.on_success {|easy| puts "success, add more easy handles" }
+  end
+  
+  curl_repo.add(c)
+end
+
+curl_repo.perform
+
+#while curl_repo.size > 0 do 
+  #sleep 0.5
+#end 
+#on_success_repo = lambda do |body|
+#puts body
+#end
+#on_failure_repo = lambda do |ex|
+#puts 'Failure.'
+#puts ex
+#end
+
+
+#curl.get('http://www.example.org/', on_success, on_failure)
+#curl.select([], []) while curl.size > 0
+
+#url = URI.parse("https://github.com/vim-scripts/repositories")
+#http = Net::HTTP.new(url.host, 443)
+#http.use_ssl = true
+#http.get(url.path) do |resp| 
+#resp.scan(/<a href=\"(\/vim-scripts\/[\w-]+?)\">/).each do |path|
+#::Vim::Jar::Importer::import("https://github.com#{path}")
+#end
+#end
+

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+require 'FileUtils'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__),'..','lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__),'formulars'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+ENV['VIM_JAR_USER_HOME'] = File.expand_path("../../tmp", __FILE__)
+
+require 'vim-jar'
+#require 'fakefs/spec_helpers'
+
+RSpec.configure do |config|
+  #config.include FakeFS::SpecHelpers
+  config.before(:each) do 
+    FileUtils.rm_rf ENV["VIM_JAR_USER_HOME"]    
+    FileUtils.mkdir_p ENV["VIM_JAR_USER_HOME"]    
+    FileUtils.touch File.join(ENV["VIM_JAR_USER_HOME"], ".vimrc")
+    FileUtils.mkdir_p File.join(ENV["VIM_JAR_USER_HOME"], ".vim")
+  end
+end
+