fir-cli-x 1.7.2.1

data/lib/fir/util/parser/pngcrush.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module FIR
+  module Parser
+    module Pngcrush
+
+      class << self
+
+        def png_bin
+          @png_bin ||= File.expand_path('../bin/pngcrush', __FILE__)
+        end
+
+        def uncrush_icon crushed_icon_path, uncrushed_icon_path
+          system("#{png_bin} -revert-iphone-optimizations #{crushed_icon_path} #{uncrushed_icon_path} &> /dev/null")
+        end
+
+        def crush_icon uncrushed_icon_path, crushed_icon_path
+          system("#{png_bin} -iphone #{uncrushed_icon_path} #{crushed_icon_path} &> /dev/null")
+        end
+      end
+    end
+  end
+end

data/lib/fir/util/publish.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+module FIR
+  module Publish
+    def publish(*args, options)
+      initialize_publish_options(args, options)
+      check_supported_file_and_token
+
+      logger_info_publishing_message
+
+      @app_info = send("#{@file_type}_info", @file_path, full_info: true)
+      @user_info      = fetch_user_info(@token)
+      @uploading_info = fetch_uploading_info
+      @app_id         = @uploading_info[:id]
+
+      upload_app
+
+      logger_info_dividing_line
+      logger_info_app_short_and_qrcode(options)
+
+      dingtalk_notifier(options)
+      upload_mapping_file_with_publish(options)
+      logger_info_blank_line
+      clean_files
+    end
+
+    def logger_info_publishing_message
+      user_info = fetch_user_info(@token)
+
+      email = user_info.fetch(:email, '')
+      name  = user_info.fetch(:name, '')
+
+      logger.info "Publishing app via #{name}<#{email}>......."
+      logger_info_dividing_line
+    end
+
+    def upload_app
+      @icon_cert   = @uploading_info[:cert][:icon]
+      @binary_cert = @uploading_info[:cert][:binary]
+
+      upload_app_icon unless @app_info[:icons].blank?
+      @app_uploaded_callback_data = upload_app_binary
+      logger.info "App id is #{@app_id}"
+      logger.info "Release id is #{@app_uploaded_callback_data[:release_id]}"
+      upload_device_info
+      update_app_info
+      fetch_app_info
+    end
+
+    %w[binary icon].each do |word|
+      define_method("upload_app_#{word}") do
+        upload_file(word)
+        storage = ENV['SOTRAGE_NAME'] || 'qiniu'
+        post("#{fir_api[:base_url]}/auth/#{storage}/callback", send("#{word}_information"))
+      end
+    end
+
+    def upload_file(postfix)
+      logger.info "Uploading app #{postfix}......"
+      url = @uploading_info[:cert][postfix.to_sym][:upload_url]
+      info = send("uploading_#{postfix}_info")
+      logger.debug "url = #{url}, info = #{info}"
+      uploaded_info = post(url, info.merge(manual_callback: true),
+                           params_to_json: false,
+                           header: nil)
+    rescue StandardError
+      logger.error "Uploading app #{postfix} failed"
+      exit 1
+    end
+
+    def uploading_icon_info
+      large_icon_path = @app_info[:icons].max_by { |f| File.size(f) }
+      @uncrushed_icon_path = convert_icon(large_icon_path)
+      {
+        key: @icon_cert[:key],
+        token: @icon_cert[:token],
+        file: File.new(@uncrushed_icon_path, 'rb'),
+        'x:is_converted' => '1'
+      }
+    end
+
+    def icon_information
+      {
+        key: @icon_cert[:key],
+        token: @icon_cert[:token],
+        origin: 'fir-cli',
+        parent_id: @app_id,
+        fsize: File.size(@uncrushed_icon_path),
+        fname: 'blob'
+      }
+    end
+
+    def binary_information
+      {
+        build: @app_info[:build],
+        fname: File.basename(@file_path),
+        key: @binary_cert[:key],
+        name: @app_info[:display_name] || @app_info[:name],
+        origin: 'fir-cli',
+        parent_id: @app_id,
+        release_tag: 'develop',
+        fsize: File.size(@file_path),
+        release_type: @app_info[:release_type],
+        distribution_name: @app_info[:distribution_name],
+        token: @binary_cert[:token],
+        version: @app_info[:version],
+        changelog: @changelog,
+        user_id: @user_info[:id]
+      }.reject { |x| x.nil? || x == '' }
+    end
+
+    def uploading_binary_info
+      {
+        key: @binary_cert[:key],
+        token: @binary_cert[:token],
+        file: File.new(@file_path, 'rb'),
+        # Custom variables
+        'x:name' => @app_info[:display_name] || @app_info[:name],
+        'x:build' => @app_info[:build],
+        'x:version' => @app_info[:version],
+        'x:changelog' => @changelog,
+        'x:release_type' => @app_info[:release_type],
+        'x:distribution_name' => @app_info[:distribution_name]
+      }
+    end
+
+    def upload_device_info
+      return if @app_info[:devices].blank?
+
+      logger.info 'Updating devices info......'
+
+      post fir_api[:udids_url], key: @binary_cert[:key],
+                                udids: @app_info[:devices].join(','),
+                                api_token: @token
+      end
+
+    def update_app_info
+      update_info = { short: @short, passwd: @passwd, is_opened: @is_opened }.compact
+
+      return if update_info.blank?
+
+      logger.info 'Updating app info......'
+
+      patch fir_api[:app_url] + "/#{@app_id}", update_info.merge(api_token: @token)
+    end
+
+    def fetch_uploading_info
+      logger.info "Fetching #{@app_info[:identifier]}@fir.im uploading info......"
+      logger.info "Uploading app: #{@app_info[:name]}-#{@app_info[:version]}(Build #{@app_info[:build]})"
+
+      post fir_api[:app_url], type: @app_info[:type],
+                              bundle_id: @app_info[:identifier],
+                              manual_callback: true,
+                              api_token: @token
+    end
+
+    def fetch_release_id
+      get "#{fir_api[:base_url]}/apps/#{@app_id}/releases/find_release_by_key", api_token: @token, key: @binary_cert[:key]
+    end
+
+    def fetch_app_info
+      logger.info 'Fetch app info from fir.im'
+
+      @fir_app_info = get(fir_api[:app_url] + "/#{@app_id}", api_token: @token)
+      write_app_info(id: @fir_app_info[:id], short: @fir_app_info[:short], name: @fir_app_info[:name])
+      @fir_app_info
+    end
+
+    def upload_mapping_file_with_publish(options)
+      return if !options[:mappingfile] || !options[:proj]
+
+      logger_info_blank_line
+
+      mapping options[:mappingfile], proj: options[:proj],
+                                     build: @app_info[:build],
+                                     version: @app_info[:version],
+                                     token: @token
+    end
+
+    def logger_info_app_short_and_qrcode(options)
+      @download_url = "#{fir_api[:domain]}/#{@fir_app_info[:short]}"
+      @download_url += "?release_id=#{@app_uploaded_callback_data[:release_id]}" if !!options[:need_release_id]
+
+      logger.info "Published succeed: #{@download_url}"
+
+      @qrcode_path = "#{File.dirname(@file_path)}/fir-#{@app_info[:name]}.png"
+      FIR.generate_rqrcode(@download_url, @qrcode_path)
+
+      logger.info "Local qrcode file: #{@qrcode_path}" if @export_qrcode
+    end
+
+    private
+
+    def clean_files
+      File.delete(@qrcode_path) unless @export_qrcode
+    end
+
+    def dingtalk_notifier(options)
+      if options[:dingtalk_access_token]
+        title = "#{@app_info[:name]}-#{@app_info[:version]}(Build #{@app_info[:build]})"
+        payload = {
+          "msgtype": 'markdown',
+          "markdown": {
+            "title": "#{title} uploaded",
+            "text": "#{title} uploaded at #{Time.now}\nurl: #{@download_url}\n ![app二维码](data:image/png;base64,#{Base64.strict_encode64(File.read(open(@qrcode_path)))})"
+          }
+        }
+        url = "https://oapi.dingtalk.com/robot/send?access_token=#{options[:dingtalk_access_token]}"
+        DefaultRest.post(url, payload)
+      end
+    rescue StandardError => e
+      logger.warn "Dingtalk send error #{e.message}"
+    end
+
+    def initialize_publish_options(args, options)
+      @file_path     = File.absolute_path(args.first.to_s)
+      @file_type     = File.extname(@file_path).delete('.')
+      @token         = options[:token] || current_token
+      @changelog     = read_changelog(options[:changelog]).to_s.to_utf8
+      @short         = options[:short].to_s
+      @passwd        = options[:password].to_s
+      @is_opened     = @passwd.blank? ? options[:open] : false
+      @export_qrcode = !!options[:qrcode]
+    end
+
+    def read_changelog(changelog)
+      return if changelog.blank?
+
+      File.exist?(changelog) ? File.read(changelog) : changelog
+    end
+
+    def check_supported_file_and_token
+      check_file_exist(@file_path)
+      check_supported_file(@file_path)
+      check_token_cannot_be_blank(@token)
+      fetch_user_info(@token)
+    end
+
+    def convert_icon(origin_path)
+      # 兼容性不太好, 蔽掉转化图标
+      return origin_path
+
+      logger.info "Converting app's icon......"
+
+      if @app_info[:type] == 'ios'
+        output_path = Tempfile.new(['uncrushed_icon', '.png']).path
+        FIR::Parser::Pngcrush.uncrush_icon(origin_path, output_path)
+        origin_path = output_path if File.size(output_path) != 0
+      end
+
+      origin_path
+    end
+  end
+end

