pantograph 0.1.0

data/pantograph/lib/pantograph/actions/twitter.rb

@@ -0,0 +1,89 @@
+module Pantograph
+  module Actions
+    class TwitterAction < Action
+      def self.run(params)
+        Actions.verify_gem!("twitter")
+        require 'twitter'
+        client = Twitter::REST::Client.new do |config|
+          config.consumer_key        = params[:consumer_key]
+          config.consumer_secret     = params[:consumer_secret]
+          config.access_token        = params[:access_token]
+          config.access_token_secret = params[:access_token_secret]
+        end
+        client.update(params[:message])
+        UI.message(['[TWITTER]', "Successfully tweeted ", params[:message]].join(': '))
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Post a tweet on [Twitter.com](https://twitter.com)"
+      end
+
+      def self.details
+        "Post a tweet on Twitter. Requires you to setup an app on [twitter.com](https://twitter.com) and obtain `consumer` and `access_token`."
+      end
+
+      def self.available_options
+        [
+          PantographCore::ConfigItem.new(key: :consumer_key,
+                                       env_name: "FL_TW_CONSUMER_KEY",
+                                       description: "Consumer Key",
+                                       sensitive: true,
+                                       is_string: true,
+                                       optional: false),
+          PantographCore::ConfigItem.new(key: :consumer_secret,
+                                       env_name: "FL_TW_CONSUMER_SECRET",
+                                       sensitive: true,
+                                       description: "Consumer Secret",
+                                       is_string: true,
+                                       optional: false),
+          PantographCore::ConfigItem.new(key: :access_token,
+                                       env_name: "FL_TW_ACCESS_TOKEN",
+                                       sensitive: true,
+                                       description: "Access Token",
+                                       is_string: true,
+                                       optional: false),
+          PantographCore::ConfigItem.new(key: :access_token_secret,
+                                       env_name: "FL_TW_ACCESS_TOKEN_SECRET",
+                                       sensitive: true,
+                                       description: "Access Token Secret",
+                                       is_string: true,
+                                       optional: false),
+          PantographCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_TW_MESSAGE",
+                                       description: "The tweet",
+                                       is_string: true,
+                                       optional: false)
+
+        ]
+      end
+
+      def self.authors
+        ["hjanuschka"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'twitter(
+            access_token: "XXXX",
+            access_token_secret: "xxx",
+            consumer_key: "xxx",
+            consumer_secret: "xxx",
+            message: "You rock!"
+          )'
+        ]
+      end
+
+      def self.category
+        :notifications
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/actions/update_pantograph.rb

