vim-jar 0.0.2 → 0.0.3

data/lib/vim-jar/cli.rb

@@ -1,96 +1,113 @@
 require 'vim-jar'
+
 module Vim
   module Jar 
-    class Cli
-      class << self 
-        PATHOGEN_URL = "http://www.vim.org/scripts/download_script.php?src_id=12116"
-        def init 
-          check!
-          setup_pathogen unless File.exist?(config.pathogen_path)
-          done
-        end
+    class Cli < Thor
+      map "-T" => :list
+      PATHOGEN_URL = "http://www.vim.org/scripts/download_script.php?src_id=12116"
+
+      desc "init","init environment"
+      def init 
+        check!
+        setup_pathogen unless File.exist?(config.pathogen_path)
+        done
+      end
 
-        def install(plugin_name)
-          check!
-          plugin = ::Vim::Jar::Plugin.find(plugin_name)
-          if plugin
-            plugin.install 
-          else
-            STDERR.puts "Can not find plugin '#{plugin_name}'"
-            STDERR.puts "you can run 'vim-jar list' to show all the existing plugins"
-            exit 1
-          end
+      desc "install NAME", "install plugin"
+      def install(plugin_name)
+        check!
+        plugin = ::Vim::Jar::Plugin.find(plugin_name)
+        if plugin
+          plugin.install 
+        else
+          STDERR.puts "Can not find plugin '#{plugin_name}'"
+          STDERR.puts "you can run 'vim-jar list' to show all the existing plugins"
+          exit 1
         end
+      end
 
-        def list(options={}) 
-          str = ::Vim::Jar::Plugin.plugins.map do |plugin_attr| 
-            "#{plugin_attr['name']}: #{plugin_attr['desc']}"
-          end.join("\n")
-          STDOUT.puts str
-        end
+      desc "list", "list all avaliable plugins"
+      def list
+        str = ::Vim::Jar::Plugin.plugins.map do |plugin_attr| 
+          "#{plugin_attr['name']}: #{plugin_attr['desc']}"
+        end.join("\n")
+        STDOUT.puts str
+      end
 
-        def import(github_url)
-          begin 
-            ::Vim::Jar::Importer.import(github_url)
-            STDOUT.puts "'#{github_url}' has import to our local cache"
-          rescue ImportError => e 
-            STDERR.puts "Can not import '#{github_url}', because #{e.message}"
-          end
+      desc "import", "import plugin info from github.com"
+      def import(github_url)
+        begin 
+          ::Vim::Jar::Importer.import(github_url)
+          STDOUT.puts "'#{github_url}' has import to our local cache"
+        rescue ImportError => e 
+          STDERR.puts "Can not import '#{github_url}', because #{e.message}"
         end
+      end
 
-        def installed
-          STDOUT.puts ::Vim::Jar::Plugin.installed.join("\n")
-        end
+      desc "installed", "list all installed plugins"
+      def installed
+        STDOUT.puts ::Vim::Jar::Plugin.installed.join("\n")
+      end
 
-        private 
-        def config 
-          @config ||= Vim::Jar.config
+      desc "uninstall", "uninstall installed plugin"
+      def uninstall(name)
+        if ::Vim::Jar::Plugin.installed.include?(name)
+          ::Vim::Jar::Plugin.uninstall(name)
+          STDOUT.puts "plugin #{name} has been already remove from #{config.bundle_home.join(name)}"
+        else
+          STDERR.puts "You didn't install plugin named #{name}"
         end
+        
+      end
 
-        def check!
-          begin 
-            config.check
-          rescue InitError => e
-            STDERR.puts "Can not init environment because of #{e.message}"
-            exit 1
-          end
-        end
+      private 
+      def config 
+        @config ||= Vim::Jar.config
+      end
 
-        def git_init 
-          #TODO will support init git repo 
+      def check!
+        begin 
+          config.check
+        rescue InitError => e
+          STDERR.puts "Can not init environment because of #{e.message}"
+          exit 1
         end
+      end
 
-        def setup_pathogen
-          config = Vim::Jar.config 
-          FileUtils.mkdir_p(config.autoload_home) if !File.exist?(config.autoload_home)
-          install_pathogen(config) 
-        end
+      def git_init 
+        #TODO will support init git repo 
+      end
+
+      def setup_pathogen
+        config = Vim::Jar.config 
+        FileUtils.mkdir_p(config.autoload_home) if !File.exist?(config.autoload_home)
+        install_pathogen(config) 
+      end
+
+      def install_pathogen(config) 
+        system("curl #{PATHOGEN_URL} -o #{config.pathogen_path}")
+        STDOUT.puts <<-EOF
 
