fastlane 0.0.1 → 0.1.0

data/lib/fastlane/actions/say.rb

@@ -0,0 +1,10 @@
+module Fastlane
+  module Actions
+    class SayAction
+      def self.run(params)
+        text = params.join(' ')
+        Actions.sh("say '#{text}'")
+      end
+    end
+  end
+end

data/lib/fastlane/actions/sigh.rb

@@ -0,0 +1,31 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      SIGH_PROFILE_PATH = :SIGH_PROFILE_PATH
+    end
+
+    class SighAction
+      def self.run(params)
+        require 'sigh'
+        require 'credentials_manager/appfile_config'
+
+        type = Sigh::DeveloperCenter::APPSTORE
+        type = Sigh::DeveloperCenter::ADHOC if params.first == :adhoc
+        type = Sigh::DeveloperCenter::DEVELOPMENT if params.first == :development
+        
+        return type if Helper.is_test?
+
+        app = CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier)
+        raise "No app_identifier definied in `./fastlane/Appfile`".red unless app
+
+        path = Sigh::DeveloperCenter.new.run(app, type)
+        output_path = File.expand_path(File.join('.', File.basename(path)))
+        FileUtils.mv(path, output_path)
+        Helper.log.info "Exported provisioning profile to '#{output_path}'".green
+        Actions.sh "open '#{output_path}'"
+
+        Actions.lane_context[SharedValues::SIGH_PROFILE_PATH] = output_path # absolute URL
+      end
+    end
+  end
+end

data/lib/fastlane/actions/slack.rb

@@ -0,0 +1,56 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      
+    end
+
+    class SlackAction
+      def self.run(params)
+        options = { message: '', 
+                    success: true, 
+                    channel: nil
+                  }.merge(params.first || {})
+        
+        require 'slack-notifier'
+
+        color = (options[:success] ? 'good' : 'danger')
+        options[:message] = Slack::Notifier::LinkFormatter.format(options[:message])
+
+        url = ENV["SLACK_URL"]
+        unless url
+          Helper.log.fatal "Please add 'ENV[\"SLACK_URL\"] = \"https://hooks.slack.com/services/...\"' to your Fastfile's `before_all` section.".red
+          raise "No SLACK_URL given.".red
+        end
+
+        notifier = Slack::Notifier.new url
+
+        notifier.username = 'fastlane'
+        notifier.channel = "##{options[:channel]}" if options[:channel].to_s.length > 0
+
+        test_result = {
+          fallback: options[:message],
+          text: options[:message],
+          color: color,
+          fields: [
+            {
+              title: "Lane",
+              value: Actions.lane_context[Actions::SharedValues::LANE_NAME],
+              short: true
+            },
+            {
+              title: "Test Result",
+              value: (options[:success] ? "Success" : "Error"),
+              short: true
+            }
+          ]
+        }
+
+        notifier.ping "", 
+                      icon_url: 'https://s3-eu-west-1.amazonaws.com/fastlane.tools/fastlane.png',
+                      attachments: [test_result]
+
+        Helper.log.info "Successfully sent Slack notification"
+      end
+    end
+  end
+end

data/lib/fastlane/actions/snapshot.rb

@@ -0,0 +1,30 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      SNAPSHOT_SCREENSHOTS_PATH = :SNAPSHOT_SCREENSHOTS_PATH
+    end
+
+    class SnapshotAction
+      def self.run(params)
+        require 'snapshot'
+
+        clean = true
+        clean = false if params.first == :noclean
+
+        if Helper.is_test?
+          Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH] = Dir.pwd
+          return clean 
+        end
+
+        Dir.chdir(FastlaneFolder.path) do
+          Snapshot::SnapshotConfig.shared_instance
+          Snapshot::Runner.new.work(clean: clean)
+
+          results_path = Snapshot::SnapshotConfig.shared_instance.screenshots_path
+
+          Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH] = File.expand_path(results_path) # absolute URL
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/actions/testmunk.rb

