fastlane 1.92.0 → 1.93.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5a8f36b44fdba28a2384ebaaf3ed6c19640e4ed
-  data.tar.gz: 97d37d0093e30964336a875e744ddc468b1ebdd9
+  metadata.gz: 3c67117c9fa728e8d4a628cd5ab40a74f615dfd1
+  data.tar.gz: 1397336e43b8257f610df1af93f04532a8480d18
 SHA512:
-  metadata.gz: 9b767890903852e42d1a7a56b0ce9cb18649934ae69ed719534f6f3178f1595e3feeef445bd59f89c860d6a4e028878ce5359ec156627e9c12d58d01b5930270
-  data.tar.gz: c55a8e615c2e69bb69388316c3618a58d8156d3ecd86b9da53ee9ea8d6f0816e16cf400b4ac9bf1929d3f1a89b68f7181c74221d06a3929e2e9a165d67758671
+  metadata.gz: c7400de730419a6c95102c79d32c623a267da6e540c2620241e12d645da46648d3433e36a8c344b5e0e49076607c75c0932e107ace0a4bb4dc0607e1d3666805
+  data.tar.gz: f91ff6eb451eff605418e3dc2416402bb7affc8448df7114ffcf13094e402772b74759d8f04b2e0de6f3e2abdaf21fa0e7e46774ce7bd78942d731df1c845b26

data/lib/assets/AvailablePlugins.md.erb

@@ -0,0 +1,24 @@
+### Available Plugins
+
+To get an up to date list of all available plugins run
+
+```
+fastlane search_plugins
+```
+
+To search for a specific plugin
+
+```
+fastlane search_plugins [search_query]
+```
+
+You can find more information about how to start using plugins in [Plugins.md](https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Plugins.md).
+
+#### List of plugins
+
+| Plugin Name | Description | Downloads
+--------------|-------------|----------|----------
+<% @plugins.each do |current| %>
+<%= current.linked_title %> | <%= current.info %> | <%= current.downloads %>
+
+<% end %>

data/lib/fastlane.rb

@@ -18,18 +18,25 @@ require 'fastlane/one_off'
 require 'fastlane/command_line_handler'
 require 'fastlane/documentation/docs_generator'
 require 'fastlane/other_action'
+require 'fastlane/plugins/plugins'
 
 module Fastlane
   Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
   UI = FastlaneCore::UI
 
-  def self.load_actions
-    Fastlane::Actions.load_default_actions
-    Fastlane::Actions.load_helpers
+  class << self
+    def load_actions
+      Fastlane::Actions.load_default_actions
+      Fastlane::Actions.load_helpers
 
-    if Fastlane::FastlaneFolder.path
-      actions_path = File.join(Fastlane::FastlaneFolder.path, 'actions')
-      Fastlane::Actions.load_external_actions(actions_path) if File.directory?(actions_path)
+      if Fastlane::FastlaneFolder.path
+        actions_path = File.join(Fastlane::FastlaneFolder.path, 'actions')
+        Fastlane::Actions.load_external_actions(actions_path) if File.directory?(actions_path)
+      end
+    end
+
+    def plugin_manager
+      @plugin_manager ||= Fastlane::PluginManager.new
     end
   end
 end

data/lib/fastlane/action_collector.rb

@@ -1,8 +1,19 @@
 module Fastlane
   class ActionCollector < FastlaneCore::ToolCollector
+    # Is this an official fastlane action, that is bundled with fastlane?
     def is_official?(name)
       return true if name == :lane_switch
-      Actions.get_all_official_actions.include? name
+      Actions.get_all_official_actions.include?(name)
+    end
+
+    def name_to_track(name)
+      return name if is_official?(name)
+
+      Fastlane.plugin_manager.plugin_references.each do |plugin_name, value|
+        return "#{plugin_name}/#{name}" if value[:actions].include?(name)
+      end
+
+      return nil
     end
 
     def show_message
@@ -15,7 +26,29 @@ module Fastlane
     end
 
     def determine_version(name)