data/lib/fir/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module FIR
+  VERSION = '1.7.2.1'
+end

data/lib/fir/xcode_wrapper.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+#!/bin/bash --login
+
+which rvm > /dev/null
+
+if [[ $? -eq 0 ]]; then
+  echo "RVM detected, forcing to use system ruby since xcodebuild cause error"
+  [[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"
+  rvm use system
+fi
+
+if which rbenv > /dev/null; then
+  echo "rbenv detected, removing env variables since xcodebuild cause error"
+  rbenv shell system
+fi
+
+shell_session_update() { :; }
+
+unset RUBYLIB
+unset RUBYOPT
+unset BUNDLE_BIN_PATH
+unset _ORIGINAL_GEM_PATH
+unset BUNDLE_GEMFILE
+unset GEM_HOME
+unset GEM_PATH
+
+set -x
+xcodebuild "$@"

data/lib/fir_cli.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+# This file exists for backward compatbility with require 'fir_cli'
+require_relative './fir'

data/test/build_ipa_test.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+class BuildAppTest < Minitest::Test
+
+  def test_build_app
+    if ENV['BUILD_TEST']
+      options = OpenStruct.new
+      options.send('publish?=', true)
+
+      assert FIR.build_ipa(default_ipa_project, options)
+      assert FIR.build_apk(default_apk_project, options)
+
+      assert FIR.build_ipa(default_ipa_git_url, options)
+      assert FIR.build_apk(default_apk_git_url, options)
+    end
+  end
+end

data/test/cases/test_apk_txt

@@ -0,0 +1 @@
+this is a text

data/test/info_test.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+class InfoTest < Minitest::Test
+
+  def test_apk_info
+    info = FIR.apk_info(default_apk, full_info: true)
+
+    assert_equal 'android',                 info[:type]
+    assert_equal 'com.bughd.myapplication', info[:identifier]
+    assert_equal 'My Application',          info[:name]
+    assert_equal '1',                       info[:build]
+    assert_equal '1.0',                     info[:version]
+
+    assert_equal true, File.exist?(info[:icons].first)
+
+    assert FIR.info(default_apk, {})
+  end
+
+  def test_ipa_info
+    info = FIR.ipa_info(default_ipa, full_info: true)
+
+    assert_equal 'ios',              info[:type]
+    assert_equal 'im.fir.build-ipa', info[:identifier]
+    assert_equal 'build_ipa',        info[:name]
+    assert_equal '1',                info[:build]
+    assert_equal '1.0',              info[:version]
+
+    # Only for OSX
+    # assert_equal nil,                       info[:display_name]
+    # assert_equal default_device_udid,       info[:devices].first
+    # assert_equal 'adhoc',                   info[:release_type]
+    # assert_equal default_distribution_name, info[:distribution_name]
+
+    assert FIR.info(default_ipa, {})
+  end
+end

data/test/login_test.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+class LoginTest < Minitest::Test
+
+  def test_login
+    user_info = FIR.fetch_user_info(default_token)
+
+    assert_equal default_email, user_info.fetch(:email, '')
+
+    assert FIR.login(default_token)
+  end
+end

data/test/mapping_test.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+class MappingTest < Minitest::Test
+
+  def test_mapping
+    options = {
+      token:   default_token,
+      version: '1.1',
+      build:   '1'
+    }
+
+    if ENV['MAPPING_TEST']
+      assert FIR.mapping(default_dsym_mapping, options.merge(proj: default_bughd_project_ios_id))
+      assert FIR.mapping(default_txt_mapping,  options.merge(proj: default_bughd_project_android_id))
+      assert FIR.mapping(bigger_txt_mapping,   options.merge(proj: default_bughd_project_android_id))
+    end
+  end
+end

data/test/me_test.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+class MeTest < Minitest::Test
+
+  def test_me
+    user_info = FIR.fetch_user_info(default_token)
+
+    FIR.write_config(email: user_info.fetch(:email, ''), token: default_token)
+    FIR.reload_config
+
+    me_info = FIR.fetch_user_info(FIR.current_token)
+
+    assert_equal default_email, me_info.fetch(:email, '')
+
+    assert FIR.me
+  end
+end

data/test/publish_test.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+class PublishTest < Minitest::Test
+
+  def setup
+    @options = {
+      token:     default_token,
+      changelog: "test from fir-cli #{Time.now.to_i}"
+    }
+  end
+
+  def test_simple_publish
+    assert FIR.publish(default_ipa, @options)
+    assert FIR.publish(default_apk, @options)
+  end
+
+  def test_update_app_info
+    short     = SecureRandom.hex[3..9]
+    is_opened = (rand(100) % 2) == 0
+
+    update_info = { short: short, open: is_opened }
+    FIR.publish(default_ipa, @options.merge(update_info))
+
+    info = FIR.fetch_app_info
+
+    assert_equal short, info[:short]
+    assert_equal is_opened, info[:is_opened]
+  end
+
+  def test_update_app_passwd
+    short     = SecureRandom.hex[3..9]
+    is_opened = (rand(100) % 2) == 0
+    passwd    = SecureRandom.hex[0..9]
+
+    update_info = { short: short, password: passwd, open: is_opened }
+    FIR.publish(default_ipa, @options.merge(update_info))
+
+    info = FIR.fetch_app_info
+
+    assert_equal short, info[:short]
+    assert_equal passwd, info[:passwd]
+    assert_equal false, info[:is_opened]
+  end
+end