u3d 0.9

data/lib/u3d/log_analyzer.rb

@@ -0,0 +1,221 @@
+## --- 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 'json'
+
+module U3d
+  # Analyzes log by filtering output along a set of rules
+  class LogAnalyzer
+    RULES_PATH = File.expand_path('../../../config/log_rules.json', __FILE__)
+    MEMORY_SIZE = 10
+
+    def initialize
+      @lines_memory = Array.new(MEMORY_SIZE)
+      @active_phase = nil
+      @active_rule = nil
+      @context = {}
+      @rule_lines_buffer = []
+      @generic_rules, @phases = load_rules
+    end
+
+    def load_rules
+      data = {}
+      generic_rules = {}
+      phases = {}
+      File.open(RULES_PATH, 'r') do |f|
+        data = JSON.parse(f.read)
+      end
+      if data['GENERAL'] && data['GENERAL']['active']
+        data['GENERAL']['rules'].each do |rn, r|
+          generic_rules[rn] = r if parse_rule(r)
+        end
+      end
+      data.delete('GENERAL')
+      data.each do |name, phase|
+        # Phase parsing
+        next unless phase['active']
+        next if phase['phase_start_pattern'].nil?
+        phase['phase_start_pattern'] = Regexp.new phase['phase_start_pattern']
+        phase['phase_end_pattern'] = Regexp.new phase['phase_end_pattern'] if phase['phase_end_pattern']
+        phase.delete('comment')
+        # Rules parsing
+        temp_rules = {}
+        unless phase['silent'] == true
+          phase['rules'].each do |rn, r|
+            temp_rules[rn] = r if parse_rule(r)
+          end
+        end
+        phase['rules'] = temp_rules
+        phases[name] = phase
+      end
+      return generic_rules, phases
+    end
+
+    def parse_line(line)
+      # Insert new line and remove last stored line
+      @lines_memory.push(line).shift
+
+      # Check if phase is changing
+      @phases.each do |name, phase|
+        next if name == @active_phase
+        next unless line =~ phase['phase_start_pattern']
+        if @active_rule
+          # Active rule should be finished
+          # If it is still active during phase change, it means that something went wrong
+          UI.error("[#{@active_phase}] Could not finish active rule '#{@active_rule}'. Aborting it.")
+          @active_rule = nil
+        end
+        @active_phase = name
+        @context.clear
+        @rule_lines_buffer.clear
+        UI.verbose("--- Beginning #{name} phase ---")
+        break
+      end
+
+      apply_ruleset = lambda do |ruleset, header|
+        # Apply the active rule
+        if @active_rule && ruleset[@active_rule]
+          rule = ruleset[@active_rule]
+          pattern = rule['end_pattern']
+
+          # Is it the end of the rule?
+          if line =~ pattern
+            unless @rule_lines_buffer.empty?
+              @rule_lines_buffer.each do |l|
+                UI.send(rule['type'], "[#{header}] " + l)
+              end
+            end
+            if rule['end_message'] != false
+              if rule['end_message']
+                match = line.match(pattern)
+                params = match.names.map(&:to_sym).zip(match.captures).to_h
+                message = rule['end_message'] % params.merge(@context)
+              else
+                message = line.chomp
+              end
+              message = "[#{header}] " + message
+              UI.send(rule['type'], message)
+            end
+            @active_rule = nil
+            @context.clear
+            @rule_lines_buffer.clear
+
+          # It's not the end of the rules, should the line be stored?
+          elsif rule['store_lines']
+            match = false
+            if rule['ignore_lines']
+              rule['ignore_lines'].each do |pat|
+                if line =~ pat
+                  match = true
+                  break
+                end
+              end
+            end
+            @rule_lines_buffer << line.chomp unless match
+          end
+        end
+
+        # If there is no active rule, try to apply a new one
+        if @active_rule.nil?
+          ruleset.each do |rn, r|
+            pattern = r['start_pattern']
+            next unless line =~ pattern
+            @active_rule = rn if r['end_pattern']
+            match = line.match(pattern)
+            @context = match.names.map(&:to_sym).zip(match.captures).to_h
+            if r['fetch_line_at_index'] || r['fetch_first_line_not_matching']
+              if r['fetch_line_at_index']
+                fetched_line = @lines_memory.reverse[r['fetch_line_at_index']]
+              else
+                fetched_line = nil
+                @lines_memory.reverse.each do |l|
+                  match = false
+                  r['fetch_first_line_not_matching'].each do |pat|
+                    next unless l =~ pat
+                    match = true
+                    break
+                  end
+                  next if match
+                  fetched_line = l
+                  break
+                end
+              end
+              if fetched_line
+                if r['fetched_line_pattern']
+                  match = fetched_line.match(r['fetched_line_pattern'])
+                  @context.merge!(match.names.map(&:to_sym).zip(match.captures).to_h)
+                end
+                if r['fetched_line_message'] != false
+                  message = if r['fetched_line_message']
+                              r['fetched_line_message'] % @context
+                            else
+                              fetched_line.chomp
+                            end
+                  message = "[#{header}] " + message
+                  UI.send(r['type'], message)
+                end
+              end
+            end
+            if r['start_message'] != false
+              message = if r['start_message']
+                          r['start_message'] % @context
+                        else
+                          line.chomp
+                        end
+              message = "[#{header}] " + message
+              UI.send(r['type'], message)
+            end
+            break
+          end
+        end
+      end
+
+      apply_ruleset.call(@phases[@active_phase]['rules'], @active_phase) if @active_phase
+      apply_ruleset.call(@generic_rules, 'GENERAL')
+    end
+
+    private
+
+    def parse_rule(r)
+      return false unless r['active']
+      return false if r['start_pattern'].nil?
+      r['start_pattern'] = Regexp.new r['start_pattern']
+      r['end_pattern'] = Regexp.new r['end_pattern'] if r['end_pattern']
+      if r['fetch_line_at_index']
+        r.delete('fetch_line_at_index') if r['fetch_line_at_index'] >= MEMORY_SIZE
+        r.delete('fetch_line_at_index') if r['fetch_line_at_index'] <= 0
+      elsif r['fetch_first_line_not_matching']
+        r['fetch_first_line_not_matching'].map! { |pat| Regexp.new pat }
+      end
+      if r['fetch_line_at_index'] || r['fetch_first_line_not_matching']
+        r['fetched_line_pattern'] = Regexp.new r['fetched_line_pattern'] if r['fetched_line_pattern']
+      end
+      r['type'] = 'important' if r['type'] == 'warning'
+      if r['type'] && r['type'] != 'error' && r['type'] != 'important' && r['type'] != 'success'
+        r['type'] = 'message'
+      end
+      r['type'] ||= 'message'
+      r['ignore_lines'].map! { |pat| Regexp.new pat } if r['ignore_lines']
+      true
+    end
+  end
+end

