vim-flavor 0.0.4 → 1.0.0

data/lib/vim-flavor/flavorfile.rb

@@ -1,61 +1,29 @@
 module Vim
   module Flavor
     class FlavorFile
-      attr_reader :flavors
-
-      def initialize()
-        @flavors = {}
-        @default_groups = [:default]
-      end
-
-      def interpret(&block)
-        instance_eval(&block)
+      # repo_name -> flavor
+      def flavor_table
+        @flavor_table ||= {}
       end
 
-      def eval_flavorfile(flavorfile_path)
-        content = File.open(flavorfile_path, 'rb') do |f|
-          f.read()
-        end
-        interpret do
-          instance_eval(content)
-        end
+      def self.load(flavorfile_path)
+        ff = new()
+        ff.load(flavorfile_path)
+        ff
       end
 
-      def repo_uri_from_repo_name(repo_name)
-        if /^([^\/]+)$/.match(repo_name) then
-          m = Regexp.last_match
-          "git://github.com/vim-scripts/#{m[1]}.git"
-        elsif /^([A-Za-z0-9_-]+)\/(.*)$/.match(repo_name) then
-          m = Regexp.last_match
-          "git://github.com/#{m[1]}/#{m[2]}.git"
-        elsif /^[a-z]+:\/\/.*$/.match(repo_name) then
-          repo_name
-        else
-          raise "repo_name is written in invalid format: #{repo_name.inspect}"
-        end
+      def load(flavorfile_path)
+        instance_eval(
+          File.open(flavorfile_path, 'r').read(),
+          flavorfile_path
+        )
       end
 
-      def flavor(repo_name, *args)
-        options = Hash === args.last ? args.pop : {}
-        options[:groups] ||= []
-        version_contraint = VersionConstraint.new(args.last || '>= 0')
-
+      def flavor(repo_name, version_constraint='>= 0')
         f = Flavor.new()
         f.repo_name = repo_name
-        f.repo_uri = repo_uri_from_repo_name(repo_name)
-        f.version_contraint = version_contraint
-        f.groups = @default_groups + options[:groups]
-
-        @flavors[f.repo_uri] = f
-      end
-
-      def group(*group_names, &block)
-        @default_groups.concat(group_names)
-        yield
-      ensure
-        group_names.each do
-          @default_groups.pop()
-        end
+        f.version_constraint = VersionConstraint.new(version_constraint)
+        flavor_table[f.repo_name] = f
       end
     end
   end

data/lib/vim-flavor/lockfile.rb

@@ -1,63 +1,46 @@
-require 'yaml'
-
 module Vim
   module Flavor
     class LockFile
-      # TODO: Resolve dependencies recursively.
-
-      attr_reader :flavors, :path
+      def self.load_or_new(lockfile_path)
+        l = new(lockfile_path)
+        l.load() if File.exists?(lockfile_path)
+        l
+      end
 
       def initialize(path)
-        @flavors = {}  # repo_uri => flavor
         @path = path
       end
 
-      def load()
-        h = File.open(@path, 'rb') do |f|
-          YAML.load(f.read())
-        end
-
-        @flavors = self.class.flavors_from_poro(h[:flavors])
+      def flavor_table
+        @flavor_table ||= {}
       end
 
-      def save()
-        h = {}
+      def flavors
+        flavor_table.values.sort_by {|f| f.repo_name}
+      end
 
-        h[:flavors] = self.class.poro_from_flavors(@flavors)
+      def load()
+        s = File.open(@path, 'r') {|io| io.read()}
+        @flavor_table =
+          Hash[LockFileParser.parse(s).map {|f| [f.repo_name, f]}]
+      end
 
-        File.open(@path, 'wb') do |f|
-          YAML.dump(h, f)
-        end
+      def update(completed_flavor_table)
+        @flavor_table = completed_flavor_table
       end
 
-      def self.poro_from_flavors(flavors)
-        Hash[
-          flavors.values.map {|f|
-            [
-              f.repo_uri,
-              {
-                :groups => f.groups,
-                :locked_version => f.locked_version.to_s(),
-                :repo_name => f.repo_name,
-                :version_contraint => f.version_contraint.to_s(),
-              }
-            ]
-          }
-        ]
+      def self.serialize_lock_status(flavor)
+        ["#{flavor.repo_name} (#{flavor.locked_version})"]
       end
 
