gemfury 0.12.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fa1399aeab2f739da48ef55e4a7a6654ce9bb8527d722a9b7ce022ac082f2c2f
+  data.tar.gz: 176541eb909afc8610b8a4f94b3653dece97f898518a69fc137a7bd46533df25
+SHA512:
+  metadata.gz: c69342a8284196e6e43b9a3dc3bead88cfe17b2ae098db213d5055314d703aefada6e5df8f4cd3d08a8c6a413bc27f211bd8f8be3dd802f4a8000f3c35121666
+  data.tar.gz: ed29f372dbec0526a614d2d8bb4ca8982ab47114a0c3d42857c4f06a480db690f7d9c898221b3be654b1e177f5d20f78382aa2069318a732b2a1ee08fb2ea71c

data/README.md

@@ -0,0 +1,87 @@
+Gemfury CLI
+===========
+
+[![Gem Version](https://badge.fury.io/rb/gemfury.svg)](http://badge.fury.io/rb/gemfury)
+[![Build Status](https://secure.travis-ci.org/gemfury/gemfury.svg?branch=master)](https://travis-ci.org/gemfury/gemfury)
+[![Code Climate](https://codeclimate.com/github/gemfury/gemfury/badges/gpa.svg)](https://codeclimate.com/github/gemfury/gemfury)
+[![Documentation](https://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://www.rubydoc.info/gems/gemfury)
+[![Documentation completeness](https://inch-ci.org/github/gemfury/gemfury.svg?branch=master)](http://inch-ci.org/github/gemfury/gemfury)
+
+This is the Gemfury CLI used to manage your Gemfury packages from the command line.  If you're
+familiar with the service and want to jump straight into command line action, please proceed to
+the [CLI documentation](https://gemfury.com/help/gemfury-cli).
+
+Gemfury is your personal cloud for your private and custom RubyGems, Python packages, and NPM
+modules.  Once you upload your packages and enable Gemfury as a source, you can securely deploy
+any package to any host. It's simple, reliable, and hassle-free.
+
+
+### Introduction to Gemfury
+* [Gemfury homepage](https://gemfury.com/)
+* [Getting started with Gemfury](https://gemfury.com/help/getting-started)
+
+### Using Gemfury CLI
+* [CLI documentation](https://gemfury.com/help/gemfury-cli)
+* [Uploading private packages](https://gemfury.com/help/gemfury-cli#uploading-packages)
+* [Manage collaborators](https://gemfury.com/help/gemfury-cli#collaboration)
+
+### Putting Gemfury to work
+* [Install private RubyGems](https://gemfury.com/help/install-gems)
+* [Install private NPM modules](https://gemfury.com/help/npm-registry)
+* [Install private Python packages](https://gemfury.com/help/pypi-server)
+* [Install private Composer packages](https://gemfury.com/help/php-composer-server)
+* [Private RubyGems on Heroku](https://gemfury.com/help/private-gems-on-heroku)
+
+
+## Using the Gemfury Client
+
+You can also use the client directly via Ruby; you will need a "Full access token" (API token) from `https://manage.fury.io/manage/YOUR-ACCOUNT-NAME/tokens/api`
+
+```ruby
+require 'gemfury'
+
+client = Gemfury::Client.new(user_api_key: "YOUR API TOKEN")
+
+all_artifacts = client.list
+puts "Available artifacts:"
+puts all_artifacts
+
+one_artifact = all_artifacts[0]
+puts "Versions of the #{one_artifact['language']} artifact #{one_artifact['name']}:"
+artifact_versions = client.versions(one_artifact["name"])
+puts artifact_versions.map { |v| v["version"] }
+```
+
+More information about the `Gemfury::Client` API is [hosted on rubydoc.info](https://rubydoc.info/gems/gemfury/Gemfury/Client).
+
+
+## Contribution and Improvements
+
+Please [email us](mailto:support@gemfury.com) if we've missed some key functionality or you have problems installing the CLI client.  Better yet, fork the code, make the changes, and submit a pull request to speed things along.
+
+### Submitting updates
+
+If you would like to contribute to this project, just do the following:
+
+1. Fork the repo on Github.
+2. Add your features and make commits to your forked repo.
+3. Make a pull request to this repo.
+4. Review will be done and changes will be requested.
+5. Once changes are done or no changes are required, pull request will be merged.
+6. The next release will have your changes in it.
+
+Please take a look at the issues page if you want to get started.
+
+### Feature requests
+
+If you think it would be nice to have a particular feature that is presently not implemented, we would love
+to hear that and consider working on it.  Just open an issue in Github.
+
+### Dependency conflicts
+
+Over time, dependencies for this gem will get stale and may interfere with your other gems.  Please let us know if you run into this and we will re-test our gem with the new version of the dependency and update the _gemspec_.
+
+
+## Questions
+
+Please email support@gemfury.com or file a Github Issue if you have any other questions or problems.

data/bin/fury

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'rubygems'
+require 'gemfury'
+require 'gemfury/command'
+
+Gemfury::Command::App.start

data/bin/gemfury

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exec(File.expand_path('../fury', __FILE__), *ARGV)

data/lib/faraday/adapter/fury_http.rb

@@ -0,0 +1,32 @@
+# This is a Faraday adapter that bypasses Faraday's response body
+# processing and streams body to STDOUT for text requests
+
+class Faraday::Adapter
+  class FuryHttp < NetHttp
+    def perform_request(http, env)
+      accept = env.request_headers['Accept']
+      return super if accept !~ /text\z/
+
+      # Stream response body to STDOUT on success
+      http.request(create_request(env)) do |resp|
+        unless resp.is_a?(Net::HTTPSuccess)
+          resp.body # Cache error body
+        else
+          resp.read_body do |chunk|
+            $stdout.print(chunk)
+            $stdout.flush
+          end
+
+          # Prevent #body from calling #read_body again
+          klass = (class << resp; self; end)
+          klass.send(:define_method, :body) { nil }
+        end
+
+        # Return response to NetHttp adapter
+        return resp
+      end
+    end
+  end
+
+  register_middleware(:fury_http => FuryHttp)
+end

data/lib/faraday/request/multipart_with_file.rb

@@ -0,0 +1,34 @@
+require 'faraday'
+
+# @private
+module Faraday
+  # @private
+  class Request::MultipartWithFile < Faraday::Middleware
+    def call(env)
+      if env[:body].is_a?(Hash)
+        env[:body].each do |key, value|
+          if value.is_a?(File)
+            env[:body][key] = Faraday::UploadIO.new(value, mime_type(value), value.path)
+          end
+        end
+      end
+
+      @app.call(env)
+    end
+
+    private
+
+    def mime_type(file)
+      case file.path
+      when /\.jpe?g/i
+        'image/jpeg'
+      when /\.gif$/i
+        'image/gif'
+      when /\.png$/i
+        'image/png'
+      else
+        'application/octet-stream'
+      end
+    end
+  end
+end

data/lib/gemfury.rb

@@ -0,0 +1,82 @@
+gem "multi_json",         "~> 1.10"
+gem "faraday",            ">= 0.9.0", "< 1.1.0.pre"
+gem "netrc",              ">= 0.10.0", "< 0.12.0.pre"
+
+require 'time'
+require 'cgi'
+require 'uri'
+require 'netrc'
+require 'multi_json'
+require 'faraday'
+require 'faraday/adapter/fury_http'
+require 'faraday/request/multipart_with_file'
+
+require 'gemfury/version'
+require 'gemfury/const'
+require 'gemfury/error'
+require 'gemfury/platform'
+require 'gemfury/configuration'
+
+require 'gemfury/client/filters'
+require 'gemfury/client/middleware'
+require 'gemfury/client'
+
+module Gemfury
+  extend Configuration
+  VALID_OPTIONS_KEYS = Configuration::CONFIGURATION_DEFAULTS.keys.freeze
+
+  class << self
+    # Alias for Gemfury::Client.new
+    #
+    # @return [Gemfury::Client]
+    def new(options={})
+      Gemfury::Client.new(options)
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+    end
+
+    # Create a hash of options and their values
+    # @return [Hash] the options and their values
+    def options
+      VALID_OPTIONS_KEYS.inject({}) do |options, k|
+        options[k] = send(k)
+        options
+      end
+    end
+
+    # Reset all configuration options to defaults
+    # @return [Configuration] The default configuration
+    def reset
+      CONFIGURATION_DEFAULTS.each { |k, v| send("#{k}=", v) }
+      self
+    end
+
+    # Delegate to Gemfury::Client
+    def method_missing(method, *args, &block)
+      return super unless new.respond_to?(method)
+      new.send(method, *args, &block)
+    end
+
+    def respond_to?(method, include_private = false)
+      new.respond_to?(method, include_private) || super(method, include_private)
+    end
+
+  end
+end
+
+# Initialize configuration
+Gemfury.reset
+
+# Polyfill #dig for Ruby 2.2 and earlier
+class Hash
+  unless self.instance_methods.include?(:dig)
+    def dig(*parts)
+      parts.inject(self) do |hash, part|
+        hash.is_a?(Hash) ? hash[part] : nil
+      end
+    end
+  end
+end

data/lib/gemfury/client.rb

@@ -0,0 +1,273 @@
+module Gemfury
+  class Client
+    include Gemfury::Client::Filters
+    include Gemfury::Configuration
+
+    # Creates a new API
+    # @param options [Hash] values for attributes described in {Gemfury::Configuration}
+    def initialize(options={})
+      options = Gemfury.options.merge(options)
+      Gemfury::VALID_OPTIONS_KEYS.each do |key|
+        send("#{key}=", options[key])
+      end
+    end
+
+    # Get the information for the current account
+    # @return [Hash]
+    def account_info
+      ensure_ready!(:authorization)
+      response = connection.get('users/me')
+      checked_response_body(response)
+    end
+
+    # Get the information for the all accounts that this account has some level of access to
+    # @return [Array<Hash>]
+    def accounts
+      ensure_ready!(:authorization)
+      response = connection.get('accounts')
+      checked_response_body(response)
+    end
+
+    # Upload an artifact file
+    # @param file [String] the filename to upload
+    # @param options [Hash] Faraday client options
+    # @return [Hash]
+    def push_gem(file, options = {})
+      ensure_ready!(:authorization)
+      push_api = connection(:url => self.pushpoint)
+      response = push_api.post('uploads', options.merge(:file => file))
+      checked_response_body(response)
+    end
+
+    # List available artifacts
+    # @param options [Hash] Faraday client options
+    # @return [Array<Hash>]
+    def list(options = {})
+      ensure_ready!(:authorization)
+      response = connection.get('gems', options)
+      checked_response_body(response)
+    end
+
+    # List versions for an artifact
+    # @param name [String] the name of the artifact
+    # @param options [Hash] Faraday client options
+    # @return [Array<Hash>]
+    def versions(name, options = {})
+      ensure_ready!(:authorization)
+      url = "gems/#{escape(name)}/versions"
+      response = connection.get(url, options)
+      checked_response_body(response)
+    end
+
+    # Delete an artifact version
+    # @param name [String] the name of the artifact
+    # @param version [String] the version of the artifact
+    # @param options [Hash] Faraday client options
+    # @return [Hash]
+    def yank_version(name, version, options = {})
+      ensure_ready!(:authorization)
+      url = "gems/#{escape(name)}/versions/#{escape(version)}"
+      response = connection.delete(url, options)
+      checked_response_body(response)
+    end
+
+    # LEGACY: Authentication token via email/password
+    def get_access_token(*args)
+      login(*args)['token']
+    end
+
+    # Get authentication info via email/password
+    # @param email [String] the account email address
+    # @param password [String] the account password
+    # @param opts [Hash] Faraday client options
+    # @return [Hash]
+    def login(email, password, opts = {})
+      ensure_ready!
+      opts = opts.merge(:email => email, :password => password)
+      checked_response_body(connection.post('login', opts))
+    end
+
+    # Invalidate session token
+    # @return [Hash]
+    def logout
+      ensure_ready!(:authorization)
+      response = connection.post('logout')
+      checked_response_body(response)
+    end
+
+    # List collaborators for this account
+    # @param options [Hash] Faraday client options
+    # @return [Array<Hash>]
+    def list_collaborators(options = {})
+      ensure_ready!(:authorization)
+      response = connection.get('collaborators', options)
+      checked_response_body(response)
+    end
+
+    # Add a collaborator to the account
+    # @param options [Hash] Faraday client options
+    # @return [Hash]
+    def add_collaborator(login, options = {})
+      ensure_ready!(:authorization)
+      url = "collaborators/#{escape(login)}"
+      response = connection.put(url, options)
+      checked_response_body(response)
+    end
+
+    # Remove a collaborator to the account
+    # @param login [String] the account login
+    # @param options [Hash] Faraday client options
+    # @return [Hash]
+    def remove_collaborator(login, options = {})
+      ensure_ready!(:authorization)
+      url = "collaborators/#{escape(login)}"
+      response = connection.delete(url, options)
+      checked_response_body(response)
+    end
+
+    # List Git repos for this account
+    # @param options [Hash] Faraday client options
+    # @return [Hash]
+    def git_repos(options = {})
+      ensure_ready!(:authorization)
+      response = connection.get(git_repo_path, options)
+      checked_response_body(response)
+    end
+
+    # Update repository name and settings
+    # @param repo [String] the repo name
+    # @param options [Hash] Faraday client options
+    # @return [Hash]
+    def git_update(repo, options = {})
+      ensure_ready!(:authorization)
+      response = connection.patch(git_repo_path(repo), options)
+      checked_response_body(response)
+    end
+
+    # Reset repository to initial state
+    # @param repo [String] the repo name
+    # @param options [Hash] Faraday client options
+    # @return [Hash]
+    def git_reset(repo, options = {})
+      ensure_ready!(:authorization)
+      response = connection.delete(git_repo_path(repo), options)
+      checked_response_body(response)
+    end
+
+    # Rebuild Git repository package
+    # @param repo [String] the repo name
+    # @param options [Hash] Faraday client options
+    # @return [Hash]
+    def git_rebuild(repo, options = {})
+      ensure_ready!(:authorization)
+      url = "#{git_repo_path(repo)}/builds"
+      api = connection(:api_format => :text)
+      checked_response_body(api.post(url, options))
+    end
+
+    # List Git repo's build configuration
+    # @param repo [String] the repo name
+    # @param options [Hash] Faraday client options
+    # @return [Hash]
+    def git_config(repo, options = {})
+      ensure_ready!(:authorization)
+      path = "#{git_repo_path(repo)}/config-vars"
+      response = connection.get(path, options)
+      checked_response_body(response)
+    end
+
+    # Update Git repo's build configuration
+    # @param repo [String] the repo name
+    # @param updates [Hash] Updates to configuration
+    # @param options [Hash] Faraday client options
+    # @return [Hash]
+    def git_config_update(repo, updates, options = {})
+      ensure_ready!(:authorization)
+      path = "#{git_repo_path(repo)}/config-vars"
+      opts = options.merge(:config_vars => updates)
+      response = connection.patch(path, opts)
+      checked_response_body(response)
+    end
+
+  private
+    def escape(str)
+      CGI.escape(str)
+    end
+
+    def git_repo_path(*args)
+      rest = args.map { |a| escape(a) }
+      ['git/repos', self.account || 'me'].concat(rest).join('/')
+    end
+
+    def connection(options = {})
+      # The 'Accept' HTTP header for API versioning
+      http_accept = begin
+        v = options.delete(:api_version) || self.api_version
+        f = options.delete(:api_format)  || :json
+        "application/vnd.fury.v#{v.to_i}+#{f}"
+      end
+
+      # Faraday client options
+      options = {
+        :url => self.endpoint,
+        :params => {},
+        :headers => {
+          :accept => http_accept,
+          :user_agent => self.user_agent,
+          :x_gem_version => Gemfury::VERSION,
+        }.merge(options.delete(:headers) || {})
+      }.merge(options)
+
+      if self.user_api_key
+        options[:headers][:authorization] = self.user_api_key
+      end
+
+      if self.account
+        options[:params][:as] = self.account
+      end
+
+      Faraday.new(options) do |builder|
+        builder.use Faraday::Request::MultipartWithFile
+        builder.use Faraday::Request::Multipart
+        builder.use Faraday::Request::UrlEncoded
+        builder.use ParseJson
+        builder.use Handle503
+        builder.adapter :fury_http
+      end
+    end
+
+    def checked_response_body(response)
+      if response.success?
+        return response.body
+      else
+        error = (response.body || {})['error'] || {}
+        error_class = case error['type']
+        when 'Forbidden'       then Gemfury::Forbidden
+        when 'GemVersionError' then Gemfury::InvalidGemVersion
+        when 'InvalidGemFile'  then Gemfury::CorruptGemFile
+        when 'DupeVersion'     then Gemfury::DupeVersion
+        else
+          case response.status
+          when 401 then Gemfury::Unauthorized
+          when 403 then Gemfury::Forbidden
+          when 404 then Gemfury::NotFound
+          when 409 then Gemfury::Conflict
+          when 503 then Gemfury::TimeoutError
+          else          Gemfury::Error
+          end
+        end
+
+        raise(error_class, error['message'])
+      end
+    end
+
+    def s3_put_file(uri, file)
+      Faraday::Connection.new(uri) do |f|
+        f.adapter :net_http
+      end.put(uri, file, {
+        :content_length => file.stat.size.to_s,
+        :content_type => ''
+      })
+    end
+  end
+end