vim-flavor 0.0.2 → 0.0.3

data/README.md

@@ -28,6 +28,50 @@
     gem install vim-flavor
 
 
+### Installable plugins
+
+Not all Vim plugins can be installed with vim-flavor.
+vim-flavor can install plugins which meet the following conditions:
+
+* Plugins must have dedicated Git repositories.
+  vim-flavor does not support other version control systems.
+  This is an intentional design.  Because:
+  * [vim-scripts.org](http://vim-scripts.org/) provides
+    [a comprehensive Git mirrors](https://github.com/vim-scripts) for
+    [plugins uploaded to www.vim.org](http://www.vim.org/scripts/index.php).
+  * Experimental plugins which are not uploaded to www.vim.org
+    are usually found in [GitHub](https://github.com/).
+* Plugins must follow [the versioning pocilies of
+  RubyGems](http://docs.rubygems.org/read/chapter/7#page26) and have "version"
+  tags in their repositories.  For example, if there is the version 1.2.3 of
+  a plugin, its repository must have the tag `1.2.3`, and the files of the
+  version 1.2.3 can be checked out via the tag `1.2.3`.  In other words,
+  plugins which do not have proper tags are not installabe.
+  This is an intentional design.  Because:
+  * It's not possible to determine whether two versions are compatible or not
+    without "version" tags.  Compatibility is a big problem to resolve
+    dependencies of plugins.  For example, if plugin A requires plugin X 1.2.3
+    or later while plugin B requires plugin X 2.0 or later, it's not possible
+    to use A and B at the same time.  Such problems should be detected before
+    installing plugins.
+  * Git mirrors by vim-scripts.org are tagged with version numbers.
+  * Some Git repositories might not have "version" tags.
+    Such plugins are not ready to use for everyone.
+    So that it should not be installable.
+* Plugins must have proper directory structures.
+  For example, directories such as `autoload`, `syntax` etc should exist in
+  the roots of plugins.
+  This is an intentional design.  Because:
+  * Git mirrors by vim-scripts.org have proper directory structures even if
+    the original plugins are uploaded to www.vim.org without proper directory
+    structures.  (A good example is
+    [a.vim](http://www.vim.org/scripts/script.php?script_id=31) and
+    [its mirror](https://github.com/vim-scripts/a.vim).)
+  * Other Git repositoris might not have proper directory structures.
+    Such plugins are not ready to use for everyone.
+    So that it should not be installable.
+
+
 
 
 ## Typical usage

data/lib/vim-flavor.rb

@@ -1,66 +1,24 @@
 require 'bundler/setup'
-require 'fileutils'
-require 'thor'
-require 'vim-flavor/version'
-require 'yaml'
 
 module Vim
   module Flavor
-    module StringExtension
-      def to_flavors_path()
-        "#{self}/flavors"
-      end
+    [
+      :CLI,
+      :Facade,
+      :Flavor,
+      :FlavorFile,
+      :LockFile,
+      :StringExtension,
+      :VERSION,
+      :VersionConstraint,
+    ].each do |name|
+      autoload name, "vim-flavor/#{name.to_s().downcase()}"
     end
 
     class ::String
       include StringExtension
     end
 
-    class VersionConstraint
-      attr_reader :base_version, :operator
-
-      def initialize(s)
-        @base_version, @operator = parse(s)
-      end
-
-      def to_s()
-        "#{@operator} #{@base_version}"
-      end
-
-      def ==(other)
-        self.base_version == other.base_version &&
-          self.operator == other.operator
-      end
-
-      def parse(s)
-        m = /^\s*(>=|~>)\s+(\S+)$/.match(s)
-        if m then
-          [Gem::Version.create(m[2]), m[1]]
-        else
-          raise "Invalid version constraint: #{s.inspect}"
-        end
-      end
-
-      def compatible?(other_version_or_s)
-        v = Gem::Version.create(other_version_or_s)
-        if @operator == '~>' then
-          self.base_version.bump() > v and v >= self.base_version
-        elsif @operator == '>=' then
-          v >= self.base_version
-        else
-          raise NotImplementedError
-        end
-      end
-
-      def find_the_best_version(versions)
-        versions.
-          select {|v| compatible?(v)}.
-          sort().
-          reverse().
-          first
-      end
-    end
-
     class << self
       @@dot_path = File.expand_path('~/.vim-flavor')
 
@@ -72,414 +30,5 @@ module Vim
         @@dot_path = path
       end
     end
-
-    class Flavor
-      @@properties = [
-        :groups,
-        :locked_version,
-        :repo_name,
-        :repo_uri,
-        :version_contraint,
-      ]
-
-      @@properties.each do |p|
-        attr_accessor p
-      end
-
-      def initialize()
-        @groups = []
-      end
-
-      def ==(other)
-        return false if self.class != other.class
-        @@properties.all? do |p|
-          self.send(p) == other.send(p)
-        end
-      end
-
-      def zapped_repo_dir_name
-        @repo_name.gsub(/[^A-Za-z0-9._-]/, '_')
-      end
-
-      def cached_repo_path
-        @cached_repo_path ||=
-          "#{Vim::Flavor.dot_path}/repos/#{zapped_repo_dir_name}"
-      end
-
-      def make_deploy_path(vimfiles_path)
-        "#{vimfiles_path.to_flavors_path()}/#{zapped_repo_dir_name}"
-      end
-
-      def clone()
-        message = %x[
-          {
-            git clone '#{@repo_uri}' '#{cached_repo_path}'
-          } 2>&1
-        ]
-        if $? != 0 then
-          raise RuntimeError, message
-        end
-        true
-      end
-
-      def fetch()
-        message = %x[
-          {
-            cd #{cached_repo_path.inspect} &&
-            git fetch origin
-          } 2>&1
-        ]
-        if $? != 0 then
-          raise RuntimeError, message
-        end
-      end
-
-      def deploy(vimfiles_path)
-        deploy_path = make_deploy_path(vimfiles_path)
-        message = %x[
-          {
-            cd '#{cached_repo_path}' &&
-            git checkout -f #{locked_version.inspect} &&
-            git checkout-index -a -f --prefix='#{deploy_path}/' &&
-            {
-              vim -u NONE -i NONE -n -N -e -s -c '
-                silent! helptags #{deploy_path}/doc
-                qall!
-              ' || true
-            }
-          } 2>&1
-        ]
-        if $? != 0 then
-          raise RuntimeError, message
-        end
-      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
-      end
-
-      def list_versions()
-        tags = %x[
-          {
-            cd '#{cached_repo_path}' &&
-            git tag
-          } 2>&1
-        ]
-        if $? != 0 then
-          raise RuntimeError, message
-        end
-
-        tags.
-          split(/[\r\n]/).
-          select {|t| t != ''}.
-          map {|t| Gem::Version.create(t)}
-      end
-
-      def update_locked_version()
-        @locked_version =
-          version_contraint.find_the_best_version(list_versions())
-      end
-    end
-
-    class FlavorFile
-      attr_reader :flavors
-
-      def initialize()
-        @flavors = {}
-        @default_groups = [:default]
-      end
-
-      def interpret(&block)
-        instance_eval(&block)
-      end
-
-      def eval_flavorfile(flavorfile_path)
-        content = File.open(flavorfile_path, 'rb') do |f|
-          f.read()
-        end
-        interpret do
-          instance_eval(content)
-        end
-      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
-      end
-
-      def flavor(repo_name, *args)
-        options = Hash === args.last ? args.pop : {}
-        options[:groups] ||= []
-        version_contraint = VersionConstraint.new(args.last || '>= 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
-      end
-    end
-
-    class LockFile
-      # TODO: Resolve dependencies recursively.
-
-      attr_reader :flavors, :path
-
-      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])
-      end
-
-      def save()
-        h = {}
-
-        h[:flavors] = self.class.poro_from_flavors(@flavors)
-
-        File.open(@path, 'wb') do |f|
-          YAML.dump(h, f)
-        end
-      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(),
-              }
-            ]
-          }
-        ]
-      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]
-          }
-        ]
-      end
-    end
-
-    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
-      end
-
-      def trace(message)
-        print(message) if @traced
-      end
-
-      def load()
-        @flavorfile = FlavorFile.new()
-        @flavorfile.eval_flavorfile(@flavorfile_path)
-
-        @lockfile = LockFile.new(@lockfile_path)
-        @lockfile.load() if File.exists?(@lockfile_path)
-      end
-
-      def make_new_flavors(current_flavors, locked_flavors, mode)
-        new_flavors = {}
-
-        current_flavors.each do |repo_uri, cf|
-          lf = locked_flavors[repo_uri]
-          nf = cf.dup()
-
-          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
-
-          new_flavors[repo_uri] = nf
-        end
-
-        new_flavors
-      end
-
-      def create_vim_script_for_bootstrap(vimfiles_path)
-        bootstrap_path = "#{vimfiles_path.to_flavors_path()}/bootstrap.vim"
-        FileUtils.mkdir_p(File.dirname(bootstrap_path))
-        File.open(bootstrap_path, 'w') do |f|
-          f.write(<<-'END')
-            function! s:bootstrap()
-              let current_rtp = &runtimepath
-              let current_rtps = split(current_rtp, ',')
-              set runtimepath&
-              let default_rtp = &runtimepath
-              let default_rtps = split(default_rtp, ',')
-              let user_dir = default_rtps[0]
-              let user_after_dir = default_rtps[-1]
-              let base_rtps =
-              \ filter(copy(current_rtps),
-              \        'v:val !=# user_dir && v:val !=# user_after_dir')
-              let flavor_dirs =
-              \ filter(split(glob(user_dir . '/flavors/*'), '\n'),
-              \        'isdirectory(v:val)')
-              let new_rtps =
-              \ []
-              \ + [user_dir]
-              \ + flavor_dirs
-              \ + base_rtps
-              \ + map(reverse(copy(flavor_dirs)), 'v:val . "/after"')
-              \ + [user_after_dir]
-              let &runtimepath = join(new_rtps, ',')
-            endfunction
-
-            call s:bootstrap()
-          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
-
-    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()
-        )
-      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()
-        )
-      end
-    end
   end
 end

