xc_metrics_aggregator 0.1.0

data/lib/xc_metrics_aggregator/formatter/output_format.rb

@@ -0,0 +1,10 @@
+module XcMetricsAggregator
+    module OutputFormat
+        CSV = "csv"
+        ASCII = "ascii"
+
+        def self.all
+            self.constants.map{|name| self.const_get(name) }
+        end
+    end
+end

data/lib/xc_metrics_aggregator/product.rb

@@ -0,0 +1,113 @@
+require 'etc'
+require 'json'
+require 'pathname'
+
+
+module XcMetricsAggregator
+  PRODUCT_PATH = File.join('/', 'Users', Etc.getlogin, 'Library', 'Developer' , 'Xcode', 'Products')
+
+  class Product
+    def metrics_dir
+      Pathname.new(File.join(@path, 'Metrics'))
+    end
+
+    def metrics_file
+        Pathname.new(File.join(metrics_dir, 'AppStore/Metrics.xcmetricsdata'))
+    end
+
+    def bundle_id
+        Pathname.new(@path).basename.to_s
+    end
+
+    def has_metrics?
+        File.exists?(metrics_dir)
+    end
+
+    def initialize(path)
+      @path = path
+    end
+
+    def open
+      FileNotFoundException.new("File not Found: #{metrics_file}") unless has_metrics?
+      File.open(metrics_file) do |file|
+        yield JSON.load(file, symbolize_names: true)
+      end
+    end
+
+
+    def try_to_open
+      return unless has_metrics?
+      File.open(metrics_file) do |file|
+        yield JSON.load(file, symbolize_names: true)
+      end
+    end
+  end
+
+  class ProductsService
+    attr_reader :products
+
+    def initialize
+        @products = Dir.glob(PRODUCT_PATH + "/*").map { |dir_path| Product.new dir_path }     
+    end
+
+    def targets(bundle_ids=[])
+      if bundle_ids.empty?
+        products
+      else
+        products.select do |product|
+           bundle_ids.include? product.bundle_id.to_s
+        end
+      end
+    end
+
+    def target(bundle_id)
+      if bundle_id.nil?
+        raise StandardError.new("needs bundle id")
+      end
+
+      products.select { |product| bundle_id == product.bundle_id.to_s }.first
+    end
+
+    def each_product(bundle_ids=[])
+      targets(bundle_ids).each do |product|
+        yield product
+      end
+    end
+
+    def structure(available_path)
+      structure = XcMetricsAggregator::TableStructure.new
+      structure.title = "available app list"
+      structure.headings = headings(available_path)
+      structure.rows = rows(available_path)
+      structure
+    end
+
+    private
+    def headings(available_path)
+      if available_path
+        ['bundle id', 'status', 'raw data path']
+      else 
+        ['bundle id', 'status']
+      end
+      
+    end
+
+    def rows(available_path)
+      rows = []
+      products.each do |product|
+        status = 
+          if product.has_metrics?
+            "has metrics"
+          else
+            "fail to get metrics"
+          end
+        if available_path
+          rows << [product.bundle_id, status, product.metrics_file.to_s]
+        else 
+          rows << [product.bundle_id, status]
+        end
+      end
+      return rows
+    end
+  end
+end

data/lib/xc_metrics_aggregator/service/categories_service.rb

