fastlane-mercafacil 2.214.0

data/fastlane/lib/fastlane/junit_generator.rb

@@ -0,0 +1,27 @@
+module Fastlane
+  class JUnitGenerator
+    def self.generate(results)
+      # JUnit file documentation: http://llg.cubic.org/docs/junit/
+      # And http://nelsonwells.net/2012/09/how-jenkins-ci-parses-and-displays-junit-output/
+      # And http://windyroad.com.au/dl/Open%20Source/JUnit.xsd
+
+      containing_folder = ENV['FL_REPORT_PATH'] || FastlaneCore::FastlaneFolder.path || Dir.pwd
+      path = File.join(containing_folder, 'report.xml')
+
+      @steps = results
+      xml_path = File.join(Fastlane::ROOT, "lib/assets/report_template.xml.erb")
+      xml = ERB.new(File.read(xml_path)).result(binding) # https://web.archive.org/web/20160430190141/www.rrn.dk/rubys-erb-templating-system
+
+      xml = xml.gsub('system_', 'system-').delete("\e") # Jenkins can not parse 'ESC' symbol
+
+      begin
+        File.write(path, xml)
+      rescue => ex
+        UI.error(ex)
+        UI.error("Couldn't save report.xml at path '#{File.expand_path(path)}', make sure you have write access to the containing directory.")
+      end
+
+      return path
+    end
+  end
+end

data/fastlane/lib/fastlane/lane.rb

@@ -0,0 +1,97 @@
+module Fastlane
+  # Represents a lane
+  class Lane
+    attr_accessor :platform
+
+    attr_accessor :name
+
+    # @return [Array] An array containing the description of this lane
+    #   Each item of the array is one line
+    attr_accessor :description
+
+    attr_accessor :block
+
+    # @return [Boolean] Is that a private lane that can't be called from the CLI?
+    attr_accessor :is_private
+
+    def initialize(platform: nil, name: nil, description: nil, block: nil, is_private: false)
+      UI.user_error!("description must be an array") unless description.kind_of?(Array)
+      UI.user_error!("lane name must not contain any spaces") if name.to_s.include?(" ")
+      UI.user_error!("lane name must start with :") unless name.kind_of?(Symbol)
+
+      self.class.verify_lane_name(name)
+
+      self.platform = platform
+      self.name = name
+      self.description = description
+      self.block = block
+      self.is_private = is_private
+    end
+
+    # Execute this lane
+    def call(parameters)
+      block.call(parameters || {})
+    end
+
+    # @return [String] The lane + name of the lane. If there is no platform, it will only be the lane name
+    def pretty_name
+      [platform, name].reject(&:nil?).join(' ')
+    end
+
+    class << self
+      # Makes sure the lane name is valid
+      def verify_lane_name(name)
+        if self.deny_list.include?(name.to_s)
+          UI.error("Lane name '#{name}' is invalid! Invalid names are #{self.deny_list.join(', ')}.")
+          UI.user_error!("Lane name '#{name}' is invalid")
+        end
+
+        if self.gray_list.include?(name.to_sym)
+          UI.error("------------------------------------------------")
+          UI.error("Lane name '#{name}' should not be used because it is the name of a fastlane tool")
+          UI.error("It is recommended to not use '#{name}' as the name of your lane")
+          UI.error("------------------------------------------------")
+          # We still allow it, because we're nice
+          # Otherwise we might break existing setups
+          return
+        end
+
+        self.ensure_name_not_conflicts(name.to_s)
+      end
+
+      def deny_list
+        %w(
+          run
+          init
+          new_action
+          lanes
+          list
+          docs
+          action
+          actions
+          enable_auto_complete
+          new_plugin
+          add_plugin
+          install_plugins
+          update_plugins
+          search_plugins
+          help
+          env
+          update_fastlane
+        )
+      end
+
+      def gray_list
+        Fastlane::TOOLS
+      end
+
+      def ensure_name_not_conflicts(name)
+        # First, check if there is a predefined method in the actions folder
+        return unless Actions.action_class_ref(name)
+        UI.error("------------------------------------------------")
+        UI.error("Name of the lane '#{name}' is already taken by the action named '#{name}'")
+        UI.error("------------------------------------------------")
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/lane_list.rb

