dagger 1.9.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 692b25152c7fd3229ad3dc13bd25250b613e55a211e489b8835258b18405db19
-  data.tar.gz: 5560f64e580e4f72f9e243eaf1c5eed1b389e439074607dc24bdd8fbe9c532f0
+  metadata.gz: 447d77e66ec69445f5040231d19c038279d4ec7de624461deda078c544423ca9
+  data.tar.gz: c5eb814e71fd6a37b3b4272f6f747654eeb157655dec65ae6ec6f0cf86d4e5ff
 SHA512:
-  metadata.gz: 85d160f0130c12fde8b2723cd54bcaf4a75c4f48319cb040c4725a93e6cc09d4f8a68a7977135f33c38922583cc8de481bc078ea6d3ff5636c42c3154a5dca74
-  data.tar.gz: 9bd29716a9e84b75e898f71b00e8fc145550fcccd15b2c0006172e56e3e5454b62668bc4536dacde371a33b429f437a942354368de4cce0394ff73296cefa8e8
+  metadata.gz: 31108057fbc3cd1d2e0c319d4c64244c596cbbb90d8ae6067945caedb2f8f7ff5c0fd144b16be55ac24cd36bbd466f08659b995b47ecd67425d26224bd505ede
+  data.tar.gz: d996eaefa87c30682eb127d9f2f28cbb28363fcf2a2f758e32610d553937c05a35750316f043a6f4d2a9eb6727aad8f0351ca761ee62b326313b46e902764fd2

data/lib/dagger/version.rb

@@ -1,6 +1,6 @@
 module Dagger
-  MAJOR = 1
-  MINOR = 9
+  MAJOR = 2
+  MINOR = 0
   PATCH = 0
 
   VERSION = [MAJOR, MINOR, PATCH].join('.')

data/lib/dagger.rb

@@ -42,18 +42,28 @@ module Dagger
     def self.resolve_uri(uri, host = nil, query = nil)
       uri = host + uri if uri[0] == '/' && host
       uri = parse_uri(uri.to_s)
-      uri.path.sub!(/\?.*|$/, '?' + Utils.encode(query)) if query and query.any?
+      uri.path.sub!(/\?.*|$/, '?' + to_query_string(query)) if query and query.any?
       uri
     end
 
-    def self.encode(obj, key = nil)
+    def self.encode_body(obj, opts = {})
+      if obj.is_a?(String)
+        obj
+      elsif opts[:json]
+        Oj.dump(obj, mode: :compat) # compat ensures symbols are converted to strings
+      else
+        to_query_string(obj)
+      end
+    end
+
+    def self.to_query_string(obj, key = nil)
       if key.nil? && obj.is_a?(String) # && obj['=']
         return obj
       end
 
       case obj
-      when Hash  then obj.map { |k, v| encode(v, append_key(key,k)) }.join('&')
-      when Array then obj.map { |v| encode(v, "#{key}[]") }.join('&')
+      when Hash  then obj.map { |k, v| to_query_string(v, append_key(key, k)) }.join('&')
+      when Array then obj.map { |v| to_query_string(v, "#{key}[]") }.join('&')
       when nil   then ''
       else
         "#{key}=#{ERB::Util.url_encode(obj.to_s)}"
@@ -119,6 +129,7 @@ module Dagger
       opts[:follow] = 10 if opts[:follow] == true
       headers = opts[:headers] || {}
       headers['Accept'] = 'application/json' if opts[:json] && headers['Accept'].nil?
+      headers['Content-Type'] = 'application/json' if opts[:json] && opts[:body]
 
       if opts[:ip]
         headers['Host'] = uri.host
@@ -127,6 +138,7 @@ module Dagger
 
       request = Net::HTTP::Get.new(uri, DEFAULT_HEADERS.merge(headers))
       request.basic_auth(opts.delete(:username), opts.delete(:password)) if opts[:username]
