fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/lane_manager.rb

@@ -0,0 +1,140 @@
+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
+    # rubocop:disable Metrics/PerceivedComplexity
+    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
+
+      # xcodeproj has a bug in certain versions that causes it to change directories
+      # and not return to the original working directory
+      # https://github.com/CocoaPods/Xcodeproj/issues/426
+      # Setting this environment variable causes xcodeproj to work around the problem
+      ENV["FORK_XCODE_WRITING"] = "true" unless platform == 'android'
+
+      Fastlane::Helper::DotenvHelper.load_dot_env(env)
+
+      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
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    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 setup to do:")
+
+      puts(table)
+
+      i = UI.input("Which number would you like 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 #{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` 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/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

data/fastlane/lib/fastlane/other_action.rb

@@ -0,0 +1,29 @@
+module Fastlane
+  # This class is used to call other actions from within actions
+  # We use a separate class so that we can easily identify when
+  # we have dependencies between actions
+  class OtherAction
+    attr_accessor :runner
+
+    def initialize(runner)
+      self.runner = runner
+    end
+
+    # Allows the user to call an action from an action
+    def method_missing(method_sym, *arguments, &_block)
+      # We have to go inside the fastlane directory
+      # since in the fastlane runner.rb we do the following
+      #   custom_dir = ".."
+      #   Dir.chdir(custom_dir) do
+      # this goes one folder up, since we're inside the "fastlane"
+      # folder at that point
+      # Since we call an action from an action we need to go inside
+      # the fastlane folder too
+
+      self.runner.trigger_action_by_name(method_sym,
+                                         FastlaneCore::FastlaneFolder.path,
+                                         true,
+                                         *arguments)
+    end
+  end
+end

data/fastlane/lib/fastlane/plugins/plugin_fetcher.rb

@@ -0,0 +1,55 @@
+module Fastlane
+  # Use the RubyGems API to get all fastlane plugins
+  class PluginFetcher
+    require 'fastlane_core'
+    require 'fastlane/plugins/plugin_manager'
+
+    # Returns an array of FastlanePlugin objects
+    def self.fetch_gems(search_query: nil)
+      require 'json'
+      require 'open-uri'
+
+      page = 1
+      plugins = []
+      loop do
+        url = "https://rubygems.org/api/v1/search.json?query=#{PluginManager.plugin_prefix}&page=#{page}"
+        FastlaneCore::UI.verbose("RubyGems API Request: #{url}")
+        results = JSON.parse(open(url).read)
+        break if results.count == 0
+
+        plugins += results.collect do |current|
+          FastlanePlugin.new(current)
+        end
+        page += 1
+      end
+
+      return plugins if search_query.to_s.length == 0
+      plugins.keep_if do |current|
+        current.full_name.include?(search_query) or current.info.include?(search_query)
+      end
+
+      return plugins
+    end
+  end
+
+  class FastlanePlugin
+    attr_accessor :full_name
+    attr_accessor :name
+    attr_accessor :downloads
+    attr_accessor :info
+    attr_accessor :homepage
+
+    def initialize(hash)
+      self.full_name = hash["name"]
+      self.name = self.full_name.gsub(PluginManager.plugin_prefix, '')
+      self.downloads = hash["downloads"]
+      self.info = hash["info"]
+      self.homepage = hash["homepage_uri"]
+    end
+
+    def linked_title
+      return "`#{name}`" if homepage.to_s.length == 0
+      return "[#{name}](#{homepage})"
+    end
+  end
+end