kmc 0.0.6

data/lib/kmc/git_adapter.rb

@@ -0,0 +1,71 @@
+module Kmc
+  module GitAdapter
+    class << self
+      def init_repo(path)
+        Dir.chdir(path) do
+          `git init`
+          `git config user.name KMC`
+          `git config user.email kmc@kmc.kmc`
+          `git config core.autocrlf false`
+
+          File.open('.gitignore', 'w') do |file|
+            file.write "!*\n"
+          end
+        end
+      end
+
+      def commit_everything(repo_path, commit_message)
+        Dir.chdir(repo_path) do
+          `git add -A -f`
+          `git commit --allow-empty -m "#{commit_message}"`
+        end
+      end
+
+      def revert_commit(repo_path, commit)
+        Dir.chdir(repo_path) do
+          # Favor "ours" (which is always HEAD for our purposes) when git-revert
+          # can handle that on its own.
+          `git revert --no-commit --strategy=merge --strategy-option=ours #{commit.sha}`
+
+          # When files are being created or deleted, git will not do anything.
+          # In this case, keep all files alive; better to accidentally pollute
+          # than accidentally delete something important.
+          `git add *`
+        end
+      end
+
+      def list_commits(repo_path)
+        Dir.chdir(repo_path) do
+          `git log --oneline`.lines.map do |line|
+            sha, message = line.split(' ', 2)
+            Commit.new(message, sha)
+          end
+        end
+      end
+    end
+
+    class Commit < Struct.new(:message, :sha)
+      def pre?
+        type == :pre
+      end
+
+      def post?
+        type == :post
+      end
+
+      def uninstall?
+        type == :uninstall
+      end
+
+      def type
+        # "POST: Example" --> :post
+        message.split(':').first.downcase.to_sym
+      end
+
+      def subject
+        # "POST: Example\n" --> "Example"
+        message.split(' ', 2).last.strip
+      end
+    end
+  end
+end

data/lib/kmc/package.rb

@@ -0,0 +1,142 @@
+require 'pathname'
+require 'httparty'
+require 'zip'
+require 'tmpdir'
+require 'damerau-levenshtein'
+
+require_relative 'package_utils'
+
+module Kmc
+  class Package
+    include PackageDsl
+
+    class << self
+      include PackageAttrs, PackageUtils
+
+      attr_reader :ksp_path, :download_dir, :do_not_unzip
+
+      # Installs a list of packages, and outputs caveats when it's done.
+      def install_packages!(ksp_path, packages)
+        caveats = {}
+        packages.each { |package| package.install!(ksp_path, caveats) }
+        log_caveats(caveats)
+      end
+
+      # Internal version of the `install` method. Handles:
+      #   * Pre- and post-requisites
+      #   * Version control
+      #   * Post-processors
+      #   * Calling a package's #install method
+      #   * Building up caveats
+      #
+      # The caveats argument is expected to be a hash going from Packages to
+      # caveat messages and will be modified in-place.
+      def install!(ksp_path, caveats)
+        return if Versioner.already_installed?(ksp_path, self)
+
+        Util.log "Installing package #{self.title}"
+        prepare_for_install(ksp_path, caveats)
+
+        Util.log "Saving your work before installing ..."
+        Versioner.mark_preinstall(ksp_path, self)
+
+        Util.log "Installing #{title} ..."
+        self.new.install
+
+        Util.log "Cleaning up ..."
+        Util.run_post_processors!(ksp_path)
+
+        Versioner.mark_postinstall(ksp_path, self)
+
+        Util.log "Done!"
+
+        install_postrequisites!(caveats)
+      end
+
+      def download_and_unzip!
+        PackageDownloads.download_and_unzip_package(self)
+      end
+
+      def download!
+        PackageDownloads.download_package(self)
+      end
+
+      def do_not_unzip!
+        @do_not_unzip = true
+      end
+
+      # a callback for when a subclass of this class is created
+      def inherited(package)
+        (@@packages ||= []) << package
+      end
+
+      def packages
+        @@packages
+      end
+
+      def load_packages!
+        Dir[File.join(Configuration.packages_path, '*.rb')].each do |file|
+          require file
+        end
+      end
+
+
+      private
+
+      # Run steps that take place before installation.
+      def prepare_for_install(ksp_path, caveats)
+        add_caveat_message!(caveats)
+        @ksp_path = ksp_path
+        install_prerequisites!(caveats)
+        @download_dir = download_and_unzip!
+      end
+
+      def add_caveat_message!(caveats)
+        if method_defined?(:caveats)
+          caveats.merge!(self => self.new.caveats)
+        end
+      end
+
+      def install_prerequisites!(caveats)
+        resolve_prerequisites.each do |package|
+          unless Versioner.already_installed?(ksp_path, package)
+            Util.log "#{title} has prerequisite #{package.title}."
+            package.install!(ksp_path, caveats)
+          end
+        end
+      end
+
+      def install_postrequisites!(caveats)
+        resolve_postrequisites.each do |package|
+          unless Versioner.already_installed?(ksp_path, package)
+            Util.log "#{title} has postrequisite #{package.title}."
+            package.install!(ksp_path, caveats)
+          end
+        end
+      end
+
+      def log_caveats(caveats)
+        if caveats.any?
+          Util.log "===> Caveats"
+
+          caveats.each do |package, message|
+            Util.log <<-EOS.undent
+              Caveat from #{package.title}:
+              #{message}
+            EOS
+          end
+        end
+      end
+
+      def load_post_processors!
+        processors_path = File.join(File.dirname(__FILE__), 'post_processors')
+        Dir["#{processors_path}/*.rb"].each do |file|
+          require file
+        end
+      end
+    end
+
+    load_packages!
+    load_post_processors!
+  end
+end

