gemfury 0.12.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '085b1527c75280eea2af851ba682cf633ad4c7254519e352ecaedce754067a4a'
-  data.tar.gz: 044cb832c6707879b7117e65895b1908f09e98b55a4641bb5c98504c264c52b5
+  metadata.gz: ca072afb73e0349c3d02481d7d665f058f68b05ca287026f208c0fd8b30361a1
+  data.tar.gz: cf3983d68afea4c3f8dbb46ed387b12273f80d3524989a63f93e447c889b0c26
 SHA512:
-  metadata.gz: cd3c775925ff9095bbc708945dede4c78082f5e24920e141b5089181fec866551a7f9e1fc7895b137f39c8e38f97252491b5fe15c9e932c52b5ed36c81bc4911
-  data.tar.gz: d2c1fda36dbe5183821d728ac2982900f1b7f0c9730d8aade63255f9b1f248018d5b6519a68367e8b4f9a7cd24dde79986f472b6f0db2546e07eee0c1d48547b
+  metadata.gz: 7da7f0ca97595441d0666eb19cd1dbd033e579c1cd6181a4b2804c30b2b1bc12a4b9f3b3d3196cc287db3393c09c4004fb11be0cef9ab849378369b51e88a686
+  data.tar.gz: c2270b3792a92fd3fe63b6230676e28bf0e7ee12f49a44e5b126f9d92491ed35476ef08fe0e078c9227963fbdaad29941dda7ff2a5ffc8e1003a2dfe246dfbf1

data/bin/fury

@@ -1,14 +1,13 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-lib = File.expand_path('../../lib', __FILE__)
+lib = File.expand_path('../lib', __dir__)
 $LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
 
 require 'rubygems'
 require 'gemfury'
 require 'gemfury/command'
 
-if defined?(Warning) && Warning.respond_to?('[]')
-  Warning[:deprecated] = !!ENV['DEBUG']
-end
+Warning[:deprecated] = !!ENV['DEBUG'] if defined?(Warning) && Warning.respond_to?('[]')
 
 Gemfury::Command::App.start

data/bin/gemfury

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

data/lib/faraday/adapter/fury_http.rb

@@ -1,32 +1,25 @@
+# frozen_string_literal: true
+
 # 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
+    def request_with_wrapped_block(http, env, &block)
+      is_text = env.request_headers['Accept'] =~ /text\z/
+      return super if !block.nil? || !is_text
 
-          # 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
+      # Stream chunks directly to STDOUT
+      resp = super(http, env) do |chunk|
+        $stdout.print(chunk)
+        $stdout.flush
       end
+
+      # Client sees nil body
+      resp.body = nil
+      resp
     end
   end
 
-  register_middleware(:fury_http => FuryHttp)
+  register_middleware(fury_http: FuryHttp)
 end

data/lib/faraday/request/multipart_with_file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 
 # @private
@@ -5,13 +7,11 @@ module Faraday
   # @private
   class Request::MultipartWithFile < Faraday::Middleware
     def call(env)
-
       if env[:body].is_a?(Hash)
 
         # Check for IO (and IO-like objects, like Zip::InputStream) in the request,
         # which represent data to be uploaded.  Replace these with Faraday
         env[:body].each do |key, value|
-
           # Faraday seems to expect a few IO methods to be available, but that's all:
           # https://github.com/lostisland/faraday/blob/master/lib/faraday/file_part.rb
           # :length seems to be an optional one
@@ -21,7 +21,7 @@ module Faraday
           #
           # We attempt to make our duck typing compatible with their duck typing
           if value.respond_to?(:read) && value.respond_to?(:rewind) && value.respond_to?(:close)
-            env[:body][key] = Faraday::UploadIO.new(value, mime_type(value))
+            env[:body][key] = Faraday::Multipart::FilePart.new(value, mime_type(value))
           end
         end
       end

data/lib/gemfury/client/filters.rb

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

data/lib/gemfury/client/middleware.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module Gemfury
   class Client
     class Handle503 < Faraday::Middleware
       def call(env)
-        # This prevents errors in ParseJson 
+        # 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
+    class ParseJson < Faraday::Middleware
       def parse(body)
         body =~ /\A\s*\z/ ? nil : MultiJson.decode(body)
       end
@@ -20,4 +22,4 @@ module Gemfury
       end
     end
   end
-end
+end

data/lib/gemfury/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Gemfury
   class Client
     include Gemfury::Client::Filters
@@ -5,7 +7,7 @@ module Gemfury
 
     # Creates a new API
     # @param options [Hash] values for attributes described in {Gemfury::Configuration}
-    def initialize(options={})
+    def initialize(options = {})
       options = Gemfury.options.merge(options)
       Gemfury::VALID_OPTIONS_KEYS.each do |key|
         send("#{key}=", options[key])
@@ -34,8 +36,8 @@ module Gemfury
     # @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))
+      push_api = connection(url: pushpoint)
+      response = push_api.post('uploads', options.merge(file: file))
       checked_response_body(response)
     end
 
@@ -83,7 +85,7 @@ module Gemfury
     # @return [Hash]
     def login(email, password, opts = {})
       ensure_ready!
-      opts = opts.merge(:email => email, :password => password)
+      opts = opts.merge(email: email, password: password)
       checked_response_body(connection.post('login', opts))
     end
 
@@ -161,7 +163,7 @@ module Gemfury
     def git_rebuild(repo, options = {})
       ensure_ready!(:authorization)
       url = "#{git_repo_path(repo)}/builds"
-      api = connection(:api_format => :text)
+      api = connection(api_format: :text)
       checked_response_body(api.post(url, options))
     end
 
@@ -184,51 +186,48 @@ module Gemfury
     def git_config_update(repo, updates, options = {})
       ensure_ready!(:authorization)
       path = "#{git_repo_path(repo)}/config-vars"
-      opts = options.merge(:config_vars => updates)
+      opts = options.merge(config_vars: updates)
       response = connection.patch(path, opts)
       checked_response_body(response)
     end
 
-  private
+    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('/')
+      ['git/repos', 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
+        v = options.delete(:api_version) || 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,
+        url: endpoint,
+        params: {},
+        headers: {
+          accept: http_accept,
+          user_agent: 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
+      options[:headers][:authorization] = user_api_key if user_api_key
 
-      if self.account
-        options[:params][:as] = self.account
-      end
+      options[:params][:as] = account if account
 
       Faraday.new(options) do |builder|
         builder.use Faraday::Request::MultipartWithFile
-        builder.use Faraday::Request::Multipart
+        builder.use Faraday::Multipart::Middleware
         builder.use Faraday::Request::UrlEncoded
         builder.use ParseJson
         builder.use Handle503
@@ -237,37 +236,35 @@ module Gemfury
     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
+      return response.body if response.success?
+
+      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
 
     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 => ''
-      })
+                content_length: file.stat.size.to_s,
+                content_type: ''
+              })
     end
   end
 end