dpl 1.10.17.travis.6637.6 → 2.0.0.alpha.1

data/lib/dpl/ctx/test.rb

@@ -0,0 +1,242 @@
+require 'cl'
+require 'stringio'
+require 'dpl/helper/squiggle'
+
+module Dpl
+  module Ctx
+    class Test < Cl::Ctx
+      include Squiggle
+
+      attr_reader :cmds, :stdout, :stderr, :last_out, :last_err
+
+      def initialize
+        @cmds = []
+        @stderr = StringIO.new
+        @stdout = {}
+        super('dpl')
+      end
+
+      def fold(name)
+        cmds << "[fold] #{name}"
+        yield.tap { cmds << "[unfold] #{name}" }
+      end
+
+      def validate_runtimes(runtimes)
+        runtimes.each do |name, requirements|
+          cmds << "[validate:runtime] #{name} (#{requirements.join(', ')})"
+        end
+      end
+
+      def apts_get(apts)
+        apts.each { |apt| apt_get(*apt) }
+      end
+
+      def apt_get(name, cmd = name)
+        cmds << "[apt:get] #{name} (#{cmd})"
+      end
+
+      def gems_require(gems)
+        gems.each { |gem| gem_require(gem) }
+      end
+
+      def gem_require(name, version = nil, opts = {})
+        cmds << "[gem:require] #{name} (#{version}, #{opts})"
+      end
+
+      def npm_install(name, cmd = name)
+        cmds << "[npm:install] #{name} (#{cmd})"
+      end
+
+      def pip_install(name, cmd = name, version = nil)
+        cmds << "[pip:install] #{name} (#{cmd}, #{version})"
+      end
+
+      def ssh_keygen(name, file)
+        File.open(file, 'w+') { |f| f.write('private-key') }
+        File.open("#{file}.pub", 'w+') { |f| f.write('ssh-rsa public-key') }
+      end
+
+      def shell(cmd, opts = {})
+        info cmd.msg if cmd.msg?
+        info cmd.echo if cmd.echo?
+        cmds << cmd.cmd
+        return true unless cmd.capture?
+        stdout[cmd.key] || 'captured_stdout'
+      end
+
+      def success?
+        true
+      end
+
+      def info(msg)
+        cmds << "[info] #{msg}"
+      end
+
+      def print(chars)
+        cmds << "[print] #{chars}"
+      end
+
+      def warn(msg)
+        cmds << "[warn] #{msg}"
+      end
+
+      def error(message)
+        raise Error, message
+      end
+
+      def deprecate_opt(key, msg)
+        msg = "please use #{msg}" if msg.is_a?(Symbol)
+        warn("deprecated option #{key} (#{msg})")
+      end
+
+      def repo_name
+        'dpl'
+      end
+
+      def repo_slug
+        'travis-ci/dpl'
+      end
+
+      def build_dir
+        '.'
+      end
+
+      def build_number
+        1
+      end
+
+      def git_commit_msg
+        'commit msg'
+      end
+
+      def git_author_name
+        'author name'
+      end
+
+      def git_author_email
+        'author email'
+      end
+
+      def git_dirty?
+        true
+      end
+
+      def git_log(args)
+        'commits'
+      end
+
+      def git_ls_files
+        %w(one two)
+      end
+
+      def git_ls_remote?(url, ref)
+        true
+      end
+
+      def git_remote_urls
+        ['git://origin.git']
+      end
+
+      def git_rev_parse(ref)
+        "ref: #{ref}"
+      end
+
+      def git_tag
+        'tag'
+      end
+
+      def git_sha
+        'sha'
+      end
+
+      def machine_name
+        'machine_name'
+      end
+
+      def node_version
+        '11.0.0'
+      end
+
+      def npm_version
+        '1'
+      end
+
+      def which(cmd)
+        false
+      end
+
+      def tmp_dir
+        FileUtils.mkdir_p('tmp')
+        'tmp'
+      end
+
+      def sleep(*)
+      end
+
+      def encoding(path)
+        'text'
+      end
+
+      def logger(level = :info)
+        logger = Logger.new(stderr)
+        logger.level = Logger.const_get(level.to_s.upcase)
+        logger
+      end
+
+      def test?
+        true
+      end
+
+      def file_size(path)
+        File.size(path.sub("#{File.expand_path('~')}", './home'))
+      end
+
+      def move_files(paths)
+        paths.each do |path|
+          mv(path, "/tmp/#{File.basename(path)}")
+        end
+      end
+
+      def unmove_files(paths)
+        paths.each do |path|
+          mv("/tmp/#{File.basename(path)}", path)
+        end
+      end
+
+      def mv(src, dest)
+        cmds << [:mv, src, dest].join(' ')
+      end
+
+      def rm_rf(path)
+        cmds << [:rm_rf, path].join(' ')
+      end
+
+      def chmod(perm, path)
+        cmds << [:chmod, perm, path].join(' ')
+      end
+
+      def write_file(path, content, chmod = nil)
+        path = File.expand_path(path)
+        path = path.sub("#{File.expand_path('~')}", './home')
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, 'w+') { |f| f.write(content) }
+      end
+
+      def write_netrc(machine, login, password)
+        write_file('~/.netrc', sq(<<-rc))
+          machine #{machine}
+            login #{login}
+            password #{password}
+        rc
+      end
+
+      def tty?
+        false
+      end
+
+      def except(hash, *keys)
+        hash.reject { |key, _| keys.include?(key) }
+      end
+    end
+  end
+end