-      def self.flavors_from_poro(poro)
-        Hash[
-          poro.to_a().map {|repo_uri, h|
-            f = Flavor.new()
-            f.groups = h[:groups]
-            f.locked_version = Gem::Version.create(h[:locked_version])
-            f.repo_name = h[:repo_name]
-            f.repo_uri = repo_uri
-            f.version_contraint = VersionConstraint.new(h[:version_contraint])
-            [f.repo_uri, f]
-          }
-        ]
+      def save()
+        File.open(@path, 'w') do |io|
+          lines = flavors.flat_map {|f| self.class.serialize_lock_status(f)}
+          lines.each do |line|
+            io.write(line)
+            io.write("\n")
+          end
+        end
       end
     end
   end

data/lib/vim-flavor/lockfileparser.rb

@@ -0,0 +1,65 @@
+require 'parslet'
+
+module Vim
+  module Flavor
+    class LockFileParser
+      def self.parse(s)
+        Transformer.new.apply(Parser.new().parse(s))[:lockfile]
+      end
+
+      class Parser < Parslet::Parser
+        root(:lockfile)
+
+        rule(:lockfile) {
+          space? >> newline.maybe >>
+          (
+            (
+              flavor >> (newline | eof)
+            ).repeat(0).as(:lockfile)
+          )
+        }
+
+        rule(:flavor) {
+          (
+            space? >>
+            repo_name >> space? >>
+            str('(') >> space? >>
+            locked_version >> space? >>
+            str(')') >> space?
+          ).as(:flavor)
+        }
+
+        rule(:repo_name) {
+          (
+            match('\w') >>
+            match('[^ \t()]').repeat(0)
+          ).as(:repo_name)
+        }
+        rule(:locked_version) {
+          (
+            match('[\d.]').repeat(1)
+          ).as(:locked_version)
+        }
+
+        rule(:space) {match('[ \t]').repeat(1)}
+        rule(:space?) {space.maybe}
+        rule(:newline) {match('[\r\n]').repeat(1)}
+        rule(:eof) {any.absent?}
+      end
+
+      class Transformer < Parslet::Transform
+        rule(
+          :flavor => {
+            :repo_name => simple(:repo_name),
+            :locked_version => simple(:locked_version),
+          }
+        ) {
+          f = Flavor.new()
+          f.repo_name = repo_name.to_s
+          f.locked_version = locked_version.to_s
+          f
+        }
+      end
+    end
+  end
+end

data/lib/vim-flavor/stringextension.rb

@@ -1,9 +1,33 @@
 module Vim
   module Flavor
     module StringExtension
-      def to_flavors_path()
+      def to_bootstrap_path
+        "#{self}/bootstrap.vim"
+      end
+
+      def to_flavorfile_path
+        "#{self}/VimFlavor"
+      end
+
+      def to_flavors_path
         "#{self}/flavors"
       end
+
+      def to_lockfile_path
+        "#{self}/VimFlavor.lock"
+      end
+
+      def to_stash_path
+        "#{self}/.vim-flavor"
+      end
+
+      def to_vimfiles_path
+        "#{self}/.vim"
+      end
+
+      def zap
+        gsub(/[^A-Za-z0-9._-]/, '_')
+      end
     end
   end
 end

data/lib/vim-flavor/version.rb

@@ -1,5 +1,5 @@
 module Vim
   module Flavor
-    VERSION = '0.0.4'
+    VERSION = '1.0.0'
   end
 end

data/lib/vim-flavor/versionconstraint.rb

@@ -1,24 +1,27 @@
 module Vim
   module Flavor
     class VersionConstraint
-      attr_reader :base_version, :operator
+      attr_reader :base_version
+
+      # Specifies how to choose a suitable version according to base_version.
+      attr_reader :qualifier
 
       def initialize(s)
-        @base_version, @operator = parse(s)
+        @base_version, @qualifier = self.class.parse(s)
       end
 
       def to_s()
