scnr-ethon 0.15.0

data/lib/ethon/easy/debug_info.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+
+    # This class is used to store and retreive debug information,
+    # which is only saved when verbose is set to true.
+    #
+    # @api private
+    class DebugInfo
+
+      MESSAGE_TYPES = Ethon::Curl::DebugInfoType.to_h.keys
+
+      class Message
+        attr_reader :type, :message
+
+        def initialize(type, message)
+          @type = type
+          @message = message
+        end
+      end
+
+      def initialize
+        @messages = []
+      end
+
+      def add(type, message)
+        @messages << Message.new(type, message)
+      end
+
+      def messages_for(type)
+        @messages.select {|m| m.type == type }.map(&:message)
+      end
+
+      MESSAGE_TYPES.each do |type|
+        eval %Q|def #{type}; messages_for(:#{type}); end|
+      end
+
+      def to_a
+        @messages.map(&:message)
+      end
+
+      def to_h
+        Hash[MESSAGE_TYPES.map {|k| [k, send(k)] }]
+      end
+    end
+  end
+end

data/lib/ethon/easy/features.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+
+    # This module contains class methods for feature checks
+    module Features
+      # Returns true if this curl version supports zlib.
+      #
+      # @example Return wether zlib is supported.
+      #   Ethon::Easy.supports_zlib?
+      #
+      # @return [ Boolean ] True if supported, else false.
+      def supports_zlib?
+        !!(Curl.version_info[:features] & Curl::VERSION_LIBZ)
+      end
+
+      # Returns true if this curl version supports AsynchDNS.
+      #
+      # @example
+      #   Ethon::Easy.supports_asynch_dns?
+      #
+      # @return [ Boolean ] True if supported, else false.
+      def supports_asynch_dns?
+        !!(Curl.version_info[:features] & Curl::VERSION_ASYNCHDNS)
+      end
+
+      alias :supports_timeout_ms? :supports_asynch_dns?
+
+    end
+  end
+end

data/lib/ethon/easy/form.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+require 'ethon/easy/util'
+require 'ethon/easy/queryable'
+
+module Ethon
+  class Easy
+
+    # This class represents a form and is used to send a payload in the
+    # request body via POST/PUT.
+    # It handles multipart forms, too.
+    #
+    # @api private
+    class Form
+      include Ethon::Easy::Util
+      include Ethon::Easy::Queryable
+
+      # Return a new Form.
+      #
+      # @example Return a new Form.
+      #   Form.new({})
+      #
+      # @param [ Hash ] params The parameter with which to initialize the form.
+      #
+      # @return [ Form ] A new Form.
+      def initialize(easy, params, multipart = nil)
+        @easy = easy
+        @params = params || {}
+        @multipart = multipart
+      end
+
+      # Return a pointer to the first form element in libcurl.
+      #
+      # @example Return the first form element.
+      #   form.first
+      #
+      # @return [ FFI::Pointer ] The first element.
+      def first
+        @first ||= FFI::MemoryPointer.new(:pointer)
+      end
+
+      # Return a pointer to the last form element in libcurl.
+      #
+      # @example Return the last form element.
+      #   form.last
+      #
+      # @return [ FFI::Pointer ] The last element.
+      def last
+        @last ||= FFI::MemoryPointer.new(:pointer)
+      end
+
+      # Return if form is multipart. The form is multipart
+      # when it contains a file or multipart option is set on the form during creation.
+      #
+      # @example Return if form is multipart.
+      #   form.multipart?
+      #
+      # @return [ Boolean ] True if form is multipart, else false.
+      def multipart?
+        return true if @multipart
+        query_pairs.any?{|pair| pair.respond_to?(:last) && pair.last.is_a?(Array)}
+      end
+
+      # Add form elements to libcurl.
+      #
+      # @example Add form to libcurl.
+      #   form.materialize
+      def materialize
+        query_pairs.each { |pair| form_add(pair.first.to_s, pair.last) }
+      end
+
+      private
+
+      def form_add(name, content)
+        case content
+        when Array
+          Curl.formadd(first, last,
+                       :form_option, :copyname, :pointer, name,
+                       :form_option, :namelength, :long, name.bytesize,
+                       :form_option, :file, :string, content[2],
+                       :form_option, :filename, :string, content[0],
+                       :form_option, :contenttype, :string, content[1],
+                       :form_option, :end
+                      )
+        else
+          Curl.formadd(first, last,
+                       :form_option, :copyname, :pointer, name,
+                       :form_option, :namelength, :long, name.bytesize,
+                       :form_option, :copycontents, :pointer, content.to_s,
+                       :form_option, :contentslength, :long, content ? content.to_s.bytesize : 0,
+                       :form_option, :end
+                      )
+        end
+
+        setup_garbage_collection
+      end
+
+      def setup_garbage_collection
+        # first is a pointer to a pointer. Since it's a MemoryPointer it will
+        # auto clean itself up, but we need to clean up the object it points
+        # to. So this results in (pseudo-c):
+        #   form_data_cleanup_handler = *first
+        #   curl_form_free(form_data_cleanup_handler)
+        @form_data_cleanup_handler ||= FFI::AutoPointer.new(@first.get_pointer(0), Curl.method(:formfree))
+      end
+    end
+  end
+end

