pantograph 0.1.0

data/pantograph/lib/pantograph/helper/dotenv_helper.rb

@@ -0,0 +1,50 @@
+module Pantograph
+  module Helper
+    class DotenvHelper
+      # @param env_cl_param [String] an optional list of dotenv environment names separated by commas, without space
+      def self.load_dot_env(env_cl_param)
+        base_path = find_dotenv_directory
+
+        return unless base_path
+
+        load_dot_envs_from(env_cl_param, base_path)
+      end
+
+      # finds the first directory of [pantograph, its parent] containing dotenv files
+      def self.find_dotenv_directory
+        path = PantographCore::PantographFolder.path
+        search_paths = [path]
+        search_paths << path + "/.." unless path.nil?
+        search_paths.compact!
+        search_paths.find do |dir|
+          Dir.glob(File.join(dir, '*.env*'), File::FNM_DOTMATCH).count > 0
+        end
+      end
+
+      # loads the dotenvs. First the .env and .env.default and
+      # then override with all speficied extra environments
+      def self.load_dot_envs_from(env_cl_param, base_path)
+        require 'dotenv'
+
+        # Making sure the default '.env' and '.env.default' get loaded
+        env_file = File.join(base_path, '.env')
+        env_default_file = File.join(base_path, '.env.default')
+        Dotenv.load(env_file, env_default_file)
+
+        return unless env_cl_param
+
+        Pantograph::Actions.lane_context[Pantograph::Actions::SharedValues::ENVIRONMENT] = env_cl_param
+
+        # multiple envs?
+        envs = env_cl_param.split(",")
+
+        # Loads .env file for the environment(s) passed in through options
+        envs.each do |env|
+          env_file = File.join(base_path, ".env.#{env}")
+          UI.success("Loading from '#{env_file}'")
+          Dotenv.overload(env_file)
+        end
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/helper/gem_helper.rb

@@ -0,0 +1,26 @@
+module Pantograph
+  module Actions
+    # will make sure a gem is installed. If it's not an appropriate error message is shown
+    # this will *not* 'require' the gem
+    def self.verify_gem!(gem_name)
+      begin
+        PantographRequire.install_gem_if_needed(gem_name: gem_name, require_gem: false)
+        # We don't import this by default, as it's not always the same
+        # also e.g. cocoapods is just required and not imported
+      rescue Gem::LoadError
+        UI.error("Could not find gem '#{gem_name}'")
+        UI.error("")
+        UI.error("If you installed pantograph using `gem install pantograph` run")
+        UI.command("gem install #{gem_name}")
+        UI.error("to install the missing gem")
+        UI.error("")
+        UI.error("If you use a Gemfile add this to your Gemfile:")
+        UI.important("  gem '#{gem_name}'")
+        UI.error("and run `bundle install`")
+
+        UI.user_error!("You have to install the `#{gem_name}` gem on this machine") unless Helper.test?
+      end
+      true
+    end
+  end
+end

data/pantograph/lib/pantograph/helper/git_helper.rb

