u3d 0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9ce28b96ca380357d267e20c4e6d5543bc7153cb
+  data.tar.gz: ce303b2b7406098130e359602a8a68970149fd67
+SHA512:
+  metadata.gz: 346aeb6ded1b7c6f2bf24cdd99b16110a837984317209a9780b3c0a1521c061108097558d1d9ec9f497ebded3b2ceb58f9122dee2ab12310aef6642f30d087a4
+  data.tar.gz: f6dc8b3879d146592e595fe8ee13850e3a78d6a46fdcc8bf847a1e66891ea93d4f8d57561e4addad99e79e4437824a1fb171d09aa911308ffa2627443d511eb7

data/.gitignore

@@ -0,0 +1,2 @@
+pkg/
+coverage/

data/.licenses.json

@@ -0,0 +1,19 @@
+[
+  {
+    "license": "LICENSE.fastlane",
+    "paths": [
+      "lib/u3d_core/ui/{disable_colors,interface,ui}.rb",
+      "lib/u3d_core/ui/implementations/shell.rb",
+      "lib/u3d_core/{command_executor,command_runner,credentials,globals,helper}.rb",
+      "spec/u3d_core/command_executor_spec.rb"
+    ]
+  },
+  { 
+    "license": "LICENSE",
+    "paths": [
+       "{lib,spec}/**/*.rb",
+       "Rakefile"
+    ]
+  }
+]
+  

data/.rspec

@@ -0,0 +1 @@
+--color --require spec_helper --format d

data/.rubocop.yml

@@ -0,0 +1,43 @@
+#
+#   File.chmod(0777, f)
+#
+# is easier to read than
+#
+#   File.chmod(0o777, f)
+#
+AllCops:
+  #Include:
+  #  - '**/fastlane/Fastfile'
+  Exclude:
+    - './fastlane-plugin-u3d/**/*'
+
+
+Style/NumericLiteralPrefix:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: false # we're not there yet
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+# Configuration parameters: AllowURI, URISchemes.
+Metrics/LineLength:
+  Max: 370
+
+# We're not there yet
+Style/Documentation:
+  Enabled: false
+
+# Better too much 'return' than one missing
+Style/RedundantReturn:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+source "https://rubygems.org"
+
+gemspec
+# gem "rails"

data/Gemfile.lock

@@ -0,0 +1,98 @@
+PATH
+  remote: .
+  specs:
+    u3d (0.9)
+      colored (>= 1.2, < 2.0.0)
+      commander (>= 4.4.0, < 5.0.0)
+      file-tail (>= 1.2.0)
+      filesize (>= 0.1.1)
+      inifile (>= 3.0.0, < 4.0.0)
+      plist (>= 3.1.0, < 4.0.0)
+      security (= 0.1.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.3.0)
+    builder (3.2.3)
+    coderay (1.1.1)
+    colored (1.2)
+    commander (4.4.3)
+      highline (~> 1.7.2)
+    coveralls (0.8.21)
+      json (>= 1.8, < 3)
+      simplecov (~> 0.14.1)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.4)
+      tins (~> 1.6)
+    diff-lcs (1.3)
+    docile (1.1.5)
+    file-tail (1.2.0)
+      tins (~> 1.0)
+    filesize (0.1.1)
+    highline (1.7.8)
+    inifile (3.0.0)
+    json (2.1.0)
+    method_source (0.8.2)
+    parser (2.4.0.0)
+      ast (~> 2.2)
+    plist (3.3.0)
+    powerpack (0.1.1)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rainbow (2.2.2)
+      rake
+    rake (10.5.0)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    rspec_junit_formatter (0.2.3)
+      builder (< 4)
+      rspec-core (>= 2, < 4, != 2.12.0)
+    rubocop (0.44.1)
+      parser (>= 2.3.1.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    security (0.1.3)
+    simplecov (0.14.1)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.1)
+    slop (3.6.0)
+    term-ansicolor (1.6.0)
+      tins (~> 1.0)
+    thor (0.19.4)
+    tins (1.15.0)
+    unicode-display_width (1.3.0)
+
+PLATFORMS
+  ruby
+  x86-mingw32
+
+DEPENDENCIES
+  bundler (~> 1.13)
+  coveralls
+  pry
+  rake (~> 10.0)
+  rspec (~> 3.1.0)
+  rspec_junit_formatter (~> 0.2.3)
+  rubocop (~> 0.44.0)
+  u3d!
+
+BUNDLED WITH
+   1.15.2

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+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.