@@ -0,0 +1,137 @@
+module Fastlane
+  class LaneList
+    # Print out the result of `generate`
+    SWIFT_FUNCTION_REGEX = /\s*func\s*(\w*)\s*\((.*)\)\s*/
+    SWIFT_DESC_REGEX = /\s*desc\s*\(\s*"(.*)"\s*\)\s*/
+    def self.output(path)
+      puts(generate(path))
+
+      puts("Execute using `fastlane [lane_name]`".yellow)
+    end
+
+    def self.generate_swift_lanes(path)
+      return unless (path || '').length > 0
+      UI.user_error!("Could not find Fastfile.swift at path '#{path}'") unless File.exist?(path)
+      path = File.expand_path(path)
+      lane_content = File.read(path)
+
+      current_lane_name = nil
+      lanes_by_name = {}
+
+      lane_content.split("\n").reject(&:empty?).each do |line|
+        line.strip!
+        if line.start_with?("func") && (current_lane_name = self.lane_name_from_swift_line(potential_lane_line: line))
+          lanes_by_name[current_lane_name] = Fastlane::Lane.new(platform: nil, name: current_lane_name.to_sym, description: [])
+        elsif line.start_with?("desc")
+          lane_description = self.desc_entry_for_swift_lane(named: current_lane_name, potential_desc_line: line)
+          unless lane_description
+            next
+          end
+
+          lanes_by_name[current_lane_name].description = [lane_description]
+          current_lane_name = nil
+        end
+      end
+      # "" because that will be interpreted as general platform
+      # (we don't detect platform right now)
+      return { "" => lanes_by_name }
+    end
+
+    def self.desc_entry_for_swift_lane(named: nil, potential_desc_line: nil)
+      unless named
+        return nil
+      end
+
+      desc_match = SWIFT_DESC_REGEX.match(potential_desc_line)
+      unless desc_match
+        return nil
+      end
+
+      return desc_match[1]
+    end
+
+    def self.lane_name_from_swift_line(potential_lane_line: nil)
+      function_name_match = SWIFT_FUNCTION_REGEX.match(potential_lane_line)
+      unless function_name_match
+        return nil
+      end
+
+      unless function_name_match[1].downcase.end_with?("lane")
+        return nil
+      end
+
+      return function_name_match[1]
+    end
+
+    def self.generate(path)
+      lanes = {}
+      if FastlaneCore::FastlaneFolder.swift?
+        lanes = generate_swift_lanes(path)
+      else
+        ff = Fastlane::FastFile.new(path)
+        lanes = ff.runner.lanes
+      end
+
+      output = ""
+
+      all_keys = lanes.keys.reject(&:nil?)
+      all_keys.unshift(nil) # because we want root elements on top. always! They have key nil
+
+      all_keys.each do |platform|
+        next if (lanes[platform] || []).count == 0
+
+        plat_text = platform
+        plat_text = "general" if platform.to_s.empty?
+        output += "\n--------- #{plat_text}---------\n".yellow
+
+        value = lanes[platform]
+        next unless value
+
+        value.each do |lane_name, lane|
+          next if lane.is_private
+
+          output += "----- fastlane #{lane.pretty_name}".green
+          if lane.description.count > 0
+            output += "\n" + lane.description.join("\n") + "\n\n"
+          else
+            output += "\n\n"
+          end
+        end
+      end
+
+      output
+    end
+
+    def self.output_json(path)
+      puts(JSON.pretty_generate(self.generate_json(path)))
+    end
+
+    # Returns a hash
+    def self.generate_json(path)
+      output = {}
+      return output if path.nil?
+      ff = Fastlane::FastFile.new(path)
+
+      all_keys = ff.runner.lanes.keys
+
+      all_keys.each do |platform|
+        next if (ff.runner.lanes[platform] || []).count == 0
+
+        output[platform] ||= {}
+
+        value = ff.runner.lanes[platform]
+        next unless value
+
+        value.each do |lane_name, lane|
+          next if lane.is_private
+
+          output[platform][lane_name] = {
+            description: lane.description.join("\n")
+          }
+        end
+      end
+
+      return output
+    end
+  end
+end