@@ -0,0 +1,177 @@
+require 'rubygems/spec_fetcher'
+require 'rubygems/command_manager'
+
+module Pantograph
+  module Actions
+    # Makes sure pantograph tools are up-to-date when running pantograph
+    class UpdatePantographAction < Action
+      ALL_TOOLS = ["pantograph"]
+
+      def self.run(options)
+        return if options[:no_update] # this is used to update itself
+
+        tools_to_update = options[:tools].split(',') unless options[:tools].nil?
+        tools_to_update ||= all_installed_tools
+
+        if tools_to_update.count == 0
+          UI.error("No tools specified or couldn't find any installed pantograph.tools")
+          return
+        end
+
+        UI.message("Looking for updates for #{tools_to_update.join(', ')}...")
+
+        updater = Gem::CommandManager.instance[:update]
+        updater.options[:prerelease] = true if options[:nightly]
+        cleaner = Gem::CommandManager.instance[:cleanup]
+
+        gem_dir = ENV['GEM_HOME'] || Gem.dir
+        sudo_needed = !File.writable?(gem_dir)
+
+        if sudo_needed
+          UI.important("It seems that your Gem directory is not writable by your current user.")
+          UI.important("pantograph would need sudo rights to update itself, however, running 'sudo pantograph' is not recommended.")
+          UI.important("If you still want to use this action, please read the documentation on how to set this up:")
+          UI.important("https://docs.pantograph.tools/actions/update_pantograph/")
+          return
+        end
+
+        unless updater.respond_to?(:highest_installed_gems)
+          UI.important("The update_pantograph action requires rubygems version 2.1.0 or greater.")
+          UI.important("Please update your version of ruby gems before proceeding.")
+          UI.command "gem install rubygems-update"
+          UI.command "update_rubygems"
+          UI.command "gem update --system"
+          return
+        end
+
+        highest_versions = updater.highest_installed_gems.keep_if { |key| tools_to_update.include?(key) }
+        update_needed = updater.which_to_update(highest_versions, tools_to_update)
+
+        if update_needed.count == 0
+          UI.success("Nothing to update ✅")
+          show_information_about_nightly_builds unless options[:nightly]
+          return
+        end
+
+        # suppress updater output - very noisy
+        Gem::DefaultUserInteraction.ui = Gem::SilentUI.new
+
+        update_needed.each do |tool_info|
+          tool = tool_info[0]
+          gem_version = tool_info[1]
+          local_version = Gem::Version.new(highest_versions[tool].version)
+          latest_official_version = PantographCore::UpdateChecker.fetch_latest(tool)
+
+          if options[:nightly]
+            UI.message("Updating #{tool} from #{local_version.to_s.yellow} to nightly build #{gem_version.to_s.yellow}... (last official release #{latest_official_version.to_s.yellow}) 🚀")
+          else
+            UI.message("Updating #{tool} from #{local_version.to_s.yellow} to #{latest_official_version.to_s.yellow}... 🚀")
+          end
+
+          # Approximate_recommendation will create a string like "~> 0.10" from a version 0.10.0, e.g. one that is valid for versions >= 0.10 and <1.0
+          requirement_version = options[:nightly] ? gem_version : local_version.approximate_recommendation
+          updater.update_gem(tool, Gem::Requirement.new(requirement_version))
+
+          UI.success("Finished updating #{tool}")
+        end
+
+        UI.message("Cleaning up old versions...")
+        cleaner.options[:args] = tools_to_update
+        cleaner.execute
+
+        if options[:nightly]
+          UI.success("Thanks for using pantograph's nightly builds! This makes it easier for everyone to detect regressions earlier.")
+          UI.success("Please submit an issue on GitHub if anything behaves differently than it should 🍪")
+        else
+          show_information_about_nightly_builds
+        end
+
+        UI.message("pantograph.tools successfully updated! I will now restart myself... 😴")
+
+        # Set no_update to true so we don't try to update again
+        exec("FL_NO_UPDATE=true #{$PROGRAM_NAME} #{ARGV.join(' ')}")
+      end
+
+      def self.show_information_about_nightly_builds
+        UI.message("")
+        UI.message("Please help us test early releases of pantograph by opting into nightly builds 🌃")
+        UI.message("Just replace your `update_pantograph` call with")
+        UI.message("")
+        UI.command_output("update_pantograph(nightly: true)")
+        UI.message("")
+        UI.message("Nightly builds are reviewed and tested just like the public releases 🚂")
+        UI.message("")
+      end
+
+      def self.all_installed_tools
+        Gem::Specification.select { |s| ALL_TOOLS.include?(s.name) }.map(&:name).uniq
+      end
+
+      def self.description
+        "Makes sure pantograph-tools are up-to-date when running pantograph"
+      end
+
+      def self.details
+        sample = <<-SAMPLE.markdown_sample
+          ```bash
+          export GEM_HOME=~/.gems
+          export PATH=$PATH:~/.gems/bin
+          ```
+        SAMPLE
+
+        [
+          "This action will update pantograph to the most recent version - major version updates will not be performed automatically, as they might include breaking changes. If an update was performed, pantograph will be restarted before the run continues.",
+          "",
+          "If you are using rbenv or rvm, everything should be good to go. However, if you are using the system's default ruby, some additional setup is needed for this action to work correctly. In short, pantograph needs to be able to access your gem library without running in `sudo` mode.",
+          "",
+          "The simplest possible fix for this is putting the following lines into your `~/.bashrc` or `~/.zshrc` file:".markdown_preserve_newlines,
+          sample,
+          "After the above changes, restart your terminal, then run `mkdir $GEM_HOME` to create the new gem directory. After this, you're good to go!",
+          "",
+          "Recommended usage of the `update_pantograph` action is at the top inside of the `before_all` block, before running any other action."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          PantographCore::ConfigItem.new(key: :nightly,
+                                       env_name: "FL_UPDATE_PANTOGRAPH_NIGHTLY",
+                                       description: "Opt-in to install and use nightly pantograph builds",
+                                       is_string: false,
+                                       default_value: false),
+          PantographCore::ConfigItem.new(key: :no_update,
+                                       env_name: "FL_NO_UPDATE",
+                                       description: "Don't update during this run. This is used internally",
+                                       is_string: false,
+                                       default_value: false),
+          PantographCore::ConfigItem.new(key: :tools,
+                                       env_name: "FL_TOOLS_TO_UPDATE",
+                                       description: "Comma separated list of pantograph tools to update (e.g. `pantograph,sigh`)",
+                                       deprecated: true,
+                                       optional: true)
+        ]
+      end
+
+      def self.authors
+        ["milch", "KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'before_all do
+            update_pantograph
+            # ...
+          end'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/actions/zip.rb

@@ -0,0 +1,120 @@
+module Pantograph
+  module Actions
+    class ZipAction < Action
+      def self.run(params)
+        UI.message("Compressing #{params[:path]}...")
+
+        params[:output_path] ||= params[:path]
+
+        absolute_output_path = File.expand_path(params[:output_path])
+
+        # Appends ".zip" if path does not end in ".zip"
+        unless absolute_output_path.end_with?(".zip")
+          absolute_output_path += ".zip"
+        end
+
+        absolute_output_dir = File.expand_path("..", absolute_output_path)
+        FileUtils.mkdir_p(absolute_output_dir)
+
+        Dir.chdir(File.expand_path("..", params[:path])) do # required to properly zip
+          zip_options = params[:verbose] ? "r" : "rq"
+          zip_options += "y" if params[:symlinks]
+
+          if params[:password]
+            password_option = "-P '#{params[:password]}'"
+            Actions.sh("zip -#{zip_options} #{password_option} #{absolute_output_path.shellescape} #{File.basename(params[:path]).shellescape}")
+          else
+            Actions.sh("zip -#{zip_options} #{absolute_output_path.shellescape} #{File.basename(params[:path]).shellescape}")
+          end
+        end
+
+        UI.success("Successfully generated zip file at path '#{File.expand_path(absolute_output_path)}'")
+        return File.expand_path(absolute_output_path)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Compress a file or folder to a zip"
+      end
+
+      def self.available_options
+        [
+          PantographCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_ZIP_PATH",
+                                       description: "Path to the directory or file to be zipped",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find file/folder at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                       end),
+          PantographCore::ConfigItem.new(key: :output_path,
+                                       env_name: "FL_ZIP_OUTPUT_NAME",
+                                       description: "The name of the resulting zip file",
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :verbose,
+                                       env_name: "FL_ZIP_VERBOSE",
+                                       description: "Enable verbose output of zipped file",
+                                       default_value: true,
+                                       type: Boolean,
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :password,
+                                       env_name: "FL_ZIP_PASSWORD",
+                                       description: "Encrypt the contents of the zip archive using a password",
+                                       optional: true),
+          PantographCore::ConfigItem.new(key: :symlinks,
+                                       env_name: "FL_ZIP_SYMLINKS",
+                                       description: "Store symbolic links as such in the zip archive",
+                                       optional: true,
+                                       type: Boolean,
+                                       default_value: false)
+        ]
+      end
+
+      def self.example_code
+        [
+          'zip',
+          'zip(
+            path: "MyApp.app",
+            output_path: "Latest.app.zip"
+          )',
+          'zip(
+            path: "MyApp.app",
+            output_path: "Latest.app.zip",
+            verbose: false
+          )',
+          'zip(
+            path: "MyApp.app",
+            output_path: "Latest.app.zip",
+            verbose: false,
+            symlinks: true
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.output
+        []
+      end
+
+      def self.return_value
+        "The path to the output zip file"
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/auto_complete.rb