data/lib/vim-flavor/cli.rb

@@ -0,0 +1,29 @@
+require 'thor'
+
+module Vim
+  module Flavor
+    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()
+        )
+      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()
+        )
+      end
+    end
+  end
+end

data/lib/vim-flavor/facade.rb

@@ -0,0 +1,156 @@
+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
+      end
+
+      def trace(message)
+        print(message) if @traced
+      end
+
+      def load()
+        @flavorfile = FlavorFile.new()
+        @flavorfile.eval_flavorfile(@flavorfile_path)
+
+        @lockfile = LockFile.new(@lockfile_path)
+        @lockfile.load() if File.exists?(@lockfile_path)
+      end
+
+      def make_new_flavors(current_flavors, locked_flavors, mode)
+        new_flavors = {}
+
+        current_flavors.each do |repo_uri, cf|
+          lf = locked_flavors[repo_uri]
+          nf = cf.dup()
+
+          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
+
+          new_flavors[repo_uri] = nf
+        end
+
+        new_flavors
+      end
+
+      def create_vim_script_for_bootstrap(vimfiles_path)
+        bootstrap_path = "#{vimfiles_path.to_flavors_path()}/bootstrap.vim"
+        FileUtils.mkdir_p(File.dirname(bootstrap_path))
+        File.open(bootstrap_path, 'w') do |f|
+          f.write(<<-'END')
+            function! s:bootstrap()
+              let current_rtp = &runtimepath
+              let current_rtps = split(current_rtp, ',')
+              set runtimepath&
+              let default_rtp = &runtimepath
+              let default_rtps = split(default_rtp, ',')
+              let user_dir = default_rtps[0]
+              let user_after_dir = default_rtps[-1]
+              let base_rtps =
+              \ filter(copy(current_rtps),
+              \        'v:val !=# user_dir && v:val !=# user_after_dir')
+              let flavor_dirs =
+              \ filter(split(glob(user_dir . '/flavors/*'), '\n'),
+              \        'isdirectory(v:val)')
+              let new_rtps =
+              \ []
+              \ + [user_dir]
+              \ + flavor_dirs
+              \ + base_rtps
+              \ + map(reverse(copy(flavor_dirs)), 'v:val . "/after"')
+              \ + [user_after_dir]
+              let &runtimepath = join(new_rtps, ',')
+            endfunction
+
+            call s:bootstrap()
+          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