data/lib/u3d/unity_version_number.rb

@@ -0,0 +1,71 @@
+## --- 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'
+
+module U3d
+  class UnityVersionNumber
+    attr_reader :parts
+
+    def initialize(version)
+      parsed = Utils.parse_unity_version(version)
+      parsed.each_with_index do |val, index|
+        next if val.nil? || (index == 3)
+        parsed[index] = val.to_i
+      end
+      @parts = parsed
+    end
+
+    def to_s
+      "#{parts[0]}.#{parts[1]}.#{parts[2]}#{parts[3]}#{parts[4]}"
+    end
+  end
+
+  class UnityVersionComparator
+    include Comparable
+
+    RELEASE_LETTER_STRENGTH = { a: 1, b: 2, f: 3, p: 4 }.freeze
+
+    attr_reader :version
+
+    def <=>(other)
+      comp = @version.parts[0] <=> other.version.parts[0]
+      return comp if comp.nonzero?
+      comp = @version.parts[1] <=> other.version.parts[1]
+      return comp if comp.nonzero?
+      comp = @version.parts[2] <=> other.version.parts[2]
+      return comp if comp.nonzero?
+      comp = RELEASE_LETTER_STRENGTH[@version.parts[3].to_sym] <=> RELEASE_LETTER_STRENGTH[other.version.parts[3].to_sym]
+      return comp if comp.nonzero?
+      return @version.parts[4] <=> other.version.parts[4]
+    end
+
+    def initialize(version)
+      version = UnityVersionNumber.new(version.to_s)
+      @version = version
+    end
+
+    def inspect
+      @version
+    end
+  end
+end

