vimpack 0.0.1

data/features/step_definitions/environment_steps.rb

@@ -0,0 +1,3 @@
+Given /^"([^"]*)" is my home directory$/ do |dir_name|
+  set_env "HOME", File.expand_path(File.join(current_dir, dir_name))
+end

data/features/step_definitions/file_utils_steps.rb

@@ -0,0 +1,36 @@
+def check_git_repo(path)
+  prep_for_fs_check do
+    res = %x{ cd #{path} ; git status ; cd - }
+    res.should_not match(/Not a git repo/)
+  end
+end
+
+def check_git_submodule(submodule, repo)
+  name = submodule.split('/')[-1]
+  prep_for_fs_check do
+    res = %x{ cd #{repo} ; git submodule ; cd - }
+    res.should match(/#{name}/)
+  end
+end
+
+Then /^a directory named "([^"]*)" should exist and be a git repo$/ do |directory|
+  check_directory_presence([directory], true)
+  check_git_repo(directory)
+end
+
+Then /^a symlink named "([^"]*)" should exist and link to "([^"]*)"$/ do |link, target|
+  File.should exist(File.join(@dirs, link))
+  require 'pathname'
+  Pathname.new(File.join(@dirs, link)).realpath.to_s.gsub('/private', '').should == File.join(@dirs, target)
+end
+
+Then /^a symlink named "([^"]*)" should not exist$/ do |link|
+  File.exists?(File.join(@dirs, link)).should be_false
+end
+
+Then /^a directory named "([^"]*)" should exist and be a git submodule of "([^"]*)"$/ do |submodule, repo|
+  check_directory_presence([repo], true)
+  check_directory_presence([submodule], true)
+  check_git_submodule(submodule, repo)
+end
+

data/features/step_definitions/initialize_steps.rb

@@ -0,0 +1,14 @@
+Given /^an initialized vimpack in "([^"]*)"$/ do |homedir|
+  steps %Q{
+    Given a directory named "#{homedir}/.vim"
+      And an empty file named "#{homedir}/.vimrc"
+      And "#{homedir}" is my home directory
+    When I run `vimpack -e development init`
+    Then the output should contain "vimpack initialized!"
+  }
+end
+
+Given /^"([^"]*)" is already installed$/ do |script_name|
+  steps %Q{ Given I run `vimpack -e development install #{script_name}` }
+end
+

data/features/step_definitions/output_steps.rb

@@ -0,0 +1,12 @@
+Then /^show me the output$/ do
+  puts all_output
+end
+
+Then /^show me the stdout$/ do
+  puts all_stdout
+end
+
+Then /^show me the stderr$/ do
+  puts all_stderr
+end
+

data/features/step_definitions/vimpack_git_steps.rb

@@ -0,0 +1,91 @@
+def check_vimpack_remote(remote_name, url)
+  prep_for_fs_check do
+    res = %x{ cd test_vimpack/.vimpack ; git config -l ; cd - }
+    res.should match(/remote.#{Regexp.escape(remote_name)}.url=#{Regexp.escape(url)}/)
+  end
+end
+
+def check_vimpack_last_commit_log(message)
+  prep_for_fs_check do
+    res = %x{ cd test_vimpack/.vimpack ; git log -1 ; cd - }
+    res.should match(/#{Regexp.escape(message)}/)
+  end
+end
+
+def check_vimpack_status
+  prep_for_fs_check do
+    res = %x{ cd test_vimpack/.vimpack ; git status ; cd - }
+    res.should match(/#{Regexp.escape('nothing to commit')}/)
+  end
+end
+
+def initialize_git_repo(path)
+  prep_for_fs_check do
+    @full_path = File.join(File.expand_path(FileUtils.pwd), @path)
+  end
+  FileUtils.rmtree(@full_path).should be_true if File::directory?(@full_path)
+  FileUtils.mkdir(@full_path).should be_true
+  res = %x( git init --bare #{@full_path} )
+  $?.should eq(0)
+end
+
+
+Then /^the vimpack git remote "([^"]*)" should be "([^"]*)"$/ do |remote_name, url|
+  check_vimpack_remote(remote_name, url)
+end
+
+Then /^the vimpack git commit logs last message should be "([^"]*)"$/ do |message|
+  check_vimpack_last_commit_log(message)
+end
+
+Then /^the vimpack git status should be empty$/ do
+  check_vimpack_status
+end
+
+Given /^an initialized git repo in "([^"]*)"$/ do |path|
+  @path = path
+  @full_path = nil
+  initialize_git_repo(@path)
+end
+
+Given /^an existing git repo in "([^"]*)"$/ do |path|
+  steps %Q{
+    Given an initialized git repo in "#{path}"
+      And I run `vimpack -e development git remote add origin /tmp/aruba/#{path}`
+    When I run `vimpack -e development git publish -m '[TEST] testing vimpack'`
+    Then the exit status should be 0
+      And the output should contain:
+        """
+         * publishing vimpack repo
+        vimpack repo published!
+        """
+      And the vimpack git remote "origin" should be "/tmp/aruba/#{path}"
+  }
+end
+
+Given /^an initialized vimpack in "([^"]*)" from remote "([^"]*)"$/ do |homedir, remote_path|
+  steps %Q{
+    Given a directory named "#{homedir}/.vim"
+      And an empty file named "#{homedir}/.vimrc"
+      And "#{homedir}" is my home directory
+    When I run `vimpack -e development init /tmp/aruba/#{remote_path}`
+    Then the exit status should be 0
+      And the output should contain "vimpack initialized!"
+      And the vimpack git remote "origin" should be "/tmp/aruba/#{remote_path}"
+  }
+end
+
+Given /^an initialized vimpack in "([^"]*)" that is out of sync with its remote$/ do |path|
+  steps %Q{
+    Given an initialized vimpack in "#{path}"
+      And "rails.vim" is already installed
+      And an existing git repo in "vimpack-repo"
+      And an initialized vimpack in "test_vimpack_remoted" from remote "vimpack-repo"
+      And "#{path}" is my home directory
+      And "cucumber.zip" is already installed
+      And I run `vimpack -e development git publish -m '[CUKE] added cucumber.zip'`
+      And "test_vimpack_remoted" is my home directory
+      And "haml.zip" is already installed
+  }
+end
+

