vim-flavor 1.1.5 → 2.0.0

data/features/version_tag_format.feature

@@ -3,35 +3,71 @@ Feature: Version tag format
   as a lazy Vim user,
   I want to use only tags which are formatted as versions.
 
+  # Points:
+  # - Use ~> to check versions are properly compared.
+  # - Install twice to check whether a lockfile is properly read or not.
+
   Scenario: With tags in the style of "X.Y.Z"
-    Given a repository "foo" with versions "1 1.2 1.2.3"
+    Given a repository "foo" with versions "1.0 1.1 1.2 1.2.3"
     And a flavorfile with:
       """ruby
-      flavor '$foo_uri'
+      flavor '$foo_uri', '~> 1.1'
       """
     When I run `vim-flavor install`
-    Then it should pass
+    Then it should pass with template:
+      """
+      Checking versions...
+        Use $foo_uri ... 1.2.3
+      Deploying plugins...
+        $foo_uri 1.2.3 ... done
+      Completed.
+      """
     And a lockfile is created with:
       """
       $foo_uri (1.2.3)
       """
     And a bootstrap script is created in "$home/.vim"
     And a flavor "$foo_uri" version "1.2.3" is deployed to "$home/.vim"
+    When I run `vim-flavor install`
+    Then it should pass with template:
+      """
+      Checking versions...
+        Use $foo_uri ... 1.2.3
+      Deploying plugins...
+        $foo_uri 1.2.3 ... skipped (already deployed)
+      Completed.
+      """
 
   Scenario: With tags in the style of "vX.Y.Z"
-    Given a repository "foo" with versions "v4.5.6 v7 v8.9"
+    Given a repository "foo" with versions "v1.0 v1.1 v1.2 v1.2.3"
     And a flavorfile with:
       """ruby
-      flavor '$foo_uri'
+      flavor '$foo_uri', '~> 1.1'
       """
     When I run `vim-flavor install`
-    Then it should pass
+    Then it should pass with template:
+      """
+      Checking versions...
+        Use $foo_uri ... v1.2.3
+      Deploying plugins...
+        $foo_uri v1.2.3 ... done
+      Completed.
+      """
     And a lockfile is created with:
       """
-      $foo_uri (v8.9)
+      $foo_uri (v1.2.3)
       """
     And a bootstrap script is created in "$home/.vim"
-    And a flavor "$foo_uri" version "v8.9" is deployed to "$home/.vim"
+    And a flavor "$foo_uri" version "v1.2.3" is deployed to "$home/.vim"
+    When I run `vim-flavor install`
+    Then it should pass with template:
+      """
+      Checking versions...
+        Use $foo_uri ... v1.2.3
+      Deploying plugins...
+        $foo_uri v1.2.3 ... skipped (already deployed)
+      Completed.
+      """
 
   Scenario: Without valid tags
     Given a repository "foo" with versions "abc def ghi"

data/lib/vim-flavor.rb