data/fastlane/lib/fastlane/lane_manager.rb

@@ -0,0 +1,131 @@
+require_relative 'lane_manager_base.rb'
+
+module Fastlane
+  class LaneManager < LaneManagerBase
+    # @param platform The name of the platform to execute
+    # @param lane_name The name of the lane to execute
+    # @param parameters [Hash] The parameters passed from the command line to the lane
+    # @param env Dot Env Information
+    # @param A custom Fastfile path, this is used by fastlane.ci
+    def self.cruise_lane(platform, lane, parameters = nil, env = nil, fastfile_path = nil)
+      UI.user_error!("lane must be a string") unless lane.kind_of?(String) || lane.nil?
+      UI.user_error!("platform must be a string") unless platform.kind_of?(String) || platform.nil?
+      UI.user_error!("parameters must be a hash") unless parameters.kind_of?(Hash) || parameters.nil?
+
+      ff = Fastlane::FastFile.new(fastfile_path || FastlaneCore::FastlaneFolder.fastfile_path)
+
+      is_platform = false
+      begin
+        is_platform = ff.is_platform_block?(lane)
+      rescue # rescue, because this raises an exception if it can't be found at all
+      end
+
+      unless is_platform
+        # maybe the user specified a default platform
+        # We'll only do this, if the lane specified isn't a platform, as we want to list all platforms then
+
+        # Make sure that's not a lane without a platform
+        unless ff.runner.available_lanes.include?(lane)
+          platform ||= Actions.lane_context[Actions::SharedValues::DEFAULT_PLATFORM]
+        end
+      end
+
+      if !platform && lane
+        # Either, the user runs a specific lane in root or want to auto complete the available lanes for a platform
+        # e.g. `fastlane ios` should list all available iOS actions
+        if ff.is_platform_block?(lane)
+          platform = lane
+          lane = nil
+        end
+      end
+
+      platform, lane = choose_lane(ff, platform) unless lane
+
+      started = Time.now
+      e = nil
+      begin
+        ff.runner.execute(lane, platform, parameters)
+      rescue NameError => ex
+        print_lane_context
+        print_error_line(ex)
+        e = ex
+      rescue Exception => ex # rubocop:disable Lint/RescueException
+        # We also catch Exception, since the implemented action might send a SystemExit signal
+        # (or similar). We still want to catch that, since we want properly finish running fastlane
+        # Tested with `xcake`, which throws a `Xcake::Informative` object
+
+        print_lane_context
+        print_error_line(ex)
+        UI.error(ex.to_s) if ex.kind_of?(StandardError) # we don't want to print things like 'system exit'
+        e = ex
+      end
+
+      # After running the lanes, since skip_docs might be somewhere in-between
+      Fastlane::DocsGenerator.run(ff) unless skip_docs?
+
+      duration = ((Time.now - started) / 60.0).round
+      finish_fastlane(ff, duration, e)
+
+      return ff
+    end
+
+    def self.skip_docs?
+      Helper.test? || FastlaneCore::Env.truthy?("FASTLANE_SKIP_DOCS")
+    end
+
+    # Lane chooser if user didn't provide a lane
+    # @param platform: is probably nil, but user might have called `fastlane android`, and only wants to list those actions
+    def self.choose_lane(ff, platform)
+      available = []
+
+      # nil is the key for lanes that are not under a specific platform
+      lane_platforms = [nil] + Fastlane::SupportedPlatforms.all
+      lane_platforms.each do |p|
+        available += ff.runner.lanes[p].to_a.reject { |lane| lane.last.is_private }
+      end
+
+      if available.empty?
+        UI.user_error!("It looks like you don't have any lanes to run just yet. Check out how to get started here: https://github.com/fastlane/fastlane 🚀")
+      end
+
+      rows = []
+      available.each_with_index do |lane, index|
+        rows << [index + 1, lane.last.pretty_name, lane.last.description.join("\n")]
+      end
+
+      rows << [0, "cancel", "No selection, exit fastlane!"]
+
+      require 'terminal-table'
+
+      table = Terminal::Table.new(
+        title: "Available lanes to run",
+        headings: ['Number', 'Lane Name', 'Description'],
+        rows: FastlaneCore::PrintTable.transform_output(rows)
+      )
+
+      UI.message("Welcome to fastlane! Here's what your app is set up to do:")
+
+      puts(table)
+
+      fastlane_command = Helper.bundler? ? "bundle exec fastlane" : "fastlane"
+      i = UI.input("Which number would you like to run?")
+
+      i = i.to_i - 1
+      if i >= 0 && available[i]
+        selection = available[i].last.pretty_name
+        UI.important("Running lane `#{selection}`. Next time you can do this by directly typing `#{fastlane_command} #{selection}` 🚀.")
+        platform = selection.split(' ')[0]
+        lane_name = selection.split(' ')[1]
+
+        unless lane_name # no specific platform, just a root lane
+          lane_name = platform
+          platform = nil
+        end
+
+        return platform, lane_name # yeah
+      else
+        UI.user_error!("Run `#{fastlane_command}` the next time you need to build, test or release your app 🚀")
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/lane_manager_base.rb

