fastlane 1.91.0 → 1.92.0.beta1

data/lib/fastlane/plugins/plugin_fetcher.rb

@@ -0,0 +1,59 @@
+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'
+      url = "https://rubygems.org/api/v1/search.json?query=#{PluginManager.plugin_prefix}"
+      results = JSON.parse(open(url).read)
+
+      plugins = results.collect do |current|
+        FastlanePlugin.new(current)
+      end
+
+      return plugins if search_query.to_s.length == 0
+
+      plugins.keep_if do |current|
+        current.full_name.include?(search_query)
+      end
+    end
+
+    def self.update_md_file!
+      @plugins = fetch_gems
+
+      lib_path = FastlaneCore::Helper.gem_path('fastlane')
+      template_path = File.join(lib_path, "lib/assets/Plugins.md.erb")
+      md = ERB.new(File.read(template_path), nil, '<>').result(binding) # http://www.rrn.dk/rubys-erb-templating-system
+
+      puts md
+      output_path = "docs/AvailablePlugins.md"
+      File.write(output_path, md)
+      FastlaneCore::UI.success("Successfully written plugin file to '#{output_path}'")
+    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

data/lib/fastlane/plugins/plugin_generator.rb

@@ -0,0 +1,109 @@
+require 'fileutils'
+require 'erb'
+
+module Fastlane
+  class PluginGenerator
+    def initialize(ui             = PluginGeneratorUI.new,
+                   info_collector = PluginInfoCollector.new(ui))
+      @ui = ui
+      @info_collector = info_collector
+    end
+
+    # entry point
+    def generate(plugin_name = nil)
+      plugin_info = @info_collector.collect_info(plugin_name)
+
+      generate_paths(plugin_info)
+
+      generate_dot_rspec(plugin_info)
+      generate_dot_gitignore(plugin_info)
+      generate_gemfile(plugin_info)
+      generate_gemspec(plugin_info)
+      generate_plugin_rb(plugin_info)
+      generate_readme(plugin_info)
+      generate_version(plugin_info)
+      generate_license(plugin_info)
+      generate_action(plugin_info)
+      generate_helper(plugin_info)
+      generate_spec_helper(plugin_info)
+      generate_action_spec(plugin_info)
+      generate_rakefile(plugin_info)
+
+      @ui.success "\nYour plugin was successfully generated at #{plugin_info.gem_name}/ 🚀"
+      @ui.success "\nTo get started with using this plugin, run"
+      @ui.message "\n    fastlane add_plugin #{plugin_info.plugin_name}\n"
+      @ui.success "\nfrom a fastlane-enabled app project directory and provide the following as the path:"
+      @ui.message "\n    #{File.expand_path(plugin_info.gem_name)}\n\n"
+    end
+
+    def generate_paths(plugin_info)
+      FileUtils.mkdir_p(plugin_path(plugin_info, 'lib', plugin_info.require_path))
+      FileUtils.mkdir_p(plugin_path(plugin_info, 'lib', plugin_info.actions_path))
+      FileUtils.mkdir_p(plugin_path(plugin_info, 'lib', plugin_info.helper_path))
+      FileUtils.mkdir_p(plugin_path(plugin_info, 'spec'))
+    end
+
+    def generate_dot_rspec(plugin_info)
+      write_template(plugin_info, 'dot_rspec.erb', plugin_path(plugin_info, ".rspec"))
+    end
+
+    def generate_dot_gitignore(plugin_info)
+      write_template(plugin_info, 'dot_gitignore.erb', plugin_path(plugin_info, ".gitignore"))
+    end
+
+    def generate_gemfile(plugin_info)
+      write_template(plugin_info, 'Gemfile.erb', plugin_path(plugin_info, "Gemfile"))
+    end
+
+    def generate_gemspec(plugin_info)
+      write_template(plugin_info, 'plugin.gemspec.erb', plugin_path(plugin_info, "#{plugin_info.gem_name}.gemspec"))
+    end
+
+    def generate_plugin_rb(plugin_info)
+      write_template(plugin_info, 'plugin.rb.erb', plugin_path(plugin_info, 'lib', 'fastlane', 'plugin', "#{plugin_info.plugin_name}.rb"))
+    end
+
+    def generate_version(plugin_info)
+      write_template(plugin_info, 'version.rb.erb', plugin_path(plugin_info, 'lib', plugin_info.require_path, 'version.rb'))
+    end
+
+    def generate_readme(plugin_info)
+      write_template(plugin_info, 'README.md.erb', plugin_path(plugin_info, "README.md"))
+    end
+
+    def generate_license(plugin_info)
+      write_template(plugin_info, 'LICENSE.erb', plugin_path(plugin_info, "LICENSE"))
+    end
+
+    def generate_action(plugin_info)
+      write_template(plugin_info, 'action.rb.erb', plugin_path(plugin_info, 'lib', plugin_info.actions_path, "#{plugin_info.plugin_name}_action.rb"))
+    end
+
+    def generate_helper(plugin_info)
+      write_template(plugin_info, 'helper.rb.erb', plugin_path(plugin_info, 'lib', plugin_info.helper_path, "#{plugin_info.plugin_name}_helper.rb"))
+    end
+
+    def generate_spec_helper(plugin_info)
+      write_template(plugin_info, 'spec_helper.rb.erb', plugin_path(plugin_info, 'spec', 'spec_helper.rb'))
+    end
+
+    def generate_action_spec(plugin_info)
+      write_template(plugin_info, 'action_spec.rb.erb', plugin_path(plugin_info, 'spec', 'action_spec.rb'))
+    end
+
+    def generate_rakefile(plugin_info)
+      write_template(plugin_info, 'Rakefile.erb', plugin_path(plugin_info, 'Rakefile'))
+    end
+
+    def write_template(plugin_info, template_name, dest_path)
+      template = File.join(File.dirname(__FILE__), 'templates', template_name)
+      erb = ERB.new(File.read(template))
+      result = erb.result(plugin_info.get_binding)
+      File.write(dest_path, result)
+    end
+
+    def plugin_path(plugin_info, *path)
+      File.join(plugin_info.gem_name, *path)
+    end
+  end
+end

