fastlane 0.10.0 → 0.11.0

data/lib/fastlane/actions/xctool.rb

@@ -23,6 +23,10 @@ module Fastlane
       def self.author
         "KrauseFx"
       end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
     end
   end
 end

data/lib/fastlane/docs_generator.rb

@@ -1,30 +1,50 @@
 module Fastlane
   class DocsGenerator
     def self.run(output_path, ff)
-      output = "fastlane documentation\n"
-      output += "================\n"
+      output = ["fastlane documentation"]
+      output << "================"
 
-      output += "# Installation\n"
-      output += "```\n"
-      output += "sudo gem install fastlane\n"
-      output += "```\n\n"
+      output << "# Installation"
+      output << "```"
+      output << "sudo gem install fastlane"
+      output << "```"
 
-      output += "# Available Actions\n"
+      output << "# Available Actions"
       
-      ff.runner.description_blocks.each do |lane, description|
-        output += "## #{lane}\n\n"
-        output += "```\n"
-        output += "fastlane #{lane}\n"
-        output += "```\n\n"
-        output += description + "\n"
+      all_keys = ff.runner.description_blocks.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 << "## #{platform}" if platform
+
+        value = ff.runner.description_blocks[platform]
+
+        value.each do |lane, description|
+          output << render(platform, lane, description)          
+        end
+
+        output << "----"
       end
 
-      output += "\n\n----\n"
-      output += "More information about fastlane can be found on [https://fastlane.tools](https://fastlane.tools).\n\n"
-      output += "The documentation of fastlane can be found on [GitHub](https://github.com/KrauseFx/fastlane)"
+      output << "More information about fastlane can be found on [https://fastlane.tools](https://fastlane.tools)."
+      output << "The documentation of fastlane can be found on [GitHub](https://github.com/KrauseFx/fastlane)"
 
-      File.write(output_path, output)
+      File.write(output_path, output.join("\n"))
       Helper.log.info "Successfully generated documentation to path '#{File.expand_path(output_path)}'".green
     end
+
+    private
+
+      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
   end
 end

data/lib/fastlane/fast_file.rb

@@ -12,14 +12,6 @@ module Fastlane
       parse(content)
     end
 
-    def collector
-      @collector ||= ActionCollector.new
-    end
-
-    def desc_collection
-      @desc_collection ||= []
-    end
-
     def parse(data)
       @runner = Runner.new
 
@@ -30,55 +22,51 @@ module Fastlane
       self
     end
 
-    def lane(key, &block)
-      desc = desc_collection.join("\n\n")
-      @runner.set_block(key, block, desc)
-      @desc_collection = nil # reset again
-    end
 
-    def before_all(&block)
-      @runner.set_before_all(block)
-    end
+    #####################################################
+    # @!group DSL
+    #####################################################
 
-    def after_all(&block)
-      @runner.set_after_all(block)
-    end
 
-    def error(&block)
-      @runner.set_error(block)
-    end
+    # 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
+      
+      desc = desc_collection.join("\n\n")
+      platform = @current_platform
 
-    # 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
+      @runner.set_block(lane_name, platform, block, desc)
+
+      @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
 
-    def actions_path(path)
-      raise "Path '#{path}' not found!".red unless File.directory?(path)
+      @current_platform = platform_name
 
-      Actions.load_external_actions(path)
+      block.call
+
+      @current_platform = nil
     end
 
-    # Execute shell command
-    def sh(command)
-      Actions.execute_action(command) do
-        Actions.sh_no_action(command)
-      end
+    # Is executed before each test run
+    def before_all(&block)
+      @runner.set_before_all(@current_platform, block)
     end
 
-    # Fastfile was finished executing
-    def did_finish
-      collector.did_finish
+    # Is executed after each test run
+    def after_all(&block)
+      @runner.set_after_all(@current_platform, block)
     end
 
-    def desc(string)
-      desc_collection << string
+    # Is executed if an error occured during fastlane execution
+    def error(&block)
+      @runner.set_error(@current_platform, block)
     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
 
@@ -96,6 +84,9 @@ module Fastlane
 
         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
@@ -112,5 +103,72 @@ module Fastlane
         raise "Action '#{method_sym}' of class '#{class_name}' was found, but has no `run` method.".red
       end
     end
+
+
+    #####################################################
+    # @!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
+    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]
+      return true if self.runner.blocks[key.to_sym].kind_of?Hash
+
+      raise "Could not find '#{key}'. Available lanes: #{self.runner.available_lanes.join(', ')}".red
+    end
+
+    def actions_path(path)
+      raise "Path '#{path}' not found!".red unless File.directory?(path)
+
+      Actions.load_external_actions(path)
+    end
+
+    # Execute shell command
+    def sh(command)
+      Actions.execute_action(command) do
+        Actions.sh_no_action(command)
+      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
+
+    # Fastfile was finished executing
+    def did_finish
+      collector.did_finish
+    end
+
+    def desc(string)
+      desc_collection << string
+    end
+
+    def collector
+      @collector ||= ActionCollector.new
+    end
+
+    def desc_collection
+      @desc_collection ||= []
+    end
   end
 end

