app-info 2.2.0

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
+require 'app_info'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/app_info.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'app_info/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'app-info'
+  spec.version       = AppInfo::VERSION
+  spec.authors       = ['icyleaf']
+  spec.email         = ['icyleaf.cn@gmail.com']
+
+  spec.summary       = 'Teardown tool for mobile app(ipa/apk) and dSYM file, analysis metedata like version, name, icon'
+  spec.description   = 'Teardown tool for ipa/apk files and dSYM file, even support for info.plist and .mobileprovision files'
+  spec.homepage      = 'http://github.com/icyleaf/app-info'
+  spec.license       = 'MIT'
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.3'
+
+  spec.add_dependency 'CFPropertyList', ['< 3.1.0', '>= 2.3.4']
+  spec.add_dependency 'image_size', '>= 1.5', '< 2.1'
+  spec.add_dependency 'pngdefry', '~> 0.1.2'
+  spec.add_dependency 'ruby-macho', '~> 2.2.0'
+  spec.add_dependency 'ruby_android', '~> 0.7.7'
+  spec.add_dependency 'rubyzip', '>= 1.2', '< 3.0'
+  spec.add_dependency 'uuidtools', '>= 2.1.5', '< 2.3.0'
+
+  spec.add_development_dependency 'bundler', '>= 1.12'
+  spec.add_development_dependency 'rake', '>= 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/app-info.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require File.dirname(__FILE__) + '/app_info'

data/lib/app_info.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'app_info/core_ext/object/try'
+require 'app_info/version'
+require 'app_info/ipa'
+require 'app_info/ipa/info_plist'
+require 'app_info/ipa/mobile_provision'
+require 'app_info/apk'
+require 'app_info/dsym'
+require 'app_info/proguard'
+
+# AppInfo Module
+module AppInfo
+  class Error < StandardError; end
+  class NotFoundError < Error; end
+  class UnkownFileTypeError < Error; end
+
+  # App Platform
+  module Platform
+    IOS = 'iOS'
+    ANDROID = 'Android'
+    DSYM = 'dSYM'
+    PROGUARD = 'Proguard'
+  end
+
+  # Get a new parser for automatic
+  def self.parse(file)
+    raise NotFoundError, file unless File.exist?(file)
+
+    case file_type(file)
+    when :ipa then IPA.new(file)
+    when :apk then APK.new(file)
+    when :mobileprovision then MobileProvision.new(file)
+    when :dsym then DSYM.new(file)
+    when :proguard then Proguard.new(file)
+    else
+      raise UnkownFileTypeError, "Sorry, AppInfo can not detect file type: #{file}"
+    end
+  end
+  singleton_class.send(:alias_method, :dump, :parse)
+
+  # Detect file type by read file header
+  #
+  # TODO: This can be better way to solvt, if anyone knows, tell me please.
+  def self.file_type(file)
+    header_hex = IO.read(file, 100)
+    type = if header_hex =~ /^\x50\x4b\x03\x04/
+             detect_zip_file(file)
+           else
+             detect_mobileprovision(header_hex)
+           end
+
+    type || :unkown
+  end
+
+  # :nodoc:
+  def self.detect_zip_file(file)
+    Zip.warn_invalid_date = false
+    zip_file = Zip::File.open(file)
+
+    return :proguard unless zip_file.glob('*mapping*.txt').empty?
+    return :apk unless zip_file.find_entry('AndroidManifest.xml').nil? &&
+                       zip_file.find_entry('classes.dex').nil?
+
+    zip_file.each do |f|
+      path = f.name
+
+      return :ipa if path.include?('Payload/') && path.end_with?('Info.plist')
+      return :dsym if path.include?('Contents/Resources/DWARF/')
+    end
+  end
+  private_class_method :detect_zip_file
+
+  # :nodoc:
+  def self.detect_mobileprovision(hex)
+    if hex =~ /^\x3C\x3F\x78\x6D\x6C/
+      # plist
+      :mobileprovision
+    elsif hex =~ /^\x62\x70\x6C\x69\x73\x74/
+      # bplist
+      :mobileprovision
+    elsif hex =~ /\x3C\x3F\x78\x6D\x6C/
+      # signed plist
+      :mobileprovision
+    end
+  end
+  private_class_method :detect_mobileprovision
+end