data/lib/fastlane/plugins/plugin_generator_ui.rb

@@ -0,0 +1,19 @@
+module Fastlane
+  class PluginGeneratorUI
+    def success(text)
+      puts text.green
+    end
+
+    def message(text)
+      puts text
+    end
+
+    def input(text)
+      UI.input(text)
+    end
+
+    def confirm(text)
+      UI.confirm(text)
+    end
+  end
+end

data/lib/fastlane/plugins/plugin_info.rb

@@ -0,0 +1,47 @@
+module Fastlane
+  class PluginInfo
+    attr_reader :plugin_name
+    attr_reader :author
+    attr_reader :gem_name
+    attr_reader :email
+    attr_reader :summary
+
+    def initialize(plugin_name, author, email, summary)
+      @plugin_name = plugin_name
+      @author = author
+      @email = email
+      @summary = summary
+    end
+
+    def gem_name
+      "#{Fastlane::PluginManager::FASTLANE_PLUGIN_PREFIX}#{plugin_name}"
+    end
+
+    def require_path
+      gem_name.tr('-', '/')
+    end
+
+    def actions_path
+      File.join(require_path, 'actions')
+    end
+
+    def helper_path
+      File.join(require_path, 'helper')
+    end
+
+    # Used to expose a local binding for use in ERB templating
+    #
+    # rubocop:disable Style/AccessorMethodName
+    def get_binding
+      binding
+    end
+    # rubocop:enable Style/AccessorMethodName
+
+    def ==(other)
+      @plugin_name == other.plugin_name &&
+      @author == other.author &&
+      @email == other.email &&
+      @summary == other.summary
+    end
+  end
+end

data/lib/fastlane/plugins/plugin_info_collector.rb

