dpl 1.8.48.travis.2486.5 → 1.9.0

data/lib/dpl/provider/pages.rb

@@ -1,212 +0,0 @@
-module DPL
-  class Provider
-    class Pages < Provider
-      """Implements Github Pages deployment
-
-      Options:
-        - repo [optional, for pushed to other repos]
-        - github-token [required]
-        - github-url [optional, defaults to github.com]
-        - target-branch [optional, defaults to gh-pages]
-        - keep-history [optional, defaults to false]
-        - allow-empty-commit [optional, defaults to false]
-        - committer-from-gh [optional, defaults to false]
-        - verbose [optional, defaults to false]
-        - local-dir [optional, defaults to `pwd`]
-        - fqdn [optional]
-        - project-name [optional, defaults to fqdn or repo slug]
-        - email [optional, defaults to deploy@travis-ci.org]
-        - name [optional, defaults to Deployment Bot]
-        - deployment-file [optional, defaults to false]
-      """
-
-      require 'tmpdir'
-
-      if RUBY_VERSION >= "2.0.0"
-        requires 'octokit', version: '~> 4.6.2'
-      else
-        requires 'octokit', version: '~> 4.3.0'
-      end
-
-      experimental 'GitHub Pages'
-
-      def initialize(context, options)
-        super
-
-        @build_dir = File.join(src_dir, options[:local_dir] || '.')
-        print_step "The target dir for deployment is '#{@build_dir}'."
-
-        @project_name = options[:project_name] || fqdn || slug
-        @target_branch = options[:target_branch] || 'gh-pages'
-
-        @gh_fqdn = fqdn
-        @gh_url = options[:github_url] || 'github.com'
-        @gh_token = option(:github_token)
-        @keep_history = !!keep_history
-        @allow_empty_commit = !!allow_empty_commit
-        @committer_from_gh = !!committer_from_gh
-        @verbose = !!verbose
-
-        @gh_email = options[:email] || 'deploy@travis-ci.org'
-        @gh_name = "#{options[:name] || 'Deployment Bot'} (from Travis CI)"
-
-        @deployment_file = !!options[:deployment_file]
-
-        @gh_ref = "#{@gh_url}/#{slug}.git"
-        @gh_remote_url = "https://#{@gh_token}@#{@gh_ref}"
-        @git_push_opts = @keep_history ? '' : ' --force'
-        @git_commit_opts = (@allow_empty_commit and @keep_history) ? ' --allow-empty' : ''
-
-        print_step "The repo is configured to use committer user and email." if @committer_from_gh
-      end
-
-      def fqdn
-        options.fetch(:fqdn) { nil }
-      end
-
-      def slug
-        options.fetch(:repo) { context.env['TRAVIS_REPO_SLUG'] }
-      end
-
-      def src_dir
-        context.env['TRAVIS_BUILD_DIR'] or Dir.pwd
-      end
-
-      def keep_history
-        options.fetch(:keep_history, false)
-      end
-
-      def committer_from_gh
-        options.fetch(:committer_from_gh, false)
-      end
-
-      def allow_empty_commit
-        options.fetch(:allow_empty_commit, false)
-      end
-
-      def verbose
-        # Achtung! Never verbosify git, since it may expose user's token.
-        options.fetch(:verbose, false)
-      end
-
-      def api  # Borrowed from Releases provider
-        error 'gh-token must be provided for Pages provider to work.' unless @gh_token
-
-        return @api if @api
-
-        api_opts = { :access_token => @gh_token }
-        api_opts[:api_endpoint] = @gh_url == 'github.com' ? "https://api.github.com/" : "https://#{@gh_url}/api/v3/"
-
-        @api = Octokit::Client.new(api_opts)
-      end
-
-      def user
-        @user ||= api.user
-      end
-
-      def setup_auth
-        user.login
-      end
-
-      def check_auth
-        setup_auth
-
-        unless api.scopes.include? 'public_repo' or api.scopes.include? 'repo'
-          error "Dpl does not have permission to access #{@gh_url} using it. Make sure your token contains the repo or public_repo scope."
-        end
-
-        log "Logged in as @#{user.login} (#{user.name})"
-      rescue Octokit::Unauthorized => exc
-        error "gh-token is invalid. Details: #{exc}"
-      end
-
-      def needs_key?
-        false
-      end
-
-      def print_step(msg)
-        log msg if @verbose
-      end
-
-      def github_pull_or_init(target_dir)
-        unless @keep_history
-          github_init(target_dir)
-          return
-        end
-
-        print_step "Trying to clone a single branch #{@target_branch} from existing repo..."
-        unless context.shell "git clone --quiet --branch='#{@target_branch}' --depth=1 '#{@gh_remote_url}' '#{target_dir}' > /dev/null 2>&1"
-          # if such branch doesn't exist at remote, init it from scratch
-          print_step "Cloning #{@target_branch} branch failed"
-          Dir.mkdir(target_dir)  # Restore dir destroyed by failed `git clone`
-          github_init(target_dir)
-        end
-      end
-
-      def github_init(target_dir)
-        FileUtils.cd(target_dir, :verbose => true) do
-          print_step "Creating a brand new local repo from scratch in dir #{Dir.pwd}..."
-          context.shell "git init" or raise 'Could not create new git repo'
-          print_step 'Repo created successfully'
-          context.shell "git checkout --orphan '#{@target_branch}'" or raise 'Could not create an orphan git branch'
-          print_step "An orphan branch #{@target_branch} created successfully"
-        end
-      end
-
-      def identify_preferred_committer
-        if @committer_from_gh and @gh_token
-          return (user.name or @gh_name), (user.email or @gh_email)
-        end
-        return @gh_name, @gh_email
-      end
-
-      def github_configure
-        committer_name, committer_email = identify_preferred_committer
-        print_step "Configuring git committer to be #{committer_name} <#{committer_email}> (workdir: #{Dir.pwd})"
-        context.shell "git config user.email '#{committer_email}'"
-        context.shell "git config user.name '#{committer_name}'"
-      end
-
-      def github_commit
-        committer_name, _ = identify_preferred_committer
-        print_step "Preparing to deploy #{@target_branch} branch to gh-pages (workdir: #{Dir.pwd})"
-        context.shell "touch \"deployed at `date` by #{committer_name}\"" if @deployment_file
-        context.shell "echo '#{@gh_fqdn}' > CNAME" if @gh_fqdn
-        context.shell 'git add -A .'
-        context.shell "git commit#{@git_commit_opts} -qm 'Deploy #{@project_name} to #{@gh_ref}:#{@target_branch}'"
-        context.shell 'git show --stat-count=10 HEAD'
-      end
-
-      def github_deploy
-        print_step "Doing the git push (workdir: #{Dir.pwd})..."
-        unless context.shell "git push#{@git_push_opts} --quiet '#{@gh_remote_url}' '#{@target_branch}':'#{@target_branch}' > /dev/null 2>&1"
-          error "Couldn't push the build to #{@gh_ref}:#{@target_branch}"
-        end
-      end
-
-      def push_app
-        print_step "Starting deployment of #{@target_branch} branch to GitHub Pages..."
-        print_step "The deployment is configured to preserve the target branch if it exists on remote" if @keep_history
-        Dir.mktmpdir do |tmpdir|
-            workdir = "#{tmpdir}/work"
-            Dir.mkdir(workdir)
-            print_step "Created a temporary work directory #{workdir}"
-
-            github_pull_or_init(workdir)
-
-            FileUtils.cd(workdir, :verbose => true) do
-              print_step "Copying #{@build_dir} contents to #{workdir} (workdir: #{Dir.pwd})..."
-              context.shell "rsync -r --exclude .git --delete '#{@build_dir}/' '#{workdir}'" or error "Could not copy #{@build_dir}."
-
-              github_configure
-              github_commit
-              github_deploy
-              context.shell "git status" if @verbose
-            end
-        end
-        print_step "App has been pushed"
-      end
-
-    end
-  end
-end