@@ -0,0 +1,119 @@
+module Vim
+  module Flavor
+    class Flavor
+      @@properties = [
+        :groups,
+        :locked_version,
+        :repo_name,
+        :repo_uri,
+        :version_contraint,
+      ]
+
+      @@properties.each do |p|
+        attr_accessor p
+      end
+
+      def initialize()
+        @groups = []
+      end
+
+      def ==(other)
+        return false if self.class != other.class
+        @@properties.all? do |p|
+          self.send(p) == other.send(p)
+        end
+      end
+
+      def zapped_repo_dir_name
+        @repo_name.gsub(/[^A-Za-z0-9._-]/, '_')
+      end
+
+      def cached_repo_path
+        @cached_repo_path ||=
+          "#{Vim::Flavor.dot_path}/repos/#{zapped_repo_dir_name}"
+      end
+
+      def make_deploy_path(vimfiles_path)
+        "#{vimfiles_path.to_flavors_path()}/#{zapped_repo_dir_name}"
+      end
+
+      def clone()
+        message = %x[
+          {
+            git clone '#{@repo_uri}' '#{cached_repo_path}'
+          } 2>&1
+        ]
+        if $? != 0 then
+          raise RuntimeError, message
+        end
+        true
+      end
+
+      def fetch()
+        message = %x[
+          {
+            cd #{cached_repo_path.inspect} &&
+            git fetch origin
+          } 2>&1
+        ]
+        if $? != 0 then
+          raise RuntimeError, message
+        end
+      end
+
+      def deploy(vimfiles_path)
+        deploy_path = make_deploy_path(vimfiles_path)
+        message = %x[
+          {
+            cd '#{cached_repo_path}' &&
+            git checkout -f '#{locked_version}' &&
+            git checkout-index -a -f --prefix='#{deploy_path}/' &&
+            {
+              vim -u NONE -i NONE -n -N -e -s -c '
+                silent! helptags #{deploy_path}/doc
+                qall!
+              ' || true
+            }
+          } 2>&1
+        ]
+        if $? != 0 then
+          raise RuntimeError, message
+        end
+      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
+      end
+
+      def list_versions()
+        tags = %x[
+          {
+            cd '#{cached_repo_path}' &&
+            git tag
+          } 2>&1
+        ]
+        if $? != 0 then
+          raise RuntimeError, message
+        end
+
+        tags.
+          split(/[\r\n]/).
+          select {|t| t != ''}.
+          map {|t| Gem::Version.create(t)}
+      end
+
+      def update_locked_version()
+        @locked_version =
+          version_contraint.find_the_best_version(list_versions())
+      end
+    end
+  end
+end

