u3d 1.1.5 → 1.2.0

data/lib/u3d/installer.rb

@@ -27,6 +27,7 @@ require 'u3d/installation'
 require 'fileutils'
 require 'file-tail'
 require 'pathname'
+require 'zip'
 
 module U3d
   DEFAULT_LINUX_INSTALL = '/opt/'.freeze
@@ -55,7 +56,7 @@ module U3d
     def self.install_modules(files, version, installation_path: nil)
       installer = Installer.create
       files.each do |name, file, info|
-        UI.header "Installing #{info['title']} (#{name})"
+        UI.header "Installing #{info.name} (#{name})"
         UI.message 'Installing with ' + file
         installer.install(file, version, installation_path: installation_path, info: info)
       end
@@ -86,6 +87,77 @@ module U3d
       return [] if list.empty?
       list.sort { |a, b| UnityVersionComparator.new(a.version) <=> UnityVersionComparator.new(b.version) }
     end
+
+    protected
+
+    def install_po(file_path, version, info: nil)
+      unity = installed.find { |u| u.version == version }
+      root_path = package_destination(info, unity.root_path)
+
+      target_path = File.join(root_path, File.basename(file_path))
+      Utils.ensure_dir(File.dirname(target_path))
+
+      UI.verbose "Copying #{file_path} to #{target_path}"
+      FileUtils.cp(file_path, target_path)
+
+      UI.success "Successfully installed language file #{File.basename(file_path)}"
+    end
+
+    def install_zip(file_path, version, info: nil)
+      unity = installed.find { |u| u.version == version }
+      root_path = package_destination(info, unity.root_path)
+
+      UI.verbose("Unzipping #{file_path} to #{root_path}")
+
+      unless File.directory?(root_path)
+        Utils.get_write_access(File.dirname(root_path)) do
+          Utils.ensure_dir(root_path)
+        end
+      end
+
+      Zip::File.open(file_path) do |zip_file|
+        zip_file.each do |entry|
+          target_path = File.join(root_path, entry.name)
+          Utils.ensure_dir(File.dirname(target_path))
+          zip_file.extract(entry, target_path) unless File.exist?(target_path)
+        end
+      end
+
+      if info && info.rename_from && info.rename_to
+        rename_from = info.rename_from.gsub(/{UNITY_PATH}/, unity.root_path)
+        rename_to = info.rename_to.gsub(/{UNITY_PATH}/, unity.root_path)
+        Utils.ensure_dir(rename_to)
+        UI.verbose("Renaming from #{rename_from} to #{rename_to}")
+        if File.file? rename_from
+          FileUtils.mv(rename_from, rename_to)
+        else
+          Dir.glob(rename_from + '/*').each { |path| FileUtils.mv(path, rename_to) }
+        end
+      end
+
+      UI.success "Successfully unizpped #{File.basename(file_path)} at #{root_path}"
+    end
+
+    def package_destination(info, unity_root_path)
+      if info && info.destination
+        info.destination.gsub(/{UNITY_PATH}/, unity_root_path)
+      else
+        unity_root_path
+      end
+    end
+
+    def extra_installation_paths
+      return [] if ENV['U3D_EXTRA_PATHS'].nil?
+      ENV['U3D_EXTRA_PATHS'].strip.split(File::PATH_SEPARATOR)
+    end
+
+    def find_installations_with_path(default_root_path: '', postfix: [])
+      ([default_root_path] | extra_installation_paths).map do |path|
+        UI.verbose "Looking for installed Unity version under #{path}"
+        pattern = File.join([path] + postfix)
+        Dir.glob(pattern).map { |found_path| yield found_path }
+      end.flatten
+    end
   end
 
   # deprecated
@@ -113,17 +185,18 @@ module U3d
       paths.map { |path| MacInstallation.new(root_path: path) }
     end
 
-    # rubocop:disable UnusedMethodArgument
-    def install(file_path, version, installation_path: nil, info: {})
+    def install(file_path, version, installation_path: nil, info: nil)
       # rubocop:enable UnusedMethodArgument
       extension = File.extname(file_path)
-      raise "Installation of #{extension} files is not supported on Mac" if extension != '.pkg'
+      raise "Installation of #{extension} files is not supported on Mac" unless %w[.zip .po .pkg].include? extension
       path = installation_path || DEFAULT_MAC_INSTALL
