fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/documentation/actions_list.rb

@@ -0,0 +1,214 @@
+module Fastlane
+  class ActionsList
+    def self.run(filter: nil, platform: nil)
+      require 'terminal-table'
+      if filter
+        show_details(filter: filter)
+      else
+        print_all(platform: platform)
+      end
+    end
+
+    def self.print_all(platform: nil)
+      rows = []
+      all_actions(platform) do |action, name|
+        current = []
+
+        if Fastlane::Actions.is_deprecated?(action)
+          current << "#{name} (DEPRECATED)".deprecated
+        else
+          current << name.yellow
+        end
+
+        if action < Action
+          current << action.description.to_s.remove_markdown if action.description
+
+          authors = Array(action.author || action.authors)
+          current << authors.first.green if authors.count == 1
+          current << "Multiple".green if authors.count > 1
+        else
+          UI.error(action_subclass_error(name))
+          current << "Please update action file".red
+          current << ' '
+        end
+        rows << current
+      end
+
+      puts(Terminal::Table.new(
+             title: "Available fastlane actions".green,
+             headings: ['Action', 'Description', 'Author'],
+             rows: FastlaneCore::PrintTable.transform_output(rows)
+      ))
+      puts("  Platform filter: #{platform}".magenta) if platform
+      puts("  Total of #{rows.count} actions")
+
+      puts("\nGet more information for one specific action using `fastlane action [name]`\n".green)
+    end
+
+    def self.show_details(filter: nil)
+      puts("Loading documentation for #{filter}:".green)
+      puts("")
+
+      action = find_action_named(filter)
+
+      if action
+        unless action < Action
+          UI.user_error!(action_subclass_error(filter))
+        end
+
+        print_summary(action, filter)
+        print_options(action, filter)
+        print_output_variables(action, filter)
+        print_return_value(action, filter)
+
+        if Fastlane::Actions.is_deprecated?(action)
+          puts("==========================================".deprecated)
+          puts("This action (#{filter}) is deprecated".deprecated)
+          puts(action.deprecated_notes.to_s.remove_markdown.deprecated) if action.deprecated_notes
+          puts("==========================================\n".deprecated)
+        end
+
+        puts("More information can be found on https://docs.fastlane.tools/actions/#{filter}")
+        puts("")
+      else
+        puts("Couldn't find action for the given filter.".red)
+        puts("==========================================\n".red)
+
+        print_all # show all available actions instead
+        print_suggestions(filter)
+      end
+    end
+
+    def self.print_suggestions(filter)
+      if !filter.nil? && filter.length > 1
+        action_names = []
+        all_actions(nil) do |action_ref, action_name|
+          action_names << action_name
+        end
+
+        corrections = []
+
+        if defined?(DidYouMean::SpellChecker)
+          spell_checker = DidYouMean::SpellChecker.new(dictionary: action_names)
+          corrections << spell_checker.correct(filter).compact
+        end
+
+        corrections << action_names.select { |name| name.include?(filter) }
+
+        puts("Did you mean: #{corrections.flatten.uniq.join(', ')}?".green) unless corrections.flatten.empty?
+      end
+    end
+
+    def self.action_subclass_error(name)
+      "Please update your action '#{name}' to be a subclass of `Action` by adding ` < Action` after your class name."
+    end
+
+    def self.print_summary(action, name)
+      rows = []
+
+      if action.description
+        description = action.description.to_s.remove_markdown
+        rows << [description]
+        rows << [' ']
+      end
+
+      if action.details
+        details = action.details.to_s.remove_markdown
+        details.split("\n").each do |detail|
+          row = detail.empty? ? ' ' : detail
+          rows << [row]
+        end
+
+        rows << [' ']
+      end
+
+      authors = Array(action.author || action.authors)
+      rows << ["Created by #{authors.join(', ').green}"] unless authors.empty?
+
+      puts(Terminal::Table.new(title: name.green, rows: FastlaneCore::PrintTable.transform_output(rows)))
+      puts("")
+    end
+
+    def self.print_options(action, name)
+      options = parse_options(action.available_options) if action.available_options
+
+      if options
+        puts(Terminal::Table.new(
+               title: "#{name} Options".green,
+               headings: ['Key', 'Description', 'Env Var(s)', 'Default'],
+               rows: FastlaneCore::PrintTable.transform_output(options)
+        ))
+      else
+        puts("No available options".yellow)
+      end
+      puts("* = default value is dependent on the user's system")
+      puts("")
+    end
+
+    def self.print_output_variables(action, name)
+      output = action.output
+      return if output.nil? || output.empty?
+
+      puts(Terminal::Table.new(
+             title: "#{name} Output Variables".green,
+             headings: ['Key', 'Description'],
+             rows: FastlaneCore::PrintTable.transform_output(output.map { |key, desc| [key.yellow, desc] })
+      ))
+      puts("Access the output values using `lane_context[SharedValues::VARIABLE_NAME]`")
+      puts("")
+    end
+
+    def self.print_return_value(action, name)
+      return unless action.return_value
+
+      puts(Terminal::Table.new(title: "#{name} Return Value".green,
+                                rows: FastlaneCore::PrintTable.transform_output([[action.return_value]])))
+      puts("")
+    end
+
+    # Iterates through all available actions and yields from there
+    def self.all_actions(platform = nil)
+      action_symbols = Fastlane::Actions.constants.select { |c| Fastlane::Actions.const_get(c).kind_of?(Class) && c != :TestSampleCodeAction }
+      action_symbols.sort.each do |symbol|
+        action = Fastlane::Actions.const_get(symbol)
+
+        # We allow classes that don't respond to is_supported? to come through because we want to list
+        # them as broken actions in the table, regardless of platform specification
+        next if platform && action.respond_to?(:is_supported?) && !action.is_supported?(platform.to_sym)
+
+        name = symbol.to_s.gsub(/Action$/, '').fastlane_underscore
+        yield(action, name)
+      end
+    end
+
+    def self.find_action_named(name)
+      all_actions do |action, action_name|
+        return action if action_name == name
+      end
+
+      nil
+    end
+
+    # Helper:
+    def self.parse_options(options, fill_all = true)
+      rows = []
+      rows << [options] if options.kind_of?(String)
+
+      if options.kind_of?(Array)
+        options.each do |current|
+          if current.kind_of?(FastlaneCore::ConfigItem)
+            rows << [current.key.to_s.yellow, current.deprecated ? current.description.red : current.description, current.env_names.join(", "), current.help_default_value]
+          elsif current.kind_of?(Array)
+            # Legacy actions that don't use the new config manager
+            UI.user_error!("Invalid number of elements in this row: #{current}. Must be 2 or 3") unless [2, 3].include?(current.count)
+            rows << current
+            rows.last[0] = rows.last.first.yellow # color it yellow :)
+            rows.last << nil while fill_all && rows.last.count < 4 # to have a nice border in the table
+          end
+        end
+      end
+
+      rows
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+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 << ""
+
+      output << "# Installation"
+      output << ""
+      output << "Make sure you have the latest version of the Xcode command line tools installed:"
+      output << ""
+      output << "```sh"
+      output << "xcode-select --install"
+      output << "```"
+      output << ""
+      output << "For _fastlane_ installation instructions, see [Installing _fastlane_](https://docs.fastlane.tools/#installing-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
+
+        if platform
+          output << ""
+          output << "## #{formatted_platform(platform)}"
+        end
+
+        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 << ""
+      output << "More information about _fastlane_ can be found on [fastlane.tools](https://fastlane.tools)."
+      output << ""
+      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 << ""
+      output << "### #{full_name}"
+      output << ""
+      output << "```sh"
+      output << "[bundle exec] fastlane #{full_name}"
+      output << "```"
+      output << ""
+      output << description
+      output
+    end
+  end
+end

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

@@ -0,0 +1,234 @@
+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")
+      generated_actions_dir = File.join("generated", "actions")
+      FileUtils.mkdir_p(File.join(docs_dir, generated_actions_dir))
+
+      # 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, "generated", "actions.md"), result)
+
+      # Generate actions sub pages (e.g. generated/actions/slather.md, generated/actions/scan.md)
+      all_actions_ref_yml = []
+      FileUtils.mkdir_p(File.join(docs_dir, generated_actions_dir))
+      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
+
+        # Actions get placed in "generated/actions" directory
+        file_name = File.join(generated_actions_dir, "#{action.action_name}.md")
+        File.write(File.join(docs_dir, file_name), result)
+
+        # The action pages when published get moved to the "actions" directory
+        # The mkdocs.yml file needs to reference the "actions" directory (not the "generated/actions" directory)
+        published_file_name = File.join("actions", "#{action.action_name}.md")
+        all_actions_ref_yml << { action.action_name => published_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["nav"].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