xcode-result-bundle-processor 1.0.0

data/lib/xcoderesultbundleprocessor/keyword_struct.rb

@@ -0,0 +1,10 @@
+module XcodeResultBundleProcessor
+
+  class KeywordStruct < Struct
+    def initialize(*args, **kwargs)
+      super()
+      param_hash = kwargs.any? ? kwargs : Hash[members.zip(args)]
+      param_hash.each { |k, v| self[k] = v }
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/log_deserializer.rb

@@ -0,0 +1,26 @@
+module XcodeResultBundleProcessor
+  module LogDeserializer
+    include Methadone::CLILogging
+
+    def self.deserialize_action_logs(results_bundle)
+
+      plist = results_bundle.read_plist('Info.plist')
+
+      action       = plist['Actions'].first
+      log_pathname = action['ActionResult']['LogPath']
+      results_bundle.open_file(log_pathname) do |activity_log_io|
+        io     = Zlib::GzipReader.new(activity_log_io)
+        tokens = SLF0::Tokenizer.read_token_stream(io)
+        tokens = SLF0::ClassNameResolver.resolve_class_names(tokens).to_a
+
+        # SLF0 files have a random int at the beginning; don't know its significance
+        tokens.shift
+
+        section = SLF0::Deserializer.deserialize(tokens)
+        debug section.ai
+
+        ActivityLogFormatter.format(section.subsections.first)
+      end
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/results_bundle.rb

@@ -0,0 +1,45 @@
+module XcodeResultBundleProcessor
+  class DirectoryResultsBundle
+    def initialize(path)
+      @path = Pathname.new(path)
+    end
+
+    def read_plist(path)
+      CFPropertyList.native_types(CFPropertyList::List.new(file: @path.join(path)).value)
+    end
+
+    def open_file(path, &block)
+      File.open(@path.join(path), &block)
+    end
+
+    def copy_file(source, destination)
+      FileUtils.copy(@path.join(source), destination)
+    end
+  end
+
+  class TarballResultsBundle
+    def initialize(path)
+      file = File.new(path)
+      zip  = Zlib::GzipReader.new(file)
+      @tar = Gem::Package::TarReader.new(zip)
+    end
+
+    def read_plist(path)
+      @tar.seek("./#{path}") do |plist_entry|
+        CFPropertyList.native_types(CFPropertyList::List.new(data: plist_entry.read).value)
+      end
+    end
+
+    def open_file(path, &block)
+      @tar.seek("./#{path}", &block)
+    end
+
+    def copy_file(source, destination)
+      @tar.seek("./#{source}") do |source_entry|
+        File.open(destination, 'w') do |destination_file|
+          destination_file.write(source_entry.read)
+        end
+      end
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/slf0/class_name_resolver.rb

@@ -0,0 +1,26 @@
+module XcodeResultBundleProcessor
+  module SLF0
+    module ClassNameResolver
+
+      ResolvedClassName = Struct.new(:class_name)
+
+      def self.resolve_class_names(tokens)
+        class_names = []
+
+        Enumerator.new do |enumerator|
+          tokens.each do |token|
+            if token.is_a?(Tokenizer::ClassName)
+              class_names << token.class_name
+            elsif token.is_a?(Tokenizer::ClassNameRef)
+              raise "Invalid ClassNameRef to class index #{token.class_name_id}" if token.class_name_id > class_names.length
+              class_name = class_names[token.class_name_id - 1]
+              enumerator.yield(ResolvedClassName.new(class_name))
+            else
+              enumerator.yield(token)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/slf0/deserializer.rb