@@ -0,0 +1,146 @@
+require 'xc_metrics_aggregator/structure/structure'
+
+module XcMetricsAggregator
+    class CategoriesService
+        attr_reader :device_service, :percentile_service
+
+        def initialize(bundle_id, json)
+            @json = json
+            @bundle_id = bundle_id
+            @device_service = DevicesService.new bundle_id, json
+            @percentile_service = PercentilesService.new bundle_id, json
+        end
+
+        def structure
+            structure = XcMetricsAggregator::TableStructure.new
+            structure.title = @bundle_id
+            structure.headings = headings
+            structure.rows = rows
+            structure
+        end
+
+        def categories
+            @json["categories"].map { |json| Category.new json }
+        end
+
+        def get_dataset(section_name, device, percentile)
+            section = categories.map { |category| category.sections.find { |section| section.display_name == section_name } }.first
+            dataset = section.datasets.find do |dataset| 
+                dataset.filter_criteria.device == device.identifier \
+                && dataset.filter_criteria.percentile == percentile.identifier
+            end
+        end
+
+
+        def get_available_dataset(section_name, device, percentile)
+            section = categories.map { |category| 
+                category.sections.find { |section| 
+                    section.display_name == section_name
+                }
+            }.flatten.compact.first
+            if section.nil?
+                return nil
+            end
+
+            datasets = section.datasets.select do |dataset| 
+                available_device = device ? dataset.filter_criteria.device == device.identifier : true
+                available_percentile = percentile ? dataset.filter_criteria.percentile == percentile.identifier : true
+                available_device && available_percentile && !dataset.points.empty?
+            end.last
+            datasets
+        end
+
+        def get_section(section_name)
+            section = categories.map { |category| 
+                category.sections.find { |section| 
+                    section.display_name == section_name
+                }
+            }.flatten.compact.first
+            section
+        end
+                
+        private
+        def rows
+            categories.map do |category| 
+                [
+                    category.display_name, 
+                    category.sections.map{ |s| s.display_name }.join("\n"), 
+                    category.sections.map{ |s| s.unit.display_name }.join("\n")
+                ] 
+            end
+        end
+
+        def headings
+            ["category", "section", "unit"]
+        end
+    end
+end 
+
+
+module XcMetricsAggregator
+    class Category
+        attr_accessor :sections, :display_name, :identifier
+
+        def initialize(json)
+            @sections = json["sections"].map { |section| Section.new section }
+            @display_name = json["displayName"]
+            @identifier = json["identifier"]
+        end
+    end
+
+    class Section
+        attr_accessor :datasets, :display_name, :identifier, :unit
+
+        def initialize(json)
+            @datasets = json["datasets"].map { |d| DataSet.new d }
+            @unit = Unit.new json["unit"]
+            @display_name = json["displayName"]
+            @identifier = json["identifier"]
+        end
+    end
+
+    class Unit
+        attr_accessor :display_name, :identifier
+
+        def initialize(json)
+            @display_name = json["displayName"]
+            @identifier = json["identifier"]
+        end
+    end
+
+    class FilterCriteria
+        attr_accessor :device, :percentile
+
+        def initialize(json)
+            @device = json["device"]
+            @percentile = json["percentile"]
+        end
+
+        def self.new_from_prop(device, percentile)
+            self.new({"device": device.identifier, "percentile": percentile.identifier})
+        end
+
+        def ==(other)
+            device == other.device && percentile == other.percentile
+        end
+    end
+
+    class Point
+        attr_accessor :summary, :version, :percentage_breakdown
+
+        def initialize(json)
+            @summary = json["summary"]
+            @version = json["version"]
+            @percentage_breakdown = json["percentageBreakdown"]
+        end
+    end
+
+    class DataSet
+        attr_accessor :points, :filter_criteria
+
+        def initialize(json)
+            @points = json["points"].map { |p| Point.new p }
+            @filter_criteria = FilterCriteria.new json["filterCriteria"]
+        end
+    end
+end

data/lib/xc_metrics_aggregator/service/devices_service.rb

