xcactivitylog 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc90141684fae80212880fb48cfb68fa36773c2d27428df4f1e2e7eccb89d988
-  data.tar.gz: 074f11361b4312d978ac19e14fb6f4c56fc958308866a92f63c0f4a2f4fddac0
+  metadata.gz: 86a13d7e86ed544e21d0bf9a1a84fb981671f8100160ec82fb59ba48ee0eb270
+  data.tar.gz: '0333681b5f17012ba1ac5850256c81965901262a93357449852874afe5bac997'
 SHA512:
-  metadata.gz: 450ac2460c8789d8efba482f009ff7813fe5e238b5f647bc6fe1bbf9ec249a364920aed7c2fce81a13c74c8c30d54407fdff2d981451bf78740b6c8f0bd90dc8
-  data.tar.gz: f5711987622f8ea0589f4b8249867d447923ebbe6b775384c3113eec42b39960618d2472efecf196e7b9b04f61c8422912b36429c414605139a8d485912cc114
+  metadata.gz: 1eb8f4baed133593e91db5554b0d2dd02e1fd52d5b2f7b1cf2a6e957438490a3cb0349c51ed273b36a533fe5730981f5b5fb2cb692c2673f3a00380c5263b108
+  data.tar.gz: 2beb9f7c54b34ba0c91a37a044732b53d14e7657127a8aa6219ae1bbc057838fe1bf29b0db8ae3eab2480cce5a3e5f44ed62a2c1061866ed9c0d2c71c507a098

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/slf0/token.rb

@@ -40,53 +40,62 @@ module SLF0
         @class_deserializer = class_deserializer
       end
 
-      def int(reason = nil)
-        shift(Int, reason).value
+      def int(&reason_blk)
+        shift(Int, &reason_blk).value
       end
 
-      def string(reason = nil)
-        return if shift_nil?(reason)
+      def string(&reason_blk)
+        return if shift_nil?(&reason_blk)
 
-        shift(String, reason).value
+        shift(String, &reason_blk).value
       end
 
-      def double(reason = nil)
+      def double(&reason_blk)
         return if shift_nil?
 
-        shift(Double, reason).value
+        shift(Double, &reason_blk).value
       end
 
-      def object_list(reason = nil)
-        return if shift_nil?(reason)
+      def object_list(&reason_blk)
+        return if shift_nil?(&reason_blk)
 
-        shift(ObjectList, reason).length.times.map { object(reason && "object in object list for #{reason}") }
+        length = shift(ObjectList, &reason_blk).length
+        Array.new(length) do
+          object { reason_blk && "object #{length} in object list for #{reason_blk&.call}" }
+        end
       end
 
-      def object(reason = nil)
-        deserializer_for(shift(ClassNameRef, reason).value)[self]
+      def object(&reason_blk)
+        return if shift_nil?(&reason_blk)
+
+        deserializer_for(shift(ClassNameRef, &reason_blk).value)[self]
       end
 
       def deserializer_for(class_ref_num)
         @class_deserializer[class_ref_num].last
       end
 
-      def shift_nil?(reason = nil)
-        shift(ObjectListNil, reason, raise: false)
+      def shift_nil?(&reason_blk)
+        shift(ObjectListNil, raise: false, &reason_blk)
       end
 
-      def shift(cls, reason = nil, raise: true)
+      def shift(cls, raise: true, &reason_blk)
         unless (token = @tokens.shift)
           raise 'no more tokens'
         end
 
         unless token.is_a?(cls)
-          raise "expected #{cls} got #{token.inspect} for #{reason}" if raise
+          unexpected_token!(cls, token, &reason_blk) if raise
 
           @tokens.unshift(token)
           return
         end
         token
       end
+
+      def unexpected_token!(expected_class, token, &reason_blk)
+        raise "expected #{expected_class} got #{token.inspect} for #{reason_blk&.call}"
+      end
     end
   end
 end

data/lib/slf0/tokenizer.rb

@@ -24,7 +24,7 @@ module SLF0
     def tokenize_body!
       body = []
       until scanner.eos?
