dpl-bintray 1.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cddd0cf19cca0575252a19a50cf88d599ce64bc9
+  data.tar.gz: a03313e0b25aa0715180d224eef2fbf3cc9b4ff5
+SHA512:
+  metadata.gz: a25a34024925c0484230428d56da872443b826dcf2209f18448b9d7120c9034e10d7a348b0571272750e05c2a8eb396f0e6fc6d7cf88d4359b04427dd8f8a39b
+  data.tar.gz: '085787918de2cbdd435b3646dd9a76e0d6a4cb8544c9727a68e4afbc398b01f14659702f076d6cd570133dba5509de996b69cf6521dfce54fae2654822f34c2f'

data/dpl-bintray.gemspec

@@ -0,0 +1,3 @@
+require './gemspec_helper'
+
+gemspec_for 'bintray'

data/lib/dpl/provider/bintray.rb

@@ -0,0 +1,501 @@
+require 'json'
+require 'net/http'
+require "uri"
+require 'find'
+
+module DPL
+  class Provider
+    class Bintray < Provider
+      def check_auth
+        @user = option(:user)
+        @key = option(:key)
+        @url = option(:url)
+      end
+
+      def needs_key?
+        false
+      end
+
+      attr_accessor :test_mode
+      attr_reader :user
+      attr_reader :key
+      attr_reader :file
+      attr_reader :passphrase
+      attr_reader :url
+      attr_reader :dry_run
+      attr_reader :descriptor
+
+      def initialize(*args)
+        super(*args)
+        @test_mode = false
+
+        @file = options[:file]
+        @passphrase = options[:passphrase]
+        @dry_run = options[:dry_run]
+
+        if @url.nil?
+          @url = 'https://api.bintray.com'
+        end
+        if @dry_run.nil?
+          @dry_run = false
+        end
+      end
+
+      def read_descriptor
+        log "Reading descriptor file: #{file}"
+        @descriptor = JSON.parse(File.read(file))
+      end
+
+      def descriptor=(json)
+        @descriptor = JSON.parse(json)
+      end
+
+      def head_request(path)
+        url = URI.parse(self.url)
+        req = Net::HTTP::Head.new(path)
+        req.basic_auth user, key
+
+        sock = Net::HTTP.new(url.host, url.port)
+        sock.use_ssl = true
+        res = sock.start {|http| http.request(req) }
+
+        return res
+      end
+
+      def post_request(path, body)
+        req = Net::HTTP::Post.new(path)
+        req.add_field('Content-Type', 'application/json')
+        req.basic_auth user, key
+        if !body.nil?
+          req.body = body.to_json
+        end
+
+        url = URI.parse(self.url)
+        sock = Net::HTTP.new(url.host, url.port)
+        sock.use_ssl = true
+        res = sock.start {|http| http.request(req) }
+        return res
+      end
+
+      def put_file_request(local_file_path, upload_path, matrix_params)
+        url = URI.parse(self.url)
+
+        file = File.open(local_file_path, 'rb')
+        data = file.read()
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = true
+
+        params = ''
+        if !matrix_params.nil?
+          matrix_params.each do |key, val|
+            params << ";#{key}=#{val}"
+          end
+          upload_path << params
+        end
+
+        request = Net::HTTP::Put.new("#{upload_path}")
+        request.basic_auth user, key
+        request.body = data
+
+        return http.request(request)
+      end
+
+      def upload_file(artifact)
+        log "Uploading file '#{artifact.local_path}' to #{artifact.upload_path}"
+
+        if dry_run
+          return
+        end
+
+        package = descriptor["package"]
+        version = descriptor["version"]
+        package_name = package["name"]
+        subject = package["subject"]
+        repo = package["repo"]
+        version_name = version["name"]
+
+        path = "/content/#{subject}/#{repo}/#{package_name}/#{version_name}/#{artifact.upload_path}"
+        res = put_file_request(artifact.local_path, path, artifact.matrix_params)
+        log_bintray_response(res)
+      end
+
+      def package_exists_path
+        package = descriptor["package"]
+        subject = package["subject"]
+        name = package["name"]
+        repo = package["repo"]
+        return "/packages/#{subject}/#{repo}/#{name}"
+      end
+
+      def package_exists?
+        path = package_exists_path
+        if !dry_run
+          res = head_request(path)
+          code = res.code.to_i
+        else
+          code = 404
+        end
+
+        if code == 404
+          return false
+        end
+        if code == 201 || code == 200
+          return true
+        end
+        name = descriptor["package"]["name"]
+        abort("Unexpected HTTP response code #{code} returned from Bintray while checking if package '#{name}' exists. " +
+                  "Response message: #{res.message}")
+      end
+
+      def version_exists_path
+        package = descriptor["package"]
+        version = descriptor["version"]
+        package_name = package["name"]
+        subject = package["subject"]
+        repo = package["repo"]
+        version_name = version["name"]
+
+        return "/packages/#{subject}/#{repo}/#{package_name}/versions/#{version_name}"
+      end
+
+      def version_exists?
+        path = version_exists_path
+        if !dry_run
+          res = head_request(path)
+          code = res.code.to_i
+        else
+          code = 404
+        end
+
+        if code == 404
+          return false
+        end
+        if code == 201 || code == 200
+          return true
+        end
+        version_name = descriptor["version"]["name"]
+        abort("Unexpected HTTP response code #{code} returned from Bintray while checking if version '#{version_name}' exists. " +
+                  "Response message: #{res.message}")
+      end
+
+      def create_package
+        package = descriptor["package"]
+        repo = package["repo"]
+        body = {}
+
+        add_to_map(body, package, "name")
+        add_to_map(body, package, "desc")
+        add_to_map(body, package, "licenses")
+        add_to_map(body, package, "labels")
+        add_to_map(body, package, "vcs_url")
+        add_to_map(body, package, "website_url")
+        add_to_map(body, package, "issue_tracker_url")
+        add_to_map(body, package, "public_download_numbers")
+        add_to_map(body, package, "public_stats")
+
+        subject = package["subject"]
+        package_name = package["name"]
+        log "Creating package '#{package_name}'..."
+
+        path = "/packages/#{subject}/#{repo}"
+        if !dry_run
+          res = post_request(path, body)
+          log_bintray_response(res)
+          code = res.code.to_i
+        else
+          code = 200
+        end
+
+        if !test_mode
+          if code == 201 || code == 200
+            add_package_attributes
+          end
+        end
+        RequestDetails.new(path, body)
+      end
+
+      def add_package_attributes
+        package = descriptor["package"]
+        repo = package["repo"]
+        subject = package["subject"]
+        package_name = package["name"]
+        attributes = package["attributes"]
+        path = nil
+        if !attributes.nil?
+          log "Adding attributes for package '#{package_name}'..."
+          path = "/packages/#{subject}/#{repo}/#{package_name}/attributes"
+          if !dry_run
+            res = post_request(path, attributes)
+            log_bintray_response(res)
+          end
+        end
+        RequestDetails.new(path, attributes)
+      end
+
+      def create_version
+        package = descriptor["package"]
+        version = descriptor["version"]
+        repo = package["repo"]
+        body = {}
+
+        add_to_map(body, version, "name")
+        add_to_map(body, version, "desc")
+        add_to_map(body, version, "released")
+        add_to_map(body, version, "vcs_tag")
+        add_to_map(body, version, "github_release_notes_file")
+        add_to_map(body, version, "github_use_tag_release_notes")
+        add_to_map(body, version, "attributes")
+
+        package_name = package["name"]
+        subject = package["subject"]
+        version_name = version["name"]
+        log "Creating version '#{version_name}'..."
+
+        path = "/packages/#{subject}/#{repo}/#{package_name}/versions"
+        if !dry_run
+          res = post_request(path, body)
+          log_bintray_response(res)
+          code = res.code.to_i
+        else
+          code = 200
+        end
+
+        if !test_mode
+          if code == 201 || code == 200
+            add_version_attributes
+          end
+        end
+        RequestDetails.new(path, body)
+      end
+
+      def add_version_attributes
+        package = descriptor["package"]
+        package_name = package["name"]
+        subject = package["subject"]
+        version = descriptor["version"]
+        version_name = version["name"]
+        repo = package["repo"]
+        attributes = version["attributes"]
+        path = nil
+        if !attributes.nil?
+          log "Adding attributes for version '#{version_name}'..."
+          path = "/packages/#{subject}/#{repo}/#{package_name}/versions/#{version_name}/attributes"
+          if !dry_run
+            res = post_request(path, attributes)
+            log_bintray_response(res)
+          end
+        end
+        RequestDetails.new(path, attributes)
+      end
+
+      def check_and_create_package
+        if !package_exists?
+          create_package
+        end
+      end
+
+      def check_and_create_version
+        if !version_exists?
+          create_version
+        end
+      end
+
+      def upload_files
+        files = files_to_upload
+
+        files.each do |key, artifact|
+          upload_file(artifact)
+        end
+      end
+
+      def publish_version
+        publish = descriptor["publish"]
+        if publish
+          package = descriptor["package"]
+          version = descriptor["version"]
+          repo = package["repo"]
+          package_name = package["name"]
+          subject = package["subject"]
+          version_name = version["name"]
+
+          log "Publishing version '#{version_name}' of package '#{package_name}'..."
+          path = "/content/#{subject}/#{repo}/#{package_name}/#{version_name}/publish"
+          if !dry_run
+            res = post_request(path, nil)
+            log_bintray_response(res)
+          end
+        end
+        RequestDetails.new(path, nil)
+      end
+
+      def gpg_sign_version
+        version = descriptor["version"]
+        gpg_sign = version["gpgSign"]
+        if gpg_sign
+          package = descriptor["package"]
+          repo = package["repo"]
+          package_name = package["name"]
+          subject = package["subject"]
+          version_name = version["name"]
+
+          body = nil
+          if !passphrase.nil?
+            log "Signing version with no passphrase..."
+            body = {}
+            body["passphrase"] = passphrase
+          else
+            log "Signing version with passphrase..."
+          end
+
+          path = "/gpg/#{subject}/#{repo}/#{package_name}/versions/#{version_name}"
+          if !dry_run
+            res = post_request(path, body)
+            log_bintray_response(res)
+          end
+          RequestDetails.new(path, body)
+        end
+      end
+
+      # Get the root path from which to start collecting files to be
+      # uploaded to Bintray.
+      def root_path(str)
+        index = str.index('(')
+        path = nil
+        if index.nil? || str.start_with?('(')
+          path = str
+        else
+          path = str[0, index]
+        end
+
+        if !test_mode && !File.exist?(path)
+          log "Warning: Path: #{path} does not exist."
+          return nil
+        end
+        return path
+      end
+
+      # Fills a map with Artifact objects which match
+      # the include pattern and do not match the exclude pattern.
+      # The artifacts are files collected from the file system.
+      def fill_files_map(map, include_pattern, exclude_pattern, upload_pattern, matrix_params)
+        # Get the root path from which to start collecting the files.
+        root_path = root_path(include_pattern)
+        if root_path.nil?
+          return
+        end
+
+        # Start scanning the root path recursively.
+        Find.find(root_path) do |path|
+          add_if_matches(map, path, include_pattern, exclude_pattern, upload_pattern, matrix_params)
+        end
+      end
+
+      def add_if_matches(map, path, include_pattern, exclude_pattern, upload_pattern, matrix_params)
+        res = path.match(/#{include_pattern}/)
+
+        # If the file matches the include pattern and it is not a directory.
+        # In case test_mode is set, we do not check if the file exists.
+        if !res.nil? && (test_mode || File.file?(path))
+          # If the file does not match the exclude pattern.
+          if exclude_pattern.nil? || exclude_pattern.empty? || !path.match(/#{exclude_pattern}/)
+            # Using the capturing groups in the include pattern, replace the $1, $2, ...
+            # in the upload pattern.
+            groups = res.captures
+            replaced_upload_pattern = upload_pattern
+            for i in 0..groups.size-1
+              replaced_upload_pattern = replaced_upload_pattern.gsub("$#{i+1}", groups[i])
+            end
+            map[path] = Artifact.new(path, replaced_upload_pattern, matrix_params)
+          end
+        end
+      end
+
+      # Returns a map containing Artifact objects.
+      # The map contains the files to be uploaded to Bintray.
+      def files_to_upload
+        upload_files = Hash.new()
+        files = descriptor["files"]
+        if files.nil?
+          return upload_files
+        end
+
+        files.each { |patterns|
+          fill_files_map(
+              upload_files,
+              patterns["includePattern"],
+              patterns["excludePattern"],
+              patterns["uploadPattern"],
+              patterns["matrixParams"])
+        }
+
+        return upload_files
+      end
+
+      def deploy
+        read_descriptor
+        check_and_create_package
+        check_and_create_version
+        upload_files
+        gpg_sign_version
+        publish_version
+      end
+
+      # Copies a key from one map to another, if the key exists there.
+      def add_to_map(to_map, from_map, key)
+        if !from_map[key].nil?
+          to_map[key] = from_map[key]
+        end
+      end
+
+      def log_bintray_response(res)
+        msg = ''
+        if !res.body.nil?
+          begin
+            response = JSON.parse(res.body)
+            msg = response["message"]
+          rescue
+          end
+        end
+
+        log "Bintray response: #{res.code.to_i} #{res.message}. #{msg}"
+      end
+
+      def log(msg)
+        puts "[Bintray Upload] #{msg}"
+      end
+
+      # This class represents an artifact (file) to be uploaded to Bintray.
+      class Artifact
+        def initialize(local_path, upload_path, matrix_params)
+          @local_path = local_path
+          @upload_path = upload_path
+          @matrix_params = matrix_params
+        end
+
+        def hash
+          return @localPath.hash
+        end
+
+        def eql?(other)
+          @localPath == other.local_path
+        end
+
+        attr_reader :local_path
+        attr_reader :upload_path
+        attr_reader :matrix_params
+      end
+
+      # Used to return the path and body of REST requests sent to Bintray.
+      # Used for testing.
+      class RequestDetails
+        def initialize(path, body)
+          @path = path
+          @body = body
+        end
+
+        attr_reader :path
+        attr_reader :body
+      end
+    end
+  end
+end

data/spec/provider/bintray_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+require 'dpl/provider/bintray'
+
+describe DPL::Provider::Bintray do
+
+  subject :provider do
+    described_class.new(DummyContext.new,
+                        :user => 'user',
+                        :key => 'key',
+                        :file => 'file',
+                        :dry_run => 'true')
+  end
+
+  subject :provider_with_passphrase do
+    described_class.new(DummyContext.new,
+                        :user => 'user',
+                        :key => 'key',
+                        :file => 'file',
+                        :dry_run => 'true',
+                        :passphrase => 'passphrase')
+  end
+
+  describe "package_exists?" do
+    example do
+      descriptor = JSON.parse(descriptor_content)
+      package = descriptor["package"]
+      package_name = package["name"]
+      subject = package["subject"]
+      repo = package["repo"]
+
+      init_provider(provider)
+      expect(provider.package_exists_path).to eq("/packages/#{subject}/#{repo}/#{package_name}")
+    end
+  end
+
+  describe "version_exists?" do
+    example do
+      descriptor = JSON.parse(descriptor_content)
+      package = descriptor["package"]
+      package_name = package["name"]
+      subject = package["subject"]
+      repo = package["repo"]
+      version_name = descriptor["version"]["name"]
+
+      init_provider(provider)
+      expect(provider.version_exists_path).to eq("/packages/#{subject}/#{repo}/#{package_name}/versions/#{version_name}")
+    end
+  end
+
+  describe "create_package" do
+    example do
+      descriptor = JSON.parse(descriptor_content)
+      package = descriptor["package"]
+      subject = package["subject"]
+      repo = package["repo"]
+
+      init_provider(provider)
+      request_details = provider.create_package
+      expect(request_details.path).to eq("/packages/#{subject}/#{repo}")
+
+      body = {
+          'name' => package["name"],
+          'desc' => package["desc"],
+          'licenses' => package["licenses"],
+          'labels' => package["labels"],
+          'vcs_url' => package["vcs_url"],
+          'website_url' => package["website_url"],
+          'issue_tracker_url' => package["issue_tracker_url"],
+          'public_download_numbers' => package["public_download_numbers"],
+          'public_stats' => package["public_stats"]
+      }
+      expect(request_details.body).to eq(body)
+    end
+  end
+
+  describe "create_version" do
+    example do
+      descriptor = JSON.parse(descriptor_content)
+      package = descriptor["package"]
+      package_name = package["name"]
+      subject = package["subject"]
+      repo = package["repo"]
+
+      init_provider(provider)
+      request_details = provider.create_version
+      expect(request_details.path).to eq("/packages/#{subject}/#{repo}/#{package_name}/versions")
+
+      version = descriptor["version"]
+      body = {
+          'name' => version["name"],
+          'desc' => version["desc"],
+          'released' => version["released"],
+          'vcs_tag' => version["vcs_tag"],
+          'attributes' => version["attributes"]
+      }
+      expect(request_details.body).to eq(body)
+    end
+  end
+
+  describe "add_package_attributes" do
+    example do
+      descriptor = JSON.parse(descriptor_content)
+      package = descriptor["package"]
+      package_name = package["name"]
+      subject = package["subject"]
+      repo = package["repo"]
+
+      init_provider(provider)
+      request_details = provider.add_package_attributes
+      expect(request_details.path).to eq("/packages/#{subject}/#{repo}/#{package_name}/attributes")
+
+      body = package["attributes"]
+      expect(request_details.body).to eq(body)
+    end
+  end
+
+  describe "add_version_attributes" do
+    example do
+      descriptor = JSON.parse(descriptor_content)
+      package = descriptor["package"]
+      package_name = package["name"]
+      subject = package["subject"]
+      repo = package["repo"]
+      version_name = descriptor["version"]["name"]
+
+      init_provider(provider)
+      request_details = provider.add_version_attributes
+      expect(request_details.path).to eq("/packages/#{subject}/#{repo}/#{package_name}/versions/#{version_name}/attributes")
+
+      descriptor = JSON.parse(descriptor_content)
+      version = descriptor["version"]
+      body = version["attributes"]
+      expect(request_details.body).to eq(body)
+    end
+  end
+
+  describe "publish_version" do
+    example do
+      descriptor = JSON.parse(descriptor_content)
+      package = descriptor["package"]
+      package_name = package["name"]
+      subject = package["subject"]
+      repo = package["repo"]
+      version_name = descriptor["version"]["name"]
+
+      init_provider(provider)
+      request_details = provider.publish_version
+      expect(request_details.path).to eq("/content/#{subject}/#{repo}/#{package_name}/#{version_name}/publish")
+    end
+  end
+
+  describe "gpg_sign_version_without_passphrase" do
+    example do
+      descriptor = JSON.parse(descriptor_content)
+      package = descriptor["package"]
+      package_name = package["name"]
+      subject = package["subject"]
+      repo = package["repo"]
+      version_name = descriptor["version"]["name"]
+
+      init_provider(provider)
+      request_details = provider.gpg_sign_version
+      expect(request_details.path).to eq("/gpg/#{subject}/#{repo}/#{package_name}/versions/#{version_name}")
+      expect(request_details.body).to eq(nil)
+    end
+  end
+
+  describe "gpg_sign_version_with_passphrase" do
+    example do
+      descriptor = JSON.parse(descriptor_content)
+      package = descriptor["package"]
+      package_name = package["name"]
+      subject = package["subject"]
+      repo = package["repo"]
+      version_name = descriptor["version"]["name"]
+
+      init_provider(provider_with_passphrase)
+      request_details = provider_with_passphrase.gpg_sign_version
+      expect(request_details.path).to eq("/gpg/#{subject}/#{repo}/#{package_name}/versions/#{version_name}")
+
+      body = {
+          'passphrase' => 'passphrase'
+      }
+      expect(request_details.body).to eq(body)
+    end
+  end
+
+  describe "upload_files" do
+    example do
+      init_provider(provider)
+      files_to_upload = Hash.new()
+      matrix_params = {
+          'p1' => 'a',
+          'p2' => 'b'
+      }
+
+      provider.add_if_matches(files_to_upload, 'build/files/a.gem', 'build/files/(.*.gem)', 'exclude', 'a/b/$1', nil)
+      provider.add_if_matches(files_to_upload, 'build/files/b.gem', 'build/files/(.*.gem)', nil, 'a/b/$1', matrix_params)
+      provider.add_if_matches(files_to_upload, 'build/files/c.gem', 'build/files/(.*.gem)', '.*files.*', 'a/b/$1', nil)
+      provider.add_if_matches(files_to_upload, 'build/files/c.txt', 'build/files/(.*.gem)', 'exclude', 'a/b/$1', nil)
+
+      expect(files_to_upload["build/files/a.gem"]).not_to eq(nil)
+      expect(files_to_upload["build/files/a.gem"].upload_path).to eq('a/b/a.gem')
+      expect(files_to_upload["build/files/a.gem"].matrix_params).to eq(nil)
+
+      expect(files_to_upload["build/files/b.gem"]).not_to eq(nil)
+      expect(files_to_upload["build/files/b.gem"].upload_path).to eq('a/b/b.gem')
+      expect(files_to_upload["build/files/b.gem"].matrix_params).to eq(matrix_params)
+
+      expect(files_to_upload["build/files/c.gem"]).to eq(nil)
+      expect(files_to_upload["build/files/c.txt"]).to eq(nil)
+    end
+  end
+
+  def init_provider(bintray)
+    bintray.descriptor=descriptor_content
+    bintray.test_mode = true
+  end
+
+  def descriptor_content
+    return """ {
+          \"package\": {
+            \"name\": \"auto-upload\",
+            \"repo\": \"myRepo\",
+            \"subject\": \"myBintrayUser\",
+            \"desc\": \"I was pushed completely automatically\",
+            \"website_url\": \"www.jfrog.com\",
+            \"issue_tracker_url\": \"https://github.com/bintray/bintray-client-java/issues\",
+            \"vcs_url\": \"https://github.com/bintray/bintray-client-java.git\",
+            \"github_use_tag_release_notes\": true,
+            \"github_release_notes_file\": \"RELEASE.txt\",
+            \"licenses\": [\"MIT\"],
+            \"labels\": [\"cool\", \"awesome\", \"gorilla\"],
+            \"public_download_numbers\": false,
+            \"public_stats\": false,
+            \"attributes\": [{\"name\": \"att1\", \"values\" : [\"val1\"], \"type\": \"string\"},
+                       {\"name\": \"att2\", \"values\" : [1, 2.2, 4], \"type\": \"number\"},
+                       {\"name\": \"att5\", \"values\" : [\"2014-12-28T19:43:37+0100\"], \"type\": \"date\"}]
+          },
+          \"version\": {
+            \"name\": \"0.5\",
+            \"desc\": \"This is a version\",
+            \"released\": \"2015-01-04\",
+            \"vcs_tag\": \"0.5\",
+            \"attributes\": [{\"name\": \"VerAtt1\", \"values\" : [\"VerVal1\"], \"type\": \"string\"},
+                       {\"name\": \"VerAtt2\", \"values\" : [1, 3.3, 5], \"type\": \"number\"},
+                     {\"name\": \"VerAtt3\", \"values\" : [\"2015-01-01T19:43:37+0100\"], \"type\": \"date\"}],
+            \"gpgSign\": true
+          },
+          \"files\":
+            [
+            {\"includePattern\": \"build/bin/(*.gem)\", \"excludePattern\": \".*/do-not-deploy/.*\", \"uploadPattern\": \"gems/$1\"},
+            {\"includePattern\": \"build/docs/(.*)\", \"uploadPattern\": \"docs/$1\"}
+            ],
+          \"publish\": true
+        }
+        """
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: dpl-bintray
+version: !ruby/object:Gem::Version
+  version: 1.9.0
+platform: ruby
+authors:
+- Konstantin Haase
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dpl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json_pure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tins
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: deploy tool abstraction for clients
+email: konstantin.mailinglists@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- dpl-bintray.gemspec
+- lib/dpl/provider/bintray.rb
+- spec/provider/bintray_spec.rb
+homepage: https://github.com/travis-ci/dpl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: deploy tool
+test_files:
+- spec/provider/bintray_spec.rb