-        "#{@operator} #{@base_version}"
+        "#{qualifier} #{base_version}"
       end
 
       def ==(other)
         self.base_version == other.base_version &&
-          self.operator == other.operator
+          self.qualifier == other.qualifier
       end
 
-      def parse(s)
+      def self.parse(s)
         m = /^\s*(>=|~>)\s+(\S+)$/.match(s)
-        if m then
+        if m
           [Gem::Version.create(m[2]), m[1]]
         else
           raise "Invalid version constraint: #{s.inspect}"
@@ -27,9 +30,9 @@ module Vim
 
       def compatible?(other_version_or_s)
         v = Gem::Version.create(other_version_or_s)
-        if @operator == '~>' then
+        if qualifier == '~>'
           self.base_version.bump() > v and v >= self.base_version
-        elsif @operator == '>=' then
+        elsif qualifier == '>='
           v >= self.base_version
         else
           raise NotImplementedError
@@ -39,9 +42,7 @@ module Vim
       def find_the_best_version(versions)
         versions.
           select {|v| compatible?(v)}.
-          sort().
-          reverse().
-          first
+          max()
       end
     end
   end

data/spec/enumerableextension_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+module Vim
+  module Flavor
+    describe EnumerableExtension do
+      describe '#before_each' do
+        it 'runs a given block before enumerating each element' do
+          xs = []
+          [1, 2, 3].
+          before_each {|n| xs << "before_each #{n}"}.
+          each do |n|
+            xs << "each #{n}"
+          end
+
+          xs.should == [
+            "before_each 1",
+            "each 1",
+            "before_each 2",
+            "each 2",
+            "before_each 3",
+            "each 3",
+          ]
+        end
+      end
+
+      describe '#after_each' do
+        it 'runs a given block after enumerating each element' do
+          xs = []
+          [1, 2, 3].
+          after_each {|n| xs << "after_each #{n}"}.
+          each do |n|
+            xs << "each #{n}"
+          end
+
+          xs.should == [
+            "each 1",
+            "after_each 1",
+            "each 2",
+            "after_each 2",
+            "each 3",
+            "after_each 3",
+          ]
+        end
+      end
+
+      describe '#on_failure' do
+        it 'runs a given block if a core block raises an exception' do
+          xs = []
+
+          expect {
+            [1, 2, 3].
+            on_failure {|n| xs << "on_failure #{n}"}.
+            each do |n|
+              xs << "each enter #{n}"
+              raise RuntimeError, "bang! #{n}" if 2 < n
+              xs << "each leave #{n}"
+            end
+          }.to raise_error(RuntimeError, 'bang! 3')
+
+          xs.should == [
+            "each enter 1",
+            "each leave 1",
+            "each enter 2",
+            "each leave 2",
+            "each enter 3",
+            "on_failure 3",
+          ]
+        end
+
+        it 'runs a given block with null if a yielder raises an exception' do
+          xs = []
+          e = Object.new()
+          def e.each
+            yield 1
+            yield 2
+            raise RuntimeError, 'bang!'
+            yield 3
+          end
+
+          expect {
+            e.to_enum.
+            on_failure {|n| xs << "on_failure #{n.class}"}.
+            each do |n|
+              xs << "each enter #{n}"
+              xs << "each leave #{n}"
+            end
+          }.to raise_error(RuntimeError, 'bang!')
+
+          xs.should == [
+            "each enter 1",
+            "each leave 1",
+            "each enter 2",
+            "each leave 2",
+            "on_failure #{nil.class}",
+          ]
+        end
+      end
+    end
+  end
+end

data/spec/facade_spec.rb

@@ -1,548 +1,57 @@
-require 'bundler/setup'
 require 'fileutils'
 require 'spec_helper'
