fastlane 1.9.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: beef52022ff1b725c056cb6d6b76940e08a80e47
-  data.tar.gz: 7d3ae10b2bd5e238fb9476d14ea3133f53c3fb04
+  metadata.gz: 1b02853674db4c9391b0afc92187c12553bd5ca5
+  data.tar.gz: abdf86a0c1a16a537e0482b988ff466aa241b6a6
 SHA512:
-  metadata.gz: 0cd216d8caabb4f7cbfe99e0d9adf6bba9269fd75f0561939c4f7e0675c9b6bc156f9ec54de1533f3f2d1ef2f17567721799654ffbe2af178dd4e4fb7f086b59
-  data.tar.gz: f882d73eb82fc32a530ae6538060c3c9895fe5b222fcbab700253a8dd9e1f1145ade69dc74b0b11453dffc4942640669e520b9fefd4b2ab98d977b163e71dbd8
+  metadata.gz: f74b8a54acbd869d226682e105a03e9e6ace60f9d87f145436538d081396d5701b0a7cad95fd987775a04b37b16458becdd56ba8aea3b72f73efe435ea00a57b
+  data.tar.gz: a51ba8231bb61993678733fb47486a25e9e94759f80678dc4f570d45474857de291004d3d6e032afaf1c28471e779ebe325e9e1c0d03b3f4abe60fa6966aa4b9

data/bin/fastlane

@@ -76,7 +76,7 @@ class FastlaneApplication
         ff = Fastlane::FastFile.new(File.join(Fastlane::FastlaneFolder.path || '.', 'Fastfile'))
         puts "\nAvailable lanes:".green
         ff.runner.available_lanes.each do |lane|
-          puts "- #{lane}"
+          puts "- #{lane}" unless lane.is_private
         end
         puts "\nExecute using `fastlane [lane_name]`".yellow
       end

data/lib/fastlane/action.rb

@@ -52,7 +52,11 @@ module Fastlane
       raise "Implementing `is_supported?` for all actions is mandatory. Please update #{self}".red
     end
 
-
+    # Is printed out in the Steps: output in the terminal
+    # Return nil if you don't want any logging in the terminal/JUnit Report
+    def self.step_text
+      self.action_name
+    end
 
     # to allow a simple `sh` in the custom actions
     def self.sh(command)

data/lib/fastlane/action_collector.rb

@@ -20,7 +20,7 @@ module Fastlane
     def did_finish
       unless ENV["FASTLANE_OPT_OUT_USAGE"]
         begin
-          unless did_show_message?
+          if !did_show_message? and !Helper.is_ci?
             Helper.log.debug("Sending Crash/Success information. More information on: https://github.com/fastlane/enhancer")
             Helper.log.debug("No personal/sensitive data is sent. Only sharing the following:")
             Helper.log.debug(launches)

data/lib/fastlane/actions/actions_helper.rb

@@ -49,14 +49,16 @@ module Fastlane
 
     # Pass a block which should be tracked. One block = one testcase
     # @param step_name (String) the name of the currently built code (e.g. snapshot, sigh, ...)
+    #   This might be nil, in which case the step is not printed out to the terminal
     def self.execute_action(step_name)
+      start = Time.now # before the raise block, since `start` is required in the ensure block
       raise 'No block given'.red unless block_given?
 
-      start = Time.now
       error = nil
       exc = nil
 
       begin
+        Helper.log_alert("Step: " + step_name) if step_name
         yield
       rescue => ex
         exc = ex
@@ -64,19 +66,23 @@ module Fastlane
       end
     ensure
       # This is also called, when the block has a return statement
-      duration = Time.now - start
-
-      executed_actions << {
-        name: step_name,
-        error: error,
-        time: duration
-        # output: captured_output
-      }
+      if step_name
+        duration = Time.now - start
+
+        executed_actions << {
+          name: step_name,
+          error: error,
+          time: duration
+        }
+      end
+
       raise exc if exc
     end
 
     # Execute a shell command
     # This method will output the string and execute it
+    # Just an alias for sh_no_action
+    # @param log [boolean] should fastlane print out the executed command
     def self.sh(command, log: true)
       sh_no_action(command, log: log)
     end

data/lib/fastlane/actions/lane_context.rb

@@ -28,6 +28,11 @@ module Fastlane
       def self.is_supported?(platform)
         true
       end
+
+      # We don't want to show this as step
+      def self.step_text
+        nil
+      end
     end
   end
 end

data/lib/fastlane/actions/puts.rb

@@ -20,6 +20,11 @@ module Fastlane
       def self.is_supported?(platform)
         true
       end
+
+      # We don't want to show this as step
+      def self.step_text
+        nil
+      end
     end
   end
 end

data/lib/fastlane/docs_generator.rb

@@ -21,6 +21,7 @@ module Fastlane
 
         if value
           value.each do |lane_name, lane|
+            next if lane.is_private
             output << render(platform, lane_name, lane.description.join("\n\n"))          
           end
 
@@ -48,6 +49,9 @@ module Fastlane
         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(' ')
 

