fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/documentation/docs_generator.rb

@@ -0,0 +1,89 @@
+module Fastlane
+  class DocsGenerator
+    def self.run(ff, output_path = nil)
+      output_path ||= File.join(FastlaneCore::FastlaneFolder.path || '.', 'README.md')
+
+      output = ["fastlane documentation"]
+      output << "================"
+
+      output << "# Installation"
+      output << ""
+      output << "Make sure you have the latest version of the Xcode command line tools installed:"
+      output << ""
+      output << "```"
+      output << "xcode-select --install"
+      output << "```"
+      output << ""
+      output << "Install _fastlane_ using"
+      output << "```"
+      output << "[sudo] gem install fastlane -NV"
+      output << "```"
+      output << "or alternatively using `brew cask install fastlane`"
+      output << ""
+      output << "# Available Actions"
+
+      all_keys = ff.runner.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|
+        lanes = ff.runner.lanes[platform]
+
+        if lanes.nil? || lanes.empty? || lanes.all? { |_, lane| lane.is_private }
+          next
+        end
+
+        output << "## #{formatted_platform(platform)}" if platform
+
+        lanes.each do |lane_name, lane|
+          next if lane.is_private
+          output << render(platform, lane_name, lane.description.join("\n\n"))
+        end
+
+        output << ""
+        output << "----"
+        output << ""
+      end
+
+      output << "This README.md is auto-generated and will be re-generated every time [fastlane](https://fastlane.tools) is run."
+      output << "More information about fastlane can be found on [fastlane.tools](https://fastlane.tools)."
+      output << "The documentation of fastlane can be found on [docs.fastlane.tools](https://docs.fastlane.tools)."
+      output << ""
+
+      begin
+        File.write(output_path, output.join("\n"))
+        UI.success("Successfully generated documentation at path '#{File.expand_path(output_path)}'") if FastlaneCore::Globals.verbose?
+      rescue => ex
+        UI.error(ex)
+        UI.error("Couldn't save fastlane documentation at path '#{File.expand_path(output_path)}', make sure you have write access to the containing directory.")
+      end
+    end
+
+    #####################################################
+    # @!group Helper
+    #####################################################
+
+    def self.formatted_platform(pl)
+      pl = pl.to_s
+      return "iOS" if pl == 'ios'
+      return "Mac" if pl == 'mac'
+      return "Android" if pl == 'android'
+
+      return pl
+    end
+
+    # @param platform [String]
+    # @param lane [Fastlane::Lane]
+    # @param description [String]
+    def self.render(platform, lane, description)
+      full_name = [platform, lane].reject(&:nil?).join(' ')
+
+      output = []
+      output << "### #{full_name}"
+      output << "```"
+      output << "fastlane #{full_name}"
+      output << "```"
+      output << description
+      output
+    end
+  end
+end

data/fastlane/lib/fastlane/documentation/markdown_docs_generator.rb