@@ -0,0 +1,92 @@
+module Fastlane
+  # Base class for all LaneManager classes
+  # Takes care of all common things like printing the lane description tables and loading .env files
+  class LaneManagerBase
+    def self.skip_docs?
+      Helper.test? || FastlaneCore::Env.truthy?("FASTLANE_SKIP_DOCS")
+    end
+
+    # All the finishing up that needs to be done
+    def self.finish_fastlane(ff, duration, error, skip_message: false)
+      # Sometimes we don't have a fastfile because we're using Fastfile.swift
+      unless ff.nil?
+        ff.runner.did_finish
+      end
+
+      # Finished with all the lanes
+      Fastlane::JUnitGenerator.generate(Fastlane::Actions.executed_actions)
+      print_table(Fastlane::Actions.executed_actions)
+
+      Fastlane::PluginUpdateManager.show_update_status
+
+      if error
+        UI.error('fastlane finished with errors') unless skip_message
+        raise error
+      elsif duration > 5
+        UI.success("fastlane.tools just saved you #{duration} minutes! 🎉") unless skip_message
+      else
+        UI.success('fastlane.tools finished successfully 🎉') unless skip_message
+      end
+    end
+
+    # Print a table as summary of the executed actions
+    def self.print_table(actions)
+      return if actions.count == 0
+      return if FastlaneCore::Env.truthy?('FASTLANE_SKIP_ACTION_SUMMARY') # User disabled table output
+
+      require 'terminal-table'
+
+      rows = []
+      actions.each_with_index do |current, i|
+        is_error_step = !current[:error].to_s.empty?
+
+        name = current[:name][0..60]
+        name = name.red if is_error_step
+        index = i + 1
+        index = "💥" if is_error_step
+        rows << [index, name, current[:time].to_i]
+      end
+
+      puts("")
+      puts(Terminal::Table.new(
+             title: "fastlane summary".green,
+             headings: ["Step", "Action", "Time (in s)"],
+             rows: FastlaneCore::PrintTable.transform_output(rows)
+      ))
+      puts("")
+    end
+
+    def self.print_lane_context
+      return if Actions.lane_context.empty?
+
+      if FastlaneCore::Globals.verbose?
+        UI.important('Lane Context:'.yellow)
+        UI.message(Actions.lane_context)
+        return
+      end
+
+      # Print a nice table unless in FastlaneCore::Globals.verbose? mode
+      rows = Actions.lane_context.collect do |key, content|
+        [key, content.to_s]
+      end
+
+      require 'terminal-table'
+      puts(Terminal::Table.new({
+        title: "Lane Context".yellow,
+        rows: FastlaneCore::PrintTable.transform_output(rows)
+      }))
+    end
+
+    def self.print_error_line(ex)
+      error_line = ex.backtrace.first
+      return if error_line.nil?
+
+      error_line = error_line.match("Fastfile:(\\d+):")
+      return unless error_line
+
+      line = error_line[1]
+      UI.error("Error in your Fastfile at line #{line}")
+      UI.content_error(File.read(FastlaneCore::FastlaneFolder.fastfile_path, encoding: "utf-8"), line)
+    end
+  end
+end