data/lib/dpl/provider/puppet_forge.rb

@@ -1,43 +0,0 @@
-module DPL
-  class Provider
-    class PuppetForge < Provider
-      require 'pathname'
-
-      requires 'json_pure', :version => '< 2.0', :load => 'json/pure'
-      requires 'puppet', :load => 'puppet/face'
-      requires 'puppet-blacksmith', :load => 'puppet_blacksmith'
-
-      def modulefile
-        @modulefile ||= Blacksmith::Modulefile.new
-      end
-
-      def forge
-        @forge ||= Blacksmith::Forge.new(options[:user], options[:password], options[:url])
-      end
-
-      def build
-        pmod = Puppet::Face['module', :current]
-        pmod.build('./')
-      end
-
-      def needs_key?
-        false
-      end
-
-      def check_app
-        modulefile.metadata
-      end
-
-      def check_auth
-        raise Error, "must supply a user" unless option(:user)
-        raise Error, "must supply a password" unless option(:password)
-      end
-
-      def push_app
-        build
-        log "Uploading to Puppet Forge #{forge.username}/#{modulefile.name}"
-        forge.push!(modulefile.name)
-      end
-    end
-  end
-end

data/lib/dpl/provider/pypi.rb

@@ -1,103 +0,0 @@
-module DPL
-  class Provider
-    class PyPI < Provider
-      DEFAULT_SERVER = 'https://upload.pypi.org/legacy/'
-      PYPIRC_FILE = '~/.pypirc'
-
-      def pypi_user
-        option(:username, :user) || context.env['PYPI_USER'] || context.env['PYPI_USERNAME']
-      end
-
-      def pypi_password
-        options[:password] || context.env['PYPI_PASSWORD']
-      end
-
-      def pypi_server
-        options[:server] || context.env['PYPI_SERVER'] || DEFAULT_SERVER
-      end
-
-      def pypi_distributions
-        options[:distributions] || context.env['PYPI_DISTRIBUTIONS'] || 'sdist'
-      end
-
-      def pypi_docs_dir_option
-        docs_dir = options[:docs_dir] || context.env['PYPI_DOCS_DIR'] || ''
-        if !docs_dir.empty?
-          '--upload-dir ' + docs_dir
-        end
-      end
-
-      def skip_upload_docs?
-        ! options.has_key?(:skip_upload_docs) ||
-          (options.has_key?(:skip_upload_docs) && options[:skip_upload_docs])
-      end
-
-      def install_deploy_dependencies
-        unless context.shell "wget -O - https://bootstrap.pypa.io/get-pip.py | python - --no-setuptools --no-wheel && " \
-                             "pip install --upgrade setuptools twine wheel"
-          error "Couldn't install pip, setuptools, twine or wheel."
-        end
-      end
-
-      def config
-        {
-          :header => '[distutils]',
-          :servers_line => 'index-servers = pypi',
-          :servers => {
-            'pypi' => [
-                         "repository: #{pypi_server}",
-                         "username: #{pypi_user}",
-                         "password: #{pypi_password}",
-                      ]
-          }
-        }
-      end
-
-      def write_servers(f)
-        config[:servers].each do |key, val|
-          f.puts " " * 4 + key
-        end
-
-        config[:servers].each do |key, val|
-          f.puts "[#{key}]"
-          f.puts val
-        end
-      end
-
-      def write_config
-        File.open(File.expand_path(PYPIRC_FILE), 'w') do |f|
-          config.each do |key, val|
-            f.puts(val) if val.is_a? String or val.is_a? Array
-          end
-          write_servers(f)
-        end
-      end
-
-      def check_auth
-        error "missing PyPI username" unless pypi_user
-        error "missing PyPI password" unless pypi_password
-        write_config
-        log "Authenticated as #{pypi_user}"
-      end
-
-      def check_app
-      end
-
-      def needs_key?
-        false
-      end
-
-      def push_app
-        context.shell "python setup.py #{pypi_distributions}"
-        unless context.shell "twine upload -r pypi dist/*"
-          error 'PyPI upload failed.'
-        end
-        context.shell "rm -rf dist/*"
-        unless skip_upload_docs?
-          log "Uploading documentation (skip with \"skip_upload_docs: true\")"
-          context.shell "python setup.py upload_docs #{pypi_docs_dir_option} -r #{pypi_server}"
-        end
-      end
-    end
-  end
-end

