fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/action.rb

@@ -0,0 +1,198 @@
+require 'fastlane/actions/actions_helper'
+require 'forwardable'
+
+module Fastlane
+  class Action
+    AVAILABLE_CATEGORIES = [
+      :testing,
+      :building,
+      :screenshots,
+      :project,
+      :code_signing,
+      :documentation,
+      :beta,
+      :push,
+      :production,
+      :source_control,
+      :notifications,
+      :app_store_connect,
+      :misc,
+      :deprecated # This should be the last item
+    ]
+
+    RETURN_TYPES = [
+      :string,
+      :array_of_strings,
+      :hash_of_strings,
+      :hash,
+      :bool,
+      :int
+    ]
+
+    class << self
+      attr_accessor :runner
+
+      extend(Forwardable)
+
+      # to allow a simple `sh` in the custom actions
+      def_delegator(Actions, :sh_control_output, :sh)
+    end
+
+    def self.run(params)
+    end
+
+    # Implement in subclasses
+    def self.description
+      "No description provided".red
+    end
+
+    def self.details
+      nil # this is your chance to provide a more detailed description of this action
+    end
+
+    def self.available_options
+      # [
+      #   FastlaneCore::ConfigItem.new(key: :ipa_path,
+      #                                env_name: "CRASHLYTICS_IPA_PATH",
+      #                                description: "Value Description")
+      # ]
+      nil
+    end
+
+    def self.output
+      # Return the keys you provide on the shared area
+      # [
+      #   ['IPA_OUTPUT_PATH', 'The path to the newly generated ipa file']
+      # ]
+      nil
+    end
+
+    def self.return_type
+      # Describes what type of data is expected to be returned, see RETURN_TYPES
+      nil
+    end
+
+    def self.return_value
+      # Describes what this method returns
+      nil
+    end
+
+    def self.sample_return_value
+      # Very optional
+      # You can return a sample return value, that might be returned by the actual action
+      # This is currently only used when generating the documentation and running its tests
+      nil
+    end
+
+    def self.author
+      nil
+    end
+
+    def self.authors
+      nil
+    end
+
+    def self.is_supported?(platform)
+      # you can do things like
+      #  true
+      #
+      #  platform == :ios
+      #
+      #  [:ios, :mac].include?(platform)
+      #
+      UI.crash!("Implementing `is_supported?` for all actions is mandatory. Please update #{self}")
+    end
+
+    # Returns an array of string of sample usage of this action
+    def self.example_code
+      nil
+    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
+
+    # Documentation category, available values defined in AVAILABLE_CATEGORIES
+    def self.category
+      :undefined
+    end
+
+    # instead of "AddGitAction", this will return "add_git" to print it to the user
+    def self.action_name
+      self.name.split('::').last.gsub('Action', '').fastlane_underscore
+    end
+
+    def self.lane_context
+      Actions.lane_context
+    end
+
+    # Allows the user to call an action from an action
+    def self.method_missing(method_sym, *arguments, &_block)
+      UI.error("Unknown method '#{method_sym}'")
+      UI.user_error!("To call another action from an action use `other_action.#{method_sym}` instead")
+    end
+
+    # When shelling out from the actoin, should we use `bundle exec`?
+    def self.shell_out_should_use_bundle_exec?
+      return File.exist?('Gemfile') && !Helper.contained_fastlane?
+    end
+
+    # Return a new instance of the OtherAction action
+    # We need to do this, since it has to have access to
+    # the runner object
+    def self.other_action
+      return OtherAction.new(self.runner)
+    end
+
+    # Describes how the user should handle deprecated an action if its deprecated
+    # Returns a string (or nil)
+    def self.deprecated_notes
+      nil
+    end
+  end
+end
+
+class String
+  def markdown_preserve_newlines
+    self.gsub(/(\n|$)/, '|\1') # prepend new lines with "|" so the erb template knows *not* to replace them with "<br>"s
+  end
+
+  def markdown_sample(is_first = false)
+    self.markdown_clean_heredoc!
+    self.markdown_details(is_first)
+  end
+
+  def markdown_list(is_first = false)
+    self.markdown_clean_heredoc!
+    self.gsub!(/^/, "- ") # add list dashes
+    self.prepend(">") unless is_first # the empty line that will be added breaks the quote
+    self.markdown_details(is_first)
+  end
+
+  def markdown_details(is_first)
+    self.prepend("\n") unless is_first
+    self << "\n>" # continue the quote
+    self.markdown_preserve_newlines
+  end
+
+  def markdown_clean_heredoc!
+    self.chomp! # remove the last new line added by the heredoc
+    self.dedent! # remove the leading whitespace (similar to the squigly heredoc `<<~`)
+  end
+
+  def dedent!
+    first_line_indent = self.match(/^\s*/)[0]
+
+    self.gsub!(/^#{first_line_indent}/, "")
+  end
+
+  def remove_markdown
+    string = self.gsub(/^>/, "") # remove Markdown quotes
+    string = string.gsub(/\[http[^\]]+\]\(([^)]+)\)/, '\1 🔗') # remove Markdown links
+    string = string.gsub(/\[([^\]]+)\]\(([^\)]+)\)/, '"\1" (\2 🔗)') # remove Markdown links with custom text
+    string = string.gsub("|", "") # remove new line preserve markers
+    return string
+  end
+end