data/lib/app_info/apk.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'ruby_apk'
+require 'image_size'
+require 'forwardable'
+require 'app_info/util'
+
+module AppInfo
+  # Parse APK file
+  class APK
+    extend Forwardable
+
+    attr_reader :file, :apk
+
+    # APK Devices
+    module Device
+      PHONE   = 'Phone'
+      TABLET  = 'Tablet'
+      WATCH   = 'Watch'
+      TV      = 'Television'
+    end
+
+    def initialize(file)
+      @file = file
+
+      Zip.warn_invalid_date = false # fix invaild date format warnings
+      @apk = ::Android::Apk.new(file)
+    end
+
+    def size(humanable = false)
+      AppInfo::Util.file_size(@file, humanable)
+    end
+
+    def os
+      AppInfo::Platform::ANDROID
+    end
+    alias file_type os
+
+    def_delegators :@apk, :manifest, :resource, :dex
+
+    def_delegators :manifest, :version_name, :package_name,
+                   :use_permissions, :components
+
+    alias release_version version_name
+    alias identifier package_name
+    alias bundle_id package_name
+
+    def version_code
+      manifest.version_code.to_s
+    end
+    alias build_version version_code
+
+    def name
+      resource.find('@string/app_name')
+    end
+
+    def device_type
+      if wear?
+        Device::WATCH
+      elsif tv?
+        Device::TV
+      else
+        Device::PHONE
+      end
+    end
+
+    # TODO: find a way to detect
+    # def tablet?
+    #   resource
+    # end
+
+    def wear?
+      use_features.include?('android.hardware.type.watch')
+    end
+
+    def tv?
+      use_features.include?('android.software.leanback')
+    end
+
+    def min_sdk_version
+      manifest.min_sdk_ver
+    end
+
+    def target_sdk_version
+      manifest.doc
+              .elements['/manifest/uses-sdk']
+              .attributes['targetSdkVersion']
+              .to_i
+    end
+
+    def use_features
+      manifest_values('/manifest/uses-feature')
+    end
+
+    def signs
+      @apk.signs.each_with_object([]) do |(path, sign), obj|
+        obj << Sign.new(path, sign)
+      end
+    end
+
+    def certificates
+      @apk.certificates.each_with_object([]) do |(path, certificate), obj|
+        obj << Certificate.new(path, certificate)
+      end
+    end
+
+    def activities
+      components.select { |c| c.type == 'activity' }
+    end
+
+    def services
+      components.select { |c| c.type == 'service' }
+    end
+
+    def icons
+      unless @icons
+        tmp_path = File.join(Dir.mktmpdir, "AppInfo-android-#{SecureRandom.hex}")
+
+        @icons = @apk.icon.each_with_object([]) do |(path, data), obj|
+          icon_name = File.basename(path)
+          icon_path = File.join(tmp_path, File.dirname(path))
+          icon_file = File.join(icon_path, icon_name)
+          FileUtils.mkdir_p icon_path
+          File.open(icon_file, 'wb') { |f| f.write(data) }
+
+          obj << {
+            name: icon_name,
+            file: icon_file,
+            dimensions: ImageSize.path(icon_file).size
+          }
+        end
+      end
+
+      @icons
+    end
+
+    private
+
+    def manifest_values(path, key = 'name')
+      values = []
+      manifest.doc.each_element(path) do |elem|
+        values << elem.attributes[key]
+      end
+      values.uniq
+    end
+
+    # Android Certificate
+    class Certificate
+      attr_reader :path, :certificate
+      def initialize(path, certificate)
+        @path = path
+        @certificate = certificate
+      end
+    end
+
+    # Android Sign
+    class Sign
+      attr_reader :path, :sign
+      def initialize(path, sign)
+        @path = path
+        @sign = sign
+      end
+    end
+  end
+end

data/lib/app_info/core_ext/object/try.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# Copyrights rails
+# Copy from https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/object/try.rb
+
+module AppInfo
+  module Tryable #:nodoc:
+    def try(method_name = nil, *args, &block)
+      if method_name.nil? && block_given?
+        if block.arity.zero?
+          instance_eval(&b)
+        else
+          yield self
+        end
+      elsif respond_to?(method_name)
+        public_send(method_name, *args, &block)
+      end
+    end
+
+    def try!(method_name = nil, *args, &block)
+      if method_name.nil? && block_given?
+        if block.arity.zero?
+          instance_eval(&block)
+        else
+          yield self
+        end
+      else
+        public_send(method_name, *args, &block)
+      end
+    end
+  end
+end
+
+class Object
+  include AppInfo::Tryable
+
+  ##
+  # :method: try
+  #
+  # :call-seq:
+  #   try(*a, &b)
+  #
+  # Invokes the public method whose name goes as first argument just like
+  # +public_send+ does, except that if the receiver does not respond to it the
+  # call returns +nil+ rather than raising an exception.
+  #
+  # This method is defined to be able to write
+  #
+  #   @person.try(:name)
+  #
+  # instead of
+  #
+  #   @person.name if @person
+  #
+  # +try+ calls can be chained:
+  #
+  #   @person.try(:spouse).try(:name)
+  #
+  # instead of
+  #
+  #   @person.spouse.name if @person && @person.spouse
+  #
+  # +try+ will also return +nil+ if the receiver does not respond to the method:
+  #
+  #   @person.try(:non_existing_method) # => nil
+  #
+  # instead of
+  #
+  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) # => nil
+  #
+  # +try+ returns +nil+ when called on +nil+ regardless of whether it responds
+  # to the method:
+  #
+  #   nil.try(:to_i) # => nil, rather than 0
+  #
+  # Arguments and blocks are forwarded to the method if invoked:
+  #
+  #   @posts.try(:each_slice, 2) do |a, b|
+  #     ...
+  #   end
+  #
+  # The number of arguments in the signature must match. If the object responds
+  # to the method the call is attempted and +ArgumentError+ is still raised
+  # in case of argument mismatch.
+  #
+  # If +try+ is called without arguments it yields the receiver to a given
+  # block unless it is +nil+:
+  #
+  #   @person.try do |p|
+  #     ...
+  #   end
+  #
+  # You can also call try with a block without accepting an argument, and the block
+  # will be instance_eval'ed instead:
+  #
+  #   @person.try { upcase.truncate(50) }
+  #
+  # Please also note that +try+ is defined on +Object+. Therefore, it won't work
+  # with instances of classes that do not have +Object+ among their ancestors,
+  # like direct subclasses of +BasicObject+.
+
+  ##
+  # :method: try!
+  #
+  # :call-seq:
+  #   try!(*a, &b)
+  #
+  # Same as #try, but raises a +NoMethodError+ exception if the receiver is
+  # not +nil+ and does not implement the tried method.
+  #
+  #   "a".try!(:upcase) # => "A"
+  #   nil.try!(:upcase) # => nil
+  #   123.try!(:upcase) # => NoMethodError: undefined method `upcase' for 123:Integer
+end

