fastlane 1.8.0 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c339ea21edfc2acca2f46b9a751d03795647c3f6
-  data.tar.gz: 9c35a144521c7f03f7a9c7fe5441026ed9882d59
+  metadata.gz: beef52022ff1b725c056cb6d6b76940e08a80e47
+  data.tar.gz: 7d3ae10b2bd5e238fb9476d14ea3133f53c3fb04
 SHA512:
-  metadata.gz: cc15fe2094ff6748d3c9f9ba7fc029b60eb7faafe91b9f7c407a749232fed51ab25a852f6b69b746ae4b0b3cd296cc260aa9b4e291385a09c530369978a05beb
-  data.tar.gz: 4849594603cd554346c5ddc54d97a1365903df26f1a14507719ecd2434ae780c79515a7c8c88c5d0392f5bfffac7da8694bc63487d3abb972bbdd965499fcd06
+  metadata.gz: 0cd216d8caabb4f7cbfe99e0d9adf6bba9269fd75f0561939c4f7e0675c9b6bc156f9ec54de1533f3f2d1ef2f17567721799654ffbe2af178dd4e4fb7f086b59
+  data.tar.gz: f882d73eb82fc32a530ae6538060c3c9895fe5b222fcbab700253a8dd9e1f1145ade69dc74b0b11453dffc4942640669e520b9fefd4b2ab98d977b163e71dbd8

data/lib/assets/custom_action_template.rb

@@ -24,6 +24,12 @@ module Fastlane
         "A short description with <= 80 characters of what this action does"
       end
 
+      def self.details
+        # Optional:
+        # this is your change to provide a more detailed description of this action
+        "You can use this action to do cool things..."
+      end
+
       def self.available_options
         # Define all options your action supports. 
         

data/lib/fastlane.rb

@@ -5,6 +5,7 @@ require 'fastlane/fast_file'
 require 'fastlane/dependency_checker'
 require 'fastlane/runner'
 require 'fastlane/setup'
+require 'fastlane/lane'
 require 'fastlane/fastlane_folder'
 require 'fastlane/junit_generator'
 require 'fastlane/lane_manager'

data/lib/fastlane/actions/actions_helper.rb

@@ -8,10 +8,7 @@ module Fastlane
       ENVIRONMENT = :ENVIRONMENT
     end
 
-    def self.executed_actions
-      @executed_actions ||= []
-    end
-
+    # Helper Methods
     def self.git_author
       s = `git log --name-status HEAD^..HEAD`
       s = s.match(/Author:.*<(.*)>/)[1]
@@ -27,6 +24,18 @@ module Fastlane
       nil
     end
 
+    # Returns the current git branch - can be replaced using the environment variable `GIT_BRANCH`
+    def self.git_branch
+      return ENV['GIT_BRANCH'] if ENV['GIT_BRANCH'].to_s.length > 0 # set by Jenkins
+      s = `git rev-parse --abbrev-ref HEAD`
+      return s.to_s.strip if s.to_s.length > 0
+      nil
+    end
+
+
+    def self.executed_actions
+      @executed_actions ||= []
+    end
 
     # The shared hash can be accessed by any action and contains information like the screenshots path or beta URL
     def self.lane_context
@@ -109,14 +118,6 @@ module Fastlane
       Encoding.default_internal = previous_encoding.last
     end
 
-    # Returns the current git branch - can be replaced using the environment variable `GIT_BRANCH`
-    def self.git_branch
-      return ENV['GIT_BRANCH'] if ENV['GIT_BRANCH'].to_s.length > 0 # set by Jenkins
-      s = `git rev-parse --abbrev-ref HEAD`
-      return s.to_s.strip if s.to_s.length > 0
-      nil
-    end
-
     # returns a list of official integrations
     def self.get_all_official_actions
       Dir[File.expand_path '*.rb', File.dirname(__FILE__)].collect do |file|

data/lib/fastlane/actions/ensure_git_branch.rb

@@ -7,9 +7,8 @@ module Fastlane
     class EnsureGitBranchAction < Action
       def self.run(params)
         branch = params[:branch]
-
         if Actions.git_branch != branch
-          raise "Git is not on the `#{branch}` branch! Please ensure the repo is checked out to the correct branch.".red
+          raise "Git is not on the `#{branch}` branch, but on `#{Actions.git_branch}`! Please ensure the repo is checked out to the correct branch.".red
         else
           Helper.log.info "Git branch is `#{branch}`, all good! 💪".green
         end