+      request.body = Utils.encode_body(opts[:body], opts) if opts[:body]
 
       if @http.respond_to?(:started?) # regular Net::HTTP
         @http.start unless @http.started?
@@ -137,7 +149,7 @@ module Dagger
 
       if REDIRECT_CODES.include?(resp.code.to_i) && resp['Location'] && (opts[:follow] && opts[:follow] > 0)
         opts[:follow] -= 1
-        debug "Following redirect to #{resp['Location']}"
+        debug { "Following redirect to #{resp['Location']}" }
         return get(resp['Location'], opts)
       end
 
@@ -148,7 +160,7 @@ module Dagger
       SocketError, EOFError, OpenSSL::SSL::SSLError => e
 
       if retries = opts[:retries] and retries.to_i > 0
-        debug "Got #{e.class}! Retrying in a sec (#{retries} retries left)"
+        debug { "Got #{e.class}! Retrying in a sec (#{retries} retries left)" }
         sleep (opts[:retry_wait] || DEFAULT_RETRY_WAIT)
         get(uri, opts.merge(retries: retries - 1))
       else
@@ -174,45 +186,44 @@ module Dagger
 
     def request(method, uri, data, opts = {})
       if method.to_s.downcase == 'get'
-        query = (opts[:query] || {}).merge(data || {})
-        return get(uri, opts.merge(query: query))
+        data ||= opts[:body]
+        return get(uri, opts.merge(body: data))
       end
 
-      uri = Utils.resolve_uri(uri, @host)
+      uri = Utils.resolve_uri(uri, @host, opts[:query])
       if @host != uri.scheme_and_host
         raise ArgumentError.new("#{uri.scheme_and_host} does not match #{@host}")
       end
 
       headers = DEFAULT_HEADERS.merge(opts[:headers] || {})
-
-      query = if data.is_a?(String)
-        data
-      elsif opts[:json]
-        headers['Content-Type'] = 'application/json'
-        headers['Accept'] = 'application/json' if headers['Accept'].nil?
-        Oj.dump(data, mode: :compat) # compat ensures symbols are converted to strings
-      else # querystring, then
-        Utils.encode(data)
-      end
+      body = Utils.encode_body(data, opts)
 
       if opts[:username] # opts[:password] is optional
         str = [opts[:username], opts[:password]].compact.join(':')
         headers['Authorization'] = 'Basic ' + Base64.encode64(str)
       end
 
+      if opts[:json]
+        headers['Content-Type'] = 'application/json'
+        headers['Accept'] = 'application/json' if headers['Accept'].nil?
+      end
+
+      start = Time.now
+      debug { "Sending #{method} request to #{uri.request_uri} with headers #{headers.inspect} -- #{query}" }
+
       if @http.respond_to?(:started?) # regular Net::HTTP
-        args = [method.to_s.downcase, uri.path, query, headers]
+        args = [method.to_s.downcase, uri.request_uri, body, headers]
         args.delete_at(2) if args[0] == 'delete' # Net::HTTP's delete does not accept data
 
         @http.start unless @http.started?
         resp, data = @http.send(*args)
       else # Net::HTTP::Persistent
-        req = Kernel.const_get("Net::HTTP::#{method.capitalize}").new(uri.path, headers)
-        # req.set_form_data(query)
-        req.body = query
+        req = Kernel.const_get("Net::HTTP::#{method.capitalize}").new(uri.request_uri, headers)
+        req.body = body
         resp, data = @http.send_request(uri, req)
       end
 
+      debug { "Got response #{resp.code} in #{(Time.now - start).round(2)}s: #{data || resp.body}" }
       @response = build_response(resp, data || resp.body)
 
     rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EINVAL, Timeout::Error, \
@@ -220,7 +231,7 @@ module Dagger
       SocketError, EOFError, OpenSSL::SSL::SSLError => e
 
       if method.to_s.downcase != 'get' && retries = opts[:retries] and retries.to_i > 0
