u3d 0.9

data/lib/u3d/downloader.rb

@@ -0,0 +1,363 @@
+## --- BEGIN LICENSE BLOCK ---
+# Copyright (c) 2016-present WeWantToKnow AS
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+## --- END LICENSE BLOCK ---
+
+require 'net/http'
+require 'u3d/iniparser'
+require 'u3d/utils'
+
+module U3d
+  # Take care of downloading files and packages
+  module Downloader
+    # Name of the directory for the package downloading
+    DOWNLOAD_DIRECTORY = 'Unity_Packages'.freeze
+    # Path to the directory for the package downloading
+    DOWNLOAD_PATH = "#{ENV['HOME']}/Downloads".freeze
+    # Regex to get the name of a package out of its file name
+    UNITY_MODULE_FILE_REGEX = %r{\/([\w\-_\.\+]+\.(?:pkg|exe|zip|sh|deb))}
+
+    class << self
+      def hash_validation(expected: nil, actual: nil)
+        if expected
+          if expected != actual
+            UI.verbose "Expected hash is #{expected}, file hash is #{actual}"
+            UI.important 'File looks corrupted (wrong hash)'
+            return false
+          end
+        else
+          UI.verbose 'No hash validation available. File is assumed correct but may not be.'
+        end
+        true
+      end
+
+      def size_validation(expected: nil, actual: nil)
+        if expected
+          if expected != actual
+            UI.verbose "Expected size is #{expected}, file size is #{actual}"
+            UI.important 'File looks corrupted (wrong size)'
+            return false
+          end
+        else
+          UI.verbose 'No size validation available. File is assumed correct but may not be.'
+        end
+        true
+      end
+
+      def download_package(path, url, size: nil)
+        File.open(path, 'wb') do |f|
+          uri = URI(url)
+          current = 0
+          Net::HTTP.start(uri.host, uri.port) do |http|
+            request = Net::HTTP::Get.new uri
+            http.request request do |response|
+              begin
+                size ||= Integer(response['Content-Length'])
+              rescue ArgumentError
+                UI.verbose 'Unable to get length of file in download'
+              end
+              started_at = Time.now.to_i - 1
+              response.read_body do |segment|
+                f.write(segment)
+                current += segment.length
+                next unless UI.interactive?
+                if size
+                  Utils.print_progress(current, size, started_at)
+                else
+                  Utils.print_progress_nosize(current, started_at)
+                end
+              end
+            end
+          end
+          print "\n" if UI.interactive?
+        end
+      rescue Interrupt => e
+        # Ensure that the file is deleted if download is aborted
+        File.delete path
+        raise e
+      end
+    end
+
+    class MacDownloader
+      class << self
+        # Downloads all packages available for given version
+        def download_all(version, cached_versions)
+          if cached_versions[version].nil?
+            UI.error "No version #{version} was found in cache. It might need updating."
+            return nil
+          end
+          files = []
+          ini_file = INIparser.load_ini(version, cached_versions)
+          ini_file.keys.each do |k|
+            result = download_specific(k, version, cached_versions)
+            files << [k, result[0], result[1]] unless result.nil?
+          end
+          files
+        end
+
+        # Downloads a specific package for given version
+        def download_specific(package, version, cached_versions)
+          if cached_versions[version].nil?
+            UI.error "No version #{version} was found in cache. It might need updating."
+            return nil
+          end
+
+          ini_file = INIparser.load_ini(version, cached_versions)
+          if ini_file[package].empty?
+            UI.error "No package \"#{package}\" was found for version #{version}."
+            return nil
+          end
+
+          url = cached_versions[version]
+          dir = File.join(DOWNLOAD_PATH, DOWNLOAD_DIRECTORY, version)
+          Utils.ensure_dir(dir)
+          return [get_package(package, ini_file, dir, url), ini_file[package]]
+        end
+
+        private #---------------------------------------------------------------
+
+        def get_package(name, ini_file, main_dir, base_url)
+          file_name = UNITY_MODULE_FILE_REGEX.match(ini_file[name]['url'])[1]
+          file_path = File.expand_path(file_name, main_dir)
+
+          # Check if file already exists and validate it
+          if File.file?(file_path)
+            if Downloader.size_validation(expected: ini_file[name]['size'], actual: File.size(file_path)) &&
+               Downloader.hash_validation(expected: ini_file[name]['md5'], actual: Utils.hashfile(file_path))
+              UI.important "#{name.capitalize} already downloaded at #{file_path}"
+              return file_path
+            else
+              UI.verbose "Deleting existing file at #{file_path}"
+              File.delete(file_path)
+            end
+          end
+
+          # Download file
+          url = base_url + ini_file[name]['url']
+          UI.header "Downloading #{name}"
+          UI.verbose 'Downloading from ' + url.to_s.cyan.underline
+          Downloader.download_package(file_path, url, size: ini_file[name]['size'])
+
+          # Validation download
+          if Downloader.size_validation(expected: ini_file[name]['size'], actual: File.size(file_path)) &&
+             Downloader.hash_validation(expected: ini_file[name]['md5'], actual: Utils.hashfile(file_path))
+            UI.success "Successfully downloaded #{name}."
+          else
+            File.delete(file_path)
+            raise 'Download failed: file is corrupted, deleting it.'
+          end
+
+          file_path
+        end
+
+        def all_local_files(version)
+          files = []
+          ini_file = INIparser.load_ini(version, {}, offline: true)
+          ini_file.keys.each do |k|
+            result = local_file(k, version)
+            files << [k, result[0], result[1]] unless result.nil?
+          end
+          files
+        end
+
+        def local_file(package, version)
+          ini_file = INIparser.load_ini(version, {}, offline: true)
+          if ini_file[package].empty?
+            UI.error "No package \"#{package}\" was found for version #{version}."
+            return nil
+          end
+
+          dir = File.join(DOWNLOAD_PATH, DOWNLOAD_DIRECTORY, version)
+          raise "Main directory #{dir} does not exist. Nothing has been downloaded for version #{version}" unless Dir.exist?(dir)
+
+          file_name = UNITY_MODULE_FILE_REGEX.match(ini_file[package]['url'])[1]
+          file_path = File.expand_path(file_name, dir)
+
+          unless File.file?(file_path)
+            UI.error "Package #{package} has not been downloaded"
+            return nil
+          end
+
+          unless Downloader.size_validation(expected: ini_file[package]['size'], actual: File.size(file_path)) &&
+                 Downloader.hash_validation(expected: ini_file[package]['md5'], actual: Utils.hashfile(file_path))
+            UI.error "File at #{file_path} is corrupted, deleting it"
+            File.delete(file_path)
+            return nil
+          end
+
+          return [file_path, ini_file[package]]
+        end
+      end
+    end
+
+    class LinuxDownloader
+      class << self
+        def download(version, cached_versions)
+          if cached_versions[version].nil?
+            UI.error "No version #{version} was found in cache. It might need updating."
+            return nil
+          end
+          url = cached_versions[version]
+          dir = File.join(DOWNLOAD_PATH, DOWNLOAD_DIRECTORY, version)
+          Utils.ensure_dir(dir)
+          file_name = UNITY_MODULE_FILE_REGEX.match(url)[1]
+          file_path = File.expand_path(file_name, dir)
+
+          # Check if file already exists
+          # Note: without size or hash validation, the file is assumed to be correct
+          if File.file?(file_path)
+            UI.important "File already downloaded at #{file_path}"
+            return file_path
+          end
+
+          # Download file
+          UI.header "Downloading Unity #{version}"
+          UI.verbose 'Downloading from ' + url.to_s.cyan.underline
+          Downloader.download_package(file_path, url)
+          U3dCore::CommandExecutor.execute(command: "chmod a+x #{file_path}")
+          file_path
+        end
+
+        def local_file(version)
+          dir = File.join(DOWNLOAD_PATH, DOWNLOAD_DIRECTORY, version)
+          raise "Main directory #{dir} does not exist. Nothing has been downloaded for version #{version}" unless Dir.exist?(dir)
+          find_cmd = "find #{dir}/ -maxdepth 2 -name '*.sh'"
+          files = U3dCore::CommandExecutor.execute(command: find_cmd).split("\n")
+          return files[0] unless files.empty?
+          raise 'No file has been downloaded'
+        end
+      end
+    end
+
+    class WindowsDownloader
+      class << self
+        def download_all(version, cached_versions)
+          if cached_versions[version].nil?
+            UI.error "No version #{version} was found in cache. It might need updating."
+            return nil
+          end
+          files = []
+          ini_file = INIparser.load_ini(version, cached_versions)
+          ini_file.keys.each do |k|
+            result = download_specific(k, version, cached_versions)
+            files << [k, result[0], result[1]] unless result.nil?
+          end
+          files
+        end
+
+        # Downloads a specific package for given version
+        def download_specific(package, version, cached_versions)
+          if cached_versions[version].nil?
+            UI.error "No version #{version} was found in cache. It might need updating."
+            return nil
+          end
+
+          ini_file = INIparser.load_ini(version, cached_versions)
+          if ini_file[package].empty?
+            UI.error "No package \"#{package}\" was found for version #{version}."
+            return nil
+          end
+
+          url = cached_versions[version]
+          dir = File.join(DOWNLOAD_PATH, DOWNLOAD_DIRECTORY, version)
+          Utils.ensure_dir(dir)
+          return [get_package(package, ini_file, dir, url), ini_file[package]]
+        end
+
+        def all_local_files(version)
+          files = []
+          ini_file = INIparser.load_ini(version, {}, offline: true)
+          ini_file.keys.each do |k|
+            result = local_file(k, version)
+            files << [k, result[0], result[1]] unless result.nil?
+          end
+          files
+        end
+
+        def local_file(package, version)
+          ini_file = INIparser.load_ini(version, {}, offline: true)
+          if ini_file[package].empty?
+            UI.error "No package \"#{package}\" was found for version #{version}."
+            return nil
+          end
+
+          dir = File.join(DOWNLOAD_PATH, DOWNLOAD_DIRECTORY, version)
+          raise "Main directory #{dir} does not exist. Nothing has been downloaded for version #{version}" unless Dir.exist?(dir)
+
+          file_name = UNITY_MODULE_FILE_REGEX.match(ini_file[package]['url'])[1]
+          file_path = File.expand_path(file_name, dir)
+
+          unless File.file?(file_path)
+            UI.error "Package #{package} has not been downloaded"
+            return nil
+          end
+
+          rounded_size = (File.size(file_path).to_f / 1024).floor
+          unless Downloader.size_validation(expected: ini_file[package]['size'], actual: rounded_size) &&
+                 Downloader.hash_validation(expected: ini_file[package]['md5'], actual: Utils.hashfile(file_path))
+            UI.error "File at #{file_path} is corrupted, deleting it"
+            File.delete(file_path)
+            return nil
+          end
+
+          return [file_path, ini_file[package]]
+        end
+
+        private #---------------------------------------------------------------
+
+        def get_package(name, ini_file, main_dir, base_url)
+          file_name = UNITY_MODULE_FILE_REGEX.match(ini_file[name]['url'])[1]
+          file_path = File.expand_path(file_name, main_dir)
+
+          # Check if file already exists and validate it
+          if File.file?(file_path)
+            rounded_size = (File.size(file_path).to_f / 1024).floor
+            if Downloader.size_validation(expected: ini_file[name]['size'], actual: rounded_size) &&
+               Downloader.hash_validation(expected: ini_file[name]['md5'], actual: Utils.hashfile(file_path))
+              UI.important "File already downloaded at #{file_path}"
+              return file_path
+            else
+              UI.verbose 'Deleting existing file'
+              File.delete(file_path)
+            end
+          end
+
+          # Download file
+          url = base_url + ini_file[name]['url']
+          UI.header "Downloading #{name}"
+          UI.verbose 'Downloading from ' + url.to_s.cyan.underline
+          Downloader.download_package(file_path, url, size: ini_file[name]['size'] * 1024)
+
+          # Validation download
+          rounded_size = (File.size(file_path).to_f / 1024).floor
+          if Downloader.size_validation(expected: ini_file[name]['size'], actual: rounded_size) &&
+             Downloader.hash_validation(expected: ini_file[name]['md5'], actual: Utils.hashfile(file_path))
+            UI.success "Successfully downloaded #{name}."
+          else
+            File.delete(file_path)
+            raise 'Download failed: file is corrupted, deleting it.'
+          end
+
+          file_path
+        end
+      end
+    end
+  end
+end