-      install_pkg(
-        file_path,
-        version: version,
-        target_path: path
-      )
+      if extension == '.po'
+        install_po(file_path, version, info: info)
+      elsif extension == '.zip'
+        install_zip(file_path, version, info: info)
+      else
+        install_pkg(file_path, version: version, target_path: path)
+      end
     end
 
     def install_pkg(file_path, version: nil, target_path: nil)
@@ -169,9 +242,14 @@ module U3d
     private
 
     def list_installed_paths
-      find = File.join(DEFAULT_MAC_INSTALL, 'Applications', 'Unity*', 'Unity.app')
-      paths = Dir[find]
-      paths = paths.map { |u| Pathname.new(u).parent.to_s }
+      paths = find_installations_with_path(
+        default_root_path: DEFAULT_MAC_INSTALL,
+        postfix: %w[
+          Applications
+          Unity*
+          Unity.app
+        ]
+      ) { |u| Pathname.new(u).parent.to_s }
       UI.verbose "Found list_installed_paths: #{paths}"
       paths
     end
@@ -213,12 +291,12 @@ module U3d
       paths.map { |path| LinuxInstallation.new(root_path: path) }
     end
 
-    # rubocop:disable UnusedMethodArgument, PerceivedComplexity
-    def install(file_path, version, installation_path: nil, info: {})
+    # rubocop:disable PerceivedComplexity
+    def install(file_path, version, installation_path: nil, info: nil)
       # rubocop:enable UnusedMethodArgument, PerceivedComplexity
       extension = File.extname(file_path)
 
-      raise "Installation of #{extension} files is not supported on Linux" unless ['.sh', '.xz', '.pkg'].include? extension
+      raise "Installation of #{extension} files is not supported on Linux" unless ['.zip', '.po', '.sh', '.xz', '.pkg'].include? extension
       if extension == '.sh'
         path = installation_path || DEFAULT_LINUX_INSTALL
         install_sh(file_path, installation_path: path)
@@ -230,6 +308,10 @@ module U3d
         new_path = File.join(DEFAULT_LINUX_INSTALL, format(UNITY_DIR_LINUX, version: version))
         path = installation_path || new_path
         install_pkg(file_path, installation_path: path)
+      elsif extension == '.po'
+        install_po(file_path, version, info: info)
+      elsif extension == '.zip'
+        install_zip(file_path, version, info: info)
       end
 
       # Forces sanitation for installation of 'weird' versions eg 5.6.1xf1Linux
@@ -332,17 +414,25 @@ module U3d
     end
 
     def list_installed_paths
-      find = File.join(DEFAULT_LINUX_INSTALL, 'unity-editor-*', 'Editor')
-      paths = Dir[find]
-      paths = paths.map { |u| Pathname.new(u).parent.to_s }
+      paths = find_installations_with_path(
+        default_root_path: DEFAULT_LINUX_INSTALL,
+        postfix: %w[
+          unity-editor-*
+          Editor
+        ]
+      ) { |u| Pathname.new(u).parent.to_s }
       UI.verbose "Found list_installed_paths: #{paths}"
       paths
     end
 
     def debian_installed_paths
-      find = File.join(DEFAULT_LINUX_INSTALL, 'Unity', 'Editor')
-      paths = Dir[find]
-      paths = paths.map { |u| Pathname.new(u).parent.to_s }
+      paths = find_installations_with_path(
+        default_root_path: DEFAULT_LINUX_INSTALL,
+        postfix: %w[
+          Unity
+          Editor
+        ]
+      ) { |u| Pathname.new(u).parent.to_s }
       UI.verbose "Found debian_installed_paths: #{paths}"
       paths
     end
@@ -362,29 +452,37 @@ module U3d
     end
 
     def installed
-      find = File.join(DEFAULT_WINDOWS_INSTALL, 'Unity*', 'Editor', 'Uninstall.exe')
-      Dir[find].map { |path| WindowsInstallation.new(root_path: File.expand_path('../..', path)) }
+      find_installations_with_path(
+        default_root_path: DEFAULT_WINDOWS_INSTALL,
+        postfix: %w[
+          Unity*
+          Editor
+          Uninstall.exe
+        ]
+      ) { |path| WindowsInstallation.new(root_path: File.expand_path('../..', path)) }
     end
 