-require 'vim-flavor'
-
-describe Vim::Flavor::Facade do
-  describe '#initialize' do
-    it 'should have proper values by default' do
-      facade = described_class.new()
-      facade.flavorfile.should == nil
-      facade.flavorfile_path.should == "#{Dir.getwd()}/VimFlavor"
-      facade.lockfile.should == nil
-      facade.lockfile_path.should == "#{Dir.getwd()}/VimFlavor.lock"
-    end
-  end
-
-  describe '#load' do
-    with_temporary_directory
-
-    before :each do
-      @facade = described_class.new()
-      @facade.flavorfile_path = "#{@tmp_path}/VimFlavor"
-      @facade.lockfile_path = "#{@tmp_path}/VimFlavor.lock"
-
-      @flavor1 = Vim::Flavor::Flavor.new()
-      @flavor1.groups = [:default]
-      @flavor1.repo_name = 'kana/vim-smartinput'
-      @flavor1.repo_uri = 'git://github.com/kana/vim-smartinput.git'
-      @flavor1.version_contraint =
-        Vim::Flavor::VersionConstraint.new('>= 0')
-      @flavor1d = @flavor1.dup()
-      @flavor1d.locked_version = Gem::Version.create('1.2.3')
-      @flavor2 = Vim::Flavor::Flavor.new()
-      @flavor2.groups = [:default]
-      @flavor2.repo_name = 'kana/vim-smarttill'
-      @flavor2.repo_uri = 'git://github.com/kana/vim-smarttill.git'
-      @flavor2.version_contraint =
-        Vim::Flavor::VersionConstraint.new('>= 0')
-      @flavor2d = @flavor2.dup()
-      @flavor2d.locked_version = Gem::Version.create('4.5.6')
-
-      File.open(@facade.flavorfile_path, 'w') do |f|
-        f.write(<<-'END')
-          flavor 'kana/vim-smartinput'
-          flavor 'kana/vim-smarttill'
-        END
-      end
-      File.open(@facade.lockfile_path, 'w') do |f|
-        f.write(<<-'END')
-          :flavors:
-            git://github.com/kana/vim-smartinput.git:
-              :groups:
-                - :default
-              :locked_version: 1.2.3
-              :repo_name: kana/vim-smartinput
-              :version_contraint: >= 0
-        END
-      end
-    end
-
-    it 'should load both files' do
-      @facade.load()
-
-      @facade.flavorfile_path.should == "#{@tmp_path}/VimFlavor"
-      @facade.lockfile_path.should == "#{@tmp_path}/VimFlavor.lock"
-      @facade.flavorfile.flavors.keys.length == 2
-      @facade.flavorfile.flavors[@flavor1.repo_uri].should == @flavor1
-      @facade.flavorfile.flavors[@flavor2.repo_uri].should == @flavor2
-      @facade.lockfile.flavors.should == {
-        @flavor1d.repo_uri => @flavor1d,
-      }
-    end
-
-    it 'should load a lockfile if it exists' do
-      @facade.load()
-
-      @facade.lockfile.flavors.should == {
-        @flavor1d.repo_uri => @flavor1d,
-      }
-
-      @facade.lockfile_path = "#{@tmp_path}/VimFlavor.lock.xxx"
-      @facade.load()
-
-      @facade.lockfile.flavors.should == {}
-    end
-  end
-
-  describe '#make_new_flavors' do
-    before :each do
-      @facade = described_class.new()
-
-      @f0 = Vim::Flavor::Flavor.new()
-      @f0.repo_name = 'kana/vim-textobj-entire'
-      @f0.repo_uri = 'git://github.com/kana/vim-textobj-entire.git'
-      @f0.version_contraint = Vim::Flavor::VersionConstraint.new('>= 0')
-      @f0.locked_version = Gem::Version.create('0')
-
-      @f1 = @f0.dup()
-      @f1.locked_version = Gem::Version.create('2')
-
-      @f1d = @f1.dup()
-      @f1d.version_contraint = Vim::Flavor::VersionConstraint.new('>= 1')
-    end
-
-    it 'should keep current locked_version for newly added flavors' do
-      @facade.make_new_flavors(
-        {
-          @f0.repo_uri => @f0,
-        },
-        {
-        },
-        :install
-      ).should == {
-        @f0.repo_uri => @f0,
-      }
-    end
-
-    it 'should keep current locked_version for flavors with new constraint' do
-      @facade.make_new_flavors(
-        {
-          @f1d.repo_uri => @f1d,
-        },
-        {
-          @f0.repo_uri => @f0,
-        },
-        :install
-      ).should == {
-        @f1d.repo_uri => @f1d,
-      }
-    end
-
-    it 'should keep current locked_version for :update mode' do
-      @facade.make_new_flavors(
-        {
-          @f1.repo_uri => @f1,
-        },
-        {
-          @f0.repo_uri => @f0,
-        },
-        :update
-      ).should == {
-        @f1.repo_uri => @f1,
-      }
-    end
-
-    it 'should keep locked flavors otherwise' do
-      @facade.make_new_flavors(
-        {
-          @f1.repo_uri => @f1,
-        },
-        {
-          @f0.repo_uri => @f0,
-        },
-        :install
-      ).should == {
-        @f0.repo_uri => @f0,
-      }
-    end
-
-    it 'should always use current groups even if locked version is updated' do
-      f0 = @f0.dup()
-      f0.groups = [:default]
-      f1 = @f1.dup()
-      f1.groups = [:default, :development]
-      f1d = f1.dup()
-      f1d.locked_version = f0.locked_version
-
-      @facade.make_new_flavors(
-        {
-          f1.repo_uri => f1,
-        },
-        {
-          f0.repo_uri => f0,
-        },
-        :install
-      ).should == {
-        f1d.repo_uri => f1d,
-      }
-    end
-  end
-
-  describe '#create_vim_script_for_bootstrap' do
-    with_temporary_directory
-
-    before :each do
-      @facade = described_class.new()
-      @home_path =
-        if File.symlink?(@tmp_path)
-          File.readlink(@tmp_path)
-        else
-          @tmp_path
+require 'tmpdir'
+
+module Vim
+  module Flavor
+    describe Facade do
+      describe '#create_vim_script_for_bootstrap' do
+        around :each do |example|
+          Dir.mktmpdir do |tmp_path|
+            @tmp_path = tmp_path
+            example.run
+          end
         end