data/lib/fastlane/actions/get_github_release.rb

@@ -0,0 +1,112 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      GET_GITHUB_RELEASE_INFO = :GET_GITHUB_RELEASE_INFO
+    end
+
+    class GetGithubReleaseAction < Action
+      def self.run(params)
+        Helper.log.info "Verifying release on GitHub (#{params[:url]}: #{params[:version]})"
+        require 'excon'
+        result = JSON.parse(Excon.get("https://api.github.com/repos/#{params[:url]}/releases").body)
+        result.each do |current|
+          if current['tag_name'] == params[:version]
+            # Found it
+            if current['body'].to_s.length > 0
+              Actions.lane_context[SharedValues::GET_GITHUB_RELEASE_INFO] = current
+              Helper.log.info "Version is already live on GitHub.com 🚁"
+              return current
+            else
+              raise "No release notes found for #{params[:version]}"
+            end
+          end 
+        end
+
+        Helper.log.error "Couldn't find GitHub release #{params[:version]}".yellow
+        return nil
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "This will verify if a given release version is avialable on GitHub"
+      end
+
+      def self.details
+        sample = '
+              {"url"=>"https://api.github.com/repos/KrauseFx/fastlane/releases/1537713",
+                 "assets_url"=>"https://api.github.com/repos/KrauseFx/fastlane/releases/1537713/assets",
+                 "upload_url"=>"https://uploads.github.com/repos/KrauseFx/fastlane/releases/1537713/assets{?name}",
+                 "html_url"=>"https://github.com/KrauseFx/fastlane/releases/tag/1.8.0",
+                 "id"=>1537713,
+                 "tag_name"=>"1.8.0",
+                 "target_commitish"=>"master",
+                 "name"=>"1.8.0 Switch Lanes & Pass Parameters",
+                 "draft"=>false,
+                 "author"=>
+                  {"login"=>"KrauseFx",
+                   "id"=>869950,
+                   "avatar_url"=>"https://avatars.githubusercontent.com/u/869950?v=3",
+                   "gravatar_id"=>"",
+                   "url"=>"https://api.github.com/users/KrauseFx",
+                   "html_url"=>"https://github.com/KrauseFx",
+                   "followers_url"=>"https://api.github.com/users/KrauseFx/followers",
+                   "following_url"=>"https://api.github.com/users/KrauseFx/following{/other_user}",
+                   "gists_url"=>"https://api.github.com/users/KrauseFx/gists{/gist_id}",
+                   "starred_url"=>"https://api.github.com/users/KrauseFx/starred{/owner}{/repo}",
+                   "subscriptions_url"=>"https://api.github.com/users/KrauseFx/subscriptions",
+                   "organizations_url"=>"https://api.github.com/users/KrauseFx/orgs",
+                   "repos_url"=>"https://api.github.com/users/KrauseFx/repos",
+                   "events_url"=>"https://api.github.com/users/KrauseFx/events{/privacy}",
+                   "received_events_url"=>"https://api.github.com/users/KrauseFx/received_events",
+                   "type"=>"User",
+                   "site_admin"=>false},
+                 "prerelease"=>false,
+                 "created_at"=>"2015-07-14T23:33:01Z",
+                 "published_at"=>"2015-07-14T23:44:10Z",
+                 "assets"=>[],
+                 "tarball_url"=>"https://api.github.com/repos/KrauseFx/fastlane/tarball/1.8.0",
+                 "zipball_url"=>"https://api.github.com/repos/KrauseFx/fastlane/zipball/1.8.0",
+                 "body"=>
+                "This is one of the biggest updates of `fastlane` yet"
+              }'
+
+        [
+          "This will return all information about a release. For example:",
+          sample
+        ].join("\n")
+      end
+
+      def self.output
+        [
+          ['GET_GITHUB_RELEASE_INFO', 'Contains all the information about this release']
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :url,
+                                       env_name: "FL_GET_GITHUB_RELEASE_URL",
+                                       description: "The path to your repo, e.g. 'KrauseFx/fastlane'",
+                                       verify_block: Proc.new do |value|
+                                          raise "Please only pass the path, e.g. 'KrauseFx/fastlane'".red if value.include?"github.com"
+                                          raise "Please only pass the path, e.g. 'KrauseFx/fastlane'".red if value.split('/').count != 2
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :version,
+                                       env_name: "FL_GET_GITHUB_RELEASE_VERSION",
+                                       description: "The version tag of the release to check")
+        ]
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/actions/git_branch.rb