@@ -0,0 +1,82 @@
+require 'fileutils'
+
+module Pantograph
+  # Enable tab auto completion
+  class AutoComplete
+    # This method copies the tab auto completion scripts to the user's home folder,
+    # while optionally adding custom commands for which to enable auto complete
+    # @param [Array] options An array of all options (e.g. --custom fl)
+    def self.execute(args, options)
+      shell = ENV['SHELL']
+
+      if shell.end_with?("fish")
+        fish_completions_dir = "~/.config/fish/completions"
+
+        if UI.interactive?
+          confirm = UI.confirm("This will copy a fish script into #{fish_completions_dir} that provides the command tab completion. If the directory does not exist it will be created. Sound good?")
+          return unless confirm
+        end
+
+        fish_completions_dir = File.expand_path(fish_completions_dir)
+        FileUtils.mkdir_p(fish_completions_dir)
+
+        completion_script_path = File.join(Pantograph::ROOT, 'lib', 'assets', 'completions', 'completion.fish')
+        final_completion_script_path = File.join(fish_completions_dir, 'pantograph.fish')
+
+        FileUtils.cp(completion_script_path, final_completion_script_path)
+
+        UI.success("Copied! You can now use tab completion for lanes")
+      else
+        pantograph_conf_dir = "~/.pantograph"
+
+        if UI.interactive?
+          confirm = UI.confirm("This will copy a shell script into #{pantograph_conf_dir} that provides the command tab completion. Sound good?")
+          return unless confirm
+        end
+
+        # create the ~/.pantograph directory
+        pantograph_conf_dir = File.expand_path(pantograph_conf_dir)
+        FileUtils.mkdir_p(pantograph_conf_dir)
+
+        # then copy all of the completions files into it from the gem
+        completion_script_path = File.join(Pantograph::ROOT, 'lib', 'assets', 'completions')
+        FileUtils.cp_r(completion_script_path, pantograph_conf_dir)
+
+        custom_commands = options.custom.to_s.split(',')
+
+        Pantograph::SHELLS.each do |shell_name|
+          open("#{pantograph_conf_dir}/completions/completion.#{shell_name}", 'a') do |file|
+            default_line_prefix = Helper.bundler? ? "bundle exec " : ""
+
+            file.puts(self.get_auto_complete_line(shell_name, "#{default_line_prefix}pantograph"))
+
+            custom_commands.each do |command|
+              auto_complete_line = self.get_auto_complete_line(shell_name, command)
+
+              next if auto_complete_line.nil?
+
+              file.puts(auto_complete_line)
+            end
+          end
+        end
+
+        UI.success("Copied! To use auto complete for pantograph, add the following line to your favorite rc file (e.g. ~/.bashrc)")
+        UI.important("  . ~/.pantograph/completions/completion.sh")
+        UI.success("Don't forget to source that file in your current shell! 🐚")
+      end
+    end
+
+    # Helper to get the auto complete register script line
+    def self.get_auto_complete_line(shell, command)
+      if shell == :bash
+        prefix = "complete -F"
+      elsif shell == :zsh
+        prefix = "compctl -K"
+      else
+        return nil
+      end
+
+      return "#{prefix} _pantograph_complete #{command}"
+    end
+  end
+end