@@ -0,0 +1,42 @@
+# How it works:
+# You can run your functional calabash testcases on real ios hardware. Follow the steps to set up your free account on testmunk.com or see below. After tests are executed you will get an email with test results. An API extension to see test results directly in Jenkins is in the works.
+
+
+# Setup 
+# 1) Create a free account on testmunk.com
+# 2) Create an own project under your account (top right) after you are logged in. You will need to use this project name within your REST API upload path.
+# 3) Upload testcases (features in calabash) over the testmunk REST API (http://docs.testmunk.com/en/latest/rest.html#upload-testcases).
+
+
+module Fastlane
+  module Actions
+    module SharedValues
+      
+    end
+
+    class TestmunkAction
+      def self.run(params)
+        
+        raise "Please pass your Testmunk email address using `ENV['TESTMUNK_EMAIL'] = 'value'`" unless ENV['TESTMUNK_EMAIL']
+        raise "Please pass your Testmunk API Key using `ENV['TESTMUNK_API'] = 'value'`" unless ENV['TESTMUNK_API']
+        raise "Please pass your Testmunk app name using `ENV['TESTMUNK_APP'] = 'value'`" unless ENV['TESTMUNK_APP']
+
+        ipa_path = ENV['TESTMUNK_IPA'] || ENV[Actions::SharedValues::DELIVER_IPA_PATH.to_s]
+        raise "Please pass a path to your ipa file using `ENV['TESTMUNK_IPA'] = 'value'`" unless ipa_path
+
+        Helper.log.info "Testmunk: Uploading the .ipa and starting your tests".green
+
+        response = system("#{"curl -H 'Accept: application/vnd.testmunk.v1+json'" +
+            " -F 'file=@#{ipa_path}' -F 'autoStart=true'" +
+            " -F 'email=#{ENV['TESTMUNK_EMAIL']}'" +
+            " https://#{ENV['TESTMUNK_API']}@api.testmunk.com/apps/#{ENV['TESTMUNK_APP']}/testruns"}")
+
+        if response
+          Helper.log.info "Your tests are being executed right now. Please wait for the mail with results and decide if you want to continue.".green
+        else
+          raise "Something went wrong while uploading your app to Testmunk".red
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/actions/xctool.rb

@@ -0,0 +1,10 @@
+module Fastlane
+  module Actions
+    class XctoolAction
+      def self.run(params)
+        raise "xctool not installed, please install using `brew install xctool`".red if `which xctool`.length == 0
+        Actions.sh("xctool " + params.join(" "))
+      end
+    end
+  end
+end

data/lib/fastlane/dependency_checker.rb

@@ -0,0 +1,18 @@
+module Fastlane
+  class DependencyChecker
+    def self.check_dependencies
+      self.check_xcode_select unless Helper.is_test?
+    end
+  
+    def self.check_xcode_select
+      unless `xcode-select -v`.include?"xcode-select version "
+        Helper.log.fatal '#############################################################'
+        Helper.log.fatal "# You have to install the Xcode commdand line tools to use fastlane"
+        Helper.log.fatal "# Install the latest version of Xcode from the AppStore"
+        Helper.log.fatal "# Run xcode-select --install to install the developer tools"
+        Helper.log.fatal '#############################################################'
+        raise "Run 'xcode-select --install' and start fastlane again"
+      end
+    end
+  end
+end

data/lib/fastlane/fast_file.rb

@@ -0,0 +1,89 @@
+module Fastlane
+  class FastFile
+    attr_accessor :runner
+
+    # @return The runner which can be executed to trigger the given actions
+    def initialize(path = nil)
+      if (path || '').length > 0
+        raise "Could not find Fastfile at path '#{path}'".red unless File.exists?path
+        @path = path
+        content = File.read(path)
+
+        parse(content)
+      end
+    end
+
+    def parse(data)
+      @runner = Runner.new
+
+      Dir.chdir(Fastlane::FastlaneFolder.path || Dir.pwd) do # context: fastlane subfolder
+        eval(data) # this is okay in this case
+      end
+
+      return self
+    end
+
+    def lane(key, &block)
+      @runner.set_block(key, block)
+    end
+
+    def before_all(&block)
+      @runner.set_before_all(block)
+    end
+
+    def after_all(&block)
+      @runner.set_after_all(block)
+    end
+
+    def error(&block)
+      @runner.set_error(block)
+    end
+
+    # 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
+
+    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 method_missing(method_sym, *arguments, &block)
+      # First, check if there is a predefined method in the actions folder
+
+      class_name = method_sym.to_s.classify + "Action"
+      class_ref = nil
+      begin
+        class_ref = Fastlane::Actions.const_get(class_name)
+      rescue NameError => ex
+        # Action not found
+        raise "Could not find method '#{method_sym}'. Check out the README for more details: https://github.com/KrauseFx/fastlane".red
+      end
+
+      if class_ref and class_ref.respond_to?(:run)
+        Helper.log.info "Step: #{method_sym.to_s}".green
+
+        Dir.chdir("..") do # go up from the fastlane folder, to the project folder
+          Actions.execute_action(method_sym) do
+            class_ref.run(arguments)
+          end
+        end
+      else
+        raise "Action '#{method_sym}' of class '#{class_name}' was found, but has no `run` method.".red
+      end
+    end
+  end
+end

data/lib/fastlane/fastlane_folder.rb

