fastlane-plugin-apprepo 0.1.0 → 0.2.0

data/lib/fastlane/plugin/apprepo/helper/detect_values.rb

@@ -0,0 +1,29 @@
+
+module Fastlane
+  module Apprepo
+    # This class is responsible for detecting values from IPA.
+    class DetectValues
+      def run!(options)
+        find_app_identifier(options)
+        find_version(options)
+      end
+
+      def find_app_identifier(options)
+        return if options[:app_identifier]
+        if options[:ipa]
+          # identifier = Apprepo::Analyser.fetch_app_identifier(options[:ipa])
+        end
+        options[:app_identifier] = identifier unless identifier.to_s.empty?
+        input_message = 'The Bundle Identifier of your App: '
+        options[:app_identifier] ||= UI.input(input_message)
+      end
+
+      def find_version(options)
+        unless options[:ipa].nil?
+          opt = Apprepo::Analyser.new(options)
+          options[:app_version] ||= opt.fetch_app_version(options[:ipa])
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/apprepo/helper/loader.rb

@@ -0,0 +1,15 @@
+require 'fastlane_core/languages'
+
+module Fastlane
+  module Apprepo
+    # Responsible for loading language folders
+    module Loader
+      def self.language_folders(root)
+        Dir.glob(File.join(root, '*')).select do |path|
+          all = ALL_LANGUAGES.include?(File.basename(path).downcase)
+          File.directory?(path) && all
+        end.sort
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/apprepo/helper/manifest.rb

@@ -0,0 +1,44 @@
+require 'json'
+
+module Fastlane
+  module Apprepo
+    # Responsible for parsing and providing manifest.json
+    class Manifest
+      #
+      # Translated internal key names from Fastlane to Apprepo
+      #
+
+      attr_accessor :appcode             # Apprepo Internal Code
+      attr_accessor :filename            # IPA file name
+      attr_accessor :bundle_identifier   # app_identifier
+      attr_accessor :bundle_version      # app_version
+      attr_accessor :title               # app_name
+      attr_accessor :subtitle            # app_description
+      attr_accessor :notify              # will send push notification / slack
+
+      def initialize(appcode)
+        self.appcode = appcode
+        UI.message('Initializing requires APPCODE. ' + self.appcode)
+      end
+
+      def parse_json(json)
+        # TODO: load values from JSON
+      end
+
+      # Provide JSON serialized data
+      def manifest_as_json
+        structure = {
+          appcode: appcode,
+          filename: filename,
+          bundle_identifier: bundle_identifier,
+          bundle_version: bundle_version,
+          title: title,
+          subtitle: subtitle,
+          notify: notify
+        }
+
+        fputs structure
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/apprepo/helper/options.rb