data/pantograph/lib/pantograph/boolean.rb

@@ -0,0 +1,5 @@
+module Pantograph
+  class Boolean
+    # Used in config item generation
+  end
+end

data/pantograph/lib/pantograph/cli_tools_distributor.rb

@@ -0,0 +1,183 @@
+module Pantograph
+  # This class is responsible for checking the ARGV
+  # to see if the user wants to launch another pantograph
+  # tool or pantograph itself
+  class CLIToolsDistributor
+    class << self
+      def running_version_command?
+        ARGV.include?('-v') || ARGV.include?('--version')
+      end
+
+      def running_help_command?
+        ARGV.include?('-h') || ARGV.include?('--help')
+      end
+
+      def running_init_command?
+        ARGV.include?("init")
+      end
+
+      def utf8_locale?
+        (ENV['LANG'] || "").end_with?("UTF-8", "utf8") || (ENV['LC_ALL'] || "").end_with?("UTF-8", "utf8") || (PantographCore::CommandExecutor.which('locale') && `locale charmap`.strip == "UTF-8")
+      end
+
+      def take_off
+        before_import_time = Time.now
+
+        if !ENV["PANTOGRAPH_DISABLE_ANIMATION"]
+          # Usually in the pantograph code base we use
+          #
+          #   Helper.show_loading_indicator
+          #   longer_taking_task_here
+          #   Helper.hide_loading_indicator
+          #
+          # but in this case we haven't required PantographCore yet
+          # so we'll have to access the raw API for now
+          require "tty-spinner"
+          require_pantograph_spinner = TTY::Spinner.new("[:spinner] 🚀 ", format: :dots)
+          require_pantograph_spinner.auto_spin
+
+          # this might take a long time if there is no Gemfile :(
+          # That's why we show the loading indicator here also
+          require "pantograph"
+
+          require_pantograph_spinner.success
+        else
+          require "pantograph"
+        end
+        # We want to avoid printing output other than the version number if we are running `pantograph -v`
+        unless running_version_command? || running_init_command?
+          print_bundle_exec_warning(is_slow: (Time.now - before_import_time > 3))
+        end
+
+        # Try to check UTF-8 with `locale`, fallback to environment variables
+        unless utf8_locale?
+          warn = "WARNING: pantograph requires your locale to be set to UTF-8. To learn more go to https://docs.pantograph.tools/getting-started/ios/setup/#set-up-environment-variables"
+          UI.error(warn)
+          at_exit do
+            # Repeat warning here so users hopefully see it
+            UI.error(warn)
+          end
+        end
+
+        # Loading any .env files before any lanes are called since
+        # variables like PANTOGRAPH_HIDE_CHANGELOG and PANTOGRAPH_DISABLE_COLORS
+        # need to be set early on in execution
+        require 'pantograph/helper/dotenv_helper'
+        Pantograph::Helper::DotenvHelper.load_dot_env(nil)
+
+        # Needs to go after load_dot_env for variable PANTOGRAPH_SKIP_UPDATE_CHECK
+        PantographCore::UpdateChecker.start_looking_for_update('pantograph')
+
+        # Disabling colors if environment variable set
+        require 'pantograph_core/ui/disable_colors' if PantographCore::Helper.colors_disabled?
+
+        tool_name = ARGV.first ? ARGV.first.downcase : nil
+
+        tool_name = process_emojis(tool_name)
+
+        if tool_name && Pantograph::TOOLS.include?(tool_name.to_sym) && !available_lanes.include?(tool_name.to_sym)
+          # Triggering a specific tool
+          # This happens when the users uses things like
+          #
+          #   pantograph sigh
+          #
+          require tool_name
+          begin
+            # First, remove the tool's name from the arguments
+            # Since it will be parsed by the `commander` at a later point
+            # and it must not contain the binary name
+            ARGV.shift
+
+            # Import the CommandsGenerator class, which is used to parse
+            # the user input
+            require File.join(tool_name, "commands_generator")
+
+            # Call the tool's CommandsGenerator class and let it do its thing
+            commands_generator = Object.const_get(tool_name.pantograph_module)::CommandsGenerator
+          rescue LoadError
+            # This will only happen if the tool we call here, doesn't provide
+            # a CommandsGenerator class yet
+            # When we launch this feature, this should never be the case
+            abort("#{tool_name} can't be called via `pantograph #{tool_name}`, run '#{tool_name}' directly instead".red)
+          end
+
+          # Some of the tools use other actions so need to load all
+          # actions before we start the tool generator
+          # Example: scan uses slack
+          Pantograph.load_actions
+
+          commands_generator.start
+        # elsif tool_name == "pantograph-credentials"
+        #   require 'credentials_manager'
+        #   ARGV.shift
+        #   CredentialsManager::CLI.new.run
+        else
+          # Triggering pantograph to call a lane
+          require "pantograph/commands_generator"
+          Pantograph::CommandsGenerator.start
+        end
+      ensure
+        # PantographCore::UpdateChecker.show_update_status('pantograph', Pantograph::VERSION)
+      end
+
+      # Since pantograph also supports the rocket and biceps emoji as executable
+      # we need to map those to the appropriate tools
+      def process_emojis(tool_name)
+        return {
+          "🚀" => "pantograph",
+          "💪" => "gym"
+        }[tool_name] || tool_name
+      end
+
+      def print_bundle_exec_warning(is_slow: false)
+        return if PantographCore::Helper.bundler? # user is alread using bundler
+        return if PantographCore::Env.truthy?('SKIP_SLOW_PANTOGRAPH_WARNING') # user disabled the warnings
+        return if PantographCore::Helper.contained_pantograph? # user uses the bundled pantograph
+
+        gemfile_path = PluginManager.new.gemfile_path
+        if gemfile_path
+          # The user has a Gemfile, but forgot to use `bundle exec`
+          # Let's tell the user how to use `bundle exec`
+          # We show this warning no matter if the command is slow or not
+          UI.important("pantograph detected a Gemfile in the current directory")
+          UI.important("however it seems like you don't use `bundle exec`")
+          UI.important("to launch pantograph faster, please use")
+          UI.message("")
+          UI.command "bundle exec pantograph #{ARGV.join(' ')}"
+          UI.message("")
+        elsif is_slow
+          # pantograph is slow and there is no Gemfile
+          # Let's tell the user how to use `gem cleanup` and how to
+          # start using a Gemfile
+          UI.important('Seems like launching pantograph takes a while - please run')
+          UI.message('')
+          UI.command('gem cleanup')
+          UI.message('')
+          UI.important('to uninstall outdated gems and make pantograph launch faster')
+          UI.important('Alternatively it is recommended to start using a Gemfile to lock your dependencies')
+          UI.important('To get started with a Gemfile, run')
+          UI.message('')
+          UI.command 'bundle init'
+          UI.command "echo 'gem \"pantograph\"' >> Gemfile"
+          UI.command 'bundle install'
+          UI.message('')
+          UI.important('After creating the Gemfile and Gemfile.lock, commit those files into version control')
+        end
+        UI.important('Get started using a Gemfile for pantograph https://docs.pantograph.tools/getting-started/ios/setup/#use-a-gemfile')
+      end
+
+      # Returns an array of symbols for the available lanes for the Pantfile
+      # This doesn't actually use the Pantfile parser, but only
+      # the available lanes. This way it's much faster, which
+      # is very important in this case, since it will be executed
+      # every time one of the tools is launched
+      # Use this only if performance is :key:
+      def available_lanes
+        pantfile_path = PantographCore::PantographFolder.pantfile_path
+        return [] if pantfile_path.nil?
+        output = `cat #{pantfile_path.shellescape} | grep \"^\s*lane \:\" | awk -F ':' '{print $2}' | awk -F ' ' '{print $1}'`
+        return output.strip.split(" ").collect(&:to_sym)
+      end
+    end
+  end
+end