fastlane 1.20.0 → 1.21.0

data/lib/fastlane/actions/xctool.rb

@@ -6,7 +6,7 @@ module Fastlane
           raise 'xctool not installed, please install using `brew install xctool`'.red if `which xctool`.length == 0
         end
 
-        params = [] if params.kind_of?FastlaneCore::Configuration
+        params = [] if params.kind_of? FastlaneCore::Configuration
 
         Actions.sh('xctool ' + params.join(' '))
       end
@@ -27,7 +27,7 @@ module Fastlane
       end
 
       def self.is_supported?(platform)
-        [:ios, :mac].include?platform
+        [:ios, :mac].include? platform
       end
     end
   end

data/lib/fastlane/actions_list.rb

@@ -2,8 +2,11 @@ module Fastlane
   class ActionsList
     def self.run(filter)
       require 'terminal-table'
-      print_all unless filter
-      show_details(filter) if filter
+      if filter
+        show_details(filter)
+      else
+        print_all
+      end
     end
 
     def self.print_all
@@ -18,8 +21,6 @@ module Fastlane
           authors = Array(action.author || action.authors)
           current << authors.first.green if authors.count == 1
           current << "Multiple".green if authors.count > 1
-
-          l = (action.description || '').length
         else
           Helper.log.error "Please update your action file #{name} to be a subclass of `Action` by adding ` < Action` after your class name.".red
           current << "Please update action file".red
@@ -45,7 +46,7 @@ module Fastlane
 
       all_actions do |action, name|
         next unless name == filter.strip
-        
+
         rows = []
         rows << [action.description] if action.description
         rows << [' ']
@@ -89,8 +90,6 @@ module Fastlane
           puts ""
         end
 
-        
-
         puts "More information can be found on https://github.com/KrauseFx/fastlane/blob/master/docs/Actions.md"
         puts "\n"
 
@@ -102,36 +101,35 @@ module Fastlane
       print_all # show all available actions instead
     end
 
-
     # Iterates through all available actions and yields from there
     def self.all_actions
-      all_actions = Fastlane::Actions.constants.select {|c| Class === Fastlane::Actions.const_get(c)}
-      all_actions.sort.each do |symbol|        
+      all_actions = Fastlane::Actions.constants.select {|c| Fastlane::Actions.const_get(c).kind_of? Class }
+      all_actions.sort.each do |symbol|
         action = Fastlane::Actions.const_get(symbol)
         name = symbol.to_s.gsub('Action', '').fastlane_underscore
         yield action, name
       end
     end
-    
-    private
-      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.description, current.env_name]
-            elsif current.kind_of?Array
-              raise "Invalid number of elements in this row: #{current}. Must be 2 or 3".red unless ([2, 3].include?current.count)
-              rows << current
-              rows.last[0] = rows.last.first.yellow # color it yellow :) 
-              rows.last << nil while (fill_all and rows.last.count < 3) # to have a nice border in the table
-            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.description, current.env_name]
+          elsif current.kind_of? Array
+            raise "Invalid number of elements in this row: #{current}. Must be 2 or 3".red unless [2, 3].include? current.count
+            rows << current
+            rows.last[0] = rows.last.first.yellow # color it yellow :)
+            rows.last << nil while fill_all and rows.last.count < 3 # to have a nice border in the table
           end
         end
-
-        rows
       end
+
+      rows
+    end
   end
-end
+end

data/lib/fastlane/command_line_handler.rb

@@ -7,9 +7,9 @@ module Fastlane
       lane_parameters = {} # the parameters we'll pass to the lane
       platform_lane_info = [] # the part that's responsible for the lane/platform definition
       args.each do |current|
-        if current.include?":" # that's a key/value which we want to pass to the lane
-          key, value = current.split(":")          
-          raise "Please pass values like this: key:value" unless (key.length > 0 and value.length > 0)
+        if current.include? ":" # that's a key/value which we want to pass to the lane
+          key, value = current.split(":")
+          raise "Please pass values like this: key:value" unless key.length > 0 and value.length > 0
           value = convert_value(value)
           Helper.log.debug "Using #{key}: #{value}".green
           lane_parameters[key.to_sym] = value
@@ -26,19 +26,18 @@ module Fastlane
         lane = platform_lane_info[0]
       end
 
-      dot_env = options.env rescue nil # we don't really care about this option in tests
+      dot_env = Helper.is_test? ? nil : options.env
 
       Fastlane::LaneManager.cruise_lane(platform, lane, lane_parameters, dot_env)
     end
 
-    private
-      # Conert into the right data type
-      def self.convert_value(value)
-        return true if (value == 'true' or value == 'yes')
-        return false if (value == 'false' || value == 'no')
-        
-        # Default case:
-        return value
-      end
+    # Helper to convert into the right data type
+    def self.convert_value(value)
+      return true if value == 'true' || value == 'yes'
+      return false if value == 'false' || value == 'no'
+
+      # Default case:
+      return value
+    end
   end
