fastlane_hotfix 2.165.0

data/fastlane_core/lib/fastlane_core/ui/interface.rb

@@ -0,0 +1,205 @@
+require_relative 'errors'
+
+module FastlaneCore
+  # Abstract super class
+  class Interface
+    #####################################################
+    # @!group Messaging: show text to the user
+    #####################################################
+
+    # Level Error: Can be used to show additional error
+    #   information before actually raising an exception
+    #   or can be used to just show an error from which
+    #   fastlane can recover (much magic)
+    #
+    #   By default those messages are shown in red
+    def error(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Important: Can be used to show warnings to the user
+    #   not necessarily negative, but something the user should
+    #   be aware of.
+    #
+    #   By default those messages are shown in yellow
+    def important(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Success: Show that something was successful
+    #
+    #   By default those messages are shown in green
+    def success(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Message: Show a neutral message to the user
+    #
+    #   By default those messages shown in white/black
+    def message(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Deprecated: Show that a particular function is deprecated
+    #
+    #   By default those messages shown in strong blue
+    def deprecated(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Command: Print out a terminal command that is being
+    #   executed.
+    #
+    #   By default those messages shown in cyan
+    def command(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Command Output: Print the output of a command with
+    #   this method
+    #
+    #   By default those messages shown in magenta
+    def command_output(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Verbose: Print out additional information for the
+    #   users that are interested. Will only be printed when
+    #   FastlaneCore::Globals.verbose? = true
+    #
+    #   By default those messages are shown in white
+    def verbose(_message)
+      not_implemented(__method__)
+    end
+
+    # Print a header = a text in a box
+    #   use this if this message is really important
+    def header(_message)
+      not_implemented(__method__)
+    end
+
+    # Print lines of content around specific line where
+    #   failed to parse.
+    #
+    #   This message will be shown as error
+    def content_error(content, error_line)
+      not_implemented(__method__)
+    end
+
+    #####################################################
+    # @!group Errors: Inputs
+    #####################################################
+
+    # Is is possible to ask the user questions?
+    def interactive?
+      not_implemented(__method__)
+    end
+
+    # get a standard text input (single line)
+    def input(_message)
+      not_implemented(__method__)
+    end
+
+    # A simple yes or no question
+    def confirm(_message)
+      not_implemented(__method__)
+    end
+
+    # Let the user select one out of x items
+    # return value is the value of the option the user chose
+    def select(_message, _options)
+      not_implemented(__method__)
+    end
+
+    # Password input for the user, text field shouldn't show
+    # plain text
+    def password(_message)
+      not_implemented(__method__)
+    end
+
+    #####################################################
+    # @!group Abort helper methods
+    #####################################################
+
+    # Pass an exception to this method to exit the program
+    #   using the given exception
+    # Use this method instead of user_error! if this error is
+    # unexpected, e.g. an invalid server response that shouldn't happen
+    def crash!(exception)
+      raise FastlaneCrash.new, exception.to_s
+    end
+
+    # Use this method to exit the program because of an user error
+    #   e.g. app doesn't exist on the given Developer Account
+    #        or invalid user credentials
+    #        or scan tests fail
+    # This will show the error message, but doesn't show the full
+    #   stack trace
+    # Basically this should be used when you actively catch the error
+    # and want to show a nice error message to the user
+    def user_error!(error_message, options = {})
+      raise FastlaneError.new(options), error_message.to_s
+    end
+
+    # Use this method to exit the program because of a shell command
+    # failure -- the command returned a non-zero response. This does
+    # not specify the nature of the error. The error might be from a
+    # programming error, a user error, or an expected  error because
+    # the user of the Fastfile doesn't have their environment set up
+    # properly. Because of this, when these errors occur, it means
+    # that the caller of the shell command did not adequate error
+    # handling and the caller error handling should be improved.
+    def shell_error!(error_message, options = {})
+      raise FastlaneShellError.new(options), error_message.to_s
+    end
+
+    # Use this method to exit the program because of a build failure
+    # that's caused by the source code of the user. Example for this
+    # is that gym will fail when the code doesn't compile or because
+    # settings for the project are incorrect.
+    # By using this method we'll have more accurate results about
+    # fastlane failures
+    def build_failure!(error_message, options = {})
+      raise FastlaneBuildFailure.new(options), error_message.to_s
+    end
+
+    # Use this method to exit the program because of a test failure
+    # that's caused by the source code of the user. Example for this
+    # is that scan will fail when the tests fail.
+    # By using this method we'll have more accurate results about
+    # fastlane failures
+    def test_failure!(error_message)
+      raise FastlaneTestFailure.new, error_message
+    end
+
+    # Use this method to exit the program because of terminal state
+    # that is neither the fault of fastlane, nor a problem with the
+    # user's input. Using this method instead of user_error! will
+    # avoid tracking this outcome as a fastlane failure.
+    #
+    #   e.g. tests ran successfully, but no screenshots were found
+    #
+    # This will show the message, but hide the full stack trace.
+    def abort_with_message!(message)
+      raise FastlaneCommonException.new, message
+    end
+
+    #####################################################
+    # @!group Helpers
+    #####################################################
+    def not_implemented(method_name)
+      require_relative 'ui'
+      UI.user_error!("Current UI '#{self}' doesn't support method '#{method_name}'")
+    end
+
+    def to_s
+      self.class.name.split('::').last
+    end
+  end
+end
+
+class String
+  def deprecated
+    self.bold.blue
+  end
+end

data/fastlane_core/lib/fastlane_core/ui/ui.rb

@@ -0,0 +1,26 @@
+module FastlaneCore
+  class UI
+    class << self
+      attr_accessor(:ui_object)
+
+      def ui_object
+        require_relative 'implementations/shell'
+        @ui_object ||= Shell.new
+      end
+
+      def method_missing(method_sym, *args, &_block)
+        # not using `responds` because we don't care about methods like .to_s and so on
+        require_relative 'interface'
+        interface_methods = FastlaneCore::Interface.instance_methods - Object.instance_methods
+        UI.user_error!("Unknown method '#{method_sym}', supported #{interface_methods}") unless interface_methods.include?(method_sym)
+
+        self.ui_object.send(method_sym, *args)
+      end
+    end
+  end
+end
+
+# Import all available implementations
+Dir[File.dirname(__FILE__) + '/implementations/*.rb'].each do |file|
+  require_relative file
+end

data/fastlane_core/lib/fastlane_core/update_checker/changelog.rb

@@ -0,0 +1,37 @@
+require 'excon'
+
+module FastlaneCore
+  class Changelog
+    class << self
+      def show_changes(gem_name, current_version, update_gem_command: "bundle update")
+        did_show_changelog = false
+
+        self.releases(gem_name).each_with_index do |release, index|
+          next unless Gem::Version.new(release['tag_name']) > Gem::Version.new(current_version)
+          puts("")
+          puts(release['name'].green)
+          puts(release['body'])
+          did_show_changelog = true
+
+          next unless index == 2
+          puts("")
+          puts("To see all new releases, open https://github.com/fastlane/#{gem_name}/releases".green)
+          break
+        end
+
+        puts("")
+        puts("Please update using `#{update_gem_command}`".green) if did_show_changelog
+      rescue
+        # Something went wrong, we don't care so much about this
+      end
+
+      def releases(gem_name)
+        url = "https://api.github.com/repos/fastlane/#{gem_name}/releases"
+        # We have to follow redirects, since some repos were moved away into a separate org
+        server_response = Excon.get(url,
+                                    middlewares: Excon.defaults[:middlewares] + [Excon::Middleware::RedirectFollower])
+        JSON.parse(server_response.body)
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/update_checker/update_checker.rb

@@ -0,0 +1,109 @@
+require 'excon'
+require 'digest'
+
+require_relative 'changelog'
+require_relative '../analytics/app_identifier_guesser'
+require_relative '../helper'
+require_relative '../ui/ui'
+
+module FastlaneCore
+  # Verifies, the user runs the latest version of this gem
+  class UpdateChecker
+    def self.start_looking_for_update(gem_name)
+      return if Helper.test?
+      return if FastlaneCore::Env.truthy?("FASTLANE_SKIP_UPDATE_CHECK")
+
+      @start_time = Time.now
+
+      Thread.new do
+        begin
+          server_results[gem_name] = fetch_latest(gem_name)
+        rescue
+          # we don't want to show a stack trace if something goes wrong
+        end
+      end
+    end
+
+    def self.server_results
+      @results ||= {}
+    end
+
+    class << self
+      attr_reader :start_time
+    end
+
+    def self.update_available?(gem_name, current_version)
+      latest = server_results[gem_name]
+      return (latest and Gem::Version.new(latest) > Gem::Version.new(current_version))
+    end
+
+    def self.show_update_status(gem_name, current_version)
+      if update_available?(gem_name, current_version)
+        show_update_message(gem_name, current_version)
+      end
+    end
+
+    # Show a message to the user to update to a new version of fastlane (or a sub-gem)
+    # Use this method, as this will detect the current Ruby environment and show an
+    # appropriate message to the user
+    def self.show_update_message(gem_name, current_version)
+      available = server_results[gem_name]
+      puts("")
+      puts('#######################################################################')
+      if available
+        puts("# #{gem_name} #{available} is available. You are on #{current_version}.")
+      else
+        puts("# An update for #{gem_name} is available. You are on #{current_version}.")
+      end
+      puts("# You should use the latest version.")
+      puts("# Please update using `#{self.update_command(gem_name: gem_name)}`.")
+
+      puts("# To see what's new, open https://github.com/fastlane/#{gem_name}/releases.") if FastlaneCore::Env.truthy?("FASTLANE_HIDE_CHANGELOG")
+
+      if !Helper.bundler? && !Helper.contained_fastlane? && Random.rand(5) == 1
+        # We want to show this message from time to time, if the user doesn't use bundler, nor bundled fastlane
+        puts('#######################################################################')
+        puts("# Run `sudo gem cleanup` from time to time to speed up fastlane")
+      end
+      puts('#######################################################################')
+      Changelog.show_changes(gem_name, current_version, update_gem_command: UpdateChecker.update_command(gem_name: gem_name)) unless FastlaneCore::Env.truthy?("FASTLANE_HIDE_CHANGELOG")
+
+      ensure_rubygems_source
+    end
+
+    # The command that the user should use to update their mac
+    def self.update_command(gem_name: "fastlane")
+      if Helper.bundler?
+        "bundle update #{gem_name.downcase}"
+      elsif Helper.contained_fastlane? || Helper.homebrew?
+        "fastlane update_fastlane"
+      elsif Helper.mac_app?
+        "the Fabric app. Launch the app and navigate to the fastlane tab to get the most recent version."
+      else
+        "sudo gem install #{gem_name.downcase}"
+      end
+    end
+
+    # Check if RubyGems is set as a gem source
+    # on some machines that might not be the case
+    # and then users can't find the update when
+    # running the specified command
+    def self.ensure_rubygems_source
+      return if Helper.contained_fastlane?
+      return if `gem sources`.include?("https://rubygems.org")
+      puts("")
+      UI.error("RubyGems is not listed as your Gem source")
+      UI.error("You can run `gem sources` to see all your sources")
+      UI.error("Please run the following command to fix this:")
+      UI.command("gem sources --add https://rubygems.org")
+    end
+
+    def self.fetch_latest(gem_name)
+      JSON.parse(Excon.get(generate_fetch_url(gem_name)).body)["version"]
+    end
+
+    def self.generate_fetch_url(gem_name)
+      "https://rubygems.org/api/v1/gems/#{gem_name}.json"
+    end
+  end
+end

data/frameit/README.md

@@ -0,0 +1,17 @@
+<h3 align="center">
+  <a href="https://docs.fastlane.tools/actions/frameit/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/fastlane/assets/fastlane.png" width="100" />
+    <br />
+    fastlane
+  </a>
+</h3>
+
+------
+
+<p align="center">
+  <a href="https://docs.fastlane.tools/actions/frameit/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/frameit/assets/frameit.png" height="110">
+  </a>
+</p>
+
+<h3 align="center">The <i>frameit</i> docs were moved to <a href='https://docs.fastlane.tools/actions/frameit/'>docs.fastlane.tools</a></h3>

data/frameit/lib/frameit.rb

@@ -0,0 +1,13 @@
+require 'frameit/frame_downloader'
+require 'frameit/device_types'
+require 'frameit/runner'
+require 'frameit/screenshot'
+require 'frameit/config_parser'
+require 'frameit/offsets'
+require 'frameit/editor'
+require 'frameit/template_finder'
+require 'frameit/strings_parser'
+require 'frameit/mac_editor'
+require 'frameit/dependency_checker'
+require 'frameit/options'
+require 'frameit/trim_box'

data/frameit/lib/frameit/commands_generator.rb

@@ -0,0 +1,140 @@
+require 'commander'
+require 'fastlane/version'
+require 'fastlane_core/globals'
+require 'fastlane_core/configuration/configuration'
+
+require_relative 'device_types'
+require_relative 'runner'
+require_relative 'options'
+require_relative 'dependency_checker'
+require_relative 'device'
+
+HighLine.track_eof = false
+
+module Frameit
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      Frameit::DependencyChecker.check_dependencies
+      self.new.run
+    end
+
+    def run
+      program :name, 'frameit'
+      program :version, Fastlane::VERSION
+      program :description, 'Quickly put your screenshots into the right device frames'
+      program :help, 'Author', 'Felix Krause <frameit@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'Documentation', 'https://docs.fastlane.tools/actions/frameit/'
+      program :help_formatter, :compact
+
+      global_option('--verbose') { FastlaneCore::Globals.verbose = true }
+      global_option('--env STRING[,STRING2]', String, 'Add environment(s) to use with `dotenv`')
+
+      default_command(:run)
+
+      command :run do |c|
+        c.syntax = 'fastlane frameit black'
+        c.description = "Adds a black frame around all screenshots"
+
+        FastlaneCore::CommanderGenerator.new.generate(Frameit::Options.available_options, command: c)
+
+        c.action do |args, options|
+          load_config(options)
+          Frameit::Runner.new.run('.', nil)
+        end
+      end
+
+      command :silver do |c|
+        c.syntax = 'fastlane frameit silver'
+        c.description = "Adds a silver frame around all screenshots"
+
+        FastlaneCore::CommanderGenerator.new.generate(Frameit::Options.available_options, command: c)
+
+        c.action do |args, options|
+          load_config(options)
+          Frameit::Runner.new.run('.', Frameit::Color::SILVER)
+        end
+      end
+
+      command :gold do |c|
+        c.syntax = 'fastlane frameit gold'
+        c.description = "Adds a gold frame around all screenshots"
+
+        FastlaneCore::CommanderGenerator.new.generate(Frameit::Options.available_options, command: c)
+
+        c.action do |args, options|
+          load_config(options)
+          Frameit::Runner.new.run('.', Frameit::Color::GOLD)
+        end
+      end
+
+      command :rose_gold do |c|
+        c.syntax = 'fastlane frameit rose_gold'
+        c.description = "Adds a rose gold frame around all screenshots"
+
+        FastlaneCore::CommanderGenerator.new.generate(Frameit::Options.available_options, command: c)
+
+        c.action do |args, options|
+          load_config(options)
+          Frameit::Runner.new.run('.', Frameit::Color::ROSE_GOLD)
+        end
+      end
+
+      command :android do |c|
+        c.syntax = 'fastlane frameit android'
+        c.description = "Adds Android frames around all screenshots"
+
+        FastlaneCore::CommanderGenerator.new.generate(Frameit::Options.available_options, command: c)
+
+        c.action do |args, options|
+          load_config(options)
+          Frameit::Runner.new.run('.', nil, Platform::ANDROID)
+        end
+      end
+
+      command :ios do |c|
+        c.syntax = 'fastlane frameit ios'
+        c.description = "Adds iOS frames around all screenshots"
+
+        FastlaneCore::CommanderGenerator.new.generate(Frameit::Options.available_options, command: c)
+
+        c.action do |args, options|
+          load_config(options)
+          Frameit::Runner.new.run('.', nil, Platform::IOS)
+        end
+      end
+
+      command :setup do |c|
+        c.syntax = 'fastlane frameit setup'
+        c.description = "Downloads and sets up the latest device frames"
+
+        c.action do |args, options|
+          Frameit::FrameDownloader.new.download_frames
+        end
+      end
+
+      command :download_frames do |c|
+        c.syntax = 'fastlane frameit download_frames'
+        c.description = "Downloads and sets up the latest device frames"
+
+        c.action do |args, options|
+          Frameit::FrameDownloader.new.download_frames
+        end
+      end
+
+      alias_command(:white, :silver)
+
+      run!
+    end
+
+    private
+
+    def load_config(options)
+      o = options.__hash__.dup
+      o.delete(:verbose)
+      Frameit.config = FastlaneCore::Configuration.create(Frameit::Options.available_options, o)
+    end
+  end
+end