data/lib/vim-flavor/flavorfile.rb

@@ -0,0 +1,62 @@
+module Vim
+  module Flavor
+    class FlavorFile
+      attr_reader :flavors
+
+      def initialize()
+        @flavors = {}
+        @default_groups = [:default]
+      end
+
+      def interpret(&block)
+        instance_eval(&block)
+      end
+
+      def eval_flavorfile(flavorfile_path)
+        content = File.open(flavorfile_path, 'rb') do |f|
+          f.read()
+        end
+        interpret do
+          instance_eval(content)
+        end
+      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
+      end
+
+      def flavor(repo_name, *args)
+        options = Hash === args.last ? args.pop : {}
+        options[:groups] ||= []
+        version_contraint = VersionConstraint.new(args.last || '>= 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
+      end
+    end
+  end
+end

data/lib/vim-flavor/lockfile.rb

@@ -0,0 +1,64 @@
+require 'yaml'
+
+module Vim
+  module Flavor
+    class LockFile
+      # TODO: Resolve dependencies recursively.
+
+      attr_reader :flavors, :path
+
+      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])
+      end
+
+      def save()
+        h = {}
+
+        h[:flavors] = self.class.poro_from_flavors(@flavors)
+
+        File.open(@path, 'wb') do |f|
+          YAML.dump(h, f)
+        end
+      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(),
+              }
+            ]
+          }
+        ]
+      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]
+          }
+        ]
+      end
+    end
+  end
+end

data/lib/vim-flavor/stringextension.rb

@@ -0,0 +1,9 @@
+module Vim
+  module Flavor
+    module StringExtension
+      def to_flavors_path()
+        "#{self}/flavors"
+      end
+    end
+  end
+end

data/lib/vim-flavor/version.rb

@@ -1,5 +1,5 @@
 module Vim
   module Flavor
-    VERSION = '0.0.2'
+    VERSION = '0.0.3'
   end
 end

data/lib/vim-flavor/versionconstraint.rb