@@ -0,0 +1,120 @@
+module Fastlane
+  class PluginInfoCollector
+    def initialize(ui = PluginGeneratorUI.new)
+      @ui = ui
+    end
+
+    def collect_info(initial_name = nil)
+      plugin_name = collect_plugin_name(initial_name)
+      author = collect_author
+      email = collect_email
+      summary = collect_summary
+
+      PluginInfo.new(plugin_name, author, email, summary)
+    end
+
+    #
+    # Plugin name
+    #
+
+    def collect_plugin_name(initial_name = nil)
+      plugin_name = initial_name
+      first_try = true
+
+      loop do
+        if !first_try || plugin_name.to_s.empty?
+          plugin_name = @ui.input("\nWhat would you like to be the name of your plugin?")
+        end
+        first_try = false
+
+        unless plugin_name_valid?(plugin_name)
+          fixed_name = fix_plugin_name(plugin_name)
+
+          if plugin_name_valid?(fixed_name)
+            plugin_name = fixed_name if @ui.confirm("\nWould '#{fixed_name}' be okay to use for your plugin name?")
+          end
+        end
+
+        break if plugin_name_valid?(plugin_name)
+
+        @ui.message("\nPlugin names can only contain lower case letters, numbers, and underscores")
+        @ui.message("and should not contain 'fastlane' or 'plugin'.")
+      end
+
+      plugin_name
+    end
+
+    def plugin_name_valid?(name)
+      # Only lower case letters, numbers and underscores allowed
+      /^[a-z0-9_]+$/ =~ name &&
+        # Does not contain the words 'fastlane' or 'plugin' since those will become
+        # part of the gem name
+        [/fastlane/, /plugin/].none? { |regex| regex =~ name }
+    end
+
+    # Applies a series of replacement rules to turn the requested plugin name into one
+    # that is acceptable, returning that suggestion
+    def fix_plugin_name(name)
+      name = name.to_s.downcase
+      fixes = {
+        /[\- ]/ => '_', # dashes and spaces become underscores
+        /[^a-z0-9_]/ => '', # anything other than lower case letters, numbers and underscores is removed
+        /fastlane[_]?/ => '', # 'fastlane' or 'fastlane_' is removed
+        /plugin[_]?/ => '' # 'plugin' or 'plugin_' is removed
+      }
+      fixes.each do |regex, replacement|
+        name = name.gsub(regex, replacement)
+      end
+      name
+    end
+
+    #
+    # Author
+    #
+
+    def collect_author
+      author = nil
+      loop do
+        author = @ui.input("\nWhat is the plugin author's name?")
+        break if author_valid?(author)
+
+        @ui.message('An author name is required.')
+      end
+
+      author
+    end
+
+    def author_valid?(author)
+      !author.to_s.strip.empty?
+    end
+
+    #
+    # Email
+    #
+
+    def collect_email
+      @ui.input("\nWhat is the plugin author's email address?")
+    end
+
+    #
+    # Summary
+    #
+
+    def collect_summary
+      summary = nil
+      loop do
+        summary = @ui.input("\nPlease enter a short summary of this fastlane plugin:")
+        break if summary_valid?(summary)
+
+        @ui.message('A summary is required.')
+      end
+
+      summary
+    end
+
+    def summary_valid?(summary)
+      !summary.to_s.strip.empty?
+    end
+
+  end
+end

data/lib/fastlane/plugins/plugin_manager.rb