data/lib/app_info/dsym.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'macho'
+require 'app_info/util'
+
+module AppInfo
+  # DSYM parser
+  class DSYM
+    attr_reader :file
+
+    def initialize(file)
+      @file = file
+    end
+
+    def file_type
+      AppInfo::Platform::DSYM
+    end
+
+    def object
+      @object ||= File.basename(app_path)
+    end
+
+    def macho_type
+      @macho_type ||= ::MachO.open(app_path)
+    end
+
+    def machos
+      @machos ||= case macho_type
+                  when ::MachO::MachOFile
+                    [MachO.new(macho_type, File.size(app_path))]
+                  else
+                    size = macho_type.fat_archs.each_with_object([]) do |arch, obj|
+                      obj << arch.size
+                    end
+
+                    machos = []
+                    macho_type.machos.each_with_index do |file, i|
+                      machos << MachO.new(file, size[i])
+                    end
+                    machos
+                  end
+    end
+
+    def release_version
+      info.try(:[], 'CFBundleShortVersionString')
+    end
+
+    def build_version
+      info.try(:[], 'CFBundleVersion')
+    end
+
+    def identifier
+      info.try(:[], 'CFBundleIdentifier').sub('com.apple.xcode.dsym.', '')
+    end
+    alias bundle_id identifier
+
+    def info
+      return nil unless File.exist?(info_path)
+
+      @info ||= CFPropertyList.native_types(CFPropertyList::List.new(file: info_path).value)
+    end
+
+    def info_path
+      @info_path ||= File.join(contents, 'Contents', 'Info.plist')
+    end
+
+    def app_path
+      unless @app_path
+        path = File.join(contents, 'Contents', 'Resources', 'DWARF')
+        name = Dir.entries(path).reject { |f| ['.', '..'].include?(f) }.first
+        @app_path = File.join(path, name)
+      end
+
+      @app_path
+    end
+
+    private
+
+    def contents
+      unless @contents
+        if File.directory?(@file)
+          @contents = @file
+        else
+          dsym_dir = nil
+          @contents = Util.unarchive(@file, path: 'dsym') do |path, zip_file|
+            zip_file.each do |f|
+              unless dsym_dir
+                dsym_dir = f.name
+                dsym_dir = dsym_dir.split('/')[0] # fix filename is xxx.app.dSYM/Contents
+              end
+
+              f_path = File.join(path, f.name)
+              zip_file.extract(f, f_path) unless File.exist?(f_path)
+            end
+          end
+
+          @contents = File.join(@contents, dsym_dir)
+        end
+      end
+
+      @contents
+    end
+
+    # DSYM Mach-O
+    class MachO
+      def initialize(file, size = 0)
+        @file = file
+        @size = size
+      end
+
+      def cpu_name
+        @file.cpusubtype
+      end
+
+      def cpu_type
+        @file.cputype
+      end
+
+      def type
+        @file.filetype
+      end
+
+      def size(humanable = false)
+        return Util.size_to_humanable(@size) if humanable
+
+        @size
+      end
+
+      def uuid
+        @file[:LC_UUID][0].uuid_string
+      end
+      alias debug_id uuid
+
+      def header
+        @header ||= @file.header
+      end
+
+      def to_h
+        {
+          uuid: uuid,
+          type: type,
+          cpu_name: cpu_name,
+          cpu_type: cpu_type,
+          size: size,
+          humanable_size: size(true)
+        }
+      end
+    end
+  end
+end