@@ -0,0 +1,41 @@
+module Fastlane
+  module Actions
+    module SharedValues
+
+    end
+
+    class GitBranchAction < Action
+      def self.run(params)
+        ENV['GIT_BRANCH'] or `git symbolic-ref HEAD --short 2>/dev/null`.strip
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Returns the name of the current git branch"
+      end
+
+      def self.details
+        "If no branch could be found, this action will return nil"
+      end
+
+      def self.available_options
+        []
+      end
+
+      def self.output
+        []
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/actions/prompt.rb

@@ -0,0 +1,58 @@
+module Fastlane
+  module Actions
+    class PromptAction < Action
+      def self.run(params)
+        params[:text] += " (y/n)" if params[:boolean]
+        Helper.log.info params[:text]
+
+        user_input = params[:ci_input] if Helper.is_ci?
+        user_input ||= STDIN.gets.chomp.strip
+
+        user_input = (user_input.downcase == 'y') if params[:boolean]
+
+        return user_input
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Ask the user for a value or for confirmation"
+      end
+
+      def self.details
+        [
+          "You can use `prompt` to ask the user for a value or to just let the user confirm the next step",
+          "When this is executed on a CI service, the passed `ci_input` value will be returned"
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :text,
+                                       description: "The text that will be displayed to the user"),
+          FastlaneCore::ConfigItem.new(key: :ci_input,
+                                       description: "The default text that will be used when being executed on a CI service",
+                                       default_value: ''),
+          FastlaneCore::ConfigItem.new(key: :boolean,
+                                       description: "Is that a boolean question (yes/no)? This will add (y/n) at the end",
+                                       default_value: false,
+                                       is_string: false)
+        ]
+      end
+
+      def self.output
+        []
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/actions/puts.rb

@@ -0,0 +1,25 @@
+module Fastlane
+  module Actions
+    class PutsAction < Action
+      def self.run(params)
+        Helper.log.info params.join(' ')
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Prints out the given text"
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/actions/slack.rb

@@ -82,6 +82,11 @@ module Fastlane
                                        description: "Remove some of the default payloads. More information about the available payloads on GitHub",
                                        optional: true,
                                        is_string: false),
+          FastlaneCore::ConfigItem.new(key: :attachment_properties,
+                                       env_name: "FL_SLACK_ATTACHMENT_PROPERTIES",
+                                       description: "Merge additional properties in the slack attachment, see https://api.slack.com/docs/attachments",
+                                       default_value: {},
+                                       is_string: false),
           FastlaneCore::ConfigItem.new(key: :success,
                                        env_name: "FL_SLACK_SUCCESS",
                                        description: "Was this build successful? (true/false)",
@@ -128,7 +133,7 @@ module Fastlane
           # test_result
           if should_add_payload[:test_result]
             slack_attachment[:fields] << {
-              title: 'Test Result',
+              title: 'Result',
               value: (options[:success] ? 'Success' : 'Error'),
               short: true
             }
@@ -165,7 +170,16 @@ module Fastlane
             }
           end
 
-          slack_attachment
+          # merge additional properties
+          deep_merge(slack_attachment, options[:attachment_properties])
+        end
+
+        # Adapted from http://stackoverflow.com/a/30225093/158525
+        def self.deep_merge(a, b)
+          merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? 
+                            v1.merge(v2, &merger) : Array === v1 && Array === v2 ? 
+                              v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
+          a.merge(b, &merger)
         end
     end
   end

data/lib/fastlane/docs_generator.rb

@@ -11,17 +11,17 @@ module Fastlane
 
       output << "# Available Actions"
       
-      all_keys = ff.runner.description_blocks.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.description_blocks[platform]
+        value = ff.runner.lanes[platform]
 
         if value
-          value.each do |lane, description|
-            output << render(platform, lane, description)          
+          value.each do |lane_name, lane|
+            output << render(platform, lane_name, lane.description.join("\n\n"))          
           end
 
           output << ""

data/lib/fastlane/fast_file.rb

@@ -1,7 +1,12 @@
 module Fastlane
   class FastFile
+    # Stores all relevant information from the currently running process
     attr_accessor :runner
 