data/features/support/env.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__), '..', '..', 'lib')
+require 'vimpack'
+require 'cucumber/formatter/unicode' # Remove this line if you don't want Cucumber Unicode support
+require 'aruba/cucumber'
+
+Before do
+  FileUtils.rmtree('/tmp/aruba')
+  @dirs = ["/tmp/aruba"]
+  @aruba_timeout_seconds = 60
+end
+

data/features/support/executable_paths.rb

@@ -0,0 +1,15 @@
+#module ArubaOverrides
+#  def detect_ruby_script(cmd)
+#    puts "CMD IS: #{cmd}"
+#    if cmd =~ /^vimpack /
+#      lib_path = File.join(File.dirname(__FILE__), '..', '..', 'lib')
+#      cmd_path = File.join(File.dirname(__FILE__), '..', '..', 'bin', cmd)
+#      puts "RUNNING VIMPACK!"
+#      "ruby -I#{lib_path} -S #{cmd_path}"
+#    else
+#      super(cmd)
+#    end
+#  end
+#end
+#
+#World(ArubaOverrides)

data/lib/vimpack/commands/command.rb

@@ -0,0 +1,46 @@
+module Vimpack
+  module Commands
+    class Command
+      include ::Vimpack::Utils::File
+      include ::Vimpack::Utils::Io
+      include ::Vimpack::Utils::Git
+      include ::Vimpack::Utils::Process
+
+      def initialize(options, global_options)
+        @options = options
+        @global_options = global_options
+        @commands = ARGV
+        setup_paths(@options[:home_directory] || ENV['HOME'])
+        initialize_environment
+        initialize_global_options
+        initialize_options
+        initialize_commands
+      end
+
+      def initialize_environment
+        Vimpack.environment = @global_options[:environment].to_sym
+        unless Vimpack.env?('production')
+          say(" * using environment #{Vimpack.environment.inspect}")
+        end
+      end
+
+      def initialize_global_options
+      end
+
+      def initialize_options
+      end
+
+      def initialize_commands
+      end
+
+      def run
+        raise NotImplemented
+      end
+
+      def self.run(options = Hash.new, commands = Hash.new)
+        new(options, commands).run
+      end
+
+    end
+  end
+end

data/lib/vimpack/commands/git.rb

@@ -0,0 +1,32 @@
+module Vimpack
+  module Commands
+    class Git < Command
+      SUB_COMMANDS = %w{ publish }
+
+      def initialize_commands
+        die!("git requires at least one argument") if @commands.size < 1
+        @subcommand = @commands.shift
+      end
+
+      def run
+        return git_exec unless SUB_COMMANDS.include?(@subcommand)
+        send("git_#{@subcommand}".to_sym)
+      end
+
+      def git_publish
+        say(" * publishing vimpack repo")
+        Vimpack::Models::Repo.publish!(@options[:message])
+        say("vimpack repo published!")
+      end
+
+      def git_exec
+        say(" * running git #{@subcommand} #{@commands.join(' ')}")
+        command = Vimpack::Models::Repo.git_exec(@subcommand, @commands)
+        say("command complete!")
+        say(command.message, :default)
+      end
+
+    end
+  end
+end
+

data/lib/vimpack/commands/info.rb