data/lib/dpl/helper/assets.rb

@@ -0,0 +1,36 @@
+require 'fileutils'
+
+module Dpl
+  module Assets
+    class Asset < Struct.new(:provider, :namespace, :name)
+      include FileUtils
+
+      DIR = File.expand_path('../../assets', __FILE__)
+
+      def copy(target)
+        cp path, File.expand_path(target)
+      end
+
+      def read
+        exists? ? provider.interpolate(File.read(path)) : unknown
+      end
+
+      def exists?
+        File.exists?(path)
+      end
+
+      def unknown
+        raise "Could not find asset #{path}"
+      end
+
+      def path
+        "#{DIR}/#{namespace}/#{name}"
+      end
+    end
+
+    def asset(*args)
+      name, namespace = args.reverse
+      Asset.new(self, namespace || registry_key, name)
+    end
+  end
+end

data/lib/dpl/helper/cmd.rb

@@ -0,0 +1,167 @@
+module Dpl
+  # Represents a shell command
+  class Cmd < Struct.new(:provider, :key, :opts)
+    # Returns the shell command string
+    #
+    # If a Symbol was passed as a command then the command will be looked
+    # up from the provider class' `cmds` declaration.
+    #
+    # The command will be interpolated, and can include secrets. See
+    # `Dpl::Interpolate` for details on interpolating variables.
+    #
+    # If the option `silence` was passed then stdout and stderr will be
+    # redirected to `/dev/null`.
+    #
+    # If the option `python` was passed then the virtualenv with the given
+    # Python version will be activated before executing the command.
+    def cmd(secure = true)
+      cmd = lookup(:cmd, key) || missing(:cmd, key)
+      cmd = interpolate(cmd, opts, secure: secure).strip
+      cmd = silence(cmd) if silence?
+      cmd = python(cmd) if python?
+      cmd
+    end
+
+    # Returns a log message version of the command string
+    #
+    # This is the same as #cmd, except that included secrets will be
+    # obfuscated, and a prompt (dollar and space) will be prepended. See
+    # `Dpl::Interpolate` for details on interpolating variables.
+    def echo
+      "$ #{cmd(false)}"
+    end
+
+    # Returns the log message for announcing a command
+    #
+    # If the option `msg` was given as a String then it will be used. If the
+    # option `msg` was given as a Symbol then it will be looked up from the
+    # provider class' `msgs` declaration.
+    #
+    # The message string will be interpolated, but included secrets will be
+    # obfuscated. See `Dpl::Interpolate` for details on interpolating
+    # variables.
+    def msg
+      msg = lookup(:msg, opts[:msg], key.is_a?(Symbol) ? key : nil)
+      msg || missing(:msg, opts[:msg], key)
+      msg = interpolate(msg, opts, secure: false).strip
+      msg
+    end
+
+    def msg?
+      !!lookup(:msg, opts[:msg], key.is_a?(Symbol) ? key : nil)
+    end
+
+    # Returns the log message for a failed command
+    #
+    # The message string will be interpolated, but included secrets will be
+    # obfuscated. See `Dpl::Interpolate` for details on interpolating
+    # variables.
+    #
+    # If the option `assert` was given as a String then it will be used. If the
+    # option `assert` was given as a Symbol then it will be looked up from the
+    # provider class' `errs` declaration. If the command was given as a Symbol,
+    # and it can be found in `errs` then this String will be used.
+    def error
+      keys = [opts[:assert], key]
+      err = lookup(:err, *keys)
+      err ? interpolate(err, opts).strip : 'Failed'
+    end
+
+    # Whether or not to assert that the command has exited with 0
+    #
+    # Returns `true` if the option `assert` was given as `true` or not given at
+    # all. Returns `false` if the option `assert` was given as `false`.
+    def assert?
+      !opts[:assert].is_a?(FalseClass)
+    end
+
+    # Whether or not to announce the command with an info level log message
+    #
+    # Returns `true` if the option `assert` was given as `true` or not given at
+    # all. Returns `false` if the option `assert` was given as `false`.
+    def echo?
+      !opts[:echo].is_a?(FalseClass)
+    end
+
+    # Whether or not to capture the commands stdout and stderr
+    #
+    # Returns `true` if the option `capture` was given as `true`. Returns
+    # `false` if the option `capture` was given as `false` or not given.
+    def capture?
+      !!opts[:capture]
+    end
+
+    # Whether or not to output a log message before the command is run
+    #
+    # Returns `true` if the option `info` was given. Returns `false` if the
+    # option `info` was given as `false` or not given.
+    def info?
+      !!opts[:info]
+    end
+
+    # Returns the log message to output after the command has succeeded
+    def info
+      opts[:info]
+    end
+
+    # Whether or not to output a log message after the command has succeeded
+    #
+    # Returns `true` if the option `success` was given. Returns `false` if the
+    # option `success` was given as `false` or not given.
+    def success?
+      !!opts[:success]
+    end
+
+    # Returns the log message to output after the command has succeeded
+    def success
+      opts[:success]
+    end
+
+    # Whether or not to activate a Python virtualenv before executing the
+    # command
+    #
+    # Returns `true` if the option `python` was given. Returns `false` if the
+    # option `python` was given as `false` or not given.
+    def python?
+      !!opts[:python]
+    end
+
+    # Returns how often to retry the command
+    def retry
+      opts[:retry]
+    end
+
+    # Whether or not to redirect the command's stdout and stderr to `/dev/null`
+    #
+    # Returns `true` if the option `silence` was given. Returns `false` if the
+    # option `silence` was given as `false` or not given.
+    def silence?
+      !!opts[:silence]
+    end
+
+    private
+
+      def lookup(type, *keys)
+        str = provider.send(type, *keys) if provider
+        str || keys.detect { |key| key.is_a?(String) }
+      end
+
+      def missing(type, *keys)
+        raise("Could not find #{type}: #{keys.compact.map(&:inspect).join(', ')}")
+      end
+
+      def interpolate(str, args, opts = {})
+        provider ? provider.interpolate(str, args, opts) : str
+      end
+
+      def silence(str)
+        "#{str} > /dev/null 2>&1"
+      end
+
+      # Activates the Python virtualenv for the given Python version.
+      def python(cmd)
+        # "bash -c 'source $HOME/virtualenv/python#{opts[:python]}/bin/activate; #{cmd.gsub(/'/, "'\\\\''")}'"
+        "source $HOME/virtualenv/python#{opts[:python]}/bin/activate && #{cmd}"
+      end
+  end
+end

