kmc 0.0.6

data/lib/kmc/packages/lack_luster_labs.rb

@@ -0,0 +1,22 @@
+class LackLusterLabs < Kosmos::Package
+  title 'Lack Luster Labs'
+  aliases 'LLL' 'Lack Luster Labs Pack'
+  
+  url 'https://www.dropbox.com/s/0h82wo8rdxu4jya/LLL-12-2.zip'
+
+  def install
+    merge_directory 'GameData/LLL', into: 'GameData'
+  end
+end
+
+class StockExtension < Kosmos::Package
+  title 'Stock eXTension'
+  aliases 'SXT' 'LLL Stock eXTension'
+
+  url 'https://dl.dropboxusercontent.com/u/39086055/SXT-16.5.zip'
+
+  def install
+    merge_directory 'GameData/SXT', into: 'GameData'
+  end
+end
+

data/lib/kmc/page_fetcher.js

@@ -0,0 +1,47 @@
+/**
+ * A PhantomJS script to help find where to download a package's zipfile from.
+ * Execute it is:
+ *
+ *    phantomjs page_fetcher.js <url>
+ *
+ * This script will "return" a value by sending it to STDOUT.
+ *
+ * There are two possible outputted values for this script.
+ *
+ *  1. If an external resource is received, and this external resource is a zip
+ *     file (as determined from the HTTP contentType header), then the URL to
+ *     that resource is returned.
+ *  2. If no external resource is found, then the HTML of the url provided,
+ *     after all Javascript has been loaded, is outputted and another script
+ *     must take care of determining where the URL of interest is found.
+ */
+
+var system = require('system');
+var page = require('webpage').create();
+
+var target = system.args[1];
+
+var externalResourceProvidedUrl = false;
+
+page.onResourceReceived = function(resource) {
+  if (resource.contentType === 'application/x-zip-compressed' &&
+      !externalResourceProvidedUrl) {
+    externalResourceProvidedUrl = true;
+
+    console.log(resource.url);
+  }
+}
+
+page.open(target, function() {
+  // If this is set to true, then an external resource already provided the
+  // desired URL, and nothing more needs to be done -- the URL has already been
+  // sent to STDOUT.
+  //
+  // If done is still false, then the page itself contains the desired URL, so
+  // we output the HTML and let Ruby-side KMC determine the target URL.
+  if (!externalResourceProvidedUrl) {
+    console.log(page.content);
+  }
+
+  phantom.exit();
+});

data/lib/kmc/post_processors/module_manager_resolver.rb

@@ -0,0 +1,32 @@
+module Kmc
+  module PostProcessors
+    class ModuleManagerResolver
+      def self.post_process(ksp_path)
+        module_managers = Dir.chdir(ksp_path) do
+          Dir["GameData/*"].select do |file|
+            File.basename(file).start_with?('ModuleManager')
+          end
+        end
+
+        most_recent_manager = module_managers.max_by do |file|
+          # Converts a string like this:
+          #
+          #   ModuleManager.5.2.3
+          #
+          # Into this:
+          #
+          #   [5, 2, 3]
+          File.basename(file).scan(/\d+/).map(&:to_i)
+        end
+
+        (module_managers - [most_recent_manager]).each do |file|
+          file_name = File.basename(file)
+          Util.log "Detected and deleting outdated version of ModuleManager: " +
+              "#{file_name}"
+
+          File.delete(File.join(ksp_path, file))
+        end
+      end
+    end
+  end
+end

data/lib/kmc/refresher.rb

@@ -0,0 +1,36 @@
+module Kmc
+  module Refresher
+    class << self
+      # Fetch packages from online and delete the old packages, if any.
+      def update_packages!
+        new_packages_dir = File.join(fetch_packages,
+          'packages-master', 'packages')
+
+        kmc_packages_path = Kmc::Configuration.packages_path
+        output_path = File.join(kmc_packages_path, '..')
+
+        remove_old_packages(kmc_packages_path)
+        FileUtils.cp_r(new_packages_dir, output_path)
+      end
+
+      private
+
+      def fetch_packages
+        zipped_packages = HTTParty.get(Kmc.config.packages_url)
+        tmp_zip = PackageDownloads.download_to_tempdir(
+          'downloaded_packages.zip', zipped_packages)
+        output_path = Pathname.new(tmp_zip.path).parent.to_s
+
+        PackageDownloads.unzip_file(tmp_zip.path, output_path)
+
+        output_path
+      end
+
+      def remove_old_packages(kmc_packages_path)
+        Dir["#{kmc_packages_path}/*.rb"].each do |file|
+          File.delete(file)
+        end
+      end
+    end
+  end
+end

