danger-app_size_report 0.0.1 → 0.0.3

data/lib/app_size_report/plugin.rb

@@ -1,111 +1,185 @@
-require 'json'
-require 'set'
+# frozen_string_literal: false
 
 module Danger
-  # Validates variant sizes of app thinning report json within a Pull Request and generates a brief report.
+  require 'json'
+  require_relative '../converter/parser/report_parser'
+  require_relative '../converter/helper/memory_size'
+
+  # A Danger plugin for reporting iOS app size violations.
+  # A valid App Thinning Size Report must be passed to the plugin
+  # for accurate functionality.
+  #
+  # @example Report app size violations if one or more App variants
+  # exceed 4GB.
+  #
+  #          report_path = "/Path/to/AppSize/Report.txt"
+  #          app_size_report.flag_violations(
+  #             report_path,
+  #             build_type: 'App',
+  #             size_limit: 4,
+  #             limit_unit: 'GB',
+  #             fail_on_warning: false
+  #          )
+  #
+  # @example Report app size violations if one or more App Clip variants
+  # exceed 8MB.
   #
-  # @example Validating code coverage for app_th (easy-peasy.io)
+  #          report_path = "/Path/to/AppSize/Report.txt"
+  #          app_size_report.flag_violations(
+  #             report_path,
+  #             build_type: 'Clip',
+  #             size_limit: 8,
+  #             limit_unit: 'MB',
+  #             fail_on_warning: false
+  #          )
   #
-  #    # Get the path to your app thinning report
-  #   
-  #    # The result is sent to the pull request with a markdown format and
-  #    # notifies failure which variants is violating the size limit.
+  # @example Fail PR if one or more App Clip variants exceed 8MB.
   #
-  #    app_size_report.report(
-  #      [path_to_report],
-  #      [app_size_limit]
-  #    )
+  #          report_path = "/Path/to/AppSize/Report.txt"
+  #          app_size_report.flag_violations(
+  #             report_path,
+  #             build_type: 'Clip',
+  #             size_limit: 8,
+  #             limit_unit: 'MB',
+  #             fail_on_warning: true
+  #          )
+  #
+  # @example Get JSON string representation of app thinning size report
+  #
+  #          report_path = "/Path/to/AppSize/Report.txt"
+  #          app_size_json = app_size_report.report_json(report_path)
+  #
+  # @see  ChargePoint/danger-app_size_report
+  # @tags ios, xcode, appclip, thinning, size
   #
   class DangerAppSizeReport < Plugin
-    # A method that create app thinning report
-    # @return   [Array<Variant>]
+    # Reports app size violations given a valid App Thinning Size Report.
+    # @param [String, required] report_path
+    #        Path to valid App Thinning Size Report text file.
+    # @param [String, optional] build_type
+    #        Specify whether the report corresponds to an App or an App Clip.
+    #        Default: 'App'
+    #        Supported values: 'App', 'Clip'
+    # @param [Numeric, optional] size_limit
+    #        Specify the app size limit.
+    #        Default: 4
+    # @param [String, optional] limit_unit
+    #        Specific the unit for the given size limit.
+    #        Default: 'GB'
+    #        Supported values: 'KB', 'MB', 'GB'
+    # @param [Boolean, optional] fail_on_warning
+    #        Specify whether the PR should fail if one or more app variants
+    #        exceed the given size limit. By default, the plugin issues
+    #        a warning in this case.
+    #        Default: 'false'
+    # @return   [void]
     #
-    def report(report_path, app_size_limit)
-      if File.exist?(report_path)
-        report = File.read(report_path)
-        json = JSON.parse(report)
-        
-        flagged_variants = parse_json(*json, app_size_limit)
-
-        if flagged_variants.length > 0
-          failure "The App Clip size limit of 10 MB has been exceeded by one or more variants"
-        end
+    def flag_violations(report_path, build_type: 'App', size_limit: 4, limit_unit: 'GB', fail_on_warning: false)
+      report_text = File.read(report_path)
+      variants = ReportParser.parse(report_text)
 