@@ -0,0 +1,48 @@
+module Vim
+  module Flavor
+    class VersionConstraint
+      attr_reader :base_version, :operator
+
+      def initialize(s)
+        @base_version, @operator = parse(s)
+      end
+
+      def to_s()
+        "#{@operator} #{@base_version}"
+      end
+
+      def ==(other)
+        self.base_version == other.base_version &&
+          self.operator == other.operator
+      end
+
+      def parse(s)
+        m = /^\s*(>=|~>)\s+(\S+)$/.match(s)
+        if m then
+          [Gem::Version.create(m[2]), m[1]]
+        else
+          raise "Invalid version constraint: #{s.inspect}"
+        end
+      end
+
+      def compatible?(other_version_or_s)
+        v = Gem::Version.create(other_version_or_s)
+        if @operator == '~>' then
+          self.base_version.bump() > v and v >= self.base_version
+        elsif @operator == '>=' then
+          v >= self.base_version
+        else
+          raise NotImplementedError
+        end
+      end
+
+      def find_the_best_version(versions)
+        versions.
+          select {|v| compatible?(v)}.
+          sort().
+          reverse().
+          first
+      end
+    end
+  end
+end

data/spec/facade_spec.rb

@@ -250,7 +250,7 @@ describe Vim::Flavor::Facade do
       @flavor = Vim::Flavor::Flavor.new()
       @flavor.repo_name = '@test_repo_path'
       @flavor.repo_uri = @test_repo_path
-      @flavor.locked_version = '1.0.0'
+      @flavor.locked_version = Gem::Version.create('1.0.0')
 
       @flavors = [@flavor]
 

data/spec/flavor_spec.rb

@@ -28,7 +28,7 @@ describe Vim::Flavor::Flavor do
       @flavor = described_class.new()
       @flavor.repo_name = '@test_repo_path'
       @flavor.repo_uri = @test_repo_path
-      @flavor.locked_version = '1.0.0'
+      @flavor.locked_version = Gem::Version.create('1.0.0')
     end
 
     it 'should clone the repository into a given path' do
@@ -51,7 +51,7 @@ describe Vim::Flavor::Flavor do
       @flavor = described_class.new()
       @flavor.repo_name = '@test_repo_path'
       @flavor.repo_uri = @test_repo_path
-      @flavor.locked_version = '1.0.0'
+      @flavor.locked_version = Gem::Version.create('1.0.0')
     end
 
     it 'should fail if the repository is not cloned yet' do
@@ -91,7 +91,7 @@ describe Vim::Flavor::Flavor do
       @flavor = described_class.new()
       @flavor.repo_name = '@test_repo_path'
       @flavor.repo_uri = @test_repo_path
-      @flavor.locked_version = '1.0.0'
+      @flavor.locked_version = Gem::Version.create('1.0.0')
 
       @vimfiles_path = "#{@tmp_path}/vimfiles"
       @deploy_path = @flavor.make_deploy_path(@vimfiles_path)
@@ -117,7 +117,7 @@ describe Vim::Flavor::Flavor do
       $?.should == 0
       tag_id = %x{
         cd #{@flavor.cached_repo_path.inspect} &&
-        git rev-list -n1 #{@flavor.locked_version.inspect}
+        git rev-list -n1 '#{@flavor.locked_version}'
       }
       $?.should == 0
       head_id.should == tag_id
@@ -181,7 +181,7 @@ describe Vim::Flavor::Flavor do
       @flavor = described_class.new()
       @flavor.repo_name = '@test_repo_path'
       @flavor.repo_uri = @test_repo_path
-      @flavor.locked_version = '1.0.0'
+      @flavor.locked_version = Gem::Version.create('1.0.0')
 
       @vimfiles_path = "#{@tmp_path}/vimfiles"
       @deploy_path = @flavor.make_deploy_path(@vimfiles_path)
@@ -209,7 +209,7 @@ describe Vim::Flavor::Flavor do
       @flavor = described_class.new()
       @flavor.repo_name = '@test_repo_path'
       @flavor.repo_uri = @test_repo_path
-      @flavor.locked_version = '1.0.0'
+      @flavor.locked_version = Gem::Version.create('1.0.0')
     end
 
     it 'should list tags as versions' do

metadata

@@ -2,7 +2,7 @@
 name: vim-flavor
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Kana Natsuno
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-27 00:00:00 +09:00
+date: 2012-04-06 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -53,7 +53,14 @@ files:
 - Rakefile
 - bin/vim-flavor
 - lib/vim-flavor.rb
+- lib/vim-flavor/cli.rb
+- lib/vim-flavor/facade.rb
+- lib/vim-flavor/flavor.rb
+- lib/vim-flavor/flavorfile.rb
+- lib/vim-flavor/lockfile.rb
+- lib/vim-flavor/stringextension.rb
 - lib/vim-flavor/version.rb
+- lib/vim-flavor/versionconstraint.rb
 - spec/cli_spec.rb
 - spec/facade_spec.rb
 - spec/flavor_spec.rb