pantograph 0.1.0

data/pantograph/lib/pantograph/actions/prompt.rb

@@ -0,0 +1,119 @@
+module Pantograph
+  module Actions
+    class PromptAction < Action
+      def self.run(params)
+        if params[:boolean]
+          return params[:ci_input] unless UI.interactive?
+          return UI.confirm(params[:text])
+        end
+
+        UI.message(params[:text])
+
+        return params[:ci_input] unless UI.interactive?
+
+        if params[:multi_line_end_keyword]
+          # Multi line
+          end_tag = params[:multi_line_end_keyword]
+          UI.important("Submit inputs using \"#{params[:multi_line_end_keyword]}\"")
+          user_input = ""
+          loop do
+            line = STDIN.gets # returns `nil` if called at end of file
+            break unless line
+            end_tag_index = line.index(end_tag)
+            if end_tag_index.nil?
+              user_input << line
+            else
+              user_input << line.slice(0, end_tag_index)
+              user_input = user_input.strip
+              break
+            end
+          end
+        else
+          # Standard one line input
+          if params[:secure_text]
+            user_input = STDIN.noecho(&:gets).chomp while (user_input || "").length == 0
+          else
+            user_input = STDIN.gets.chomp.strip while (user_input || "").length == 0
+          end
+        end
+
+        return user_input
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Ask the user for a value or for confirmation"
+      end
+
+      def self.details
+        [
+          "You can use `prompt` to ask the user for a value or to just let the user confirm the next step.",
+          "When this is executed on a CI service, the passed `ci_input` value will be returned.",
+          "This action also supports multi-line inputs using the `multi_line_end_keyword` option."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          PantographCore::ConfigItem.new(key: :text,
+                                       description: "The text that will be displayed to the user",
+                                       default_value: "Please enter some text: "),
+          PantographCore::ConfigItem.new(key: :ci_input,
+                                       description: "The default text that will be used when being executed on a CI service",
+                                       default_value: ''),
+          PantographCore::ConfigItem.new(key: :boolean,
+                                       description: "Is that a boolean question (yes/no)? This will add (y/n) at the end",
+                                       default_value: false,
+                                       is_string: false),
+          PantographCore::ConfigItem.new(key: :secure_text,
+                                       description: "Is that a secure text (yes/no)?",
+                                       default_value: false,
+                                       is_string: false),
+          PantographCore::ConfigItem.new(key: :multi_line_end_keyword,
+                                       description: "Enable multi-line inputs by providing an end text (e.g. 'END') which will stop the user input",
+                                       optional: true,
+                                       is_string: true)
+        ]
+      end
+
+      def self.output
+        []
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'changelog = prompt(text: "Changelog: ")',
+          'changelog = prompt(
+            text: "Changelog: ",
+            multi_line_end_keyword: "END"
+          )
+
+          crashlytics(notes: changelog)'
+        ]
+      end
+
+      def self.sample_return_value
+        "User Content\nWithNewline"
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/actions/push_git_tags.rb

@@ -0,0 +1,76 @@
+module Pantograph
+  module Actions
+    class PushGitTagsAction < Action
+      def self.run(params)
+        command = [
+          'git',
+          'push',
+          params[:remote]
+        ]
+
+        if params[:tag]
+          command << "refs/tags/#{params[:tag]}"
+        else
+          command << '--tags'
+        end
+
+        # optionally add the force component
+        command << '--force' if params[:force]
+
+        result = Actions.sh(command.join(' '))
+        UI.success('Tags pushed to remote')
+        result
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Push local tags to the remote - this will only push tags"
+      end
+
+      def self.available_options
+        [
+          PantographCore::ConfigItem.new(key: :force,
+                                       env_name: "FL_PUSH_GIT_FORCE",
+                                       description: "Force push to remote",
+                                       is_string: false,
+                                       default_value: false,
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :remote,
+                                       env_name: "FL_GIT_PUSH_REMOTE",
+                                       description: "The remote to push tags to",
+                                       default_value: "origin",
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :tag,
+                                       env_name: "FL_GIT_PUSH_TAG",
+                                       description: "The tag to push to remote",
+                                       optional: true)
+        ]
+      end
+
+      def self.author
+        ['vittoriom']
+      end
+
+      def self.details
+        "If you only want to push the tags and nothing else, you can use the `push_git_tags` action"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'push_git_tags'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/actions/push_to_git_remote.rb

