vimpack 0.0.1

data/lib/vimpack/models/script.rb

@@ -0,0 +1,110 @@
+module Vimpack
+  module Models
+
+    class Script
+      include Vimpack::Utils::Vimscripts
+      include Vimpack::Utils::Github
+
+      class ScriptNotFound < StandardError; end
+      class AlreadyInstalled < StandardError; end
+      class NotInstalled < StandardError; end
+
+      # From Vimscripts.org
+      attr_reader :name, :type, :version, :version_date, :author, :author_email
+      # From Github
+      attr_reader :url, :description
+
+      SCRIPT_TYPES = [ 'utility', 'color scheme', 'syntax', 'ftplugin',
+                       'indent', 'game', 'plugin', 'patch' ]
+
+      def initialize(attrs={})
+        set_attributes_from_input(attrs)
+        set_attributes_from_github
+      end
+
+      def set_attributes_from_input(attrs)
+        attrs.each_pair do |attr, value|
+          instance_variable_set("@#{attr}".to_sym, value)
+        end
+      end
+
+      def set_attributes_from_github
+        url = "vim-scripts/#{name}"
+        @repo = self.class.repo("vim-scripts/#{name}")
+        [ :url, :description ].each { |attr| instance_variable_set("@#{attr}".to_sym, @repo[attr]) }
+        set_version_from_github
+      end
+
+      def commits
+        @commits ||= self.class.commits(@repo).sort do |a, b|
+          a.authored_date <=> b.authored_date
+        end
+      end
+
+      def set_version_from_github
+        last_commit = commits.last
+        @version = last_commit.message[0..10].gsub(/Version /, '')
+        @version_date = last_commit.authored_date
+      end
+
+      def self.search(q, types = [], limit = 10, offset = 0)
+        search_vimscripts(q, types).map do |vimscript|
+          Script.new(vimscript)
+        end
+      end
+
+      def self.get(name)
+        vimscript = get_vimscript(name)
+        raise ScriptNotFound.new(name) if vimscript.nil?
+        Script.new(vimscript)
+      end
+
+      def self.info(name)
+        get(name)
+      end
+
+      def install!(link_to_bundle=true)
+        Repo.raise_unless_initialized!
+        raise AlreadyInstalled.new(name) if installed?
+        Repo.add_submodule(url, type.gsub(' ', '_'), name)
+        if link_to_bundle
+          Repo.create_link(install_path, bundle_path)
+        end
+        true
+      end
+
+      def uninstall!
+        Repo.raise_unless_initialized!
+        raise NotInstalled.new(name) unless installed?
+        Repo.remove_submodule(type.gsub(' ', '_'), name)
+        Repo.remove_link(bundle_path) if Repo.symlink_exists?(bundle_path)
+        true
+      end
+
+      def installed?
+        Repo.initialized? && Repo.directory_exists?(install_path)
+      end
+
+      def installable?
+        Repo.initialized? && !installed?
+      end
+
+      def install_path
+        Repo.script_path.join(type.gsub(' ', '_'), name)
+      end
+
+      def bundle_path
+        Repo.bundle_path.join(name)
+      end
+
+      private
+
+        def self.script_not_found(name)
+          scripts = search(name, Array.new, 1)
+          return exit_with_error!("Script not found! Did you mean #{scripts.first.name}?") if scripts.any?
+          exit_with_error!('Script not found!')
+        end
+
+    end
+  end
+end

data/lib/vimpack/models.rb

@@ -0,0 +1,8 @@
+module Vimpack
+  module Models
+    autoload :Base,    'vimpack/models/base'
+    autoload :ApiBase, 'vimpack/models/apibase'
+    autoload :Script,  'vimpack/models/script'
+    autoload :Repo,    'vimpack/models/repo'
+  end
+end

data/lib/vimpack/utils/api.rb

