artifactory_api 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 292f834fe01f7e90f6e0b8e2f0d67afab066f9fc
+  data.tar.gz: 492a47063e8101ad28a9218d234f198c1446dbb8
+SHA512:
+  metadata.gz: 2ada15a767456c235450b4e2b1109e6cbbe2d2173d64361dd2f598b2f9d28c45d2d0407bc8c7376021c4d43361400f638dfb10e3b049e641faee16e84c344e88
+  data.tar.gz: 65e54220c99d42e288141a5ba3722a85e6875e2269efa9120bb3ce9ac95e991150c1c795e4fbc05a4a617ba4dd259f08c4e6ce7e5aaabcc412d9b207d9f9d7cf

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+
+group :development,:test do
+  gem 'artifactory_api', :path => '../artifactory_api'
+  gem 'bundler', '~> 1.8.0'
+  gem 'rake', '~> 10.1.0'
+  gem 'rubygems-tasks', '~> 0.2'
+  gem "rspec"
+  gem "builder"
+end

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: ../artifactory_api
+  specs:
+    artifactory_api (0.1.4)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.2.2)
+    diff-lcs (1.2.5)
+    rake (10.1.1)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.0)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.1)
+    rubygems-tasks (0.2.4)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  artifactory_api!
+  builder
+  bundler (~> 1.8.0)
+  rake (~> 10.1.0)
+  rspec
+  rubygems-tasks (~> 0.2)

data/README.md