data/lib/fastlane/lane_manager.rb

@@ -1,66 +1,59 @@
 module Fastlane
   class LaneManager
-    def self.cruise_lanes(lanes, env=nil)
-      Actions.lane_context[Actions::SharedValues::ENVIRONMENT] = env
-      raise 'lanes must be an array' unless lanes.is_a?(Array)
+    # @param platform The name of the platform to execute
+    # @param lane_name The name of the lane to execute
+    def self.cruise_lane(platform, lane, env = nil)
+      raise 'lane must be a string' unless (lane.is_a?(String) or lane.nil?)
+      raise 'platform must be a string' unless (platform.is_a?(String) or platform.nil?)
 
       ff = Fastlane::FastFile.new(File.join(Fastlane::FastlaneFolder.path, 'Fastfile'))
 
-      if lanes.count == 0
-        loop do
-          Helper.log.error "You must provide a lane to drive. Available lanes:"
-          available = ff.runner.available_lanes
-
-          available.each_with_index do |lane, index|
-            puts "#{index + 1}) #{lane}"
-          end
-
-          i = gets.strip.to_i - 1
-          if i >= 0 and (available[i] rescue nil)
-            lanes = [available[i]]
-            Helper.log.info "Driving the lane #{lanes.first}. Next time launch fastlane using `fastlane #{lanes.first}`".green
-            break # yeah
-          end
+      unless (ff.is_platform_block?lane rescue false) # rescue, because this raises an exception if it can't be found at all
+        # maybe the user specified a default platform
+        # We'll only do this, if the lane specified isn't a platform, as we want to list all platforms then
+        platform ||= Actions.lane_context[Actions::SharedValues::DEFAULT_PLATFORM]
+      end
 
-          Helper.log.error "Invalid input. Please enter the number of the lane you want to use".red
+      if not platform and lane
+        # Either, the user runs a specific lane in root or want to auto complete the available lanes for a platform
+        # e.g. `fastlane ios` should list all available iOS actions
+        if ff.is_platform_block?lane
+          platform = lane
+          lane = nil
         end
       end
 
-      # Making sure the default '.env' and '.env.default' get loaded
-      env_file = File.join(Fastlane::FastlaneFolder.path || "", '.env')
-      env_default_file = File.join(Fastlane::FastlaneFolder.path || "", '.env.default')
-      Dotenv.load(env_file, env_default_file)
+      platform, lane = choose_lane(ff, platform) unless lane
 
-      # Loads .env file for the environment passed in through options
-      if env
-        env_file = File.join(Fastlane::FastlaneFolder.path || "", ".env.#{env}")
-        Helper.log.info "Loading from '#{env_file}'".green
-        Dotenv.overload(env_file)
-      end
+      load_dot_env(env)
 
-      start = Time.now
+      started = Time.now
       e = nil
       begin
-        lanes.each do |key|
-          ff.runner.execute(key)
-        end
+        ff.runner.execute(lane, platform)
       rescue => ex
-        if Actions.lane_context.count > 0
-          Helper.log.info 'Variable Dump:'.yellow
-          Helper.log.info Actions.lane_context
-        end
+        Helper.log.info 'Variable Dump:'.yellow
+        Helper.log.info Actions.lane_context
         Helper.log.fatal ex
         e = ex
       end
 
+      duration = ((Time.now - started) / 60.0).round
+
+      finish_fastlane(ff, duration, e)
+
+      return ff
+    end
+
+    # All the finishing up that needs to be done
+    def self.finish_fastlane(ff, duration, error)
       thread = ff.did_finish
 
       # Finished with all the lanes
       Fastlane::JUnitGenerator.generate(Fastlane::Actions.executed_actions)
 
-      duration = ((Time.now - start) / 60.0).round
 
-      unless e
+      unless error
         thread.join # to wait for the request to be finished
         if duration > 5
           Helper.log.info "fastlane.tools just saved you #{duration} minutes! 🎉".green
@@ -70,9 +63,56 @@ module Fastlane
       else
         thread.join # to wait for the request to be finished
         Helper.log.fatal 'fastlane finished with errors'.red