@@ -0,0 +1,39 @@
+module Vimpack
+  module Utils
+    module Api
+
+      def self.included(base)
+        base.send(:extend,  ClassMethods)
+        unless Vimpack.env?('production')
+          require 'vcr'
+          VCR.config do |c|
+            c.cassette_library_dir     = Vimpack.root.join('cassette_library')
+            c.stub_with                :webmock
+            c.ignore_localhost         = true
+            c.default_cassette_options = { :record => :new_episodes }
+          end
+        end
+      end
+
+      module ClassMethods
+
+       def wrap_open(*args)
+          wrap_http_call do
+            open(*args)
+          end
+        end
+
+        def wrap_http_call(cassette_name='vimpack')
+          raise StandardError.new('you must give a block to wrap_http_call') unless block_given?
+          if Vimpack.env?(:production)
+            yield
+          else
+            VCR.use_cassette(cassette_name) do
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vimpack/utils/file.rb

@@ -0,0 +1,66 @@
+module Vimpack
+  module Utils
+
+    module File
+
+      attr_accessor :home_path, :pack_path, :script_path, :vim_path, :bundle_path
+
+      def setup_paths(home_path)
+        self.home_path   = FilePath.new(home_path)
+        self.pack_path   = FilePath.new(self.home_path.join('.vimpack'))
+        self.script_path = FilePath.new(self.pack_path.join('scripts'))
+        self.vim_path    = FilePath.new(self.pack_path.join('vim'))
+        self.bundle_path = FilePath.new(self.vim_path.join('bundle'))
+      end
+
+      def file_exists?(filename)
+        ::File.exists?(filename)
+      end
+
+      def directory_exists?(directory)
+        ::File::directory?(directory)
+      end
+
+      def symlink_exists?(linkname)
+        ::File.exists?(linkname) && ::File.stat(linkname).symlink?
+      end
+
+      def create_link(target, linkname, relative=true)
+        target = Pathname.new(target).relative_path_from(
+          Pathname.new(::File.dirname(linkname))
+        ) if relative
+        ::FileUtils.ln_s(target, linkname)
+      end
+
+      def remove_link(link)
+        ::FileUtils.rm(link)
+      end
+
+      def remove_directory(directory)
+        exit_with_error!("no way!") if directory == '/'
+        ::FileUtils.rmtree(directory)
+      end
+
+      def move_path(source, target)
+        ::FileUtils.mv(source, target) if file_exists?(source)
+      end
+
+      def make_dir(*paths)
+        ::FileUtils.mkdir_p(*paths)
+      end
+
+      def template_path(*path)
+        Vimpack.root.join('templates', *path)
+      end
+
+      def template(name, path)
+        name = name + '.erb'
+        contents = ::ERB.new(::File.read(template_path(name))).result(binding)
+        target = ::File.open(path, 'w')
+        target.write(contents)
+        target.close
+      end
+
+    end
+  end
+end

data/lib/vimpack/utils/file_path.rb

@@ -0,0 +1,25 @@
+module Vimpack
+  module Utils
+
+    class FilePath
+      attr_accessor :base_path
+      def initialize(base_path)
+        self.base_path = base_path
+      end
+
+      def base_path=(base_path)
+        @base_path = ::File.expand_path(base_path)
+      end
+      
+      def join(*paths)
+        ::File.join(@base_path, *paths)
+      end
+
+      def to_s
+        @base_path
+      end
+
+    end
+
+  end
+end

data/lib/vimpack/utils/git.rb

