vim-flavor 0.0.4 → 1.0.0

data/features/typical_usage/uninstall_vim_plugins.feature

@@ -0,0 +1,31 @@
+@typical_usage
+Feature: Uninstall Vim plugins
+  In order to automate boring steps,
+  as a lazy Vim user,
+  I want to use a declarative way to delete Vim plugins from my configuration.
+
+  Background:
+    Given a temporary directory called 'tmp'
+    And a home directory called 'home' in '$tmp/home'
+    And a repository 'foo' with versions '1.0.0 1.0.1 1.0.2'
+    And a repository 'bar' with versions '2.0.0 2.0.1 2.0.2'
+
+  Scenario: Install after deleting some flavors in flavorfile
+    Given flavorfile
+      """ruby
+      flavor '$foo_uri'
+      flavor '$bar_uri'
+      """
+    And I run `vim-flavor install`
+    When I edit flavorfile as
+      """ruby
+      flavor '$bar_uri'
+      """
+    And I run `vim-flavor install` again
+    Then I get lockfile
+      """
+      $bar_uri (2.0.2)
+      """
+    And I get a bootstrap script in '$home/.vim'
+    And I get flavor '$bar_uri' with '2.0.2' in '$home/.vim'
+    But I don't have flavor '$foo_uri' in '$home/.vim'

data/features/typical_usage/upgrade_vim_plugins.feature

@@ -0,0 +1,27 @@
+@typical_usage
+Feature: Upgrade Vim plugins
+  In order to automate boring steps,
+  as a lazy Vim user,
+  I want to use a declarative way to upgrade my favorite Vim plugins.
+
+  Background:
+    Given a temporary directory called 'tmp'
+    And a home directory called 'home' in '$tmp/home'
+    And a repository 'foo' with versions '1.0.0 1.0.1 1.0.2'
+
+  Scenario: Upgrade with lockfile
+    Given flavorfile
+      """ruby
+      flavor '$foo_uri'
+      """
+    And lockfile
+      """
+      $foo_uri (1.0.0)
+      """
+    When I run `vim-flavor upgrade`
+    Then I get lockfile
+      """
+      $foo_uri (1.0.2)
+      """
+    And I get a bootstrap script in '$home/.vim'
+    And I get flavor '$foo_uri' with '1.0.2' in '$home/.vim'

data/features/uninstall_vim_flavor.md

@@ -0,0 +1,16 @@
+## Uninstallation steps
+
+    rm -r ~/.vim-flavor
+    rm -r ~/.vim/flavors  # or ~/vimfiles/flavors etc.
+
+    cd $YOUR_REPOSITORY_FOR_DOTFILES
+    rm VimFlavor VimFlavor.lock
+    vim vimrc  # Remove the "runtime flavors/bootstrap.vim" line.
+    git commit -am 'Farewell to vim-flavor'
+
+    gem uninstall vim-flavor
+
+
+
+
+<!-- vim: set expandtab shiftwidth=4 softtabstop=4 textwidth=78 : -->

data/features/version_lock.feature

@@ -0,0 +1,26 @@
+Feature: Version lock
+  In order to use the same configuration on every machine,
+  as a lazy Vim user,
+  I want to keep versions of Vim plugins which I installed before.
+
+  Background:
+    Given a temporary directory called 'tmp'
+    And a home directory called 'home' in '$tmp/home'
+    And a repository 'foo' with versions '1.0.0 1.0.1 1.0.2'
+
+  Scenario: Install with lockfile
+    Given flavorfile
+      """ruby
+      flavor '$foo_uri'
+      """
+    And lockfile
+      """
+      $foo_uri (1.0.0)
+      """
+    When I run `vim-flavor install`
+    Then I get lockfile
+      """
+      $foo_uri (1.0.0)
+      """
+    And I get a bootstrap script in '$home/.vim'
+    And I get flavor '$foo_uri' with '1.0.0' in '$home/.vim'

data/lib/vim-flavor.rb

@@ -1,4 +1,5 @@
 require 'bundler/setup'
+require 'vim-flavor/enumerableextension'
 
 module Vim
   module Flavor
@@ -8,6 +9,7 @@ module Vim
       :Flavor,
       :FlavorFile,
       :LockFile,
+      :LockFileParser,
       :StringExtension,
       :VERSION,
       :VersionConstraint,
@@ -18,17 +20,5 @@ module Vim
     class ::String
       include StringExtension
     end
-
-    class << self
-      @@dot_path = File.expand_path('~/.vim-flavor')
-
-      def dot_path
-        @@dot_path
-      end
-
-      def dot_path= path
-        @@dot_path = path
-      end
-    end
   end
 end

