gemfury 0.10.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 624ab4a41068c6d17c63693ff3bc4de20641ee87390f68df9f7d02c29a59e16e
+  data.tar.gz: f4657867345ca219161a3090be0fb2ba19c475cb3fb33ac637213aa0c32916c5
+SHA512:
+  metadata.gz: 569f391a1d8230204d9b1778042a57e53a72afae523ae7f1b4646971ad2db1918dc1260792f0fce000e995619d78f5c2bc3ca013945883cb01c6292463694219
+  data.tar.gz: f3906e7e9b1e360ba75f8615f5728009b3e8c01915be185777ea2fdef9d1207990abe3c86f405a18e8275461eef334efb8c1c738ceb62eb74765d63d24fa063e

data/README.md

@@ -0,0 +1,62 @@
+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)
+
+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)
+
+## 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,53 @@
+gem "multi_json",         "~> 1.10"
+gem "faraday",            ">= 0.9.0", "< 0.16.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
+  class << self
+    # Alias for Gemfury::Client.new
+    #
+    # @return [Gemfury::Client]
+    def new(options={})
+      Gemfury::Client.new(options)
+    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
+
+class Hash
+  # Access nested hashes as a period-separated path
+  def path(path, separator = '.')
+    path.split(separator).inject(self) do |hash, part|
+      hash.is_a?(Hash) ? hash[part] : nil
+    end
+  end
+end

data/lib/gemfury/client.rb

@@ -0,0 +1,211 @@
+module Gemfury
+  class Client
+    include Gemfury::Client::Filters
+    attr_accessor *Configuration::VALID_OPTIONS_KEYS
+
+    # Creates a new API
+    def initialize(options={})
+      options = Gemfury.options.merge(options)
+      Configuration::VALID_OPTIONS_KEYS.each do |key|
+        send("#{key}=", options[key])
+      end
+    end
+
+    # Get the information for the current account
+    def account_info
+      ensure_ready!(:authorization)
+      response = connection.get('users/me')
+      checked_response_body(response)
+    end
+
+    # Get the information for the current account
+    def accounts
+      ensure_ready!(:authorization)
+      response = connection.get('accounts')
+      checked_response_body(response)
+    end
+
+    # Uploading a gem file
+    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 gems
+    def list(options = {})
+      ensure_ready!(:authorization)
+      response = connection.get('gems', options)
+      checked_response_body(response)
+    end
+
+    # List versions for a gem
+    def versions(name, options = {})
+      ensure_ready!(:authorization)
+      url = "gems/#{escape(name)}/versions"
+      response = connection.get(url, options)
+      checked_response_body(response)
+    end
+
+    # Delete a gem version
+    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
+    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
+    def logout
+      ensure_ready!(:authorization)
+      response = connection.post('logout')
+      checked_response_body(response)
+    end
+
+    # List collaborators for this account
+    def list_collaborators(options = {})
+      ensure_ready!(:authorization)
+      response = connection.get('collaborators', options)
+      checked_response_body(response)
+    end
+
+    # Add a collaborator to the account
+    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
+    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
+    def git_repos(options = {})
+      ensure_ready!(:authorization)
+      response = connection.get(git_repo_path, options)
+      checked_response_body(response)
+    end
+
+    # Update repository name and settings
+    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
+    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
+    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
+
+  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

data/lib/gemfury/client/filters.rb

@@ -0,0 +1,18 @@
+module Gemfury
+  class Client
+    module Filters
+
+    private
+      def ensure_ready!(*args)
+        # Ensure authorization
+        if args.include?(:authorization)
+          raise Unauthorized unless authenticated?
+        end
+      end
+
+      def authenticated?
+        self.user_api_key && !self.user_api_key.empty?
+      end
+    end
+  end
+end

data/lib/gemfury/client/middleware.rb

@@ -0,0 +1,23 @@
+module Gemfury
+  class Client
+    class Handle503 < Faraday::Middleware
+      def call(env)
+        # This prevents errors in ParseJson 
+        @app.call(env).on_complete do |out|
+          out[:body] = '' if out[:status] == 503
+        end
+      end
+    end
+
+    class ParseJson < Faraday::Response::Middleware
+      def parse(body)
+        body =~ /\A\s*\z/ ? nil : MultiJson.decode(body)
+      end
+
+      def on_complete(response)
+        ok = response.request_headers['Accept'] =~ /json\z/
+        response.body = parse(response.body) if ok
+      end
+    end
+  end
+end