data/lib/kmc/package_attrs.rb

@@ -0,0 +1,69 @@
+module Kmc
+  module PackageAttrs
+      def title(title = nil)
+        if title
+          @title = title
+        else
+          @title
+        end
+      end
+
+      def url(url = nil)
+        if url
+          @url = url
+        else
+          @url
+        end
+      end
+
+      def aliases(*aliases)
+        @aliases ||= []
+
+        if aliases.any?
+          @aliases = aliases
+        else
+          @aliases
+        end
+      end
+
+      def names
+        [title, aliases].flatten
+      end
+
+      def prerequisites(*prerequisites)
+        @prerequisites ||= []
+
+        if prerequisites.any?
+          @prerequisites = prerequisites
+        else
+          @prerequisites
+        end
+      end
+
+      alias_method :prerequisite, :prerequisites
+      alias_method :pre_requisite, :prerequisites
+      alias_method :pre_requisites, :prerequisites
+
+      def postrequisites(*postrequisites)
+        @postrequisites ||= []
+
+        if postrequisites.any?
+          @postrequisites = postrequisites
+        else
+          @postrequisites
+        end
+      end
+
+      alias_method :postrequisite, :postrequisites
+      alias_method :post_requisite, :postrequisites
+      alias_method :post_requisites, :postrequisites
+
+      def resolve_prerequisites
+        prerequisites.map { |package_name| find(package_name) }
+      end
+
+      def resolve_postrequisites
+        postrequisites.map { |package_name| find(package_name) }
+      end
+  end
+end

data/lib/kmc/package_downloads.rb