-        init_app_size_violation_table(*json, flagged_variants, app_size_limit)
-        init_supported_variant_descriptors(*json)
-        init_ads()
+      unless %w[App Clip].include? build_type
+        raise ArgumentError, "The 'build_type' argument only accepts the values \"App\" and \"Clip\""
       end
-    end
 
-    # A method that create an array of variants that violate app size limit
-    # @return   [Array<Variant>]
-    #
-    def parse_json(*json, app_size_limit)
-      flagged_variants = Array.new
-
-      json.each do |variant, value|
-        app_size = variant["app_size"]["uncompressed"]["value"]
-        app_odr_size = variant["app_on_demand_resources_size"]["uncompressed"]["value"]
-        if app_size > app_size_limit || app_odr_size > app_size_limit
-          flagged_variants.append(variant)
-        end
+      raise ArgumentError, "The 'size_limit' argument only accepts numeric values" unless size_limit.is_a? Numeric
+
+      limit_unit.upcase!
+      unless %w[KB MB GB].include? limit_unit
+        raise ArgumentError, "The 'build_type' argument only accepts the values \"KB\", \"MB\" and \"GB\""
       end
-      
-      if flagged_variants.length > 0
-        failure "The App Clip size limit of 10 MB has been exceeded by one or more variants"
+
+      unless [true, false].include? fail_on_warning
+        raise ArgumentError, "The 'fail_on_warning' argument only accepts the values 'true' and 'false'"
       end
 
-      return flagged_variants
+      generate_size_report_markdown(variants, build_type, size_limit, limit_unit, fail_on_warning)
+      generate_variant_descriptors_markdown(variants)
+      generate_ads_label_markdown
     end
 
-    # A method that create the violation table in Github
-    # 
+    # Returns a JSON string representation of the given App Thinning Size Report.
+    # @param [String, required] report_path
+    #        Path to valid App Thinning Size Report text file.
+    # @return   [String]
     #
-    def init_app_size_violation_table(*json, flagged_variants, app_size_limit)
+    def report_json(report_path)
+      report_text = File.read(report_path)
+      variants = ReportParser.parse(report_text)
+      JSON.pretty_generate(variants)
+    end
+
+    private
+
+    def generate_size_report_markdown(variants, build_type, size_limit, limit_unit, fail_on_warning)
+      limit_size = MemorySize.new("#{size_limit}#{limit_unit}")
+
+      if build_type == 'Clip' && limit_size.megabytes > 10
+        message "The size limit was set to 10 MB as the given limit of #{size_limit} #{limit_unit} exceeds Apple's App Clip size restrictions"
+        size_limit = 10
+        limit_unit = 'MB'
+        limit_size.kilobytes = 10 * 1024
+      elsif build_type == 'App' && limit_size.gigabytes > 4
+        message "The size limit was set to 4 GB as the given limit of #{size_limit} #{limit_unit} exceeds Apple's App size restrictions"
+        size_limit = 4
+        limit_unit = 'GB'
+        limit_size.kilobytes = 4 * 1024 * 1024
+      end
+
+      flagged_variant_names = []
+      variants.each do |variant|
+        if variant.app_size.uncompressed.value > limit_size.megabytes || variant.on_demand_resources_size.uncompressed.value > limit_size.megabytes
+          flagged_variant_names.append(variant.variant)
+        end
+      end
+
+      if flagged_variant_names.length.positive?
+        if fail_on_warning
+          failure "The size limit of #{size_limit} #{limit_unit.upcase} has been exceeded by one or more variants"
+        else
+          warn "The size limit of #{size_limit} #{limit_unit.upcase} has been exceeded by one or more variants"
+        end
+      end
+
       size_report = "# App Thinning Size Report\n"