-    def install(file_path, version, installation_path: nil, info: {})
+    def install(file_path, version, installation_path: nil, info: nil)
       extension = File.extname(file_path)
-      raise "Installation of #{extension} files is not supported on Windows" unless %w[.exe .msi].include? extension
+      raise "Installation of #{extension} files is not supported on Windows" unless %w[.po .zip .exe .msi].include? extension
       path = installation_path || File.join(DEFAULT_WINDOWS_INSTALL, format(UNITY_DIR, version: version))
-      install_exe(
-        file_path,
-        installation_path: path,
-        info: info
-      )
+      if extension == '.po'
+        install_po(file_path, version, info: info)
+      elsif extension == '.zip'
+        install_zip(file_path, version, info: info)
+      else
+        install_exe(file_path, installation_path: path, info: info)
+      end
     end
 
-    def install_exe(file_path, installation_path: nil, info: {})
+    def install_exe(file_path, installation_path: nil, info: nil)
       installation_path ||= DEFAULT_WINDOWS_INSTALL
       final_path = U3dCore::Helper.windows_path(installation_path)
       Utils.ensure_dir(final_path)
       begin
         command = nil
-        if info['cmd']
-          command = info['cmd']
+        if info.command
+          command = info.command
           if /msiexec/ =~ command
             command.sub!(/{FILENAME}/, '"' + U3dCore::Helper.windows_path(file_path) + '"')
           else
@@ -400,7 +498,7 @@ module U3d
       rescue StandardError => e
         UI.error "Failed to install package at #{file_path}: #{e}"
       else
-        UI.success "Successfully installed #{info['title']}"
+        UI.success "Successfully installed #{info.name}"
       end
     end
 

data/lib/u3d/log_analyzer.rb

@@ -232,7 +232,7 @@ module U3d
       begin
         message = string % params.merge(@context)
       rescue KeyError => e
-        UI.error("[U3D] Rule #{@active_rule} captures were incomplete: #{e.message}")
+        UI.error("[U3D] Rule '#{@active_rule}' captures were incomplete: #{e.message}")
       end
       message
     end

data/lib/u3d/unity_module.rb