+    # the platform in which we're currently in when parsing the Fastfile
+    # This is used to identify the platform in which the lane is in
+    attr_accessor :current_platform
+
     SharedValues = Fastlane::Actions::SharedValues
 
     # @return The runner which can be executed to trigger the given actions
@@ -34,10 +39,10 @@ module Fastlane
     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
       
-      desc = desc_collection.join("\n\n")
-      platform = @current_platform
-
-      @runner.set_block(lane_name, platform, block, desc)
+      self.runner.add_lane(Lane.new(platform: self.current_platform,
+                                       block: block,
+                                 description: desc_collection,
+                                        name: lane_name))
 
       @desc_collection = nil # reset the collected description again for the next lane
     end
@@ -46,11 +51,11 @@ module Fastlane
     def platform(platform_name, &block)
       SupportedPlatforms.verify!platform_name
 
-      @current_platform = platform_name
+      self.current_platform = platform_name
 
       block.call
 
-      @current_platform = nil
+      self.current_platform = nil
     end
 
     # Is executed before each test run
@@ -68,61 +73,6 @@ module Fastlane
       @runner.set_error(@current_platform, block)
     end
 
-    def try_switch_to_lane(new_lane, parameters)
-      current_platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
-      block = @runner.blocks.fetch(current_platform, {}).fetch(new_lane, nil)
-      platform_nil = (block == nil) # used for the output
-      block ||= @runner.blocks.fetch(nil, {}).fetch(new_lane, nil) # fallback to general lane for multiple platforms
-      if block
-        pretty = [new_lane]
-        pretty = [current_platform, new_lane] unless platform_nil
-        Helper.log.info "Cruising over to lane '#{pretty.join(' ')}' 🚖".green
-        collector.did_launch_action(:lane_switch)
-        result = block.call(parameters.first || {}) # to always pass a hash
-        original_lane = Actions.lane_context[Actions::SharedValues::LANE_NAME]
-        Helper.log.info "Cruising back to lane '#{original_lane}' 🚘".green
-        return result
-      else
-        # No action and no lane, raising an exception now
-        raise "Could not find action or lane '#{new_lane}'. Check out the README for more details: https://github.com/KrauseFx/fastlane".red
-      end
-    end
-
-    def execute_action(method_sym, class_ref, arguments)
-      collector.did_launch_action(method_sym)
-
-      step_name = class_ref.step_text rescue nil
-      step_name = method_sym.to_s unless step_name
-
-      verify_supported_os(method_sym, class_ref)
-
-      Helper.log_alert("Step: " + step_name)
-
-      begin
-        Dir.chdir('..') do # go up from the fastlane folder, to the project folder
-          Actions.execute_action(method_sym) do
-            # arguments is an array by default, containing an hash with the actual parameters
-            # Since we usually just need the passed hash, we'll just use the first object if there is only one
-            if arguments.count == 0 
-              arguments = ConfigurationHelper.parse(class_ref, {}) # no parameters => empty hash
-            elsif arguments.count == 1 and arguments.first.kind_of?Hash
-              arguments = ConfigurationHelper.parse(class_ref, arguments.first) # Correct configuration passed
-            elsif not class_ref.available_options
-              # This action does not use the new action format
-              # Just passing the arguments to this method
-            else
-              raise "You have to pass the options for '#{method_sym}' in a different way. Please check out the current documentation on GitHub!".red
-            end
-
-            class_ref.run(arguments)
-          end
-        end
-      rescue => ex
-        collector.did_raise_error(method_sym)
-        raise ex
-      end
-    end
-
     # Is used to look if the method is implemented as an action
     def method_missing(method_sym, *arguments, &_block)
       # First, check if there is a predefined method in the actions folder
@@ -132,14 +82,14 @@ module Fastlane
         class_ref = Fastlane::Actions.const_get(class_name)
         if class_ref && class_ref.respond_to?(:run)
           # Action is available, now execute it
-          return execute_action(method_sym, class_ref, arguments)
+          return self.runner.execute_action(method_sym, class_ref, arguments)
         else
           raise "Action '#{method_sym}' of class '#{class_name}' was found, but has no `run` method.".red
         end
       rescue NameError => ex
         # Action not found
         # Is there a lane under this name?
-        return try_switch_to_lane(method_sym, arguments)
+        return self.runner.try_switch_to_lane(method_sym, arguments)
       end
     end
 
@@ -147,21 +97,16 @@ module Fastlane
     # @!group Other things
     #####################################################
 
