travis-packagecloud-ruby 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 84a4d56bec4d70a54f2b482a5dd01f65f01c669c089ff30acc9812f171970222
+  data.tar.gz: c3797c10f55a0220e14cca64b01628841be63cd1557707ddd1bc8dd8e9bf603d
+SHA512:
+  metadata.gz: 5a32ada5ae606b9a7d2579f5f15041c936473b7dd7769da01befdd996b646eff7fc8c8a9e8423988d1e2105fbdc72e85311ffde77f3d8e28465d0962fc9414a0
+  data.tar.gz: ca0e2a2698520dc5a54f1df7614ebaaf7906fa6a2a0061af7fbc0892f35c7d4f4692addbe7b7bd7af22539ccbe59a2b85f6c4caa855dd2b837adf7d82ca495b8

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.rdoc
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.lock
+doc/
+pkg/
+vendor/cache/*.gem

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.travis.yml

@@ -0,0 +1,8 @@
+sudo: false
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.1.0
+  - 2.4.3
+  - 2.5.0

data/.yardopts

@@ -0,0 +1 @@
+--markup rdoc --title "packagecloud-ruby Documentation" --protected

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Computology, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,135 @@
+## packagecloud-ruby
+
+![Build Status](https://travis-ci.org/computology/packagecloud-ruby.svg?branch=master "Build Status")
+
+
+Ruby library for communicating with the [packagecloud.io](https://packagecloud.io) API.
+
+* [Homepage](https://rubygems.org/gems/packagecloud-ruby)
+* [Documentation](http://rubydoc.info/gems/packagecloud-ruby/frames)
+* [Email](mailto:support@packagecloud.io)
+
+## Goals
+
+This library aims to have widest amount of compatibility possible between Ruby versions and implementations. All dependencies are pure Ruby and kept to a minimum to ensure this.
+
+#### Tested Rubies
+  
+  * Ruby 1.8.x, 1.9x, and 2.x
+
+## Implemented API Endpoints
+
+  * [Get Package Contents](https://packagecloud.io/docs/api#resource_packages_method_contents)
+  * [Upload Package](https://packagecloud.io/docs/api#resource_packages_method_create)
+  * [List Distributions](https://packagecloud.io/docs/api#resource_distributions_method_index)
+  * [View Repository](https://packagecloud.io/docs/api#resource_repositories_method_show)
+  * [View Repositories](https://packagecloud.io/docs/api#resource_repositories_method_index)
+  * [Create Repository](https://packagecloud.io/docs/api#resource_repositories_method_create)
+
+## Installation
+
+  ```
+  gem install packagecloud-ruby
+  ```
+
+## Getting your API token
+
+Login to [packagecloud.io](https://packagecloud.io) and
+go to your [Account Settings](https://packagecloud.io/api_token) to see your API token.
+
+## Creating a Client
+
+  Note that you should not use the email address associated with your
+  [packagecloud.io](https://packagecloud.io) account when accessing the API.
+  Please use your username on the site.
+
+  ```ruby
+  require 'packagecloud'
+
+  # Create a client using your username and API token
+  credentials = Packagecloud::Credentials.new("joedamato", "my_api_token")
+  @client = Packagecloud::Client.new(credentials)
+
+  ```
+
+## Result objects
+
+  Every client API method call returns a ```Result``` object, which is simply:
+
+  ```ruby
+  module Packagecloud
+    class Result
+      attr_accessor :response
+      attr_accessor :succeeded
+    end
+  end
+  ```
+
+  If ```.succeeded``` is ```true``` then, ```.response``` is the parsed JSON response
+  of that endpoint, otherwise ```.response``` is the error text explaining what went wrong.
+
+
+## Usage
+
+### Distributions
+
+  This is the list of currently [supported distributions](https://packagecloud.io/docs#os_distro_version).
+
+  ```ruby
+  # Get all distributions
+  distros = @client.distributions
+
+  # Looking up a distribution id by name
+  id = @client.find_distribution_id("el/6") # returns 27
+  ```
+
+### Repositories
+
+  ```ruby
+  # Looking up all repositories available for a client
+  repos = @client.repositories
+
+  # Lookup info on a single repo
+  repo = @client.repository("my_repo")
+
+  # Creating a repository
+  @client.create_repository("my_repo")
+
+  ```
+
+  When specifying your repository name, you should use just the name and not
+  the fully qualified name (fqname).
+
+  For example:
+
+  ```ruby
+  # INCORRECT: this should just be "my_repo"
+  repo = @client.repository("user/my_repo")
+  ```
+
+### Packages
+
+  ```ruby
+  # Create RPM Packages (can take File, IO, or path argument)
+  rpm_package = Packagecloud::Package.new(:file => "libcurl-0.1.2.rpm")
+
+  # Creating gem Packages using IO (needs :filename passed in)
+  gem_package = Packagecloud::Package.new(:file => io_object, :filename => "rails-4.0.0.gem")
+
+  # Creating source Packages
+  source_files = { "jake_1.0.orig.tar.bz2" => open("/path/jake_1.0.orig.tar.bz2"),
+                   "jake_1.0-7.debian.tar.gz" => open("/path/jake_1.0-7.debian.tar.gz") }
+  dsc_package = Packagecloud::Package.new(:file => "jake_1.0-7.dsc", :source_files => source_files)
+
+  # Upload Packages
+  @client.put_package("test_repo", gem_package)
+  @client.put_package("test_repo", rpm_package, "el/6")
+  @client.put_package("test_repo", dsc_package, "ubuntu/trusty")
+  @client.put_package("test_repo", node_package, "node")
+  ```
+
+## Copyright
+
+Copyright (c) 2014-2018 Computology, LLC
+
+See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,45 @@
+# 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 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new  
+task :doc => :yard
+
+require 'rspec/core/rake_task'
+
+desc "Run all specs with rcov"
+RSpec::Core::RakeTask.new("spec:coverage") do |t|
+ t.rcov = true
+ t.rcov_opts = %w{-Ispec
+                  --exclude gems\/,spec\/,features\/,seeds\/}
+ t.spec_opts = ["-c"]
+end
+

data/lib/packagecloud/client.rb

@@ -0,0 +1,296 @@
+require 'json'
+require 'mime'
+require 'excon'
+require 'packagecloud/result'
+require 'packagecloud/connection'
+require 'packagecloud/version'
+
+module Packagecloud
+  SUPPORTED_EXTENSIONS = ["deb", "dsc", "gem", "rpm", "whl", "zip", "egg", "egg-info", "tar", "bz2", "Z", "gz", "tgz"]
+
+  class UnauthenticatedException < StandardError
+    attr_reader :object
+
+    def initialize(object = nil)
+      @object = object
+    end
+  end
+
+  class GemOutOfDateException < StandardError
+    attr_reader :object
+
+    def initialize(object = nil)
+      @object = object
+    end
+  end
+
+  class InvalidRepoNameException < StandardError
+    attr_reader :object
+
+    def initialize(object = nil)
+      @object = object
+    end
+  end
+
+  class InvalidUsernameException < StandardError
+    attr_reader :object
+
+    def initialize(object = nil)
+      @object = object
+    end
+  end
+
+  class Client
+    attr_reader :connection
+    attr_reader :credentials
+
+    def initialize(credentials, user_agent="packagecloud-ruby #{Packagecloud::VERSION}", connection=Connection.new)
+      @credentials = credentials
+      @connection = connection
+      @user_agent = user_agent
+
+      scheme = self.connection.scheme
+      host = self.connection.host
+      port = self.connection.port
+      token = self.credentials.token
+
+      @excon = Excon.new("#{scheme}://#{token}@#{host}:#{port}", :connect_timeout => @connection.connect_timeout)
+      assert_valid_credentials
+    end
+
+    def distributions
+      response = get("/api/v1/distributions.json")
+      parsed_json_result(response)
+    end
+
+    def repositories
+      response = get("/api/v1/repos.json")
+      parsed_json_result(response)
+    end
+
+    def repository(repo)
+      assert_valid_repo_name(repo)
+      response = get("/api/v1/repos/#{username}/#{repo}.json")
+      parsed_json_result(response)
+    end
+
+    def gem_version
+      response = get("/api/v1/gem_version.json")
+      parsed_json_result(response)
+    end
+
+    def create_repository(repo, private=false)
+      assert_valid_repo_name(repo)
+      privacy = private ? 1 : 0
+      body = { "repository" => { "name" => repo, "private" => privacy.to_s } }
+      response = post("/api/v1/repos.json", body.to_json)
+      parsed_json_result(response)
+    end
+
+    def package_contents(repo, package, distro_version_id=nil)
+      assert_valid_repo_name(repo)
+      if distro_version_id.nil?
+        raise "No distribution supplied for package_contents!"
+      end
+
+      url = "/api/v1/repos/#{username}/#{repo}/packages/contents.json"
+
+      mixed_msg = MIME::Multipart::FormData.new
+
+      package.file.rewind
+      pkg_data = MIME::Application.new(package.file.read)
+      pkg_data.headers.set('Content-Transfer-Encoding', 'binary')
+      mixed_msg.add(pkg_data, "package[package_file]", package.filename)
+
+      if distro_version_id.is_a? String
+        distro_version = find_distribution_id(distro_version_id)
+        raise "Cannot find distribution: #{distro_version_id}" if distro_version.nil?
+        mixed_msg.add(MIME::Text.new(distro_version), "package[distro_version_id]")
+      else
+        mixed_msg.add(MIME::Text.new(distro_version_id), "package[distro_version_id]")
+      end
+
+      response = multipart_post(url, mixed_msg)
+
+      parsed_json_result(response)
+    end
+
+    def list_packages(repo)
+      assert_valid_repo_name(repo)
+      response = get("/api/v1/repos/#{username}/#{repo}/packages.json")
+      parsed_json_result(response)
+    end
+
+    def delete_package(repo, distro, distro_release, package_filename)
+      assert_valid_repo_name(repo)
+      url = "/api/v1/repos/#{username}/#{repo}/#{distro}/#{distro_release}/#{package_filename}"
+      response = delete(url)
+      parsed_json_result(response)
+    end
+
+    def put_package(repo, package, distro_version_id=nil)
+      assert_valid_repo_name(repo)
+
+      url = "/api/v1/repos/#{username}/#{repo}/packages.json"
+
+      mixed_msg = MIME::Multipart::FormData.new
+
+      if distro_version_id != nil
+        if distro_version_id.is_a? String
+          distro_version = find_distribution_id(distro_version_id)
+          raise "Cannot find distribution: #{distro_version_id}" if distro_version.nil?
+          mixed_msg.add(MIME::Text.new(distro_version), "package[distro_version_id]")
+        else
+          mixed_msg.add(MIME::Text.new(distro_version_id), "package[distro_version_id]")
+        end
+      end
+
+      package.file.rewind
+      pkg_data = MIME::Application.new(package.file.read)
+      pkg_data.headers.set('Content-Transfer-Encoding', 'binary')
+      mixed_msg.add(pkg_data, "package[package_file]", package.filename)
+
+      package.source_files.each do |filename, io|
+        io.rewind
+        src_pkg_data = MIME::Application.new(io.read)
+        src_pkg_data.headers.set('Content-Transfer-Encoding', 'binary')
+        mixed_msg.add(src_pkg_data, "package[source_files][]", filename)
+      end
+
+      response = multipart_post(url, mixed_msg)
+
+      prepare_result(response) { |result| result.response = "" }
+    end
+
+    def find_distribution_id(distro_query)
+      distros = distributions
+      if distros.succeeded
+        deb_distros = distro_map distros.response["deb"]
+        rpm_distros = distro_map distros.response["rpm"]
+        py_distros = distro_map distros.response["py"]
+        node_distros = distro_map distros.response["node"]
+        all_distros = deb_distros.merge(rpm_distros).merge(py_distros).merge(node_distros)
+        result = all_distros.select { |distro, id| distro.include?(distro_query) }
+        if result.size > 1
+          keys = result.map { |x| x.first }.join(' ')
+          raise ArgumentError, "'#{distro_query}' is ambiguous, did you mean: #{keys}?"
+        elsif result.size == 1
+          result.first[1] # [["ubuntu/breezy", 1]]
+        else
+          nil
+        end
+      end
+    end
+
+    def create_read_tokens(repo, master_token_id, read_token_name)
+      assert_valid_repo_name(repo)
+      url = "/api/v1/repos/#{username}/#{repo}/master_tokens/#{master_token_id}/read_tokens.json"
+      response = post(url, "read_token[name]=#{read_token_name}", "application/x-www-form-urlencoded")
+      parsed_json_result(response)
+    end
+
+    def delete_read_token(repo, master_token_id, read_token_id)
+      assert_valid_repo_name(repo)
+      url = "/api/v1/repos/#{username}/#{repo}/master_tokens/#{master_token_id}/read_tokens/#{read_token_id}"
+      response = delete(url)
+      Result.new.tap do |result|
+        result.succeeded = (response.status == 204)
+      end
+    end
+
+    def list_read_tokens(repo, master_token_id)
+      assert_valid_repo_name(repo)
+      response = get("/api/v1/repos/#{username}/#{repo}/master_tokens/#{master_token_id}/read_tokens.json")
+      parsed_json_result(response)
+    end
+
+    private
+      def assert_valid_repo_name(repo)
+        if repo.include?("/")
+          raise InvalidRepoNameException.new("The repo name: #{repo} is " \
+                                             "invalid. It looks like you are " \
+                                             "using the fully qualified name " \
+                                             "(fqname) instead of just the " \
+                                             "repo name. Please try again.")
+        end
+      end
+
+      def assert_valid_credentials
+        result = distributions
+        if result.succeeded == false && result.response.downcase.include?('unauthenticated')
+          raise UnauthenticatedException
+        end
+      end
+
+      def distro_map(distros)
+        result = {}
+        distros.each do |distro|
+          name = distro["index_name"]
+          distro["versions"].each do |version|
+            version_name = version["index_name"]
+            key = "#{name}/#{version_name}"
+            result[key] = version["id"]
+          end
+        end
+        result
+      end
+
+      def user_agent
+        "packagecloud-ruby #{VERSION}/#{@user_agent}"
+      end
+
+      def multipart_post(url, mixed_msg)
+        boundary = mixed_msg.boundary
+        content_type = "multipart/form-data; boundary=#{boundary}"
+        body = mixed_msg.to_s
+        post(url, body, content_type)
+      end
+
+      def post(url, body, content_type="application/json")
+        request(url, :post, body, content_type)
+      end
+
+      def get(url)
+        request(url, :get)
+      end
+
+      def delete(url)
+        request(url, 'DELETE')
+      end
+
+      def username
+        self.credentials.username
+      end
+
+      def request(url, method=:get, body=nil, content_type=nil)
+        headers = { "User-Agent" => user_agent }
+        if content_type != nil
+          headers.merge!({ "Content-Type" => content_type })
+        end
+        request_params = { :method => method, :path => url, :headers => headers }
+        if body != nil
+          request_params.merge!({ :body => body })
+        end
+
+        @excon.request(request_params.merge({:read_timeout => connection.read_timeout, :write_timeout => connection.write_timeout }))
+      end
+
+      # returns the parsed body of a successful result
+      def parsed_json_result(response)
+        prepare_result(response) { |result| result.response = JSON.parse(response.data[:body]) }
+      end
+
+      def prepare_result(response)
+        result = Result.new
+        if response.status == 201 || response.status == 200
+          result.succeeded = true
+          yield result
+        else
+          result.response = response.data[:body]
+          result.succeeded = false
+        end
+        result
+      end
+
+  end
+end

data/lib/packagecloud/connection.rb

@@ -0,0 +1,15 @@
+module Packagecloud
+  class Connection
+    attr_reader :scheme, :host, :port, :connect_timeout, :read_timeout, :write_timeout
+
+    def initialize(scheme="https", host="packagecloud.io", port="443", options={})
+      @scheme = scheme
+      @host = host
+      @port = port
+
+      @connect_timeout = options[:connect_timeout] || 60
+      @read_timeout = options[:read_timeout] || 60
+      @write_timeout = options[:write_timeout] || 180
+    end
+  end
+end

data/lib/packagecloud/credentials.rb

@@ -0,0 +1,18 @@
+module Packagecloud
+  class Credentials
+    attr_reader :username
+    attr_reader :token
+
+    def initialize(username, token)
+      @username = username
+      @token = token
+      if @username.include?("@")
+        raise InvalidUsernameException.new("Sorry, looks like you may have " \
+                                           "tried to use an email address " \
+                                           "instead of your packagecloud.io " \
+                                           "username. Please use your " \
+                                           "username instead!")
+      end
+    end
+  end
+end

data/lib/packagecloud/package.rb

@@ -0,0 +1,30 @@
+module Packagecloud
+  class Package
+
+    attr_reader :file
+    attr_accessor :source_files
+    attr_reader :filename
+    attr_reader :client
+
+    def initialize(options = {})
+      if options[:file].nil?
+        raise ArgumentError, 'file cannot be nil' if file.nil?
+      end
+      if options[:file].is_a? String
+        options[:file] = File.open(options[:file])
+      end
+      if options[:file].is_a? File
+        options[:filename] = File.basename(options[:file].path)
+      end
+      if options[:filename].nil?
+        raise ArgumentError, 'filename cannot be nil' if file.nil?
+      end
+
+      @file = options[:file]
+      @filename = options[:filename]
+      @source_files = options[:source_files] || {}
+      @client = options[:client]
+    end
+
+  end
+end

data/lib/packagecloud/result.rb

@@ -0,0 +1,6 @@
+module Packagecloud
+  class Result
+    attr_accessor :response
+    attr_accessor :succeeded
+  end
+end

data/lib/packagecloud/version.rb

@@ -0,0 +1,7 @@
+module Packagecloud
+  MAJOR_VERSION = "1"
+  MINOR_VERSION = "1"
+  PATCH_VERSION = "0"
+
+  VERSION = [MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION].join(".")
+end

data/lib/packagecloud.rb

@@ -0,0 +1,4 @@
+require 'packagecloud/version'
+require 'packagecloud/client'
+require 'packagecloud/package'
+require 'packagecloud/credentials'

data/packagecloud-ruby.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/packagecloud/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "travis-packagecloud-ruby"
+  gem.version       = Packagecloud::VERSION
+  gem.summary       = "library for interacting with packagecloud.io"
+  gem.description   = gem.summary
+  gem.license       = "MIT" # as stated in LICENSE.txt file
+  gem.authors       = ["Joe Damato"]
+  gem.email         = "joe@packagecloud.io"
+  gem.homepage      = "https://rubygems.org/gems/packagecloud-ruby"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'excon', '~> 0.40'
+  gem.add_runtime_dependency 'json_pure', '~> 2'
+  gem.add_runtime_dependency 'mime', '~> 0.4'
+
+  gem.add_development_dependency 'bundler', '~> 2.0'
+  gem.add_development_dependency 'rake', '~> 0.8'
+  gem.add_development_dependency 'rspec', '~> 2.4'
+  gem.add_development_dependency 'simplecov', '~> 0.9'
+  gem.add_development_dependency 'rubygems-tasks', '~> 0.2'
+  gem.add_development_dependency 'yard', '~> 0.9.11'
+end