@@ -0,0 +1,135 @@
+module Pantograph
+  module Actions
+    GIT_MERGE_COMMIT_FILTERING_OPTIONS = [:include_merges, :exclude_merges, :only_include_merges].freeze
+
+    def self.git_log_between(pretty_format, from, to, merge_commit_filtering, date_format = nil, ancestry_path)
+      command = %w(git log)
+      command << "--pretty=#{pretty_format}"
+      command << "--date=#{date_format}" if date_format
+      command << '--ancestry-path' if ancestry_path
+      command << "#{from}...#{to}"
+      command << git_log_merge_commit_filtering_option(merge_commit_filtering)
+      # "*command" syntax expands "command" array into variable arguments, which
+      # will then be individually shell-escaped by Actions.sh.
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    def self.git_log_last_commits(pretty_format, commit_count, merge_commit_filtering, date_format = nil, ancestry_path)
+      command = %w(git log)
+      command << "--pretty=#{pretty_format}"
+      command << "--date=#{date_format}" if date_format
+      command << '--ancestry-path' if ancestry_path
+      command << '-n' << commit_count.to_s
+      command << git_log_merge_commit_filtering_option(merge_commit_filtering)
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    def self.last_git_tag_hash(tag_match_pattern = nil)
+      tag_pattern_param = tag_match_pattern ? "=#{tag_match_pattern}" : ''
+      Actions.sh('git', 'rev-list', "--tags#{tag_pattern_param}", '--max-count=1').chomp
+    rescue
+      nil
+    end
+
+    def self.last_git_tag_name(match_lightweight = true, tag_match_pattern = nil)
+      hash = last_git_tag_hash(tag_match_pattern)
+      # If hash is nil (command fails), "git describe" command below will still
+      # run and provide some output, although it's definitely not going to be
+      # anything reasonably expected. Bail out early.
+      return unless hash
+
+      command = %w(git describe)
+      command << '--tags' if match_lightweight
+      command << hash
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    def self.last_git_commit_dict
+      return nil if last_git_commit_formatted_with('%an').nil?
+
+      {
+          author: last_git_commit_formatted_with('%an'),
+          author_email: last_git_commit_formatted_with('%ae'),
+          message: last_git_commit_formatted_with('%B'),
+          commit_hash: last_git_commit_formatted_with('%H'),
+          abbreviated_commit_hash: last_git_commit_formatted_with('%h')
+      }
+    end
+
+    # Gets the last git commit information formatted into a String by the provided
+    # pretty format String. See the git-log documentation for valid format placeholders
+    def self.last_git_commit_formatted_with(pretty_format, date_format = nil)
+      command = %w(git log -1)
+      command << "--pretty=#{pretty_format}"
+      command << "--date=#{date_format}" if date_format
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    # @deprecated Use <tt>git_author_email</tt> instead
+    # Get the author email of the last git commit
+    # <b>DEPRECATED:</b> Use <tt>git_author_email</tt> instead.
+    def self.git_author
+      UI.deprecated('`git_author` is deprecated. Please use `git_author_email` instead.')
+      git_author_email
+    end
+
+    # Get the author email of the last git commit
+    def self.git_author_email
+      s = last_git_commit_formatted_with('%ae')
+      return s if s.to_s.length > 0
+      return nil
+    end
+
+    # Returns the unwrapped subject and body of the last commit
+    # <b>DEPRECATED:</b> Use <tt>last_git_commit_message</tt> instead.
+    def self.last_git_commit
+      UI.important('`last_git_commit` is deprecated. Please use `last_git_commit_message` instead.')
+      last_git_commit_message
+    end
+
+    # Returns the unwrapped subject and body of the last commit
+    def self.last_git_commit_message
+      s = (last_git_commit_formatted_with('%B') || "").strip
+      return s if s.to_s.length > 0
+      nil
+    end
+
+    # Get the hash of the last commit
+    def self.last_git_commit_hash(short)
+      format_specifier = short ? '%h' : '%H'
+      string = last_git_commit_formatted_with(format_specifier).to_s
+      return string unless string.empty?
+      return nil
+    end
+
+    # Returns the current git branch - can be replaced using the environment variable `GIT_BRANCH`
+    def self.git_branch
+      return ENV['GIT_BRANCH'] if ENV['GIT_BRANCH'].to_s.length > 0 # set by Jenkins
+      s = Actions.sh("git rev-parse --abbrev-ref HEAD", log: false).chomp
+      return s.to_s.strip if s.to_s.length > 0
+      nil
+    rescue
+      nil
+    end
+
+    private_class_method
+    def self.git_log_merge_commit_filtering_option(merge_commit_filtering)
+      case merge_commit_filtering
+      when :exclude_merges
+        "--no-merges"
+      when :only_include_merges
+        "--merges"
+      when :include_merges
+        nil
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/helper/gradle_helper.rb