data/lib/u3d/unity_versions.rb

@@ -0,0 +1,207 @@
+## --- 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/iniparser'
+require 'u3d_core/helper'
+require 'net/http'
+
+module U3d
+  # Takes care of fectching versions and version list
+  module UnityVersions
+    #####################################################
+    # @!group URLS: Locations to fetch information from
+    #####################################################
+    # URL for the forum thread listing all the Linux releases
+    UNITY_LINUX_DOWNLOADS = 'https://forum.unity3d.com/threads/unity-on-linux-release-notes-and-known-issues.350256/'.freeze
+    # URL for the main releases for Windows and Macintosh
+    UNITY_DOWNLOADS = 'https://unity3d.com/get-unity/download/archive'.freeze
+    # URL for the patch releases for Windows and Macintosh
+    UNITY_PATCHES = 'https://unity3d.com/unity/qa/patch-releases'.freeze
+    # URL for the beta releases list, they need to be accessed after
+    UNITY_BETAS = 'https://unity3d.com/unity/beta/archive'.freeze
+    # URL for a specific beta, takes into parameter a version string (%s)
+    UNITY_BETA_URL = 'https://unity3d.com/unity/beta/unity%s'.freeze
+
+    #####################################################
+    # @!group REGEX: expressions to interpret data
+    #####################################################
+    # Captures a version and its base url
+    MAC_DOWNLOAD = %r{"(https?://[\w/\.-]+/[0-9a-f]{12}/)MacEditorInstaller/[a-zA-Z0-9/\.]+-(\d+\.\d+\.\d+\w\d+)\.?\w+"}
+    WIN_DOWNLOAD = %r{"(https?://[\w/\.-]+/[0-9a-f]{12}/)Windows..EditorInstaller/[a-zA-Z0-9/\.]+-(\d+\.\d+\.\d+\w\d+)\.?\w+"}
+    LINUX_DOWNLOAD = %r{"(https?://[\w/\._-]+/unity\-editor\-installer\-(\d+\.\d+\.\d+\w\d+).*\.sh)"}
+    # Captures a beta version in html page
+    UNITY_BETAVERSION_REGEX = %r{\/unity\/beta\/unity(\d+\.\d+\.\d+\w\d+)"}
+    UNITY_EXTRA_DOWNLOAD_REGEX = %r{"(https?:\/\/[\w\/.-]+\.unity3d\.com\/(\w+))\/[a-zA-Z\/.-]+\/download.html"}
+
+    class << self
+      def list_available(os: nil)
+        os ||= U3dCore::Helper.operating_system
+
+        case os
+        when :linux
+          return U3d::UnityVersions::LinuxVersions.list_available
+        when :mac
+          return U3d::UnityVersions::MacVersions.list_available
+        when :win
+          return U3d::UnityVersions::WindowsVersions.list_available
+        else
+          raise ArgumentError, "Operating system #{os} not supported"
+        end
+      end
+
+      def fetch_version(url, pattern)
+        hash = {}
+        data = Utils.get_ssl(url)
+        results = data.scan(pattern)
+        results.each { |capt| hash[capt[1]] = capt[0] }
+        return hash
+      end
+
+      def fetch_betas(url, pattern)
+        hash = {}
+        data = Utils.get_ssl(url)
+        results = data.scan(UNITY_BETAVERSION_REGEX).uniq
+        results.each { |beta| hash.merge!(fetch_version(UNITY_BETA_URL % beta[0], pattern)) }
+        hash
+      end
+    end
+
+    class LinuxVersions
+      class << self
+        def list_available
+          UI.message 'Loading Unity releases'
+          request = nil
+          response = nil
+          data = ''
+          uri = URI(UNITY_LINUX_DOWNLOADS)
+          Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+            request = Net::HTTP::Get.new uri
+            request['Connection'] = 'keep-alive'
+            response = http.request request
+
+            case response
+            when Net::HTTPSuccess then
+              # Successfully retrieved forum content
+              data = response.body
+            when Net::HTTPRedirection then
+              # A session must be opened with the server before accessing forum
+              res = nil
+              cookie_str = ''
+              # Store the name and value of the cookies returned by the server
+              response['set-cookie'].gsub(/\s+/, '').split(',').each do |c|
+                cookie_str << c.split(';', 2)[0] + '; '
+              end
+              cookie_str.chomp!('; ')
+
+              # It should be the Unity register API
+              uri = URI(response['location'])
+              Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http_api|
+                request = Net::HTTP::Get.new uri
+                request['Connection'] = 'keep-alive'
+                res = http_api.request request
+              end
+
+              raise 'Unexpected result' unless res.is_a? Net::HTTPRedirection
+              # It should be a redirection to the forum to perform authentication
+              uri = URI(res['location'])
+
+              request = Net::HTTP::Get.new uri
+              request['Connection'] = 'keep-alive'
+              request['Cookie'] = cookie_str
+
+              res = http.request request
+
+              raise 'Unable to establish a session with Unity forum' unless res.is_a? Net::HTTPRedirection
+
+              cookie_str << '; ' + res['set-cookie'].gsub(/\s+/, '').split(';', 2)[0]
+
+              uri = URI(res['location'])
+
+              request = Net::HTTP::Get.new uri
+              request['Connection'] = 'keep-alive'
+              request['Cookie'] = cookie_str
+
+              res = http.request request
+
+              data = res.body if res.is_a? Net::HTTPSuccess
+            else raise "Request failed with status #{response.code}"
+            end
+          end
+          data.gsub(/[ \t]+/, '').each_line { |l| puts l if /<a href=/ =~ l }
+          versions = {}
+          results = data.scan(LINUX_DOWNLOAD)
+          results.each do |capt|
+            versions[capt[1]] = capt[0]
+          end
+          if versions.count.zero?
+            UI.important 'Found no releases'
+          else
+            UI.success "Found #{versions.count} releases."
+          end
+          versions
+        end
+      end
+    end
+
+    class MacVersions
+      class << self
+        def list_available
+          versions = {}
+          UI.message 'Loading Unity releases'
+          current = UnityVersions.fetch_version(UNITY_DOWNLOADS, MAC_DOWNLOAD)
+          UI.success "Found #{current.count} releases." if current.count.nonzero?
+          versions = versions.merge(current)
+          UI.message 'Loading Unity patch releases'
+          current = UnityVersions.fetch_version(UNITY_PATCHES, MAC_DOWNLOAD)
+          UI.success "Found #{current.count} patch releases." if current.count.nonzero?
+          versions = versions.merge(current)
+          UI.message 'Loading Unity beta releases'
+          current = UnityVersions.fetch_betas(UNITY_BETAS, MAC_DOWNLOAD)
+          UI.success "Found #{current.count} beta releases." if current.count.nonzero?
+          versions = versions.merge(current)
+          versions
+        end
+      end
+    end
+
+    class WindowsVersions
+      class << self
+        def list_available
+          versions = {}
+          UI.message 'Loading Unity releases'
+          current = UnityVersions.fetch_version(UNITY_DOWNLOADS, WIN_DOWNLOAD)
+          UI.success "Found #{current.count} releases." if current.count.nonzero?
+          versions = versions.merge(current)
+          UI.message 'Loading Unity patch releases'
+          current = UnityVersions.fetch_version(UNITY_PATCHES, WIN_DOWNLOAD)
+          UI.success "Found #{current.count} patch releases." if current.count.nonzero?
+          versions = versions.merge(current)
+          UI.message 'Loading Unity beta releases'
+          current = UnityVersions.fetch_betas(UNITY_BETAS, WIN_DOWNLOAD)
+          UI.success "Found #{current.count} beta releases." if current.count.nonzero?
+          versions = versions.merge(current)
+          versions
+        end
+      end
+    end
+  end
+end