@@ -0,0 +1,6 @@
+[![Build Status](https://travis-ci.org/rcarragher/artifactory_api.png)](https://travis-ci.org/rcarragher/artifactory_api)
+
+artifactory_api
+===============
+
+A simple API client for accessing artifactory.

data/Rakefile

@@ -0,0 +1,43 @@
+
+
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler'
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install bundler` to install Bundler."
+  exit -1
+end
+
+begin
+  Bundler.setup(:development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn "Run `bundle install` to install missing gems."
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rubygems/tasks'
+Gem::Tasks.new
+
+# require 'cucumber/rake/task'
+#
+# Cucumber::Rake::Task.new do |t|
+#   t.cucumber_opts = %w[--format pretty]
+# end
+
+task :default => [:test]
+task :spec => :test
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:test) do |spec|
+  spec.pattern = FileList['spec/**/*.rb']
+end
+

data/lib/artifactory_api.rb

@@ -0,0 +1,8 @@
+
+# Copyright (c) 2013 
+
+require 'artifactory_api/version'
+require 'artifactory_api/exceptions'
+require 'artifactory_api/client'
+require 'artifactory_api/builds'
+require 'artifactory_api/artifacts'

data/lib/artifactory_api/artifacts.rb

@@ -0,0 +1,35 @@
+module ArtifactoryApi
+  class Client
+    class Artifacts
+      def initialize(client)
+        @client = client
+        @logger = @client.logger
+      end
+
+      def to_s
+        "#<ArtifactoryApi::Clients::Builds>"
+      end
+
+      def deploy_artifact repo, path, file
+        url = "/#{repo}#{path}"
+        @client.api_put_request url, file
+      end
+
+      def retrieve_artifact repo, path
+        url = "/#{repo}#{path}"
+        response = @client.api_get_request url, raw_response=true
+        response.body
+      end
+
+      def artifact_info repo, path
+        url = "/api/storage/#{repo}#{path}"
+        @client.api_get_request url
+      end
+
+      def copy_artifact from_repo, from_path, to_repo, to_path
+        url = "/api/copy/#{from_repo}#{from_path}?to=/#{to_repo}#{to_path}"
+        @client.api_post_request url
+      end
+    end
+  end
+end

data/lib/artifactory_api/builds.rb

@@ -0,0 +1,57 @@
+
+module ArtifactoryApi
+  class Client
+    class Builds
+      def initialize(client)
+        @client = client
+        @logger = @client.logger
+      end
+
+      def to_s
+        "#<ArtifactoryApi::Client::Builds"
+      end
+
+      #Returns an array of hashes, containing a "name" key and a "last_built" key
+      #The api returns build names with a starting slash, this will remove them.
+      def list_all
+        response_json = @client.api_get_request("/api/build")
+
+        return nil unless response_json
+
+        response_json["builds"].map do |build|
+          {
+            :name => build["uri"].sub(/^\//,''),
+            :uri => build["uri"],
+            :lastStarted => build["lastStarted"]
+          }
+        end.sort{ |x,y| x[:name] <=> y[:name]}
+
+      end
+
+      def get_runs_for_build build
+        response_json = @client.api_get_request("/api/build/#{build}")
+        return nil unless response_json
+
+        response_json["buildsNumbers"].map do |build|
+          {
+            :number => build["uri"].sub(/^\//,''),
+            :uri => build["uri"],
+            :started => build["started"]
+          }
+        end.sort{|x,y| x[:number].to_i <=> y[:number].to_i}
+      end
+
+      def get_run_info build,run
+        response_json = @client.api_get_request("/api/build/#{build}/#{run}")
+        return nil unless response_json
+        result = response_json["buildInfo"]
+        result[:number] = result["number"]
+        result[:name] = result["name"]
+        result
+      end
+
+      def diffs_for_build_run build, to_run, from_run
+      end
+    end
+  end
+end

data/lib/artifactory_api/client.rb

@@ -0,0 +1,242 @@
+require 'logger'
+require 'base64'
+require 'uri'
+require 'json'
+require 'net/http'
+require 'net/https'
+
+module ArtifactoryApi
+  class Client
+    attr_accessor :logger
+
+    DEFAULT_SERVER_PORT = 80
+
+    VALID_PARAMS = [
+      "server_url",
+      "server_ip",
+      "server_port",
+      "artifactory_path",
+      "username",
+      "password",
+      "password_base64",
+      "log_location",
+      "log_level",
+      "ssl",
+      "follow_redirects"
+    ].freeze
+
+    def initialize(args)
+      args.each do |key, value|
+        if value && VALID_PARAMS.include?(key.to_s)
+          instance_variable_set("@#{key}", value)
+        end
+      end if args.is_a? Hash
+
+      # Server IP or Server URL must be specified
+      unless @server_ip || @server_url
+        raise ArgumentError, "Server IP or Server URL is required to connect" +
+          " to Artifactory"
+      end
+
+      # Username/password are optional as some artifactory servers do not require
+      # authentication
+      if @username && !(@password || @password_base64)
+        raise ArgumentError, "If username is provided, password is required"
+      end
+
+      # Get info from the server_url, if we got one
+      if @server_url
+        server_uri = URI.parse(@server_url)
+        @server_ip = server_uri.host
+        @server_port = server_uri.port
+        @ssl = server_uri.scheme == "https"
+        @artifactory_path = server_uri.path
+      end
+
+      @artifactory_path ||= ""
+      @artifactory_path.gsub!(/\/$/, "") # remove trailing slash if there is one
+
+      @server_port = DEFAULT_SERVER_PORT unless @server_port
+      @ssl ||= false
+
+      # Setting log options
+      @log_location = STDOUT unless @log_location
+      @log_level = Logger::INFO unless @log_level
+      @logger = Logger.new(@log_location)
+      @logger.level = @log_level
+
+      # Base64 decode inserts a newline character at the end. As a workaround
+      # added chomp to remove newline characters. I hope nobody uses newline
+      # characters at the end of their passwords :)
+      @password = Base64.decode64(@password_base64).chomp if @password_base64
+
+    end
+
+    def builds
+      ArtifactoryApi::Client::Builds.new(self)
+    end
+
+    def artifacts
+      ArtifactoryApi::Client::Artifacts.new(self)
+    end
+
+    # Returns a string representing the class name
+    #
+    # @return [String] string representation of class name
+    #
+    def to_s
+      "#<ArtifactoryApi::Client>"
+    end
+
+    # Connects to the Artifactory server, sends the specified request and returns
+    # the response.
+    #
+    # @param [Net::HTTPRequest] request The request object to send
+    # @param [Boolean] follow_redirect whether to follow redirects or not
+    #
+    # @return [Net::HTTPResponse] Response from Jenkins
+    #
+    def make_http_request(request, follow_redirect = @follow_redirects)
+      request.basic_auth @username, @password if @username
+
+      http = Net::HTTP.new(@server_ip, @server_port)
+
+      if @ssl
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      response = http.request(request)
+      case response
+        when Net::HTTPRedirection then
+          # If we got a redirect request, follow it (if flag set), but don't
+          # go any deeper (only one redirect supported - don't want to follow
+          # our tail)
+          if follow_redirect
+            redir_uri = URI.parse(response['location'])
+            response = make_http_request(
+              Net::HTTP::Get.new(redir_uri.path, false)
+            )
+          end
+      end
+      return response
+    end
+
+    protected :make_http_request
+
+
+    # Sends a GET request to the Artifactory server with the specified URL
+    #
+    # @param [String] url_prefix The prefix to use in the URL
+    # @param [Boolean] raw_response Return complete Response object instead of
+    #   JSON body of response
+    #
+    # @return [String, JSON] JSON response from Jenkins
+    #
+    def api_get_request(url_prefix, raw_response = false)
+      url_prefix = "#{@artifactory_path}#{url_prefix}"
+      to_get = URI.escape(url_prefix)
+      request = Net::HTTP::Get.new(to_get)
+      @logger.info "GET #{to_get}"
+      exec_request(request, raw_response)
+    end
+
+    # Sends a PUT request to the Artifactory server with the specified URL
+    def api_put_request(url_prefix, data, raw_response = false)
+      url_prefix = "#{@artifactory_path}#{url_prefix}"
+      to_put = URI.escape(url_prefix)
+      request = Net::HTTP::Put.new(to_put)
+      request.body = data
+      @logger.info "PUT #{to_put}"
+      exec_request(request, raw_response, data)
+    end
+
+    # Sends a POST request to the Artifactory server with the specified URL
+    def api_post_request(url_prefix, raw_response = false, data=nil)
+      url_prefix = "#{@artifactory_path}#{url_prefix}"
+      to_post = URI.escape(url_prefix)
+      request = Net::HTTP::Post.new(to_post)
+      @logger.info "POST #{to_post}"
+      exec_request(request, raw_response, data)
+    end
+
+    #
+    # @param [Net::HTTP::Get Put or Post] request
+    # @param [Boolean] raw_response Return complete Response object instead of
+    #   JSON body of response
+    # @param [String] data String to be sent as body of the request
+
+    # @return [String, JSON] Response returned whether loaded JSON or raw
+    def exec_request(request, raw_response=false, data=nil)
+      request.body = data if !data.nil?
+      response = make_http_request(request)
+      if raw_response
+        handle_exception(response, "raw")
+      else
+        handle_exception(response, "body", send_json=true)
+      end
+    end
+
+    private
+
+    # Private method that handles the exception and raises with proper error
+    # message with the type of exception and returns the required values if no
+    # exceptions are raised.
+    #
+    # @param [Net::HTTP::Response] response Response from Artifactory
+    # @param [String] to_send What should be returned as a response. Allowed
+    #   values: "code", "body", and "raw".
+    # @param [Boolean] send_json Boolean value used to determine whether to
+    #   load the JSON or send the response as is.
+    #
+    # @return [String, JSON] Response returned whether loaded JSON or raw
+    #   string
+    #
+    # @raise [Exceptions::Unauthorized] When invalid credentials are
+    #   provided to connect to Artifactory
+    # @raise [Exceptions::NotFound] When the requested page on Artifactory is not
+    #   found
+    # @raise [Exceptions::InternalServerError] When Artifactory returns a 500
+    #   Internal Server Error
+    # @raise [Exceptions::ApiException] Any other exception returned from
+    #   Artifactory that are not categorized in the API Client.
+    #
+    def handle_exception(response, to_send = "code", send_json = false)
+      msg = "ArtifactoryAPI HTTP Code: #{response.code}, Response Body: #{response.body}"
+      @logger.debug msg
+      case response.code.to_i
+        when 200, 201, 302
+          if to_send == "body" && send_json
+            return JSON.parse(response.body)
+          elsif to_send == "body"
+            return response.body
+          elsif to_send == "code"
+            return response.code
+          elsif to_send == "raw"
+            return response
+          end
+        when 400
+          matched = response.body.match(/<p>(.*)<br\s*\/>/)
+          api_message = matched[1] unless matched.nil?
+          @logger.info "API message: #{api_message}"
+          raise Exceptions::ApiException.new(api_message)
+        when 401
+          raise Exceptions::Unauthorized.new
+        when 403
+          raise Exceptions::Forbidden.new
+        when 404
+          raise Exceptions::NotFound.new
+        when 500
+          raise Exceptions::InternalServerError.new
+        when 503
+          raise Exceptions::ServiceUnavailable.new
+        else
+          raise Exceptions::ApiException.new(
+                  "Error code #{response.code}"
+                )
+      end
+    end
+  end
+end
+
+

data/lib/artifactory_api/exceptions.rb

@@ -0,0 +1,70 @@
+
+
+require 'logger'
+
+module ArtifactoryApi
+  # This module contains classes that define exceptions for various catories.
+  #
+  module Exceptions
+    # This is the base class for Exceptions that is inherited from
+    # RuntimeError.
+    #
+    class ApiException < RuntimeError
+      def initialize( message = "")
+        super(message)
+      end
+    end
+
+    # This exception class handles cases where invalid credentials are provided
+    # to connect to Artifactory.
+    #
+    class Unauthorized < ApiException
+      def initialize( message = "")
+        msg = "Invalid credentials are provided. #{message}"
+        super(msg)
+      end
+    end
+
+    # This exception class handles cases where invalid credentials are provided
+    # to connect to Artifactory.
+    #
+    class Forbidden < ApiException
+      def initialize( message = "")
+        msg = "Forbiddent exception #{message}"
+        super(msg)
+      end
+    end
+
+    # This exception class handles cases where a requested page is not found on
+    # the Artifactory API.
+    #
+    class NotFound < ApiException
+      def initialize( message = "")
+        msg = "Requested component is not found on Artifactory" \
+          if message.empty?
+        super(msg)
+      end
+    end
+
+    # This exception class handles cases where the Artifactory API returns with a
+    # 500 Internel Server Error.
+    #
+    class InternalServerError < ApiException
+      def initialize( message = "")
+        msg = "Internel Server Error. #{message}"
+        super(msg)
+      end
+    end
+  
+    # This exception class handles cases where Artifactory is getting restarted
+    # or reloaded where the response code returned is 503
+    #
+    class ServiceUnavailable < ApiException
+      def initialize( message = "")
+        msg = "Artifactory is unavailable #{message}"
+        super(msg)
+      end
+    end
+
+  end
+end

data/lib/artifactory_api/version.rb

@@ -0,0 +1,14 @@
+module ArtifactoryApi
+  class Client
+    # Major version of the gem
+    MAJOR   = 0
+    # Minor version of the gem
+    MINOR   = 1
+    # Tiny version of the gem used for patches
+    TINY    = 4
+    # Used for pre-releases
+    PRE     = 'pre2'
+    # Version String of Jenkins API Client.
+    VERSION = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
+end

data/spec/builds_spec.rb

@@ -0,0 +1,81 @@
+require_relative "spec_helper"
+
+describe ArtifactoryApi::Client::Builds do
+
+  before(:each) do
+    #Setup mocks
+    logger = Logger.new("test_log.log")
+    @client = double("client")
+    @client.stub(:logger) {logger}
+    @builds = ArtifactoryApi::Client::Builds.new(@client)
+  end
+
+  it "should call the all builds endpoint" do
+    #@client.should_receive(:api_get_request) {"/api/builds"}
+    @client.should_receive(:api_get_request).with("/api/build").and_return(nil)
+    builds = ArtifactoryApi::Client::Builds.new(@client)
+    builds.list_all
+  end
+
+  it "should return the builds map" do
+    the_response = { "builds" => [{"uri" => "/Build1",
+                                   "lastStarted" => "2013-06-03T13:41:18.147+0000"}],
+                     "uri" => "http://artifactory/api/build"}
+
+    @client.should_receive(:api_get_request).with("/api/build").and_return(the_response)
+
+    build_list = @builds.list_all
+    expect(build_list.length).to eq(1)
+    expect(build_list[0][:lastStarted]).to eq("2013-06-03T13:41:18.147+0000")
+    expect(build_list[0][:name]).to eq("Build1")
+
+  end
+
+  it "should return all runs given a build" do
+    the_response = {"buildsNumbers" => [{"uri" => "/149","started" => "2013-03-14T16:07:43.636+0000"}],
+                    "uri" => "https://artifactory-1.ampaxs.net/api/build/Server"}
+    @client.should_receive(:api_get_request).with("/api/build/MyBuild").and_return(the_response)
+
+    runs = @builds.get_runs_for_build "MyBuild"
+
+    expect(runs.length).to eq(1)
+    expect(runs[0][:number]).to eq("149")
+    expect(runs[0][:started]).to eq("2013-03-14T16:07:43.636+0000")
+
+  end
+
+  it "should sort runs by the run number" do
+     the_response = {"buildsNumbers" => [
+                      {"uri" => "/149","started" => "2013-03-14T16:07:43.636+0000"},
+                      {"uri" => "/2464","started" => "2013-03-14T16:07:43.636+0000"},
+                      {"uri" => "/379","started" => "2013-06-10T19:38:05.857+0000"},
+                      {"uri" => "/222","started" => "2013-04-25T19:39:26.464+0000"}],
+                    "uri" => "https://artifactory-1.ampaxs.net/api/build/Server"}
+
+    @client.should_receive(:api_get_request).with("/api/build/MyBuild").and_return(the_response)
+
+    runs = @builds.get_runs_for_build "MyBuild"
+
+    expect(runs.length).to eq(4)
+    expect(runs[0][:number]).to eq("149")
+    expect(runs[1][:number]).to eq("222")
+    expect(runs[2][:number]).to eq("379")
+    expect(runs[3][:number]).to eq("2464")
+
+  end
+
+
+  it "should return info for a run, given a build and run" do
+
+    the_response = {"buildInfo" => {"version" => "1.0.1", "name" => "MyBuild", "number" => "430"},
+                          "uri" => "https://artifactory-1.ampaxs.net/api/build/Server/430"}
+
+    @client.should_receive(:api_get_request).with("/api/build/MyBuild/430").and_return(the_response)
+
+    run_info = @builds.get_run_info "MyBuild","430"
+
+    expect(run_info[:number]).to eq("430")
+    expect(run_info[:name]).to eq("MyBuild")
+  end
+
+end

data/spec/client_spec.rb

@@ -0,0 +1,83 @@
+require_relative "spec_helper"
+
+describe ArtifactoryApi::Client do
+
+  describe "initialization" do
+    it "should initialize when server ip, port, and user/password is provided" do
+      expect(
+        lambda do
+          ArtifactoryApi::Client.new(
+            :server_ip => '127.0.0.1',
+            :server_port => 8080,
+            :username => 'username',
+            :password => 'password'
+          )
+        end
+      ).not_to raise_error
+    end
+
+    it "should initialize when username/password not specified" do
+      expect(
+        lambda do
+          ArtifactoryApi::Client.new(
+            :server_ip => '127.0.0.1',
+            :server_port => 8080
+          )
+        end
+      ).not_to raise_error
+    end
+
+    it "should initializes with server_url" do
+      expect(
+        lambda do
+          ArtifactoryApi::Client.new(
+            :server_url => 'http://localhost',
+            :username => 'username',
+            :password => 'password'
+          )
+        end
+      ).not_to raise_error
+    end
+
+    it "should fail to initialize when a username is provided but not a password" do
+      expect(
+        lambda do
+          ArtifactoryApi::Client.new(
+            :server_url => 'http://localhost',
+            :username => 'user_id'
+          )
+        end
+      ).to raise_error
+    end
+
+    it "should fail to initialize when you don't provide any server data" do
+      expect(
+        lambda do
+          ArtifactoryApi::Client.new(
+            :username => "user", :password => "password")
+        end
+      ).to raise_error
+    end
+  end
+
+  context "With valid credentials given" do
+    before do
+      @client = ArtifactoryApi::Client.new(
+        :server_ip => '127.0.0.1',
+        :server_port => 8080,
+        :username => 'username',
+        :password => 'password',
+        :log_location => '/dev/null'
+      )
+    end
+
+    it "should return a Build object when you ask for it" do
+      expect(@client.builds.class).to eq(ArtifactoryApi::Client::Builds)
+    end
+
+    it "should return a Artifacts object when you ask for it" do
+      expect(@client.artifacts.class).to eq(ArtifactoryApi::Client::Artifacts)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../../lib/artifactory_api', __FILE__)
+require 'logger'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.color_enabled = true
+  config.order = :random
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+end
+

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: artifactory_api
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+platform: ruby
+authors:
+- Rick Carragher
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-08-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  prerelease: false
+  type: :development
+description: A client to the artifactory rest api
+email: rcarragher@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/artifactory_api.rb
+- lib/artifactory_api/artifacts.rb
+- lib/artifactory_api/builds.rb
+- lib/artifactory_api/client.rb
+- lib/artifactory_api/exceptions.rb
+- lib/artifactory_api/version.rb
+- spec/builds_spec.rb
+- spec/client_spec.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/artifactory_api
+licenses:
+- Apachev2
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.5
+signing_key:
+specification_version: 4
+summary: artfifactory_api consumes the artifactory rest api to do useful stuff
+test_files:
+- spec/builds_spec.rb
+- spec/client_spec.rb
+- spec/spec_helper.rb