fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/helper/gradle_helper.rb

@@ -0,0 +1,62 @@
+module Fastlane
+  module Helper
+    class GradleTask
+      attr_accessor :title
+
+      attr_accessor :description
+
+      def initialize(title: nil, description: nil)
+        self.title = title
+        self.description = description
+      end
+    end
+
+    class GradleHelper
+      # Path to the gradle script
+      attr_accessor :gradle_path
+
+      # Read-only path to the shell-escaped gradle script, suitable for use in shell commands
+      attr_reader :escaped_gradle_path
+
+      # All the available tasks
+      attr_accessor :tasks
+
+      def initialize(gradle_path: nil)
+        self.gradle_path = gradle_path
+      end
+
+      # Run a certain action
+      def trigger(task: nil, flags: nil, serial: nil, print_command: true, print_command_output: true)
+        android_serial = (serial != "") ? "ANDROID_SERIAL=#{serial}" : nil
+        command = [android_serial, escaped_gradle_path, task, flags].compact.join(" ")
+        Action.sh(command, print_command: print_command, print_command_output: print_command_output)
+      end
+
+      def task_available?(task)
+        load_all_tasks
+        return tasks.collect(&:title).include?(task)
+      end
+
+      def gradle_path=(gradle_path)
+        @gradle_path = gradle_path
+        @escaped_gradle_path = gradle_path.shellescape
+      end
+
+      private
+
+      def load_all_tasks
+        self.tasks = []
+
+        command = [escaped_gradle_path, "tasks", "--console=plain"].join(" ")
+        output = Action.sh(command, print_command: false, print_command_output: false)
+        output.split("\n").each do |line|
+          if (result = line.match(/(\w+)\s\-\s([\w\s]+)/))
+            self.tasks << GradleTask.new(title: result[1], description: result[2])
+          end
+        end
+
+        self.tasks
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/podspec_helper.rb

