rest-man 1.0.0 → 1.1.0

data/lib/restman/payload.rb

@@ -1,13 +1,4 @@
-require 'tempfile'
-require 'securerandom'
-require 'stringio'
-
-begin
-  # Use mime/types/columnar if available, for reduced memory usage
-  require 'mime/types/columnar'
-rescue LoadError
-  require 'mime/types'
-end
+require 'mime/types/columnar'
 
 module RestMan
   module Payload
@@ -15,220 +6,47 @@ module RestMan
 
     def generate(params)
       if params.is_a?(RestMan::Payload::Base)
-        # pass through Payload objects unchanged
         params
+
       elsif params.is_a?(String)
         Base.new(params)
+
       elsif params.is_a?(Hash)
         if params.delete(:multipart) == true || has_file?(params)
           Multipart.new(params)
+
         else
           UrlEncoded.new(params)
         end
+
       elsif params.is_a?(ParamsArray)
-        if _has_file?(params)
+        if has_file?(params)
           Multipart.new(params)
+
         else
           UrlEncoded.new(params)
+
         end
       elsif params.respond_to?(:read)
         Streamed.new(params)
+
       else
         nil
       end
     end
 
-    def has_file?(params)
-      unless params.is_a?(Hash)
-        raise ArgumentError.new("Must pass Hash, not #{params.inspect}")
-      end
-      _has_file?(params)
-    end
-
-    def _has_file?(obj)
+    def has_file?(obj)
       case obj
       when Hash, ParamsArray
-        obj.any? {|_, v| _has_file?(v) }
+        obj.any? {|_, v| has_file?(v) }
+
       when Array
-        obj.any? {|v| _has_file?(v) }
+        obj.any? {|v| has_file?(v) }
+
       else
         obj.respond_to?(:path) && obj.respond_to?(:read)
       end
     end
 