data/LICENSE.fastlane

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Original work Copyright (c) 2015-present the fastlane authors
+Modified work Copyright 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.

data/LOG_RULES.md

@@ -0,0 +1,170 @@
+# Log Analyzer rules
+
+The Log Prettifier processes both Unity output and existing log files thanks to a set of JSON rules. These rules are under ./config/log_rules.json. They are meant to be customizable to fit as best as possible your logging specifications.
+
+This document explains how to customize the ruleset.
+
+## I - Foreword
+
+### A - Log Prettifying Philosophy
+
+The main thing to understand behind our rule system is that it is based on a whitelist approach: anything coming in the analyzer will be ignored unless it matches a rule, in which case it will be processed accordingly.
+
+The reason behind this approach is that Unity generates a lot of unwanted noise that would have been complicated to filter out. By filtering in, only relevant and/or expected information will be logged, allowing for a much clearer output, and better understanding of what is happening during Unity's runtime.
+
+### B - Patterns
+
+The log analyzer relies heavily on 'patterns' to follow the Unity output and extract information. These patterns are regular expressions which will be used to parse the returned lines. They are declared as regular `string` in the rules file, but are parsed to standard Ruby Regexp later on, and therefore follow their syntax.
+
+For more information on how to use patterns, please refer to [Ruby's Regexp Documentation](https://ruby-doc.org/core-2.3.1/Regexp.html).
+
+## II - Phases
+
+### A - Phased behaviour of the prettifier
+
+As Unity usually goes through different phases during running, compilation or whichever action you want it to perform, the information (and its processing) that it will output will most likely be dependent on the action being performed.
+Therefore, our log prettifier behaves in a phased fashion. It has an inner memory keeping track of the active 'phase' Unity is going through, the ruleset it applies depends on it.
+
+A phase is started when a given pattern is encountered in the logs, and ends in two different ways: either a terminating pattern is met, or another phase starts.
+
+Because there are rules that you may want to apply throughout the whole analysis, there is a peculiar phase: the 'GENERAL' one. It contains a generic set of rules which will be applied in parallel to the active phase's ruleset, and allows for not having to repeat rules in different phases. The main use which this phase was designed for is to catch exceptions, warnings and errors no matter the active phase, but it is obviously not limited to that.
+
+### B - Phase syntax
+
+The syntax of phases is as follows:
+
+```json
+"PHASE_NAME": {
+  "active": true,
+  "silent": false,
+  "comment": "This is an optional comment for clarity purpose",
+  "phase_start_pattern": "This pattern ends the phase",
+  "phase_end_pattern": "This pattern ends the phase",
+  "rules": {
+    "rule_1": {},
+    "rule_2": {}
+  }
+}
+```
+* `active`: controls whether or not the phase should be active. If the phase is not active the analyzer will never try to start it, nor applying its rules.
+* __[OPTIONAL]__ `silent`: the phase will start and end normally, it will nonetheless never try to apply its rules, resulting in the phase being logically present, even though silent. More or less an alternative to toggling off every rule in its ruleset.
+* __[OPTIONAL]__ `comment`: short description of the phase. This section is only for readability purpose and will be ignored during parsing as it does not contain logic.
+* `phase_start_pattern`: this is a mandatory pattern that controls the condition under which the phase will start.
+* __[OPTIONAL]__ `phase_end_pattern`: this patterns specifies when the phase should end. It is optional because a phase will also end when another one begins, as stated in II A. This is used when you know exactly when the phase has finished.
+* `rules`: contains a set of rules. See III for further information on rule declaration.
+
+## Rules
+
+### A - Rule declaration
+
+The information contained in Unity's log can be formatted differently: it can be contained in a single line, spread on several, the lines can contain exactly what you want or be way too verbose for your liking.
+
+In consequence, the rule syntax is pretty loose to cover as many cases as possible, and below is describe syntax for some of archetypal rules.
+
+They contain nonetheless two mandatory sections and a recurring one:
+
+```json
+"rule_name": {
+  "active": true,
+  "start_pattern": "This pattern will start the rule"
+}
+```
+Similarly to phases, `active` will control whether or not the rule should be applied, and the `start_pattern` will trigger the rule.
+
+### B - One line parsing
+
+The most basic rule is when you want to extract a single line without having to do any processing on it. Here is an example:
+
+```json
+"asset_DB_loading": {
+  "active": true,
+  "start_pattern": "Loading Asset Database ?... {,2}\\d+\\.?\\d*"
+}
+```
+This example rule extracts the line stating whether the asset database has successfully loaded, and the time and logs it as is.
+
+### C - One line parsing with data extraction
+
+When the line formatting does not suit your needs, you may want to process it rather than simply logging it. Here is an example which occurs at the beginning of the compile phase:
+```json
+"target": {
+  "active": true,
+  "start_pattern": "- starting compile (?<path>.+), for buildtarget (?<target>.+)",
+  "start_message": "Target: %{path} (buildtarget %{target})"
+}
+```
+Simple rewording of the base log, by extracting the meaningful information and putting it back where it was needed.
+
+### D - Multi-line parsing and displaying
+
+The following rule illustrates when you want to log a chunk of lines as they appear in Unity at the same time. This structure is useful when you know exactly where the block begins and end. If not, please check section F.
+```json
+"percentage": {
+  "active": true,
+  "start_pattern": "Textures\\s+\\d+\\.?\\d* .b\\s+\\d{1,3}\\.?\\d*%",
+  "end_pattern": "Complete size\\s+\\d+\\.?\\d* .b\\s+\\d{1,3}\\.?\\d*%",
+  "store_lines": true
+}
+```
+`start_pattern` and `end_pattern` are the limits in between which the lines will be parsed. `store_lines` indicates that we want these lines stored, and displayed later.
+
+###  E - Multi-line parsing and displaying with line filtering and data extraction
+
+This example illustrates several additional functionalities in comparison to the previous sections.
+```json
+"fail": {
+  "active": true,
+  "start_pattern": "^(?<fail>Failed to .+)\\n",
+  "end_pattern": "Filename: (?:[\\w/:]+/(?<file>\\w+\\.\\w+))? Line: (?<line>-?\\d+)",
+  "start_message": false,
+  "end_message": "%{file}(line %{line}): %{fail}",
+  "store_lines": true,
+  "ignore_lines": [
+    "UnityEditor",
+    "UnityEngine",
+    "^\\n"
+  ]
+}
+```
+* `start_message` set to `false` allows for silent rule start. It will start to parse the log, without logging neither the original line nor a reworded version of it. Useful here not to log twice the information. It is not the case here, but this can be applied to the `end_message` in the same fashion to allow for a silent rule ending.
+* `ignore_lines` must be used alongside `store_lines` set to `true`. It will filter the lines so that unwanted lines are not logged. This is really useful here in the case of a fail to log only your applicative stack and not the Unity message logging one, by making the fail message cleaner.
+* This example illustrates also that you can extract data on the first line and use it upon rule termination. The rule has a 'context' which keeps track of extracted data.
+
+_Note_: this is a modified version of the actual rule, for example purposes.
+
+### F - Multi-line with no clear entry point (memory fetching)
+
+This section illustrates how a rule will fetch lines from the previously logged lines. It is used when you want to log several lines, but the fixed point is not at the beginning of the block.
+```json
+"log": {
+  "active": true,
+  "start_pattern": "UnityEngine\\.Debug:Log\\(Object\\)",
+  "fetch_first_line_not_matching": [
+    "UnityEngine\\.",
+    "^\\n"
+  ],
+  "fetched_line_pattern": "(?<message>.*)\\n",
+  "fetched_line_message": false,
+  "start_message": false,
+  "end_pattern": "Filename: (?:[\\w/:]+/(?<file>\\w+\\.\\w+))? Line: (?<line>-?\\d+)",
+  "end_message": "[LOG] %{file}(line %{line}): %{message}"
+}
+```
+The key feature here is the `fetch_first_line_not_matching` pattern. The last lines will be fetched from memory, from the most recent to the oldest, and the first one not matching the specified patterns will be fetched. The `fetched_line_pattern` then extracts data from the fetched line.
+
+This previous rule is used to keep tracks of the Debug.Log messages. Because they log the messages first and you probably don't know it or don't want to create a specific rule for every single message, backtracking is necessary. As the full stack isn't necessary either, the `store_lines` is absent (default is `false`) so the full stack is not displayed.
+
+### G - Logging color code
+
+You can specify the color of the message created by your rules by specifying a type:
+```json
+"target": {
+  "active": true,
+  "type": "warning"
+}
+```
+It will output it differently based on this type. Correct types are:
+* __[DEFAULT]__ `message`: normal logging
+* `warning`: yellow
+* `error`: red
+* `success`: green

data/README.md

@@ -0,0 +1,72 @@
+# U3D
+
+U3d is a set of tools to interact with Unity3D from command line. It is available on Linux, Macintosh and Windows.
+
+## What can it do?
+
+U3d provides help for running and installing unity from CLI. Available commands are:
+
+* `u3d available`: List versions available to download
+
+* `u3d install`: Download (and install) Unity
+
+* `u3d list`: List installed versions
+
+* `u3d local_install`: Install already downloaded packages
+
+* `u3d run`: Run Unity
+
+## Installation
+
+  The gem isn't yet on a public repository, so do
+```shell
+./local_gem_install.sh
+```
+## Security
+
+When you install Unity with this tool, you will have to grant it higher privileges so it can perfrom the installation. It means that under MacOS and Linux, you will be asked for your sudo password.
+
+On Windows, you must launch a administrative command interface to be able to run `local_install` and `install` (only if you install for the latter).
+
+## Examples
+
+* List installed versions on your computer:
+
+```shell
+u3d list
+```
+
+* List versions you can download and install from Unity, as well as their packages, on Mac:
+
+```shell
+u3d available -p -o mac
+```
+
+* Download and install version 5.6.0f3 of Unity with its documentation and the WebPlayer package:
+
+```shell
+u3d install 5.6.0f3 -p Unity,Documentation,WebPlayer
+```
+* Run a CLI on the current project given the configured unity version:
+
+```shell
+u3d run -- -batchmode -quit -logFile `pwd`/editor.log -executeMethod "WWTK.SimpleBuild.PerformAndroidBuild"
+```
+
+You can get further information on how to use U3d by running `u3d --help` (or `u3d -h`).
+
+## SSL Error
+
+If you face an issue similar to this one
+
+    SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed
+
+your ruby setup to work with OpenSSL may want to be fixed.
+
+ * __On MacOS:__
+
+Your version of OpenSSL may be be outdated, make sure you are using the last one.
+
+ * __On Windows:__
+
+A fix to the issue stated above has been found on [StackOverflow](http://stackoverflow.com/questions/5720484/how-to-solve-certificate-verify-failed-on-windows). If you follow the steps described in this topic, you will most likely get rid of this issue.