@@ -0,0 +1,122 @@
+module Kmc
+  module PackageDownloads
+    class << self
+      # Downloads and unzips a package. This will call #download! on its own, and
+      # will return the location where the package was downloaded to as a
+      # Pathname.
+      def download_and_unzip_package(package, opts = {})
+        download_file = download_package(package, opts)
+        output_path = Pathname.new(download_file.path).parent.to_s
+
+        return output_path if package.do_not_unzip
+
+        Util.log "Unzipping ..."
+        unzip_file(download_file.path, output_path)
+
+        File.delete(File.absolute_path(download_file))
+
+        output_path
+      end
+
+      # Downloads the zipfile for a package using its URL, unless a cached version
+      # is found first. Uses DownloadUrl to intelligently resolve download URLs.
+      #
+      # Returns the file downloaded, which is created in a temp directory.
+      def download_package(package, opts = {})
+        download_uri, downloaded_file = fetch_package_file(package)
+
+        save_to_cache(package, downloaded_file) if opts[:cache_after_download]
+
+        download_to_tempdir(download_file_name(download_uri), downloaded_file)
+      end
+
+      def unzip_file(zipfile_path, output_path)
+        Zip::File.open(zipfile_path) do |zip_file|
+          zip_file.each do |entry|
+            destination = File.join(output_path, entry.name)
+            parent_dir = File.expand_path('..', destination)
+
+            FileUtils.mkdir_p(parent_dir) unless File.exists?(parent_dir)
+
+            entry.extract(destination)
+          end
+        end
+      end
+
+      # Places `file_contents` into a file called `file_name` in a temporary
+      # directory.
+      def download_to_tempdir(file_name, file_contents)
+        tmpdir = Dir.mktmpdir
+
+        file = File.new(File.join(tmpdir, file_name), 'wb+')
+        file.write(file_contents)
+        file.close
+
+        file
+      end
+
+      private
+
+      # Given a package, returns a two-entry array.
+      #
+      # The first entry is a String uri pointing to where the file was fetched
+      # from (either the filesystem or a website), and the second entry is the
+      # contents of the download.
+      def fetch_package_file(package)
+        cache = cache_file(package)
+        if cache
+          Util.log "Using a cached version of #{package.title} ..."
+
+          [cache, File.read(cache)]
+        else
+          Util.log "The package is found at #{package.url}."
+          Util.log "Finding the download URL ..."
+
+          download_uri = resolve_download_url(package)
+
+          Util.log "Found it. Downloading from #{download_uri} ..."
+          [download_uri, HTTParty.get(download_uri)]
+        end
+      end
+
+      # Returns the location of the cached version of a package, or some falsy
+      # value if no such file exists.
+      def cache_file(package)
+        if Kmc::Configuration.cache_dir
+          cache_file = File.join(Kmc::Configuration.cache_dir,
+            "#{package.title}.zip")
+
+          File.file?(cache_file) && cache_file
+        end
+      end
+
+      def resolve_download_url(package)
+        DownloadUrl.new(package.url).resolve_download_url
+      end
+
+      # Writes a downloaded package to the cache.
+      #
+      # This method assumes `Kmc.cache_dir` already exists.
+      def save_to_cache(package, downloaded_file)
+        Util.log "Saving #{package.title} to cache ..."
+
+        cache_location = File.join(Kmc.cache_dir, "#{package.title}.zip")
+        File.open(cache_location, 'wb+') do |file|
+          file.write(downloaded_file)
+        end
+      end
+
+      VALID_CHARS = ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" +
+          "0123456789-._~:/?#[]@!$&'()*+,;=").chars
+
+      # Converts a string URI into the file name a downloaded file should be
+      # placed into.
+      def download_file_name(uri)
+        # Remove invalid characters to ensure a valid URI.
+        clean_uri = uri.chars.select { |char| VALID_CHARS.include?(char) }.join
+
+        File.basename(URI(clean_uri).path)
+      end
+    end
+  end
+end

data/lib/kmc/package_dsl.rb

@@ -0,0 +1,13 @@
+module Kmc
+  module PackageDsl
+    def merge_directory(from, opts = {})
+      destination = opts[:into] || '.'
+
+      FileUtils.cp_r(File.join(self.class.download_dir, from),
+        File.join(self.class.ksp_path, destination))
+    end
+    def remove_filepath(filepath)
+      FileUtils.rm_r(File.join(self.class.ksp_path, filepath))
+    end
+  end
+end

data/lib/kmc/package_utils.rb

@@ -0,0 +1,29 @@
+module Kmc
+  module PackageUtils
+    # Lowercases and hyphenates a package name; this is the format packages
+    # are expected to be supplied as when passed from the user.
+    def normalize_for_find(name)
+      name.downcase.gsub(/[ \-]+/, "-")
+    end
+
+    def normalized_title
+      normalize_for_find(title)
+    end
+
+    def find(name)
+      packages.find do |package|
+        package.names.any? do |candidate_name|
+          normalize_for_find(candidate_name) == normalize_for_find(name)
+        end
+      end
+    end
+
+    def search(name)
+      packages.min_by do |package|
+        package.names.map do |candidate_name|
+          DamerauLevenshtein.distance(name, candidate_name)
+        end.min
+      end
+    end
+  end
+end