@@ -0,0 +1,333 @@
+module Fastlane
+  class PluginManager
+    require "bundler"
+
+    PLUGINFILE_NAME = "Pluginfile".freeze
+    DEFAULT_GEMFILE_PATH = "Gemfile".freeze
+    GEMFILE_SOURCE_LINE = "source \"https://rubygems.org\"\n"
+    FASTLANE_PLUGIN_PREFIX = "fastlane-plugin-"
+    TROUBLESHOOTING_URL = "https://github.com/fastlane/fastlane/blob/master/fastlane/docs/PluginsTroubleshooting.md"
+
+    #####################################################
+    # @!group Reading the files and their paths
+    #####################################################
+
+    def gemfile_path
+      # This is pretty important, since we don't know what kind of
+      # Gemfile the user has (e.g. Gemfile, gems.rb, or custom env variable)
+      Bundler::SharedHelpers.default_gemfile.to_s
+    rescue Bundler::GemfileNotFound
+      nil
+    end
+
+    def pluginfile_path
+      File.join(FastlaneFolder.path, PLUGINFILE_NAME) if FastlaneFolder.path
+    end
+
+    def gemfile_content
+      File.read(gemfile_path) if gemfile_path && File.exist?(gemfile_path)
+    end
+
+    def pluginfile_content
+      File.read(pluginfile_path) if pluginfile_path && File.exist?(pluginfile_path)
+    end
+
+    #####################################################
+    # @!group Helpers
+    #####################################################
+
+    def self.plugin_prefix
+      FASTLANE_PLUGIN_PREFIX
+    end
+
+    # Returns an array of gems that are added to the Gemfile or Pluginfile
+    def available_gems
+      return [] unless gemfile_path
+      dsl = Bundler::Dsl.evaluate(gemfile_path, nil, true)
+      return dsl.dependencies.map(&:name)
+    end
+
+    # Returns an array of fastlane plugins that are added to the Gemfile or Pluginfile
+    # The returned array contains the string with their prefixes (e.g. fastlane-plugin-xcversion)
+    def available_plugins
+      available_gems.keep_if do |current|
+        current.start_with?(self.class.plugin_prefix)
+      end
+    end
+
+    # Check if a plugin is added as dependency to either the
+    # Gemfile or the Pluginfile
+    def plugin_is_added_as_dependency?(plugin_name)
+      UI.user_error!("fastlane plugins must start with '#{self.class.plugin_prefix}' string") unless plugin_name.start_with?(self.class.plugin_prefix)
+      return available_plugins.include?(plugin_name)
+    end
+
+    #####################################################
+    # @!group Modifying dependencies
+    #####################################################
+
+    def add_dependency(plugin_name)
+      plugin_name = self.class.plugin_prefix + plugin_name unless plugin_name.start_with?(self.class.plugin_prefix)
+
+      unless plugin_is_added_as_dependency?(plugin_name)
+        content = pluginfile_content || "# Autogenerated by fastlane\n\n"
+
+        line_to_add = "gem '#{plugin_name}'"
+        line_to_add += gem_dependency_suffix(plugin_name)
+        UI.verbose("Adding line: #{line_to_add}")
+
+        content += "#{line_to_add}\n"
+        File.write(pluginfile_path, content)
+        UI.success("Plugin '#{plugin_name}' was added to '#{pluginfile_path}'")
+      end
+
+      # We do this *after* creating the Plugin file
+      # Since `bundle exec` would be broken if something fails on the way
+      ensure_plugins_attached!
+
+      true
+    end
+
+    # Get a suffix (e.g. `path` or `git` for the gem dependency)
+    def gem_dependency_suffix(plugin_name)
+      return "" unless self.class.fetch_gem_info_from_rubygems(plugin_name).nil?
+
+      selection_git_url = "Git URL"
+      selection_path = "Local Path"
+      selection_rubygems = "RubyGems.org ('#{plugin_name}' seems to not be available there)"
+      selection = UI.select(
+        "Seems like the plugin is not available on RubyGems, what do you want to do?",
+        [selection_git_url, selection_path, selection_rubygems]
+      )
+
+      if selection == selection_git_url
+        git_url = UI.input('Please enter the URL to the plugin, including the protocol (e.g. https:// or git://)')
+        return ", git: '#{git_url}'"
+      elsif selection == selection_path
+        path = UI.input('Please enter the relative path to the plugin you want to use. It has to point to the directory containing the .gemspec file')
+        return ", path: '#{path}'"
+      elsif selection == selection_rubygems
+        return ""
+      else
+        UI.user_error!("Unknown input #{selection}")
+      end
+    end
+
+    # Modify the user's Gemfile to load the plugins
+    def attach_plugins_to_gemfile!(path_to_gemfile)
+      content = gemfile_content || GEMFILE_SOURCE_LINE
+
+      # We have to make sure fastlane is also added to the Gemfile, since we now use
+      # bundler to run fastlane
+      content += "\ngem 'fastlane'\n" unless available_gems.include?('fastlane')
+      content += "\n#{self.class.code_to_attach}\n"
+
+      File.write(path_to_gemfile, content)
+    end
+
+    #####################################################
+    # @!group Accessing RubyGems
+    #####################################################
+
+    def self.fetch_gem_info_from_rubygems(gem_name)
+      require 'open-uri'
+      require 'json'
+      url = "https://rubygems.org/api/v1/gems/#{gem_name}.json"
+      begin
+        JSON.parse(open(url).read)
+      rescue
+        nil
+      end
+    end
+
+    #####################################################
+    # @!group Installing and updating dependencies
+    #####################################################
+
+    # Warning: This will exec out
+    # This is necessary since the user might be prompted for their password
+    def install_dependencies!
+      # Using puts instead of `UI` to have the same style as the `echo`
+      puts "Installing plugin dependencies..."
+      ensure_plugins_attached!
+      with_clean_bundler_env do
+        cmd = "bundle install"
+        cmd << " --quiet" unless $verbose
+        cmd << " && echo 'Successfully installed plugins'"
+        UI.command(cmd) if $verbose
+        exec(cmd)
+      end
+    end
+
+    # Warning: This will exec out
+    # This is necessary since the user might be prompted for their password
+    def update_dependencies!
+      puts "Updating plugin dependencies..."
+      ensure_plugins_attached!
+      with_clean_bundler_env do
+        cmd = "bundle update"
+        cmd << " --quiet" unless $verbose
+        cmd << " && echo 'Successfully updated plugins'"
+        UI.command(cmd) if $verbose
+        exec(cmd)
+      end
+    end
+
+    def with_clean_bundler_env
+      # There is an interesting problem with using exec to call back into Bundler
+      # The `bundle ________` command that we exec, inherits all of the Bundler
+      # state we'd already built up during this run. That was causing the command
+      # to fail, telling us to install the Gem we'd just introduced, even though
+      # that is exactly what we are trying to do!
+      #
+      # Bundler.with_clean_env solves this problem by resetting Bundler state before the
+      # exec'd call gets merged into this process.
+
+      Bundler.with_clean_env do
+        yield if block_given?
+      end
+    end
+
+    #####################################################
+    # @!group Initial setup
+    #####################################################
+
+    def setup
+      UI.important("It looks like fastlane plugins are not yet set up for this project.")
+
+      path_to_gemfile = gemfile_path || DEFAULT_GEMFILE_PATH
+
+      if gemfile_content.to_s.length > 0
+        UI.important("fastlane will modify your existing Gemfile at path '#{path_to_gemfile}'")
+      else
+        UI.important("fastlane will create a new Gemfile at path '#{path_to_gemfile}'")
+      end
+
+      UI.important("This change is neccessary for fastlane plugins to work")
+
+      unless UI.confirm("Should fastlane modify the Gemfile at path '#{path_to_gemfile}' for you?")
+        UI.important("Please add the following code to '#{path_to_gemfile}':")
+        puts ""
+        puts self.class.code_to_attach.magenta # we use `puts` instead of `UI` to make it easier to copy and paste
+        UI.user_error!("Please update '#{path_to_gemfile} and run fastlane again")
+      end
+
+      attach_plugins_to_gemfile!(path_to_gemfile)
+      UI.success("Successfully modified '#{path_to_gemfile}'")
+    end
+
+    # The code required to load the Plugins file
+    def self.code_to_attach
+      if FastlaneFolder.path
+        fastlane_folder_name = File.basename(FastlaneFolder.path)
+      else
+        fastlane_folder_name = "fastlane"
+      end
+      "plugins_path = File.join(File.dirname(__FILE__), '#{fastlane_folder_name}', '#{PluginManager::PLUGINFILE_NAME}')\n" \
+      "eval(File.read(plugins_path), binding) if File.exist?(plugins_path)"
+    end
+
+    # Makes sure, the user's Gemfile actually loads the Plugins file
+    def plugins_attached?
+      gemfile_path && gemfile_content.include?(self.class.code_to_attach)
+    end
+
+    def ensure_plugins_attached!
+      return if plugins_attached?
+      self.setup
+    end
+
+    #####################################################
+    # @!group Requiring the plugins
+    #####################################################
+
+    # Iterate over all available plugins
+    # which follow the naming convention
+    #   fastlane-plugin-[plugin_name]
+    # This will make sure to load the action
+    # and all its helpers
+    def self.load_plugins
+      UI.verbose("Checking if there are any plugins that should be loaded...")
+
+      loaded_plugins = false
+      Gem::Specification.each do |current_gem|
+        gem_name = current_gem.name
+        next unless gem_name.start_with?(PluginManager.plugin_prefix)
+
+        UI.verbose("Loading '#{gem_name}' plugin")
+        begin
+          require gem_name.tr("-", "/") # from "fastlane-plugin-xcversion" to "fastlane/plugin/xcversion"
+          store_plugin_reference(gem_name)
+          loaded_plugins = true
+        rescue => ex
+          UI.error("Error loading plugin '#{gem_name}': #{ex}")
+
+          # We'll still add it to the table, to make the error
+          # much more visible and obvious
+          self.plugin_references[gem_name] = {
+            version_number: Fastlane::ActionCollector.determine_version(gem_name),
+            actions: []
+          }
+        end
+      end
+
+      if !loaded_plugins && PluginManager.new.pluginfile_content.to_s.include?(plugin_prefix)
+        UI.error("It seems like you wanted to load some plugins, however they couldn't be loaded")
+        UI.error("Please follow the troubleshooting guide: #{TROUBLESHOOTING_URL}")
+      end
+
+      print_plugin_information(self.plugin_references) unless self.plugin_references.empty?
+    end
+
+    # Prints a table all the plugins that were loaded
+    def self.print_plugin_information(references)
+      rows = references.collect do |current|
+        if current[1][:actions].empty?
+          # Something is wrong with this plugin, no available actions
+          [current[0].red, current[1][:version_number], "No actions found".red]
+        else
+          [current[0], current[1][:version_number], current[1][:actions].join("\n")]
+        end
+      end
+
+      puts Terminal::Table.new({
+        rows: rows,
+        title: "Used plugins".green,
+        headings: ["Plugin", "Version", "Action"]
+      })
+      puts ""
+    end
+
+    #####################################################
+    # @!group Reference between plugins to actions
+    #####################################################
+
+    # Connection between plugins and their actions
+    # Example value of plugin_references
+    # => {"fastlane-plugin-ruby" => {
+    #          version_number: "0.1.0",
+    #          actions: [:rspec, :rubocop]
+    #     }}
+    def self.plugin_references
+      @plugin_references ||= {}
+    end
+
+    def self.store_plugin_reference(gem_name)
+      module_name = gem_name.gsub(PluginManager.plugin_prefix, '').fastlane_class
+      # We store a collection of the imported plugins
+      # This way we can tell which action came from what plugin
+      # (a plugin may contain any number of actions)
+      version_number = Fastlane::ActionCollector.determine_version(gem_name)
+      references = Fastlane.const_get(module_name).all_classes.collect do |path|
+        next unless File.dirname(path).end_with?("/actions") # we only want to match actions
+
+        File.basename(path).gsub("_action", "").gsub(".rb", "").to_sym # the _action is optional
+      end
+
+      self.plugin_references[gem_name] = {
+        version_number: version_number,
+        actions: references.keep_if { |a| !a.nil? }
+      }
+    end
+  end
+end