@@ -0,0 +1,127 @@
+module Pantograph
+  module Actions
+    # Push local changes to the remote branch
+    class PushToGitRemoteAction < Action
+      def self.run(params)
+        local_branch = params[:local_branch]
+        local_branch ||= Actions.git_branch.gsub(%r{#{params[:remote]}\/}, '') if Actions.git_branch
+        local_branch ||= 'master'
+
+        remote_branch = params[:remote_branch] || local_branch
+
+        # construct our command as an array of components
+        command = [
+          'git',
+          'push',
+          params[:remote],
+          "#{local_branch.shellescape}:#{remote_branch.shellescape}"
+        ]
+
+        # optionally add the tags component
+        command << '--tags' if params[:tags]
+
+        # optionally add the force component
+        command << '--force' if params[:force]
+
+        # optionally add the force component
+        command << '--force-with-lease' if params[:force_with_lease]
+
+        # optionally add the no-verify component
+        command << '--no-verify' if params[:no_verify]
+
+        # optionally add the set-upstream component
+        command << '--set-upstream' if params[:set_upstream]
+
+        # execute our command
+        Actions.sh('pwd')
+        return command.join(' ') if Helper.test?
+
+        Actions.sh(command.join(' '))
+        UI.message('Successfully pushed to remote.')
+      end
+
+      def self.description
+        "Push local changes to the remote branch"
+      end
+
+      def self.available_options
+        [
+          PantographCore::ConfigItem.new(key: :local_branch,
+                                       env_name: "FL_GIT_PUSH_LOCAL_BRANCH",
+                                       description: "The local branch to push from. Defaults to the current branch",
+                                       default_value_dynamic: true,
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :remote_branch,
+                                       env_name: "FL_GIT_PUSH_REMOTE_BRANCH",
+                                       description: "The remote branch to push to. Defaults to the local branch",
+                                       default_value_dynamic: true,
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :force,
+                                       env_name: "FL_PUSH_GIT_FORCE",
+                                       description: "Force push to remote",
+                                       type: Boolean,
+                                       default_value: false),
+          PantographCore::ConfigItem.new(key: :force_with_lease,
+                                       env_name: "FL_PUSH_GIT_FORCE_WITH_LEASE",
+                                       description: "Force push with lease to remote",
+                                       type: Boolean,
+                                       default_value: false),
+          PantographCore::ConfigItem.new(key: :tags,
+                                       env_name: "FL_PUSH_GIT_TAGS",
+                                       description: "Whether tags are pushed to remote",
+                                       type: Boolean,
+                                       default_value: true),
+          PantographCore::ConfigItem.new(key: :remote,
+                                       env_name: "FL_GIT_PUSH_REMOTE",
+                                       description: "The remote to push to",
+                                       default_value: 'origin'),
+          PantographCore::ConfigItem.new(key: :no_verify,
+                                       env_name: "FL_GIT_PUSH_USE_NO_VERIFY",
+                                       description: "Whether or not to use --no-verify",
+                                       type: Boolean,
+                                       default_value: false),
+          PantographCore::ConfigItem.new(key: :set_upstream,
+                                       env_name: "FL_GIT_PUSH_USE_SET_UPSTREAM",
+                                       description: "Whether or not to use --set-upstream",
+                                       type: Boolean,
+                                       default_value: false)
+        ]
+      end
+
+      def self.author
+        "lmirosevic"
+      end
+
+      def self.details
+        [
+          "Lets you push your local commits to a remote git repo. Useful if you make local changes such as adding a version bump commit (using `commit_version_bump`) or a git tag (using 'add_git_tag') on a CI server, and you want to push those changes back to your canonical/main repo.",
+          "If this is a new branch, use the `set_upstream` option to set the remote branch as upstream."
+        ].join("\n")
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'push_to_git_remote # simple version. pushes "master" branch to "origin" remote',
+          'push_to_git_remote(
+            remote: "origin",         # optional, default: "origin"
+            local_branch: "develop",  # optional, aliased by "branch", default is set to current branch
+            remote_branch: "develop", # optional, default is set to local_branch
+            force: true,              # optional, default: false
+            force_with_lease: true,   # optional, default: false
+            tags: false,              # optional, default: true
+            no_verify: true,          # optional, default: false
+            set_upstream: true        # optional, default: false
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/actions/puts.rb

@@ -0,0 +1,68 @@
+module Pantograph
+  module Actions
+    class PutsAction < Action
+      def self.run(params)
+        # display text from the message param
+        # if called like `puts 'hi'` then params won't be a configuration item, so we have to check
+        if params.kind_of?(PantographCore::Configuration) && params[:message]
+          UI.message(params[:message])
+          return
+        end
+
+        # no parameter included in the call means treat this like a normal pantograph ruby call
+        UI.message(params.join(' '))
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Prints out the given text"
+      end
+
+      def self.available_options
+        [
+          PantographCore::ConfigItem.new(key: :message,
+                                       env_name: 'PUTS_MESSAGE',
+                                       description: 'Message to be printed out',
+                                       optional: true,
+                                       is_string: true)
+        ]
+      end
+
+      def self.authors
+        ['KrauseFx']
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.alias_used(action_alias, params)
+        if !params.kind_of?(PantographCore::Configuration) || params[:message].nil?
+          UI.important("#{action_alias} called, please use 'puts' instead!")
+        end
+      end
+
+      def self.aliases
+        ["println", "echo"]
+      end
+
+      # We don't want to show this as step
+      def self.step_text
+        nil
+      end
+
+      def self.example_code
+        [
+          'puts "Hi there"'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/actions/reset_git_repo.rb

@@ -0,0 +1,121 @@
+require 'shellwords'
+
+module Pantograph
+  module Actions
+    # Does a hard reset and clean on the repo
+    class ResetGitRepoAction < Action
+      def self.run(params)
+        if params[:force] || Actions.lane_context[SharedValues::GIT_REPO_WAS_CLEAN_ON_START]
+          paths = params[:files]
+
+          return paths if Helper.test?
+
+          if paths.nil?
+            Actions.sh('git reset --hard HEAD')
+
+            clean_options = ['q', 'f', 'd']
+            clean_options << 'x' if params[:disregard_gitignore]
+            clean_command = 'git clean' + ' -' + clean_options.join
+
+            # we want to make sure that we have an array of patterns, and no nil values
+            unless params[:exclude].kind_of?(Enumerable)
+              params[:exclude] = [params[:exclude]].compact
+            end
+
+            # attach our exclude patterns to the command
+            clean_command += ' ' + params[:exclude].map { |exclude| '-e ' + exclude.shellescape }.join(' ') unless params[:exclude].count == 0
+
+            Actions.sh(clean_command) unless params[:skip_clean]
+
+            UI.success('Git repo was reset and cleaned back to a pristine state.')
+          else
+            paths.each do |path|
+              UI.important("Couldn't find file at path '#{path}'") unless File.exist?(path)
+              Actions.sh("git checkout -- '#{path}'")
+            end
+            UI.success("Git cleaned up #{paths.count} files.")
+          end
+        else
+          UI.user_error!('This is a destructive and potentially dangerous action. To protect from data loss, please add the `ensure_git_status_clean` action to the beginning of your lane, or if you\'re absolutely sure of what you\'re doing then call this action with the :force option.')
+        end
+      end
+
+      def self.description
+        "Resets git repo to a clean state by discarding uncommitted changes"
+      end
+
+      def self.details
+        list = <<-LIST.markdown_list
+          You have called the `ensure_git_status_clean` action prior to calling this action. This ensures that your repo started off in a clean state, so the only things that will get destroyed by this action are files that are created as a byproduct of the pantograph run.
+        LIST
+
+        [
+          "This action will reset your git repo to a clean state, discarding any uncommitted and untracked changes. Useful in case you need to revert the repo back to a clean state, e.g. after running _pantograph_.",
+          "Untracked files like `.env` will also be deleted, unless `:skip_clean` is true.",
+          "It's a pretty drastic action so it comes with a sort of safety latch. It will only proceed with the reset if this condition is met:".markdown_preserve_newlines,
+          list
+        ].join("\n")
+      end
+
+      def self.example_code
+        [
+          'reset_git_repo',
+          'reset_git_repo(force: true) # If you don\'t care about warnings and are absolutely sure that you want to discard all changes. This will reset the repo even if you have valuable uncommitted changes, so use with care!',
+          'reset_git_repo(skip_clean: true) # If you want "git clean" to be skipped, thus NOT deleting untracked files like ".env". Optional, defaults to false.',
+          'reset_git_repo(
+            force: true,
+            files: [
+              "./file.txt"
+            ]
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+
+      def self.available_options
+        [
+          PantographCore::ConfigItem.new(key: :files,
+                                       env_name: "FL_RESET_GIT_FILES",
+                                       description: "Array of files the changes should be discarded. If not given, all files will be discarded",
+                                       optional: true,
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass an array only") unless value.kind_of?(Array)
+                                       end),
+          PantographCore::ConfigItem.new(key: :force,
+                                       env_name: "FL_RESET_GIT_FORCE",
+                                       description: "Skip verifying of previously clean state of repo. Only recommended in combination with `files` option",
+                                       is_string: false,
+                                       default_value: false),
+          PantographCore::ConfigItem.new(key: :skip_clean,
+                                       env_name: "FL_RESET_GIT_SKIP_CLEAN",
+                                       description: "Skip 'git clean' to avoid removing untracked files like `.env`",
+                                       is_string: false,
+                                       default_value: false),
+          PantographCore::ConfigItem.new(key: :disregard_gitignore,
+                                       env_name: "FL_RESET_GIT_DISREGARD_GITIGNORE",
+                                       description: "Setting this to true will clean the whole repository, ignoring anything in your local .gitignore. Set this to true if you want the equivalent of a fresh clone, and for all untracked and ignore files to also be removed",
+                                       is_string: false,
+                                       optional: true,
+                                       default_value: true),
+          PantographCore::ConfigItem.new(key: :exclude,
+                                       env_name: "FL_RESET_GIT_EXCLUDE",
+                                       description: "You can pass a string, or array of, file pattern(s) here which you want to have survive the cleaning process, and remain on disk, e.g. to leave the `artifacts` directory you would specify `exclude: 'artifacts'`. Make sure this pattern is also in your gitignore! See the gitignore documentation for info on patterns",
+                                       is_string: false,
+                                       optional: true)
+        ]
+      end
+
+      def self.author
+        'lmirosevic'
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/actions/rocket.rb

@@ -0,0 +1,83 @@
+module Pantograph
+  module Actions
+    class RocketAction < Action
+      def self.run(params)
+        puts("
+        ____
+       /    \\
+      |      |
+      |      |
+      |      |
+       \\____/
+       |    |
+       |    |
+       |    |
+       |____|
+      {|    |}
+       |    |
+       |    |
+       | F  |
+       | A  |
+       | S  |
+       | T  |
+       | L  |
+       | A  |
+      /| N  |\\
+      || E  ||
+      ||    ||
+      \\|____|/
+       /_\\/_\\
+       ######
+      ########
+       ######
+        ####
+        ####
+         ##
+         ##
+         ##
+         ##
+         ")
+        return "🚀"
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Outputs ascii-art for a rocket 🚀"
+      end
+
+      def self.details
+        "Print an ascii Rocket :rocket:. Useful after using _crashlytics_ or _pilot_ to indicate that your new build has been shipped to outer-space."
+      end
+
+      def self.available_options
+        [
+        ]
+      end
+
+      def self.authors
+        ["JaviSoto", "radex"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'rocket'
+        ]
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/actions/rsync.rb

@@ -0,0 +1,74 @@
+
+module Pantograph
+  module Actions
+    module SharedValues
+    end
+
+    class RsyncAction < Action
+      def self.run(params)
+        rsync_cmd = ["rsync"]
+        rsync_cmd << params[:extra]
+        rsync_cmd << params[:source]
+        rsync_cmd << params[:destination]
+        Actions.sh(rsync_cmd.join(" "))
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Rsync files from :source to :destination"
+      end
+
+      def self.details
+        "A wrapper around `rsync`, which is a tool that lets you synchronize files, including permissions and so on. For a more detailed information about `rsync`, please see [rsync(1) man page](https://linux.die.net/man/1/rsync)."
+      end
+
+      def self.available_options
+        [
+          PantographCore::ConfigItem.new(key: :extra,
+                                       short_option: "-X",
+                                       env_name: "FL_RSYNC_EXTRA", # The name of the environment variable
+                                       description: "Port", # a short description of this parameter
+                                       optional: true,
+                                       default_value: "-av",
+                                       is_string: true),
+          PantographCore::ConfigItem.new(key: :source,
+                                       short_option: "-S",
+                                       env_name: "FL_RSYNC_SRC", # The name of the environment variable
+                                       description: "source file/folder", # a short description of this parameter
+                                       optional: false,
+                                       is_string: true),
+          PantographCore::ConfigItem.new(key: :destination,
+                                       short_option: "-D",
+                                       env_name: "FL_RSYNC_DST", # The name of the environment variable
+                                       description: "destination file/folder", # a short description of this parameter
+                                       optional: false,
+                                       is_string: true)
+        ]
+      end
+
+      def self.authors
+        ["hjanuschka"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'rsync(
+            source: "root@host:/tmp/1.txt",
+            destination: "/tmp/local_file.txt"
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end