@@ -0,0 +1,62 @@
+module Pantograph
+  module Helper
+    class GradleTask
+      attr_accessor :title
+
+      attr_accessor :description
+
+      def initialize(title: nil, description: nil)
+        self.title = title
+        self.description = description
+      end
+    end
+
+    class GradleHelper
+      # Path to the gradle script
+      attr_accessor :gradle_path
+
+      # Read-only path to the shell-escaped gradle script, suitable for use in shell commands
+      attr_reader :escaped_gradle_path
+
+      # All the available tasks
+      attr_accessor :tasks
+
+      def initialize(gradle_path: nil)
+        self.gradle_path = gradle_path
+      end
+
+      # Run a certain action
+      def trigger(task: nil, flags: nil, serial: nil, print_command: true, print_command_output: true)
+        android_serial = (serial != "") ? "ANDROID_SERIAL=#{serial}" : nil
+        command = [android_serial, escaped_gradle_path, task, flags].compact.join(" ")
+        Action.sh(command, print_command: print_command, print_command_output: print_command_output)
+      end
+
+      def task_available?(task)
+        load_all_tasks
+        return tasks.collect(&:title).include?(task)
+      end
+
+      def gradle_path=(gradle_path)
+        @gradle_path = gradle_path
+        @escaped_gradle_path = gradle_path.shellescape
+      end
+
+      private
+
+      def load_all_tasks
+        self.tasks = []
+
+        command = [escaped_gradle_path, "tasks", "--console=plain"].join(" ")
+        output = Action.sh(command, print_command: false, print_command_output: false)
+        output.split("\n").each do |line|
+          if (result = line.match(/(\w+)\s\-\s([\w\s]+)/))
+            self.tasks << GradleTask.new(title: result[1], description: result[2])
+          end
+        end
+
+        self.tasks
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/helper/sh_helper.rb

@@ -0,0 +1,134 @@
+require "open3"
+
+module Pantograph
+  module Actions
+    # Execute a shell command
+    # This method will output the string and execute it
+    # Just an alias for sh_no_action
+    # When running this in tests, it will return the actual command instead of executing it
+    # @param log [Boolean] should pantograph print out the executed command
+    # @param error_callback [Block] a callback invoked with the command output if there is a non-zero exit status
+    def self.sh(*command, log: true, error_callback: nil, &b)
+      sh_control_output(*command, print_command: log, print_command_output: log, error_callback: error_callback, &b)
+    end
+
+    def self.sh_no_action(*command, log: true, error_callback: nil, &b)
+      sh_control_output(*command, print_command: log, print_command_output: log, error_callback: error_callback, &b)
+    end
+
+    # @param command The command to be executed (variadic)
+    # @param print_command [Boolean] Should we print the command that's being executed
+    # @param print_command_output [Boolean] Should we print the command output during execution
+    # @param error_callback [Block] A block that's called if the command exits with a non-zero status
+    # @yield [status, result, cmd] The return status of the command, all output from the command and an equivalent shell command
+    # @yieldparam [Process::Status] status A Process::Status indicating the status of the completed command
+    # @yieldparam [String] result The complete output to stdout and stderr of the completed command
+    # @yieldparam [String] cmd A shell command equivalent to the arguments passed
+    # rubocop: disable Metrics/PerceivedComplexity
+    def self.sh_control_output(*command, print_command: true, print_command_output: true, error_callback: nil)
+      print_command = print_command_output = true if $troubleshoot
+      # Set the encoding first, the user might have set it wrong
+      previous_encoding = [Encoding.default_external, Encoding.default_internal]
+      Encoding.default_external = Encoding::UTF_8
+      Encoding.default_internal = Encoding::UTF_8
+
+      # Workaround to support previous Pantograph syntax.
+      # This has some limitations. For example, it requires the caller to shell escape
+      # everything because of usages like ["ls -la", "/tmp"] instead of ["ls", "-la", "/tmp"].
+      command = [command.first.join(" ")] if command.length == 1 && command.first.kind_of?(Array)
+
+      shell_command = shell_command_from_args(*command)
+      UI.command(shell_command) if print_command
+
+      result = ''
+      exit_status = nil
+      if Helper.sh_enabled?
+        # The argument list is passed directly to Open3.popen2e, which
+        # handles the variadic argument list in the same way as Kernel#spawn.
+        # (http://ruby-doc.org/core-2.4.2/Kernel.html#method-i-spawn) or
+        # Process.spawn (http://ruby-doc.org/core-2.4.2/Process.html#method-c-spawn).
+        #
+        # sh "ls -la /Applications/Xcode\ 7.3.1.app"
+        # sh "ls", "-la", "/Applications/Xcode 7.3.1.app"
+        # sh({ "FOO" => "Hello" }, "echo $FOO")
+        Open3.popen2e(*command) do |stdin, io, thread|
+          io.sync = true
+          io.each do |line|
+            UI.command_output(line.strip) if print_command_output
+            result << line
+          end
+          exit_status = thread.value
+        end
+
+        # Checking Process::Status#exitstatus instead of #success? makes for more
+        # testable code. (Tests mock exitstatus only.) This is also consistent
+        # with previous implementations of sh and... probably portable to all
+        # relevant platforms.
+        if exit_status.exitstatus != 0
+          message = if print_command
+                      "Exit status of command '#{shell_command}' was #{exit_status.exitstatus} instead of 0."
+                    else
+                      "Shell command exited with exit status #{exit_status.exitstatus} instead of 0."
+                    end
+          message += "\n#{result}" if print_command_output
+
+          if error_callback || block_given?
+            UI.error(message)
+            # block notified below, on success or failure
+            error_callback && error_callback.call(result)
+          else
+            UI.shell_error!(message)
+          end
+        end
+      else
+        result << shell_command # only for the tests
+      end
+
+      if block_given?
+        # Avoid yielding nil in tests. $? will be meaningless, but calls to
+        # it will not crash. There is no Process::Status.new. The alternative
+        # is to move this inside the sh_enabled? check and not yield in tests.
+        return yield(exit_status || $?, result, shell_command)
+      end
+      result
+    rescue => ex
+      raise ex
+    ensure
+      Encoding.default_external = previous_encoding.first
+      Encoding.default_internal = previous_encoding.last
+    end
+    # rubocop: enable Metrics/PerceivedComplexity
+
+    # Used to produce a shell command string from a list of arguments that may
+    # be passed to methods such as Kernel#system, Kernel#spawn and Open3.popen2e
+    # in order to print the command to the terminal. The same *args are passed
+    # directly to a system call (Open3.popen2e). This interpretation is not
+    # used when executing a command.
+    #
+    # @param args Any number of arguments used to construct a command
+    # @raise [ArgumentError] If no arguments passed
+    # @return [String] A shell command representing the arguments passed in
+    def self.shell_command_from_args(*args)
+      raise ArgumentError, "sh requires at least one argument" unless args.count > 0
+
+      command = ""
+
+      # Optional initial environment Hash
+      if args.first.kind_of?(Hash)
+        command = args.shift.map { |k, v| "#{k}=#{v.shellescape}" }.join(" ") + " "
+      end
+
+      # Support [ "/usr/local/bin/foo", "foo" ], "-x", ...
+      if args.first.kind_of?(Array)
+        command += args.shift.first.shellescape + " " + args.shelljoin
+        command.chomp!(" ")
+      elsif args.count == 1 && args.first.kind_of?(String)
+        command += args.first
+      else
+        command += args.shelljoin
+      end
+
+      command
+    end
+  end
+end

