fastlane-plugin-bundletool 1.0.0 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 163f2ddba8e6f8c3aba41b8310aa832d672dd3b93131b1aa3f7accb588721978
-  data.tar.gz: a6cd88f56cea3a410019d6d79f9e437d5d0c92ecbcae556adf506dc1dcfaf693
+  metadata.gz: 2beec5bfb2d18b0204a6818f4cc811b598d2453712b8c459150c2718e4247f6f
+  data.tar.gz: fdef06f79576b285814a231beeca51059d5c6a65ad56181f1bebadacb2e131d9
 SHA512:
-  metadata.gz: c178cd9227ccd548eb83502e68e1283655e288a59d2a5c9ee64bba0b1303d3b48991643b92c4dc51d40d916fca3d078e3c838111cc3cee3a5f7ecfcf86584948
-  data.tar.gz: 533afee2b9cc30b48e5c57585a68845ee646c11b9b75b6e6d712b5b09b917b51810ce30661bd6691b070fd250c76054388c4e00b14d16e826ab7704821e33a49
+  metadata.gz: 7f34ea0842d770fcbe88d39f9b776b4eda9179c6337394a178827791a3cf4fe10387b6b3c1e4e137c9dba5e7d2e10546f02456e5298bd5c5c2c9fa3120c66fac
+  data.tar.gz: e63256fe509d81b64fd7cf4c79abd3870f78d1db106badd16fc3988a213284546a1db885c409ce7ad8943996682842da3d3681261b3bc02c1d34a8da85111ac3

data/README.md