data/lib/gemfury/command.rb

@@ -0,0 +1,12 @@
+gem "highline", ">= 1.6.0", "< 2.1.0.pre"
+gem "thor",     ">= 0.14.0", "< 1.0.0.pre"
+
+require 'thor'
+require 'yaml'
+require 'highline'
+require 'fileutils'
+
+module Gemfury::Command; end
+
+require 'gemfury/command/authorization'
+require 'gemfury/command/app'

data/lib/gemfury/command/app.rb

@@ -0,0 +1,295 @@
+class Gemfury::Command::App < Thor
+  include Gemfury::Command::Authorization
+  UserAgent = "Gemfury CLI #{Gemfury::VERSION}".freeze
+  PackageExtensions = %w(gem egg tar.gz tgz nupkg)
+
+  # Impersonation
+  class_option :as, :desc => 'Access an account other than your own'
+  class_option :api_token, :desc => 'API token to use for commands'
+
+  map "-v" => :version
+  desc "version", "Show Gemfury version", :hide => true
+  def version
+    shell.say Gemfury::VERSION
+  end
+
+  ### PACKAGE MANAGEMENT ###
+  option :public, :type => :boolean, :desc => "Create as public package"
+  desc "push FILE", "Upload a new version of a package"
+  def push(*gems)
+    with_checks_and_rescues do
+      push_files(:push, gems)
+    end
+  end
+
+  desc "list", "List your packages"
+  def list
+    with_checks_and_rescues do
+      gems = client.list
+      shell.say "\n*** GEMFURY PACKAGES ***\n\n"
+
+      va = [ %w{ name kind version privacy } ]
+      gems.each do |g|
+        va << [ g['name'], g['language'],
+                g.path('latest_version.version') || 'beta',
+                g['private'] ? 'private' : 'public ' ]
+      end
+
+      shell.print_table(va)
+    end
+  end
+
+  desc "versions NAME", "List all the package versions"
+  def versions(gem_name)
+    with_checks_and_rescues do
+      versions = client.versions(gem_name)
+      shell.say "\n*** #{gem_name.capitalize} Versions ***\n\n"
+
+      va = []
+      va = [ %w{ version uploaded uploaded_by } ]
+      versions.each do |v|
+        uploaded = Time.parse(v['created_at']).strftime('%F %R %z')
+        va << [ v['version'], uploaded, v['created_by']['name'] ]
+      end
+
+      shell.print_table(va)
+    end
+  end
+
+  desc "yank NAME", "Delete a package version"
+  method_options %w(version -v) => :required
+  def yank(gem_name)
+    with_checks_and_rescues do
+      version = options[:version]
+      client.yank_version(gem_name, version)
+      shell.say "\n*** Yanked #{gem_name}-#{version} ***\n\n"
+    end
+  end
+
+  ### AUTHENTICATION ###
+  desc "logout", "Remove Gemfury credentials"
+  def logout
+    if !has_credentials?
+      shell.say "You are logged out"
+    elsif shell.yes? "Are you sure you want to log out? [yN]"
+      with_checks_and_rescues { client.logout }
+      wipe_credentials!
+      shell.say "You have been logged out"
+    end
+  end
+
+  desc "login", "Save Gemfury credentials"
+  def login
+    with_checks_and_rescues do
+      me = client.account_info['name']
+      shell.say %Q(You are logged in as "#{me}"), :green
+    end
+  end
+
+  desc "whoami", "Show current user"
+  def whoami
+    has_credentials? ? self.login : begin
+      shell.say %Q(You are not logged in), :green
+    end
+  end
+
+  desc "accounts", "Show info about your Gemfury accounts"
+  def accounts
+    with_checks_and_rescues do
+      accounts = client.accounts
+
+      va = [ %w{ name kind permission } ]
+      accounts.each do |a|
+        va << [ a['name'], a['type'], a['viewer_permission'].downcase ]
+      end
+
+      shell.print_table(va)
+    end
+  end
+
+  ### COLLABORATION MANAGEMENT ###
+  map "sharing:add" => 'sharing_add'
+  map "sharing:remove" => 'sharing_remove'
+
+  desc "sharing", "List collaborators"
+  def sharing
+    with_checks_and_rescues do
+      me = client.account_info['username']
+      collaborators = client.list_collaborators
+      if collaborators.empty?
+        shell.say "You (#{me}) are the only collaborator", :green
+      else
+        shell.say %Q(\n*** Collaborators for "#{me}" ***\n), :green
+        usernames = [me] + collaborators.map { |c| c['username'] }
+        shell.say usernames.join("\n")
+      end
+      shell.say "\n"
+    end
+  end
+
+  desc "sharing:add EMAIL", "Add a collaborator"
+  def sharing_add(username)
+    with_checks_and_rescues do
+      client.add_collaborator(username)
+      shell.say "Invited #{username} as a collaborator"
+    end
+  end
+
+  desc "sharing:remove EMAIL", "Remove a collaborator"
+  def sharing_remove(username)
+    with_checks_and_rescues do
+      client.remove_collaborator(username)
+      shell.say "Removed #{username} as a collaborator"
+    end
+  end
+
+  ### MIGRATION (Pushing directories) ###
+  desc "migrate DIR", "Upload all packages within a directory"
+  def migrate(*paths)
+    with_checks_and_rescues do
+      gem_paths = Dir.glob(paths.map do |p|
+        if File.directory?(p)
+          PackageExtensions.map { |ext| "#{p}/**/*.#{ext}" }
+        elsif File.file?(p)
+          p
+        else
+          nil
+        end
+      end.flatten.compact)
+
+      if gem_paths.empty?
+        die!("Problem: No valid packages found", nil, :migrate)
+      else
+        shell.say "Found the following packages:"
+        gem_paths.each { |p| shell.say "  #{File.basename(p)}" }
+        if shell.yes? "Upload these files to Gemfury? [yN]", :green
+          push_files(:migrate, gem_paths)
+        end
+      end
+    end
+  end
+
+  ### GIT REPOSITORY MANAGEMENT ###
+  map "git:list"    => 'git_list'
+  map "git:reset"   => 'git_reset'
+  map "git:rename"  => 'git_rename'
+  map "git:rebuild" => 'git_rebuild'
+
+  desc "git:list", "List Git repositories"
+  def git_list
+    with_checks_and_rescues do
+      repos = client.git_repos['repos']
+      shell.say "\n*** GEMFURY GIT REPOS ***\n\n"
+      names = repos.map { |r| r['name'] }
+      names.sort.each { |n| shell.say(n) }
+    end
+  end
+
+  desc "git:rename", "Rename a Git repository"
+  def git_rename(repo, new_name)
+    with_checks_and_rescues do
+      client.git_update(repo, :repo => { :name => new_name })
+      shell.say "Renamed #{repo} repository to #{new_name}\n"
+    end
+  end
+
+  desc "git:reset", "Remove a Git repository"
+  def git_reset(repo)
+    with_checks_and_rescues do
+      client.git_reset(repo)
+      shell.say "\n*** Yanked #{repo} repository ***\n\n"
+    end
+  end
+
+  desc "git:rebuild", "Rebuild a Git repository"
+  method_options %w(revision -r) => :string
+  def git_rebuild(repo)
+    with_checks_and_rescues do
+      params = { :revision => options[:revision] }
+      shell.say "\n*** Rebuilding #{repo} repository ***\n\n"
+      shell.say client.git_rebuild(repo, :build => params)
+    end
+  end
+
+private
+  def client
+    opts = {}
+    opts[:user_api_key] = @user_api_key if @user_api_key
+    opts[:account] = options[:as] if options[:as]
+    client = Gemfury::Client.new(opts)
+    client.user_agent = UserAgent
+    return client
+  end
+
+  def with_checks_and_rescues(&block)
+    @user_api_key = options[:api_token] if options[:api_token]
+    with_authorization(&block)
+  rescue Gemfury::InvalidGemVersion => e
+    shell.say "You have a deprecated Gemfury client", :red
+    if shell.yes? "Would you like to update it now? [yN]"
+      exec("gem update gemfury")
+    else
+      shell.say %q(No problem. You can also run "gem update gemfury")
+    end
+  rescue Gemfury::Conflict => e
+    die!("Oops! Locked for another user. Try again later.", e)
+  rescue Gemfury::Forbidden => e
+    die!("Oops! You're not allowed to access this", e)
+  rescue Gemfury::NotFound => e
+    die!("Oops! Doesn't look like this exists", e)
+  rescue Gemfury::Error => e
+    die!("Oops! %s" % e.message, e)
+  rescue StandardError => e
+    die!("Oops! Something went wrong. Please contact support.", e)
+  end
+
+  def push_files(command, gem_paths)
+    files = gem_paths.map do |g|
+      g.is_a?(String) ? File.new(g) : g rescue nil
+    end.compact
+
+    if files.empty?
+      die!("Problem: No valid packages found", nil, command)
+    end
+
+    push_options = { }
+    unless options[:public].nil?
+      push_options[:public] = options[:public]
+    end
+
+    error_ex = nil
+
+    # Let's get uploading
+    files.each do |file|
+      begin
+        shell.say "Uploading #{File.basename(file.path)} "
+        client.push_gem(file, push_options)
+        shell.say "- done"
+      rescue Gemfury::CorruptGemFile => e
+        shell.say "- problem processing this package", :red
+        error_ex = e
+      rescue Gemfury::DupeVersion => e
+        shell.say "- this version already exists", :red
+        error_ex = e
+      rescue Gemfury::TimeoutError, Errno::EPIPE => e
+        shell.say "- this file is too much to handle", :red
+        shell.say "  Visit http://www.gemfury.com/large-package for more info"
+        error_ex = e
+      rescue => e
+        shell.say "- oops", :red
+        error_ex = e
+      end
+    end
+
+    unless error_ex.nil?
+      die!('There was a problem uploading at least 1 package', error_ex)
+    end
+  end
+
+  def die!(msg, err = nil, command = nil)
+    shell.say msg, :red
+    help(command) if command
+    shell.say %Q(#{err.class.name}: #{err}\n#{err.backtrace.join("\n")}) if err && ENV['DEBUG']
+    exit(1)
+  end
+end

data/lib/gemfury/command/authorization.rb

@@ -0,0 +1,79 @@
+module Gemfury::Command::Authorization
+  include Gemfury::Platform
+
+  def wipe_credentials!
+    FileUtils.rm(config_path, :force => true) # never raises exception
+    each_netrc_host { |h| netrc_conf.delete(h) }
+    netrc_conf.save
+  end
+
+  def has_credentials?
+    !!netrc_conf[netrc_api_host] ||
+    read_config_file.key?(:gemfury_api_key)
+  end
+
+private
+  def with_authorization(&block)
+    # Load up the credentials if user_api_key is not already set
+    load_credentials! if @user_api_key.nil?
+
+    # Attempt the operation and prompt user in case of
+    # lack of authorization or a 401 response from the server
+    begin
+      prompt_credentials! if @user_api_key.nil?
+      block.call
+    rescue Gemfury::Unauthorized
+      if acct = client.account
+        shell.say %Q(Oops! You don't have access to "#{acct}"), :red
+      else
+        shell.say "Oops! Authentication failure.", :red
+        @user_api_key = nil
+        retry
+      end
+    end
+  end
+
+  def prompt_credentials!
+    # Prompt credentials
+    highline = HighLine.new
+    highline.say 'Please enter your Gemfury credentials.'
+    email = highline.ask('Email: ')
+    passw = highline.ask('Password: ') { |q| q.echo = false }
+
+    # Request and save the API access token
+    if !email.empty? && !passw.empty?
+      @user_api_key = client.get_access_token(email, passw)
+      write_credentials!(email)
+    end
+  end
+
+  def load_credentials!
+    # Get credentials from ~/.netrc
+    _, @user_api_key = netrc_conf[netrc_api_host]
+    # Legacy loading from ~/.gem/gemfury
+    @user_api_key ||= read_config_file[:gemfury_api_key]
+  end
+
+  def write_credentials!(email)
+    each_netrc_host { |h| netrc_conf[h] = email, @user_api_key }
+    netrc_conf.save
+  end
+
+  def read_config_file
+    File.exist?(config_path) ? YAML.load_file(config_path) : {}
+  end
+
+  def netrc_conf
+    @netrc ||= Netrc.read
+  end
+
+  def netrc_api_host
+    URI.parse(client.endpoint).host
+  end
+
+  def each_netrc_host
+    [:endpoint, :gitpoint].each do |c|
+      yield(URI.parse(client.send(c)).host)
+    end
+  end
+end

data/lib/gemfury/configuration.rb

@@ -0,0 +1,72 @@
+module Gemfury
+  # Defines constants and methods related to configuration
+  module Configuration
+    # An array of valid keys in the options hash when configuring
+    VALID_OPTIONS_KEYS = [
+      :user_api_key,
+      :adapter,
+      :endpoint,
+      :gitpoint,
+      :pushpoint,
+      :user_agent,
+      :api_version,
+      :account].freeze
+
+    # The adapter that will be used to connect if none is set
+    DEFAULT_ADAPTER = :net_http
+
+    # The endpoint that will be used to connect if none is set
+    DEFAULT_ENDPOINT  = 'https://api.fury.io/'.freeze
+
+    # The HTTP endpoint for git repo (used for .netrc credentials)
+    DEFAULT_GITPOINT  = 'https://git.fury.io/'.freeze
+
+    # The endpoint for the Push API if not set
+    DEFAULT_PUSHPOINT = 'https://push.fury.io/'.freeze
+
+    # The value sent in the 'User-Agent' header if none is set
+    DEFAULT_USER_AGENT = "Gemfury RubyGem #{Gemfury::VERSION}".freeze
+
+    # Default API version
+    DEFAULT_API_VERSION = 1
+
+    # Default user API key
+    DEFAULT_API_KEY = nil
+
+    # Use the current account (no impersonation)
+    DEFAULT_ACCOUNT = nil
+
+    # @private
+    attr_accessor *VALID_OPTIONS_KEYS
+
+    # When this module is extended, set all configuration options to their default values
+    def self.extended(base)
+      base.reset
+    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
+    def options
+      options = {}
+      VALID_OPTIONS_KEYS.each{|k| options[k] = send(k)}
+      options
+    end
+
+    # Reset all configuration options to defaults
+    def reset
+      self.user_api_key       = DEFAULT_API_KEY
+      self.adapter            = DEFAULT_ADAPTER
+      self.endpoint           = DEFAULT_ENDPOINT
+      self.gitpoint           = DEFAULT_GITPOINT
+      self.pushpoint          = DEFAULT_PUSHPOINT
+      self.user_agent         = DEFAULT_USER_AGENT
+      self.api_version        = DEFAULT_API_VERSION
+      self.account            = DEFAULT_ACCOUNT
+      self
+    end
+  end
+end

data/lib/gemfury/const.rb

@@ -0,0 +1,26 @@
+module Gemfury
+  module Const
+    class << self
+      def host
+        'www.gemfury.com'
+        #'localhost:3000'
+      end
+
+      def welcome
+        "Welcome to Gemfury!\nPlease complete the following information"
+      end
+
+      def email_error
+        "Invalid email address. Please try again."
+      end
+
+      def email_regex
+        return @email_regex if @email_regex
+        email_name_regex  = '[A-Z0-9_\.%\+\-\']+'
+        domain_head_regex = '(?:[A-Z0-9\-]+\.)+'
+        domain_tld_regex  = '(?:[A-Z]{2,4}|museum|travel)'
+        @email_regex = /^#{email_name_regex}@#{domain_head_regex}#{domain_tld_regex}$/i
+      end
+    end
+  end
+end

data/lib/gemfury/error.rb

@@ -0,0 +1,28 @@
+module Gemfury
+  # Base Error class
+  Error = Class.new(StandardError)
+
+  # The Gemfury gem version doesn't match the one on the server
+  InvalidGemVersion = Class.new(Error)
+
+  # Client#user_api_key is not defined or Gemfury returns 401
+  Unauthorized = Class.new(Error)
+
+  # Client is not allowed to perform this operation
+  Forbidden = Class.new(Error)
+
+  # Account is locked for another operation
+  Conflict = Class.new(Error)
+
+  # Returned if something is not found
+  NotFound = Class.new(Error)
+
+  # Corrupt Gem File
+  CorruptGemFile = Class.new(Error)
+
+  # Version already exists
+  DupeVersion = Class.new(Error)
+
+  # TimeoutError for 503s
+  TimeoutError = Class.new(Error)
+end

data/lib/gemfury/platform.rb

@@ -0,0 +1,19 @@
+module Gemfury
+  module Platform
+    def home_directory
+      on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
+    end
+
+    def config_path
+      File.expand_path('.gem/gemfury', home_directory)
+    end
+
+    def on_windows?
+      RUBY_PLATFORM =~ /mswin32|mingw32/
+    end
+
+    def on_mac?
+      RUBY_PLATFORM =~ /-darwin\d/
+    end
+  end
+end

data/lib/gemfury/tasks.rb

@@ -0,0 +1,2 @@
+# Load Gemfury rakefile extensions
+load "gemfury/tasks/release.rake"

data/lib/gemfury/tasks/release.rake

@@ -0,0 +1,36 @@
+require 'rubygems/package'
+require 'gemfury'
+require 'gemfury/command'
+
+namespace 'fury' do
+  desc "Build gem and push it to Gemfury"
+  task :release, [:gemspec, :as] do |t, args|
+    gemspec = args[:gemspec] ||
+              FileList["#{Dir.pwd}/*.gemspec"][0]
+
+    if gemspec.nil? || !File.exist?(gemspec)
+      puts "No gemspec found"
+    else
+      puts "Building #{File.basename(gemspec)}"
+      spec = Gem::Specification.load(gemspec)
+
+      if Gem::Package.respond_to?(:build)
+        Gem::Package.build(spec)
+      else
+        require 'rubygems/builder'
+        Gem::Builder.new(spec).build
+      end
+
+      gemfile = File.basename(spec.cache_file)
+
+      params = ['push', gemfile]
+      params << "--as=#{args[:as]}" if args[:as]
+
+      Gemfury::Command::App.start(params)
+    end
+  end
+end
+
+namespace 'gemfury' do
+  task :release => 'fury:release'
+end

data/lib/gemfury/version.rb

@@ -0,0 +1,3 @@
+module Gemfury
+  VERSION = '0.10.0.rc1'
+end

data/lib/rubygems/commands/fury_command.rb

@@ -0,0 +1,29 @@
+require 'gemfury'
+require 'gemfury/command'
+
+class Gem::Commands::FuryCommand < Gem::Command
+  def description
+    'Push a private gem to your Gemfury account'
+  end
+
+  def arguments
+    "GEM       built gem file to push"
+  end
+
+  def usage
+    "#{program_name} GEM"
+  end
+
+  def initialize
+    super 'fury', description
+    add_option('-a', '--as USERNAME', 'Impersonate another account') do |value, options|
+      options[:as] = value
+    end
+  end
+
+  def execute
+    opts = options.dup
+    args = opts.delete(:args)
+    Gemfury::Command::App.send(:dispatch, "push", args, opts, {})
+  end
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,2 @@
+require 'rubygems/command_manager'
+Gem::CommandManager.instance.register_command :fury

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: gemfury
+version: !ruby/object:Gem::Version
+  version: 0.10.0.rc1
+platform: ruby
+authors:
+- Michael Rykov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0.pre
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0.pre
+- !ruby/object:Gem::Dependency
+  name: netrc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.12.0.pre
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.12.0.pre
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.16.0.pre
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.16.0.pre
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.1.0.pre
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.1.0.pre
+description: 'Hosted repo for your public and private packages at https://gemfury.com
+
+'
+email: hello@gemfury.com
+executables:
+- gemfury
+- fury
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/fury
+- bin/gemfury
+- lib/faraday/adapter/fury_http.rb
+- lib/faraday/request/multipart_with_file.rb
+- lib/gemfury.rb
+- lib/gemfury/client.rb
+- lib/gemfury/client/filters.rb
+- lib/gemfury/client/middleware.rb
+- lib/gemfury/command.rb
+- lib/gemfury/command/app.rb
+- lib/gemfury/command/authorization.rb
+- lib/gemfury/configuration.rb
+- lib/gemfury/const.rb
+- lib/gemfury/error.rb
+- lib/gemfury/platform.rb
+- lib/gemfury/tasks.rb
+- lib/gemfury/tasks/release.rake
+- lib/gemfury/version.rb
+- lib/rubygems/commands/fury_command.rb
+- lib/rubygems_plugin.rb
+homepage: https://gemfury.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: |
+  ************************************************************************
+
+    Upload your first package to start using Gemfury:
+    fury push my-package-1.0.0.gem
+
+    If you have a directory with packages, you can use:
+    fury migrate ./path/to/codez
+
+    Find out what else you can do:
+    fury help
+
+    Follow @gemfury on Twitter for announcements, updates, and news.
+    https://twitter.com/gemfury
+
+  ************************************************************************
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Hosted repo for your public and private packages
+test_files: []