@@ -4,6 +4,7 @@ require 'vim-flavor/enumerableextension'
 module Vim
   module Flavor
     [
+      :BranchVersion,
       :CLI,
       :Env,
       :Facade,
@@ -11,6 +12,7 @@ module Vim
       :FlavorFile,
       :LockFile,
       :LockFileParser,
+      :PlainVersion,
       :ShellUtility,
       :StringExtension,
       :VERSION,

data/lib/vim-flavor/branchversion.rb

@@ -0,0 +1,28 @@
+module Vim
+  module Flavor
+    class BranchVersion
+      attr_reader :branch
+      attr_reader :revision
+
+      def initialize(branch, revision)
+        @branch = branch
+        @revision = revision
+      end
+
+      def ==(other)
+        self.class === other and
+          self.branch == other.branch and
+          self.revision == other.revision
+      end
+
+      def to_s()
+        "#{revision} at #{branch}"
+      end
+
+      def to_revision()
+        return revision if revision
+        throw "Internal error: A revision of a branch #{branch} is not known"
+      end
+    end
+  end
+end

data/lib/vim-flavor/facade.rb

@@ -102,10 +102,10 @@ module Vim
         if vs.length == 1
           nfg.first
         else
-          latest_version = vs.max()
-          if nfg.all? {|nf| nf.satisfied_with?(latest_version)}
+          lv = find_latest_version(vs)
+          if lv and nfg.all? {|nf| nf.satisfied_with?(lv)}
             nf = nfg.first
-            nf.use_specific_version(latest_version)
+            nf.use_specific_version(lv)
             nf
           else
             stop_by_incompatible_declarations(nfg)
@@ -113,6 +113,10 @@ module Vim
         end
       end
 
+      def find_latest_version(vs)
+        vs.all? {|v| PlainVersion === v} and vs.max() or nil
+      end
+
       def stop_by_incompatible_declarations(nfg)
         ss = []
         ss << 'Found incompatible declarations:'

data/lib/vim-flavor/flavor.rb

@@ -28,7 +28,7 @@ module Vim
         system <<-"END"
           {
             cd '#{cached_repo_path}' &&
-            git rev-list --quiet '#{version}'
+            git rev-list --quiet '#{version.to_revision}' --
           } >/dev/null 2>&1
         END
       end
@@ -74,7 +74,7 @@ module Vim
         sh %Q{
           {
             cd '#{cached_repo_path}' &&
-            git fetch --tags
+            git fetch origin --tags 'refs/heads/*:refs/remotes/origin/*'
           } 2>&1
         }
       end
@@ -83,7 +83,7 @@ module Vim
         sh %Q[
           {
             cd '#{cached_repo_path}' &&
-            git checkout -f '#{locked_version}'
+            git checkout -f '#{locked_version.to_revision}'
           } 2>&1
         ]
       end
@@ -93,7 +93,7 @@ module Vim
         sh %Q[
           {
             cd '#{cached_repo_path}' &&
-            git checkout -f '#{locked_version}' &&
+            git checkout -f '#{locked_version.to_revision}' &&
             git checkout-index -a -f --prefix='#{deployment_path}/' &&
             {
               vim -u NONE -i NONE -n -N -e -s -c '
@@ -108,7 +108,14 @@ module Vim
 
       def use_appropriate_version()
         @locked_version =
-          version_constraint.find_the_best_version(list_versions)
+          case
+          when PlainVersion === version_constraint.base_version
+            version_constraint.find_the_best_version(list_versions)
+          when BranchVersion === version_constraint.base_version
+            make_branch_version(version_constraint.base_version.branch)
+          else
+            throw "Unexpected version_constraint: #{version_constraint}"
+          end
       end
 
       def use_specific_version(locked_version)
@@ -138,6 +145,14 @@ module Vim
       def satisfied_with?(version)
         version_constraint.compatible?(version)
       end
+
+      def make_branch_version(branch)
+        revision = sh(%Q[
+          cd '#{cached_repo_path}' &&
+          git rev-list -n1 'origin/#{branch}' --
+        ]).chomp
+        BranchVersion.new(branch, revision)
+      end
     end
   end
 end

data/lib/vim-flavor/flavorfile.rb

@@ -33,22 +33,23 @@ module Vim
         )
       end
 
-      # :call-seq:
-      #   flavor repo_name, version_constraint='>= 0', options={} -> a_flavor
-      def flavor(repo_name, *args)
-        a = args.shift()
-        if a.kind_of?(String)
-          version_constraint = a
-          a = args.shift()
-        else
-          version_constraint = '>= 0'
+      def flavor(repo_name, version_constraint=nil, group: nil, branch: nil)
+        if version_constraint and branch
+          throw <<-"END"
+Found an invalid declaration on #{repo_name}.
+A version constraint '#{version_constraint}' and
+a branch '#{branch}' are specified at the same time.
+But a branch cannot be used with a version constraint.
+          END
         end
-        options = a.kind_of?(Hash) ? a : {}
 
         f = Flavor.new()
         f.repo_name = repo_name
-        f.version_constraint = VersionConstraint.new(version_constraint)
-        f.group = options[:group] || default_group
+        f.version_constraint = VersionConstraint.new(
+          branch && "branch: #{branch}" ||
+          version_constraint || '>= 0'
+        )
+        f.group = group || default_group
         flavor_table[f.repo_name] = f
       end
 

data/lib/vim-flavor/lockfileparser.rb

@@ -37,10 +37,19 @@ module Vim
         }
         rule(:locked_version) {
           (
-            str('v').maybe >>
-            match('[\d.]').repeat(1)
+            branch_version |
+            plain_version
           ).as(:locked_version)
         }
+        rule(:plain_version) {
+          str('v').maybe >>
+          match('[\d.]').repeat(1)
+        }
+        rule(:branch_version) {
+          match('\h').repeat(1).as(:revision) >>
+          str(' at ') >>
+          match('[^\s()]').repeat(1).as(:branch)
+        }
 
         rule(:space) {match('[ \t]').repeat(1)}
         rule(:space?) {space.maybe}
@@ -52,12 +61,17 @@ module Vim
         rule(
           :flavor => {
             :repo_name => simple(:repo_name),
-            :locked_version => simple(:locked_version),
+            :locked_version => subtree(:locked_version),
           }
         ) {
           f = Flavor.new()
           f.repo_name = repo_name.to_s
-          f.locked_version = Version.create(locked_version.to_s)
+          f.locked_version =
+            Version.create(
+              Hash === locked_version ?
+              locked_version :
+              locked_version.to_s
+            )
           f
         }
       end

data/lib/vim-flavor/plainversion.rb

@@ -0,0 +1,28 @@
+module Vim
+  module Flavor
+    class PlainVersion < Gem::Version
+      attr_accessor :original_tag_name
+
+      def initialize(tag_name)
+        @original_tag_name = tag_name
+        super(self.class.normalize_tag_name(tag_name))
+      end
+
+      def self.normalize_tag_name(tag_name)
+        tag_name.to_s.sub(/^v/, '')
+      end
+
+      def self.correct?(tag_name)
+        super(normalize_tag_name(tag_name))
+      end
+
+      def to_s()
+        @original_tag_name
+      end
+
+      def to_revision()
+        to_s
+      end
+    end
+  end
+end

data/lib/vim-flavor/version.rb

@@ -1,25 +1,18 @@
 module Vim
   module Flavor
-    VERSION = '1.1.5'
+    VERSION = '2.0.0'
 
-    class Version < Gem::Version
-      attr_accessor :original_tag_name
-
-      def initialize(tag_name)
-        @original_tag_name = tag_name
-        super(self.class.normalize_tag_name(tag_name))
-      end
-
-      def self.normalize_tag_name(tag_name)
-        tag_name.to_s.sub(/^v/, '')
-      end
-
-      def self.correct?(tag_name)
-        super(normalize_tag_name(tag_name))
+    class Version
+      def self.create(arg)
+        if String === arg
+          PlainVersion.create(arg)
+        else
+          BranchVersion.new(arg[:branch], arg[:revision])
+        end
       end
 
-      def to_s()
-        @original_tag_name
+      def self.correct?(*args)
+        PlainVersion.correct?(*args)
       end
     end
   end

data/lib/vim-flavor/versionconstraint.rb

@@ -11,7 +11,14 @@ module Vim
       end
 
       def to_s()
-        "#{qualifier} #{base_version}"
+        case
+        when PlainVersion === base_version
+          "#{qualifier} #{base_version}"
+        when BranchVersion === base_version
+          "#{qualifier} #{base_version.branch}"
+        else
+          throw "Unexpected base_version: #{base_version}"
+        end
       end
 
       def ==(other)
@@ -20,20 +27,29 @@ module Vim
       end
 
       def self.parse(s)
-        m = /^\s*(>=|~>)\s+(\S+)$/.match(s)
+        m = /^\s*(>=|~>|branch:)\s+(\S+)\s*$/.match(s)
         if m
-          [Version.create(m[2]), m[1]]
+          if m[1] == 'branch:'
+            [Version.create(branch: m[2]), m[1]]
+          else
+            [Version.create(m[2]), m[1]]
+          end
         else
           raise "Invalid version constraint: #{s.inspect}"
         end
       end
 
-      def compatible?(other_version_or_s)
-        v = Version.create(other_version_or_s)
+      def compatible?(version)
         if qualifier == '~>'
-          self.base_version.bump() > v and v >= self.base_version
+          PlainVersion === version and
+            self.base_version.bump() > version and
+            version >= self.base_version
         elsif qualifier == '>='
-          v >= self.base_version
+          PlainVersion === version and
+            version >= self.base_version
+        elsif qualifier == 'branch:'
+          BranchVersion === version and
+            version.branch == self.base_version.branch
         else
           raise NotImplementedError
         end

data/spec/branchversion_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module Vim
+  module Flavor
+    describe BranchVersion do
+      def v(*args)
+        described_class.new(*args)
+      end
+
+      let(:v1) {v('master', '1' * 40)}
+      let(:v1d) {v('master', '1' * 40)}
+      let(:v2) {v('master', '2' * 40)}
+
+      it 'is equatable' do
+        expect(v1).to be == v1
+        expect(v1).to be == v1d
+        expect(v1).not_to be == v2
+      end
+
+      it 'is not comparable' do
+        expect {v1 < v2}.to raise_error
+        expect {v1 <= v2}.to raise_error
+        expect {v1 > v2}.to raise_error
+        expect {v1 >= v2}.to raise_error
+        expect(v1 <=> v2).to be_nil
+      end
+
+      describe '#to_s' do
+        it 'makes a user-friendly representation' do
+          expect(v1.to_s).to be == "#{'1' * 40} at master"
+        end
+      end
+
+      describe '#to_revision' do
+        it 'returns a revision corresponding to a branch' do
+          expect(v('master', '1' * 40).to_revision).to be == '1' * 40
+          expect(v('experimental', '2' * 40).to_revision).to be == '2' * 40
+        end
+
+        it 'fails if a revision is not known' do
+          expect {
+            v('master', nil).to_revision
+          }.to raise_error(
+            /Internal error: A revision of a branch master is not known/
+          )
+        end
+      end
+    end
+  end
+end