-    # Speak out loud
-    def say(value)
-      # Overwrite this, since there is already a 'say' method defined in the Ruby standard library
-      value ||= yield
-      Actions.execute_action('say') do
-        Fastlane::Actions::SayAction.run([value])
-      end
+    def collector
+      runner.collector
     end
 
     # Is the given key a platform block or a lane?
     def is_platform_block?(key)
       raise 'No key given'.red unless key
 
-      return false if (self.runner.blocks[nil][key.to_sym] rescue false)
-      return true if self.runner.blocks[key.to_sym].kind_of?Hash
+      return false if (self.runner.lanes[nil][key.to_sym] rescue false)
+      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
@@ -179,34 +124,35 @@ module Fastlane
       end
     end
 
-    def verify_supported_os(name, class_ref)
-      if class_ref.respond_to?(:is_supported?)
-        if Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
-          # This value is filled in based on the executed platform block. Might be nil when lane is in root of Fastfile
-          platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
-
-          unless class_ref.is_supported?(platform)
-            raise "Action '#{name}' doesn't support required operating system '#{platform}'.".red 
-          end
-        end
-      end
+    def desc(string)
+      desc_collection << string
     end
 
-    # Fastfile was finished executing
-    def did_finish
-      collector.did_finish
+    def desc_collection
+      @desc_collection ||= []
     end
 
-    def desc(string)
-      desc_collection << string
-    end
+    #####################################################
+    # @!group Overwriting Ruby methods
+    #####################################################
 
-    def collector
-      @collector ||= ActionCollector.new
+    # Speak out loud
+    def say(value)
+      # Overwrite this, since there is already a 'say' method defined in the Ruby standard library
+      value ||= yield
+      Actions.execute_action('say') do
+        collector.did_launch_action(:say)
+        Fastlane::Actions::SayAction.run([value])
+      end
     end
 
-    def desc_collection
-      @desc_collection ||= []
+    def puts(value)
+      # Overwrite this, since there is already a 'puts' method defined in the Ruby standard library
+      value ||= yield
+      Actions.execute_action('puts') do
+        collector.did_launch_action(:pus)
+        Fastlane::Actions::PutsAction.run([value])
+      end
     end
   end
 end

data/lib/fastlane/fastlane_folder.rb

@@ -4,11 +4,13 @@ module Fastlane
 
     # Path to the fastlane folder containing the Fastfile and other configuration files
     def self.path
-      return "./#{FOLDER_NAME}/" if File.directory?("./#{FOLDER_NAME}/")
-      return "./.#{FOLDER_NAME}/" if File.directory?("./.#{FOLDER_NAME}/") # hidden folder
-      return './' if File.basename(Dir.getwd) == FOLDER_NAME && File.exist?('Fastfile') # inside the folder
-      return './' if File.basename(Dir.getwd) == ".#{FOLDER_NAME}" && File.exist?('Fastfile') # inside the folder and hidden
-      nil
+      value ||= "./#{FOLDER_NAME}/" if File.directory?("./#{FOLDER_NAME}/")
+      value ||= "./.#{FOLDER_NAME}/" if File.directory?("./.#{FOLDER_NAME}/") # hidden folder
+      value ||= "./" if File.basename(Dir.getwd) == FOLDER_NAME && File.exist?('Fastfile') # inside the folder
+      value ||= "./" if File.basename(Dir.getwd) == ".#{FOLDER_NAME}" && File.exist?('Fastfile') # inside the folder and hidden
+
+      value = nil if Helper.is_test? # this is required, as the tests would use the ./fastlane folder otherwise
+      return value
     end
 
     # Does a fastlane configuration already exist? 

data/lib/fastlane/lane.rb

@@ -0,0 +1,33 @@
+module Fastlane
+  # Represents a lane
+  class Lane
+    attr_accessor :platform
+
+    attr_accessor :name
+
+    # @return (Array) An array containing the description of this lane
+    #   Each item of the array is one line
+    attr_accessor :description
+
+    attr_accessor :block
+
+    def initialize(platform: nil, name: nil, description: nil, block: nil)
+      raise "description must be an array" unless description.kind_of?Array
+      
+      self.platform = platform
+      self.name = name
+      self.description = description
+      self.block = block
+    end
+
+    # Execute this lane
+    def call(parameters)
+      block.call(parameters || {})
+    end
+
+    # @return [String] The lane + name of the lane. If there is no platform, it will only be the lane name
+    def pretty_name
+      [platform, name].reject(&:nil?).join(' ')
+    end
+  end
+end