data/fastlane/lib/fastlane/markdown_table_formatter.rb

@@ -0,0 +1,62 @@
+module Fastlane
+  class MarkdownTableFormatter
+    # taken from: https://github.com/benbalter/markdown-table-formatter
+    def initialize(string, header = true)
+      @doc = string
+      @header = header
+    end
+
+    # converts the markdown string into an array of arrays
+    def parse
+      @table = []
+      rows = @doc.split(/\r?\n/)
+      rows.each do |row|
+        row_array = row.split("|")
+        row_array.each(&:strip!)
+        @table.push(row_array)
+      end
+      @table.delete_at(1) if @header # strip header separator
+      @table
+    end
+
+    def table
+      @table ||= parse
+    end
+
+    def column_width(column)
+      width = 0
+      table.each do |row|
+        length = row[column].strip.length
+        width = length if length > width
+      end
+      width
+    end
+
+    def pad(string, length)
+      string.strip.ljust(length, ' ')
+    end
+
+    def separator(length)
+      "".ljust(length, '-')
+    end
+
+    def header_separator_row
+      output = []
+      [*0...table.first.length].each do |column|
+        output.push(separator(column_width(column)))
+      end
+      output
+    end
+
+    def to_md
+      output = ""
+      t = table.clone
+      t.insert(1, header_separator_row) if @header
+      t.each_with_index do |row, index|
+        row.map!.with_index { |cell_row, index_row| pad(cell_row, column_width(index_row)) }
+        output += "#{row.join(' | ').lstrip} |\n"
+      end
+      output
+    end
+  end
+end

data/fastlane/lib/fastlane/new_action.rb

@@ -0,0 +1,47 @@
+module Fastlane
+  # Guides the new user through creating a new action
+  module NewAction
+    def self.run(new_action_name: nil)
+      name = new_action_name && check_action_name_from_args(new_action_name) ? new_action_name : fetch_name
+      generate_action(name)
+    end
+
+    def self.fetch_name
+      puts("Must be lower case, and use a '_' between words. Do not use '.'".green)
+      puts("examples: 'testflight', 'upload_to_s3'".green)
+      name = UI.input("Name of your action: ")
+      until name_valid?(name)
+        puts("Name is invalid. Please ensure the name is all lowercase, free of spaces and without special characters! Try again.")
+        name = UI.input("Name of your action: ")
+      end
+      name
+    end
+
+    def self.generate_action(name)
+      template = File.read("#{Fastlane::ROOT}/lib/assets/custom_action_template.rb")
+      template.gsub!('[[NAME]]', name)
+      template.gsub!('[[NAME_UP]]', name.upcase)
+      template.gsub!('[[NAME_CLASS]]', name.fastlane_class + 'Action')
+
+      actions_path = File.join((FastlaneCore::FastlaneFolder.path || Dir.pwd), 'actions')
+      FileUtils.mkdir_p(actions_path) unless File.directory?(actions_path)
+
+      path = File.join(actions_path, "#{name}.rb")
+      File.write(path, template)
+      UI.success("Created new action file '#{path}'. Edit it to implement your custom action.")
+    end
+
+    def self.check_action_name_from_args(new_action_name)
+      if name_valid?(new_action_name)
+        new_action_name
+      else
+        puts("Name is invalid. Please ensure the name is all lowercase, free of spaces and without special characters! Try again.")
+      end
+    end
+
+    def self.name_valid?(name)
+      name =~ /^[a-z0-9_]+$/
+    end
+    private_class_method :name_valid?
+  end
+end

data/fastlane/lib/fastlane/notification/slack.rb

@@ -0,0 +1,56 @@
+module Fastlane
+  module Notification
+    class Slack
+      def initialize(webhook_url)
+        @webhook_url = webhook_url
+        @client = Faraday.new do |conn|
+          conn.use(Faraday::Response::RaiseError)
+        end
+      end
+
+      # Overriding channel, icon_url and username is only supported in legacy incoming webhook.
+      # Also note that the use of attachments has been discouraged by Slack, in favor of Block Kit.
+      # https://api.slack.com/legacy/custom-integrations/messaging/webhooks
+      def post_to_legacy_incoming_webhook(channel:, username:, attachments:, link_names:, icon_url:)
+        @client.post(@webhook_url) do |request|
+          request.headers['Content-Type'] = 'application/json'
+          request.body = {
+            channel: channel,
+            username: username,
+            icon_url: icon_url,
+            attachments: attachments,
+            link_names: link_names
+          }.to_json
+        end
+      end
+
+      # This class was inspired by `LinkFormatter` in `slack-notifier` gem
+      # https://github.com/stevenosloan/slack-notifier/blob/4bf6582663dc9e5070afe3fdc42d67c14a513354/lib/slack-notifier/util/link_formatter.rb
+      class LinkConverter
+        HTML_PATTERN = %r{<a.*?href=['"](?<link>#{URI.regexp})['"].*?>(?<label>.+?)<\/a>}
+        MARKDOWN_PATTERN = /\[(?<label>[^\[\]]*?)\]\((?<link>#{URI.regexp}|mailto:#{URI::MailTo::EMAIL_REGEXP})\)/
+
+        def self.convert(string)
+          convert_markdown_to_slack_link(convert_html_to_slack_link(string.scrub))
+        end
+
+        def self.convert_html_to_slack_link(string)
+          string.gsub(HTML_PATTERN) do |match|
+            slack_link(Regexp.last_match[:link], Regexp.last_match[:label])
+          end
+        end
+
+        def self.convert_markdown_to_slack_link(string)
+          string.gsub(MARKDOWN_PATTERN) do |match|
+            slack_link(Regexp.last_match[:link], Regexp.last_match[:label])
+          end
+        end
+
+        def self.slack_link(href, text)
+          return "<#{href}>" if text.nil? || text.empty?
+          "<#{href}|#{text}>"
+        end
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/one_off.rb

@@ -0,0 +1,45 @@
+module Fastlane
+  # Call actions without triggering a full lane
+  class OneOff
+    def self.execute(args: nil)
+      action_parameters = {}
+      action_name = nil
+
+      args.each do |current|
+        if current.include?(":") # that's a key/value which we want to pass to the lane
+          key, value = current.split(":", 2)
+          UI.user_error!("Please pass values like this: key:value") unless key.length > 0
+          value = CommandLineHandler.convert_value(value)
+          UI.verbose("Using #{key}: #{value}")
+          action_parameters[key.to_sym] = value
+        else
+          action_name ||= current
+        end
+      end
+
+      UI.crash!("invalid syntax") unless action_name
+
+      run(action: action_name,
+          parameters: action_parameters)
+    end
+
+    def self.run(action: nil, parameters: nil)
+      Fastlane.load_actions
+
+      class_ref = Actions.action_class_ref(action)
+      unless class_ref
+        if Fastlane::Actions.formerly_bundled_actions.include?(action)
+          # This was a formerly bundled action which is now a plugin.
+          UI.verbose(caller.join("\n"))
+          UI.user_error!("The action '#{action}' is no longer bundled with fastlane. You can install it using `fastlane add_plugin #{action}`")
+        else
+          Fastlane::ActionsList.print_suggestions(action)
+          UI.user_error!("Action '#{action}' not available, run `fastlane actions` to get a full list")
+        end
+      end
+
+      r = Runner.new
+      r.execute_action(action, class_ref, [parameters], custom_dir: '.')
+    end
+  end
+end