-      super(name) || Fastlane::VERSION
+      self.class.determine_version(name)
+    end
+
+    # e.g.
+    #   :gym
+    #   :xcversion
+    #   "fastlane-plugin-my_plugin/xcversion"
+    def self.determine_version(name)
+      result = super(name)
+      return result if result
+
+      if name.to_s.include?(PluginManager.plugin_prefix)
+        # That's an action from a plugin, we need to fetch its version number
+        begin
+          plugin_name = name.split("/").first.gsub(PluginManager.plugin_prefix, '')
+          return Fastlane.const_get(plugin_name.fastlane_class)::VERSION
+        rescue => ex
+          UI.verbose(ex)
+          return "undefined"
+        end
+      end
+
+      return Fastlane::VERSION # that's the case for all built-in actions
     end
   end
 end

data/lib/fastlane/actions/actions_helper.rb

@@ -101,5 +101,9 @@ module Fastlane
         end
       end
     end
+
+    def self.formerly_bundled_actions
+      ["xcake"]
+    end
   end
 end

data/lib/fastlane/commands_generator.rb

@@ -8,8 +8,13 @@ module Fastlane
     include Commander::Methods
 
     def self.start
+      # since at this point we haven't yet loaded commander
+      # however we do want to log verbose information in the PluginManager
+      $verbose = true if ARGV.include?("--verbose")
+
       FastlaneCore::UpdateChecker.start_looking_for_update('fastlane')
       Fastlane.load_actions
+      Fastlane.plugin_manager.load_plugins
       self.new.run
     ensure
       FastlaneCore::UpdateChecker.show_update_status('fastlane', Fastlane::VERSION)
@@ -170,8 +175,63 @@ module Fastlane
         end
       end
 
-      default_command :trigger
+      #####################################################
+      # @!group Plugins
+      #####################################################
+
+      command :new_plugin do |c|
+        c.syntax = 'fastlane new_plugin [plugin_name]'
+        c.description = 'Create a new plugin that can be used with fastlane'
+
+        c.action do |args, options|
+          PluginGenerator.new.generate(args.shift)
+        end
+      end
+
+      command :add_plugin do |c|
+        c.syntax = 'fastlane add_plugin [plugin_name]'
+        c.description = 'Add a new plugin to your fastlane setup'
+
+        c.action do |args, options|
+          args << UI.input("Enter the name of the plugin to install: ") if args.empty?
+          args.each do |plugin_name|
+            Fastlane.plugin_manager.add_dependency(plugin_name)
+          end
+
+          UI.important("Make sure to commit your Gemfile, Gemfile.lock and #{PluginManager::PLUGINFILE_NAME} to version control")
+          Fastlane.plugin_manager.install_dependencies!
+        end
+      end
+
+      command :install_plugins do |c|
+        c.syntax = 'fastlane install_plugins'
+        c.description = 'Install all plugins for this project'
 
+        c.action do |args, options|
+          Fastlane.plugin_manager.install_dependencies!
+        end
+      end
+
+      command :update_plugins do |c|
+        c.syntax = 'fastlane update_plugins'
+        c.description = 'Update all plugin dependencies'
+
+        c.action do |args, options|
+          Fastlane.plugin_manager.update_dependencies!
+        end
+      end
+
+      command :search_plugins do |c|
+        c.syntax = 'fastlane search_plugins [search_query]'
+        c.description = 'Search for plugins, search query is optional'
+
+        c.action do |args, options|
+          search_query = args.last
+          PluginSearch.print_plugins(search_query: search_query)
+        end
+      end
+
+      default_command :trigger
       run!
     end
 

data/lib/fastlane/lane.rb

@@ -55,7 +55,7 @@ module Fastlane
       end
 
       def black_list
-        %w(run init new_action lanes list docs action actions help)
+        %w(run init new_action lanes list docs action actions enable_auto_complete new_plugin add_plugin install_plugins update_plugins search_plugins help)
       end
 
       def gray_list

data/lib/fastlane/lane_manager.rb

@@ -44,10 +44,14 @@ module Fastlane
       e = nil
       begin
         ff.runner.execute(lane, platform, parameters)