-    class Base
-      def initialize(params)
-        build_stream(params)
-      end
-
-      def build_stream(params)
-        @stream = StringIO.new(params)
-        @stream.seek(0)
-      end
-
-      def read(*args)
-        @stream.read(*args)
-      end
-
-      def to_s
-        result = read
-        @stream.seek(0)
-        result
-      end
-
-      def headers
-        {'Content-Length' => size.to_s}
-      end
-
-      def size
-        @stream.size
-      end
-
-      alias :length :size
-
-      def close
-        @stream.close unless @stream.closed?
-      end
-
-      def closed?
-        @stream.closed?
-      end
-
-      def to_s_inspect
-        to_s.inspect
-      end
-
-      def short_inspect
-        if size && size > 500
-          "#{size} byte(s) length"
-        else
-          to_s_inspect
-        end
-      end
-
-    end
-
-    class Streamed < Base
-      def build_stream(params = nil)
-        @stream = params
-      end
-
-      def size
-        if @stream.respond_to?(:size)
-          @stream.size
-        elsif @stream.is_a?(IO)
-          @stream.stat.size
-        end
-      end
-
-      # TODO (breaks compatibility): ought to use mime_for() to autodetect the
-      # Content-Type for stream objects that have a filename.
-
-      alias :length :size
-    end
-
-    class UrlEncoded < Base
-      def build_stream(params = nil)
-        @stream = StringIO.new(Utils.encode_query_string(params))
-        @stream.seek(0)
-      end
-
-      def headers
-        super.merge({'Content-Type' => 'application/x-www-form-urlencoded'})
-      end
-    end
-
-    class Multipart < Base
-      EOL = "\r\n"
-
-      def build_stream(params)
-        b = '--' + boundary
-
-        @stream = Tempfile.new('rest-man.multipart.')
-        @stream.binmode
-        @stream.write(b + EOL)
-
-        case params
-        when Hash, ParamsArray
-          x = Utils.flatten_params(params)
-        else
-          x = params
-        end
-
-        last_index = x.length - 1
-        x.each_with_index do |a, index|
-          k, v = * a
-          if v.respond_to?(:read) && v.respond_to?(:path)
-            create_file_field(@stream, k, v)
-          else
-            create_regular_field(@stream, k, v)
-          end
-          @stream.write(EOL + b)
-          @stream.write(EOL) unless last_index == index
-        end
-        @stream.write('--')
-        @stream.write(EOL)
-        @stream.seek(0)
-      end
-
-      def create_regular_field(s, k, v)
-        s.write("Content-Disposition: form-data; name=\"#{k}\"")
-        s.write(EOL)
-        s.write(EOL)
-        s.write(v)
-      end
-
-      def create_file_field(s, k, v)
-        begin
-          s.write("Content-Disposition: form-data;")
-          s.write(" name=\"#{k}\";") unless (k.nil? || k=='')
-          s.write(" filename=\"#{v.respond_to?(:original_filename) ? v.original_filename : File.basename(v.path)}\"#{EOL}")
-          s.write("Content-Type: #{v.respond_to?(:content_type) ? v.content_type : mime_for(v.path)}#{EOL}")
-          s.write(EOL)
-          while (data = v.read(8124))
-            s.write(data)
-          end
-        ensure
-          v.close if v.respond_to?(:close)
-        end
-      end
-
-      def mime_for(path)
-        mime = MIME::Types.type_for path
-        mime.empty? ? 'text/plain' : mime[0].content_type
-      end
-
-      def boundary
-        return @boundary if defined?(@boundary) && @boundary
-
-        # Use the same algorithm used by WebKit: generate 16 random
-        # alphanumeric characters, replacing `+` `/` with `A` `B` (included in
-        # the list twice) to round out the set of 64.
-        s = SecureRandom.base64(12)
-        s.tr!('+/', 'AB')
-
-        @boundary = '----RubyFormBoundary' + s
-      end
-
-      # for Multipart do not escape the keys
-      #
-      # Ostensibly multipart keys MAY be percent encoded per RFC 7578, but in
-      # practice no major browser that I'm aware of uses percent encoding.
-      #
-      # Further discussion of multipart encoding:
-      # https://github.com/rest-man/rest-man/pull/403#issuecomment-156976930
-      #
-      def handle_key key
-        key
-      end
-
-      def headers
-        super.merge({'Content-Type' => %Q{multipart/form-data; boundary=#{boundary}}})
-      end
-
-      def close
-        @stream.close!
-      end
-    end
   end
 end

data/lib/restman/platform.rb

@@ -2,28 +2,12 @@ require 'rbconfig'
 
 module RestMan
   module Platform
-    # Return true if we are running on a darwin-based Ruby platform. This will
-    # be false for jruby even on OS X.
-    #
-    # @return [Boolean]
+    # :include: _doc/lib/restman/platform/mac_mri?.rdoc
     def self.mac_mri?
       RUBY_PLATFORM.include?('darwin')
     end
 
-    # Return true if we are running on Windows.
-    #
-    # @return [Boolean]
-    #
-    def self.windows?
-      # Ruby only sets File::ALT_SEPARATOR on Windows, and the Ruby standard
-      # library uses that to test what platform it's on.
-      !!File::ALT_SEPARATOR
-    end
-
-    # Return true if we are running on jruby.
-    #
-    # @return [Boolean]
-    #
+    # :include: _doc/lib/restman/platform/jruby?.rdoc
     def self.jruby?
       # defined on mri >= 1.9
       RUBY_ENGINE == 'jruby'

data/lib/restman/raw_response.rb

@@ -1,14 +1,5 @@
 module RestMan
-  # The response from RestMan on a raw request looks like a string, but is
-  # actually one of these.  99% of the time you're making a rest call all you
-  # care about is the body, but on the occasion you want to fetch the
-  # headers you can:
-  #
-  #   RestMan.get('http://example.com').headers[:content_type]
-  #
-  # In addition, if you do not use the response as a string, you can access
-  # a Tempfile object at res.file, which contains the path to the raw
-  # downloaded request body.
+  # :include: _doc/lib/restman/raw_response.rdoc
   class RawResponse
 
     include AbstractResponse
@@ -19,10 +10,7 @@ module RestMan
       "<RestMan::RawResponse @code=#{code.inspect}, @file=#{file.inspect}, @request=#{request.inspect}>"
     end
 
-    # @param [Tempfile] tempfile The temporary file containing the body
-    # @param [Net::HTTPResponse] net_http_res
-    # @param [RestMan::Request] request
-    # @param [Time] start_time
+    # :include: _doc/lib/restman/raw_response/new.rdoc
     def initialize(tempfile, net_http_res, request, start_time=nil)
       @file = tempfile
 

data/lib/restman/request/default_ssl_cert_store.rb

@@ -0,0 +1,13 @@
+module RestMan
+  class Request
+    class DefaultSSLCertStore < ActiveMethod::Base
+
+      def call
+        cert_store = OpenSSL::X509::Store.new
+        cert_store.set_default_paths
+        cert_store
+      end
+
+    end
+  end
+end

data/lib/restman/request/fetch_body_to_tempfile.rb

@@ -0,0 +1,58 @@
+module RestMan
+  class Request
+    class FetchBodyToTempfile < ActiveMethod::Base
+
+      argument :http_response
+
+      def call
+        # Taken from Chef, which as in turn...
+        # Stolen from http://www.ruby-forum.com/topic/166423
+        # Kudos to _why!
+        tf = Tempfile.new('rest-man.')
+        tf.binmode
+
+        size = 0
+        total = http_response['Content-Length'].to_i
+        stream_log_bucket = nil
+
+        http_response.read_body do |chunk|
+          tf.write chunk
+          size += chunk.size
+          if log
+            if total == 0
+              log << "streaming %s %s (%d of unknown) [0 Content-Length]\n" % [method.upcase, url, size]
+            else
+              percent = (size * 100) / total
+              current_log_bucket, _ = percent.divmod(stream_log_percent)
+              if current_log_bucket != stream_log_bucket
+                stream_log_bucket = current_log_bucket
+                log << "streaming %s %s %d%% done (%d of %d)\n" % [method.upcase, url, (size * 100) / total, size, total]
+              end
+            end
+          end
+        end
+        tf.close
+        tf
+      end
+
+      private
+
+      def log
+        request.log
+      end
+
+      def method
+        request.method
+      end
+
+      def url
+        request.url
+      end
+
+      def stream_log_percent
+        request.stream_log_percent
+      end
+
+    end
+  end
+end

data/lib/restman/request/init/cookie_jar.rb

@@ -0,0 +1,65 @@
+module RestMan
+  class Request
+    module Init
+      # :include: _doc/lib/restman/request/init/cookie_jar.rdoc
+      class CookieJar < ActiveMethod::Base
+
+        argument :uri
+        argument :headers
+        argument :args
+
+        def call
+          duplicated_cookies_check
+          return cookies.dup if cookies.is_a?(HTTP::CookieJar)
+
+          cookies.each do |key, value|
+            cookie_jar.add cookie(key, value)
+          end
+
+          cookie_jar
+        end
+
+        private
+
+        # Avoid ambiguity in whether options from headers or options from
+        # Request#initialize should take precedence by raising ArgumentError when
+        # both are present. Prior versions of rest-man claimed to give
+        # precedence to init options, but actually gave precedence to headers.
+        # Avoid that mess by erroring out instead.
+        def duplicated_cookies_check
+          if headers[:cookies] && args[:cookies]
+            raise ArgumentError.new(
+              "Cannot pass :cookies in Request.new() and in headers hash at the same time")
+          end
+        end
+
+        def cookies
+          @cookies ||= headers.delete(:cookies) || args[:cookies] || []
+        end
+
+        # Support for Array<HTTP::Cookie> mode:
+        # If key is a cookie object, add it to the jar directly and assert that
+        # there is no separate val.
+        def cookie(key, value)
+          if key.is_a?(HTTP::Cookie)
+            raise ArgumentError.new("extra cookie val: #{value.inspect}") if value
+
+            key # cookie
+          else
+            HTTP::Cookie.new(
+              key.to_s, value,
+              domain: uri.hostname.downcase,
+              path: '/',
+              for_domain: true
+            )
+          end
+        end
+
+        def cookie_jar
+          @cookie_jar ||= HTTP::CookieJar.new
+        end
+
+      end
+    end
+  end
+end

data/lib/restman/request/init/ssl_opts.rb

@@ -0,0 +1,70 @@
+module RestMan
+  class Request
+    module Init
+      class SSLOpts < ActiveMethod::Base
+
+        argument :args
+        argument :uri
+
+        def call
+          ssl_opts[:verify_ssl] = verify_ssl
+ 
+          Request::SSLOptionList.each do |key|
+            ssl_key = ('ssl_' + key).to_sym
+
+            if args.key?(ssl_key)
+              ssl_opts[key.to_sym] = args.fetch(ssl_key)
+            end
+          end
+    
+          set_cert_store
+
+          ssl_opts
+        end
+
+        private
+
+        def verify_ssl
+          return default_ssl_verify unless args.key?(:verify_ssl)
+          return ssl_verify_none unless args[:verify_ssl]
+
+          if args[:verify_ssl] == true
+            default_ssl_verify 
+          else
+            args[:verify_ssl]
+          end
+        end
+
+        def default_ssl_verify
+          ssl_verify_peer
+        end
+
+        def ssl_verify_peer
+          OpenSSL::SSL::VERIFY_PEER
+        end
+
+        def ssl_verify_none
+          OpenSSL::SSL::VERIFY_NONE
+        end
+
+        def set_cert_store
+          return unless use_ssl?
+    
+          # If there's no CA file, CA path, or cert store provided, use default
+          if !ssl_opts[:ca_file] && !ssl_opts[:ca_path] && !ssl_opts.include?(:cert_store)
+            ssl_opts[:cert_store] = Request.default_ssl_cert_store
+          end
+        end
+
+        def use_ssl?
+          uri.is_a?(URI::HTTPS)
+        end
+
+        def ssl_opts
+          @ssl_opts ||= {}
+        end
+
+      end
+    end
+  end
+end

data/lib/restman/request/init/url/add_query_from_headers.rb

@@ -0,0 +1,51 @@
+module RestMan
+  class Request
+    module Init
+      class Url
+        class AddQueryFromHeaders < ActiveMethod::Base
+
+          argument :url
+          argument :headers
+
+          def call
+            url_params = params_from_headers
+
+            if url_params && !url_params.empty?
+              query_string = RestMan::Utils.encode_query_string(url_params)
+
+              if url.include?('?')
+                url + "&#{query_string}"
+              else
+                url + "?#{query_string}"
+              end
+            else
+              url
+            end
+          end
+
+          private
+
+          def params_from_headers
+            params = nil
+
+            # find and extract/remove "params" key if the value is a Hash/ParamsArray
+            headers.delete_if do |key, value|
+              if key.to_s.downcase == 'params' && (value.is_a?(Hash) || value.is_a?(RestMan::ParamsArray))
+                if params
+                  raise ArgumentError.new("Multiple 'params' options passed")
+                end
+                params = value
+                true
+              else
+                false
+              end
+            end
+
+            params
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/restman/request/init/url/normalize_url.rb

@@ -0,0 +1,19 @@
+module RestMan
+  class Request
+    module Init
+      class Url
+        class NormalizeUrl < ActiveMethod::Base
+          argument :url
+
+          def call
+            if url.match(%r{\A[a-z][a-z0-9+.-]*://}i)
+              url
+            else
+              "http://#{url}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restman/request/init/url.rb

@@ -0,0 +1,40 @@
+module RestMan
+  class Request
+    module Init
+      class Url < ActiveMethod::Base
+
+        autoload :AddQueryFromHeaders, "restman/request/init/url/add_query_from_headers"
+        autoload :NormalizeUrl, "restman/request/init/url/normalize_url"
+
+        argument :args
+        argument :headers
+
+        attr_accessor :url
+
+        def call
+          raise ArgumentError, "must pass :url" unless url
+
+          add_http_scheme
+          add_query_from_headers
+
+          url
+        end
+
+        private
+
+        def add_http_scheme
+          self.url = NormalizeUrl.call(url)
+        end
+
+        def add_query_from_headers
+          self.url = AddQueryFromHeaders.call(url, headers)
+        end
+
+        def url
+          @url ||= args[:url].dup
+        end
+
+      end
+    end
+  end
+end