data/lib/u3d/iniparser.rb

@@ -0,0 +1,83 @@
+## --- BEGIN LICENSE BLOCK ---
+# Copyright (c) 2016-present WeWantToKnow AS
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+## --- END LICENSE BLOCK ---
+
+require 'inifile'
+require 'u3d/utils'
+require 'u3d_core/helper'
+
+module U3d
+  # Load and parse INI files
+  module INIparser
+    #####################################################
+    # @!group INI parameters to load and save ini files
+    #####################################################
+    INI_NAME = 'unity-%{version}-%{os}.ini'.freeze
+    INI_LINUX_PATH = File.join(ENV['HOME'], '.u3d', 'ini_files').freeze
+    INI_MAC_PATH = File.join(ENV['HOME'], 'Library', 'Application Support', 'u3d', 'ini_files').freeze
+    INI_WIN_PATH = File.join(ENV['HOME'], 'AppData', 'Local', 'u3d', 'ini_files').freeze
+
+    class << self
+      def load_ini(version, cached_versions, os: U3dCore::Helper.operating_system, offline: false)
+        unless os == :win || os == :mac
+          raise ArgumentError, "OS #{os.id2name} does not use ini files"
+        end
+        os = if os == :mac
+               'osx'
+             else
+               os.id2name
+             end
+        ini_name = INI_NAME % { version: version, os: os }
+        Utils.ensure_dir(default_ini_path)
+        ini_path = File.expand_path(ini_name, default_ini_path)
+        unless File.file?(ini_path)
+          raise "INI file does not exist at #{ini_path}" if offline
+          uri = URI(cached_versions[version] + ini_name)
+          File.open(ini_path, 'wb') do |f|
+            data = Net::HTTP.get(uri)
+            data.tr!("\"", '')
+            data.gsub!(/Note:.+\n/, '')
+            f.write(data)
+          end
+        end
+        begin
+          result = IniFile.load(ini_path).to_h
+        rescue => e
+          raise "Could not parse INI data (#{e})"
+        end
+        result
+      end
+
+      private
+
+      def default_ini_path
+        case U3dCore::Helper.operating_system
+        when :linux
+          INI_LINUX_PATH
+        when :mac
+          INI_MAC_PATH
+        when :win
+          INI_WIN_PATH
+        end
+      end
+    end
+  end
+end