data/lib/ethon/easy/header.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    # This module contains the logic around adding headers to libcurl.
+    #
+    # @api private
+    module Header
+      # Return headers, return empty hash if none.
+      #
+      # @example Return the headers.
+      #   easy.headers
+      #
+      # @return [ Hash ] The headers.
+      def headers
+        @headers ||= {}
+      end
+
+      # Set the headers.
+      #
+      # @example Set the headers.
+      #   easy.headers = {'User-Agent' => 'ethon'}
+      #
+      # @param [ Hash ] headers The headers.
+      def headers=(headers)
+        headers ||= {}
+        header_list = nil
+        headers.each do |k, v|
+          header_list = Curl.slist_append(header_list, compose_header(k,v))
+        end
+        Curl.set_option(:httpheader, header_list, handle)
+
+        @header_list = header_list && FFI::AutoPointer.new(header_list, Curl.method(:slist_free_all))
+      end
+
+      # Return header_list.
+      #
+      # @example Return header_list.
+      #   easy.header_list
+      #
+      # @return [ FFI::Pointer ] The header list.
+      def header_list
+        @header_list
+      end
+
+      # Compose libcurl header string from key and value.
+      # Also replaces null bytes, because libcurl will complain
+      # otherwise.
+      #
+      # @example Compose header.
+      #   easy.compose_header('User-Agent', 'Ethon')
+      #
+      # @param [ String ] key The header name.
+      # @param [ String ] value The header value.
+      #
+      # @return [ String ] The composed header.
+      def compose_header(key, value)
+        Util.escape_zero_byte("#{key}: #{value}")
+      end
+    end
+  end
+end

data/lib/ethon/easy/http/actionable.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+require 'ethon/easy/http/putable'
+require 'ethon/easy/http/postable'
+
+module Ethon
+  class Easy
+    module Http
+      # This module represents a Http Action and is a factory
+      # for more real actions like GET, HEAD, POST and PUT.
+      module Actionable
+
+        QUERY_OPTIONS = [ :params, :body, :params_encoding ]
+
+        # Create a new action.
+        #
+        # @example Create a new action.
+        #   Action.new("www.example.com", {})
+        #
+        # @param [ String ] url The url.
+        # @param [ Hash ] options The options.
+        #
+        # @return [ Action ] A new action.
+        def initialize(url, options)
+          @url = url
+          @options, @query_options = parse_options(options)
+        end
+
+        # Return the url.
+        #
+        # @example Return url.
+        #   action.url
+        #
+        # @return [ String ] The url.
+        def url
+          @url
+        end
+
+        # Return the options hash.
+        #
+        # @example Return options.
+        #   action.options
+        #
+        # @return [ Hash ] The options.
+        def options
+          @options
+        end
+
+        # Returns the query options hash.
+        #
+        # @example Return query options.
+        #   action.query_options
+        #
+        # @return [ Hash ] The query options.
+        def query_options
+          @query_options
+        end
+
+        # Return the params.
+        #
+        # @example Return params.
+        #   action.params
+        #
+        # @return [ Params ] The params.
+        def params
+          @params ||= Params.new(@easy, query_options.fetch(:params, nil))
+        end
+
+        # Return the form.
+        #
+        # @example Return form.
+        #   action.form
+        #
+        # @return [ Form ] The form.
+        def form
+          @form ||= Form.new(@easy, query_options.fetch(:body, nil), options.fetch(:multipart, nil))
+        end
+
+        # Get the requested array encoding. By default it's
+        # :typhoeus, but it can also be set to :rack.
+        #
+        # @example Get encoding from options
+        #   action.params_encoding
+        #
+        def params_encoding
+          @params_encoding ||= query_options.fetch(:params_encoding, :typhoeus)
+        end
+
+        # Setup everything necessary for a proper request.
+        #
+        # @example setup.
+        #   action.setup(easy)
+        #
+        # @param [ easy ] easy the easy to setup.
+        def setup(easy)
+          @easy = easy
+
+          # Order is important, @easy will be used to provide access to options
+          # relevant to the following operations (like whether or not to escape
+          # values).
+          easy.set_attributes(options)
+
+          set_form(easy) unless form.empty?
+
+          if params.empty?
+            easy.url = url
+          else
+            set_params(easy)
+          end
+        end
+
+        # Setup request with params.
+        #
+        # @example Setup nothing.
+        #   action.set_params(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def set_params(easy)
+          params.escape = easy.escape?
+          params.params_encoding = params_encoding
+
+          base_url, base_params = url.split('?')
+          base_url << '?'
+          base_url << base_params.to_s
+          base_url << '&' if base_params
+          base_url << params.to_s
+
+          easy.url = base_url
+        end
+
+        # Setup request with form.
+        #
+        # @example Setup nothing.
+        #   action.set_form(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def set_form(easy)
+        end
+
+        private
+
+        def parse_options(options)
+          query_options = {}
+          options = options.dup
+
+          QUERY_OPTIONS.each do |query_option|
+            if options.key?(query_option)
+              query_options[query_option] = options.delete(query_option)
+            end
+          end
+
+          return options, query_options
+        end
+      end
+    end
+  end
+end
+