@@ -0,0 +1,26 @@
+module Vimpack
+  module Commands
+    class Info < Command
+
+      def initialize_commands
+        die!("info requires a single argument") unless @commands.size == 1
+        @script_name = @commands[0]
+      end
+
+      def run
+        begin
+          script = Vimpack::Models::Script.info(@script_name)
+        rescue Vimpack::Models::Script::ScriptNotFound
+          return exit_with_error!('Script not found!')
+        end
+        say("Name: #{script.name}")
+        say("Author: #{script.author}")
+        say("Version: #{script.version} (#{script.version_date})")
+        say("Type: #{script.type}")
+        say("Description: #{script.description}")
+      end
+
+    end
+  end
+end
+

data/lib/vimpack/commands/init.rb

@@ -0,0 +1,23 @@
+module Vimpack
+  module Commands
+    class Init < Command
+      def initialize_commands
+        die!("init takes a single optional argument") if @commands.size > 1
+        @repo_url = @commands.size == 1 ? @commands[0] : nil
+      end
+
+      def run
+        say(start_message)
+        Vimpack::Models::Repo.initialize!(@repo_url)
+        say('vimpack initialized!')
+      end
+
+      private
+
+        def start_message
+          " * initializing vimpack repo#{@repo_url.nil? ? '' : " from #{@repo_url}"}"
+        end
+
+    end
+  end
+end

data/lib/vimpack/commands/install.rb

@@ -0,0 +1,35 @@
+module Vimpack
+  module Commands
+    class Install < Command
+
+      def initialize_commands
+        die!("install requires at least one script name argument") unless @commands.size >= 0
+        @script_names = @commands
+      end
+
+      def run
+        @script_names.each do |script_name|
+          begin
+            script = Vimpack::Models::Script.get(script_name)
+          rescue Vimpack::Models::Script::ScriptNotFound
+            exit_with_did_you_mean!(script_name)
+          end
+          say(" * installing #{script.name}")
+          script.install!
+          say("#{script.name} (#{script.version}) installed!")
+        end
+      end
+
+      private
+
+        def exit_with_did_you_mean!(script_name)
+          possible = Vimpack::Models::Script.search(script_name).first rescue nil
+          return possible.nil? ?
+            exit_with_error!('Script not found!') :
+            exit_with_error!("Script not found! Did you mean #{possible.name}?")
+        end
+
+    end
+  end
+end
+

data/lib/vimpack/commands/list.rb

@@ -0,0 +1,14 @@
+module Vimpack
+  module Commands
+    class List < Command
+
+      def run
+        Vimpack::Models::Repo.installed_scripts.each do |script|
+          say(script.name)
+        end
+      end
+
+    end
+  end
+end
+

data/lib/vimpack/commands/search.rb

@@ -0,0 +1,37 @@
+module Vimpack
+  module Commands
+    class Search < Command
+
+      def initialize_options
+        @conditions = Vimpack::Models::Script::SCRIPT_TYPES.map.inject([]) do |conditions, script_type|
+          conditions << script_type if @options[script_type.gsub(' ', '_').to_sym]
+          conditions
+        end
+      end
+
+      def initialize_commands
+        die!("search requires a single argument") unless (@commands.size == 1 || !@conditions.empty?)
+        @pattern = @commands[0] if @commands.size >= 1
+      end
+
+      def run
+        scripts = Vimpack::Models::Script.search(@pattern, @conditions)
+        return exit_with_error!('No scripts found!', 0) if scripts.empty?
+        say_justified_script_names(scripts)
+      end
+
+      private
+
+        def say_justified_script_names(scripts)
+          linesize = scripts.sort do |a,b|
+            a.name.size <=> b.name.size
+          end.reverse.first.name.size + 1
+          scripts.each do |script|
+            say("#{script.name.ljust(linesize)} #{script.type}")
+          end
+        end
+
+    end
+  end
+end
+

data/lib/vimpack/commands/uninstall.rb

@@ -0,0 +1,27 @@
+module Vimpack
+  module Commands
+    class Uninstall < Command
+
+      def initialize_commands
+        die!("uninstall requires at least one script name argument") unless @commands.size >= 0
+        @script_names = @commands
+      end
+
+      def run
+        @script_names.each do |script_name|
+          begin
+            script = ::Vimpack::Models::Script.get(script_name)
+            return exit_with_error!('Script not found!') unless file_exists?(script.install_path)
+          rescue ::Vimpack::Models::Script::ScriptNotFound
+            return exit_with_error!('Script not found!')
+          end
+          say(" * uninstalling #{script.name}")
+          script.uninstall!
+          say("#{script.name} uninstalled!")
+        end
+      end
+
+    end
+  end
+end
+

data/lib/vimpack/commands.rb