data/lib/dpl/helper/config_file.rb

@@ -0,0 +1,47 @@
+module Dpl
+  module ConfigFile
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # should this sit in Cl?
+    module ClassMethods
+      attr_reader :config_files
+
+      def config(*paths)
+        if paths.any?
+          @config_files = paths
+        elsif config_files
+          paths = config_files.dup
+          opts = paths.last.is_a?(Hash) ? paths.pop : {}
+          conf = ConfigFiles.new(paths, opts).config
+          known = self.opts.map(&:name).map(&:to_sym)
+          conf.select { |key, _| known.include?(key) }
+        else
+          {}
+        end
+      end
+    end
+
+    class ConfigFiles < Struct.new(:paths, :opts)
+      def config
+        paths.map { |path| parse(path) }.inject(&:merge) || {}
+      end
+
+      def parse(path)
+        str = File.exists?(path) ? File.read(path) : ''
+        opts = str.lines.select { |line| line.include?('=') }.map(&:strip)
+        opts = opts.map { |pair| pair.split('=', 2) }.to_h
+        opts.map { |key, value| [strip_prefix(key).to_sym, value] }.to_h
+      end
+
+      def strip_prefix(str)
+        opts[:prefix] ? str.sub(/^#{opts[:prefix]}[\-_]?/, '') : str
+      end
+    end
+
+    def opts
+      @opts ||= self.class.config.merge(super)
+    end
+  end
+end