-      size_report << "### Size limit = #{app_size_limit} MB\n\n"
+      size_report << "### Size limit = #{size_limit} #{limit_unit.upcase}\n\n"
       size_report << "| Under Limit | Variant | App Size - Compressed | App Size - Uncompressed | ODR Size - Compressed | ODR Size - Uncompressed |\n"
-      size_report << "| ---------- | ------- | --------------------- | --------------------- | --------------------- | --------------------- |\n"
-      flagged_variants_set = flagged_variants.to_set
-      json.each do |variant, _|
-        isViolating = flagged_variants_set.include?(variant) ? "❌" : "✅"
-        app_size_compressed = "#{variant["app_size"]["compressed"]["value"]} #{variant["app_size"]["uncompressed"]["unit"]}"
-        app_size_uncompressed = "#{variant["app_size"]["uncompressed"]["value"]} #{variant["app_size"]["uncompressed"]["unit"]}" 
-        odr_size_compressed = "#{variant["on_demand_resources_size"]["compressed"]["value"]} #{variant["app_size"]["uncompressed"]["unit"]}"
-        odr_size_uncompressed = "#{variant["on_demand_resources_size"]["uncompressed"]["value"]} #{variant["app_size"]["uncompressed"]["unit"]}"
-        
-        size_report << "#{isViolating} | #{variant["variant"]} | #{app_size_compressed} | #{app_size_uncompressed} | #{odr_size_compressed} | #{odr_size_uncompressed} |\n"
+      size_report << "| :-: | :-: | :-: | :-: | :-: | :-: |\n"
+
+      flagged_variants_set = flagged_variant_names.to_set
+
+      variants.each do |variant|
+        is_violating = flagged_variants_set.include?(variant.variant) ? '❌' : '✅'
+        app_size_compressed = "#{variant.app_size.compressed.value} #{variant.app_size.compressed.unit}"
+        app_size_uncompressed = "#{variant.app_size.uncompressed.value} #{variant.app_size.uncompressed.unit}"
+        odr_size_compressed = "#{variant.on_demand_resources_size.compressed.value} #{variant.on_demand_resources_size.compressed.unit}"
+        odr_size_uncompressed = "#{variant.on_demand_resources_size.uncompressed.value} #{variant.on_demand_resources_size.uncompressed.unit}"
+
+        size_report << "#{is_violating} | #{variant.variant} | #{app_size_compressed} | #{app_size_uncompressed} | #{odr_size_compressed} | #{odr_size_uncompressed} |\n"
       end
 
       markdown size_report
     end
 
-    # A method that create the supported variant table in Github
-    # 
-    #
-    def init_supported_variant_descriptors(*json)
-      variant_descriptor_report = "### Supported Variant Descriptors \n\n"
-      json.each do |variant, _|
-        variant_descriptor_report << "<details> \n"
-        variant_descriptor_report << "<summary> Variant #{variant["variant"]} </summary> \n\n"
-        variant_descriptor_report << "| Model | Operating System | \n"
-        variant_descriptor_report << "| ----- | ---------------- | \n"
-        variant["supported_variant_descriptors"].each do |model, _|
-          variant_descriptor_report << "#{model["device"]} | #{model["os_version"]} | \n"
+    def generate_variant_descriptors_markdown(variants)
+      variant_descriptors_report = "### Supported Variant Descriptors \n\n"
+      variants.each do |variant|
+        variant_descriptors_report << "<details> \n"
+        variant_descriptors_report << "<summary> #{variant.variant} </summary> \n\n"
+        variant_descriptors_report << "| Model | Operating System | \n"
+        variant_descriptors_report << "| - | :-: |\n"
+        variant.supported_variant_descriptors.each do |variant_descriptor|
+          variant_descriptors_report << "#{variant_descriptor.device} | #{variant_descriptor.os_version} | \n"
         end
-        variant_descriptor_report << "</details> \n\n"
+        variant_descriptors_report << "</details> \n\n"
       end
 