data/lib/vim-flavor/cli.rb

@@ -5,25 +5,29 @@ module Vim
     class CLI < Thor
       desc 'install', 'Install Vim plugins according to VimFlavor file.'
       method_option :vimfiles_path,
-        :desc => 'A path to your vimfiles directory.'
-      def install()
-        facade = Facade.new()
-        facade.traced = true
-        facade.install(
-          options[:vimfiles_path] || facade.get_default_vimfiles_path()
+        :desc => 'Where to install Vim plugins.',
+        :banner => 'DIR'
+      def install
+        Facade.new().install(
+          options[:vimfiles_path] || default_vimfiles_path
         )
       end
 
       desc 'upgrade', 'Upgrade Vim plugins according to VimFlavor file.'
       method_option :vimfiles_path,
-        :desc => 'A path to your vimfiles directory.'
-      def upgrade()
-        facade = Facade.new()
-        facade.traced = true
-        facade.upgrade(
-          options[:vimfiles_path] || facade.get_default_vimfiles_path()
+        :desc => 'Where to install Vim plugins.',
+        :banner => 'DIR'
+      def upgrade
+        Facade.new().upgrade(
+          options[:vimfiles_path] || default_vimfiles_path
         )
       end
+
+      no_tasks do
+        def default_vimfiles_path
+          ENV['HOME'].to_vimfiles_path
+        end
+      end
     end
   end
 end

data/lib/vim-flavor/enumerableextension.rb

@@ -0,0 +1,48 @@
+module Vim
+  module Flavor
+    EnumerableExtension = ::Enumerable
+
+    module EnumerableExtension
+      def before_each(&block)
+        vs = each
+        Enumerator.new do |y|
+          loop do
+            v = vs.next
+            block.call(v)
+            y << v
+          end
+        end
+      end
+
+      def after_each(&block)
+        vs = each
+        Enumerator.new do |y|
+          loop do
+            v = vs.next
+            y << v
+            block.call(v)
+          end
+        end
+      end
+
+      def on_failure(&block)
+        vs = each
+        Enumerator.new do |y|
+          v = nil
+          begin
+            loop do
+              v = vs.next
+              y << v
+              v = nil
+            end
+          rescue StopIteration
+            raise
+          rescue
+            block.call(v)
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vim-flavor/facade.rb

@@ -3,56 +3,85 @@ require 'fileutils'
 module Vim
   module Flavor
     class Facade
-      attr_reader :flavorfile
-      attr_accessor :flavorfile_path
-      attr_reader :lockfile
-      attr_accessor :lockfile_path
-      attr_accessor :traced
-
-      def initialize()
-        @flavorfile = nil  # FlavorFile
-        @flavorfile_path = "#{Dir.getwd()}/VimFlavor"
-        @lockfile = nil  # LockFile
-        @lockfile_path = "#{Dir.getwd()}/VimFlavor.lock"
-        @traced = false
+      def trace message
+        print message
       end
 
-      def trace(message)
-        print(message) if @traced
+      def refresh_flavors(mode, vimfiles_path)
+        flavorfile = FlavorFile.load(Dir.getwd().to_flavorfile_path)
+        lockfile = LockFile.load_or_new(Dir.getwd().to_lockfile_path)
+
+        lockfile.update(
+          complete(
+            flavorfile.flavor_table,
+            lockfile.flavor_table,
+            mode
+          )
+        )
+        lockfile.save()
+
+        deploy_flavors(lockfile.flavors, vimfiles_path)
+
+        trace "Completed.\n"
       end
 
-      def load()
-        @flavorfile = FlavorFile.new()
-        @flavorfile.eval_flavorfile(@flavorfile_path)
+      def install(vimfiles_path)
+        refresh_flavors(:install, vimfiles_path)
+      end
 
-        @lockfile = LockFile.new(@lockfile_path)
-        @lockfile.load() if File.exists?(@lockfile_path)
+      def upgrade(vimfiles_path)
+        refresh_flavors(:upgrade, vimfiles_path)
       end
 
-      def make_new_flavors(current_flavors, locked_flavors, mode)
-        new_flavors = {}
+      def complete(current_flavor_table, locked_flavor_table, mode)
+        completed_flavor_table = {}
+
+        trace "Checking versions...\n"
+
+        current_flavor_table.values.map(&:dup).sort_by(&:repo_name).
+        before_each {|nf| trace "  Use #{nf.repo_name} ..."}.
+        after_each {|nf| trace " #{nf.locked_version}\n"}.
+        on_failure {trace " failed\n"}.
+        each do |nf|
+          lf = locked_flavor_table[nf.repo_name]
 
-        current_flavors.each do |repo_uri, cf|
-          lf = locked_flavors[repo_uri]
-          nf = cf.dup()
+          already_cached = nf.cached?
+          nf.clone() unless already_cached
 
-          nf.locked_version =
-            if (not lf) or
-              cf.version_contraint != lf.version_contraint or
-              mode == :update then
-              cf.locked_version
-            else
-              lf.locked_version
-            end
+          if mode == :install and lf and nf.satisfied_with?(lf)
+            nf.use_specific_version(lf.locked_version)
+          else
+            nf.fetch() if already_cached
+            nf.use_appropriate_version()
+          end
 
-          new_flavors[repo_uri] = nf
+          completed_flavor_table[nf.repo_name] = nf
         end
 
-        new_flavors
+        completed_flavor_table
+      end
+
+      def deploy_flavors(flavors, vimfiles_path)
+        trace "Deploying plugins...\n"
+
+        FileUtils.rm_rf(
+          ["#{vimfiles_path.to_flavors_path}"],
+          :secure => true
+        )
+
+        create_vim_script_for_bootstrap(vimfiles_path)
+
+        flavors.
+        before_each {|f| trace "  #{f.repo_name} #{f.locked_version} ..."}.
+        after_each {|f| trace " done\n"}.
+        on_failure {trace " failed\n"}.
+        each do |f|
+          f.deploy(vimfiles_path)
+        end
       end
 
       def create_vim_script_for_bootstrap(vimfiles_path)
-        bootstrap_path = "#{vimfiles_path.to_flavors_path()}/bootstrap.vim"
+        bootstrap_path = vimfiles_path.to_flavors_path.to_bootstrap_path
         FileUtils.mkdir_p(File.dirname(bootstrap_path))
         File.open(bootstrap_path, 'w') do |f|
           f.write(<<-'END')
@@ -84,73 +113,7 @@ module Vim
           END
         end
       end
-
-      def deploy_flavors(flavor_list, vimfiles_path)
-        FileUtils.rm_rf(
-          ["#{vimfiles_path.to_flavors_path()}"],
-          :secure => true
-        )
-
-        create_vim_script_for_bootstrap(vimfiles_path)
-        flavor_list.each do |f|
-          trace("Deploying #{f.repo_name} (#{f.locked_version})\n")
-          f.deploy(vimfiles_path)
-        end
-      end
-
-      def save_lockfile()
-        @lockfile.save()
-      end
-
-      def complete_locked_flavors(mode)
-        nfs = {}
-        @flavorfile.flavors.each do |repo_uri, cf|
-          nf = cf.dup()
-          lf = @lockfile.flavors[repo_uri]
-
-          trace("Using #{nf.repo_name} ... ")
-          begin
-            if not File.exists?(nf.cached_repo_path)
-              nf.clone()
-            end
-
-            if mode == :upgrade_all or
-              (not lf) or
-              nf.version_contraint != lf.version_contraint then
-              nf.fetch()
-              nf.update_locked_version()
-            else
-              nf.locked_version = lf.locked_version
-            end
-          end
-          trace("(#{nf.locked_version})\n")
-
-          nfs[repo_uri] = nf
-        end
-
-        @lockfile.instance_eval do
-          @flavors = nfs
-        end
-      end
-
-      def get_default_vimfiles_path()
-        # FIXME: Compute more appropriate value.
-        "#{ENV['HOME']}/.vim"
-      end
-
-      def install(vimfiles_path)
-        load()
-        complete_locked_flavors(:upgrade_if_necessary)
-        save_lockfile()
-        deploy_flavors(lockfile.flavors.values, vimfiles_path)
-      end
-
-      def upgrade(vimfiles_path)
-        load()
-        complete_locked_flavors(:upgrade_all)
-        save_lockfile()
-        deploy_flavors(lockfile.flavors.values, vimfiles_path)
-      end
     end
   end
 end
+

data/lib/vim-flavor/flavor.rb

@@ -1,118 +1,125 @@
 module Vim
   module Flavor
     class Flavor
-      @@properties = [
-        :groups,
-        :locked_version,
-        :repo_name,
-        :repo_uri,
-        :version_contraint,
-      ]
-
-      @@properties.each do |p|
-        attr_accessor p
-      end
+      # A short name of a repository.
+      # Possible formats are "$user/$repo", "$repo" and "$repo_uri".
+      attr_accessor :repo_name
 
-      def initialize()
-        @groups = []
-      end
+      # A constraint to choose a proper version.
+      attr_accessor :version_constraint
 
-      def ==(other)
-        return false if self.class != other.class
-        @@properties.all? do |p|
-          self.send(p) == other.send(p)
-        end
-      end
+      # A version of a plugin to be installed.
+      attr_accessor :locked_version
 
-      def zapped_repo_dir_name
-        @repo_name.gsub(/[^A-Za-z0-9._-]/, '_')
+      # Return true if this flavor's repository is already cloned.
+      def cached?
+        Dir.exists?(cached_repo_path)
       end
 
       def cached_repo_path
         @cached_repo_path ||=
-          "#{Vim::Flavor.dot_path}/repos/#{zapped_repo_dir_name}"
+          "#{ENV['HOME'].to_stash_path}/repos/#{@repo_name.zap}"
       end
 
-      def make_deploy_path(vimfiles_path)
-        "#{vimfiles_path.to_flavors_path()}/#{zapped_repo_dir_name}"
+      def self.github_repo_uri(user, repo)
+        @github_repo_uri ||= lambda {|user, repo|
+          "git://github.com/#{user}/#{repo}.git"
+        }
+        @github_repo_uri.call(user, repo)
+      end
+
+      def repo_uri
+        @repo_uri ||=
+          if /^([^\/]+)$/.match(repo_name)
+            m = Regexp.last_match
+            self.class.github_repo_uri('vim-scripts', m[1])
+          elsif /^([A-Za-z0-9_-]+)\/(.*)$/.match(repo_name)
+            m = Regexp.last_match
+            self.class.github_repo_uri(m[1], m[2])
+          elsif /^[a-z]+:\/\/.*$/.match(repo_name)
+            repo_name
+          else
+            raise "Invalid repo_name: #{repo_name.inspect}"
+          end
       end
 
       def clone()
-        message = %x[
+        sh %Q[
           {
-            git clone '#{@repo_uri}' '#{cached_repo_path}'
+            git clone '#{repo_uri}' '#{cached_repo_path}'
           } 2>&1
         ]
-        if $? != 0 then
-          raise RuntimeError, message
-        end
         true
       end
 
       def fetch()
-        message = %x[
+        sh %Q{
           {
-            cd #{cached_repo_path.inspect} &&
-            git fetch origin
+            cd '#{cached_repo_path}' &&
+            git fetch --tags
           } 2>&1
-        ]
-        if $? != 0 then
-          raise RuntimeError, message
-        end
+        }
       end
 
       def deploy(vimfiles_path)
-        deploy_path = make_deploy_path(vimfiles_path)
-        message = %x[
+        deployment_path = "#{vimfiles_path.to_flavors_path}/#{repo_name.zap}"
+        sh %Q[
           {
             cd '#{cached_repo_path}' &&
             git checkout -f '#{locked_version}' &&
-            git checkout-index -a -f --prefix='#{deploy_path}/' &&
+            git checkout-index -a -f --prefix='#{deployment_path}/' &&
             {
               vim -u NONE -i NONE -n -N -e -s -c '
-                silent! helptags #{deploy_path}/doc
+                silent! helptags #{deployment_path}/doc
                 qall!
               ' || true
             }
           } 2>&1
         ]
-        if $? != 0 then
-          raise RuntimeError, message
-        end
+        true
       end
 
-      def undeploy(vimfiles_path)
-        deploy_path = make_deploy_path(vimfiles_path)
-        message = %x[
-          {
-            rm -fr '#{deploy_path}'
-          } 2>&1
-        ]
-        if $? != 0 then
-          raise RuntimeError, message
-        end
+      def use_appropriate_version()
+        @locked_version =
+          version_constraint.find_the_best_version(list_versions)
       end
 
-      def list_versions()
-        tags = %x[
+      def use_specific_version(locked_version)
+        @locked_version = locked_version
+      end
+
+      def list_tags()
+        output = sh %Q[
           {
             cd '#{cached_repo_path}' &&
             git tag
           } 2>&1
         ]
-        if $? != 0 then
-          raise RuntimeError, message
-        end
+        output.split(/[\r\n]/)
+      end
 
+      def versions_from_tags(tags)
         tags.
-          split(/[\r\n]/).
           select {|t| t != '' && Gem::Version.correct?(t)}.
           map {|t| Gem::Version.create(t)}
       end
 
-      def update_locked_version()
-        @locked_version =
-          version_contraint.find_the_best_version(list_versions())
+      def list_versions()
+        versions_from_tags(list_tags())
+      end
+
+      def sh script
+        output = send(:`, script)
+        if $? == 0
+          output
+        else
+          raise RuntimeError, output
+        end
+      end
+
+      def satisfied_with?(locked_flavor)
+        repo_name == locked_flavor.repo_name &&
+          version_constraint.compatible?(locked_flavor.locked_version)
       end
     end
   end