data/lib/kmc/user_interface.rb

@@ -0,0 +1,195 @@
+class String
+  def undent
+    gsub(/^.{#{slice(/^ +/).length}}/, '')
+  end
+end
+
+module Kmc
+  module UserInterface
+    class << self
+      def init(args)
+        ksp_path = extract_ksp_path_from_args(args)
+
+        unless ksp_path
+          Util.log <<-EOS.undent
+            Error: You did not specify what folder you keep KSP in.
+
+            Before doing anything else, please execute the command:
+
+              kmc init ksp-folder
+
+            Where "ksp-folder" is the name of the folder where you keep KSP.
+          EOS
+
+          return
+        end
+
+        Util.log "Initializing KMC into #{ksp_path} (This will take a sec) ..."
+
+        Kmc::Versioner.init_repo(ksp_path)
+        Kmc::Configuration.save_ksp_path(ksp_path)
+
+        Util.log <<-EOS.undent
+          Done! You're ready to begin installing mods.
+
+          Install your first mod by running the command:
+
+              kmc install [name-of-the-mod]
+        EOS
+      end
+
+      def install(args)
+        return unless check_initialized!
+
+        ksp_path = Kmc::Configuration.load_ksp_path
+
+        packages = load_packages(args)
+        return unless packages
+
+        return unless check_installed_packages(ksp_path, packages)
+
+        Util.log "KMC is about to install #{packages.count} package(s):"
+        pretty_print_list(packages.map(&:title))
+
+        Package.install_packages!(ksp_path, packages)
+      end
+
+      def uninstall(args)
+        return unless check_initialized!
+
+        ksp_path = Kmc::Configuration.load_ksp_path
+
+        package_name = args.shift
+        unless package_name
+          Util.log <<-EOS.undent
+            Error: You need to specify what package to uninstall. Example:
+                kmc uninstall name-of-the-mod"
+          EOS
+
+          return
+        end
+
+        package = Kmc::Package.find(package_name)
+        installed_packages = Kmc::Versioner.installed_packages(ksp_path)
+
+        if !package
+          Util.log "Error: KMC couldn't find any packages with the name #{package_name.inspect}."
+        elsif !installed_packages.include?(package.title)
+          Util.log <<-EOS.undent
+            Error: #{package.title} is not currently installed.
+
+            There are three reasons you may get this error:
+
+              1. You have already uninstalled #{package.title}.
+              2. You have never previously installed #{package.title}.
+              3. You did not use KMC to install #{package.title}.
+          EOS
+        else
+          Util.log "Preparing to uninstall #{package.title} ..."
+          Kmc::Versioner.uninstall_package(ksp_path, package)
+          Util.log "Done! Just uninstalled: #{package.title}."
+        end
+      end
+
+      def list(args)
+        return unless check_initialized!
+
+        ksp_path = Kmc::Configuration.load_ksp_path
+
+        packages = Kmc::Versioner.installed_packages(ksp_path)
+        Util.log "You have installed #{packages.length} mod(s) using KMC:"
+        pretty_print_list(packages.map(&:title))
+      end
+
+      def refresh(args)
+        Util.log "Getting the most up-to-date packages for KMC ..."
+        Kmc::Refresher.update_packages!
+        Util.log "Done. The KMC packages you have are all up-to-date."
+      end
+
+      def server(args)
+        Web::App.start!
+      end
+
+      private
+
+      # Extracts the path to init to from the user-supplied arguments. If the
+      # user passed arguments via the commandline, then spaces in paths are
+      # auto-handled beacuse they come from ARGV.
+      #
+      # If, however, the user passed arguments from the server, then these
+      # arguments will still be separated by spaces. This method will then re-
+      # join them.
+      def extract_ksp_path_from_args(args)
+        if args
+          path = args.join(' ')
+
+          # Trim leading quotation mark if any
+          path = path[1..-1] if path.start_with?('"')
+          path = path[0..-2] if path.end_with?('"')
+
+          if path.empty?
+            nil
+          else
+            path
+          end
+        end
+      end
+
+      def check_initialized!
+        if Kmc::Configuration.load_ksp_path
+          true
+        else
+          Util.log <<-EOS.undent
+            Error: You have not yet initialized KMC.
+
+            Before doing anything else, please execute the command:
+
+              kmc init ksp-folder
+
+            Where "ksp-folder" is the name of the folder where you keep KSP.
+          EOS
+        end
+      end
+
+      def pretty_print_list(list)
+        list.each { |value| Util.log "  * #{value}" }
+      end
+
+      def load_packages(package_names)
+        packages = Hash[package_names.map do |name|
+          [name, Kmc::Package.find(name)]
+        end]
+
+        unknown_packages = packages.select { |_, package| package.nil? }
+        package_suggestions = unknown_packages.map do |name, _|
+          best_guess = Kmc::Package.search(name).normalized_title
+          "#{name} (Maybe you meant: #{best_guess.inspect}?)"
+        end
+
+        if unknown_packages.any?
+          Util.log "Error: KMC couldn't find any packages with the following names:"
+          pretty_print_list(package_suggestions)
+
+          return false
+        end
+
+        packages.values
+      end
+
+      def check_installed_packages(ksp_path, new_packages)
+        installed_packages = Kmc::Versioner.installed_packages(ksp_path)
+        already_installed = new_packages & installed_packages
+
+        if already_installed.any?
+          Util.log "Error: You have already installed the following packages using KMC:"
+          pretty_print_list(already_installed.map(&:title))
+
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/kmc/util.rb

@@ -0,0 +1,11 @@
+module Kmc
+  module Util
+    def self.log(msg)
+      Kmc.config.output_method.call(msg) if Kmc.config.verbose
+    end
+
+    def self.run_post_processors!(ksp_path)
+      Kmc.config.post_processors.each { |p| p.post_process(ksp_path) }
+    end
+  end
+end

data/lib/kmc/version.rb

@@ -0,0 +1,3 @@
+module Kmc
+  VERSION = "0.0.6"
+end

data/lib/kmc/versioner.rb

@@ -0,0 +1,70 @@
+module Kmc
+  class Versioner
+    class << self
+      INIT_COMMIT_MESSAGE = "INIT: Initialize KMC"
+
+      def init_repo(path)
+        GitAdapter.init_repo(path)
+        GitAdapter.commit_everything(path, INIT_COMMIT_MESSAGE)
+      end
+
+      def mark_preinstall(path, package)
+        GitAdapter.commit_everything(path, pre_install_message(package))
+      end
+
+      def mark_postinstall(path, package)
+        GitAdapter.commit_everything(path, post_install_message(package))
+      end
+
+      def installed_packages(path)
+        commits = GitAdapter.list_commits(path)
+
+        postinstalls = commits.select(&:post?).map(&:subject)
+        uninstalls = commits.select(&:uninstall?).map(&:subject)
+
+        # The packages that have actually been installed are those that have a
+        # 'post-install' without any corresponding 'uninstall'. We can find
+        # these packages by getting post-installs, and removing the first
+        # instance of each package also found in uninstall.
+        #
+        # Note that we can't use Array#delete because that method will delete
+        # *all* instances of a package, which won't work because it's possible
+        # for a user to install, uninstall, then re-install a package.
+        uninstalls.each do |package|
+          postinstalls.delete_at(postinstalls.index(package))
+        end
+
+        postinstalls.map { |package_title| Package.find(package_title) }
+      end
+
+      # Has this package already been installed?
+      def already_installed?(path, package)
+        installed_packages(path).include?(package)
+      end
+
+      def uninstall_package(path, package)
+        to_revert = GitAdapter.list_commits(path).find do |commit|
+          commit.post? && commit.subject == package.title
+        end
+
+        GitAdapter.revert_commit(path, to_revert)
+        Util.run_post_processors!(path)
+        GitAdapter.commit_everything(path, uninstall_message(package))
+      end
+
+      private
+
+      def pre_install_message(package)
+        "PRE: #{package.title}"
+      end
+
+      def post_install_message(package)
+        "POST: #{package.title}"
+      end
+
+      def uninstall_message(package)
+        "UNINSTALL: #{package.title}"
+      end
+    end
+  end
+end

data/lib/kmc/web/app.rb

@@ -0,0 +1,42 @@
+require 'sinatra'
+
+module Kmc
+  module Web
+    class App < Sinatra::Application
+      set server: 'thin', connection: nil
+
+      get '/' do
+        send_file(File.join(settings.public_folder, 'index.html'))
+      end
+
+      get '/stream', provides: 'text/event-stream' do
+        stream :keep_open do |out|
+          settings.connection = out
+        end
+      end
+
+      post '/' do
+        Kmc.configure do |config|
+          config.output_method = Proc.new do |str|
+            # Send to STDOUT
+            puts str
+
+            # And to the in-browser UI
+            str.split("\n").each do |line|
+              settings.connection << "data: #{line}\n\n"
+            end
+          end
+        end
+
+        kmc_params = params[:params].split(' ')
+        kmc_command = %w(init install uninstall list).find do |command|
+          command == params[:command]
+        end
+
+        UserInterface.send(kmc_command, kmc_params)
+
+        204
+      end
+    end
+  end
+end