@@ -0,0 +1,45 @@
+module XcodeResultBundleProcessor
+  module SLF0
+    module Deserializer
+      include Methadone::CLILogging
+
+      def self.deserialize(tokens)
+        debug "Deserializing #{tokens.ai}"
+
+        if tokens.first.nil?
+          tokens.shift
+          return nil
+        end
+
+        self._assert_first_token_type(ClassNameResolver::ResolvedClassName, tokens)
+
+        resolved_class = tokens.shift
+        return nil if resolved_class.nil?
+
+        class_name = resolved_class.class_name
+        raise "Unsupported class #{class_name}" unless Model.const_defined?(class_name)
+
+        Model.const_get(class_name).deserialize(tokens)
+      end
+
+      def self.deserialize_list(tokens)
+        if tokens.first.nil?
+          tokens.shift
+          return []
+        end
+
+        self._assert_first_token_type(Tokenizer::ObjectList, tokens)
+
+        object_list_info = tokens.shift
+
+        object_list_info.mystery_number.times.map { Deserializer.deserialize(tokens) }
+      end
+
+      private
+
+      def self._assert_first_token_type(expected_type, tokens)
+        raise "First token should be #{expected_type} but was a <#{tokens.first}>" unless tokens.first.is_a?(expected_type)
+      end
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/slf0/model/dvtdocumentlocation.rb