-      markdown variant_descriptor_report
+      markdown variant_descriptors_report
     end
 
-    # A method that create the footnote label in Github
-    # 
-    #
-    def init_ads
-      ads_label = "Powered by [danger-app_size_report](https://github.com/ChargePoint)"
+    def generate_ads_label_markdown
+      ads_label = 'Powered by [danger-app_size_report](https://github.com/ChargePoint)'
       markdown ads_label
     end
-
   end
 end

data/lib/converter/helper/json_converter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'json'
+
+class JSONConverter
+  def to_json(_options = {})
+    hash = {}
+    instance_variables.each do |var|
+      key = var.to_s[1..]
+      hash[key] = instance_variable_get(var)
+    end
+    JSON.pretty_generate(hash)
+  end
+end

data/lib/converter/helper/memory_size.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: false
+
+require_relative '../helper/json_converter'
+class MemorySize < JSONConverter
+  attr_accessor :kilobytes
+
+  ZERO_SIZE = 'zero kb'.freeze
+
+  UNIT = {
+    bytes: 'B',
+    kilobytes: 'KB',
+    megabytes: 'MB',
+    gigabytes: 'GB'
+  }.freeze
+
+  def bytes
+    @kilobytes * 1024
+  end
+
+  def megabytes
+    @kilobytes / 1024
+  end
+
+  def gigabytes
+    @kilobytes / 1024 / 1024
+  end
+
+  def initialize(text)
+    super()
+    value = parse_from(text)
+
+    @kilobytes = value || 0
+  end
+
+  private
+
+  def parse_from(text)
+    text_to_memory_unit = {
+      'b' => :bytes,
+      'byte' => :bytes,
+      'bytes' => :bytes,
+      'kb' => :kilobytes,
+      'kilobyte' => :kilobytes,
+      'kilobytes' => :kilobytes,
+      'mb' => :megabytes,
+      'megabyte' => :megabytes,
+      'megabytes' => :megabytes,
+      'gb' => :gigabytes,
+      'gigabyte' => :gigabytes,
+      'gigabytes' => :gigabytes
+    }
+
+    unit = text_to_memory_unit[parse_units(text)]
+    size = parse_size(text)
+
+    return nil unless size
+
+    unit ||= :megabytes
+
+    case unit
+    when :bytes
+      kilobytes_from_bytes(size)
+    when :kilobytes
+      size
+    when :megabytes
+      kilobytes_from_megabytes(size)
+    when :gigabytes
+      kilobytes_from_gigabytes(size)
+    end
+  end
+
+  def parse_units(text)
+    return 'kb' if text.downcase == ZERO_SIZE
+
+    result = ''
+
+    text.each_char do |char|
+      result << char if char.match?(/[[:alpha:]]/) && char != '.' && char != ','
+    end
+
+    result.downcase
+  end
+
+  def parse_size(text)
+    return 0.to_f if text.downcase == ZERO_SIZE
+
+    result = ''
+
+    text.each_char do |char|
+      result << char if char.match?(/[[:digit:]]/) || char == '.' || char == ','
+    end
+
+    result.to_f
+  end
+
+  def kilobytes_from_bytes(bytes)
+    bytes / 1024
+  end
+
+  def kilobytes_from_megabytes(megabytes)
+    megabytes * 1024
+  end
+
+  def kilobytes_from_gigabytes(gigabytes)
+    gigabytes * 1024 * 1024
+  end
+end

data/lib/converter/helper/result_factory.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../parser/variant_parser'
+require_relative '../parser/variant_descriptor_parser'
+require_relative '../parser/app_size_parser'
+
+class ResultFactory
+  def self.parse(from_text: '', parser: nil)
+    result = nil
+    case parser
+    when :variant
+      variant_parser = VariantParser.new(from_text)
+      variant_parser.parse
+      result = variant_parser.result
+    when :supported_variant_descriptors
+      variant_descriptor_parser = VariantDescriptorParser.new(from_text)
+      variant_descriptor_parser.parse
+      result = variant_descriptor_parser.result
+    when :app_on_demand_resources_size
+      app_size_parser = AppSizeParser.new(from_text)
+      app_size_parser.parse
+      result = app_size_parser.result
+    when :app_size
+      app_size_parser = AppSizeParser.new(from_text)
+      app_size_parser.parse
+      result = app_size_parser.result
+    when :on_demand_resources_size
+      app_size_parser = AppSizeParser.new(from_text)
+      app_size_parser.parse
+      result = app_size_parser.result
+    end
+    result
+  end
+end

data/lib/converter/models/app_size_model.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../helper/json_converter'
+class AppSizeModel < JSONConverter
+  attr_reader :compressed, :uncompressed
+
+  PARSING_KEYS = {
+    compressed: 'compressed',
+    uncompressed: 'uncompressed'
+  }.freeze
+
+  def initialize(compressed: SizeModel.placeholder, uncompressed: SizeModel.placeholder)
+    super()
+    @compressed = compressed
+    @uncompressed = uncompressed
+  end
+end
+
+class SizeModel < JSONConverter
+  attr_reader :raw_value, :value, :unit
+
+  def initialize(raw_value, value, unit)
+    super()
+    @raw_value = raw_value
+    @value = value
+    @unit = unit
+  end
+
+  def self.placeholder
+    SizeModel.new('Unknown', 0, MemorySize::UNIT[:bytes])
+  end
+end

data/lib/converter/models/device_model.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../helper/json_converter'
+class DeviceModel < JSONConverter
+  attr_reader :device, :os_version
+
+  PARSING_KEYS = {
+    device: 'device: ',
+    os_version: 'os-version: '
+  }.freeze
+
+  def initialize(device, os_version)
+    super()
+    @device = device
+    @os_version = os_version
+  end
+end

data/lib/converter/models/variant_model.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../helper/json_converter'
+class VariantModel < JSONConverter
+  attr_reader :variant, :supported_variant_descriptors, :app_on_demand_resources_size, :app_size,
+              :on_demand_resources_size
+
+  PARSING_KEYS = {
+    variant: 'Variant: ',
+    supported_variant_descriptors: 'Supported variant descriptors: ',
+    app_on_demand_resources_size: 'App + On Demand Resources size: ',
+    app_size: 'App size: ',
+    on_demand_resources_size: 'On Demand Resources size: '
+  }.freeze
+
+  def initialize(variant, supported_variant_descriptors, app_on_demand_resources_size, app_size, on_demand_resources_size)
+    super()
+    @variant = variant
+    @supported_variant_descriptors = supported_variant_descriptors
+    @app_on_demand_resources_size = app_on_demand_resources_size
+    @app_size = app_size
+    @on_demand_resources_size = on_demand_resources_size
+  end
+end

data/lib/converter/parser/app_size_parser.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: false
+
+require_relative '../models/app_size_model'
+require_relative '../helper/memory_size'
+require_relative './model_parser'
+
+class AppSizeParser < ModelParser
+  attr_reader :standardized_unit
+
+  def initialize(text, standardized_unit: MemorySize::UNIT[:megabytes])
+    super(text)
+    @standardized_unit = standardized_unit
+  end
+
+  def parse
+    @text = @text.strip
+    if @text.empty?
+      @result = nil
+    else
+      parseable_text = @text.split(', ')
+      properties = {}
+      parsing_keys = AppSizeModel::PARSING_KEYS
+      parseable_text.each do |size_text|
+        parsing_keys.each do |_property, key|
+          if size_text.include?(key) && !properties.fetch(key, nil)
+            value = size_text.gsub!(key, '')
+            properties[key] = value.strip
+          end
+        end
+      end
+
+      compressed_string = properties.fetch(parsing_keys[:compressed], nil)
+      uncompressed_string = properties.fetch(parsing_keys[:uncompressed], nil)
+      compressed_value = MemorySize.new(compressed_string).megabytes
+      uncompressed_value = MemorySize.new(uncompressed_string).megabytes
+
+      if compressed_string && uncompressed_string && compressed_value && uncompressed_value
+        compressed_raw_value = compressed_string.downcase == MemorySize::ZERO_SIZE ? '0 KB' : compressed_string
+        compressed_size = SizeModel.new(compressed_raw_value, compressed_value, @standardized_unit)
+        uncompressed_raw_value = uncompressed_string.downcase == MemorySize::ZERO_SIZE ? '0 KB' : uncompressed_string
+        uncompressed_size = SizeModel.new(uncompressed_raw_value, uncompressed_value, @standardized_unit)
+        @result = AppSizeModel.new(compressed: compressed_size, uncompressed: uncompressed_size)
+      else
+        @result = AppSizeModel.new
+      end
+    end
+  end
+end