-        def install_pathogen(config) 
-          system("curl #{PATHOGEN_URL} -o #{config.pathogen_path}")
-          STDOUT.puts <<-EOF
+  Pathogen is installed into #{config.pathogen_path}. 
 
-Pathogen is installed into #{config.pathogen_path}. 
+  NOTICE: you need copy line below into #{config.vimrc_path}.
 
-NOTICE: you need copy line below into #{config.vimrc_path}.
-  
   call pathogen#runtime_append_all_bundles() 
 
-          EOF
-        end
+        EOF
+      end
 
-        def done 
-          #TODO improve finish message
-          STDOUT.puts <<-EOF
+      def done 
+        #TODO improve finish message
+        STDOUT.puts <<-EOF
 
-Congratulation!  vim-jar already initialized your environment. 
+  Congratulation!  vim-jar already initialized your environment. 
 
-Try:
+  Try:
 
   vim-jar install [PLUGIN_NAME]
 
-          EOF
-        end
+        EOF
       end
     end
   end

data/lib/vim-jar/config.rb

@@ -20,6 +20,14 @@ module Vim
         @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
@@ -36,6 +44,7 @@ module Vim
         @yaml_path ||= File.expand_path("./plugins.yml",File.dirname(__FILE__))
       end
 
+
       def check 
         %w[vim_home vimrc_path].each do |method_name|
           path = self.send(method_name)

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

@@ -1,15 +1,16 @@
 module Vim
-  module Jar 
-    module Installer  
+  module Jar
+    module Installer
       module Git
         def install_to(source, output_path)
-          Dir.chdir(config.vim_home)
-          system("git submodule add #{source} #{Pathname.new(output_path).relative_path_from(config.vim_home)}")
-          system("git submodule init")
+          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 config 
-          ::Vim::Jar::Config.instance 
+        def config
+          ::Vim::Jar::Config.instance
         end
       end
     end

data/lib/vim-jar/plugin.rb

@@ -1,11 +1,11 @@
 module Vim
-  module Jar 
+  module Jar
     module Plugin
       autoload :Git, 'vim-jar/plugin/git.rb'
 
-      def self.find(plugin_name)  
+      def self.find(plugin_name)
         #TODO use sqlite in the future
-        plugin_attrs = plugins.detect{|p| p["name"].to_s.downcase == plugin_name.to_s.downcase } 
+        plugin_attrs = plugins.detect { |p| p["name"].to_s.downcase == plugin_name.to_s.downcase }
         build(plugin_attrs)
       end
 
@@ -14,52 +14,95 @@ module Vim
         if !File.exist? config.yaml_path
           FileUtils.touch config.yaml_path
           @plugins = []
-        else 
-         @plugins = YAML.load_file(config.yaml_path)  || []
+        else
+          @plugins = YAML.load_file(config.yaml_path) || []
         end
         @plugins
       end
 
-      def self.exist? name 
+      def self.exist? name
         #OPTIMIZE
         @exist_list ||= {}
         return @exist_list[name] if @exist_list.has_key? name
-        result = self.plugins.any? {|p| p["name"].strip.downcase == name.strip.downcase} 
+        result            = self.plugins.any? { |p| p["name"].strip.downcase == name.strip.downcase }
         @exist_list[name] = result
         result
       end
 
-      def self.insert(attrs) 
+      def self.insert(attrs)
         #OPTIMIZE
         if self.exist? attrs["name"]
           return false
-        else 
+        else
           self.plugins << attrs
           return true
         end
       end
 
-      def installed
-        @installed ||= Dir[config.bundle_home.join("*")].map { |bundle_path| File.basename(bundle_path)}
+      def self.installed
+        @installed ||= Dir[config.bundle_home.join("*")].map { |bundle_path| File.basename(bundle_path) }
       end
 