@@ -1,4 +1,4 @@
-# bundletool plugin
+# Bundletool for Fastlane
 
 [![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-bundletool)
 
@@ -10,30 +10,44 @@ This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To
 fastlane add_plugin bundletool
 ```
 
-## About bundletool
+or in your Pluginfile under fastlane folder write the following line and run `bundle install`.
 
-Extracts a universal apk from an .aab file
+```
+gem 'fastlane-plugin-bundletool', '1.0.2'
+```
 
-**Note to author:** Add a more detailed description about this plugin here. If your plugin contains multiple actions, make sure to mention them here.
+## About bundletool
 
-## Example
+**bundletool** is the underlying tool that Gradle, Android Studio, and Google Play use to build an Android App Bundle or convert an app bundle into the various APKs that are deployed to devices. bundletool is also available to you as a command line tool, so you can recreate, inspect, and verify Google Play’s server-side build of your app’s APKs.
 
-Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+https://developer.android.com/studio/command-line/bundletool
 
-**Note to author:** Please set up a sample project to make it easy for users to explore what your plugin does. Provide everything that is necessary to try out the plugin in this project (including a sample Xcode/Android project if necessary)
+The motivation of this plugin is to extract an universal `.apk` file from an [.aab](https://fileinfo.com/extension/aab) file. Since we cannot distribute aab files, it's great that we can extract from the very same binary a file that we can distribute internally.
 
-## Run tests for this plugin
+## Usage
 
-To run both the tests, and code style validation, run
+In your Fastfile you need to use `bundletool` action. After you build the `.aab` file you can run the following code.
 
-```
-rake
+```ruby
+bundletool(
+  ks_path: keystore_path,
+  ks_password: keystore_password,
+  ks_key_alias: keystore_alias,
+  ks_key_alias_password: keystore_alias_password,
+  bundletool_version: '0.11.0',
+  aab_path: aab_path,
+  apk_output_path: apk_output_path,
+  verbose: true
+)
 ```
 
-To automatically fix many of the styling issues, use
-```
-rubocop -a
-```
+This will output the universal `.apk` in the output path you set.
+
+## Use case
+
+Here you can find a post I did explaining why I have to create this action.
+
+https://medium.com/@gonzalez.martin90/bundletool-with-fastlane-8f8862ab16e0
 
 ## Issues and Feedback
 

data/lib/fastlane/plugin/bundletool/actions/bundletool_action.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fastlane/action'
 require_relative '../helper/bundletool_helper'
 
@@ -10,7 +12,7 @@ module Fastlane
         @bundletool_temp_path = "#{@project_root}/bundletool_temp"
         @verbose = params[:verbose]
         keystore_info = {}
-        unless (params[:ks_path].nil?)
+        unless params[:ks_path].nil?
           keystore_info[:keystore_path] = params[:ks_path]
           keystore_info[:keystore_password] = params[:ks_password]
           keystore_info[:alias] = params[:ks_key_alias]
@@ -19,45 +21,48 @@ module Fastlane
 
         bundletool_version = params[:bundletool_version]
         aab_path = params[:aab_path]
-        output_path = params[:apk_output_path]
+        output_path = params[:apk_output_path] || '.'
+
+        return unless validate_aab!(aab_path)
+
+        return unless download_bundletool(bundletool_version)
 
-        validate_aab!(aab_path) 
-        download_bundletool(bundletool_version)
         extract_universal_apk_from(aab_path, output_path, keystore_info)
       end
 
       def self.validate_aab!(aab_path)
         puts_message('Checking if .aab file exists...')
-        puts_error!(".aab file at #{aab_path} does not exist") unless File.file?(aab_path)
+        unless File.file?(aab_path)
+          puts_error!(".aab file at #{aab_path} does not exist")
+          return false
+        end
         puts_success('Checking if .aab file exists')
       end
 
       def self.download_bundletool(version)
-        begin
-          puts_message("Downloading bundletool (#{version}) from https://github.com/google/bundletool/releases/download/#{version}/bundletool-all-#{version}.jar...")
-          Dir.mkdir "#{@project_root}/bundletool_temp"
-          open("https://github.com/google/bundletool/releases/download/#{version}/bundletool-all-#{version}.jar") do |bundletool|
-            File.open("#{@bundletool_temp_path}/bundletool.jar", "wb") do |file|
-              file.write(bundletool.read)
-            end
+        puts_message("Downloading bundletool (#{version}) from https://github.com/google/bundletool/releases/download/#{version}/bundletool-all-#{version}.jar...")
+        Dir.mkdir "#{@project_root}/bundletool_temp"        
+        URI.open("https://github.com/google/bundletool/releases/download/#{version}/bundletool-all-#{version}.jar") do |bundletool|
+          File.open("#{@bundletool_temp_path}/bundletool.jar", 'wb') do |file|
+            file.write(bundletool.read)
           end
-          puts_success('Downloading bundletool')
-        rescue StandardError => e
-          puts_error!("Something went wrong when downloading bundletool version #{version}")
         end
+        puts_success('Downloading bundletool')
+      rescue OpenURI::HTTPError => e
+        clean_temp!
+        puts_error!("Something went wrong when downloading bundletool version #{version}. \nError message\n #{e.message}")        
+        false
       end
 
       def self.extract_universal_apk_from(aab_path, apk_output_path, keystore_info)
-        begin
-          aab_absolute_path = Pathname.new(File.expand_path(aab_path)).to_s
-          apk_output_absolute_path = Pathname.new(File.expand_path(apk_output_path)).to_s
-          output_path = run_bundletool!(aab_absolute_path, keystore_info)
-          prepare_apk!(output_path, apk_output_absolute_path)
-        rescue StandardError => e
-          puts_error!("Bundletool could not extract universal apk from aab at #{aab_absolute_path}")
-        ensure
-          clean_temp!
-        end
+        aab_absolute_path = Pathname.new(File.expand_path(aab_path)).to_s
+        apk_output_absolute_path = Pathname.new(File.expand_path(apk_output_path)).to_s
+        output_path = run_bundletool!(aab_absolute_path, keystore_info)
+        prepare_apk!(output_path, apk_output_absolute_path)
+      rescue StandardError => e
+        puts_error!("Bundletool could not extract universal apk from aab at #{aab_absolute_path}. \nError message\n #{e.message}")
+      ensure
+        clean_temp!
       end
 
       def self.run_bundletool!(aab_path, keystore_info)
@@ -65,18 +70,11 @@ module Fastlane
         output_path = "#{@bundletool_temp_path}/output.apks"
         keystore_params = ''
 
-        unless (keystore_info.empty?)
-          keystore_params = "--ks=#{keystore_info[:keystore_path]} \
-          --ks-pass=pass:#{keystore_info[:keystore_password]} \
-          --ks-key-alias=#{keystore_info[:alias]} \
-          --key-pass=pass:#{keystore_info[:alias_password]}"
+        unless keystore_info.empty?
+          keystore_params = "--ks=\"#{keystore_info[:keystore_path]}\" --ks-pass=\"pass:#{keystore_info[:keystore_password]}\" --ks-key-alias=\"#{keystore_info[:alias]}\" --key-pass=\"pass:#{keystore_info[:alias_password]}\""
         end
 
-        cmd = "java -jar #{@bundletool_temp_path}/bundletool.jar build-apks \
-        --bundle=#{aab_path} \
-        --output=#{output_path} \
-        --mode=universal \
-        #{keystore_params}"
+        cmd = "java -jar #{@bundletool_temp_path}/bundletool.jar build-apks --bundle=\"#{aab_path}\" --output=\"#{output_path}\" --mode=universal #{keystore_params}"
 
         Open3.popen3(cmd) do |_, _, stderr, wait_thr|
           exit_status = wait_thr.value
@@ -88,15 +86,17 @@ module Fastlane
 
       def self.prepare_apk!(output_path, target_path)
         puts_message("Preparing apk to #{target_path}...")
-        puts_important("Apk at path #{target_path} exists. Replacing it.") if File.file?(target_path)
+        if File.file?(target_path)
+          puts_important("Apk at path #{target_path} exists. Replacing it.")
+        end
         target_dir_name = File.dirname(target_path)
         unless Dir.exist?(target_dir_name)
-          puts_important("Creating path #{target_path} since does not exist")
-          Dir.mkdir target_dir_name
+          puts_important("Creating path #{target_dir_name} since does not exist")
+          FileUtils.mkdir_p target_dir_name
         end
-        cmd = "mv #{output_path} #{@bundletool_temp_path}/output.zip &&
-        unzip #{@bundletool_temp_path}/output.zip -d #{@bundletool_temp_path} &&
-        mv #{@bundletool_temp_path}/universal.apk #{target_path}"
+        cmd = "mv \"#{output_path}\" \"#{@bundletool_temp_path}/output.zip\" &&
+        unzip \"#{@bundletool_temp_path}/output.zip\" -d \"#{@bundletool_temp_path}\" &&
+        mv \"#{@bundletool_temp_path}/universal.apk\" \"#{target_path}\""
         Open3.popen3(cmd) do |_, _, stderr, wait_thr|
           exit_status = wait_thr.value
           raise stderr.read unless exit_status.success?
@@ -104,7 +104,7 @@ module Fastlane
         puts_success("Preparing apk to #{target_path}")
       end
 
-      def self.clean_temp!()
+      def self.clean_temp!
         cmd = "rm -rf #{@project_root}/bundletool_temp"
         Open3.popen3(cmd) do |_, _, stderr, wait_thr|
           exit_status = wait_thr.value
@@ -117,14 +117,19 @@ module Fastlane
       end
 
       def self.puts_success(message)
-        UI.success "#{message} #{Fastlane::Helper::Emojis.green_checkmark}" if @verbose
+        if @verbose
+          UI.success "#{message} #{Fastlane::Helper::Emojis.green_checkmark}"
+        end
       end
 
       def self.puts_important(message)
-        UI.important "#{message} #{Fastlane::Helper::Emojis.warning}" if @verbose
+        if @verbose
+          UI.important "#{message} #{Fastlane::Helper::Emojis.warning}"
+        end
       end
 
       def self.puts_error!(message)
+        p message
         UI.user_error! message
       end
 
@@ -162,12 +167,8 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :apk_output_path,
                                        description: 'Path where the apk file is going to be placed',
                                        is_string: true,
-                                       optional: false,
-                                       verify_block: proc do |value|
-                                                       unless value && !value.empty?
-                                                         UI.user_error!('You must set apk_output_path.')
-                                                       end
-                                                     end),
+                                       optional: true,
+                                       default_value: '.'),
           FastlaneCore::ConfigItem.new(key: :verbose,
                                        description: 'Show every messages of the action',
                                        is_string: false,
@@ -181,20 +182,20 @@ module Fastlane
       def self.print_params(options)
         table_title = "Params for bundletool #{Fastlane::Bundletool::VERSION}"
         FastlaneCore::PrintTable.print_values(config: options,
-                                              mask_keys: [:ks_password, :ks_key_alias_password],
+                                              mask_keys: %i[ks_password ks_key_alias_password],
                                               title: table_title)
       end
 
       def self.description
-        "Extracts an universal apk from an .aab file"
+        'Extracts an universal apk from an .aab file'
       end
 
       def self.authors
-        ["Martin Gonzalez"]
+        ['Martin Gonzalez']
       end
 
       def self.details
-        "Using the google oficial bundletool to extract an universal apk from .aab file to distribute it"
+        'Using the google oficial bundletool to extract an universal apk from .aab file to distribute it'
       end
 
       def self.is_supported?(platform)

data/lib/fastlane/plugin/bundletool/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module Bundletool
-    VERSION = "1.0.0"
+    VERSION = "1.0.4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-bundletool
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.4
 platform: ruby
 authors:
 - Martin Gonzalez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-09 00:00:00.000000000 Z
+date: 2021-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -168,7 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: Extracts a universal apk from an .aab file