danger-apkstats 0.0.2 → 0.1.0

data/lib/apkstats/command/executable.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Apkstats::Command
+  module Executable
+    require "open3"
+
+    attr_reader :command_path
+
+    def executable?
+      File.executable?(command_path)
+    end
+
+    # Compare two apk files and return results.
+    #
+    # {
+    #   base: {
+    #     file_size: Integer,
+    #     download_size: Integer,
+    #     required_features: Array<String>,
+    #     non_required_features: Array<String>,
+    #     permissions: Array<String>,
+    #     min_sdk: String,
+    #     target_sdk: String,
+    #   },
+    #   other: {
+    #     file_size: Integer,
+    #     download_size: Integer,
+    #     required_features: Array<String>,
+    #     non_required_features: Array<String>,
+    #     permissions: Array<String>,
+    #     min_sdk: String,
+    #     target_sdk: String,
+    #   },
+    #   diff: {
+    #     file_size: Integer,
+    #     download_size: Integer,
+    #     required_features: {
+    #       new: Array<String>,
+    #       removed: Array<String>,
+    #     },
+    #     non_required_features:{
+    #       new: Array<String>,
+    #       removed: Array<String>,
+    #     },
+    #     permissions: {
+    #       new: Array<String>,
+    #       removed: Array<String>,
+    #     },
+    #     min_sdk: Array<String>,
+    #     target_sdk: Array<String>,
+    #   }
+    # }
+    #
+    # @return [Hash]
+    def compare_with(apk_filepath, other_apk_filepath)
+      base = Apkstats::Entity::ApkInfo.new(self, apk_filepath)
+      other = Apkstats::Entity::ApkInfo.new(self, other_apk_filepath)
+
+      Apkstats::Entity::ApkInfoDiff.new(base, other).to_h
+    end
+  end
+end

data/lib/apkstats/entity/apk_info.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Apkstats::Entity
+  class ApkInfo
+    KEYS = %i(
+      file_size
+      download_size
+      required_features
+      non_required_features
+      permissions
+      min_sdk
+      target_sdk
+    ).freeze
+
+    # Integer
+    attr_accessor :file_size, :download_size
+
+    # String
+    attr_accessor :min_sdk, :target_sdk
+
+    # Array<String>
+    attr_accessor :required_features, :non_required_features, :permissions
+
+    def initialize(command, apk_filepath)
+      KEYS.each do |key|
+        self.send("#{key}=", command.send(key, apk_filepath))
+      end
+    end
+
+    def [](key)
+      send(key)
+    end
+
+    def to_h
+      KEYS.each_with_object({}) do |key, acc|
+        acc[key] = self[key]
+      end
+    end
+  end
+end

data/lib/apkstats/entity/apk_info_diff.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Apkstats::Entity
+  class ApkInfoDiff
+    KEYS = Apkstats::Entity::ApkInfo::KEYS
+
+    # ApkInfo
+    attr_reader :base, :other
+
+    private(:base, :other)
+
+    def initialize(base, other)
+      @base = base
+      @other = other
+    end
+
+    def to_h
+      KEYS.each_with_object({}) do |key, acc|
+        acc[key] = self.send(key)
+      end.compact
+    end
+
+    def file_size
+      # Integer
+      @base[__method__].to_i - @other[__method__].to_i
+    end
+
+    def download_size
+      # Integer
+      @base[__method__].to_i - @other[__method__].to_i
+    end
+
+    def required_features
+      # Features
+      {
+          new: (@base[__method__] - @other[__method__]).to_a,
+          removed: (@other[__method__] - @base[__method__]).to_a,
+      }
+    end
+
+    def non_required_features
+      # Features
+      {
+          new: (@base[__method__] - @other[__method__]).to_a,
+          removed: (@other[__method__] - @base[__method__]).to_a,
+      }
+    end
+
+    def permissions
+      # Permissions
+      {
+          new: (@base[__method__] - @other[__method__]).to_a,
+          removed: (@other[__method__] - @base[__method__]).to_a,
+      }
+    end
+
+    def min_sdk
+      # String
+      [@base[__method__], @other[__method__]].uniq
+    end
+
+    def target_sdk
+      # String
+      [@base[__method__], @other[__method__]].uniq
+    end
+  end
+end