-      def self.reset 
+      def self.uninstall(name)
+        remove_ref_from_gitmodules(name)
+        remove_ref_from_git_config(name)
+        remove_from_cache(name)
+      end
+
+      def self.remove_from_cache(name)
+        Dir.chdir(config.vim_home) do
+          system("git rm --cached bundle/#{name}")
+        end
+      end
+
+      def self.remove_ref_from_gitmodules(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 self.remove_ref_from_git_config(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 self.reset
         self.instance_variable_set("@plugins", nil)
         self.plugins
       end
 
-      def self.config 
+      def self.config
         ::Vim::Jar::Config.instance
       end
 
       def self.build(plugin_attrs)
         return nil unless plugin_attrs
-        type = plugin_attrs["type"]  
+        type = plugin_attrs["type"]
         case type
-        when "git" 
-          ::Vim::Jar::Plugin::Git.new(plugin_attrs)
-        else 
-          nil
+          when "git"
+            ::Vim::Jar::Plugin::Git.new(plugin_attrs)
+          else
+            nil
         end
       end
     end

data/lib/vim-jar/version.rb

@@ -1,5 +1,5 @@
 module Vim
   module Jar
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/lib/vim-jar.rb

@@ -2,6 +2,7 @@ require 'pathname'
 require 'fileutils'
 require 'yaml'
 require 'curb'
+require 'thor'
 
 module Vim
   module Jar

data/spec/vim-jar/config_spec.rb

@@ -49,6 +49,23 @@ describe Vim::Jar::Config do
     end
   end
 
+  context ".gitmodules_file_path" do 
+    it "should be in .vim/.gitmodules" do 
+      path = Pathname.new(".")
+      mock(config).vim_home { path }
+      config.gitmodules_file_path.to_s.should == path.join(".gitmodules").to_s
+    end
+  end
+
+  context ".gitconfig_file_path" do
+    it "should be in .vim/.git/config" do
+      path = Pathname.new(".")
+      mock(config).vim_home  { path }
+      config.gitconfig_file_path.to_s.should == path.join(".git/config").to_s
+    end
+  end
+
+
   context ".check" do 
     it "should raise exception if folder check not pass" do 
       mock(File).exist?(anything) { false }

data/spec/vim-jar/git-config

@@ -0,0 +1,16 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+	ignorecase = true
+[remote "origin"]
+	fetch = +refs/heads/*:refs/remotes/origin/*
+	url = git@github.com:allenwei/vim-config.git
+[branch "master"]
+	remote = origin
+	merge = refs/heads/master
+[submodule "bundle/vim-rails"]
+	url = git://github.com/tpope/vim-rails.git
+[submodule "bundle/VimClojure"]
+	url = git://github.com/vim-scripts/VimClojure.git

data/spec/vim-jar/gitmodules

@@ -0,0 +1,6 @@
+[submodule "bundle/vim-cucumber"]
+	path = bundle/vim-cucumber
+	url = git://github.com/tpope/vim-cucumber.git
+[submodule "bundle/vim-afterimage"]
+	path = bundle/vim-afterimage
+	url = git://github.com/tpope/vim-afterimage.git

data/spec/vim-jar/plugin_spec.rb

@@ -36,4 +36,50 @@ describe Vim::Jar::Plugin do
       plugin.url.should == "git://github.com/tpope/vim-rails.git"
     end
   end
+
+  context ".remove_ref_from_gitmodules" do 
+    before(:each) do 
+      @gitmodules_file_path = File.expand_path("./gitmodules", File.dirname(__FILE__))
+      @old_str = File.read @gitmodules_file_path
+      stub(Vim::Jar::Plugin.config).gitmodules_file_path { @gitmodules_file_path }
+    end
+
+    after(:each) do 
+      File.open(@gitmodules_file_path,"w+") do |f|
+        f.puts @old_str
+      end
+    end
+
+    it "should remove lines include plugin name" do 
+      Vim::Jar::Plugin.remove_ref_from_gitmodules("vim-cucumber")
+      new_str = File.read @gitmodules_file_path 
+      new_str.split("\n").should have(3).items
+    end
+  end
+
+
+  context ".remove_ref_from_gitmodules" do
+    before(:each) do
+      @gitconfig_file_path = File.expand_path("./git-config", File.dirname(__FILE__))
+      @old_str = File.read @gitconfig_file_path
+      stub(Vim::Jar::Plugin.config).gitconfig_file_path { @gitconfig_file_path }
+    end
+
+    after(:each) do
+      File.open(@gitconfig_file_path, "w+") do |f|
+        f.puts @old_str
+      end
+    end
+
+    it "should remove lines include plugin name" do
+      Vim::Jar::Plugin.remove_ref_from_git_config("vim-rails")
+      new_str = File.read @gitconfig_file_path
+      new_str.should match /\[core\]/
+      new_str.should match /\[remote \"origin\"\]/
+      new_str.should match /\[branch \"master\"\]/
+      new_str.should match /\[submodule \"bundle\/VimClojure\"\]/
+      new_str.should_not match /vim-rails/
+    end
+  end
+
 end

data/vim-jar.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_runtime_dependency('curb')
+  s.add_runtime_dependency('thor')
   s.add_development_dependency('rspec')
   s.add_development_dependency('rr')
   s.add_development_dependency('fuubar')