-      @vimfiles_path = "#{@home_path}/.vim"
-    end
-
-    it 'should create a bootstrap script into a given vimfiles path' do
-      bootstrap_path = "#{@vimfiles_path.to_flavors_path()}/bootstrap.vim"
-
-      File.exists?(bootstrap_path).should be_false
-      @facade.create_vim_script_for_bootstrap(@vimfiles_path)
-      File.exists?(bootstrap_path).should be_true
-    end
-
-    it 'should create a valid bootstrap script' do
-      @facade.create_vim_script_for_bootstrap(@vimfiles_path)
-
-      _rtp = %x{
-        HOME='#{@home_path}'
-        for plugin_name in 'foo' 'bar' 'baz'
-        do
-          mkdir -p "#{@vimfiles_path.to_flavors_path()}/$plugin_name"
-        done
-        vim -u NONE -i NONE -e -s -c '
-          set nocompatible verbose=1
-          let vimfiles_path = split(&runtimepath, ",")[0]
-          source #{@vimfiles_path}/flavors/bootstrap.vim
-          for path in split(&runtimepath, ",")
-            if stridx(path, vimfiles_path) == 0
-              echo substitute(path, vimfiles_path, "!", "")
-            endif
-          endfor
-          qall!
-        ' 2>&1
-      }
-      rtps =
-        _rtp.
-        split(/[\r\n]/).
-        select {|p| p != ''}
-      rtps.should == [
-        '!',
-        '!/flavors/bar',
-        '!/flavors/baz',
-        '!/flavors/foo',
-        '!/flavors/foo/after',
-        '!/flavors/baz/after',
-        '!/flavors/bar/after',
-        '!/after',
-      ]
-    end
-  end
-
-  describe '#deploy_flavors' do
-    with_temporary_directory
-
-    before :each do
-      @facade = described_class.new()
-
-      @test_repo_path = "#{@tmp_path}/test/origin"
-
-      @flavor = Vim::Flavor::Flavor.new()
-      @flavor.repo_name = '@test_repo_path'
-      @flavor.repo_uri = @test_repo_path
-      @flavor.locked_version = Gem::Version.create('1.0.0')
-
-      @flavors = [@flavor]
-
-      @vimfiles_path = "#{@tmp_path}/vimfiles"
-      @bootstrap_path = "#{@vimfiles_path.to_flavors_path()}/bootstrap.vim"
-    end
-
-    it 'should replace a given path with given flavors' do
-      create_a_test_repo(@test_repo_path)
-      @flavors.each do |f|
-        f.clone()
-      end
-
-      File.exists?(@vimfiles_path).should be_false
-      File.exists?(@bootstrap_path).should be_false
-      @flavors.each do |f|
-        File.exists?(f.make_deploy_path(@vimfiles_path)).should be_false
-      end
-
-      @facade.deploy_flavors(@flavors, @vimfiles_path)
-
-      File.exists?(@vimfiles_path).should be_true
-      File.exists?(@bootstrap_path).should be_true
-      @flavors.each do |f|
-        File.exists?(f.make_deploy_path(@vimfiles_path)).should be_true
-      end
-
-      system(<<-"END")
-        touch '#{@vimfiles_path}/foo'
-        touch '#{@vimfiles_path.to_flavors_path()}/foo'
-      END
-
-      File.exists?("#{@vimfiles_path}/foo").should be_true
-      File.exists?("#{@vimfiles_path.to_flavors_path()}/foo").should be_true
-
-      @facade.deploy_flavors(@flavors, @vimfiles_path)
-
-      File.exists?("#{@vimfiles_path}/foo").should be_true
-      File.exists?("#{@vimfiles_path.to_flavors_path()}/foo").should be_false
-    end
-  end
-
-  describe '#save_lockfile' do
-    with_temporary_directory
-
-    before :each do
-      @facade = described_class.new()
-      @facade.flavorfile_path = "#{@tmp_path}/VimFlavor"
-      @facade.lockfile_path = "#{@tmp_path}/VimFlavor.lock"
-
-      File.open(@facade.flavorfile_path, 'w') do |f|
-        f.write(<<-'END')
-        END
-      end
-    end
-
-    it 'should save locked flavors' do
-      @facade.load()
-
-      @facade.lockfile.flavors.should == {}
-
-      flavor1 = Vim::Flavor::Flavor.new()
-      flavor1.groups = [:default]
-      flavor1.locked_version = Gem::Version.create('1.2.3')
-      flavor1.repo_name = 'kana/vim-smartinput'
-      flavor1.repo_uri = 'git://github.com/kana/vim-smartinput.git'
-      flavor1.version_contraint = Vim::Flavor::VersionConstraint.new('>= 0')
-      @facade.lockfile.instance_eval do
-        @flavors = {
-          flavor1.repo_uri => flavor1,
-        }
-      end
-      @facade.save_lockfile()
-      @facade.lockfile.instance_eval do
-        @flavors = nil
-      end
-
-      @facade.lockfile.flavors.should == nil
-
-      @facade.load()
-
-      @facade.lockfile.flavors.should == {
-        flavor1.repo_uri => flavor1,
-      }
-    end
-  end
-
-  describe '#complete_locked_flavors' do
-    with_temporary_directory
-
-    before :each do
-      @test_repo_path = "#{@tmp_path}/test/origin"
-      @facade = described_class.new()
-      @facade.flavorfile_path = "#{@tmp_path}/VimFlavor"
-      @facade.lockfile_path = "#{@tmp_path}/VimFlavor.lock"
-
-      create_a_test_repo(@test_repo_path)
-      File.open(@facade.flavorfile_path, 'w') do |f|
-        f.write(<<-"END")
-          flavor 'file://#{@test_repo_path}', '~> 1.1.1'
-        END
-      end
-    end
-
-    it 'should complete flavors if they are not locked' do
-      @facade.load()
-
-      cf1 = @facade.flavorfile.flavors.values[0]
-      cf1.locked_version.should be_nil
-      File.exists?(cf1.cached_repo_path).should be_false
-      @facade.lockfile.flavors.should == {}
-
-      @facade.complete_locked_flavors(:upgrade_if_necessary)
-
-      lf1 = @facade.lockfile.flavors.values[0]
-      lf1.locked_version.should == Gem::Version.create('1.1.2')
-      File.exists?(lf1.cached_repo_path).should be_true
-      @facade.lockfile.flavors.should == {
-        lf1.repo_uri => lf1,
-      }
-
-      @facade.complete_locked_flavors(:upgrade_if_necessary)
-
-      lf1d = @facade.lockfile.flavors.values[0]
-      lf1d.locked_version.should == Gem::Version.create('1.1.2')
-      File.exists?(lf1d.cached_repo_path).should be_true
-      @facade.lockfile.flavors.should == {
-        lf1d.repo_uri => lf1d,
-      }
-    end
-
-    it 'should complete flavors if their constraint are changed' do
-      @facade.load()
-
-      cf1 = @facade.flavorfile.flavors.values[0]
-      cf1.locked_version.should be_nil
-      File.exists?(cf1.cached_repo_path).should be_false
-      @facade.lockfile.flavors.should == {}
-
-      @facade.complete_locked_flavors(:upgrade_if_necessary)
-
-      lf1 = @facade.lockfile.flavors.values[0]
-      lf1.locked_version.should == Gem::Version.create('1.1.2')
-      File.exists?(lf1.cached_repo_path).should be_true
-      @facade.lockfile.flavors.should == {
-        lf1.repo_uri => lf1,
-      }
-
-      cf1.version_contraint = Vim::Flavor::VersionConstraint.new('~> 1.1.2')
-      update_a_test_repo(@test_repo_path)
-      @facade.complete_locked_flavors(:upgrade_if_necessary)
-
-      lf1d = @facade.lockfile.flavors.values[0]
-      lf1d.locked_version.should == Gem::Version.create('1.1.9')
-      File.exists?(lf1d.cached_repo_path).should be_true
-      @facade.lockfile.flavors.should == {
-        lf1d.repo_uri => lf1d,
-      }
-    end
-
-    it 'should upgrade flavors even if their constraint are not changed' do
-      @facade.load()
-
-      cf1 = @facade.flavorfile.flavors.values[0]
-      cf1.locked_version.should be_nil
-      File.exists?(cf1.cached_repo_path).should be_false
-      @facade.lockfile.flavors.should == {}
-
-      @facade.complete_locked_flavors(:upgrade_all)
-
-      lf1 = @facade.lockfile.flavors.values[0]
-      lf1.locked_version.should == Gem::Version.create('1.1.2')
-      File.exists?(lf1.cached_repo_path).should be_true
-      @facade.lockfile.flavors.should == {
-        lf1.repo_uri => lf1,
-      }
-
-      update_a_test_repo(@test_repo_path)
-      @facade.complete_locked_flavors(:upgrade_all)
 