@@ -0,0 +1,8 @@
+require 'vimpack/commands/command'
+require 'vimpack/commands/init'
+require 'vimpack/commands/search'
+require 'vimpack/commands/install'
+require 'vimpack/commands/uninstall'
+require 'vimpack/commands/list'
+require 'vimpack/commands/info'
+require 'vimpack/commands/git'

data/lib/vimpack/models/apibase.rb

@@ -0,0 +1,7 @@
+module Vimpack
+  module Models
+    class ApiBase < Base
+      include ::Vimpack::Utils::Api
+    end
+  end
+end

data/lib/vimpack/models/base.rb

@@ -0,0 +1,29 @@
+module Vimpack
+  module Models
+
+    class Base
+      class << self
+
+        include ::Vimpack::Utils::File
+        include ::Vimpack::Utils::Git
+
+        attr_reader :attributes
+        def attributes(*attribute_names)
+          return @attributes if attribute_names.empty?
+          attribute_names = attribute_names.map(&:to_sym)
+          @attributes = attribute_names
+          attr_accessor *attribute_names
+        end
+
+      end
+      setup_paths(ENV['HOME'])
+
+      def initialize(attributes = Hash.new)
+        attributes.each do |name, value|
+          send("#{name}=".to_sym, value)
+        end
+      end
+
+    end
+  end
+end

data/lib/vimpack/models/repo.rb

@@ -0,0 +1,117 @@
+module Vimpack
+  module Models
+
+    class Repo < Base
+      class AlreadyInitialized < StandardError ; end
+      class NotInitialized < StandardError ; end
+      class OriginRemoteUnset < StandardError ; end
+
+      class << self
+        include ::Vimpack::Utils::File
+        include ::Vimpack::Utils::Git
+
+        def initialize!(repo_url=nil)
+          raise_if_initialized!
+          @repo_url = repo_url
+          backup_existing_vim_environment
+          @repo_url.nil? ? initialize_vimpack_repo : initialize_vimpack_remote_repo
+        end
+
+        def initialized?
+          directory_exists?(pack_path.to_s)
+        end
+
+        def raise_if_initialized!
+          raise AlreadyInitialized if initialized?
+        end
+
+        def raise_unless_initialized!
+          raise NotInitialized unless initialized?
+        end
+
+        def publish!(message)
+          raise OriginRemoteUnset unless origin_set?
+          repo_add_dot
+          repo_commit(message)
+          repo_push
+          true
+        end
+
+        def git_exec(subcommand, commands)
+          repo_exec(subcommand, commands)
+        end
+
+        def installed_script_names
+          Dir.glob(script_directories).each.inject([]) do |scripts, script_dir|
+            script_name = ::File.split(script_dir)[-1]
+            scripts << script_name unless script_name == 'pathogen.vim'
+            scripts
+          end
+        end
+
+        def installed_scripts
+          installed_script_names.each.inject([]) do |scripts, script_name|
+            scripts << Script.info(script_name)
+          end
+        end
+
+        private
+        def script_directories
+          Script::SCRIPT_TYPES.map do |script_type|
+            script_path.join(script_type.gsub(' ', '_'), '*')
+          end
+        end
+
+        def origin_set?
+          repo_remote?('origin')
+        end
+
+        def initialize_vimpack_remote_repo
+          repo_clone(@repo_url, self.pack_path.to_s)
+          init_submodule
+          update_submodule
+          link_dot_vim
+          initialize_vimrc
+        end
+
+        def backup_existing_vim_environment
+          move_path(home_path.join('.vim'), home_path.join('.vim.before_vimpack'))
+          move_path(home_path.join('.vimrc'), home_path.join('.vimrc.before_vimpack'))
+        end
+
+        def initialize_vimpack_repo
+          %w{ autoload bundle }.each do |directory|
+            make_dir(vim_path.join(directory))
+            ::FileUtils.touch(vim_path.join(directory, '.gitkeep'))
+          end
+          make_dir(script_path.to_s)
+          create_vimpack_repo
+          initialize_pathogen_submodule
+          link_dot_vim
+          initialize_vimrc
+        end
+
+        def link_dot_vim
+          create_link(self.vim_path.to_s, self.home_path.join('.vim'))
+        end
+
+        def initialize_pathogen_submodule
+          Script.get('pathogen.vim').install!(false)
+          create_link(script_path.join('utility', 'pathogen.vim', 'plugin', 'pathogen.vim'),
+                      vim_path.join('autoload', 'pathogen.vim'))
+        end
+
+        def create_vimpack_repo
+          init_repo(pack_path)
+        end
+
+        def initialize_vimrc
+          template('vimrc', self.pack_path.join('vimrc')) unless ::File.exists?(self.pack_path.join('vimrc'))
+          create_link(self.pack_path.join('vimrc'), self.home_path.join('.vimrc'))
+        end
+
+      end
+      setup_paths(ENV['HOME'])
+    end
+  end
+end