data/lib/fastlane/lane_list.rb

@@ -12,25 +12,21 @@ module Fastlane
       ff = Fastlane::FastFile.new(path)
       output = ""
       
-      all_keys = ff.runner.description_blocks.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|
-        next if (ff.runner.description_blocks[platform] || []).count == 0
+        next if (ff.runner.lanes[platform] || []).count == 0
         plat_text = platform
         plat_text = "general" if platform.to_s.empty?
         output += "\n--------- #{plat_text}---------\n".yellow
       
-        value = ff.runner.description_blocks[platform]
+        value = ff.runner.lanes[platform]
         
         if value
-          value.each do |lane, description|
-            lane_text = "----- fastlane "
-            lane_text += platform.to_s + " " if platform
-            lane_text += lane.to_s + "\n"
-
-            output += lane_text.green
-            output += description.gsub("\n\n", "\n") + "\n\n" if description.to_s.length > 0
+          value.each do |lane_name, lane|
+            output += "----- fastlane #{lane.pretty_name}".green
+            output += "\n" + lane.description.join("\n") + "\n\n" if lane.description.count > 0
           end
         end
       end

data/lib/fastlane/lane_manager.rb

@@ -50,7 +50,7 @@ module Fastlane
 
     # All the finishing up that needs to be done
     def self.finish_fastlane(ff, duration, error)
-      ff.did_finish
+      ff.runner.did_finish
 
       # Finished with all the lanes
       Fastlane::JUnitGenerator.generate(Fastlane::Actions.executed_actions)

data/lib/fastlane/runner.rb

@@ -1,48 +1,56 @@
 module Fastlane
   class Runner
+    # Symbol for the current lane
+    attr_accessor :current_lane
 
-    # This will take care of executing **one** lane. 
+    # Symbol for the current platform
+    attr_accessor :current_platform
+
+    # @return [Hash] All the lanes available, first the platform, then the lane
+    attr_accessor :lanes
+
+    def full_lane_name
+      [current_platform, current_lane].reject(&:nil?).join(' ')
+    end
+
+    # This will take care of executing **one** lane. That's when the user triggers a lane from the CLI for example
+    # This method is **not** executed when switching a lane
     # @param lane_name The name of the lane to execute
     # @param platform The name of the platform to execute
     # @param parameters [Hash] The parameters passed from the command line to the lane
     def execute(lane, platform = nil, parameters = nil)
       raise "No lane given" unless lane
 
-      ENV["FASTLANE_LANE_NAME"] = lane.to_s
-      if platform
-        ENV["FASTLANE_PLATFORM_NAME"] = platform.to_s
-      else
-        ENV["FASTLANE_PLATFORM_NAME"] = nil
-      end
-      
-      lane = lane.to_sym
-      platform = platform.to_sym if platform # might be nil, which is okay => root element
+      self.current_lane = lane.to_sym
+      self.current_platform = (platform ? platform.to_sym : nil)
 
-      Actions.lane_context[Actions::SharedValues::PLATFORM_NAME] = platform # set this in any case: important
+      ENV["FASTLANE_LANE_NAME"] = current_lane.to_s
+      ENV["FASTLANE_PLATFORM_NAME"] = (current_platform ? current_platform.to_s : nil)
+      
+      Actions.lane_context[Actions::SharedValues::PLATFORM_NAME] = current_platform
+      Actions.lane_context[Actions::SharedValues::LANE_NAME] = full_lane_name
 
-      full_lane_name = [platform, lane].reject(&:nil?).join(' ')
       Helper.log.info "Driving the lane '#{full_lane_name}' 🚀".green
-      Actions.lane_context[Actions::SharedValues::LANE_NAME] = full_lane_name
 
       return_val = nil
 
       path_to_use = Fastlane::FastlaneFolder.path || Dir.pwd
       Dir.chdir(path_to_use) do # the file is located in the fastlane folder
 
-        unless (blocks[platform][lane] rescue nil)
+        unless (lanes[current_platform][current_lane] rescue nil)
           raise "Could not find lane '#{full_lane_name}'. Available lanes: #{available_lanes.join(', ')}".red
         end
 
         # Call the platform specific before_all block and then the general one