@@ -0,0 +1,85 @@
+require 'xc_metrics_aggregator/structure/structure'
+
+module XcMetricsAggregator
+    class Device
+        attr_accessor :is_represented, :display_name, :identifier
+
+        def initialize(json)
+            @is_represented = json["isRepresented"]
+            @display_name = json["displayName"]
+            @identifier = json["identifier"]
+        end
+    end
+
+    class DeviceFamily
+        attr_accessor :is_represented, :display_name, :identifier, :devices
+
+        def initialize(json)
+            @is_represented = json["isRepresented"]
+            @display_name = json["displayName"]
+            @identifier = json["identifier"]
+            @devices = json["devices"].map { |json| Device.new json }
+        end
+    end
+
+
+    class DevicesService
+        def initialize(bundle_id, json)
+            @json = json
+            @bundle_id = bundle_id
+        end
+        
+        def devicefamilies
+            device_families_json = @json["filterCriteriaSets"]["deviceFamilies"]
+            device_families_json.map do |device_family_json|
+                DeviceFamily.new device_family_json
+            end
+        end
+
+        def structure
+            structure = XcMetricsAggregator::TableStructure.new
+            structure.title = @bundle_id
+            structure.headings = headings()
+            structure.rows = rows()
+            structure
+        end
+
+        def get_device(identifier)
+            if identifier.nil?
+                nil
+            end
+            
+            device = devicefamilies.map do |devicefamily|
+                if devicefamily.identifier == identifier
+                    return devicefamily
+                end
+                
+                devicefamily.devices.select do |device|
+                    device.identifier == identifier
+                end
+            end.flatten.first
+
+            device
+        end
+
+        private
+        def rows
+            rows = []
+            devicefamilies.each_with_index do |devicefamily, idx| 
+                device_display_names = devicefamily.devices.map{ |d| d.display_name }.join("\n")
+                device_identifiers = devicefamily.devices.map{ |d| d.identifier }.join("\n")
+                row = [devicefamily.display_name, device_display_names, device_identifiers]
+                rows += if idx == devicefamilies.count - 1
+                    [row]
+                else
+                    [row] + [:separator]
+                end
+            end
+            return rows
+        end
+
+        def headings
+            ["kind", "device", "id"]
+        end
+    end
+end

data/lib/xc_metrics_aggregator/service/latest_service.rb

@@ -0,0 +1,91 @@
+require 'xc_metrics_aggregator/structure/structure'
+
+module XcMetricsAggregator
+    class LatestService
+        def initialize(section, deviceid, percentileid)
+            target_datasets = {}
+            unit_label = ""
+            each_product do |product|
+                product.try_to_open do |json| 
+                    device = get_device(product, json, deviceid)
+                    percentile = get_percentile(product, json, percentileid)
+
+                    if device && percentile
+                        dataset = get_dataset(product, json, section, device, percentile)
+                    else
+                        dataset = get_available_dataset(product, json, section, device, percentile)
+                    end
+
+                    unless dataset.nil? || dataset.points.empty?
+                      unit_label = get_unit_label(product, json, section)
+                      target_datasets[product.bundle_id] = dataset
+                    end
+                end
+            end
+            @unit_label = unit_label
+            @target_datasets = target_datasets
+        end
+
+        def structure
+            structure = XcMetricsAggregator::ChartStructure.new
+            structure.series = series
+            structure.samples = samples
+            structure.unit = @unit_label
+            return structure
+        end
+
+        private
+        def samples
+            @target_datasets.keys.each_with_index.reduce([]) do |sum, (bundle_id, idx)|
+              dataset = @target_datasets[bundle_id]
+              if dataset.points.empty?
+                sum
+              else
+                latest_point = dataset.points.last
+                sum + [[idx, latest_point.summary]]
+              end
+            end
+        end
+
+        def series
+          structure = XcMetricsAggregator::TableStructure.new
+          structure.headings = ["Label", "Bundle ID", "Version"]
+          structure.rows = @target_datasets.keys.each_with_index.map do |bundle_id, idx|
+            latest_point = @target_datasets[bundle_id].points.last
+            [idx, bundle_id, latest_point.version]
+          end
+          structure
+        end
+
+        private
+        def each_product
+            XcMetricsAggregator::ProductsService.new.each_product do |product|
+                yield product
+            end
+        end
+
+        def get_device(product, json, deviceid)
+            DevicesService.new(product.bundle_id, json).get_device deviceid
+        end
+
+        def get_percentile(product, json, percentileid)
+            PercentilesService.new(product.bundle_id, json).get_percentile percentileid
+        end
+
+        def get_category_service(product, json)
+            CategoriesService.new(product.bundle_id, json) 
+        end
+
+        def get_dataset(product, json, section, device, percentile)
+            get_category_service(product, json).get_dataset section, device, percentile
+        end
+
+        def get_available_dataset(product, json, section, device, percentile)
+            get_category_service(product, json).get_available_dataset section, device, percentile
+        end
+
+        def get_unit_label(product, json, section)
+            get_category_service(product, json).get_section(section).unit.display_name
+        end
+    end
+end

data/lib/xc_metrics_aggregator/service/metrics_service.rb