@@ -0,0 +1,16 @@
+module XcodeResultBundleProcessor
+  module SLF0
+    module Model
+      class DVTDocumentLocation < KeywordStruct.new(:document_url_string,
+                                                    :timestamp)
+
+        def self.deserialize(tokens)
+          self.new(
+              document_url_string: tokens.shift,
+              timestamp:           tokens.shift,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/slf0/model/dvttextdocumentlocation.rb

@@ -0,0 +1,23 @@
+module XcodeResultBundleProcessor
+  module SLF0
+    module Model
+      class DVTTextDocumentLocation < KeywordStruct.new(*(DVTDocumentLocation.members + [:starting_line_number, :starting_column_number, :ending_line_number, :ending_column_number, :character_range_1, :character_range_2, :location_encoding]))
+
+        def self.deserialize(tokens)
+          parent        = DVTDocumentLocation.deserialize(tokens)
+          parent_values = DVTDocumentLocation.members.map { |member| parent[member] }
+
+          self.new(*(parent_values + [
+              tokens.shift,
+              tokens.shift,
+              tokens.shift,
+              tokens.shift,
+              tokens.shift,
+              tokens.shift,
+              tokens.shift,
+          ]))
+        end
+      end
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/slf0/model/ideactivitylogmessage.rb

@@ -0,0 +1,26 @@
+module XcodeResultBundleProcessor
+  module SLF0
+    module Model
+      class IDEActivityLogMessage < KeywordStruct.new(
+          :title, :short_title, :time_emitted, :range_in_section_text_1, :range_in_section_text_2, :submessages, :severity, :type, :location, :category_ident, :secondary_locations, :additional_description)
+
+        def self.deserialize(tokens)
+          self.new(
+              title:                   tokens.shift,
+              short_title:             tokens.shift,
+              time_emitted:            tokens.shift,
+              range_in_section_text_1: tokens.shift,
+              range_in_section_text_2: tokens.shift,
+              submessages:             Deserializer.deserialize_list(tokens),
+              severity:                tokens.shift,
+              type:                    tokens.shift,
+              location:                Deserializer.deserialize(tokens),
+              category_ident:          tokens.shift,
+              secondary_locations:     Deserializer.deserialize_list(tokens),
+              additional_description:  tokens.shift
+          )
+        end
+      end
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/slf0/model/ideactivitylogsection.rb

@@ -0,0 +1,29 @@
+module XcodeResultBundleProcessor
+  module SLF0
+    module Model
+      class IDEActivityLogSection < KeywordStruct.new(:section_type, :domain_type, :title, :signature, :time_started_recording, :time_stopped_recording, :subsections, :text, :messages, :cancelled?, :quiet?, :fetched_from_cache?, :subtitle, :location, :command_detail_desc, :uuid, :localized_result_string)
+        def self.deserialize(tokens)
+          self.new(
+              section_type:            tokens.shift,
+              domain_type:             tokens.shift,
+              title:                   tokens.shift,
+              signature:               tokens.shift,
+              time_started_recording:  tokens.shift,
+              time_stopped_recording:  tokens.shift,
+              subsections:             Deserializer.deserialize_list(tokens),
+              text:                    tokens.shift,
+              messages:                Deserializer.deserialize_list(tokens),
+              cancelled?:              tokens.shift == 1,
+              quiet?:                  tokens.shift == 1,
+              fetched_from_cache?:     tokens.shift == 1,
+              subtitle:                tokens.shift,
+              location:                tokens.shift,
+              command_detail_desc:     tokens.shift,
+              uuid:                    tokens.shift,
+              localized_result_string: tokens.shift
+          )
+        end
+      end
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/slf0/model/ideactivitylogunittestsection.rb

@@ -0,0 +1,24 @@
+module XcodeResultBundleProcessor
+  module SLF0
+    module Model
+      class IDEActivityLogUnitTestSection < KeywordStruct.new(*(IDEActivityLogSection.members + [:tests_passed_string, :duration_string, :summary_string,
+                                                                                                 :suite_name, :test_name, :performance_test_output_string]))
+
+        def self.deserialize(tokens)
+          parent        = IDEActivityLogSection.deserialize(tokens)
+          parent_values = IDEActivityLogSection.members.map { |member| parent[member] }
+
+          self.new(
+              *(parent_values +
+                  [tokens.shift,
+                   tokens.shift,
+                   tokens.shift,
+                   tokens.shift,
+                   tokens.shift,
+                   tokens.shift])
+          )
+        end
+      end
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/slf0/model/ideconsoleitem.rb

@@ -0,0 +1,16 @@
+module XcodeResultBundleProcessor
+  module SLF0
+    module Model
+      class IDEConsoleItem < KeywordStruct.new(:adaptor_type, :content, :kind, :timestamp)
+        def self.deserialize(tokens)
+          self.new(
+              adaptor_type: tokens.shift,
+              content:      tokens.shift,
+              kind:         tokens.shift,
+              timestamp:    tokens.shift,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/slf0/tokenizer.rb

@@ -0,0 +1,82 @@
+module XcodeResultBundleProcessor
+  module SLF0
+    module Tokenizer
+      Token                = Struct.new(:int, :identifier)
+      ClassName            = Struct.new(:class_name)
+      ClassNameRef         = Struct.new(:class_name_id)
+      ObjectList           = Struct.new(:mystery_number)
+      TOKEN_INT            = '#'
+      TOKEN_CLASS_NAME     = '%'
+      TOKEN_CLASS_NAME_REF = '@'
+      TOKEN_STRING         = '"'
+      TOKEN_DOUBLE         = '^'
+      OBJECT_LIST_NIL      = '-'
+      OBJECT_LIST          = '('
+
+      def self.read_token_stream(io)
+        raise 'Not an SLF0 file' unless self.valid_slf0_io?(io)
+
+        Enumerator.new do |enumerator|
+          until io.eof?
+            token = self.read_length_and_token_type(io)
+
+            case token.identifier
+              when TOKEN_INT
+                enumerator.yield(token.int)
+              when TOKEN_DOUBLE
+                enumerator.yield(token.int)
+              when TOKEN_STRING
+                enumerator.yield(io.read(token.int).gsub("\r", "\n"))
+              when TOKEN_CLASS_NAME
+                enumerator.yield(ClassName.new(io.read(token.int)))
+              when TOKEN_CLASS_NAME_REF
+                enumerator.yield(ClassNameRef.new(token.int))
+              when OBJECT_LIST
+                enumerator.yield(ObjectList.new(token.int))
+              when OBJECT_LIST_NIL
+                enumerator.yield(nil)
+              else
+                enumerator.yield(token)
+            end
+
+          end
+        end
+      end
+
+      def self.valid_slf0_io?(io)
+        return false if io.nil?
+        io.read(4) == 'SLF0'
+      end
+
+      def self.read_length_and_token_type(io)
+        # The length appears as the start of the token as 0 or more ASCII decimal or hex digits until the token type marker
+        length_string = ''
+        until [TOKEN_INT, TOKEN_CLASS_NAME, TOKEN_CLASS_NAME_REF, TOKEN_STRING, TOKEN_DOUBLE, OBJECT_LIST_NIL, OBJECT_LIST].include?((c = io.readchar)) do
+          length_string << c
+        end
+
+        token = c
+
+        # TODO: Doubles are stored as hex strings. If it turns out the doubles contain useful information, implement
+        # logic to convert the hex string to doubles
+        if token == TOKEN_DOUBLE
+          length_string = ''
+        end
+
+        return Token.new(length_string.to_i, c)
+      end
+
+      private
+
+      def self._read_length_for_token(io, token_identifier)
+        # The length is an ASCII decimal string possibly preceded by dashes
+        length_string = ''
+        while (c = io.readchar) != token_identifier do
+          length_string << c unless c == '-' # Some strings lengths are preceded by 1 or more dashes, which we want to skip
+        end
+
+        length_string.to_i
+      end
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/snapshot_summary.rb

@@ -0,0 +1,47 @@
+module XcodeResultBundleProcessor
+  class SnapshotSummary < KeywordStruct.new(:element_class, :children, :identifier, :title, :label, :value, :frame, :placeholder, :focused?, :keyboardFocused?, :selected?, :enabled?)
+
+    def self.parse(element_snapshot)
+      element_class = nil
+      if element_snapshot.key?(:additionalAttributes) and element_snapshot[:additionalAttributes].key?(5004.to_s.to_sym)
+        element_class = element_snapshot[:additionalAttributes][5004.to_s.to_sym]
+      end
+
+      SnapshotSummary.new(
+          element_class:    element_class,
+          children:         Array(element_snapshot[:children]).map { |child| SnapshotSummary.parse(child) },
+          identifier:       element_snapshot[:identifier],
+          title:            element_snapshot[:title],
+          label:            element_snapshot[:label],
+          value:            element_snapshot[:value],
+          frame:            element_snapshot[:frame],
+          placeholder:      element_snapshot[:placeholder],
+          focused?:         !!element_snapshot[:hasFocus],
+          keyboardFocused?: !!element_snapshot[:hasKeyboardFocus],
+          selected?:        !!element_snapshot[:selected],
+          enabled?:         element_snapshot[:enabled] != false,
+      )
+
+    end
+
+    def summary
+      summary_components = [
+          self.element_class || 'UnknownElement',
+          self.frame
+      ]
+
+      summary_components += [:identifier, :title, :label, :value, :placeholder].map do |attribute|
+        unless self[attribute].nil? or self[attribute].empty?
+          "#{attribute}=#{self[attribute]}"
+        end
+      end
+
+      summary_components << 'focused' if self.focused?
+      summary_components << 'keyboardFocused' if self.keyboardFocused?
+      summary_components << 'selected' if self.selected?
+      summary_components << 'disabled' unless self.enabled?
+
+      summary_components.compact.join(' ')
+    end
+  end
+end

data/lib/xcoderesultbundleprocessor/test_summaries/html_report.rb

@@ -0,0 +1,156 @@
+module XcodeResultBundleProcessor
+  module TestSummaries
+    class HTMLReport
+      include Methadone::CLILogging
+
+      def initialize(results_bundle)
+        @results_bundle  = results_bundle
+        @stylesheet_path = File.join(File.dirname(__FILE__), '..', '..', '..', 'static', 'report.css')
+        @js_path         = File.join(File.dirname(__FILE__), '..', '..', '..', 'static', 'report.js')
+      end
+
+      def save(destination_dir)
+        info "Saving HTML report to #{destination_dir}"
+
+        raise "Destination directory #{destination_dir} already exists" if Dir.exist?(destination_dir)
+
+        FileUtils.mkdir_p(File.join(destination_dir, 'screenshots'))
+
+        info 'Deserializing logs'
+        action_logs = LogDeserializer.deserialize_action_logs(@results_bundle)
+        debug action_logs
+
+
+        tests = TestSummaries.new(@results_bundle.read_plist('TestSummaries.plist'))
+
+        debug "Formatting test summaries <#{tests.ai}>"
+
+        Markaby::Builder.set_html5_options!
+        Markaby::Builder.set(:indent, 2)
+        mab    = Markaby::Builder.new({}, self)
+        report = mab.html5 do
+          head do
+            link rel: 'stylesheet', href: 'report.css'
+            script src: 'report.js' do
+              ''
+            end
+          end
+
+          body do
+            unless tests.failed_tests.empty?
+              h1 'Failed Tests :('
+              ul do
+                tests.failed_tests.each do |failed_test|
+                  li do
+                    a href: "##{failed_test.identifier}" do
+                      failed_test.identifier
+                    end
+                  end
+                end
+              end
+            end
+
+            h1 'Test Timelines'
+            tests.tests.each do |test|
+              _format_test(test, mab, destination_dir)
+            end
+
+            hr
+
+            h1 'Action Logs'
+            pre action_logs
+
+          end
+        end
+
+        FileUtils.copy(@stylesheet_path, File.join(destination_dir, 'report.css'))
+        FileUtils.copy(@js_path, File.join(destination_dir, 'report.js'))
+        File.open(File.join(destination_dir, 'index.html'), 'w').write(report)
+      end
+
+      def _format_test(test, mab, destination_dir)
+        mab.a name: test.identifier do
+          if test.passed?
+            mab.h2 test.summary
+          else
+            mab.h2.testFailed test.summary
+          end
+        end
+
+        mab.ul do
+          test.failure_summaries.each do |failure_summary|
+            li do
+              em "Failure at #{failure_summary.location}"
+              pre failure_summary.message
+            end
+          end
+          ''
+        end
+
+        mab.div.timelineContainer do
+          table do
+            tr do
+              test.activities.each do |activity_summary|
+                td do
+                  h4 activity_summary.title
+
+                  table do
+                    tr do
+                      activity_summary.subactivities.each do |subactivity|
+                        td do
+                          h5 subactivity.title
+
+                          unless subactivity.screenshot_path.nil?
+                            basename = File.basename(subactivity.screenshot_path)
+
+                            output_image_path = File.join(destination_dir, 'screenshots', basename)
+                            @results_bundle.copy_file(File.join('Attachments', subactivity.screenshot_path), output_image_path)
+
+                            img src: File.join('screenshots', basename)
+                          end
+
+                          unless subactivity.snapshot_path.nil?
+                            a.viewSnapshot href: '#' do
+                              'View Snapshot'
+                            end
+
+                            pre.snapshot do
+                              @results_bundle.open_file(File.join('Attachments', subactivity.snapshot_path)) do |file|
+                                snapshot_plist   = CFPropertyList::List.new(data: file.read)
+                                element_snapshot = ElementSnapshot.new(snapshot_plist)
+
+                                snapshot_summary = SnapshotSummary.parse(element_snapshot.to_h)
+
+                                buffer = IndentedStringBuffer.new
+                                _format_element_summary(buffer, snapshot_summary)
+                              end
+                            end
+                          end
+
+                          ''
+                        end
+                      end
+                      ''
+                    end
+                  end
+                end
+              end
+              ''
+            end
+          end
+        end
+        ''
+      end
+
+      def _format_element_summary(buffer, element_summary)
+        buffer << element_summary.summary
+
+        element_summary.children.each do |child|
+          _format_element_summary(buffer.indent, child)
+        end
+
+        buffer
+      end
+    end
+  end
+end