data/lib/apkstats/entity/feature.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Apkstats::Entity
+  class Feature
+    # String
+    attr_reader :name
+
+    # String?
+    attr_reader :implied_reason
+
+    def initialize(name, not_required: false, implied_reason: nil)
+      @name = name
+      # cast to Boolean
+      @not_required = not_required == true
+      @implied_reason = implied_reason || nil
+    end
+
+    def not_required?
+      @not_required
+    end
+
+    def implied?
+      @implied_reason
+    end
+
+    def to_s
+      if implied?
+        "#{name} (#{implied_reason})"
+      elsif not_required?
+        "#{name} (not-required)"
+      else
+        name
+      end
+    end
+
+    def ==(other)
+      return if !other || other.class != self.class
+
+      to_s == other.to_s
+    end
+
+    def eql?(other)
+      to_s.eql?(other.to_s)
+    end
+
+    def hash
+      h = not_required? ? 1 : 0
+      h *= 31
+      h += name.hash
+
+      if implied_reason
+        h *= 31
+        h += implied_reason.hash
+      end
+
+      h
+    end
+  end
+
+  class Features
+    attr_reader :values
+
+    # Array<Feature>
+    def initialize(feature_arr)
+      @values = feature_arr
+    end
+
+    def -(other)
+      raise "#{self.class} cannot handle #{other.class} with the minus operator" unless other.class == Features
+
+      self_hash = Features.hashnize(self)
+      other_hash = Features.hashnize(other)
+
+      diff_features = (self_hash.keys - other_hash.keys).map do |key|
+        self_hash[key]
+      end
+
+      Features.new(diff_features)
+    end
+
+    def to_a
+      values.map(&:to_s)
+    end
+
+    def eql?(other)
+      return if !other || other.class == Features
+      other.values == values
+    end
+
+    def hash
+      values.hash
+    end
+
+    def self.hashnize(features)
+      features.values.each_with_object({}) do |feature, acc|
+        acc[[feature.name, feature.not_required?]] = feature
+      end
+    end
+  end
+end

data/lib/apkstats/entity/permission.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Apkstats::Entity
+  class Permission
+    # String
+    attr_reader :name
+
+    # String?
+    attr_reader :max_sdk
+
+    def initialize(name, max_sdk: nil)
+      @name = name
+      @max_sdk = max_sdk
+    end
+
+    def to_s
+      if max_sdk
+        "#{name} maxSdkVersion=#{max_sdk}"
+      else
+        name
+      end
+    end
+
+    def ==(other)
+      return if !other || other.class != self.class
+
+      to_s == other.to_s
+    end
+
+    def eql?(other)
+      to_s.eql?(other.to_s)
+    end
+
+    def hash
+      h = name.hash
+
+      if max_sdk
+        h *= 31
+        h += max_sdk.hash
+      end
+
+      h
+    end
+  end
+
+  class Permissions
+    attr_reader :values
+
+    # Array<Permission>
+    def initialize(permission_arr)
+      @values = permission_arr
+    end
+
+    def -(other)
+      raise "#{self.class} cannot handle #{other.class} with the minus operator" unless other.class == Permissions
+
+      self_hash = Permissions.hashnize(self)
+      other_hash = Permissions.hashnize(other)
+
+      diff_permissions = (self_hash.keys - other_hash.keys).map do |key|
+        self_hash[key]
+      end
+
+      Permissions.new(diff_permissions)
+    end
+
+    def to_a
+      values.map(&:to_s)
+    end
+
+    def eql?(other)
+      return if !other || other.class == Permissions
+      other.values == values
+    end
+
+    def hash
+      values.hash
+    end
+
+    def self.hashnize(permissions)
+      permissions.values.each_with_object({}) do |permission, acc|
+        acc[[permission.name, permission.max_sdk]] = permission
+      end
+    end
+  end
+end

data/lib/apkstats/gem_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Apkstats
-  VERSION = "0.0.2".freeze
+  VERSION = "0.1.0"
 end

data/lib/apkstats/helper/bytes.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Apkstats::Helper
+  module Bytes
+    STEP = 2**10.to_f
+
+    def self.from_b(byte)
+      Byte.new(byte)
+    end
+
+    def self.from_kb(k_byte)
+      Byte.new(down_unit(k_byte))
+    end
+
+    def self.from_mb(m_byte)
+      Byte.new(down_unit(down_unit(m_byte)))
+    end
+
+    def self.up_unit(size)
+      (size.to_f / STEP).round(2)
+    end
+
+    def self.down_unit(size)
+      size.to_f * STEP
+    end
+
+    class Byte
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def to_b
+        value
+      end
+
+      def to_kb
+        Bytes.up_unit(value)
+      end
+
+      def to_mb
+        Bytes.up_unit(to_kb)
+      end
+
+      def to_s_b
+        add_op(to_b)
+      end
+
+      def to_s_kb
+        add_op(to_kb)
+      end
+
+      def to_s_mb
+        add_op(to_mb)
+      end
+
+      private
+
+      def add_op(size)
+        size.negative? ? size.to_s : "+#{size}"
+      end
+    end
+  end
+end

data/lib/apkstats/plugin.rb