data/lib/ethon/easy/http/custom.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Http
+
+      # This class knows everything about making requests for custom HTTP verbs.
+      class Custom
+        include Ethon::Easy::Http::Actionable
+        include Ethon::Easy::Http::Postable
+
+        def initialize(verb, url, options)
+          @verb = verb
+          super(url, options)
+        end
+
+        # Setup easy to make a request.
+        #
+        # @example Setup.
+        #   custom.set_params(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def setup(easy)
+          super
+          easy.customrequest = @verb
+        end
+      end
+    end
+  end
+end

data/lib/ethon/easy/http/delete.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Http
+
+      # This class knows everything about making DELETE requests.
+      class Delete
+        include Ethon::Easy::Http::Actionable
+        include Ethon::Easy::Http::Postable
+
+        # Setup easy to make a DELETE request.
+        #
+        # @example Setup customrequest.
+        #   delete.setup(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def setup(easy)
+          super
+          easy.customrequest = "DELETE"
+        end
+      end
+    end
+  end
+end
+

data/lib/ethon/easy/http/get.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Http
+
+      # This class knows everything about making GET requests.
+      class Get
+        include Ethon::Easy::Http::Actionable
+        include Ethon::Easy::Http::Postable
+
+        # Setup easy to make a GET request.
+        #
+        # @example Setup.
+        #   get.set_params(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def setup(easy)
+          super
+          easy.customrequest = "GET" unless form.empty?
+        end
+      end
+    end
+  end
+end

data/lib/ethon/easy/http/head.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Http
+
+      # This class knows everything about making HEAD requests.
+      class Head
+        include Ethon::Easy::Http::Actionable
+        include Ethon::Easy::Http::Postable
+
+        # Setup easy to make a HEAD request.
+        #
+        # @example Setup.
+        #   get.set_params(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def setup(easy)
+          super
+          easy.nobody = true
+        end
+      end
+    end
+  end
+end

data/lib/ethon/easy/http/options.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Http
+
+      # This class knows everything about making OPTIONS requests.
+      class Options
+        include Ethon::Easy::Http::Actionable
+        include Ethon::Easy::Http::Postable
+
+        # Setup easy to make a OPTIONS request.
+        #
+        # @example Setup.
+        #   options.setup(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def setup(easy)
+          super
+          easy.customrequest = "OPTIONS"
+        end
+      end
+    end
+  end
+end

data/lib/ethon/easy/http/patch.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Http
+
+      # This class knows everything about making PATCH requests.
+      class Patch
+        include Ethon::Easy::Http::Actionable
+        include Ethon::Easy::Http::Postable
+
+        # Setup easy to make a PATCH request.
+        #
+        # @example Setup.
+        #   patch.setup(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def setup(easy)
+          super
+          easy.customrequest = "PATCH"
+        end
+      end
+    end
+  end
+end

data/lib/ethon/easy/http/post.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Http
+      # This class knows everything about making POST requests.
+      class Post
+        include Ethon::Easy::Http::Actionable
+        include Ethon::Easy::Http::Postable
+
+        # Setup easy to make a POST request.
+        #
+        # @example Setup.
+        #   post.setup(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def setup(easy)
+          super
+          if form.empty?
+            easy.postfieldsize = 0
+            easy.copypostfields = ""
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ethon/easy/http/postable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Http
+
+      # This module contains logic for setting up a [multipart] POST body.
+      module Postable
+
+        # Set things up when form is provided.
+        # Deals with multipart forms.
+        #
+        # @example Setup.
+        #   post.set_form(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def set_form(easy)
+          easy.url ||= url
+          form.params_encoding = params_encoding
+          if form.multipart?
+            form.escape = false
+            form.materialize
+            easy.httppost = form.first.read_pointer
+          else
+            form.escape = easy.escape?
+            easy.postfieldsize = form.to_s.bytesize
+            easy.copypostfields = form.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ethon/easy/http/put.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Http
+
+      # This class knows everything about making PUT requests.
+      class Put
+        include Ethon::Easy::Http::Actionable
+        include Ethon::Easy::Http::Putable
+
+        # Setup easy to make a PUT request.
+        #
+        # @example Setup.
+        #   put.setup(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def setup(easy)
+          super
+          if form.empty?
+            easy.upload = true
+            easy.infilesize = 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ethon/easy/http/putable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Http
+
+      # This module contains logic about setting up a PUT body.
+      module Putable
+        # Set things up when form is provided.
+        # Deals with multipart forms.
+        #
+        # @example Setup.
+        #   put.set_form(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def set_form(easy)
+          easy.upload = true
+          form.escape = true
+          form.params_encoding = params_encoding
+          easy.infilesize = form.to_s.bytesize
+          easy.set_read_callback(form.to_s)
+        end
+      end
+    end
+  end
+end