@@ -0,0 +1,103 @@
+module Vimpack
+  module Utils
+    module Git
+
+      include Process
+
+      def init_repo(path, bare=false)
+        run_process_or_die!("git init --quiet#{bare == true ? ' --bare' : ''}", path)
+      end
+
+      def add_submodule(repo_uri, *paths)
+        parent, name = paths[0..-2], paths[-1]
+        path = ::File.join('scripts', *paths)
+        run_process_or_die!("git submodule add #{repo_uri} #{path}",
+                            self.pack_path)
+        init_submodule(path)
+        update_submodule(path)
+      end
+
+      def replace_contents(path, match, new='')
+        contents = ::File.read(path)
+        contents = contents.sub(match, new)
+        ::File.open(path, 'w') do |file|
+          file.write(contents)
+        end
+      end
+
+      def remove_submodule(*paths)
+        path = ::File.join('scripts', *paths)
+        submod_match = ::Regexp.escape("[submodule \"#{path}\"]") + '\n.*\n.*'
+        config_match = ::Regexp.escape("[submodule \"#{path}\"]") + '\n.*'
+        replace_contents(self.pack_path.join('.gitmodules'), submod_match)
+        replace_contents(self.pack_path.join('.git', 'config'), config_match)
+        remove_link(self.bundle_path.join(paths[-1]))
+        remove_directory(self.pack_path.join(path))
+        run_process_or_die!("git rm -r #{path}", self.pack_path)
+      end
+
+      def init_submodule(path='')
+        run_process_or_die!("git submodule init #{path}", self.pack_path)
+      end
+
+      def update_submodule(path='')
+        run_process_or_die!("git submodule update #{path}", self.pack_path)
+      end
+
+      def repo_add_remote(name, path)
+        cmd = "git remote add #{name} #{path}"
+        run_process_or_die!(cmd, self.pack_path.to_s)
+      end
+
+      def repo_remote?(name)
+        remotes = run_process_and_wait!("git remote show #{name}", pack_path.to_s)
+        !remotes.message.include?('does not appear to be a git') && remotes.message.include?(name)
+      end
+
+
+      def repo_commit(msg='')
+        msg = '[VIMPACK] vimpack updated' if msg == ''
+        cmd = "git add . && git commit -m '#{msg}'"
+        run_process_or_die!(cmd, self.pack_path.to_s)
+      end
+
+      def repo_pull(remote_path='origin master')
+        run_process_or_die!("git pull #{remote_path}", self.pack_path.to_s)
+      end
+
+      def repo_push
+        cmd = "git push origin master"
+        error_message = <<-EOE
+error: local repo out of sync with remote
+  use git to sync with something like this:
+   vimpack git fetch && vimpack git merge origin/master
+        EOE
+        run_process_or_die!(cmd, self.pack_path.to_s, error_message)
+      end
+
+      def repo_clone(repo_url, path)
+        cmd = "git clone #{repo_url} #{path}"
+        run_process_or_die!(cmd)
+      end
+
+      def repo_add_dot
+        cmd = "git add ."
+        run_process_or_die!(cmd, self.pack_path.to_s)
+      end
+
+      def repo_exec(subcommand, commands)
+        commands = sanitize_commands(commands)
+        cmd = "git #{subcommand} #{commands}"
+        run_process_or_die!(cmd, self.pack_path.to_s)
+      end
+
+      def sanitize_commands(commands)
+        commands.each.inject('') do |full_command, command|
+          full_command << ' ' unless full_command == ''
+          full_command << (command.include?(' ') ? "'#{command}'" : command)
+        end
+      end
+
+    end
+  end
+end

data/lib/vimpack/utils/github.rb

@@ -0,0 +1,41 @@
+module Vimpack
+  module Utils
+    module Github
+
+      def self.included(base)
+        base.send(:include, Vimpack::Utils::Api)
+        base.send(:extend, ClassMethods)
+      end
+
+      module ClassMethods
+
+        def octokit
+          @octokit ||= Octokit::Client.new
+        end
+
+        def search_all_repos(q, options = {})
+          search_repositories(CGI.escape(q), options.merge(:language => 'VimL')).delete_if do |repo|
+            repo.name.downcase.include?('dotfiles') ||
+              repo.description.downcase.include?('dotfiles')
+          end
+        end
+
+        def search_vimscript_repos(q)
+          search_all_repos(q).delete_if { |repo| !(repo.owner == 'vim-scripts') }
+        end
+
+        def respond_to?(meth)
+          octokit.respond_to?(meth) || super
+        end
+
+        def method_missing(meth, *args)
+          if octokit.respond_to?(meth)
+            return wrap_http_call { octokit.send(meth, *args) }
+          end
+          super
+        end
+
+      end
+    end
+  end
+end