@@ -0,0 +1,24 @@
+module Fastlane
+  class FastlaneFolder
+    FOLDER_NAME = 'fastlane'
+    
+    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 and File.exists?"Fastfile" # inside the folder
+      return "./" if File.basename(Dir.getwd) == FOLDER_NAME and File.exists?"Fastfile" # inside the folder and hidden
+      return nil
+    end
+
+    def self.setup?
+      return false unless self.path
+      return File.exists?self.path
+    end
+
+    def self.create_folder!
+      path = "./#{FOLDER_NAME}"
+      FileUtils.mkdir_p path
+      Helper.log.info "Created new folder '#{path}'.".green
+    end
+  end
+end

data/lib/fastlane/helper.rb

@@ -0,0 +1,66 @@
+require 'logger'
+
+
+class String
+  def classify
+    self.split('_').collect!{ |w| w.capitalize }.join
+  end
+end
+
+
+
+module Fastlane
+  module Helper
+
+    # Logging happens using this method
+    def self.log
+      if is_test?
+        @@log ||= Logger.new(nil) # don't show any logs when running tests
+      else
+        @@log ||= Logger.new(STDOUT)
+      end
+
+      @@log.formatter = proc do |severity, datetime, progname, msg|
+        string = "#{severity} [#{datetime.strftime('%Y-%m-%d %H:%M:%S.%2N')}]: "
+        second = "#{msg}\n"
+
+        if severity == "DEBUG"
+          string = string.magenta
+        elsif severity == "INFO"
+          string = string.white
+        elsif severity == "WARN"
+          string = string.yellow
+        elsif severity == "ERROR"
+          string = string.red
+        elsif severity == "FATAL"
+          string = string.red.bold
+        end
+
+
+        [string, second].join("")
+      end
+
+      @@log
+    end
+
+    # @return true if the currently running program is a unit test
+    def self.is_test?
+      defined?SpecHelper
+    end
+
+    # @return the full path to the Xcode developer tools of the currently
+    #  running system
+    def self.xcode_path
+      return "" if self.is_test? and not OS.mac?
+      `xcode-select -p`.gsub("\n", '') + "/"
+    end
+
+    def self.gem_path
+      if not Helper.is_test? and Gem::Specification::find_all_by_name('fastlane').any?
+        return Gem::Specification.find_by_name('fastlane').gem_dir
+      else
+        return './'
+      end
+    end
+  end
+end

data/lib/fastlane/junit_generator.rb

@@ -0,0 +1,32 @@
+require 'nokogiri'
+
+module Fastlane
+  class JUnitGenerator
+    def self.generate(results)
+      # JUnit file documentation: http://llg.cubic.org/docs/junit/
+      # And http://nelsonwells.net/2012/09/how-jenkins-ci-parses-and-displays-junit-output/
+
+      containing_folder = Fastlane::FastlaneFolder.path || Dir.pwd
+      path = File.join(containing_folder, "report.xml")
+
+
+      builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+        xml.testsuites(name: "fastlane") {
+          xml.testsuite(name: "deploy") {
+            results.each_with_index do |current, index|
+              xml.testcase(name: [index, current[:name]].join(": "), time: current[:time]) {
+                xml.failure(message: current[:error]) if current[:error]
+                xml.system_out current[:output] if current[:output]
+              }
+            end
+          }
+        }
+      end
+      result = builder.to_xml.gsub("system_", "system-").gsub("", " ") # Jenkins can not parse 'ESC' symbol
+
+      File.write(path, result)
+
+      return path
+    end
+  end
+end

data/lib/fastlane/lane_manager.rb

@@ -0,0 +1,39 @@
+module Fastlane
+  class LaneManager
+    def self.cruise_lanes(lanes)
+      raise "lanes must be an array" unless lanes.kind_of?Array
+      ff = Fastlane::FastFile.new(File.join(Fastlane::FastlaneFolder.path, 'Fastfile'))
+
+      if lanes.count == 0
+        raise "Please pass the name of the lane you want to drive. Available lanes: #{ff.runner.available_lanes.join(', ')}".red
+      end
+
+      start = Time.now
+      e = nil
+      begin
+        lanes.each do |key|
+          ff.runner.execute(key)
+        end
+      rescue => ex
+        if Actions.lane_context.count > 0
+          Helper.log.info "Variable Dump:".yellow
+          Helper.log.info Actions.lane_context
+        end
+        Helper.log.fatal ex
+        e = ex
+      end
+
+      # Finished with all the lanes
+      Fastlane::JUnitGenerator.generate(Fastlane::Actions.executed_actions)
+
+      duration = ((Time.now - start) / 60.0).round
+
+      unless e
+        Helper.log.info "fastlane.tools just saved you #{duration} minutes! 🎉".green
+      else
+        Helper.log.fatal "fastlane finished with errors".red
+        raise e
+      end
+    end
+  end
+end