@@ -0,0 +1,145 @@
+## --- 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 ---
+
+module U3d
+  class UnityModule
+    # Basic module attributes
+    attr_reader :id, :name, :description, :url
+    # Validation attributes
+    attr_reader :installed_size, :download_size, :checksum
+    # Internal attributes
+    attr_reader :os, :depends_on, :command, :destination, :rename_from, :rename_to
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(
+      id:, name: nil, description: nil, url: nil,
+      installed_size: nil, download_size: nil, checksum: nil,
+      os: nil, depends_on: nil, command: nil, destination: nil, rename_from: nil, rename_to: nil
+    )
+      @id = id.downcase
+      @name = name
+      @description = description
+      @url = url
+      @installed_size = installed_size
+      @download_size = download_size
+      @checksum = checksum
+      @os = os
+      @depends_on = depends_on
+      @command = command
+      @destination = destination
+      @rename_from = rename_from
+      @rename_to = rename_to
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def depends_on?(other)
+      return true if other.id == 'unity'
+      return false unless depends_on
+
+      other.id == depends_on || other.name == depends_on
+    end
+
+    class << self
+      def load_modules(version, cached_versions, os: U3dCore::Helper.operating_system, offline: false)
+        if version.is_a? Array
+          UI.verbose "Loading modules for several versions: #{version}"
+          load_versions_modules(version, cached_versions, os, offline)
+        else
+          UI.verbose "Loading modules for version #{version}"
+          load_version_modules(version, cached_versions, os, offline)
+        end
+      end
+
+      private
+
+      # Optimized version of load_version_modules that only makes one HTTP call
+      def load_versions_modules(versions, cached_versions, os, offline)
+        ini_modules = versions
+                      .map { |version| [version, INIModulesParser.load_ini(version, cached_versions, os: os, offline: offline)] }
+                      .map do |version, ini_data|
+          url_root = cached_versions[version]
+          modules = ini_data.map { |k, v| module_from_ini_data(k, v, url_root, os) }
+          [version, modules]
+        end.to_h
+
+        HubModulesParser.download_modules(os: os) unless offline
+        hub_modules = versions
+                      .map { |version| [version, HubModulesParser.load_modules(version, os: os, offline: true)] }
+                      .map do |version, json_data|
+          modules = json_data.map { |data| module_from_json_data(data, os) }
+          [version, modules]
+        end.to_h
+
+        return ini_modules.merge(hub_modules) do |_version, ini_version_modules, json_version_modules|
+          (ini_version_modules + json_version_modules).uniq(&:id)
+        end
+      end
+
+      def load_version_modules(version, cached_versions, os, offline)
+        ini_data = INIModulesParser.load_ini(version, cached_versions, os: os, offline: offline)
+        url_root = cached_versions[version]
+        ini_modules = ini_data.map { |k, v| module_from_ini_data(k, v, url_root, os) }
+
+        json_data = HubModulesParser.load_modules(version, os: os, offline: offline)
+        json_modules = json_data.map { |data| module_from_json_data(data, os) }
+
+        return (ini_modules + json_modules).uniq(&:id)
+      end
+
+      def module_from_ini_data(module_key, entries, url_root, os)
+        url = entries['url']
+        url = url_root + url unless /^http/ =~ url
+
+        UnityModule.new(
+          id: module_key,
+          name: entries['title'],
+          description: entries['description'],
+          url: url,
+          download_size: entries['size'],
+          installed_size: entries['installedsize'],
+          checksum: entries['md5'],
+          command: entries['cmd'],
+          depends_on: entries['sync'],
+          os: os
+        )
+      end
+
+      def module_from_json_data(entries, os)
+        UnityModule.new(
+          id: entries['id'],
+          name: entries['name'],
+          description: entries['description'],
+          url: entries['downloadUrl'],
+          download_size: entries['downloadSize'],
+          installed_size: entries['installedSize'],
+          checksum: entries['checksum'],
+          destination: entries['destination'],
+          rename_from: entries['renameFrom'],
+          rename_to: entries['renameTo'],
+          command: entries['cmd'],
+          depends_on: entries['sync'],
+          os: os
+        )
+      end
+    end
+  end
+end

data/lib/u3d/unity_version_definition.rb

@@ -20,43 +20,47 @@
 # SOFTWARE.
 ## --- END LICENSE BLOCK ---
 
-require 'u3d/iniparser'
+require 'u3d/ini_modules_parser'
 
 module U3d
   class UnityVersionDefinition
-    attr_accessor :version, :os, :url, :ini
+    attr_accessor :version, :os, :url
+    attr_reader :packages
+
+    private
+
+    attr_writer :packages
+
+    public
 
     def initialize(version, os, cached_versions, offline: false)
       @version = version
       @os = os
       # Cache is assumed to be correct
       @url = cached_versions ? cached_versions[version] : nil
-      begin
-        @ini = INIparser.load_ini(version, cached_versions, os: os, offline: offline)
-      rescue StandardError => e
-        # FIXME: weird that we catch this here
-        UI.error "Could not load INI file for version #{@version} on #{@os}: #{e}"
-        @ini = nil
-      end
+      @packages = UnityModule.load_modules(version, cached_versions, os: os, offline: offline)
     end
 
     def available_packages
-      @ini.keys
+      @packages.map(&:id)
+    end
+
+    def available_package?(package)
+      available_packages.include? package.downcase
     end
 
-    def available_package?(p)
-      available_packages.include? p
+    def [](package)
+      return nil unless available_package? package
+      @packages.find { |pack| pack.id == package.downcase }
     end
 
-    def [](key)
-      return nil unless @ini
-      @ini[key]
+    def ini
+      UI.deprecated 'UnityVersionDefinition no longer exposes the raw ini data'
+      return nil
     end
 
-    def size_in_bytes(package)
-      return nil unless @ini
-      return -1 unless @ini[package] && @ini[package]['size']
-      @os == :win ? @ini[package]['size'] * 1024 : @ini[package]['size']
+    def ini=(_value)
+      UI.deprecated 'UnityVersionDefinition no longer exposes the raw ini data'
     end
   end
 end