data/lib/vimpack/utils/io.rb

@@ -0,0 +1,26 @@
+module Vimpack
+  module Utils
+    module Io
+
+      def say(message, color=:green)
+        puts message.color(color) unless message.nil?
+      end
+
+      def scream(message)
+        say(message, :red)
+      end
+
+      def die!(message=nil)
+        scream(message)
+        return Trollop::die USAGE
+      end
+
+      def exit_with_error!(message=nil, exit_code=1)
+        scream(message) unless message.nil?
+        exit(exit_code)
+      end
+
+    end
+  end
+end
+

data/lib/vimpack/utils/process.rb

@@ -0,0 +1,61 @@
+module Vimpack
+  module Utils
+    module Process
+      include Io
+
+      class Results
+        attr_accessor :process, :message
+        def initialize(process, message=nil)
+          self.process = process
+          self.message = message
+        end
+      end
+
+      def run_process!(cmd)
+        child = ::ChildProcess.build(cmd)
+        child.io.stdout = ::Tempfile.new('child-out')
+        child.io.stderr = ::Tempfile.new('child-err')
+        child.start
+        child
+        Results.new(child)
+      end
+
+      def wait_for_child(child, timeout=30)
+        child.process.poll_for_exit(timeout.to_f)
+        child.process.stop unless child.process.exited?
+        child.process.io.stdout.close
+        child.process.io.stderr.close
+        child.process.io.stdout.open
+        child.process.io.stderr.open
+        child.message = child.process.io.stdout.read
+        child.message << " "
+        child.message << child.process.io.stderr.read
+        child
+      end
+
+      def run_process_and_wait!(cmd, dir=nil)
+        child = nil
+        within_dir(dir) do
+          child = run_process!(cmd)
+        end
+        child = wait_for_child(child)
+      end
+
+      def run_process_or_die!(cmd, dir=nil, err_msg=nil)
+        child = run_process_and_wait!(cmd, dir)
+        child.message << err_msg if err_msg
+        exit_with_error!("child process died:\n#{child.message}") unless child.process.exit_code == 0
+        child
+      end
+
+      def within_dir(dir=nil, &block)
+        orig_path = Dir.pwd
+        dir = dir.nil? ? orig_path : dir.to_s
+        ::Dir.chdir(dir)
+        block.call
+        ::Dir.chdir(orig_path)
+      end
+
+    end
+  end
+end

data/lib/vimpack/utils/vimscripts.rb