-end
+end

data/lib/fastlane/configuration_helper.rb

@@ -1,29 +1,27 @@
 module Fastlane
   class ConfigurationHelper
     def self.parse(action, params)
-      begin
-        first_element = (action.available_options.first rescue nil) # might also be nil
-        
-        if first_element and first_element.kind_of?FastlaneCore::ConfigItem
-          # default use case
-          return FastlaneCore::Configuration.create(action.available_options, params)
+      first_element = (action.available_options || []).first
 
-        elsif first_element
-          puts "Old configuration format for action '#{action}'".red if Helper.is_test?
-          return params
-        else
+      if first_element and first_element.kind_of? FastlaneCore::ConfigItem
+        # default use case
+        return FastlaneCore::Configuration.create(action.available_options, params)
 
-          # No parameters... we still need the configuration object array
-          FastlaneCore::Configuration.create(action.available_options, {})
+      elsif first_element
+        puts "Old configuration format for action '#{action}'".red if Helper.is_test?
+        return params
+      else
 
-        end
-      rescue => ex
-        if action.respond_to?:action_name
-          Helper.log.fatal "You passed invalid parameters to '#{action.action_name}'.".red
-          Helper.log.fatal "Check out the error below and available options by running `fastlane action #{action.action_name}`".red
-        end
-        raise ex
+        # No parameters... we still need the configuration object array
+        FastlaneCore::Configuration.create(action.available_options, {})
+
+      end
+    rescue => ex
+      if action.respond_to? :action_name
+        Helper.log.fatal "You passed invalid parameters to '#{action.action_name}'.".red
+        Helper.log.fatal "Check out the error below and available options by running `fastlane action #{action.action_name}`".red
       end
+      raise ex
     end
   end
-end
+end

data/lib/fastlane/core_ext/string.rb

@@ -5,8 +5,8 @@ class String
 
   def fastlane_underscore
     self.gsub(/::/, '/').
-    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+    gsub(/([a-z\d])([A-Z])/, '\1_\2').
     tr("-", "_").
     downcase
   end

data/lib/fastlane/docs_generator.rb

@@ -10,25 +10,24 @@ module Fastlane
       output << "```"
 
       output << "# Available Actions"
-      
-      all_keys = ff.runner.lanes.keys.reject(&:nil?) 
+
+      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|
         output << "## #{formatted_platform(platform)}" if platform
 
         value = ff.runner.lanes[platform]
+        next unless value
 
-        if value
-          value.each do |lane_name, lane|
-            next if lane.is_private
-            output << render(platform, lane_name, lane.description.join("\n\n"))          
-          end
-
-          output << ""
-          output << "----"
-          output << ""
+        value.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 << "Generate this documentation by running `fastlane docs`"
@@ -39,29 +38,31 @@ module Fastlane
       Helper.log.info "Successfully generated documentation to path '#{File.expand_path(output_path)}'".green
     end
 
-    private
+    #####################################################
+    # @!group Helper
+    #####################################################
 
-      def self.formatted_platform(pl)
-        pl = pl.to_s
-        return "iOS" if pl == 'ios'
-        return "Mac" if pl == 'mac'
+    def self.formatted_platform(pl)
+      pl = pl.to_s
+      return "iOS" if pl == 'ios'
+      return "Mac" if pl == 'mac'
 
-        return pl
-      end
+      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(' ')
+    # @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
+      output = []
+      output << "### #{full_name}"
+      output << "```"
+      output << "fastlane #{full_name}"
+      output << "```"
+      output << description
+      output
+    end
   end
-end
+end

data/lib/fastlane/erb_template_helper.rb

@@ -13,7 +13,7 @@ module Fastlane
       File.read(template_filepath)
     end
 
-    def self.render(template,template_vars_hash)
+    def self.render(template, template_vars_hash)
       Fastlane::ErbalT.new(template_vars_hash).render(template)
     end
 

data/lib/fastlane/fast_file.rb

@@ -23,13 +23,14 @@ module Fastlane
       @runner ||= Runner.new
 
       Dir.chdir(Fastlane::FastlaneFolder.path || Dir.pwd) do # context: fastlane subfolder
+        # rubocop:disable Lint/Eval
         eval(data) # this is okay in this case
+        # rubocop:enable Lint/Eval
       end
 
       self
     end
 
-
     #####################################################
     # @!group DSL
     #####################################################
@@ -37,7 +38,7 @@ module Fastlane
     # User defines a new lane
     def lane(lane_name, &block)
       raise "You have to pass a block using 'do' for lane '#{lane_name}'. Make sure you read the docs on GitHub.".red unless block