-        raise e
+        raise error
+      end
+    end
+
+    # Lane chooser if user didn't provide a lane
+    # @param platform: is probably nil, but user might have called `fastlane android`, and only wants to list those actions
+    def self.choose_lane(ff, platform)
+      loop do
+        Helper.log.error "You must provide a lane to drive. Available lanes:"
+        available = ff.runner.available_lanes(platform)
+
+        available.each_with_index do |lane, index|
+          puts "#{index + 1}) #{lane}"
+        end
+
+        i = $stdin.gets.strip.to_i - 1
+        if i >= 0 and (available[i] rescue nil)
+          selection = available[i]
+          Helper.log.info "Driving the lane #{selection}. Next time launch fastlane using `fastlane #{selection}`".green
+          platform = selection.split(' ')[0]
+          lane_name = selection.split(' ')[1]
+
+          unless lane_name # no specific platform, just a root lane
+            lane_name = platform
+            platform = nil
+          end
+
+          return platform, lane_name # yeah
+        end
+
+        Helper.log.error "Invalid input. Please enter the number of the lane you want to use".red
       end
     end
 
+    def self.load_dot_env(env)
+      require 'dotenv'
+
+      Actions.lane_context[Actions::SharedValues::ENVIRONMENT] = env
+
+      # Making sure the default '.env' and '.env.default' get loaded
+      env_file = File.join(Fastlane::FastlaneFolder.path || "", '.env')
+      env_default_file = File.join(Fastlane::FastlaneFolder.path || "", '.env.default')
+      Dotenv.load(env_file, env_default_file)
+
+      # Loads .env file for the environment passed in through options
+      if env
+        env_file = File.join(Fastlane::FastlaneFolder.path || "", ".env.#{env}")
+        Helper.log.info "Loading from '#{env_file}'".green
+        Dotenv.overload(env_file)
+      end
+    end
   end
 end

data/lib/fastlane/runner.rb

@@ -1,27 +1,43 @@
 module Fastlane
   class Runner
 
-    def execute(key)
-      key = key.to_sym
-      Helper.log.info "Driving the lane '#{key}'".green
-      Actions.lane_context[Actions::SharedValues::LANE_NAME] = key
-      ENV["FASTLANE_LANE_NAME"] = key.to_s
+    # This will take care of executing **one** lane. 
+    # @param lane_name The name of the lane to execute
+    # @param platform The name of the platform to execute
+    def execute(lane, platform = nil)
+      raise "No lane given" unless lane
+
+      lane = lane.to_sym
+
+      platform = platform.to_sym if platform # might be nil, which is okay => root element
+
+      Actions.lane_context[Actions::SharedValues::PLATFORM_NAME] = platform # set this in any case: important
+
+      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
+      ENV["FASTLANE_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
-        @before_all.call(key) if @before_all
-        
-        return_val = nil
 
-        if blocks[key]
-          return_val = blocks[key].call
-        else
-          raise "Could not find lane for type '#{key}'. Available lanes: #{available_lanes.join(', ')}".red
+        unless (blocks[platform][lane] rescue nil)
+          raise "Could not find lane '#{full_lane_name}'. Available lanes: #{available_lanes.join(', ')}".red
         end
 
-        @after_all.call(key) if @after_all # this is only called if no exception was raised before
+        # 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]
+        
+        return_val = blocks[platform][lane].call
+        
+        
+        # `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])
       end
 
       return return_val
@@ -29,41 +45,69 @@ module Fastlane
       Dir.chdir(path_to_use) do
         # Provide error block exception without colour code
         error_ex = ex.exception(ex.message.gsub(/\033\[\d+m/, ''))
-        @error.call(key, error_ex) if @error # notify the block
+
+        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]
       end
       raise ex
     end
 
-    def available_lanes
-      blocks.keys
+    # @param filter_platform: Filter, to only show the lanes of a given platform
+    def available_lanes(filter_platform = nil)
+      all = []
+      blocks.each do |platform, lane| 
+        next if (filter_platform and filter_platform.to_s != platform.to_s) # skip actions that don't match
+
+        lane.each do |lane_name, block|
+          all << [platform, lane_name].reject(&:nil?).join(' ')
+        end
+      end
+      all
     end
 
     # Called internally
-    def set_before_all(block)
-      @before_all = block
+    def set_before_all(platform, block)
+      before_all_blocks[platform] = block
     end
 
-    def set_after_all(block)
-      @after_all = block
+    def set_after_all(platform, block)
+      after_all_blocks[platform] = block
     end
 
-    def set_error(block)
-      @error = block
+    def set_error(platform, block)
+      error_blocks[platform] = block
     end
 
-    # @param key: The name of the lane
+    # @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(key, block, desc = nil)
-      raise "Lane '#{key}' was defined multiple times!".red if blocks[key]
-      blocks[key] = block
-      description_blocks[key] = desc
+    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 ||= {}
     end
 
+    def before_all_blocks
+      @before_all ||= {}
+    end
+
+    def after_all_blocks
+      @after_all ||= {}
+    end
+
+    def error_blocks
+      @error_blocks ||= {}
+    end
+
     def description_blocks
       @description_blocks ||= {}
     end