@@ -0,0 +1,64 @@
+module Vimpack
+  module Utils
+    module Vimscripts
+
+      def self.included(base)
+        base.send(:include, Vimpack::Utils::Api)
+        base.send(:extend,  ClassMethods)
+      end
+
+      module ClassMethods
+
+        def vimscripts_url
+          'http://vim-scripts.org/api/scripts_recent.json'
+        end
+
+        def vimscripts
+          # {"n"=>"test.vim", "t"=>"utility", "s"=>"example utility script file -- used for testing vimonline", "rv"=>"1.0", "rd"=>"2001-05-28", "ra"=>"Scott Johnston", "re"=>"scrott@users.sourceforge.net"}
+          @vimscripts ||= Yajl.load(wrap_open(vimscripts_url))
+          @vimscripts.clone
+        end
+
+        def search_vimscripts(q, types = [], limit = 10, offset = 0)
+          results = q.nil? ? vimscripts : search_for_string(q, vimscripts)
+          results = types.empty? ? results : search_for_type(types, results)
+          normalize_results(limit, offset, results)
+        end
+
+        def normalize_results(limit, offset, results)
+          results[offset..limit-1].map do |script|
+            normalize_vimscript(script)
+          end
+        end
+
+        def search_for_type(types, results)
+          results.delete_if do |vimscript|
+            !types.include?(vimscript['t'])
+          end
+        end
+
+        def search_for_string(q, results)
+          q = q.downcase
+          results.delete_if do |vimscript|
+            !(vimscript['n'].downcase.include?(q) or vimscript['s'].downcase.include?(q))
+          end
+        end
+
+        def get_vimscript(name)
+          results = vimscripts.delete_if do |vimscript|
+            !(vimscript['n'] == name)
+          end
+          normalize_vimscript(results.first) rescue nil
+        end
+
+        def normalize_vimscript(script)
+          { :name => script['n'], :type => script['t'],
+            :description => script['s'], :script_version => script['rv'],
+            :author => script['ra'], :author_email => script['re']
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/vimpack/version.rb

@@ -0,0 +1,4 @@
+module Vimpack
+  # FIXME: shouldn't have to have this unless statement
+  VERSION = "0.0.1" unless const_defined?('VERSION')
+end

data/lib/vimpack.rb

@@ -0,0 +1,46 @@
+require 'fileutils'
+require 'tempfile'
+require 'erb'
+require 'pathname'
+require 'open-uri'
+require 'cgi'
+
+require "bundler/setup"
+#Bundler.require :default
+
+require 'active_model'
+require 'trollop'
+# TODO: term-ascicolor is required by rails/rspec/cuke
+# or something in rails stack me thinks...maybe us it instead
+require 'rainbow'
+require 'childprocess'
+# TODO: let active support figure out what json to use
+require 'yajl'
+require 'enviro'
+require 'nokogiri'
+require 'octokit'
+
+# vimpack
+module Vimpack
+  include Enviro::Environate
+
+  autoload :Models,   'vimpack/models'
+  autoload :Commands, 'vimpack/commands'
+  module Utils
+    autoload :FilePath,   'vimpack/utils/file_path'
+    autoload :File,       'vimpack/utils/file'
+    autoload :Io,         'vimpack/utils/io'
+    autoload :Process,    'vimpack/utils/process'
+    autoload :Git,        'vimpack/utils/git'
+    autoload :Api,        'vimpack/utils/api'
+    autoload :Vimscripts, 'vimpack/utils/vimscripts'
+    autoload :Github,     'vimpack/utils/github'
+  end
+
+  def self.root
+    @root ||= Vimpack::Utils::FilePath.new(File.join(File.dirname(__FILE__), '..'))
+  end
+
+end
+
+

data/simplecov_setup.rb

@@ -0,0 +1,5 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/features/'
+  add_filter '/spec/'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '..', 'simplecov_setup')
+require 'vimpack'
+
+def check_git_repo(path)
+  res = %x{ ( cd #{path} ; git status ; cd - )2>&1 }
+  res.should_not match(/Not a git repo/)
+end
+
+def check_git_submodule(submodule, repo)
+  name = submodule.split('/')[-1]
+  res = %x{ ( cd #{repo} ; git submodule ; cd - )2>&1 }
+  res.should match(/#{name}/)
+end
+
+def check_vimpack_remote(remote_name, url)
+  res = %x{ cd /tmp/vimpack_home/.vimpack ; git config -l ; cd - }
+  res.should match(/remote.#{Regexp.escape(remote_name)}.url=#{Regexp.escape(url)}/)
+end
+
+HOME = '/tmp/vimpack_home'
+ENV['HOME'] = HOME
+def remove_temp_home
+  ::FileUtils.rm_rf(HOME) if ::File.exists?(HOME)
+  ::FileUtils.mkdir(HOME)
+end
+
+RSpec.configure do |config|
+  config.before(:each) do
+    remove_temp_home
+  end
+end
+