-      rescue => ex
+      rescue Exception => ex # rubocop:disable Lint/RescueException
+        # We also catch Exception, since the implemented action might send a SystemExit signal
+        # (or similar). We still want to catch that, since we want properly finish running fastlane
+        # Tested with `xcake`, which throws a `Xcake::Informative` object
+
         UI.important 'Variable Dump:'.yellow
         UI.message Actions.lane_context
-        UI.error ex.to_s
+        UI.error ex.to_s if ex.kind_of?(StandardError) # we don't want to print things like 'system exit'
         e = ex
       end
 

data/lib/fastlane/one_off.rb

@@ -29,7 +29,13 @@ module Fastlane
       begin
         class_ref = Fastlane::Actions.const_get(class_name)
       rescue NameError
-        UI.user_error!("Action '#{action}' not available, run `fastlane actions` to get a full list")
+        if Fastlane::Actions.formerly_bundled_actions.include?(action)
+          # This was a formerly bundled action which is now a plugin.
+          UI.verbose(caller.join("\n"))
+          UI.user_error!("The action '#{action}' is no longer bundled with fastlane. You can install it using `fastlane add_plugin #{action}`")
+        else
+          UI.user_error!("Action '#{action}' not available, run `fastlane actions` to get a full list")
+        end
       end
 
       r = Runner.new

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/AvailablePlugins.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,86 @@
+module Fastlane
+  # Generates a sample plugin by traversing a template directory structure
+  # and reproducing it in a destination location. At the same time, it runs
+  # variable replacements on directory names, file names, and runs ERB
+  # templating on file contents whose names end with '.erb'.
+  #
+  # Directory and file name variable replacements are defined like: %gem_name%
+  # The text between the percent signs will be used to invoke an accessor
+  # method on the PluginInfo object to get the replacement value.
+  class PluginGenerator
+    def initialize(ui:             PluginGeneratorUI.new,
+                   info_collector: PluginInfoCollector.new(ui),
+                   template_root:  File.join(File.dirname(__FILE__), 'template'),
+                   dest_root:      FileUtils.pwd)
+      @ui = ui
+      @info_collector = info_collector
+      @template_root = template_root
+      @dest_root = dest_root
+    end
+
+    # entry point
+    def generate(plugin_name = nil)
+      plugin_info = @info_collector.collect_info(plugin_name)
+
+      # Traverse all the files and directories in the template root,
+      # handling each in turn
+      Find.find(@template_root) do |template_path|
+        handle_template_path(template_path, plugin_info)
+      end
+
+      @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 handle_template_path(template_path, plugin_info)
+      dest_path = derive_dest_path(template_path, plugin_info)
+
+      if File.directory?(template_path)
+        FileUtils.mkdir_p(dest_path)
+      else
+        copy_file(template_path, dest_path, plugin_info)
+      end
+    end
+
+    def derive_dest_path(template_path, plugin_info)
+      relative_template_path = template_path.gsub(@template_root, '')
+      replaced_path = replace_path_variables(relative_template_path, plugin_info)
+
+      File.join(@dest_root, plugin_info.gem_name, replaced_path)
+    end
+
+    def copy_file(template_path, dest_path, plugin_info)
+      contents = File.read(template_path)
+
+      if dest_path.end_with?('.erb')
+        contents = ERB.new(contents).result(plugin_info.get_binding)
+        dest_path = dest_path[0...-4] # Remove the .erb suffix
+      end
+
+      File.write(dest_path, contents)
+    end
+
+    # Path variables can be defined like: %gem_name%
+    #
+    # The text between the percent signs will be used to invoke an accessor
+    # method on the PluginInfo object to be the replacement value.
+    def replace_path_variables(template_path, plugin_info)
+      path = template_path.dup
+
+      loop do
+        replacement_variable_regexp = /%([\w\-]*)%/
+        match = replacement_variable_regexp.match(path)
+
+        break unless match
+
+        replacement_value = plugin_info.send(match[1].to_sym)
+        path.gsub!(replacement_variable_regexp, replacement_value)
+      end
+
+      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