@@ -0,0 +1,228 @@
+module Fastlane
+  class MarkdownDocsGenerator
+    attr_accessor :categories
+
+    def initialize
+      require 'fastlane'
+      require 'fastlane/documentation/actions_list'
+      Fastlane.load_actions
+
+      self.work
+    end
+
+    def work
+      fill_built_in_actions
+    end
+
+    def fill_built_in_actions
+      self.categories = {}
+
+      Fastlane::Action::AVAILABLE_CATEGORIES.each { |a| self.categories[readable_category_name(a)] = {} }
+
+      # Fill categories with all built-in actions
+      ActionsList.all_actions do |action|
+        readable = readable_category_name(action.category)
+
+        if self.categories[readable].kind_of?(Hash)
+          self.categories[readable][number_of_launches_for_action(action.action_name)] = action
+        else
+          UI.error("Action '#{action.name}' doesn't contain category information... skipping")
+        end
+      end
+    end
+
+    def number_of_launches_for_action(action_name)
+      found = all_actions_from_enhancer.find { |c| c['action'] == action_name.to_s }
+
+      return found["index"] if found
+      return 10_000 + rand # new actions that we've never tracked before will be shown at the bottom of the page, need `rand` to not overwrite them
+    end
+
+    def all_actions_from_enhancer
+      require 'json'
+      @_launches ||= JSON.parse(File.read(File.join(Fastlane::ROOT, "assets/action_ranking.json"))) # root because we're in a temporary directory here
+    end
+
+    def actions_path
+      "lib/fastlane/actions/"
+    end
+
+    def where_is(klass)
+      # Gets all source files for action
+      methods = klass.methods(false).map { |m| klass.method(m) }
+      source_files = methods
+                     .map(&:source_location)
+                     .compact
+                     .map { |(file, line)| file }
+                     .uniq
+
+      # Return file or error if multiples
+      if source_files.size == 1
+        return source_files.first
+      else
+        UI.crash!("Multiple source files were found for action `#{klass}`")
+      end
+    end
+
+    def filename_for_action(action)
+      absolute_path = where_is(action)
+      filename = File.basename(absolute_path)
+
+      path = File.join(Fastlane::ROOT, actions_path, filename)
+      unless File.exist?(path)
+        UI.error("Action '#{action.name}' not found in root fastlane project... skipping")
+        UI.verbose("Action '#{action.name}' found at #{path}")
+        return nil
+      end
+      filename
+    end
+
+    def custom_action_docs_path
+      "lib/fastlane/actions/docs/"
+    end
+
+    def load_custom_action_md(action)
+      # check if there is a custom detail view in markdown available in the fastlane code base
+      custom_file_location = File.join(Fastlane::ROOT, custom_action_docs_path, "#{action.action_name}.md")
+      if File.exist?(custom_file_location)
+        UI.verbose("Using custom md file for action #{action.action_name}")
+        return File.read(custom_file_location)
+      end
+      return load_custom_action_md_erb(action)
+    end
+
+    def load_custom_action_md_erb(action)
+      # check if there is a custom detail view as markdown ERB available in the fastlane code base
+      custom_file_location = File.join(Fastlane::ROOT, custom_action_docs_path, "#{action.action_name}.md.erb")
+      if File.exist?(custom_file_location)
+        UI.verbose("Using custom md.erb file for action #{action.action_name}")
+
+        result = ERB.new(File.read(custom_file_location), 0, '-').result(binding) # https://web.archive.org/web/20160430190141/www.rrn.dk/rubys-erb-templating-system
+
+        return result
+      end
+      return nil
+    end
+
+    def actions_md_contents
+      action_mds = {}
+
+      ActionsList.all_actions do |action|
+        @action = action
+        @action_filename = filename_for_action(action)
+
+        unless @action_filename
+          next
+        end
+
+        @custom_content = load_custom_action_md(action)
+
+        if action.superclass != Fastlane::Action
+          @custom_content ||= load_custom_action_md(action.superclass)
+        end
+
+        template = File.join(Fastlane::ROOT, "lib/assets/ActionDetails.md.erb")
+        result = ERB.new(File.read(template), 0, '-').result(binding)
+
+        action_mds[action.action_name] = result
+      end
+
+      return action_mds
+    end
+
+    def generate!(target_path: nil)
+      require 'yaml'
+      FileUtils.mkdir_p(target_path)
+      docs_dir = File.join(target_path, "docs")
+
+      # Generate actions.md
+      template = File.join(Fastlane::ROOT, "lib/assets/Actions.md.erb")
+      result = ERB.new(File.read(template), 0, '-').result(binding) # https://web.archive.org/web/20160430190141/www.rrn.dk/rubys-erb-templating-system
+      File.write(File.join(docs_dir, "actions.md"), result)
+
+      # Generate actions sub pages (e.g. actions/slather.md, actions/scan.md)
+      all_actions_ref_yml = []
+      FileUtils.mkdir_p(File.join(docs_dir, "actions"))
+      ActionsList.all_actions do |action|
+        @action = action # to provide a reference in the .html.erb template
+        @action_filename = filename_for_action(action)
+
+        unless @action_filename
+          next
+        end
+
+        # Make sure to always assign `@custom_content`, as we're in a loop and `@` is needed for the `erb`
+        @custom_content = load_custom_action_md(action)
+
+        if action.superclass != Fastlane::Action
+          # This means, the current method is an alias
+          # meaning we're gonna look if the parent class
+          # has a custom md file.
+          # e.g. `DeliverAction`'s superclass is `UploadToAppStoreAction`
+          @custom_content ||= load_custom_action_md(action.superclass)
+        end
+
+        template = File.join(Fastlane::ROOT, "lib/assets/ActionDetails.md.erb")
+        result = ERB.new(File.read(template), 0, '-').result(binding) # https://web.archive.org/web/20160430190141/www.rrn.dk/rubys-erb-templating-system
+
+        file_name = File.join("actions", "#{action.action_name}.md")
+        File.write(File.join(docs_dir, file_name), result)
+
+        all_actions_ref_yml << { action.action_name => file_name }
+      end
+
+      # Modify the mkdocs.yml to list all the actions
+      mkdocs_yml_path = File.join(target_path, "mkdocs.yml")
+      raise "Could not find mkdocs.yml in #{target_path}, make sure to point to the fastlane/docs repo" unless File.exist?(mkdocs_yml_path)
+      mkdocs_yml = YAML.load_file(mkdocs_yml_path)
+      hidden_actions_array = mkdocs_yml["pages"].find { |p| !p["_Actions"].nil? }
+      hidden_actions_array["_Actions"] = all_actions_ref_yml
+      File.write(mkdocs_yml_path, mkdocs_yml.to_yaml)
+
+      # Copy over the assets from the `actions/docs/assets` directory
+      Dir[File.join(custom_action_docs_path, "assets", "*")].each do |current_asset_path|
+        UI.message("Copying asset #{current_asset_path}")
+        FileUtils.cp(current_asset_path, File.join(docs_dir, "img", "actions", File.basename(current_asset_path)))
+      end
+
+      UI.success("Generated new docs on path #{target_path}")
+    end
+
+    private
+
+    def readable_category_name(category_symbol)
+      case category_symbol
+      when :misc
+        "Misc"
+      when :source_control
+        "Source Control"
+      when :notifications
+        "Notifications"
+      when :code_signing
+        "Code Signing"
+      when :documentation
+        "Documentation"
+      when :testing
+        "Testing"
+      when :building
+        "Building"
+      when :push
+        "Push"
+      when :screenshots
+        "Screenshots"
+      when :project
+        "Project"
+      when :beta
+        "Beta"
+      when :production
+        "Releasing your app"
+      when :app_store_connect
+        "App Store Connect"
+      when :deprecated
+        "Deprecated"
+      else
+        category_symbol.to_s.capitalize
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/environment_printer.rb