@@ -0,0 +1,51 @@
+require 'xc_metrics_aggregator/service/categories_service'
+require 'xc_metrics_aggregator/structure/structure'
+
+module XcMetricsAggregator
+    class MetricsService
+        def initialize(bundle_id, json)
+            @bundle_id = bundle_id
+            @category_service = CategoriesService.new bundle_id, json
+        end
+
+        def structures(section_name, device_id, percentile_id, version)
+            rows = []
+            samples = [] 
+            index = 0
+            datasets(section_name).each do |dataset|
+                device_identifier =  dataset.filter_criteria.device
+                validated_device = !device_id || device_identifier == device_id
+                percentile_identifier =  dataset.filter_criteria.percentile
+                validated_percentile = !percentile_id || percentile_identifier == percentile_id
+
+                unless validated_device && validated_percentile
+                    next
+                end
+                percentile = @category_service.percentile_service.get_percentile dataset.filter_criteria.percentile
+                device = @category_service.device_service.get_device dataset.filter_criteria.device
+                rows += dataset.points.map.with_index(index) { |p, i| [i, p.version, device.display_name, percentile.display_name] }
+                samples += dataset.points.map.with_index(index) { |p, i| [i, p.summary] }
+                index += dataset.points.count
+            end
+
+            table_structure = XcMetricsAggregator::TableStructure.new
+            table_structure.headings = ["Label", "Version", "Device", "Percentile"]
+            table_structure.title = section_name
+            table_structure.rows = rows
+            structure = XcMetricsAggregator::ChartStructure.new
+            structure.series = table_structure
+            structure.unit = @category_service.get_section(section_name).unit.display_name
+            structure.samples = samples
+
+            structure
+        end
+
+        def datasets(section_name)
+            section = @category_service.get_section(section_name)
+            unless section
+                raise StandardError.new("wrong section name")
+            end
+            section.datasets
+        end
+    end
+end

data/lib/xc_metrics_aggregator/service/percentiles_service.rb

@@ -0,0 +1,52 @@
+require 'xc_metrics_aggregator/structure/structure'
+
+module XcMetricsAggregator
+    class Percentile
+        attr_accessor :display_name, :is_represented, :identifier
+        
+        def initialize(json)
+            @is_represented = json["isRepresented"]
+            @display_name = json["displayName"]
+            @identifier = json["identifier"]
+        end
+    end
+
+    class PercentilesService
+        def initialize(bundle_id, json)
+            @json = json
+            @bundle_id = bundle_id
+        end
+        
+        def percentiles
+            percentiles_json = @json["filterCriteriaSets"]["percentiles"]
+            percentiles_json.map { |percentile_json| Percentile.new percentile_json }
+        end
+        
+        def structure
+            structure = XcMetricsAggregator::TableStructure.new
+            structure.title = @bundle_id
+            structure.headings = headings()
+            structure.rows = rows()
+            structure
+        end
+        
+        def rows
+            percentiles.map { |percentile| [percentile.display_name, percentile.identifier] }
+        end
+
+        def headings
+            ["percentile", "id"]
+        end
+
+        def get_percentile(identifier)
+            if identifier.nil?
+                nil
+            end
+
+
+            res = percentiles.find do |percentile| 
+                percentile.identifier == identifier
+            end
+        end
+    end
+end

data/lib/xc_metrics_aggregator/structure/structure.rb

@@ -0,0 +1,17 @@
+require 'xc_metrics_aggregator/formatter/formatter'
+
+module XcMetricsAggregator
+    class Structure
+        def format(formatter)
+            formatter.format(self)
+        end
+    end
+
+    class TableStructure < Structure
+        attr_accessor :title, :headings, :rows
+    end
+
+    class ChartStructure < Structure
+        attr_accessor :series, :samples, :unit, :dscription
+    end
+end

data/lib/xc_metrics_aggregator/version.rb

@@ -0,0 +1,3 @@
+module XcMetricsAggregator
+  VERSION = "0.1.0"
+end

data/lib/xc_metrics_aggregator.rb

