fastlane-plugin-apprepo 0.5.4 → 0.5.5

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

@@ -1,29 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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 server'),
-           FastlaneCore::ConfigItem.new(key: :repo_port,
-                                        short_option: '-P',
-                                        optional: false,
-                                        env_name: 'APPREPO_PORT',
-                                        description: 'SSH port of your server'),
-          FastlaneCore::ConfigItem.new(key: :repo_user,
-                                       short_option: '-u',
-                                       optional: false,
-                                       env_name: 'APPREPO_USER',
-                                       description: 'USER of your server'),
-          FastlaneCore::ConfigItem.new(key: :repo_password,
-                                       short_option: '-p',
-                                       optional: true,
-                                       env_name: 'APPREPO_PASSWORD',
-                                       description: 'PASSWORD for your 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

@@ -1,68 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,306 +0,0 @@
-#!/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 :port
-      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.port = options[:repo_port]
-        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, port: port,  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, port: port,  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, port: port,  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, port: port,  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)
-          FastlaneCore::UI.command_output('Uploading IPA...')
-          upload_ipa(sftp, local_ipa_path, remote_ipa_path)
-          FastlaneCore::UI.command_output('Uploading manifest...')
-          upload_manifest(sftp, manifest_path, remote_manifest_path(appcode))
-          FastlaneCore::UI.command_output('Verification...')
-          # 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_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