-      lf1d = @facade.lockfile.flavors.values[0]
-      lf1d.locked_version.should == Gem::Version.create('1.1.9')
-      File.exists?(lf1d.cached_repo_path).should be_true
-      @facade.lockfile.flavors.should == {
-        lf1d.repo_uri => lf1d,
-      }
-    end
-  end
-
-  describe '#get_default_vimfiles_path' do
-    it 'should return an appropriate value for *nix' do
-      # FIXME: Add proper tests depending on the current environment.
-      @facade = described_class.new()
-      @facade.get_default_vimfiles_path().should == "#{ENV['HOME']}/.vim"
-    end
-  end
-
-  describe '#install' do
-    with_temporary_directory
-
-    before :each do
-      @test_repo_path = "#{@tmp_path}/test/origin"
-      @vimfiles_path = "#{@tmp_path}/vimfiles"
-      @facade = described_class.new()
-      @facade.flavorfile_path = "#{@tmp_path}/VimFlavor"
-      @facade.lockfile_path = "#{@tmp_path}/VimFlavor.lock"
-
-      create_a_test_repo(@test_repo_path)
-      File.open(@facade.flavorfile_path, 'w') do |f|
-        f.write(<<-"END")
-          flavor 'file://#{@test_repo_path}', '~> 1.1.1'
-        END
-      end
-    end
-
-    it 'should install Vim plugins according to VimFlavor' do
-      File.exists?(@facade.lockfile_path).should be_false
-      File.exists?(@vimfiles_path).should be_false
-      @facade.lockfile.should be_nil
-
-      @facade.install(@vimfiles_path)
-
-      File.exists?(@facade.lockfile_path).should be_true
-      File.exists?(@vimfiles_path).should be_true
-      @facade.lockfile.flavors.values.each do |f|
-        File.exists?(f.make_deploy_path(@vimfiles_path)).should be_true
-      end
-    end
-
-    it 'should respect existing VimFlavor.lock if possible' do
-      def self.install()
-        @facade.install(@vimfiles_path)
-        [
-          @facade.lockfile.flavors.map {|_, f| f.locked_version},
-          @facade.flavorfile.flavors.count(),
-        ]
-      end
-
-      result1 = self.install()
-      update_a_test_repo(@test_repo_path)
-      result2 = self.install()
-
-      result2.should == result1
-    end
-  end
-
-  describe '#upgrade' do
-    with_temporary_directory
-
-    before :each do
-      @test_repo_path = "#{@tmp_path}/test/origin"
-      @vimfiles_path = "#{@tmp_path}/vimfiles"
-      @facade = described_class.new()
-      @facade.flavorfile_path = "#{@tmp_path}/VimFlavor"
-      @facade.lockfile_path = "#{@tmp_path}/VimFlavor.lock"
-
-      create_a_test_repo(@test_repo_path)
-      File.open(@facade.flavorfile_path, 'w') do |f|
-        f.write(<<-"END")
-          flavor 'file://#{@test_repo_path}', '~> 1.1.1'
-        END
-      end
-    end
-
-    it 'should upgrade Vim plugins according to VimFlavor' do
-      File.exists?(@facade.lockfile_path).should be_false
-      File.exists?(@vimfiles_path).should be_false
-      @facade.lockfile.should be_nil
-
-      @facade.upgrade(@vimfiles_path)
-
-      File.exists?(@facade.lockfile_path).should be_true
-      File.exists?(@vimfiles_path).should be_true
-      @facade.lockfile.flavors.values.each do |f|
-        File.exists?(f.make_deploy_path(@vimfiles_path)).should be_true
-      end
-    end
-
-    it 'should always upgrade existing VimFlavor.lock' do
-      def self.upgrade()
-        @facade.upgrade(@vimfiles_path)
-        [
-          @facade.lockfile.flavors.map {|_, f| f.locked_version},
-          @facade.flavorfile.flavors.count(),
-        ]
+        it 'creates a bootstrap script to configure runtimepath for flavors' do
+          vimfiles_path = @tmp_path.to_vimfiles_path
+          Facade.new().create_vim_script_for_bootstrap(vimfiles_path)
+
+          File.should exist(vimfiles_path.to_flavors_path.to_bootstrap_path)
+
+          _rtp = %x{
+            for plugin_name in 'foo' 'bar' 'baz'
+            do
+              mkdir -p "#{vimfiles_path.to_flavors_path}/$plugin_name"
+            done
+            HOME='#{@tmp_path}' vim -u NONE -i NONE -n -N -e -s -c '
+              set verbose=1
+              let vimfiles_path = split(&runtimepath, ",")[0]
+              runtime flavors/bootstrap.vim
+              for path in split(&runtimepath, ",")
+                if stridx(path, vimfiles_path) == 0
+                  echo substitute(path, vimfiles_path, "!", "")
+                endif
+              endfor
+              qall!
+            ' 2>&1
+          }
+          rtps =
+            _rtp.
+            split(/[\r\n]/).
+            select {|p| p != ''}
+          rtps.should == [
+            '!',
+            '!/flavors/bar',
+            '!/flavors/baz',
+            '!/flavors/foo',
+            '!/flavors/foo/after',
+            '!/flavors/baz/after',
+            '!/flavors/bar/after',
+            '!/after',
+          ]
+        end
       end
-
-      result1 = self.upgrade()
-      update_a_test_repo(@test_repo_path)
-      result2 = self.upgrade()
-
-      result2.should_not == result1
     end
   end
 end