fastlane 1.92.0.beta2 → 1.92.0

data/lib/fastlane/plugins/plugin_generator_ui.rb

@@ -1,19 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,333 +0,0 @@
-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