-      
+
       self.runner.add_lane(Lane.new(platform: self.current_platform,
                                        block: block,
                                  description: desc_collection,
@@ -72,10 +73,10 @@ module Fastlane
 
       @desc_collection = nil # reset the collected description again for the next lane
     end
-    
+
     # User defines a platform block
     def platform(platform_name, &block)
-      SupportedPlatforms.verify!platform_name
+      SupportedPlatforms.verify! platform_name
 
       self.current_platform = platform_name
 
@@ -101,12 +102,15 @@ module Fastlane
 
     # Is used to look if the method is implemented as an action
     def method_missing(method_sym, *arguments, &_block)
+      method_str = method_sym.to_s
+      method_str.delete!('?') # as a `?` could be at the end of the method name
+
       # First, check if there is a predefined method in the actions folder
-      class_name = method_sym.to_s.fastlane_class + 'Action'
+      class_name = method_str.fastlane_class + 'Action'
       class_ref = nil
       begin
         class_ref = Fastlane::Actions.const_get(class_name)
-      rescue NameError => ex
+      rescue NameError
         # Action not found
         # Is there a lane under this name?
         return self.runner.try_switch_to_lane(method_sym, arguments)
@@ -135,8 +139,8 @@ module Fastlane
     def is_platform_block?(key)
       raise 'No key given'.red unless key
 
-      return false if (self.runner.lanes[nil][key.to_sym] rescue false)
-      return true if self.runner.lanes[key.to_sym].kind_of?Hash
+      return false if self.runner.lanes.fetch(nil, {}).fetch(key.to_sym, nil)
+      return true if self.runner.lanes[key.to_sym].kind_of? Hash
 
       raise "Could not find '#{key}'. Available lanes: #{self.runner.available_lanes.join(', ')}".red
     end
@@ -169,9 +173,9 @@ module Fastlane
       unless Pathname.new(path).absolute? # unless an absolute path
         path = File.join(File.expand_path('..', @path), path)
       end
-      
-      raise "Could not find Fastfile at path '#{path}'".red unless File.exists?(path)
-      
+
+      raise "Could not find Fastfile at path '#{path}'".red unless File.exist?(path)
+
       collector.did_launch_action(:import)
       parse(File.read(path))
 
@@ -181,8 +185,9 @@ module Fastlane
     end
 
     # @param url [String] The git URL to clone the repository from
+    # @param branch [String] The branch to checkout in the repository
     # @param path [String] The path to the Fastfile
-    def import_from_git(url: nil, path: 'fastlane/Fastfile')
+    def import_from_git(url: nil, branch: 'HEAD', path: 'fastlane/Fastfile')
       raise "Please pass a path to the `import_from_git` action".red if url.to_s.length == 0
 
       Actions.execute_action('import_from_git') do
@@ -192,13 +197,17 @@ module Fastlane
         repo_name = url.split("/").last
 
         folder = File.join("/tmp", "fl_clones", repo_name)
-        clone_command = "git clone '#{url}' '#{folder}' --depth 1 -n"
 
-        if File.directory?folder
+        branch_option = ""
+        branch_option = "--branch #{branch}" if branch != 'HEAD'
+
+        clone_command = "git clone '#{url}' '#{folder}' --depth 1 -n #{branch_option}"
+
+        if File.directory? folder
           Helper.log.info "Using existing git repo..."
           begin
             Actions.sh("cd '#{folder}' && git pull")
-          rescue => ex
+          rescue
             # Something went wrong, clear the folder and pull again
             Actions.sh("rm -rf '#{folder}'")
             Actions.sh(clone_command)
@@ -209,15 +218,15 @@ module Fastlane
           Actions.sh(clone_command)
         end
 
-        Actions.sh("cd '#{folder}' && git checkout HEAD '#{path}'")
+        Actions.sh("cd '#{folder}' && git checkout #{branch} '#{path}'")
 
         # We also want to check out all the local actions of this fastlane setup
         containing = path.split(File::SEPARATOR)[0..-2]
         containing = "." if containing.count == 0
         actions_folder = File.join(containing, "actions")
         begin
-          Actions.sh("cd '#{folder}' && git checkout HEAD '#{actions_folder}'")
-        rescue => ex
+          Actions.sh("cd '#{folder}' && git checkout #{branch} '#{actions_folder}'")
+        rescue
           # We don't care about a failure here, as local actions are optional
         end
 

data/lib/fastlane/fastlane_folder.rb

@@ -13,7 +13,7 @@ module Fastlane
       return value
     end
 
-    # Does a fastlane configuration already exist? 
+    # Does a fastlane configuration already exist?
     def self.setup?
       return false unless path
       File.exist?(File.join(path, "Fastfile"))