@@ -0,0 +1,297 @@
+module Fastlane
+  class EnvironmentPrinter
+    def self.output
+      env_info = get
+
+      # Remove sensitive option values
+      FastlaneCore::Configuration.sensitive_strings.compact.each do |sensitive_element|
+        env_info.gsub!(sensitive_element, "#########")
+      end
+
+      puts(env_info)
+      UI.important("Take notice that this output may contain sensitive information, or simply information that you don't want to make public.")
+      if FastlaneCore::Helper.mac? && UI.interactive? && UI.confirm("🙄  Wow, that's a lot of markdown text... should fastlane put it into your clipboard, so you can easily paste it on GitHub?")
+        copy_to_clipboard(env_info)
+        UI.success("Successfully copied markdown into your clipboard 🎨")
+      end
+      UI.success("Open https://github.com/fastlane/fastlane/issues/new to submit a new issue ✅")
+    end
+
+    def self.get
+      UI.important("Generating fastlane environment output, this might take a few seconds...")
+      require "fastlane/markdown_table_formatter"
+      env_output = ""
+      env_output << print_system_environment
+      env_output << print_system_locale
+      env_output << print_fastlane_files
+      env_output << print_loaded_fastlane_gems
+      env_output << print_loaded_plugins
+      env_output << print_loaded_gems
+      env_output << print_date
+
+      # Adding title
+      status = (env_output.include?("🚫") ? "🚫" : "✅")
+      env_header = "<details><summary>#{status} fastlane environment #{status}</summary>\n\n"
+      env_tail = "</details>"
+      final_output = ""
+
+      if FastlaneCore::Globals.captured_output?
+        final_output << "### Captured Output\n\n"
+        final_output << "Command Used: `#{ARGV.join(' ')}`\n"
+        final_output << "<details><summary>Output/Log</summary>\n\n```\n\n#{FastlaneCore::Globals.captured_output}\n\n```\n\n</details>\n\n"
+      end
+
+      final_output << env_header + env_output + env_tail
+    end
+
+    def self.print_date
+      date = Time.now.strftime("%Y-%m-%d")
+      "\n*generated on:* **#{date}**\n"
+    end
+
+    def self.print_loaded_plugins
+      ENV["FASTLANE_ENV_PRINTER"] = "enabled"
+      env_output =  "### Loaded fastlane plugins:\n"
+      env_output << "\n"
+      plugin_manager = Fastlane::PluginManager.new
+      plugin_manager.load_plugins
+      if plugin_manager.available_plugins.length <= 0
+        env_output << "**No plugins Loaded**\n"
+      else
+        table = ""
+        table << "| Plugin | Version | Update-Status |\n"
+        table << "|--------|---------|\n"
+        plugin_manager.available_plugins.each do |plugin|
+          begin
+            installed_version = Fastlane::ActionCollector.determine_version(plugin)
+            latest_version = FastlaneCore::UpdateChecker.fetch_latest(plugin)
+            if Gem::Version.new(installed_version) == Gem::Version.new(latest_version)
+              update_status = "✅ Up-To-Date"
+            else
+              update_status = "🚫 Update available"
+            end
+          rescue
+            update_status = "💥 Check failed"
+          end
+          table << "| #{plugin} | #{installed_version} | #{update_status} |\n"
+        end
+
+        rendered_table = MarkdownTableFormatter.new(table)
+        env_output << rendered_table.to_md
+      end
+
+      env_output << "\n\n"
+      env_output
+    end
+
+    # We have this as a separate method, as this has to be handled
+    # slightly differently, depending on how fastlane is being called
+    def self.gems_to_check
+      if Helper.contained_fastlane?
+        Gem::Specification
+      else
+        Gem.loaded_specs.values
+      end
+    end
+
+    def self.print_loaded_fastlane_gems
+      # fastlanes internal gems
+      env_output = "### fastlane gems\n\n"
+      table = ""
+      table << "| Gem | Version | Update-Status |\n"
+      table << "|-----|---------|------------|\n"
+      fastlane_tools = Fastlane::TOOLS + [:fastlane_core, :credentials_manager]
+
+      gems_to_check.each do |current_gem|
+        update_status = "N/A"
+
+        next unless fastlane_tools.include?(current_gem.name.to_sym)
+        begin
+          latest_version = FastlaneCore::UpdateChecker.fetch_latest(current_gem.name)
+          if Gem::Version.new(current_gem.version) >= Gem::Version.new(latest_version)
+            update_status = "✅ Up-To-Date"
+          else
+            update_status = "🚫 Update available"
+          end
+        rescue
+          update_status = "💥 Check failed"
+        end
+        table << "| #{current_gem.name} | #{current_gem.version} | #{update_status} |\n"
+      end
+
+      rendered_table = MarkdownTableFormatter.new(table)
+      env_output << rendered_table.to_md
+
+      env_output << "\n\n"
+
+      return env_output
+    end
+
+    def self.print_loaded_gems
+      env_output = "<details>"
+      env_output << "<summary><b>Loaded gems</b></summary>\n\n"
+
+      table = "| Gem | Version |\n"
+      table << "|-----|---------|\n"
+      gems_to_check.each do |current_gem|
+        unless Fastlane::TOOLS.include?(current_gem.name.to_sym)
+          table << "| #{current_gem.name} | #{current_gem.version} |\n"
+        end
+      end
+      rendered_table = MarkdownTableFormatter.new(table)
+
+      env_output << rendered_table.to_md
+      env_output << "</details>\n\n"
+      return env_output
+    end
+
+    def self.print_system_locale
+      env_output = "### System Locale\n\n"
+      found_one = false
+      env_table = ""
+      ["LANG", "LC_ALL", "LANGUAGE"].each do |e|
+        env_icon = "🚫"
+        if ENV[e] && ENV[e].end_with?("UTF-8")
+          env_icon = "✅"
+          found_one = true
+        end
+        if ENV[e].nil?
+          env_icon = ""
+        end
+        env_table << "| #{e} | #{ENV[e]} | #{env_icon} |\n"
+      end
+      if !found_one
+        table = "| Error |\n"
+        table << "|-----|\n"
+        table << "| No Locale with UTF8 found 🚫|\n"
+      else
+        table = "| Variable | Value |  |\n"
+        table << "|-----|---------|----|\n"
+        table << env_table
+      end
+      rendered_table = MarkdownTableFormatter.new(table)
+      env_output << rendered_table.to_md
+      env_output << "\n\n"
+    end
+
+    def self.print_system_environment
+      require "openssl"
+
+      env_output = "### Stack\n\n"
+      product, version, build = "Unknown"
+      os_version = "UNKNOWN"
+
+      if Helper.mac?
+        product, version, build = `sw_vers`.strip.split("\n").map { |line| line.split(':').last.strip }
+        os_version = version
+      end
+
+      if Helper.linux?
+        # this should work on pretty much all linux distros
+        os_version = `uname -a`.strip
+        version = ""
+        build = `uname -r`.strip
+        product = `cat /etc/issue.net`.strip
+
+        distro_guesser = {
+          fedora: "/etc/fedora-release",
+          debian_based: "/etc/debian_version",
+          suse: "/etc/SUSE-release",
+          mandrake: "/etc/mandrake-release"
+        }
+
+        distro_guesser.each do |dist, vers|
+          os_version = "#{dist} " + File.read(vers).strip if File.exist?(vers)
+          version = os_version
+        end
+      end
+
+      table_content = {
+        "fastlane" => Fastlane::VERSION,
+        "OS" => os_version,
+        "Ruby" => RUBY_VERSION,
+        "Bundler?" => Helper.bundler?,
+        "Git" => `git --version`.strip.split("\n").first,
+        "Installation Source" => anonymized_path($PROGRAM_NAME),
+        "Host" => "#{product} #{version} (#{build})",
+        "Ruby Lib Dir" => anonymized_path(RbConfig::CONFIG['libdir']),
+        "OpenSSL Version" => OpenSSL::OPENSSL_VERSION,
+        "Is contained" => Helper.contained_fastlane?.to_s,
+        "Is homebrew" => Helper.homebrew?.to_s,
+        "Is installed via Fabric.app" => Helper.mac_app?.to_s
+      }
+
+      if Helper.mac?
+        table_content["Xcode Path"] = anonymized_path(Helper.xcode_path)
+        begin
+          table_content["Xcode Version"] = Helper.xcode_version
+        rescue => ex
+          UI.error(ex)
+          UI.error("Could not get Xcode Version")
+        end
+      end
+
+      table = ["| Key | Value |"]
+      table += table_content.collect { |k, v| "| #{k} | #{v} |" }
+
+      begin
+        rendered_table = MarkdownTableFormatter.new(table.join("\n"))
+        env_output << rendered_table.to_md
+      rescue => ex
+        UI.error(ex)
+        UI.error("Error rendering markdown table using the following text:")
+        UI.message(table.join("\n"))
+        env_output << table.join("\n")
+      end
+
+      env_output << "\n\n"
+      env_output
+    end
+
+    def self.print_fastlane_files
+      env_output = "### fastlane files:\n\n"
+
+      fastlane_path = FastlaneCore::FastlaneFolder.fastfile_path
+
+      if fastlane_path && File.exist?(fastlane_path)
+        env_output << "<details>"
+        env_output << "<summary>`#{fastlane_path}`</summary>\n"
+        env_output << "\n"
+        env_output << "```ruby\n"
+        env_output <<  File.read(fastlane_path, encoding: "utf-8")
+        env_output <<  "\n```\n"
+        env_output << "</details>"
+      else
+        env_output << "**No Fastfile found**\n"
+      end
+      env_output << "\n\n"
+
+      appfile_path = CredentialsManager::AppfileConfig.default_path
+      if appfile_path && File.exist?(appfile_path)
+        env_output << "<details>"
+        env_output << "<summary>`#{appfile_path}`</summary>\n"
+        env_output << "\n"
+        env_output << "```ruby\n"
+        env_output <<  File.read(appfile_path, encoding: "utf-8")
+        env_output <<  "\n```\n"
+        env_output << "</details>"
+      else
+        env_output << "**No Appfile found**\n"
+      end
+      env_output << "\n\n"
+      env_output
+    end
+
+    def self.anonymized_path(path, home = ENV['HOME'])
+      return home ? path.gsub(%r{^#{home}(?=/(.*)|$)}, '~\2') : path
+    end
+
+    # Copy a given string into the clipboard
+    # Make sure to ask the user first, as some people don't
+    # use a clipboard manager, so they might lose something important
+    def self.copy_to_clipboard(string)
+      require 'open3'
+      Open3.popen3('pbcopy') { |input, _, _| input << string }
+    end
+  end
+end