vim-flavor 1.1.5 → 2.0.0

data/spec/enumerableextension_spec.rb

@@ -12,7 +12,7 @@ module Vim
             xs << "each #{n}"
           end
 
-          xs.should == [
+          expect(xs).to be == [
             "before_each 1",
             "each 1",
             "before_each 2",
@@ -32,7 +32,7 @@ module Vim
             xs << "each #{n}"
           end
 
-          xs.should == [
+          expect(xs).to be == [
             "each 1",
             "after_each 1",
             "each 2",
@@ -57,7 +57,7 @@ module Vim
             end
           }.to raise_error(RuntimeError, 'bang! 3')
 
-          xs.should == [
+          expect(xs).to be == [
             "each enter 1",
             "each leave 1",
             "each enter 2",
@@ -86,7 +86,7 @@ module Vim
             end
           }.to raise_error(RuntimeError, 'bang!')
 
-          xs.should == [
+          expect(xs).to be == [
             "each enter 1",
             "each leave 1",
             "each enter 2",

data/spec/facade_spec.rb

@@ -17,7 +17,7 @@ module Vim
           flavors_path = @tmp_path.to_vimfiles_path.to_flavors_path
           Facade.new().create_vim_script_for_bootstrap(flavors_path)
 
-          File.should exist(flavors_path.to_bootstrap_path)
+          expect(File).to exist(flavors_path.to_bootstrap_path)
 
           _rtp = %x{
             for plugin_name in 'foo' 'bar' 'baz'
@@ -40,7 +40,7 @@ module Vim
             _rtp.
             split(/[\r\n]/).
             select {|p| p != ''}
-          rtps.should == [
+          expect(rtps).to be == [
             '!',
             '!/flavors/bar',
             '!/flavors/baz',

data/spec/flavor_spec.rb

@@ -6,7 +6,8 @@ module Vim
       describe '#versions_from_tags' do
         def example tags, versions
           f = Flavor.new()
-          f.versions_from_tags(tags).sort.map(&:version).should == versions
+          expect(f.versions_from_tags(tags).sort.map(&:version)).to be ==
+            versions
         end
 
         it 'converts tags into versions' do
@@ -34,15 +35,15 @@ module Vim
           Version.create(s)
         end
 
-        it {should be_satisfied_with version('1.2.3')}
+        it {is_expected.to be_satisfied_with version('1.2.3')}
 
-        it {should be_satisfied_with version('1.2.4')}
-        it {should be_satisfied_with version('1.3.3')}
-        it {should be_satisfied_with version('2.2.3')}
+        it {is_expected.to be_satisfied_with version('1.2.4')}
+        it {is_expected.to be_satisfied_with version('1.3.3')}
+        it {is_expected.to be_satisfied_with version('2.2.3')}
 
-        it {should_not be_satisfied_with version('0.2.3')}
-        it {should_not be_satisfied_with version('1.1.3')}
-        it {should_not be_satisfied_with version('1.2.2')}
+        it {is_expected.not_to be_satisfied_with version('0.2.3')}
+        it {is_expected.not_to be_satisfied_with version('1.1.3')}
+        it {is_expected.not_to be_satisfied_with version('1.2.2')}
       end
     end
   end

data/spec/flavorfile_spec.rb

@@ -3,48 +3,52 @@ require 'spec_helper'
 module Vim
   module Flavor
     describe FlavorFile do
+      def constraint(*args)
+        VersionConstraint.new(*args)
+      end
+
       describe '#flavor' do
         let(:ff) {FlavorFile.new()}
 
-        context 'basics' do
+        context 'with basic usage' do
           it 'registers a flavor' do
             ff.flavor 'kana/vim-altr', '>= 1.2.3'
             f = ff.flavor_table['kana/vim-altr']
-            f.repo_name.should == 'kana/vim-altr'
-            f.version_constraint.should == VersionConstraint.new('>= 1.2.3')
+            expect(f.repo_name).to be == 'kana/vim-altr'
+            expect(f.version_constraint).to be == constraint('>= 1.2.3')
           end
 
-          it 'completes version constraint if it is not given' do
+          it 'completes a version constraint if it is not given' do
             ff.flavor 'kana/vim-altr'
             f = ff.flavor_table['kana/vim-altr']
-            f.repo_name.should == 'kana/vim-altr'
-            f.version_constraint.should == VersionConstraint.new('>= 0')
+            expect(f.repo_name).to be == 'kana/vim-altr'
+            expect(f.version_constraint).to be == constraint('>= 0')
           end
         end
 
-        context 'group option' do
+        context 'with a group option' do
           it 'supports a group option with a version constraint' do
             ff.flavor 'kana/vim-vspec', '~> 1.0', :group => :development
             f = ff.flavor_table['kana/vim-vspec']
-            f.version_constraint.should == VersionConstraint.new('~> 1.0')
-            f.group.should == :development
+            expect(f.version_constraint).to be == constraint('~> 1.0')
+            expect(f.group).to be == :development
           end
 
           it 'supports a group option without version constraint' do
             ff.flavor 'kana/vim-vspec', :group => :development
             f = ff.flavor_table['kana/vim-vspec']
-            f.version_constraint.should == VersionConstraint.new('>= 0')
-            f.group.should == :development
+            expect(f.version_constraint).to be == constraint('>= 0')
+            expect(f.group).to be == :development
           end
 
           it 'uses :default as the default group' do
             ff.flavor 'kana/vim-vspec'
             f = ff.flavor_table['kana/vim-vspec']
-            f.group.should == :runtime
+            expect(f.group).to be == :runtime
           end
         end
 
-        context 'group block' do
+        context 'in a group block' do
           it 'changes the default group for flavors in a given block' do
             ff.flavor 'a'
             ff.group :outer do
@@ -56,11 +60,11 @@ module Vim
             end
             ff.flavor 'e'
 
-            ff.flavor_table['a'].group.should == :runtime
-            ff.flavor_table['b'].group.should == :outer
-            ff.flavor_table['c'].group.should == :inner
-            ff.flavor_table['d'].group.should == :outer
-            ff.flavor_table['e'].group.should == :runtime
+            expect(ff.flavor_table['a'].group).to be == :runtime
+            expect(ff.flavor_table['b'].group).to be == :outer
+            expect(ff.flavor_table['c'].group).to be == :inner
+            expect(ff.flavor_table['d'].group).to be == :outer
+            expect(ff.flavor_table['e'].group).to be == :runtime
           end
 
           it 'restores the default group even if an exception is raised' do
@@ -78,11 +82,26 @@ module Vim
             end
             ff.flavor 'e'
 
-            ff.flavor_table['a'].group.should == :runtime
-            ff.flavor_table['b'].group.should == :outer
-            ff.flavor_table['c'].should be_nil
-            ff.flavor_table['d'].group.should == :outer
-            ff.flavor_table['e'].group.should == :runtime
+            expect(ff.flavor_table['a'].group).to be == :runtime
+            expect(ff.flavor_table['b'].group).to be == :outer
+            expect(ff.flavor_table['c']).to be_nil
+            expect(ff.flavor_table['d'].group).to be == :outer
+            expect(ff.flavor_table['e'].group).to be == :runtime
+          end
+        end
+
+        context 'with a branch option' do
+          it 'is supported' do
+            ff.flavor 'kana/vim-altr', branch: 'master'
+            f = ff.flavor_table['kana/vim-altr']
+            expect(f.repo_name).to be == 'kana/vim-altr'
+            expect(f.version_constraint).to be == constraint('branch: master')
+          end
+
+          it 'cannot be used with a version constraint' do
+            expect {
+              ff.flavor 'kana/vim-altr', '>= 0', branch: 'master'
+            }.to raise_error(/branch cannot be used with a version constraint/)
           end
         end
       end
@@ -102,8 +121,8 @@ module Vim
           end
           ff = FlavorFile.load(flavorfile_path)
           f = ff.flavor_table['kana/vim-altr']
-          f.repo_name.should == 'kana/vim-altr'
-          f.version_constraint.should == VersionConstraint.new('~> 1.2')
+          expect(f.repo_name).to be == 'kana/vim-altr'
+          expect(f.version_constraint).to be == constraint('~> 1.2')
         end
       end
     end

data/spec/lockfile_spec.rb

@@ -14,30 +14,41 @@ module Vim
       def flavor(repo_name, locked_version)
         f = Flavor.new()
         f.repo_name = repo_name
-        f.locked_version = version(locked_version)
+        f.locked_version = v(locked_version)
         f
       end
 
-      def version(s)
+      def v(s)
         Version.create(s)
       end
 
-      it 'has flavors sorted by repo_name' do
-        l = LockFile.new(@tmp_path.to_lockfile_path)
-        foo = flavor('foo', '1.2.3')
-        bar = flavor('bar', '2.3.4')
-        baz = flavor('baz', '3.4.5')
-        [foo, bar, baz].each do |f|
-          l.flavor_table[f.repo_name] = f
-        end
+      describe '#flavors' do
+        it 'is sorted by repo_name' do
+          l = LockFile.new(@tmp_path.to_lockfile_path)
+          foo = flavor('foo', '1.2.3')
+          bar = flavor('bar', '2.3.4')
+          baz = flavor('baz', '3.4.5')
+          [foo, bar, baz].each do |f|
+            l.flavor_table[f.repo_name] = f
+          end
 
-        l.flavors.should == [bar, baz, foo]
+          expect(l.flavors).to be == [bar, baz, foo]
+        end
       end
 
       describe '::serialize_lock_status' do
         it 'converts a flavor into an array of lines' do
-          LockFile.serialize_lock_status(flavor('foo', '1.2.3')).should ==
-            ['foo (1.2.3)']
+          expect(
+            LockFile.serialize_lock_status(flavor('foo', '1.2.3'))
+          ).to be == ['foo (1.2.3)']
+        end
+
+        it 'supports a flavor locked to a branch' do
+          expect(
+            LockFile.serialize_lock_status(
+              flavor('foo', branch: 'master', revision: '1' * 40)
+            )
+          ).to be == ["foo (#{'1' * 40} at master)"]
         end
       end
 
@@ -52,15 +63,39 @@ module Vim
           end
 
           l = LockFile.new(@tmp_path.to_lockfile_path)
-          l.flavor_table.should be_empty
+          expect(l.flavor_table).to be_empty
+
+          l.load()
+          expect(l.flavor_table['foo'].repo_name).to be == 'foo'
+          expect(l.flavor_table['foo'].locked_version).to be == v('1.2.3')
+          expect(l.flavor_table['bar'].repo_name).to be == 'bar'
+          expect(l.flavor_table['bar'].locked_version).to be == v('2.3.4')
+          expect(l.flavor_table['baz'].repo_name).to be == 'baz'
+          expect(l.flavor_table['baz'].locked_version).to be == v('3.4.5')
+        end
+
+        it 'recognizes flavors with BranchVersion' do
+          File.open(@tmp_path.to_lockfile_path, 'w') do |io|
+            io.write(<<-"END")
+              foo (#{'1' * 40} at master)
+              bar (#{'2' * 40} at experimental)
+              baz (#{'3' * 40} at stable)
+            END
+          end
+
+          l = LockFile.new(@tmp_path.to_lockfile_path)
+          expect(l.flavor_table).to be_empty
 
           l.load()
-          l.flavor_table['foo'].repo_name.should == 'foo'
-          l.flavor_table['foo'].locked_version.should == version('1.2.3')
-          l.flavor_table['bar'].repo_name.should == 'bar'
-          l.flavor_table['bar'].locked_version.should == version('2.3.4')
-          l.flavor_table['baz'].repo_name.should == 'baz'
-          l.flavor_table['baz'].locked_version.should == version('3.4.5')
+          expect(l.flavor_table['foo'].repo_name).to be == 'foo'
+          expect(l.flavor_table['foo'].locked_version).to be ==
+            v(branch: 'master', revision: '1' * 40)
+          expect(l.flavor_table['bar'].repo_name).to be == 'bar'
+          expect(l.flavor_table['bar'].locked_version).to be ==
+            v(branch: 'experimental', revision: '2' * 40)
+          expect(l.flavor_table['baz'].repo_name).to be == 'baz'
+          expect(l.flavor_table['baz'].locked_version).to be ==
+            v(branch: 'stable', revision: '3' * 40)
         end
       end
 
@@ -73,13 +108,13 @@ module Vim
           end
 
           l = LockFile.load_or_new(@tmp_path.to_lockfile_path)
-          l.flavor_table['foo'].repo_name.should == 'foo'
-          l.flavor_table['foo'].locked_version.should == version('1.2.3')
+          expect(l.flavor_table['foo'].repo_name).to be == 'foo'
+          expect(l.flavor_table['foo'].locked_version).to be == v('1.2.3')
         end
 
         it 'only creates a new instance if a given path does not exist' do
           l = LockFile.load_or_new(@tmp_path.to_lockfile_path)
-          l.flavor_table.should be_empty
+          expect(l.flavor_table).to be_empty
         end
       end
     end

data/spec/plainversion_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Vim
+  module Flavor
+    describe PlainVersion do
+      v = described_class
+
+      describe '::create' do
+        it 'accept "X.Y.Z" style tags' do
+          expect {
+            v.create('1')
+            v.create('1.2')
+            v.create('1.2.3')
+          }.not_to raise_error
+        end
+
+        it 'accept "vX.Y.Z" style tags' do
+          expect {
+            v.create('v1')
+            v.create('v1.2')
+            v.create('v1.2.3')
+          }.not_to raise_error
+        end
+      end
+
+      describe '::correct?' do
+        it 'accept "X.Y.Z" style tags' do
+          expect(v.correct?('1')).to be_true
+          expect(v.correct?('1.2')).to be_true
+          expect(v.correct?('1.2.3')).to be_true
+        end
+
+        it 'accept "vX.Y.Z" style tags' do
+          expect(v.correct?('v1')).to be_true
+          expect(v.correct?('v1.2')).to be_true
+          expect(v.correct?('v1.2.3')).to be_true
+        end
+      end
+
+      describe '#<=>' do
+        it 'can comapre "X.Y.Z" tags' do
+          expect(v.create('1.2.3')).to be <= v.create('1.3')
+          expect(v.create('1.2.3')).to be == v.create('1.2.3')
+          expect(v.create('1.2.3')).to be >= v.create('1.1')
+        end
+
+        it 'can comapre "vX.Y.Z" tags' do
+          expect(v.create('v1.2.3')).to be <= v.create('v1.3')
+          expect(v.create('v1.2.3')).to be == v.create('v1.2.3')
+          expect(v.create('v1.2.3')).to be >= v.create('v1.1')
+        end
+
+        it 'can comapre "X.Y.Z" tag with "vX.Y.Z" tag' do
+          expect(v.create('1.2.3')).to be <= v.create('v1.3')
+          expect(v.create('1.2.3')).to be == v.create('v1.2.3')
+          expect(v.create('1.2.3')).to be >= v.create('v1.1')
+        end
+      end
+
+      describe '#to_s' do
+        it 'is converted into the original string' do
+          expect(v.create('1.2.3').to_s).to be == '1.2.3'
+          expect(v.create('v1.2.3').to_s).to be == 'v1.2.3'
+        end
+      end
+
+      describe '#to_revision' do
+        it 'returns the revision corresponding to a version' do
+          expect(v.create('1.2.3').to_revision).to be == '1.2.3'
+          expect(v.create('v1.2.3').to_revision).to be == 'v1.2.3'
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,2 +1,12 @@
 require 'bundler/setup'
 require 'vim-flavor'
+
+module OneLinerExpectSyntax
+  def is_expected
+    expect(subject)
+  end
+end
+
+RSpec.configure do |rspec|
+  rspec.include OneLinerExpectSyntax
+end

data/spec/stringextension_spec.rb

@@ -5,9 +5,10 @@ module Vim
     describe StringExtension do
       describe '#zap' do
         it 'replace unsafe characters with "_"' do
-          'fakeclip'.zap.should == 'fakeclip'
-          'kana/vim-altr'.zap.should == 'kana_vim-altr'
-          'git://example.com/foo.git'.zap.should == 'git___example.com_foo.git'
+          expect('fakeclip'.zap).to be == 'fakeclip'
+          expect('kana/vim-altr'.zap).to be == 'kana_vim-altr'
+          expect('git://example.com/foo.git'.zap).to be ==
+            'git___example.com_foo.git'
         end
       end
     end

data/spec/version_spec.rb

@@ -3,62 +3,44 @@ require 'spec_helper'
 module Vim
   module Flavor
     describe Version do
-      describe '::create' do
-        it 'accept "X.Y.Z" style tags' do
-          expect {
-            Version.create('1')
-            Version.create('1.2')
-            Version.create('1.2.3')
-          }.not_to raise_error
-        end
+      v = described_class
 
-        it 'accept "vX.Y.Z" style tags' do
-          expect {
-            Version.create('v1')
-            Version.create('v1.2')
-            Version.create('v1.2.3')
-          }.not_to raise_error
+      describe '::create' do
+        context 'with a string' do
+          it 'makes a PlainVersion' do
+            expect(v.create('1.2.3')).to be_a(PlainVersion)
+            expect(v.create('v1.2.3')).to be_a(PlainVersion)
+          end
+        end
+
+        context 'with a branch' do
+          it 'makes a BranchVersion' do
+            r = v.create(branch: 'master')
+            expect(r).to be_a(BranchVersion)
+            expect(r.branch).to be == 'master'
+            expect(r.revision).to be_nil
+          end
+        end
+
+        context 'with a branch and a ref' do
+          it 'makes a BranchVersion' do
+            r = v.create(branch: 'master', revision: '1' * 40)
+            expect(r).to be_a(BranchVersion)
+            expect(r.branch).to be == 'master'
+            expect(r.revision).to be == '1' * 40
+          end
         end
       end
 
       describe '::correct?' do
-        it 'accept "X.Y.Z" style tags' do
-          Version.correct?('1').should be_true
-          Version.correct?('1.2').should be_true
-          Version.correct?('1.2.3').should be_true
-        end
-
-        it 'accept "vX.Y.Z" style tags' do
-          Version.correct?('v1').should be_true
-          Version.correct?('v1.2').should be_true
-          Version.correct?('v1.2.3').should be_true
-        end
-      end
-
-      describe '#<=>' do
-        it 'can comapre "X.Y.Z" tags' do
-          Version.create('1.2.3').should be <= Version.create('1.3')
-          Version.create('1.2.3').should be == Version.create('1.2.3')
-          Version.create('1.2.3').should be >= Version.create('1.1')
-        end
-
-        it 'can comapre "vX.Y.Z" tags' do
-          Version.create('v1.2.3').should be <= Version.create('v1.3')
-          Version.create('v1.2.3').should be == Version.create('v1.2.3')
-          Version.create('v1.2.3').should be >= Version.create('v1.1')
-        end
-
-        it 'can comapre "X.Y.Z" tag with "vX.Y.Z" tag' do
-          Version.create('1.2.3').should be <= Version.create('v1.3')
-          Version.create('1.2.3').should be == Version.create('v1.2.3')
-          Version.create('1.2.3').should be >= Version.create('v1.1')
-        end
-      end
-
-      describe '#to_s' do
-        it 'is converted into the original string' do
-          Version.create('1.2.3').to_s.should == '1.2.3'
-          Version.create('v1.2.3').to_s.should == 'v1.2.3'
+        it 'is an alias of PlainVersion::correct?' do
+          expect(v.correct?('1')).to be_true
+          expect(v.correct?('1.2')).to be_true
+          expect(v.correct?('1.2.3')).to be_true
+          expect(v.correct?('v1')).to be_true
+          expect(v.correct?('v1.2')).to be_true
+          expect(v.correct?('v1.2.3')).to be_true
+          expect(v.correct?('vim7.4')).to be_false
         end
       end
     end