@@ -0,0 +1,75 @@
+module Fastlane
+  module Helper
+    class PodspecHelper
+      attr_accessor :path
+      attr_accessor :podspec_content
+      attr_accessor :version_regex
+      attr_accessor :version_match
+      attr_accessor :version_value
+
+      def initialize(path = nil, require_variable_prefix = true)
+        version_var_name = 'version'
+        variable_prefix = require_variable_prefix ? /\w\./ : //
+        @version_regex = /^(?<begin>[^#]*#{variable_prefix}#{version_var_name}\s*=\s*['"])(?<value>(?<major>[0-9]+)(\.(?<minor>[0-9]+))?(\.(?<patch>[0-9]+))?(?<appendix>(\.[0-9]+)*)?(-(?<prerelease>(.+)))?)(?<end>['"])/i
+
+        return unless (path || '').length > 0
+        UI.user_error!("Could not find podspec file at path '#{path}'") unless File.exist?(path)
+
+        @path = File.expand_path(path)
+        podspec_content = File.read(path)
+
+        parse(podspec_content)
+      end
+
+      def parse(podspec_content)
+        @podspec_content = podspec_content
+        @version_match = @version_regex.match(@podspec_content)
+        UI.user_error!("Could not find version in podspec content '#{@podspec_content}'") if @version_match.nil?
+        @version_value = @version_match[:value]
+      end
+
+      def bump_version(bump_type)
+        UI.user_error!("Do not support bump of 'appendix', please use `update_version_appendix(appendix)` instead") if bump_type == 'appendix'
+
+        major = version_match[:major].to_i
+        minor = version_match[:minor].to_i || 0
+        patch = version_match[:patch].to_i || 0
+
+        case bump_type
+        when 'patch'
+          patch += 1
+        when 'minor'
+          minor += 1
+          patch = 0
+        when 'major'
+          major += 1
+          minor = 0
+          patch = 0
+        end
+
+        @version_value = "#{major}.#{minor}.#{patch}"
+      end
+
+      def update_version_appendix(appendix = nil)
+        new_appendix = appendix || @version_value[:appendix]
+        return if new_appendix.nil?
+
+        new_appendix = new_appendix.sub(".", "") if new_appendix.start_with?(".")
+        major = version_match[:major].to_i
+        minor = version_match[:minor].to_i || 0
+        patch = version_match[:patch].to_i || 0
+
+        @version_value = "#{major}.#{minor}.#{patch}.#{new_appendix}"
+      end
+
+      def update_podspec(version = nil)
+        new_version = version || @version_value
+        updated_podspec_content = @podspec_content.gsub(@version_regex, "#{@version_match[:begin]}#{new_version}#{@version_match[:end]}")
+
+        File.open(@path, "w") { |file| file.puts(updated_podspec_content) } unless Helper.test?
+
+        updated_podspec_content
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/sh_helper.rb

@@ -0,0 +1,134 @@
+require "open3"
+
+module Fastlane
+  module Actions
+    # Execute a shell command
+    # This method will output the string and execute it
+    # Just an alias for sh_no_action
+    # When running this in tests, it will return the actual command instead of executing it
+    # @param log [Boolean] should fastlane print out the executed command
+    # @param error_callback [Block] a callback invoked with the command output if there is a non-zero exit status
+    def self.sh(*command, log: true, error_callback: nil, &b)
+      sh_control_output(*command, print_command: log, print_command_output: log, error_callback: error_callback, &b)
+    end
+
+    def self.sh_no_action(*command, log: true, error_callback: nil, &b)
+      sh_control_output(*command, print_command: log, print_command_output: log, error_callback: error_callback, &b)
+    end
+
+    # @param command The command to be executed (variadic)
+    # @param print_command [Boolean] Should we print the command that's being executed
+    # @param print_command_output [Boolean] Should we print the command output during execution
+    # @param error_callback [Block] A block that's called if the command exits with a non-zero status
+    # @yield [status, result, cmd] The return status of the command, all output from the command and an equivalent shell command
+    # @yieldparam [Process::Status] status A Process::Status indicating the status of the completed command
+    # @yieldparam [String] result The complete output to stdout and stderr of the completed command
+    # @yieldparam [String] cmd A shell command equivalent to the arguments passed
+    # rubocop: disable Metrics/PerceivedComplexity
+    def self.sh_control_output(*command, print_command: true, print_command_output: true, error_callback: nil)
+      print_command = print_command_output = true if $troubleshoot
+      # Set the encoding first, the user might have set it wrong
+      previous_encoding = [Encoding.default_external, Encoding.default_internal]
+      Encoding.default_external = Encoding::UTF_8
+      Encoding.default_internal = Encoding::UTF_8
+
+      # Workaround to support previous Fastlane syntax.
+      # This has some limitations. For example, it requires the caller to shell escape
+      # everything because of usages like ["ls -la", "/tmp"] instead of ["ls", "-la", "/tmp"].
+      command = [command.first.join(" ")] if command.length == 1 && command.first.kind_of?(Array)
+
+      shell_command = shell_command_from_args(*command)
+      UI.command(shell_command) if print_command
+
+      result = ''
+      exit_status = nil
+      if Helper.sh_enabled?
+        # The argument list is passed directly to Open3.popen2e, which
+        # handles the variadic argument list in the same way as Kernel#spawn.
+        # (http://ruby-doc.org/core-2.4.2/Kernel.html#method-i-spawn) or
+        # Process.spawn (http://ruby-doc.org/core-2.4.2/Process.html#method-c-spawn).
+        #
+        # sh "ls -la /Applications/Xcode\ 7.3.1.app"
+        # sh "ls", "-la", "/Applications/Xcode 7.3.1.app"
+        # sh({ "FOO" => "Hello" }, "echo $FOO")
+        Open3.popen2e(*command) do |stdin, io, thread|
+          io.sync = true
+          io.each do |line|
+            UI.command_output(line.strip) if print_command_output
+            result << line
+          end
+          exit_status = thread.value
+        end
+
+        # Checking Process::Status#exitstatus instead of #success? makes for more
+        # testable code. (Tests mock exitstatus only.) This is also consistent
+        # with previous implementations of sh and... probably portable to all
+        # relevant platforms.
+        if exit_status.exitstatus != 0
+          message = if print_command
+                      "Exit status of command '#{shell_command}' was #{exit_status.exitstatus} instead of 0."
+                    else
+                      "Shell command exited with exit status #{exit_status.exitstatus} instead of 0."
+                    end
+          message += "\n#{result}" if print_command_output
+
+          if error_callback || block_given?
+            UI.error(message)
+            # block notified below, on success or failure
+            error_callback && error_callback.call(result)
+          else
+            UI.shell_error!(message)
+          end
+        end
+      else
+        result << shell_command # only for the tests
+      end
+
+      if block_given?
+        # Avoid yielding nil in tests. $? will be meaningless, but calls to
+        # it will not crash. There is no Process::Status.new. The alternative
+        # is to move this inside the sh_enabled? check and not yield in tests.
+        return yield(exit_status || $?, result, shell_command)
+      end
+      result
+    rescue => ex
+      raise ex
+    ensure
+      Encoding.default_external = previous_encoding.first
+      Encoding.default_internal = previous_encoding.last
+    end
+    # rubocop: enable Metrics/PerceivedComplexity
+
+    # Used to produce a shell command string from a list of arguments that may
+    # be passed to methods such as Kernel#system, Kernel#spawn and Open3.popen2e
+    # in order to print the command to the terminal. The same *args are passed
+    # directly to a system call (Open3.popen2e). This interpretation is not
+    # used when executing a command.
+    #
+    # @param args Any number of arguments used to construct a command
+    # @raise [ArgumentError] If no arguments passed
+    # @return [String] A shell command representing the arguments passed in
+    def self.shell_command_from_args(*args)
+      raise ArgumentError, "sh requires at least one argument" unless args.count > 0
+
+      command = ""
+
+      # Optional initial environment Hash
+      if args.first.kind_of?(Hash)
+        command = args.shift.map { |k, v| "#{k}=#{v.shellescape}" }.join(" ") + " "
+      end
+
+      # Support [ "/usr/local/bin/foo", "foo" ], "-x", ...
+      if args.first.kind_of?(Array)
+        command += args.shift.first.shellescape + " " + args.shelljoin
+        command.chomp!(" ")
+      elsif args.count == 1 && args.first.kind_of?(String)
+        command += args.first
+      else
+        command += args.shelljoin
+      end
+
+      command
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/xcodeproj_helper.rb

@@ -0,0 +1,12 @@
+module Fastlane
+  module Helper
+    class XcodeprojHelper
+      DEPENDENCY_MANAGER_DIRS = ['Pods', 'Carthage'].freeze
+
+      def self.find(dir)
+        xcodeproj_paths = Dir[File.expand_path(File.join(dir, '**/*.xcodeproj'))]
+        xcodeproj_paths.reject { |path| %r{/(#{DEPENDENCY_MANAGER_DIRS.join('|')})/.*.xcodeproj} =~ path }
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/xcversion_helper.rb

@@ -0,0 +1,25 @@
+module Fastlane
+  module Helper
+    class XcversionHelper
+      def self.find_xcode(req)
+        req = Gem::Requirement.new(req.to_s)
+
+        require 'xcode/install'
+        installer = XcodeInstall::Installer.new
+        installed = installer.installed_versions.reverse
+        installed.detect do |xcode|
+          req.satisfied_by?(Gem::Version.new(xcode.version))
+        end
+      end
+
+      module Verify
+        def self.requirement(req)
+          UI.user_error!("Version must be specified") if req.nil? || req.to_s.strip.size == 0
+          Gem::Requirement.new(req.to_s)
+        rescue Gem::Requirement::BadRequirementError
+          UI.user_error!("The requirement '#{req}' is not a valid RubyGems style requirement")
+        end
+      end
+    end
+  end
+end

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.black_list.include?(name.to_s)
+          UI.error("Lane name '#{name}' is invalid! Invalid names are #{self.black_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 black_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