data/lib/u3d/installer.rb

@@ -0,0 +1,445 @@
+## --- BEGIN LICENSE BLOCK ---
+# Copyright (c) 2016-present WeWantToKnow AS
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+## --- END LICENSE BLOCK ---
+
+require 'u3d/utils'
+require 'fileutils'
+require 'file-tail'
+
+# Mac specific only right now
+module U3d
+  DEFAULT_LINUX_INSTALL = '/opt/'.freeze
+  DEFAULT_MAC_INSTALL = '/'.freeze
+  DEFAULT_WINDOWS_INSTALL = 'C:/Program Files/'.freeze
+  UNITY_DIR = "Unity_%s".freeze
+  UNITY_DIR_CHECK = /Unity_\d+\.\d+\.\d+[a-z]\d+/
+
+  class Installation
+    def self.create(path: nil)
+      if Helper.mac?
+        MacInstallation.new path
+      elsif Helper.linux?
+        LinuxInstallation.new path
+      else
+        WindowsInstallation.new path
+      end
+    end
+  end
+
+  class MacInstallation < Installation
+    attr_reader :path
+
+    require 'plist'
+
+    def initialize(path: nil)
+      @path = path
+    end
+
+    def version
+      plist['CFBundleVersion']
+    end
+
+    def default_log_file
+      "#{ENV['HOME']}/Library/Logs/Unity/Editor.log"
+    end
+
+    def exe_path
+      "#{path}/Contents/MacOS/Unity"
+    end
+
+    def packages
+      if Utils.parse_unity_version(version)[0].to_i <= 4
+        # Unity < 5 doesn't have packages
+        return []
+      end
+      fpath = File.expand_path('../PlaybackEngines', path)
+      raise "Unity installation does not seem correct. Couldn't locate PlaybackEngines." unless Dir.exist? fpath
+      Dir.entries(fpath).select { |e| File.directory?(File.join(fpath, e)) && !(e == '.' || e == '..') }
+    end
+
+    private
+
+    def plist
+      @plist ||= Plist.parse_xml("#{@path}/Contents/Info.plist")
+    end
+  end
+
+  class LinuxInstallation < Installation
+    attr_reader :path
+
+    def initialize(path: nil)
+      @path = path
+    end
+
+    def version
+      # I don't find an easy way to extract the version on Linux
+      require 'rexml/document'
+      fpath = "#{path}/Data/PlaybackEngines/LinuxStandaloneSupport/ivy.xml"
+      raise "Couldn't find file #{fpath}" unless File.exist? fpath
+      doc = REXML::Document.new(File.read(fpath))
+      version = REXML::XPath.first(doc, 'ivy-module/info/@e:unityVersion').value
+      if m = version.match(/^(.*)x(.*)Linux$/)
+        version = "#{m[1]}#{m[2]}"
+      end
+      version
+    end
+
+    def default_log_file
+      "#{ENV['HOME']}/.config/unity3d/Editor.log"
+    end
+
+    def exe_path
+      "#{path}/Unity"
+    end
+
+    def packages
+      false
+    end
+  end
+
+  class WindowsInstallation < Installation
+    attr_reader :path
+
+    def initialize(path: nil)
+      @path = path
+    end
+
+    def version
+      require 'rexml/document'
+      fpath = "#{path}/Editor/Data/PlaybackEngines/windowsstandalonesupport/ivy.xml"
+      raise "Couldn't find file #{fpath}" unless File.exist? fpath
+      doc = REXML::Document.new(File.read(fpath))
+      version = REXML::XPath.first(doc, 'ivy-module/info/@e:unityVersion').value
+
+      version
+    end
+
+    def default_log_file
+      if @logfile.nil?
+        begin
+          loc_appdata = Utils.windows_local_appdata
+          log_dir = File.expand_path('Unity/Editor/', loc_appdata)
+          UI.important "Log directory (#{log_dir}) does not exist" unless Dir.exist? log_dir
+          @logfile = File.expand_path('Editor.log', log_dir)
+        rescue RuntimeError => ex
+          UI.error "Unable to retrieve the editor logfile: #{ex}"
+        end
+      end
+      @logfile
+    end
+
+    def exe_path
+      File.join(@path, 'Editor', 'Unity.exe')
+    end
+
+    def packages
+      # Unity prior to Unity5 did not have package
+      return [] if Utils.parse_unity_version(version)[0].to_i <= 4
+      fpath = "#{path}/Editor/Data/PlaybackEngines/"
+      raise "Unity installation does not seem correct. Couldn't locate PlaybackEngines." unless Dir.exist? fpath
+      Dir.entries(fpath).select { |e| File.directory?(File.join(fpath, e)) && !(e == '.' || e == '..') }
+    end
+  end
+
+  class Runner
+    def run(installation, args, raw_logs: false)
+      require 'fileutils'
+
+      log_file = find_logFile_in_args(args)
+
+      if log_file # we wouldn't want to do that for the default log file.
+        File.delete(log_file) if File.exist?(log_file)
+      else
+        log_file = installation.default_log_file
+      end
+
+      FileUtils.touch(log_file)
+
+      tail_thread = Thread.new do
+        begin
+          if raw_logs
+            pipe(log_file) { |l| UI.message l.rstrip }
+          else
+            analyzer = LogAnalyzer.new
+            pipe(log_file) { |l| analyzer.parse_line l }
+          end
+        rescue => e
+          UI.error "Failure while trying to pipe #{log_file}: #{e.message}"
+          e.backtrace.each { |l| UI.error "  #{l}" }
+        end
+      end
+
+      begin
+        args.unshift(installation.exe_path)
+        if Helper.windows?
+          args.map! { |a| a =~ / / ? "\"#{a}\"" : a }
+        else
+          args.map!(&:shellescape)
+        end
+        U3dCore::CommandExecutor.execute(command: args)
+      ensure
+        sleep 0.5
+        Thread.kill(tail_thread)
+      end
+    end
+
+    def find_logFile_in_args(args)
+      find_arg_in_args('-logFile', args)
+    end
+
+    def find_projectpath_in_args(args)
+      find_arg_in_args('-projectpath', args)
+    end
+
+    def find_arg_in_args(arg_to_find, args)
+      raise 'Only arguments of type array supported right now' unless args.is_a?(Array)
+      args.each_with_index do |arg, index|
+        return args[index + 1] if arg == arg_to_find && index < args.count - 1
+      end
+      nil
+    end
+
+    private
+
+    def pipe(file)
+      File.open(file, 'r') do |f|
+        f.extend File::Tail
+        f.interval = 0.1
+        f.max_interval = 0.4
+        f.backward 100
+        f.tail { |l| yield l }
+      end
+    end
+  end
+
+  class Installer
+    def self.create
+      installer = if Helper.mac?
+                    MacInstaller.new
+                  elsif Helper.linux?
+                    LinuxInstaller.new
+                  else
+                    WindowsInstaller.new
+                  end
+      if UI.interactive?
+        unclean = []
+        installer.installed.each { |unity| unclean << unity unless unity.path =~ UNITY_DIR_CHECK }
+        if !unclean.empty? && UI.confirm("#{unclean.count} Unity installation should be moved. Proceed?")
+          unclean.each { |unity| installer.sanitize_install(unity) }
+        end
+      end
+      installer
+    end
+
+    def self.install_module(file_path, version, installation_path: nil, info: {})
+      extension = File.extname(file_path)
+      if extension == '.pkg'
+        path = installation_path || DEFAULT_MAC_INSTALL
+        MacInstaller.install_pkg(
+          file_path,
+          version: version,
+          target_path: path
+        )
+      elsif extension == '.exe'
+        path = installation_path || File.join(DEFAULT_WINDOWS_INSTALL, UNITY_DIR % version)
+        WindowsInstaller.install_exe(
+          file_path,
+          installation_path: path,
+          info: info
+        )
+      elsif extension == '.sh'
+        path = installation_path || File.join(DEFAULT_LINUX_INSTALL, UNITY_DIR % version)
+        LinuxInstaller.install_sh(
+          file_path,
+          installation_path: path
+        )
+      else
+        raise "File type #{extension} not yet supported"
+      end
+    end
+  end
+
+  class MacInstaller
+    def sanitize_install(unity)
+      source_path = File.expand_path('..', unity.path)
+      parent = File.expand_path('..', source_path)
+      new_path = File.join(parent, UNITY_DIR % unity.version)
+      UI.important "Moving #{source_path} to #{new_path}..."
+      source_path = "\"#{source_path}\"" if source_path =~ / /
+      new_path = "\"#{new_path}\"" if new_path =~ / /
+      U3dCore::CommandExecutor.execute(command: "mv #{source_path} #{new_path}", admin: true)
+    rescue => e
+      UI.error "Unable to move #{source_path} to #{new_path}: #{e}"
+    else
+      UI.success "Successfully moved #{source_path} to #{new_path}"
+    end
+
+    def installed
+      unless (`mdutil -s /` =~ /disabled/).nil?
+        $stderr.puts 'Please enable Spotlight indexing for /Applications.'
+        exit(1)
+      end
+
+      bundle_identifiers = ['com.unity3d.UnityEditor4.x', 'com.unity3d.UnityEditor5.x']
+
+      mdfind_args = bundle_identifiers.map { |bi| "kMDItemCFBundleIdentifier == '#{bi}'" }.join(' || ')
+
+      cmd = "mdfind \"#{mdfind_args}\" 2>/dev/null"
+      UI.verbose cmd
+      versions = `#{cmd}`.split("\n").map { |path| MacInstallation.new(path: path) }
+
+      # sorting should take into account stable/patch etc
+      versions.sort! { |x, y| x.version <=> y.version }
+    end
+
+    def self.install_pkg(file_path, version: nil, target_path: nil)
+      target_path ||= DEFAULT_MAC_INSTALL
+      command = "installer -pkg #{file_path.shellescape} -target #{target_path.shellescape}"
+      unity = Installer.create.installed.find { |u| u.version == version }
+      if unity.nil?
+        UI.verbose "No Unity install for version #{version} was found"
+        U3dCore::CommandExecutor.execute(command: command, admin: true)
+      else
+        begin
+          path = File.expand_path('..', unity.path)
+          temp_path = File.join(target_path, 'Applications', 'Unity')
+          move_to_temp = (temp_path != path)
+          if move_to_temp
+            UI.verbose "Temporary switching location of #{path} to #{temp_path} for installation purpose"
+            FileUtils.mv path, temp_path
+          end
+          U3dCore::CommandExecutor.execute(command: command, admin: true)
+        ensure
+          FileUtils.mv temp_path, path if move_to_temp
+        end
+      end
+    rescue => e
+      UI.error "Failed to install pkg at #{file_path}: #{e}"
+    else
+      UI.success "Successfully installed package from #{file_path}"
+    end
+  end
+
+  class LinuxInstaller
+    def sanitize_install(unity)
+      source_path = File.expand_path(unity.path)
+      parent = File.expand_path('..', source_path)
+      new_path = File.join(parent, UNITY_DIR % unity.version)
+      UI.important "Moving #{source_path} to #{new_path}..."
+      source_path = "\"#{source_path}\"" if source_path =~ / /
+      new_path = "\"#{new_path}\"" if new_path =~ / /
+      U3dCore::CommandExecutor.execute(command: "mv #{source_path} #{new_path}", admin: true)
+    rescue => e
+      UI.error "Unable to move #{source_path} to #{new_path}: #{e}"
+    else
+      UI.success "Successfully moved #{source_path} to #{new_path}"
+    end
+
+    def installed
+      find = File.join(DEFAULT_LINUX_INSTALL, 'Unity*')
+      versions = Dir[find].map { |path| LinuxInstallation.new(path: path) }
+
+      # sorting should take into account stable/patch etc
+      versions.sort! { |x, y| x.version <=> y.version }
+    end
+
+    def self.install_sh(file, installation_path: nil)
+      cmd = file.shellescape
+      if installation_path
+        Utils.ensure_dir(installation_path)
+        U3dCore::CommandExecutor.execute(command: "cd #{installation_path}; #{cmd}", admin: true)
+      else
+        U3dCore::CommandExecutor.execute(command: cmd, admin: true)
+      end
+    rescue => e
+      UI.error "Failed to install bash file at #{file_path}: #{e}"
+    else
+      UI.success 'Installation successful'
+    end
+  end
+
+  class WindowsInstaller
+    def sanitize_install(unity)
+      source_path = File.expand_path(unity.path)
+      parent = File.expand_path('..', source_path)
+      new_path = File.join(parent, UNITY_DIR % unity.version)
+      UI.important "Moving #{source_path} to #{new_path}..."
+      source_path.tr!('/', '\\')
+      new_path.tr!('/', '\\')
+      source_path = "\"" + source_path + "\"" if source_path =~ / /
+      new_path = "\"" + new_path + "\"" if new_path =~ / /
+      U3dCore::CommandExecutor.execute(command: "move #{source_path} #{new_path}", admin: true)
+    rescue => e
+      UI.error "Unable to move #{source_path} to #{new_path}: #{e}"
+    else
+      UI.success "Successfully moved #{source_path} to #{new_path}"
+    end
+
+    def installed
+      find = File.join(DEFAULT_WINDOWS_INSTALL, 'Unity*', 'Editor', 'Uninstall.exe')
+      versions = Dir[find].map { |path| WindowsInstallation.new(path: File.expand_path('../..', path)) }
+
+      # sorting should take into account stable/patch etc
+      versions.sort! { |x, y| x.version <=> y.version }
+    end
+
+    def self.install_exe(file_path, installation_path: nil, info: {})
+      installation_path ||= DEFAULT_WINDOWS_INSTALL
+      final_path = installation_path.tr('/', '\\')
+      Utils.ensure_dir(final_path)
+      begin
+        command = nil
+        if info['cmd']
+          command = info['cmd']
+          command.sub!(/{FILENAME}/, file_path)
+          command.sub!(/{INSTDIR}/, final_path)
+          command.sub!(/{DOCDIR}/, final_path)
+          command.sub!(/{MODULEDIR}/, final_path)
+          command.sub!(/\/D=/, '/S /D=') unless /\/S/ =~ command
+        end
+        command ||= file_path.to_s
+        U3dCore::CommandExecutor.execute(command: command, admin: true)
+      rescue => e
+        UI.error "Failed to install exe at #{file_path}: #{e}"
+      else
+        UI.success "Successfully installed #{info['title']}"
+      end
+    end
+  end
+
+  class UnityProject
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def exist?
+      Dir.exist?("#{@path}/Assets") && Dir.exist?("#{@path}/ProjectSettings")
+    end
+
+    def editor_version
+      require 'yaml'
+      yaml = YAML.load(File.read("#{@path}/ProjectSettings/ProjectVersion.txt"))
+      yaml['m_EditorVersion']
+    end
+  end
+end