@@ -1,80 +1,241 @@
+# frozen_string_literal: true
+
+require_relative "helper/bytes"
+
+require_relative "entity/apk_info"
+require_relative "entity/apk_info_diff"
+require_relative "entity/feature"
+require_relative "entity/permission"
+
+require_relative "command/executable"
+require_relative "command/apk_analyzer"
+
 module Danger
-  # This is your plugin class. Any attributes or methods you expose here will
-  # be available from within your Dangerfile.
+  # Show stats of your apk file.
+  # By default, it's done using apkanalyzer in android sdk.
+  #
+  # All command need your apk filepath like below
+  #
+  #         apkstats.apk_filepath=<your new apk filepath>
+  #
+  # @example Compare two apk files and print it.
+  #
+  #         apkstats.compare_with(<your old apk filepath>, do_report: true) # report it in markdown table
+  #         apkstats.compare_with(<your old apk filepath>, do_report: false) # just return results
+  #
+  # @example Show the file size of your apk file.
+  #
+  #         apkstats.file_size
+  #
+  # @example Show the download size of your apk file.
+  #
+  #         apkstats.download_size
+  #
+  # @example Show all required features of your apk file.
+  #
+  #         apkstats.required_features
+  #
+  # @example Show all non-required features of your apk file.
+  #
+  #         apkstats.non_required_features
   #
-  # To be published on the Danger plugins site, you will need to have
-  # the public interface documented. Danger uses [YARD](http://yardoc.org/)
-  # for generating documentation from your plugin source, and you can verify
-  # by running `danger plugins lint` or `bundle exec rake spec`.
+  # @example Show all requested permissions of your apk file.
   #
-  # You should replace these comments with a public description of your library.
+  #         apkstats.permissions
   #
-  # @example Ensure people are well warned about merging on Mondays
+  # @example Show the min sdk version of your apk file.
   #
-  #          my_plugin.warn_on_mondays
+  #         apkstats.min_sdk
+  #
+  # @example Show the target sdk version of your apk file.
+  #
+  #         apkstats.target_sdk
   #
   # @see  Jumpei Matsuda/danger-apkstats
   # @tags android, apk_stats
   #
   class DangerApkstats < Plugin
-    require_relative 'command/executable_command'
-    require_relative 'command/apk_analyzer'
-
     COMMAND_TYPE_MAP = {
-      apk_analyzer: Danger::Apkstats::ApkAnalyzer,
+      apk_analyzer: Apkstats::Command::ApkAnalyzer,
     }.freeze
 
     private_constant(:COMMAND_TYPE_MAP)
 
-    # A command type to be run
+    # *Optional*
+    # A command type to be run.
+    # One of keys of COMMAND_TYPE_MAP
     #
-    # @return [Symbol, String] either of array( apk_analyzer )
+    # @return [Symbol, Nil] _
     attr_accessor :command_type
 
-    # An apk file to be operated
+    # *Optional*
+    # A custom command path
+    #
+    # @return [Symbol, Nil] _
+    attr_accessor :command_path
+
+    # *Required*
+    # Your target apk filepath.
     #
     # @return [String]
     attr_accessor :apk_filepath
 
-    # TODO multiple apks
+    # rubocop:disable Metrics/AbcSize
+
+    # Get stats of two apk files and calculate diffs between them.
+    #
+    # @param [String] other_apk_filepath your old apk
+    # @param [Boolean] do_report report markdown table if true, otherwise just return results
+    # @return [Hash] see command/executable#compare_with for more detail
+    def compare_with(other_apk_filepath, do_report: true)
+      raise "apk filepaths must be specified" if apk_filepath.nil? || apk_filepath.empty?
+
+      base_apk = Apkstats::Entity::ApkInfo.new(command, apk_filepath)
+      other_apk = Apkstats::Entity::ApkInfo.new(command, other_apk_filepath)
+
+      return {
+          base: base_apk.to_h,
+          other: base_apk.to_h,
+          diff: Apkstats::Entity::ApkInfoDiff.new(base_apk, other_apk).to_h,
+      }.tap do |result|
+        break unless do_report
+
+        diff = result[:diff]
+
+        md = +"### Apk comparision results" << "\n\n"
+        md << "Property | Summary" << "\n"
+        md << ":--- | :---" << "\n"
+
+        diff[:min_sdk].tap do |min_sdk|
+          break if min_sdk.size == 1
+
+          md << "Min SDK Change | Before #{min_sdk[1]} / After #{min_sdk[0]}" << "\n"
+        end
+
+        diff[:target_sdk].tap do |target_sdk|
+          break if target_sdk.size == 1
+
+          md << "Target SDK Change | Before #{target_sdk[1]} / After #{target_sdk[0]}" << "\n"
+        end
+
+        result[:base][:file_size].tap do |file_size|
+          size = Apkstats::Helper::Bytes.from_b(file_size)
+
+          md << "New File Size | #{size.to_b} Bytes. (#{size.to_mb} MB " << "\n"
+        end
 