data/lib/converter/parser/model_parser.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: false
+
+class ModelParser
+  attr_reader :text, :result
+
+  def initialize(text)
+    @text = text
+  end
+
+  def parse
+    raise NotImplementedError, 'Implement this method in a child class'
+  end
+end

data/lib/converter/parser/report_parser.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: false
+
+require 'securerandom'
+require_relative '../models/variant_model'
+require_relative '../helper/result_factory'
+
+class ReportParser
+  def self.parse(text)
+    splitter_id = SecureRandom.uuid
+
+    # First we trim the report text
+    preprocessed_data = text.strip
+
+    preprocessed_data.gsub!(/\n{2,3}/, "\n#{splitter_id}\n")
+
+    # Also append the splitter ID to the end of the text so we do not miss the last variant
+    preprocessed_data += "\n#{splitter_id}\n"
+
+    data = preprocessed_data.split("\n")
+
+    variants = []
+    dict = {}
+
+    data.each do |value|
+      parsing_keys = VariantModel::PARSING_KEYS
+      if value == splitter_id && dict.fetch(parsing_keys[:variant], nil)
+        variant = dict.fetch(parsing_keys[:variant], '')
+        supported_variant_descriptors = dict.fetch(parsing_keys[:supported_variant_descriptors], '')
+        app_on_demand_resources_size = dict.fetch(parsing_keys[:app_on_demand_resources_size], '')
+        app_size = dict.fetch(parsing_keys[:app_size], '')
+        on_demand_resources_size = dict.fetch(parsing_keys[:on_demand_resources_size], '')
+
+        # initialize variant model from all the parser result
+        model = VariantModel.new(variant,
+                                 supported_variant_descriptors,
+                                 app_on_demand_resources_size,
+                                 app_size,
+                                 on_demand_resources_size)
+
+        variants.append(model)
+
+        # reset all the properties
+        dict = {}
+      end
+
+      parsing_keys.each do |property, key|
+        next unless value.include? key
+
+        # clean the key from the text
+        # i.e. "Variant: ChargePointAppClip-354363463-...." remove the "Variant: " so we have a clean text that we can parse ("ChargePointAppClip-354363463-....")
+        # i.e. "Supported variant descriptors: [device: iPhone10,3, os-version:14.0], ..." will pass only the "[device: iPhone10,3, os-version:14.0], ..." to the parser
+        if (key == parsing_keys[:on_demand_resources_size]) && (value.include? parsing_keys[:app_on_demand_resources_size])
+          parseable_text = value.gsub(parsing_keys[:app_on_demand_resources_size], '')
+          dict[key] = parseable_text
+          dict[key] = ResultFactory.parse(from_text: parseable_text, parser: :app_on_demand_resources_size)
+        else
+          parseable_text = value.gsub(key, '')
+          dict[key] = parseable_text
+          dict[key] = ResultFactory.parse(from_text: parseable_text, parser: property)
+        end
+      end
+    end
+    variants
+  end
+end