@@ -0,0 +1,125 @@
+require "xc_metrics_aggregator/version"
+require 'xc_metrics_aggregator/product'
+require 'xc_metrics_aggregator/crawler'
+require 'xc_metrics_aggregator/service/devices_service'
+require 'xc_metrics_aggregator/service/percentiles_service'
+require 'xc_metrics_aggregator/service/categories_service'
+require 'xc_metrics_aggregator/service/metrics_service'
+require 'xc_metrics_aggregator/service/latest_service'
+require 'xc_metrics_aggregator/formatter/formatter'
+require 'xc_metrics_aggregator/formatter/output_format'
+require 'thor'
+require 'ascii_charts'
+require 'pp'
+
+module XcMetricsAggregator
+
+  class Error < StandardError; end
+  class CLI < Thor
+
+    desc "crowl", "Aggregate raw data of Xcode Organizer Metrics"
+    def crowl
+      Crawler.execute()
+    end
+
+    desc "apps", "Shows available bundle ids on Xcode Organizer Metrics"
+    option :available_path, type: :boolean, aliases: "-a", default: false
+    option :format, aliases: "-f", type: :string, default: "ascii"
+    def apps
+      service = ProductsService.new 
+      puts service.structure(options[:available_path]).format Formatter.get_formatter(format)
+    end
+
+    option :bundle_ids, :aliases => "-b", type: :array, default: []
+    option :format, :aliases => "-f", type: :string, default: "ascii"
+    desc "devices [-b <bundle id 1> <bundle id 2> ...] [-f <format>]", "Show available devices by builde id"
+    def devices
+      each_product do |product|
+        product.try_to_open do |json| 
+          puts DevicesService
+            .new(product.bundle_id, json)
+            .structure
+            .format Formatter.get_formatter(format)
+          puts "\n\n"
+        end
+      end
+    end
+
+    option :bundle_ids, :aliases => "-b", type: :array, default: []
+    option :format, :aliases => "-f", type: :string, default: "ascii"
+    desc "percentiles [-b <bundle id>,...] [-f <format>]", "Show available percentiles by builde id"
+    def percentiles
+      each_product do |product|
+        product.try_to_open do |json| 
+          puts PercentilesService
+            .new(product.bundle_id, json)
+            .structure
+            .format Formatter.get_formatter(format)
+          puts "\n\n"
+        end
+      end
+    end
+
+    
+    option :bundle_id, :aliases => "-b", require: true
+    option :format, :aliases => "-f", type: :string, default: "ascii"
+    desc "categories -b <bundle id> [-f <format>]", "Show available categories by builde id"
+    def sections
+      product.try_to_open do |json|
+        puts CategoriesService
+          .new(product.bundle_id, json)
+          .structure
+          .format Formatter.get_formatter(format)
+      end
+    end
+    
+    option :section, :aliases => "-s", require: true
+    option :bundle_id, :aliases => "-b", require: true
+    option :format, :aliases => "-f", type: :string, default: "ascii"
+    option :version, :aliases => "-v", require: false
+    option :device, :aliases => "-d", require: false
+    option :percentile, :aliases => "-p", require: false
+    desc "metrics -b <bundle id> -s <section> [-f <format>] [-d <device id>] [-p <percentile id>] [-v <version>]", "Show metrics data to a builde id"
+    def metrics
+      product.try_to_open do |json| 
+        structure = MetricsService
+          .new(product.bundle_id, json)
+          .structures(options[:section], options[:device], options[:percentile], options[:version])
+        
+        puts structure.format Formatter.get_formatter(format)
+        puts "\n\n"
+      end
+    end
+
+    option :section, :aliases => "-s", require: true
+    option :device, :aliases => "-d", type: :string
+    option :percentile, :aliases => "-p", type: :string
+    option :format, :aliases => "-f", type: :string, default: "ascii"
+    desc "latest -s <section> [-p <percentile id>] [-d <device id>] [-f <format>]", "Compare a latest version's metrics between available builde ids"
+    def latest
+      deviceid = options[:device]
+      percentileid = options[:percentile]
+      section = options[:section]
+
+      puts LatestService
+        .new(section, deviceid, percentileid)
+        .structure
+        .format Formatter.get_formatter(format)
+    end
+
+    private 
+    def format
+      OutputFormat.all.find { |v| v == options[:format] }
+    end
+
+    def each_product
+      ProductsService.new.each_product(options[:bundle_ids]) { |product|
+        yield product
+      }
+    end
+
+    def product
+      ProductsService.new.target options[:bundle_id]
+    end
+  end
+end