data/fastlane/lib/fastlane/action_collector.rb

@@ -0,0 +1,35 @@
+module Fastlane
+  class ActionCollector
+    def show_message
+      UI.message("Sending Crash/Success information. Learn more at https://docs.fastlane.tools/#metrics")
+      UI.message("No personal/sensitive data is sent. Only sharing the following:")
+      UI.message(launches)
+      UI.message(@error) if @error
+      UI.message("This information is used to fix failing actions and improve integrations that are often used.")
+      UI.message("You can disable this by adding `opt_out_usage` at the top of your Fastfile")
+    end
+
+    def determine_version(name)
+      self.class.determine_version(name)
+    end
+
+    # e.g.
+    #   :gym
+    #   :xcversion
+    #   "fastlane-plugin-my_plugin/xcversion"
+    def self.determine_version(name)
+      if name.to_s.include?(PluginManager.plugin_prefix)
+        # That's an action from a plugin, we need to fetch its version number
+        begin
+          plugin_name = name.split("/").first.gsub(PluginManager.plugin_prefix, '')
+          return Fastlane.const_get(plugin_name.fastlane_class)::VERSION
+        rescue => ex
+          UI.verbose(ex)
+          return "undefined"
+        end
+      end
+
+      return Fastlane::VERSION # that's the case for all built-in actions
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/README.md

@@ -0,0 +1,3 @@
+All built-in integrations are available in this directory. Use the `fastlane new_action` command to create a new action.
+
+_fastlane_ will automatically detect the files in this folder

data/fastlane/lib/fastlane/actions/actions_helper.rb