@@ -0,0 +1,120 @@
+require 'fastlane_core'
+
+module Fastlane
+  module Apprepo
+    # Provides available options for the commands generator
+    class Options
+      # rubocop:disable Metrics/AbcSize
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :ipa,
+                                       short_option: '-i',
+                                       optional: true,
+                                       env_name: 'APPREPO_IPA_PATH',
+                                       description: 'Path to your ipa file',
+                                       default_value: Dir['*.ipa'].first,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Could not find ipa file at path '#{value}'") unless File.exist?(value)
+                                         UI.user_error!("'#{value}' doesn't seem to be an ipa file") unless value.end_with?('.ipa')
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                       short_option: '-b',
+                                       optional: false,
+                                       env_name: 'APPREPO_APP_ID',
+                                       description: 'Your bundle identifier',
+                                       default_value: ''),
+          FastlaneCore::ConfigItem.new(key: :app_code,
+                                       short_option: '-c',
+                                       optional: true,
+                                       env_name: 'APPREPO_APPCODE',
+                                       description: 'APPCODE value for apprepo'),
+          FastlaneCore::ConfigItem.new(key: :repo_url,
+                                       short_option: '-r',
+                                       optional: false,
+                                       env_name: 'APPREPO_URL',
+                                       description: 'URL of your Apprepo server'),
+          FastlaneCore::ConfigItem.new(key: :repo_user,
+                                       short_option: '-u',
+                                       optional: false,
+                                       env_name: 'APPREPO_USER',
+                                       description: 'USER of your Apprepo server'),
+          FastlaneCore::ConfigItem.new(key: :repo_password,
+                                       short_option: '-p',
+                                       optional: true,
+                                       env_name: 'APPREPO_PASSWORD',
+                                       description: 'PASSWORD for your Apprepo server (not for production)',
+                                       conflicting_options: [:repo_key],
+                                       conflict_block: proc do |value|
+                                         UI.user_error!("You can't use 'password' and '#{value.key}' options in one run.")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :repo_key,
+                                       short_option: '-k',
+                                       optional: false,
+                                       env_name: 'APPREPO_KEY',
+                                       description: 'RSA key for your Apprepo server',
+                                       conflicting_options: [:repo_password],
+                                       conflict_block: proc do |value|
+                                         UI.user_error!("You can't use 'repo_key' and '#{value.key}' options in one run.")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :repo_description,
+                                       short_option: '-d',
+                                       optional: true,
+                                       description: 'Long detailed description for your Apprepo server',
+                                       default_value: ''),
+          FastlaneCore::ConfigItem.new(key: :repo_summary,
+                                       short_option: '-s',
+                                       optional: true,
+                                       description: 'Short description for your Apprepo server',
+                                       default_value: ''),
+          FastlaneCore::ConfigItem.new(key: :manifest_path,
+                                       short_option: '-m',
+                                       description: 'Path to the folder containing the metadata files',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :repo_title,
+                                       short_option: '-a',
+                                       description: 'Title of the app',
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :appcode,
+                                       short_option: '-o',
+                                       description: 'Name of the app on Apprepo',
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :skip_binary_upload,
+                                       description: 'Skip uploading an ipa or to Apprepo',
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :app_version,
+                                       short_option: '-z',
+                                       description: 'The version that should be edited or created',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :skip_manifest,
+                                       description: "Don't upload the metadata (e.g. title, description), this will still upload screenshots",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :notify,
+                                       description: 'Notify Apprepo users on update',
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :build_number,
+                                       short_option: '-n',
+                                       description: 'If set the given build number (already uploaded to iTC) will be used instead of the current built one',
+                                       optional: true,
+                                       conflicting_options: [:ipa],
+                                       conflict_block: proc do |value|
+                                         UI.user_error!("You can't use 'build_number' and '#{value.key}' options in one run.")
+                                       end),
+
+          # App Metadata
+          # Non Localised
+          FastlaneCore::ConfigItem.new(key: :app_icon,
+                                       description: 'Metadata: The path to the app icon',
+                                       optional: true,
+                                       short_option: '-l',
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Could not find png file at path '#{value}'") unless File.exist?(value)
+                                         UI.user_error!("'#{value}' doesn't seem to be a png file") unless value.end_with?('.png')
+                                       end)
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/apprepo/helper/runner.rb

@@ -0,0 +1,68 @@
+require_relative 'uploader'
+
+module Fastlane
+  module Apprepo
+    # Responsible for running
+    class Runner
+      attr_accessor :options
+
+      def initialize(options)
+        self.options = options
+        Apprepo::DetectValues.new.run!(self.options)
+        FastlaneCore::PrintTable.print_values(config: options, hide_keys: [:repo_password], mask_keys: [:repo_key], title: "apprepo-sftp #{Apprepo::VERSION} Summary")
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def run
+        UI.success('Apprepo SFTP Uploader running...')
+        verify_version unless options[:app_version].to_s.empty?
+        has_binary = options[:ipa]
+        if !options[:skip_binary_upload] && !options[:build_number] && has_binary
+          upload_binary
+        end
+        UI.success('Finished the upload to Apprepo.')
+        notify unless options[:notify].nil?
+      end
+
+      # Make sure the version on Apprepo matches the one in the ipa
+      # If not, the new version will automatically be created
+      def verify_version
+        app_version = options[:app_version]
+        msg = "TODO: Test if Apprepo matches '#{app_version}' from the IPA..."
+        UI.message(msg)
+
+        # changed = options[:app].ensure_version!(app_version)
+        # if changed
+        #  UI.success("Successfully set the version to '#{app_version}'")
+        # else
+        #  UI.success("'#{app_version}' is the latest version on Apprepo")
+        # end
+      end
+
+      def download_manifest
+        if options[:manifest_path]
+          uploader = Apprepo::Uploader.new(options)
+          result = uploader.download_manifest_only
+          msg = 'Metadata download failed. Check out the error above.'
+          UI.user_error!(msg) unless result
+        end
+      end
+
+      # Upload the binary to Apprepo
+      def upload_binary
+        if options[:ipa]
+          uploader = Apprepo::Uploader.new(options)
+          result = uploader.upload
+          msg = 'Binary upload failed. Check out the error above.'
+          UI.user_error!(msg) unless result
+        end
+      end
+
+      def notify
+        # should be in metadata
+        UI.command_output('TODO: Missing implementation for Apprepo Push Notifier')
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/apprepo/helper/setup.rb