data/pantograph/lib/pantograph/junit_generator.rb

@@ -0,0 +1,27 @@
+module Pantograph
+  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/
+      # And http://windyroad.com.au/dl/Open%20Source/JUnit.xsd
+
+      containing_folder = ENV['FL_REPORT_PATH'] || PantographCore::PantographFolder.path || Dir.pwd
+      path = File.join(containing_folder, 'report.xml')
+
+      @steps = results
+      xml_path = File.join(Pantograph::ROOT, "lib/assets/report_template.xml.erb")
+      xml = ERB.new(File.read(xml_path)).result(binding) # https://web.archive.org/web/20160430190141/www.rrn.dk/rubys-erb-templating-system
+
+      xml = xml.gsub('system_', 'system-').delete("\e") # Jenkins can not parse 'ESC' symbol
+
+      begin
+        File.write(path, xml)
+      rescue => ex
+        UI.error(ex)
+        UI.error("Couldn't save report.xml at path '#{File.expand_path(path)}', make sure you have write access to the containing directory.")
+      end
+
+      return path
+    end
+  end
+end

data/pantograph/lib/pantograph/lane.rb

@@ -0,0 +1,97 @@
+module Pantograph
+  # Represents a lane
+  class Lane
+    attr_accessor :platform
+
+    attr_accessor :name
+
+    # @return [Array] An array containing the description of this lane
+    #   Each item of the array is one line
+    attr_accessor :description
+
+    attr_accessor :block
+
+    # @return [Boolean] Is that a private lane that can't be called from the CLI?
+    attr_accessor :is_private
+
+    def initialize(platform: nil, name: nil, description: nil, block: nil, is_private: false)
+      UI.user_error!("description must be an array") unless description.kind_of?(Array)
+      UI.user_error!("lane name must not contain any spaces") if name.to_s.include?(" ")
+      UI.user_error!("lane name must start with :") unless name.kind_of?(Symbol)
+
+      self.class.verify_lane_name(name)
+
+      self.platform = platform
+      self.name = name
+      self.description = description
+      self.block = block
+      self.is_private = is_private
+    end
+
+    # Execute this lane
+    def call(parameters)
+      block.call(parameters || {})
+    end
+
+    # @return [String] The lane + name of the lane. If there is no platform, it will only be the lane name
+    def pretty_name
+      [platform, name].reject(&:nil?).join(' ')
+    end
+
+    class << self
+      # Makes sure the lane name is valid
+      def verify_lane_name(name)
+        if self.black_list.include?(name.to_s)
+          UI.error("Lane name '#{name}' is invalid! Invalid names are #{self.black_list.join(', ')}.")
+          UI.user_error!("Lane name '#{name}' is invalid")
+        end
+
+        if self.gray_list.include?(name.to_sym)
+          UI.error("------------------------------------------------")
+          UI.error("Lane name '#{name}' should not be used because it is the name of a pantograph tool")
+          UI.error("It is recommended to not use '#{name}' as the name of your lane")
+          UI.error("------------------------------------------------")
+          # We still allow it, because we're nice
+          # Otherwise we might break existing setups
+          return
+        end
+
+        self.ensure_name_not_conflicts(name.to_s)
+      end
+
+      def black_list
+        %w(
+          run
+          init
+          new_action
+          lanes
+          list
+          docs
+          action
+          actions
+          enable_auto_complete
+          new_plugin
+          add_plugin
+          install_plugins
+          update_plugins
+          search_plugins
+          help
+          env
+          update_pantograph
+        )
+      end
+
+      def gray_list
+        Pantograph::TOOLS
+      end
+
+      def ensure_name_not_conflicts(name)
+        # First, check if there is a predefined method in the actions folder
+        return unless Actions.action_class_ref(name)
+        UI.error("------------------------------------------------")
+        UI.error("Name of the lane '#{name}' is already taken by the action named '#{name}'")
+        UI.error("------------------------------------------------")
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/lane_list.rb