-        debug "[#{DAGGER_NAME}] Got #{e.class}! Retrying in a sec (#{retries} retries left)"
+        debug { "Got #{e.class}! Retrying in a sec (#{retries} retries left)" }
         sleep (opts[:retry_wait] || DEFAULT_RETRY_WAIT)
         request(method, uri, data, opts.merge(retries: retries - 1))
       else
@@ -252,8 +263,16 @@ module Dagger
 
     private
 
-    def debug(str)
-      puts str if ENV['DEBUGGING']
+    def debug(&block)
+      if ENV['DEBUGGING'] || ENV['DEBUG']
+        str = yield
+        logger.info "[#{DAGGER_NAME}] #{str}"
+      end
+    end
+
+    def logger
+      require 'logger'
+      @logger ||= Logger.new(@logfile || STDOUT)
     end
 
     def build_response(resp, body)

data/spec/persistent_spec.rb

@@ -6,25 +6,28 @@ require 'rspec/expectations'
 describe 'Persistent mode' do
 
   it 'works' do
-    fake_client = double('Client')
-    expect(Dagger::Client).to receive(:new).once.and_return(fake_client)
-    expect(fake_client).to receive(:open).once #.and_return(fake_resp)
-    expect(fake_client).to receive(:close).once #.and_return(fake_resp)
+    # fake_client = double('Client')
+    # expect(Dagger::Client).to receive(:new).once.and_return(fake_client)
+    # expect(fake_client).to receive(:open).once #.and_return(fake_resp)
+    # expect(fake_client).to receive(:close).once #.and_return(fake_resp)
 
+    res1, res2 = nil, nil
     obj = Dagger.open('https://www.google.com') do
-      get('/search?q=dagger+http+client')
-      get('google.com/search?q=thank+you+ruby')
+      res1 = get('/search?q=dagger+http+client', { body: 'foo' })
+      res2 = get('https://www.google.com/search?q=thank+you+ruby')
+      res3 = post('https://www.google.com/search?q=foobar', { foo: 'bar' })
     end
+
+    expect(res1.code).to eq(400)
+    expect(res2.code).to eq(200)
+    expect(res2.code).to eq(200)
+    expect(obj).to be_a(Dagger::Client)
   end
 
 end
 
 describe 'using threads' do
 
-  def get(url)
-    @http.get(url)
-  end
-
   def connect(host)
     raise if @http
     @http = Dagger.open(host)
@@ -49,7 +52,7 @@ describe 'using threads' do
         # mutex.synchronize { Dagger.open(host) }
         http = Dagger.open(host)
         while url = mutex.synchronize { urls.pop }
-          puts "Fetching #{url}"
+          # puts "Fetching #{url}"
           resp = http.get(url)
           mutex.synchronize do
             result.push(resp.code)

data/spec/sending_data_spec.rb

@@ -0,0 +1,19 @@
+require './lib/dagger'
+
+require 'rspec/mocks'
+require 'rspec/expectations'
+
+describe 'sending data' do
+
+  it 'works with get if using .request' do
+    resp = Dagger.request('get', 'https://httpbingo.org/get?x=123', { foo: 'bar', testing: 1 }, { json: true })
+    expect(resp.ok?).to eq(true)
+  end
+
+  it 'works with get if passing body as option' do
+    resp = Dagger.get('https://httpbingo.org/get?x=123', { body: { foo: 'bar', testing: 1 }, json: true })
+    expect(resp.ok?).to eq(true)
+  end
+
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dagger
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Tomás Pollak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-11 00:00:00.000000000 Z
+date: 2021-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -120,6 +120,7 @@ files:
 - spec/ip_connect_spec.rb
 - spec/parsers_spec.rb
 - spec/persistent_spec.rb
+- spec/sending_data_spec.rb
 homepage: https://github.com/tomas/dagger
 licenses: []
 metadata: {}