-    def compare_with(other_apk_filepath, opts={})
-      raise 'apks must be specified' if apk_filepath.nil? || apk_filepath.empty?
+        diff[:file_size].tap do |file_size|
+          size = Apkstats::Helper::Bytes.from_b(file_size)
 
-      out, err = command.compare_with(apk_filepath, other_apk_filepath)
+          md << "File Size Change | #{size.to_s_b} Bytes. (#{size.to_s_kb} KB) " << "\n"
+        end
+
+        diff[:download_size].tap do |download_size|
+          size = Apkstats::Helper::Bytes.from_b(download_size)
 
-      if opts[:do_report]
-        if out&.empty?
-          message("Apk file size was not changed")
-        elsif out
-          left, right, diff, = out.split("\s")
-          message("Apk file size was changed by #{diff} : from #{left} to #{right}")
-        else
-          warn(err)
+          md << "Download Size Change | #{size.to_s_b} Bytes. (#{size.to_s_kb} KB) " << "\n"
         end
+
+        report_hash_and_arrays = lambda { |key, name|
+          list_up_entities = lambda { |type_key, label|
+            diff[key][type_key].tap do |features|
+              break if features.empty?
+
+              md << "#{label} | " << features.map { |f| "- #{f}" }.join("<br>").to_s << "\n"
+            end
+          }
+
+          list_up_entities.call(:new, "New #{name}")
+          list_up_entities.call(:removed, "Removed #{name}")
+        }
+
+        report_hash_and_arrays.call(:required_features, "Required Features")
+        report_hash_and_arrays.call(:non_required_features, "Non-required Features")
+        report_hash_and_arrays.call(:permissions, "Permissions")
+
+        markdown(md)
       end
+    rescue StandardError => e
+      warn("apkstats failed to execute the command due to #{e.message}")
+
+      e.backtrace&.each { |line| STDOUT.puts line }
+    end
+
+    # rubocop:enable Metrics/AbcSize
+
+    # Show the file size of your apk file.
+    #
+    # @return [Fixnum] return positive value if exists, otherwise -1.
+    def file_size(_opts = {})
+      result = run_command(__method__)
+      result ? result.to_i : -1
+    end
+
+    # Show the download size of your apk file.
+    #
+    # @return [Fixnum] return positive value if exists, otherwise -1.
+    def download_size(_opts = {})
+      result = run_command(__method__)
+      result ? result.to_i : -1
+    end
 
-      return out, err
+    # Show all required features of your apk file.
+    # The result doesn't contain non-required features.
+    #
+    # @return [Array<String>, Nil] return nil unless retrieved.
+    def required_features(_opts = {})
+      result = run_command(__method__)
+      result ? result.to_a : nil
     end
 
-    def filesize(opts={})
-      raise 'apks must be specified' if apk_filepath.nil? || apk_filepath.empty?
+    # Show all non-required features of your apk file.
+    # The result doesn't contain required features.
+    #
+    # @return [Array<String>, Nil] return nil unless retrieved.
+    def non_required_features(_opts = {})
+      result = run_command(__method__)
+      result ? result.to_a : nil
+    end
 
-      out, = command.filesize(apk_filepath)
-      out
+    # Show all permissions of your apk file.
+    #
+    # @return [Array<String>, Nil] return nil unless retrieved.
+    def permissions(_opts = {})
+      result = run_command(__method__)
+      result ? result.to_a : nil
     end
 
-    def downloadsize(opts={})
-      raise 'apks must be specified' if apk_filepath.nil? || apk_filepath.empty?
+    # Show the min sdk version of your apk file.
+    #
+    # @return [String, Nil] return nil unless retrieved.
+    def min_sdk(_opts = {})
+      run_command(__method__)
+    end
 
-      out, = command.downloadsize(apk_filepath)
-      out
+    # Show the target sdk version of your apk file.
+    #
+    # @return [String, Nil] return nil unless retrieved.
+    def target_sdk(_opts = {})
+      run_command(__method__)
     end
 
     private
 
+    def run_command(name)
+      raise "#{command.command_path} is not found or is not executable" unless command.executable?
+
+      return command.send(name, apk_filepath)
+    rescue StandardError => e
+      warn("apkstats failed to execute the command #{name} due to #{e.message}")
+
+      e.backtrace&.each { |line| puts line }
+
+      nil
+    end
+
     def command
-      @command ||= COMMAND_TYPE_MAP[command_type.to_sym].new
+      command_type ||= :apk_analyzer
+      @command ||= COMMAND_TYPE_MAP[command_type.to_sym].new(command_path: command_path)
     end
   end
 end