@@ -0,0 +1,77 @@
+module Pantograph
+  class LaneList
+    # Print out the result of `generate`
+
+    def self.output(path)
+      puts(generate(path))
+
+      puts("Execute using `pantograph [lane_name]`".yellow)
+    end
+
+    def self.generate(path)
+      ff = Pantograph::PantFile.new(path)
+      lanes = ff.runner.lanes
+
+      output = ""
+
+      all_keys = lanes.keys.reject(&:nil?)
+      all_keys.unshift(nil) # because we want root elements on top. always! They have key nil
+
+      all_keys.each do |platform|
+        next if (lanes[platform] || []).count == 0
+
+        plat_text = platform
+        plat_text = "general" if platform.to_s.empty?
+        output += "\n--------- #{plat_text}---------\n".yellow
+
+        value = lanes[platform]
+        next unless value
+
+        value.each do |lane_name, lane|
+          next if lane.is_private
+
+          output += "----- pantograph #{lane.pretty_name}".green
+          if lane.description.count > 0
+            output += "\n" + lane.description.join("\n") + "\n\n"
+          else
+            output += "\n\n"
+          end
+        end
+      end
+
+      output
+    end
+
+    def self.output_json(path)
+      puts(JSON.pretty_generate(self.generate_json(path)))
+    end
+
+    # Returns a hash
+    def self.generate_json(path)
+      output = {}
+      return output if path.nil?
+      ff = Pantograph::PantFile.new(path)
+
+      all_keys = ff.runner.lanes.keys
+
+      all_keys.each do |platform|
+        next if (ff.runner.lanes[platform] || []).count == 0
+
+        output[platform] ||= {}
+
+        value = ff.runner.lanes[platform]
+        next unless value
+
+        value.each do |lane_name, lane|
+          next if lane.is_private
+
+          output[platform][lane_name] = {
+            description: lane.description.join("\n")
+          }
+        end
+      end
+
+      return output
+    end
+  end
+end