data/lib/dpl/provider/releases.rb

@@ -1,139 +0,0 @@
-module DPL
-  class Provider
-    class Releases < Provider
-      require 'pathname'
-
-      if RUBY_VERSION >= "2.0.0"
-        requires 'octokit', version: '~> 4.6.2'
-      else
-        requires 'octokit', version: '~> 4.3.0'
-      end
-
-      requires 'mime-types', version: '~> 2.0'
-
-      def travis_tag
-        # Check if $TRAVIS_TAG is unset or set but empty
-        if context.env.fetch('TRAVIS_TAG','') == ''
-          nil
-        else
-          context.env['TRAVIS_TAG']
-        end
-      end
-
-      def get_tag
-        if travis_tag.nil?
-          @tag ||= `git describe --tags --exact-match 2>/dev/null`.chomp
-        else
-          @tag ||= travis_tag
-        end
-      end
-
-      def api
-        if options[:user] and options[:password]
-          @api ||= Octokit::Client.new(:login => options[:user], :password => options[:password])
-        else
-          @api ||= Octokit::Client.new(:access_token => option(:api_key))
-        end
-      end
-
-      def slug
-        options.fetch(:repo) { context.env['TRAVIS_REPO_SLUG'] }
-      end
-
-      def releases
-        @releases ||= api.releases(slug)
-      end
-
-      def user
-        @user ||= api.user
-      end
-
-      def files
-        if options[:file_glob]
-          Array(options[:file]).map do |glob|
-            Dir.glob(glob)
-          end.flatten
-        else
-          Array(options[:file])
-        end
-      end
-
-      def needs_key?
-        false
-      end
-
-      def check_app
-        log "Deploying to repo: #{slug}"
-
-        context.shell 'git fetch --tags' if travis_tag.nil?
-        log "Current tag is: #{get_tag}"
-      end
-
-      def setup_auth
-        user.login
-      end
-
-      def check_auth
-        setup_auth
-
-        unless api.scopes.include? 'public_repo' or api.scopes.include? 'repo'
-          raise Error, "Dpl does not have permission to upload assets. Make sure your token contains the repo or public_repo scope."
-        end
-
-        log "Logged in as #{user.name}"
-      end
-
-      def push_app
-        tag_matched = false
-        release_url = nil
-
-        if options[:release_number]
-          tag_matched = true
-          release_url = "https://api.github.com/repos/" + slug + "/releases/" + options[:release_number]
-        else
-          releases.each do |release|
-            if release.tag_name == get_tag
-              release_url = release.rels[:self].href
-              tag_matched = true
-            end
-          end
-        end
-
-        #If for some reason GitHub hasn't already created a release for the tag, create one
-        if tag_matched == false
-          release_url = api.create_release(slug, get_tag, options.merge({:draft => true})).rels[:self].href
-        end
-
-        files.each do |file|
-          existing_url = nil
-          filename = Pathname.new(file).basename.to_s
-          api.release(release_url).rels[:assets].get.data.each do |existing_file|
-            if existing_file.name == filename
-              existing_url = existing_file.url
-            end
-          end
-          if !existing_url
-            upload_file(file, filename, release_url)
-          elsif existing_url && options[:overwrite]
-            log "#{filename} already exists, overwriting."
-            api.delete_release_asset(existing_url)
-            upload_file(file, filename, release_url)
-          else
-            log "#{filename} already exists, skipping."
-          end
-        end
-
-        api.update_release(release_url, {:draft => false}.merge(options))
-      end
-
-      def upload_file(file, filename, release_url)
-        content_type = MIME::Types.type_for(file).first.to_s
-        if content_type.empty?
-          # Specify the default content type, as it is required by GitHub
-          content_type = "application/octet-stream"
-        end
-        api.upload_asset(release_url, file, {:name => filename, :content_type => content_type})
-      end
-    end
-  end
-end