data/lib/fastlane/fast_file.rb

@@ -42,7 +42,21 @@ module Fastlane
       self.runner.add_lane(Lane.new(platform: self.current_platform,
                                        block: block,
                                  description: desc_collection,
-                                        name: lane_name))
+                                        name: lane_name,
+                                  is_private: false))
+
+      @desc_collection = nil # reset the collected description again for the next lane
+    end
+
+    # User defines a new private lane, which can't be called from the CLI
+    def private_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,
+                                        name: lane_name,
+                                  is_private: true))
 
       @desc_collection = nil # reset the collected description again for the next lane
     end
@@ -80,17 +94,21 @@ module Fastlane
       class_ref = nil
       begin
         class_ref = Fastlane::Actions.const_get(class_name)
-        if class_ref && class_ref.respond_to?(:run)
-          # Action is available, now execute it
-          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 self.runner.try_switch_to_lane(method_sym, arguments)
       end
+
+      # It's important to *not* have this code inside the rescue block
+      # otherwise all NameErrors will be catched and the error message is
+      # confusing
+      if class_ref && class_ref.respond_to?(:run)
+        # Action is available, now execute it
+        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
     end
 
     #####################################################
@@ -149,10 +167,8 @@ module Fastlane
     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
+      collector.did_launch_action(:puts)
+      Fastlane::Actions::PutsAction.run([value])
     end
   end
 end

data/lib/fastlane/lane.rb

@@ -5,19 +5,23 @@ module Fastlane
 
     attr_accessor :name
 
-    # @return (Array) An array containing the description of this lane
+    # @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)
+    # @return [Boolean] Is that a private lane that can't be called from the CLI?
+    attr_accessor :is_private
+
+    def initialize(platform: nil, name: nil, description: nil, block: nil, is_private: false)
       raise "description must be an array" unless description.kind_of?Array
       
       self.platform = platform
       self.name = name
       self.description = description
       self.block = block
+      self.is_private = is_private
     end
 
     # Execute this lane

data/lib/fastlane/lane_list.rb

@@ -25,6 +25,8 @@ module Fastlane
         
         if value
           value.each do |lane_name, lane|
+            next if lane.is_private
+            
             output += "----- fastlane #{lane.pretty_name}".green
             output += "\n" + lane.description.join("\n") + "\n\n" if lane.description.count > 0
           end

data/lib/fastlane/runner.rb

@@ -24,6 +24,11 @@ module Fastlane
       self.current_lane = lane.to_sym
       self.current_platform = (platform ? platform.to_sym : nil)
 
+
+      lane_obj = (lanes[current_platform][current_lane] rescue nil)
+      raise "Could not find lane '#{full_lane_name}'. Available lanes: #{available_lanes.join(', ')}".red unless lane_obj
+      raise "You can't call the private lane '#{lane}' directly" if lane_obj.is_private
+
       ENV["FASTLANE_LANE_NAME"] = current_lane.to_s
       ENV["FASTLANE_PLATFORM_NAME"] = (current_platform ? current_platform.to_s : nil)
       
@@ -35,34 +40,32 @@ module Fastlane
       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 (lanes[current_platform][current_lane] rescue nil)
-          raise "Could not find lane '#{full_lane_name}'. Available lanes: #{available_lanes.join(', ')}".red
+      begin
+        Dir.chdir(path_to_use) do # the file is located in the fastlane folder
+
+          # Call the platform specific before_all block and then the general one
+          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 = lane_obj.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[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
 
-        # Call the platform specific before_all block and then the general one
-        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 = 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[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
-    rescue => ex
-      Dir.chdir(path_to_use) do
-        # Provide error block exception without colour code
-        error_ex = ex.exception(ex.message.gsub(/\033\[\d+m/, ''))
+        return return_val
+      rescue => ex
+        Dir.chdir(path_to_use) do
+          # Provide error block exception without colour code
+          error_ex = ex.exception(ex.message.gsub(/\033\[\d+m/, ''))
 
-        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]
+          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
-      raise ex
     end
 
     # @param filter_platform: Filter, to only show the lanes of a given platform
@@ -94,6 +97,7 @@ module Fastlane
 
         pretty = [new_lane]
         pretty = [current_platform, new_lane] if current_platform
+        Actions.execute_action("Switch to #{pretty.join(' ')} lane") {} # log the action
         Helper.log.info "Cruising over to lane '#{pretty.join(' ')}' 🚖".green
 
         # Actually switch lane now
@@ -106,6 +110,7 @@ module Fastlane
         return result
       else
         # No action and no lane, raising an exception now
+        Helper.log.error caller.join("\n")
         raise "Could not find action or lane '#{new_lane}'. Check out the README for more details: https://github.com/KrauseFx/fastlane".red
       end
     end
@@ -118,11 +123,9 @@ module Fastlane
 
       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
+          Actions.execute_action(class_ref.step_text) 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 

data/lib/fastlane/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.10.0
 platform: ruby
 authors:
 - Felix Krause
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-16 00:00:00.000000000 Z
+date: 2015-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri