pantograph 0.1.0

data/pantograph/lib/pantograph/action.rb

@@ -0,0 +1,194 @@
+require 'pantograph/actions/actions_helper'
+require 'forwardable'
+
+module Pantograph
+  class Action
+    AVAILABLE_CATEGORIES = [
+      :testing,
+      :building,
+      :documentation,
+      :beta,
+      :push,
+      :production,
+      :source_control,
+      :notifications,
+      :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
+      # [
+      #   PantographCore::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', '').pantograph_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_pantograph?
+    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/pantograph/lib/pantograph/action_collector.rb

@@ -0,0 +1,35 @@
+module Pantograph
+  class ActionCollector
+    def show_message
+      UI.message("Sending Crash/Success information. Learn more at https://docs.pantograph.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 Pantfile")
+    end
+
+    def determine_version(name)
+      self.class.determine_version(name)
+    end
+
+    # e.g.
+    #   :gym
+    #   :xcversion
+    #   "pantograph-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 Pantograph.const_get(plugin_name.pantograph_class)::VERSION
+        rescue => ex
+          UI.verbose(ex)
+          return "undefined"
+        end
+      end
+
+      return Pantograph::VERSION # that's the case for all built-in actions
+    end
+  end
+end

data/pantograph/lib/pantograph/actions/README.md

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

data/pantograph/lib/pantograph/actions/actions_helper.rb

@@ -0,0 +1,166 @@
+module Pantograph
+  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. 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.pantograph_class + 'Action'
+      class_ref = nil
+      begin
+        class_ref = Pantograph::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)
+
+      class_refs = []
+      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.pantograph_class + 'Action'
+        begin
+          class_ref = Pantograph::Actions.const_get(class_name)
+          class_refs << class_ref
+
+          if class_ref.respond_to?(:run)
+            UI.success("Successfully loaded custom action '#{file}'.") if PantographCore::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.pantograph.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.pantograph.tools/')
+          UI.user_error!("Action '#{file_name}' is damaged!", show_github_issues: true)
+        end
+      end
+      Actions.reset_aliases
+
+      return class_refs
+    end
+
+    def self.formerly_bundled_actions
+      ["xcake"]
+    end
+
+    # Returns a boolean indicating whether the class
+    # reference is a Pantograph::Action
+    def self.is_class_action?(class_ref)
+      return false if class_ref.nil?
+      is_an_action = class_ref < Pantograph::Action
+      return is_an_action || false
+    end
+
+    # Returns a boolean indicating if the class
+    # reference is a deprecated Pantograph::Action
+    def self.is_deprecated?(class_ref)
+      is_class_action?(class_ref) && class_ref.category == :deprecated
+    end
+  end
+end

data/pantograph/lib/pantograph/actions/add_extra_platforms.rb

@@ -0,0 +1,45 @@
+module Pantograph
+  module Actions
+    class AddExtraPlatformsAction < Action
+      def self.run(params)
+        UI.verbose("Before injecting extra platforms: #{Pantograph::SupportedPlatforms.all}")
+        Pantograph::SupportedPlatforms.extra = params[:platforms]
+        UI.verbose("After injecting extra platforms (#{params[:platforms]})...: #{Pantograph::SupportedPlatforms.all}")
+      end
+
+      def self.description
+        "Modify the default list of supported platforms"
+      end
+
+      def self.available_options
+        [
+          PantographCore::ConfigItem.new(key: :platforms,
+                                       optional: false,
+                                       type: Array,
+                                       default_value: "",
+                                       description: "The optional extra platforms to support")
+        ]
+      end
+
+      def self.authors
+        ["lacostej"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'add_extra_platforms(
+            platforms: [:windows, :neogeo]
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/actions/artifactory.rb

@@ -0,0 +1,157 @@
+module Pantograph
+  module Actions
+    module SharedValues
+      ARTIFACTORY_DOWNLOAD_URL = :ARTIFACTORY_DOWNLOAD_URL
+      ARTIFACTORY_DOWNLOAD_SIZE = :ARTIFACTORY_DOWNLOAD_SIZE
+    end
+
+    class ArtifactoryAction < Action
+      def self.run(params)
+        Actions.verify_gem!('artifactory')
+
+        require 'artifactory'
+        file_path = File.absolute_path(params[:file])
+        if File.exist?(file_path)
+          client = connect_to_artifactory(params)
+          artifact = Artifactory::Resource::Artifact.new
+          artifact.client = client
+          artifact.local_path = file_path
+          artifact.checksums = {
+              "sha1" => Digest::SHA1.file(file_path),
+              "md5" => Digest::MD5.file(file_path)
+          }
+          UI.message("Uploading file: #{artifact.local_path} ...")
+          upload = artifact.upload(params[:repo], params[:repo_path], params[:properties])
+
+          Actions.lane_context[SharedValues::ARTIFACTORY_DOWNLOAD_URL] = upload.uri
+          Actions.lane_context[SharedValues::ARTIFACTORY_DOWNLOAD_SIZE] = upload.size
+
+          UI.message("Uploaded Artifact:")
+          UI.message("Repo: #{upload.repo}")
+          UI.message("URI: #{upload.uri}")
+          UI.message("Size: #{upload.size}")
+          UI.message("SHA1: #{upload.sha1}")
+        else
+          UI.message("File not found: '#{file_path}'")
+        end
+      end
+
+      def self.connect_to_artifactory(params)
+        config_keys = [:endpoint, :username, :password, :ssl_pem_file, :ssl_verify, :proxy_username, :proxy_password, :proxy_address, :proxy_port, :read_timeout]
+        config = params.values.select do |key|
+          config_keys.include?(key)
+        end
+        Artifactory::Client.new(config)
+      end
+
+      def self.description
+        'This action uploads an artifact to artifactory'
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.author
+        ["koglinjg", "tommeier"]
+      end
+
+      def self.output
+        [
+          ['ARTIFACTORY_DOWNLOAD_URL', 'The download url for file uploaded'],
+          ['ARTIFACTORY_DOWNLOAD_SIZE', 'The reported file size for file uploaded']
+        ]
+      end
+
+      def self.example_code
+        [
+          'artifactory(
+            username: "username",
+            password: "password",
+            endpoint: "https://artifactory.example.com/artifactory/",
+            file: "example.ipa",                                # File to upload
+            repo: "mobile_artifacts",                           # Artifactory repo
+            repo_path: "/ios/appname/example-major.minor.ipa"   # Path to place the artifact including its filename
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.available_options
+        [
+          PantographCore::ConfigItem.new(key: :file,
+                                       env_name: "FL_ARTIFACTORY_FILE",
+                                       description: "File to be uploaded to artifactory",
+                                       optional: false),
+          PantographCore::ConfigItem.new(key: :repo,
+                                       env_name: "FL_ARTIFACTORY_REPO",
+                                       description: "Artifactory repo to put the file in",
+                                       optional: false),
+          PantographCore::ConfigItem.new(key: :repo_path,
+                                       env_name: "FL_ARTIFACTORY_REPO_PATH",
+                                       description: "Path to deploy within the repo, including filename",
+                                       optional: false),
+          PantographCore::ConfigItem.new(key: :endpoint,
+                                       env_name: "FL_ARTIFACTORY_ENDPOINT",
+                                       description: "Artifactory endpoint",
+                                       optional: false),
+          PantographCore::ConfigItem.new(key: :username,
+                                       env_name: "FL_ARTIFACTORY_USERNAME",
+                                       description: "Artifactory username",
+                                       optional: false),
+          PantographCore::ConfigItem.new(key: :password,
+                                       env_name: "FL_ARTIFACTORY_PASSWORD",
+                                       description: "Artifactory password",
+                                       sensitive: true,
+                                       optional: false),
+          PantographCore::ConfigItem.new(key: :properties,
+                                       env_name: "FL_ARTIFACTORY_PROPERTIES",
+                                       description: "Artifact properties hash",
+                                       is_string: false,
+                                       default_value: {},
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :ssl_pem_file,
+                                       env_name: "FL_ARTIFACTORY_SSL_PEM_FILE",
+                                       description: "Location of pem file to use for ssl verification",
+                                       default_value: nil,
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :ssl_verify,
+                                       env_name: "FL_ARTIFACTORY_SSL_VERIFY",
+                                       description: "Verify SSL",
+                                       is_string: false,
+                                       default_value: true,
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :proxy_username,
+                                       env_name: "FL_ARTIFACTORY_PROXY_USERNAME",
+                                       description: "Proxy username",
+                                       default_value: nil,
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :proxy_password,
+                                       env_name: "FL_ARTIFACTORY_PROXY_PASSWORD",
+                                       description: "Proxy password",
+                                       sensitive: true,
+                                       default_value: nil,
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :proxy_address,
+                                       env_name: "FL_ARTIFACTORY_PROXY_ADDRESS",
+                                       description: "Proxy address",
+                                       default_value: nil,
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :proxy_port,
+                                       env_name: "FL_ARTIFACTORY_PROXY_PORT",
+                                       description: "Proxy port",
+                                       default_value: nil,
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :read_timeout,
+                                       env_name: "FL_ARTIFACTORY_READ_TIMEOUT",
+                                       description: "Read timeout",
+                                       default_value: nil,
+                                       optional: true)
+        ]
+      end
+    end
+  end
+end