@@ -0,0 +1,49 @@
+module Fastlane
+  module Apprepo
+    # Responsible for setting up the Repofile configuration
+    class Setup
+      def setup_apprepo(file_path, data, _apprepo_path, _options)
+        UI.message('[Apprepo:Setup] Setting up...')
+        File.write(file_path, data)
+
+        # TODO: implement later
+        download_manifest(apprepo_path, options)
+
+        UI.success("NOT! created new Repofile at path '#{file_path}'")
+      end
+
+      # This method takes care of creating a new 'apprepo' folder with metadata
+      # and screenshots folders
+      def generate_apprepo_file(_apprepo_path, options)
+        # v = options[:app].latest_version
+        # generate_apprepo_file(v, File.join(apprepo_path, 'manifest.json'))
+
+        # Generate the final Repofile here
+        gem_path = Helper.gem_path('apprepo')
+        apprepo = File.read("#{gem_path}/../assets/RepofileDefault")
+        apprepo.gsub!('[[APP_IDENTIFIER]]', options[:app].bundle_id)
+        apprepo.gsub!('[[APPREPO_IPA_PATH]]', options[:app].file_path)
+        apprepo.gsub!('[[APP_VERSION]]', options[:app].version)
+        apprepo.gsub!('[[APP_NAME]]', options[:app].name)
+        # apprepo (was deliver)
+      end
+
+      def download_manifest(apprepo_path, _options)
+        path = File.join(apprepo_path, 'metadata')
+        FileUtils.mkdir_p(path)
+        UI.success("TODO: DOWNLOAD MANIFEST'")
+        Apprepo::Uploader.new(options).download_manifest_only
+      end
+
+      def run(options)
+        UI.message('[Apprepo:Setup] Running...')
+        containing = (File.directory?('fastlane') ? 'fastlane' : '.')
+        file_path = File.join(containing, 'Repofile')
+        data = generate_apprepo_file(containing, options)
+        setup_apprepo(file_path, data, containing, options)
+      end
+    end
+  end
+
+  # @setup = new Apprepo::Setup
+end

data/lib/fastlane/plugin/apprepo/helper/uploader.rb

