cloudsmith-api 0.53.1 → 0.57.1

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.14.0/lib/ethon/easy/options.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+
+    # This module contains the logic and knowledge about the
+    # available options on easy.
+    module Options
+      attr_reader :url
+
+      def url=(value)
+        @url = value
+        Curl.set_option(:url, value, handle)
+      end
+
+      def escape=( b )
+        @escape = b
+      end
+
+      def escape?
+        return true if !defined?(@escape) || @escape.nil?
+        @escape
+      end
+
+      def multipart=(b)
+        @multipart = b
+      end
+
+      def multipart?
+        !!@multipart
+      end
+
+      Curl.easy_options(nil).each do |opt, props|
+        method_name = "#{opt}=".freeze
+        unless method_defined? method_name
+          define_method(method_name) do |value|
+            Curl.set_option(opt, value, handle)
+            value
+          end
+        end
+        next if props[:type] != :callback || method_defined?(opt)
+        define_method(opt) do |&block|
+          @procs ||= {}
+          @procs[opt.to_sym] = block
+          Curl.set_option(opt, block, handle)
+          nil
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.14.0/lib/ethon/easy/params.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'ethon/easy/util'
+require 'ethon/easy/queryable'
+
+module Ethon
+  class Easy
+
+    # This class represents HTTP request parameters.
+    #
+    # @api private
+    class Params
+      include Ethon::Easy::Util
+      include Ethon::Easy::Queryable
+
+      # Create a new Params.
+      #
+      # @example Create a new Params.
+      #   Params.new({})
+      #
+      # @param [ Hash ] params The params to use.
+      #
+      # @return [ Params ] A new Params.
+      def initialize(easy, params)
+        @easy = easy
+        @params = params || {}
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.14.0/lib/ethon/easy/queryable.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+
+    # This module contains logic about building
+    # query parameters for url or form.
+    module Queryable
+
+      # :nodoc:
+      def self.included(base)
+        base.send(:attr_accessor, :escape)
+        base.send(:attr_accessor, :params_encoding)
+      end
+
+      # Return wether there are elements in params or not.
+      #
+      # @example Return if params is empty.
+      #   form.empty?
+      #
+      # @return [ Boolean ] True if params is empty, else false.
+      def empty?
+        @params.empty?
+      end
+
+      # Return the string representation of params.
+      #
+      # @example Return string representation.
+      #   params.to_s
+      #
+      # @return [ String ] The string representation.
+      def to_s
+        @to_s ||= query_pairs.map{ |pair|
+          return pair if pair.is_a?(String)
+
+          if escape && @easy
+            pair.map{ |e| @easy.escape(e.to_s) }.join("=")
+          else
+            pair.join("=")
+          end
+        }.join('&')
+      end
+
+      # Return the query pairs.
+      #
+      # @example Return the query pairs.
+      #   params.query_pairs
+      #
+      # @return [ Array ] The query pairs.
+      def query_pairs
+        @query_pairs ||= build_query_pairs(@params)
+      end
+
+      # Return query pairs build from a hash.
+      #
+      # @example Build query pairs.
+      #   action.build_query_pairs({a: 1, b: 2})
+      #   #=> [[:a, 1], [:b, 2]]
+      #
+      # @param [ Hash ] hash The hash to go through.
+      #
+      # @return [ Array ] The array of query pairs.
+      def build_query_pairs(hash)
+        return [hash] if hash.is_a?(String)
+
+        pairs = []
+        recursively_generate_pairs(hash, nil, pairs)
+        pairs
+      end
+
+      # Return file info for a file.
+      #
+      # @example Return file info.
+      #   action.file_info(File.open('fubar', 'r'))
+      #
+      # @param [ File ] file The file to handle.
+      #
+      # @return [ Array ] Array of informations.
+      def file_info(file)
+        filename = File.basename(file.path)
+        [
+          filename,
+          mime_type(filename),
+          File.expand_path(file.path)
+        ]
+      end
+
+      private
+
+      def mime_type(filename)
+        if defined?(MIME) && t = MIME::Types.type_for(filename).first
+          t.to_s
+        else
+          'application/octet-stream'
+        end
+      end
+
+      def recursively_generate_pairs(h, prefix, pairs)
+        case h
+        when Hash
+          encode_hash_pairs(h, prefix, pairs)
+        when Array
+          if params_encoding == :rack
+            encode_rack_array_pairs(h, prefix, pairs)
+          elsif params_encoding == :multi
+            encode_multi_array_pairs(h, prefix, pairs)
+          elsif params_encoding == :none
+            pairs << [prefix, h]
+          else
+            encode_indexed_array_pairs(h, prefix, pairs)
+          end
+        end
+      end
+
+      def encode_hash_pairs(h, prefix, pairs)
+        h.each_pair do |k,v|
+          key = prefix.nil? ? k : "#{prefix}[#{k}]"
+          pairs_for(v, key, pairs)
+        end
+      end
+
+      def encode_indexed_array_pairs(h, prefix, pairs)
+        h.each_with_index do |v, i|
+          key = "#{prefix}[#{i}]"
+          pairs_for(v, key, pairs)
+        end
+      end
+
+      def encode_rack_array_pairs(h, prefix, pairs)
+        h.each do |v|
+          key = "#{prefix}[]"
+          pairs_for(v, key, pairs)
+        end
+      end
+
+    def encode_multi_array_pairs(h, prefix, pairs)
+      h.each_with_index do |v, i|
+        key = prefix
+        pairs_for(v, key, pairs)
+      end
+    end
+
+      def pairs_for(v, key, pairs)
+        case v
+        when Hash, Array
+          recursively_generate_pairs(v, key, pairs)
+        when File, Tempfile
+          pairs << [key, file_info(v)]
+        else
+          pairs << [key, v]
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.14.0/lib/ethon/easy/response_callbacks.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+
+    # This module contains the logic for the response callbacks.
+    # The on_complete callback is the only one at the moment.
+    #
+    # You can set multiple callbacks, which are then executed
+    # in the same order.
+    #
+    #   easy.on_complete { p 1 }
+    #   easy.on_complete { p 2 }
+    #   easy.complete
+    #   #=> 1
+    #   #=> 2
+    #
+    # You can clear the callbacks:
+    #
+    #   easy.on_complete { p 1 }
+    #   easy.on_complete { p 2 }
+    #   easy.on_complete.clear
+    #   easy.on_complete
+    #   #=> []
+    module ResponseCallbacks
+
+      # Set on_headers callback.
+      #
+      # @example Set on_headers.
+      #   request.on_headers { p "yay" }
+      #
+      # @param [ Block ] block The block to execute.
+      def on_headers(&block)
+        @on_headers ||= []
+        @on_headers << block if block_given?
+        @on_headers
+      end
+
+      # Execute on_headers callbacks.
+      #
+      # @example Execute on_headers.
+      #   request.headers
+      def headers
+        return if @headers_called
+        @headers_called = true
+        if defined?(@on_headers) and not @on_headers.nil?
+          @on_headers.each{ |callback| callback.call(self) }
+        end
+      end
+
+      # Set on_complete callback.
+      #
+      # @example Set on_complete.
+      #   request.on_complete { p "yay" }
+      #
+      # @param [ Block ] block The block to execute.
+      def on_complete(&block)
+        @on_complete ||= []
+        @on_complete << block if block_given?
+        @on_complete
+      end
+
+      # Execute on_complete callbacks.
+      #
+      # @example Execute on_completes.
+      #   request.complete
+      def complete
+        headers unless @response_headers.empty?
+        if defined?(@on_complete) and not @on_complete.nil?
+          @on_complete.each{ |callback| callback.call(self) }
+        end
+      end
+
+      # Set on_progress callback.
+      #
+      # @example Set on_progress.
+      #   request.on_progress {|dltotal, dlnow, ultotal, ulnow| p "#{dltotal} #{dlnow} #{ultotal} #{ulnow}" }
+      #
+      # @param [ Block ] block The block to execute.
+      def on_progress(&block)
+        @on_progress ||= []
+        if block_given?
+          @on_progress << block
+          set_progress_callback
+          self.noprogress = 0
+        end
+        @on_progress
+      end
+
+      # Execute on_progress callbacks.
+      #
+      # @example Execute on_progress.
+      #   request.body(1, 1, 1, 1)
+      def progress(dltotal, dlnow, ultotal, ulnow)
+        if defined?(@on_progress) and not @on_progress.nil?
+          @on_progress.each{ |callback| callback.call(dltotal, dlnow, ultotal, ulnow) }
+        end
+      end
+
+      # Set on_body callback.
+      #
+      # @example Set on_body.
+      #   request.on_body { |chunk| p "yay" }
+      #
+      # @param [ Block ] block The block to execute.
+      def on_body(&block)
+        @on_body ||= []
+        @on_body << block if block_given?
+        @on_body
+      end
+
+      # Execute on_body callbacks.
+      #
+      # @example Execute on_body.
+      #   request.body("This data came from HTTP.")
+      #
+      # @return [ Object ] If there are no on_body callbacks, returns the symbol :unyielded.
+      def body(chunk)
+        if defined?(@on_body) and not @on_body.nil?
+          result = nil
+          @on_body.each do |callback|
+            result = callback.call(chunk, self)
+            break if result == :abort
+          end
+          result
+        else
+          :unyielded
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.14.0/lib/ethon/easy/util.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy # :nodoc:
+
+    # This module contains small helpers.
+    #
+    # @api private
+    module Util
+
+      # Escapes zero bytes in strings.
+      #
+      # @example Escape zero bytes.
+      #   Util.escape_zero_byte("1\0")
+      #   #=> "1\\0"
+      #
+      # @param [ Object ] value The value to escape.
+      #
+      # @return [ String, Object ] Escaped String if
+      #   zero byte found, original object if not.
+      def escape_zero_byte(value)
+        return value unless value.to_s.include?(0.chr)
+        value.to_s.gsub(0.chr, '\\\0')
+      end
+
+      extend self
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.14.0/lib/ethon/errors.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require 'ethon/errors/ethon_error'
+require 'ethon/errors/global_init'
+require 'ethon/errors/multi_timeout'
+require 'ethon/errors/multi_fdset'
+require 'ethon/errors/multi_add'
+require 'ethon/errors/multi_remove'
+require 'ethon/errors/select'
+require 'ethon/errors/invalid_option'
+require 'ethon/errors/invalid_value'
+
+module Ethon
+
+  # This namespace contains all errors raised by ethon.
+  module Errors
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.14.0/lib/ethon/errors/ethon_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Default Ethon error class for all custom errors.
+    class EthonError < StandardError
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.14.0/lib/ethon/errors/global_init.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raises when global_init failed.
+    class GlobalInit < EthonError
+      def initialize
+        super("An error occured initializing curl.")
+      end
+    end
+  end
+end
+

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.14.0/lib/ethon/errors/invalid_option.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raises when option is invalid.
+    class InvalidOption < EthonError
+      def initialize(option)
+        super("The option: #{option} is invalid.")
+      end
+    end
+  end
+end
+