-        before_all_blocks[platform].call(lane) if (before_all_blocks[platform] and platform != nil)
-        before_all_blocks[nil].call(lane) if before_all_blocks[nil]
+        before_all_blocks[current_platform].call(current_lane) if (before_all_blocks[current_platform] and current_platform)
+        before_all_blocks[nil].call(current_lane) if before_all_blocks[nil]
         
-        return_val = blocks[platform][lane].call(parameters || {}) # by default no parameters
+        return_val = lanes[current_platform][current_lane].call(parameters || {}) # by default no parameters
         
         # `after_all` is only called if no exception was raised before
         # Call the platform specific before_all block and then the general one
-        after_all_blocks[platform].call(lane) if (after_all_blocks[platform] and platform != nil)
-        after_all_blocks[nil].call(lane) if (after_all_blocks[nil])
+        after_all_blocks[current_platform].call(current_lane) if (after_all_blocks[current_platform] and current_platform)
+        after_all_blocks[nil].call(current_lane) if (after_all_blocks[nil])
       end
 
       return return_val
@@ -51,26 +59,126 @@ module Fastlane
         # Provide error block exception without colour code
         error_ex = ex.exception(ex.message.gsub(/\033\[\d+m/, ''))
 
-        error_blocks[platform].call(lane, error_ex) if (error_blocks[platform] and platform != nil)
-        error_blocks[nil].call(lane, error_ex) if error_blocks[nil]
+        error_blocks[current_platform].call(current_lane, error_ex) if (error_blocks[current_platform] and current_platform)
+        error_blocks[nil].call(current_lane, error_ex) if error_blocks[nil]
       end
       raise ex
     end
 
     # @param filter_platform: Filter, to only show the lanes of a given platform
+    # @return an array of lanes (platform lane_name) to print them out to the user
     def available_lanes(filter_platform = nil)
       all = []
-      blocks.each do |platform, lane| 
+      lanes.each do |platform, platform_lanes|
         next if (filter_platform and filter_platform.to_s != platform.to_s) # skip actions that don't match
 
-        lane.each do |lane_name, block|
+        platform_lanes.each do |lane_name, lane|
           all << [platform, lane_name].reject(&:nil?).join(' ')
         end
       end
       all
     end
 
-    # Called internally
+    # 
+    # All the methods that are usually called on execution
+    # 
+
+    def try_switch_to_lane(new_lane, parameters)
+      block = lanes.fetch(current_platform, {}).fetch(new_lane, nil)
+      block ||= lanes.fetch(nil, {}).fetch(new_lane, nil) # fallback to general lane for multiple platforms
+      if block
+        original_full = full_lane_name
+        original_lane = current_lane
+
+        raise "Parameters for a lane must always be a hash".red unless (parameters.first || {}).kind_of?Hash
+
+        pretty = [new_lane]
+        pretty = [current_platform, new_lane] if current_platform
+        Helper.log.info "Cruising over to lane '#{pretty.join(' ')}' 🚖".green
+
+        # Actually switch lane now
+        current_lane = new_lane
+        collector.did_launch_action(:lane_switch)
+        result = block.call(parameters.first || {}) # to always pass a hash
+        current_lane = original_lane
+
+        Helper.log.info "Cruising back to lane '#{original_full}' 🚘".green
+        return result
+      else
+        # No action and no lane, raising an exception now
+        raise "Could not find action or lane '#{new_lane}'. Check out the README for more details: https://github.com/KrauseFx/fastlane".red
+      end
+    end
+
+    def execute_action(method_sym, class_ref, arguments)
+      collector.did_launch_action(method_sym)
+
+      step_name = class_ref.step_text rescue nil
+      step_name = method_sym.to_s unless step_name
+
+      verify_supported_os(method_sym, class_ref)
+
+      Helper.log_alert("Step: " + step_name)
+
+      begin
+        Dir.chdir('..') do # go up from the fastlane folder, to the project folder
+          Actions.execute_action(method_sym) do
+            # arguments is an array by default, containing an hash with the actual parameters
+            # Since we usually just need the passed hash, we'll just use the first object if there is only one
+            if arguments.count == 0 
+              arguments = ConfigurationHelper.parse(class_ref, {}) # no parameters => empty hash
+            elsif arguments.count == 1 and arguments.first.kind_of?Hash
+              arguments = ConfigurationHelper.parse(class_ref, arguments.first) # Correct configuration passed
+            elsif not class_ref.available_options
+              # This action does not use the new action format
+              # Just passing the arguments to this method
+            else
+              raise "You have to pass the options for '#{method_sym}' in a different way. Please check out the current documentation on GitHub!".red
+            end
+
+            class_ref.run(arguments)
+          end
+        end
+      rescue => ex
+        collector.did_raise_error(method_sym)
+        raise ex
+      end
+    end
+
+    def verify_supported_os(name, class_ref)
+      if class_ref.respond_to?(:is_supported?)
+        if Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+          # This value is filled in based on the executed platform block. Might be nil when lane is in root of Fastfile
+          platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+
+          unless class_ref.is_supported?(platform)
+            raise "Action '#{name}' doesn't support required operating system '#{platform}'.".red 
+          end
+        end
+      end
+    end
+
+    def collector
+      @collector ||= ActionCollector.new
+    end
+
+    # Fastfile was finished executing
+    def did_finish
+      collector.did_finish
+    end
+
+    # Called internally to setup the runner object
+    # 
+
+    # @param lane [Lane] A lane object
+    def add_lane(lane)
+      lanes[lane.platform] ||= {}
+
+      raise "Lane '#{lane.name}' was defined multiple times!".red if lanes[lane.platform][lane.name]
+      
+      lanes[lane.platform][lane.name] = lane
+    end
+
     def set_before_all(platform, block)
       before_all_blocks[platform] = block
     end
@@ -83,22 +191,8 @@ module Fastlane
       error_blocks[platform] = block
     end
 
-    # @param lane: The name of the lane
-    # @param platform: The platform for the given block - might be nil - nil is actually the root of Fastfile with no specific platform
-    # @param block: The block of the lane
-    # @param desc: Description of this action
-    def set_block(lane, platform, block, desc = nil)
-      blocks[platform] ||= {}
-      description_blocks[platform] ||= {}
-
-      raise "Lane '#{lane}' was defined multiple times!".red if blocks[platform][lane]
-      
-      blocks[platform][lane] = block
-      description_blocks[platform][lane] = desc
-    end
-
-    def blocks
-      @blocks ||= {}
+    def lanes
+      @lanes ||= {}
     end
 
     def before_all_blocks
@@ -112,9 +206,5 @@ module Fastlane
     def error_blocks
       @error_blocks ||= {}
     end
-
-    def description_blocks
-      @description_blocks ||= {}
-    end
   end
 end

data/lib/fastlane/version.rb

@@ -1,3 +1,3 @@
 module Fastlane
-  VERSION = '1.8.0'
+  VERSION = '1.9.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.9.0
 platform: ruby
 authors:
 - Felix Krause
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-14 00:00:00.000000000 Z
+date: 2015-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -430,6 +430,8 @@ files:
 - lib/fastlane/actions/fastlane_version.rb
 - lib/fastlane/actions/frameit.rb
 - lib/fastlane/actions/gcovr.rb
+- lib/fastlane/actions/get_github_release.rb
+- lib/fastlane/actions/git_branch.rb
 - lib/fastlane/actions/hg_add_tag.rb
 - lib/fastlane/actions/hg_commit_version_bump.rb
 - lib/fastlane/actions/hg_ensure_clean_status.rb
@@ -442,6 +444,7 @@ files:
 - lib/fastlane/actions/install_carthage.rb
 - lib/fastlane/actions/install_cocapods.rb
 - lib/fastlane/actions/ipa.rb
+- lib/fastlane/actions/lane_context.rb
 - lib/fastlane/actions/lcov.rb
 - lib/fastlane/actions/mailgun.rb
 - lib/fastlane/actions/notify.rb
@@ -449,7 +452,9 @@ files:
 - lib/fastlane/actions/opt_out_usage.rb
 - lib/fastlane/actions/pem.rb
 - lib/fastlane/actions/produce.rb
+- lib/fastlane/actions/prompt.rb
 - lib/fastlane/actions/push_to_git_remote.rb
+- lib/fastlane/actions/puts.rb
 - lib/fastlane/actions/register_devices.rb
 - lib/fastlane/actions/reset_git_repo.rb
 - lib/fastlane/actions/resign.rb
@@ -483,7 +488,7 @@ files:
 - lib/fastlane/fast_file.rb
 - lib/fastlane/fastlane_folder.rb
 - lib/fastlane/junit_generator.rb
-- lib/fastlane/lane_context.rb
+- lib/fastlane/lane.rb
 - lib/fastlane/lane_list.rb
 - lib/fastlane/lane_manager.rb
 - lib/fastlane/new_action.rb