@@ -0,0 +1,301 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'json'
+require 'net/ssh'
+require 'net/sftp'
+require 'fastlane_core'
+require 'fastlane_core/languages'
+
+require_relative 'options'
+
+module Fastlane
+  module Apprepo
+    # rubocop:disable Metrics/ClassLength
+
+    # Responsible for performing the SFTP operation
+    class Uploader
+      attr_accessor :options
+
+      #
+      # These want to be an input parameters:
+      #
+
+      attr_accessor :host
+      attr_accessor :user
+      attr_accessor :password
+      attr_accessor :rsa_keypath
+      attr_accessor :ipa_path
+      attr_accessor :manifest_path
+      attr_accessor :appcode
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def initialize(options)
+        self.options = options unless options.nil?
+        self.host = options[:repo_url] # 'repo.teacloud.net'
+        self.user = options[:repo_user]
+        self.password = options[:repo_password]
+        self.rsa_keypath = options[:repo_key] # '../assets/circle.key'
+        self.ipa_path = options[:ipa] # '../sampleapp.ipa'
+        self.manifest_path = options[:manifest_path] # '../assets/example_manifest.json'
+        self.appcode = options[:appcode]
+
+        # Apprepo::Uploader.new.run!
+        # FastlaneCore::PrintTable.print_values(config: nil , hide_keys: [:app],
+        # mask_keys: ['app_review_information.demo_password'],
+        # title: "deliver #{Apprepo::VERSION} Summary") # options
+      end
+
+      #
+      # Upload IPA & manifest
+      #
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def upload
+        # Login & Upload IPA with metadata using RSA key or username/password
+        FastlaneCore::UI.message('upload...')
+
+        if host.nil? || user.nil?
+          FastlaneCore::UI.user_error('repo_url, repo_user and repo_pasdword or repo_key must be set on upload')
+          return false
+        end
+
+        if rsa_keypath
+          rsa_key = load_rsa_key(rsa_keypath)
+          if rsa_key.nil?
+            FastlaneCore::UI.user_error('Failed to load RSA key... ' + options[:rsa_keypath])
+          end
+        end
+
+        success = false
+        if !rsa_key.nil?
+          FastlaneCore::UI.message('Logging in with RSA key...')
+          Net::SSH.start(host, user, key_data: rsa_key, keys_only: true) do |ssh|
+            FastlaneCore::UI.message('Uploading IPA & Manifest...')
+            success = ssh_sftp_upload(ssh, ipa_path, manifest_path)
+          end
+        else
+          FastlaneCore::UI.message('Logging in with username/password...')
+          Net::SSH.start(host, user, password: password) do |ssh|
+            FastlaneCore::UI.message('Uploading IPA & Manifest...')
+            success = ssh_sftp_upload(ssh, ipa_path, manifest_path)
+          end
+        end
+        success
+      end
+
+      #
+      # Download metadata only
+      #
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def download_manifest_only
+        FastlaneCore::UI.message('download_manifest_only...')
+        rsa_key = load_rsa_key(rsa_keypath)
+        success = true
+        if !rsa_key.nil?
+          FastlaneCore::UI.message('Logging in with RSA key for download...')
+          Net::SSH.start(host, user, key_data: rsa_key, keys_only: true) do |ssh|
+            FastlaneCore::UI.message('Uploading UPA & Manifest...')
+            success = ssh_sftp_download(ssh, manifest_path)
+          end
+        else
+          FastlaneCore::UI.message('Logging in for download...')
+          Net::SSH.start(host, user, password: password) do |ssh|
+            FastlaneCore::UI.message('Uploading UPA & Manifest...')
+            success = ssh_sftp_download(ssh, manifest_path)
+          end
+        end
+        success
+      end
+
+      private
+
+      def ssh_sftp_download(ssh, _manifest_path)
+        ssh.sftp.connect do |sftp|
+          FastlaneCore::UI.message('Fetching remote manifest...')
+          manifest = download_manifest(sftp)
+          puts '********************************************************'
+          puts JSON.pretty_generate(manifest)
+          puts '********************************************************'
+          FastlaneCore::UI.success('Successfully fetched manifest')
+          FastlaneCore::UI.command_output('TODO: Processing manifest not implemented.')
+        end
+      end
+
+      def ssh_sftp_upload(ssh, local_ipa_path, manifest_path)
+        ssh.sftp.connect do |sftp|
+          break unless check_ipa(local_ipa_path)
+          check_appcode(sftp, appcode)
+          path = remote_path(appcode)
+          manifest = download_manifest(sftp)
+          puts JSON.pretty_generate(manifest) unless manifest.nil?
+          bump_ipa(sftp, local_ipa_path, appcode)
+          remote_ipa_path = get_remote_ipa_path(local_ipa_path, appcode)
+          upload_ipa(sftp, local_ipa_path, remote_ipa_path)
+          upload_manifest(sftp, manifest_path, remote_manifest_path(appcode))
+          # Lists the entries in a directory for verification
+          sftp.dir.foreach(path) do |entry|
+            FastlaneCore::UI.message(entry.longname)
+          end
+        end
+      end
+
+      # Check IPA existence locally
+      #
+      # @param local_ipa_path
+      def check_ipa(local_ipa_path)
+        if File.exist?(local_ipa_path)
+          FastlaneCore::UI.important('IPA found at ' + local_ipa_path)
+          return true
+        else
+          FastlaneCore::UI.verbose('IPA at given path does not exist yet.')
+          return false
+        end
+      end
+
+      # Private methods - Remote Operations
+
+      # Checks/creates remote APPCODE directory
+      # @param sftp
+      # @param [String] appcode
+      def check_appcode(sftp, appcode)
+        path = remote_path(appcode)
+        FastlaneCore::UI.message('Checking APPCODE')
+        remote_mkdir(sftp, path)
+      end
+
+      # Checks/renames remote IPA
+      #
+      # @params sftp
+      # @params [String] local_ipa_path
+      def bump_ipa(sftp, local, appcode)
+        remote = get_remote_ipa_path(local, appcode)
+        FastlaneCore::UI.message('Checking remote IPA')
+        begin
+          sftp.stat!(remote) do |response|
+            if response.ok?
+              begin
+                sftp.rename!(remote, remote + '.bak')
+              rescue
+                begin
+                  sftp.remove(remote + '.bak') # may fail if not existent
+                  FastlaneCore::UI.message('Removed ' + remote + '.bak')
+                rescue
+                  sftp.rename!(remote, remote + '.bak')
+                  FastlaneCore::UI.message('Bumped to ' + remote + '.bak')
+                end
+              end
+            end
+          end
+        rescue
+          FastlaneCore::UI.message('No previous IPA found.')
+        end
+      end
+
+      # Downloads remote manifest, self.appcode required by options.
+      #
+      # @param sftp
+      # @param [String] remote_path
+      # @returns [JSON] json or nil
+      def download_manifest(sftp)
+        FastlaneCore::UI.message('Checking remote Manifest')
+        json = nil
+        remote_manifest_path = remote_manifest_path(appcode)
+        begin
+          sftp.stat!(remote_manifest_path) do |response|
+            if response.ok?
+              FastlaneCore::UI.success('Loading remote manifest:')
+              manifest = sftp.download!(remote_manifest_path)
+              json = JSON.parse(manifest)
+            end
+          end
+        rescue
+          FastlaneCore::UI.message('No previous Manifest found')
+        end
+        json
+      end
+
+      # Upload current IPA
+      #
+      # @param sftp
+      # @param [String] local_ipa_path
+      # @param [String] remote_ipa_path
+      def upload_ipa(sftp, local_ipa_path, remote_ipa_path)
+        msg = "[Uploading IPA] #{local_ipa_path} to #{remote_ipa_path}"
+        FastlaneCore::UI.message(msg)
+        result = sftp.upload!(local_ipa_path, remote_ipa_path) do |event, _uploader, *_args|
+          case event
+          when :open then
+            putc '.'
+          when :put then
+            putc '.'
+            $stdout.flush
+          when :close then
+            puts "\n"
+          when :finish then
+            FastlaneCore::UI.success('IPA upload successful')
+          end
+        end
+      end
+
+      # Upload current manifest.json
+      #
+      # @param sftp
+      # @param [String] manifest_path
+      # @param [String] remote_manifest_path
+      def upload_manifest(sftp, local_path, remote_path)
+        msg = '[Uploading Manifest] ' + local_path + ' to ' + remote_path
+        FastlaneCore::UI.message(msg)
+        result = sftp.upload!(local_path, remote_path) do |event, _uploader, *_args|
+          case event
+          when :finish then
+            FastlaneCore::UI.success('Manifest upload successful')
+          end
+        end
+      end
+
+      def get_remote_ipa_path(local_ipa_path, appcode)
+        remote_path(appcode) + File.basename(local_ipa_path)
+      end
+
+      def remote_path(appcode)
+        generate_remote_path + appcode + '/'
+      end
+
+      def remote_manifest_path(appcode)
+        remote_manifest_path = remote_path(appcode) + 'manifest.json'
+      end
+
+      def generate_remote_path
+        '/home/' + user + '/repo/apps/'
+      end
+
+      def remote_mkdir(sftp, remote_path)
+        sftp.mkdir remote_path
+      rescue Net::SFTP::StatusException => e
+        raise if e.code != 11
+        msg = "Remote dir #{remote_path} exists."
+        FastlaneCore::UI.message(msg)
+      end
+
+      # Private methods - Local Operations
+
+      def load_rsa_key(rsa_keypath)
+        File.open(rsa_keypath, 'r') do |file|
+          rsa_key = nil
+          rsa_key = [file.read]
+          if !rsa_key.nil?
+            FastlaneCore::UI.success('Successfully loaded RSA key...')
+          else
+            FastlaneCore::UI.user_error!('Failed to load RSA key...')
+          end
+          rsa_key
+        end
+      end
+    end
+  end
+end