@@ -0,0 +1,162 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      LANE_NAME = :LANE_NAME
+      PLATFORM_NAME = :PLATFORM_NAME
+      ENVIRONMENT = :ENVIRONMENT
+    end
+
+    def self.reset_aliases
+      @alias_actions = nil
+    end
+
+    def self.alias_actions
+      unless @alias_actions
+        @alias_actions = {}
+        ActionsList.all_actions do |action, name|
+          next unless action.respond_to?(:aliases)
+          @alias_actions[name] = action.aliases
+        end
+      end
+      @alias_actions
+    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
+      @lane_context ||= {}
+    end
+
+    # Used in tests to get a clear lane before every test
+    def self.clear_lane_context
+      @lane_context = nil
+    end
+
+    # 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
+      UI.crash!("No block given") unless block_given?
+
+      error = nil
+      exc = nil
+
+      begin
+        UI.header("Step: " + step_name) if step_name
+        yield
+      rescue => ex
+        exc = ex
+        error = caller.join("\n") + "\n\n" + ex.to_s
+      end
+    ensure
+      # This is also called, when the block has a return statement
+      if step_name
+        duration = Time.now - start
+
+        executed_actions << {
+          name: step_name,
+          error: error,
+          time: duration
+        }
+      end
+
+      raise exc if exc
+    end
+
+    # returns a list of official integrations
+    # rubocop:disable Style/AccessorMethodName
+    def self.get_all_official_actions
+      Dir[File.expand_path('*.rb', File.dirname(__FILE__))].collect do |file|
+        File.basename(file).gsub('.rb', '').to_sym
+      end
+    end
+    # rubocop:enable Style/AccessorMethodName
+
+    # Returns the class ref to the action based on the action name
+    # Returns nil if the action is not aailable
+    def self.action_class_ref(action_name)
+      class_name = action_name.to_s.fastlane_class + 'Action'
+      class_ref = nil
+      begin
+        class_ref = Fastlane::Actions.const_get(class_name)
+      rescue NameError
+        return nil
+      end
+      return class_ref
+    end
+
+    def self.load_default_actions
+      Dir[File.expand_path('*.rb', File.dirname(__FILE__))].each do |file|
+        require file
+      end
+    end
+
+    # Import all the helpers
+    def self.load_helpers
+      Dir[File.expand_path('../helper/*.rb', File.dirname(__FILE__))].each do |file|
+        require file
+      end
+    end
+
+    def self.load_external_actions(path)
+      UI.user_error!("You need to pass a valid path") unless File.exist?(path)
+
+      Dir[File.expand_path('*.rb', path)].each do |file|
+        begin
+          require file
+        rescue SyntaxError => ex
+          content = File.read(file, encoding: "utf-8")
+          ex.to_s.lines
+            .collect { |error| error.match(/#{file}:(\d+):(.*)/) }
+            .reject(&:nil?)
+            .each { |error| UI.content_error(content, error[1]) }
+          UI.user_error!("Syntax error in #{File.basename(file)}")
+          next
+        end
+
+        file_name = File.basename(file).gsub('.rb', '')
+
+        class_name = file_name.fastlane_class + 'Action'
+        begin
+          class_ref = Fastlane::Actions.const_get(class_name)
+
+          if class_ref.respond_to?(:run)
+            UI.success("Successfully loaded custom action '#{file}'.") if FastlaneCore::Globals.verbose?
+          else
+            UI.error("Could not find method 'run' in class #{class_name}.")
+            UI.error('For more information, check out the docs: https://docs.fastlane.tools/')
+            UI.user_error!("Action '#{file_name}' is damaged!", show_github_issues: true)
+          end
+        rescue NameError
+          # Action not found
+          UI.error("Could not find '#{class_name}' class defined.")
+          UI.error('For more information, check out the docs: https://docs.fastlane.tools/')
+          UI.user_error!("Action '#{file_name}' is damaged!", show_github_issues: true)
+        end
+      end
+      Actions.reset_aliases
+    end
+
+    def self.formerly_bundled_actions
+      ["xcake"]
+    end
+
+    # Returns a boolean indicating whether the class
+    # reference is a Fastlane::Action
+    def self.is_class_action?(class_ref)
+      return false if class_ref.nil?
+      is_an_action = class_ref < Fastlane::Action
+      return is_an_action || false
+    end
+
+    # Returns a boolean indicating if the class
+    # reference is a deprecated Fastlane::Action
+    def self.is_deprecated?(class_ref)
+      is_class_action?(class_ref) && class_ref.category == :deprecated
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/adb.rb

@@ -0,0 +1,78 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    class AdbAction < Action
+      def self.run(params)
+        adb = Helper::AdbHelper.new(adb_path: params[:adb_path])
+        result = adb.trigger(command: params[:command], serial: params[:serial])
+        return result
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Run ADB Actions"
+      end
+
+      def self.details
+        "see adb --help for more details"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :serial,
+                                       env_name: "FL_ANDROID_SERIAL",
+                                       description: "Android serial of the device to use for this command",
+                                       is_string: true,
+                                       default_value: ""),
+          FastlaneCore::ConfigItem.new(key: :command,
+                                       env_name: "FL_ADB_COMMAND",
+                                       description: "All commands you want to pass to the adb command, e.g. `kill-server`",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :adb_path,
+                                       env_name: "FL_ADB_PATH",
+                                       optional: true,
+                                       description: "The path to your `adb` binary (can be left blank if the ANDROID_SDK_ROOT environment variable is set)",
+                                       is_string: true,
+                                       default_value: "adb")
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.example_code
+        [
+          'adb(
+            command: "shell ls"
+          )'
+        ]
+      end
+
+      def self.return_value
+        "The output of the adb command"
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.authors
+        ["hjanuschka"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end