-        object = tokenize_field || tokenize_double_field || tokenize_object_list_nil
+        object = tokenize_double_field || tokenize_field || tokenize_object_list_nil
         raise "malformed no object: #{scanner.rest.inspect}\n\nafter: #{body.inspect}" unless object
 
         body << object
@@ -39,11 +39,11 @@ module SLF0
       when '#'
         SLF0::Token::Int.new int
       when '%'
-        SLF0::Token::ClassName.new scanner.scan(/.{#{int}}/).freeze
+        SLF0::Token::ClassName.new scan_length(int).freeze
       when '@'
         SLF0::Token::ClassNameRef.new int
       when '"'
-        SLF0::Token::String.new scanner.scan(/.{#{int}}/).tr("\r", "\n").freeze
+        SLF0::Token::String.new scan_length(int).tr("\r", "\n").freeze
       when '('
         SLF0::Token::ObjectList.new int
       else
@@ -52,8 +52,14 @@ module SLF0
       end
     end
 
+    def scan_length(length)
+      string = scanner.string[scanner.pos, length]
+      scanner.pos += length
+      string
+    end
+
     def tokenize_double_field
-      return unless (hex = scanner.scan(/[0-9a-fA-F]*\^/)&.chomp('^'))
+      return unless (hex = scanner.scan(/\h*\^/)&.chop)
 
       double = [hex.to_i(16)].pack('Q<').unpack1('G')
       SLF0::Token::Double.new double

data/lib/xcactivitylog/objects.rb

@@ -2,8 +2,8 @@
 
 module XCActivityLog
   class SerializedObject
-    Attribute = Struct.new(:name, :type, :first_version, :last_version)
-    def self.attribute(name, type, first_version = 0, last_version = 99_999)
+    Attribute = Struct.new(:name, :type, :first_version, :first_version_without)
+    def self.attribute(name, type, first_version = 0, first_version_without = 99_999)
       attr_reader name
       alias_method "#{name}?", name if type == :boolean
       if type == :time
@@ -12,7 +12,7 @@ module XCActivityLog
           time.to_i * 1_000_000 + time.usec
         end
       end
-      attributes << Attribute.new(name, type, first_version, last_version).freeze
+      attributes << Attribute.new(name, type, first_version, first_version_without).freeze
     end
 
     def self.attributes
@@ -47,6 +47,47 @@ module XCActivityLog
   end
 
   class IDEActivityLogSection < SerializedObject
+    class Severity
+      protected
+
+      attr_reader :severity
+
+      public
+
+      def initialize(severity)
+        @severity = severity
+        freeze
+      end
+
+      SUCCESS = new(0)
+      WARNING = new(1)
+      ERROR = new(2)
+      TEST_FAILURE = new(3)
+
+      def to_s
+        case severity
+        when 0
+          'Success'
+        when 1
+          'Warning'
+        when 2
+          'Error'
+        when 3
+          'Test Failure'
+        else
+          "Unknown (#{severity})"
+        end
+      end
+
+      include Comparable
+
+      def <=>(other)
+        severity <=> other.severity
+      end
+    end
+
+    TargetInfo = Struct.new(:name, :configuration, :workspace, keyword_init: true)
+
     include Enumerable
     def each(&blk)
       return enum_for(__method__) unless block_given?
@@ -55,9 +96,82 @@ module XCActivityLog
       subsections&.each { |s| s.each(&blk) }
     end
 
+    def each_with_parent(parent: nil, &blk)
+      return enum_for(__method__) unless block_given?
+
+      yield self, parent
+      subsections&.each { |s| s.each_with_parent(parent: self, &blk) }
+    end
+
     def duration_usec
       time_stopped_recording_usec - time_started_recording_usec
     end
+
+    def target_info(parent: nil)
+      parent&.target_info ||
+        (title =~ /=== BUILD TARGET (.+?) OF PROJECT (.+?) WITH CONFIGURATION (.+?) ===/ &&
+          TargetInfo.new(name: Regexp.last_match(1), configuration: Regexp.last_match(3), workspace: Regexp.last_match(2)))
+    end
+
+    def each_trace_event
+      thread_id_map_by_section_type = Hash.new { |h, k| h[k] = [] }
+      each_with_parent.sort_by { |s, _| s.time_started_recording }.each do |section, parent|
+        thread_id_map = thread_id_map_by_section_type[section.section_type]
+        best_thread, thread_id = thread_id_map.each_with_index.select do |thread, _tid|
+          section.time_started_recording > thread.last.time_stopped_recording
+        end.min_by do |thread, _tid|
+          (section.time_started_recording - thread.last.time_stopped_recording) +
+            (thread.last.time_stopped_recording - thread_id_map.map(&:last).map(&:time_stopped_recording).min)
+        end
+        unless thread_id
+          thread_id = thread_id_map.size
+          best_thread = []
+          thread_id_map << best_thread
+        end
+        best_thread << section
+
+        yield(section: section, parent: parent, thread_id: thread_id)
+      end
+    end
+
+    def write_chrome_trace_file(section_type:, to:)
+      to << '{"traceEvents":[' << "\n"
+      written_comma = false
+      each_trace_event do |section:, parent:, thread_id:|
+        case section.section_type
+        when section_type
+          if written_comma
+            to << ",\n"
+          else
+            written_comma = true
+          end
+          require 'json'
+          to << JSON.generate(
+            pid: section.section_type.to_s,
+            tid: thread_id,
+            ts: section.time_started_recording_usec,
+            ph: 'X',
+            name: section.title.dup&.force_encoding('UTF-8'),
+            dur: section.duration_usec,
+            args: {
+              subtitle: section.subtitle.dup&.force_encoding('UTF-8'),
+              target: section.target_info(parent: parent).to_h,
+              severity: section.severity
+            }
+          )
+        end
+      end
+
+      to << "\n]}"
+
+      to
+    end
+
+    def severity
+      severity = (messages || []).reduce(Severity::SUCCESS) { |a, e| [a, Severity.new(e.severity)].max }
+      (subsections || []).reduce(severity) { |a, e| [a, e.severity].max }
+    end
+
     attribute :section_type, :int
     attribute :domain_type, :string
     attribute :title, :string
@@ -75,13 +189,28 @@ module XCActivityLog
     attribute :command_detail_description, :string
     attribute :unique_identifier, :string
     attribute :localized_result_string, :string
-    attribute :xcbuild_signature, :string
-    attribute :collect_metrics, :boolean, 9
+    attribute :xcbuild_signature, :string, 8
+    attribute :collect_metrics, :boolean, 9, 10
     attributes.freeze
   end
   class IDECommandLineBuildLog < IDEActivityLogSection
     attributes.freeze
   end
+  class IDEActivityLogCommandInvocationSection < IDEActivityLogSection
+    attributes.freeze
+  end
+  class IDEActivityLogUnitTestSection < IDEActivityLogSection
+    attribute :tests_passes, :string
+    attribute :duration, :string
+    attribute :summary, :string
+    attribute :suite_name, :string
+    attribute :test_name, :string
+    attribute :performance_test_output, :string
+    attributes.freeze
+  end
+  class IDEActivityLogMajorGroupSection < IDEActivityLogSection
+    attributes.freeze
+  end
 
   class IDEActivityLogMessage < SerializedObject
     include Enumerable
@@ -98,7 +227,7 @@ module XCActivityLog
     attribute :submessages, :object_list
     attribute :severity, :int
     attribute :type, :string
-    attribute :location, :object
+    attribute :location, :document_location
     attribute :category_identifier, :string
     attribute :secondary_locations, :object_list
     attribute :additional_description, :string
@@ -107,6 +236,34 @@ module XCActivityLog
   class IDEClangDiagnosticActivityLogMessage < IDEActivityLogMessage
     attributes.freeze
   end
+  class IDEActivityLogAnalyzerResultMessage < IDEActivityLogMessage
+    attribute :result_type, :string
+    attribute :key_event_index, :int
+    attributes.freeze
+  end
+  class IDEActivityLogAnalyzerStepMessage < IDEActivityLogMessage
+    attribute :parent_index, :int
+    attributes.freeze
+  end
+  class IDEActivityLogAnalyzerEventStepMessage < IDEActivityLogAnalyzerStepMessage
+    attribute :result_type, :string
+    attribute :key_event_index, :int
+    attributes.freeze
+  end
+  class IDEActivityLogAnalyzerControlFlowStepMessage < IDEActivityLogAnalyzerStepMessage
+    attribute :end_location, :document_location
+    attribute :edges, :object_list
+    attributes.freeze
+  end
+  class IDEActivityLogAnalyzerWarningMessage < IDEActivityLogMessage
+    attributes.freeze
+  end
+
+  class IDEActivityLogAnalyzerControlFlowStepEdge < SerializedObject
+    attribute :start_location, :document_location
+    attribute :end_location, :document_location
+    attributes.freeze
+  end
 
   class DVTDocumentLocation < SerializedObject
     attribute :document_url_string, :string
@@ -123,7 +280,7 @@ module XCActivityLog
     attribute :ending_line_number, :int
     attribute :ending_column_number, :int
     attribute :character_range, :nsrange
-    attribute :location_encoding, :int
+    attribute :location_encoding, :int, 7
     attributes.freeze
   end
 end

data/lib/xcactivitylog/parser.rb

@@ -8,7 +8,7 @@ module XCActivityLog
     class S < SLF0::Token::Stream
       def initialize(tokens, class_deserializer:)
         super(tokens, class_deserializer: class_deserializer)
-        @version = int('activity log version')
+        @version = int { 'activity log version' }
       end
 
       def deserializer_for(class_ref_num)
@@ -24,34 +24,38 @@ module XCActivityLog
       def deserialize_instance_of(stream, cls)
         instance = cls.new
         cls.attributes.each do |attr|
-          next if attr.first_version > @version || attr.last_version < @version
+          next if attr.first_version > @version || attr.first_version_without <= @version
 
-          value = stream.send(attr.type, "#{attr.name} for #{cls.name.split('::').last}")
+          value = stream.send(attr.type) { "#{attr.name} for #{cls.name.split('::').last} #{instance.inspect}" }
           instance.instance_variable_set(:"@#{attr.name}", value)
         end
         instance.freeze
       end
 
-      def boolean(reason = nil)
-        int(reason) != 0
+      def boolean(&reason_blk)
+        int(&reason_blk) != 0
       end
 
-      def nsrange(_reason = nil)
+      def nsrange(&_reason_blk)
         deserialize_instance_of(self, NSRange)
       end
 
-      def document_location(reason = nil)
+      def document_location(&reason_blk)
         return if shift_nil?
 
-        object(reason).tap do |o|
-          raise "expected location, got #{o.class.name} for #{reason}" unless o.is_a?(DVTDocumentLocation)
+        object(&reason_blk).tap do |o|
+          raise "expected location, got #{o.class.name} for #{reason_blk&.call}" unless o.is_a?(DVTDocumentLocation)
         end
       end
 
       EPOCH = Time.new(2001, 1, 1, 0, 0, 0, '+00:00').freeze
 
-      def time(reason = nil)
-        EPOCH.+(double(reason)).freeze
+      def time(&reason_blk)
+        EPOCH.+(double(&reason_blk)).freeze
+      end
+
+      def unexpected_token!(expected_class, token, &reason_blk)
+        raise "expected #{expected_class} got #{token.inspect} for #{reason_blk&.call} (XCActivityLog version #{@version})"
       end
     end
     def make_stream(tokens, class_deserializer)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcactivitylog
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Samuel Giddins
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-05-14 00:00:00.000000000 Z
+date: 2020-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,7 +52,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: 
+description:
 email:
 - segiddins@segiddins.me
 executables: []
@@ -76,7 +76,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/segiddins/xcactivitylog
   source_code_uri: https://github.com/segiddins/xcactivitylog
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -91,9 +91,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.0.1
+signing_key:
 specification_version: 4
 summary: Parse Xcode's xcactivitylog files (and other SLF0-serialized files)
 test_files: []