dagger 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 554b365474524830ac1017cac8b57354d8fed85a
-  data.tar.gz: be62ee9a3bab4868326fb4cf15db03776e0591bf
+  metadata.gz: 212d001704ff60792d0e250469c8271d0ccbdc77
+  data.tar.gz: fecce54d5ca8b521df7ee101d1a7f01797562034
 SHA512:
-  metadata.gz: f03630f6ccd2603de2aa87cca29987a08dd3de8190ea4eb85820b0a46a3735287a1da5b9c704cd8d6d6d644a7e209c7b4d4c56144117839fb6b71ab630b66937
-  data.tar.gz: 4dbc25a2e30be77ec37e29e2ecd240a01871e2fa56420524a21aa48c643892289f9f16715e433e7c2cab36bf5bb1616be4109fb57deaf972f18432ebf94dc970
+  metadata.gz: 10e9e8a85477e41656a1b7c28b797092903fa017fbe0764504d3bbc5271e170b62929915e24744203c37cbd5f1f2622814dc63395d7d277acad556ca42ca5ff3
+  data.tar.gz: a0aafed3e61cdf7e720436fd48ce1ee8dcd203d9806bec82746d4a4e09d8cb6379c5c61911468edbffd0a0f3da6d8a4d67d38c43d3d98a758a1c83269a8427fb

data/Gemfile

@@ -1,4 +1,4 @@
-source :rubygems
+source 'https://rubygems.org'
 
 # specified in tuktuk.gemspec
 gemspec

data/lib/dagger.rb

@@ -10,117 +10,157 @@ module Dagger
 
   REDIRECT_CODES  = [301, 302, 303].freeze
   DEFAULT_HEADERS = {
-    'Accept' => '*/*',
+    'Accept'     => '*/*',
     'User-Agent' => "Dagger/#{VERSION} (Ruby Net::HTTP Wrapper, like curl)"
   }
 
-  def self.get(uri, query = nil, opts = {})
-    opts[:follow] = 10 if opts[:follow] == true
+  module Utils
 
-    uri       = parse_uri(uri)
-    uri.query = encode(query) if query
-    http      = client(uri, opts)
-    request   = Net::HTTP::Get.new(uri.request_uri, DEFAULT_HEADERS.merge(opts[:headers] || {}))
-
-    if opts[:username] # && opts[:password]
-      request.basic_auth(opts.delete(:username), opts.delete(:password))
+    def self.parse_uri(uri)
+      uri = 'http://' + uri unless uri.to_s['http']
+      uri = URI.parse(uri)
+      raise ArgumentError.new("Invalid URI: #{uri}") unless uri.is_a?(URI::HTTP)
+      uri.path = '/' if uri.path == ''
+      uri
     end
 
-    resp, data = http.request(request)
+    def self.encode(value, key = nil)
+      case value
+      when Hash  then value.map { |k,v| encode(v, append_key(key,k)) }.join('&')
+      when Array then value.map { |v| encode(v, "#{key}[]") }.join('&')
+      when nil   then ''
+      else
+        "#{key}=#{URI.escape(value.to_s)}"
+      end
+    end
 
-    if REDIRECT_CODES.include?(resp.code.to_i) && resp['Location'] && (opts[:follow] && opts[:follow] > 0)
-      opts[:follow] -= 1
-      return get(resp['Location'], nil, opts)
+    def self.append_key(root_key, key)
+      root_key.nil? ? key : "#{root_key}[#{key.to_s}]"
     end
 
-    build_response(resp, data || resp.body) # 1.8 vs 1.9 style responses
   end
 
-  def self.post(uri, params = {}, options = {})
-    send_request('post', uri, params, options)
-  end
+  class Client
 
-  def self.put(uri, params = {}, options = {})
-    send_request('put', uri, params, options)
-  end
+    def self.init(uri, opts)
+      uri  = Utils.parse_uri(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
 
-  def self.delete(uri, params = {}, options = {})
-    send_request('delete', uri, params, options)
-  end
+      if uri.port == 443
+        http.use_ssl = true
+        http.verify_mode = opts[:verify_ssl] === false ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+      end
 
-  def self.request(method, url, params = {}, options = {})
-    return get(url, params, options) if method.to_s.downcase == 'get'
-    send_request(method.to_s.downcase, url, params, options)
-  end
+      [:open_timeout, :read_timeout, :ssl_version, :ciphers].each do |key|
+        http.send("#{key}=", opts[key]) if opts.has_key?(key)
+      end
+
+      new(http)
+    end
+
+    def initialize(http)
+      @http = http
+    end
+
+    def get(uri, opts = {})
+      opts[:follow] = 10 if opts[:follow] == true
+
+      path = uri[0] == '/' ? uri : Utils.parse_uri(uri)
+      path.sub!(/\?.*|$/, '?' + Utils.encode(opts[:query])) if opts[:query]
+
+      request = Net::HTTP::Get.new(path, DEFAULT_HEADERS.merge(opts[:headers] || {}))
+      request.basic_auth(opts.delete(:username), opts.delete(:password)) if opts[:username]
+
+      @resp, @data = @http.request(request)
+
+      if REDIRECT_CODES.include?(@resp.code.to_i) && @resp['Location'] && (opts[:follow] && opts[:follow] > 0)
+        opts[:follow] -= 1
+        return get(@resp['Location'], nil, opts)
+      end
+
+      response
+    end
+
+    def request(method, uri, data, opts = {})
+      return get(uri, opts.merge(query: data)) if method.to_s.downcase == 'get'
+
+      uri     = Utils.parse_uri(uri)
+      headers = DEFAULT_HEADERS.merge(opts[:headers] || {})
+
+      query = if data.is_a?(String)
+        data
+      elsif opts[:json]
+        Oj.dump(data) # convert to JSON
+        headers['Content-Type'] = 'application/json'
+      else # querystring, then
+        Utils.encode(data)
+      end
 
-  private
+      if opts[:username] # opts[:password] is optional
+        str = [opts[:username], opts[:password]].compact.join(':')
+        headers['Authorization'] = "Basic " + Base64.encode64(str)
+      end
 
-  def self.send_request(method, uri, params, opts = {})
-    uri     = parse_uri(uri)
-    headers = opts[:headers] || {}
+      args = [method.to_s.downcase, uri.path, query, headers]
+      args.delete_at(2) if args[0] == 'delete' # Net::HTTP's delete does not accept data
 
-    query = if params.is_a?(String)
-      params
-    elsif opts[:json]
-      Oj.dump(params) # convert to JSON
-      headers['Content-Type'] = 'application/json'
-    else
-      encode(params)
+      @resp, @data = @http.send(*args)
+      response
     end
 
-    if opts[:username] # opts[:password] is optional
-      str = [opts[:username], opts[:password]].compact.join(':')
-      headers['Authorization'] = "Basic " + Base64.encode64(str)
+    def response
+      raise 'No response yet!' unless @resp
+      @response ||= build_response(@resp, @data || @resp.body) # 1.8 vs 1.9 style responses
     end
 
-    args = [method, uri.path, query, headers]
-    args.delete_at(2) if method.to_s == 'delete' # Net::HTTP's delete does not accept data
+    private
 
-    resp, data = client(uri, opts).send(*args)
-    build_response(resp, data || resp.body) # 1.8 vs 1.9 style responses
-  end
+    def build_response(resp, body)
+      resp.extend(Response)
+      resp.set_body(body) unless resp.body
+      resp
+    end
 
-  def self.build_response(resp, body)
-    resp.extend(Response)
-    resp.set_body(body) unless resp.body
-    resp
   end
 
-  def self.client(uri, opts = {})
-    http = Net::HTTP.new(uri.host, uri.port)
+  class << self
 
-    if uri.port == 443
-      http.use_ssl = true
-      http.verify_mode = opts[:verify_ssl] === false ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+    def open(uri, opts = {}, &block)
+      uri = Utils.parse_uri(uri)
+      opts.merge!(use_ssl: uri.scheme == 'https')
+      opts.merge!(verify_mode: OpenSSL::SSL::VERIFY_NONE) if opts[:verify_ssl] === false
+
+      Net::HTTP.start(uri.host, uri.port, opts) do |http|
+        client = Client.new(http)
+        # yield(client)
+        client.instance_eval(&block)
+      end
     end
 
-    [:open_timeout, :read_timeout, :ssl_version, :ciphers].each do |key|
-      http.send("#{key}=", opts[key]) if opts.has_key?(key)
+    def get(uri, options = {})
+      request(:get, uri, nil, options)
     end
 
-    http
-  end
+    def post(uri, data, options = {})
+      request(:post, uri, data, options)
+    end
 
-  def self.parse_uri(uri)
-    uri = 'http://' + uri unless uri.to_s['http']
-    uri = URI.parse(uri)
-    raise ArgumentError.new("Invalid URI: #{uri}") unless uri.is_a?(URI::HTTP)
-    uri.path = '/' if uri.path == ''
-    uri
-  end
+    def put(uri, data, options = {})
+      request(:put, uri, data, options)
+    end
 
-  def self.encode(value, key = nil)
-    case value
-    when Hash  then value.map { |k,v| encode(v, append_key(key,k)) }.join('&')
-    when Array then value.map { |v| encode(v, "#{key}[]") }.join('&')
-    when nil   then ''
-    else
-      "#{key}=#{URI.escape(value.to_s)}"
+    def patch(uri, data, options = {})
+      request(:patch, uri, data, options)
+    end
+
+    def delete(uri, data, options = {})
+      request(:delete, uri, data, options)
+    end
+
+    def request(method, url, data = {}, options = {})
+      Client.init(url, options).request(method, url, data, options)
     end
-  end
 
-  def self.append_key(root_key, key)
-    root_key.nil? ? key : "#{root_key}[#{key.to_s}]"
   end
 
 end

data/lib/dagger/ox_extension.rb

@@ -1,8 +1,32 @@
 require 'ox'
 
 XMLNode = Struct.new(:name, :text, :attributes, :children) do
+  # this lets us traverse an parsed object like this:
+  # doc[:child][:grandchild].value
   def [](key)
-    children.select { |node| node.name.to_s == key.to_s }.first
+    found = children.select { |node| node.name.to_s == key.to_s }
+    found.empty? ? nil : found.size == 1 ? found.first : found
+  end
+
+  # returns first matching node
+  def first(key)
+    if found = self[key]
+      found.is_a?(XMLNode) ? found : found.first
+    else
+      children.find do |ch|
+        if res = ch.first(key)
+          return res
+        end
+      end
+    end
+  end
+
+  # returns all matching nodes
+  def all(key)
+    found    = self[key]
+    direct   = found.is_a?(XMLNode) ? [found] : found || []
+    indirect = children.map { |ch| ch.all(key) }.flatten.compact
+    direct + indirect
   end
 end
 

data/lib/dagger/version.rb

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

data/test/parsers_spec.rb

@@ -6,7 +6,7 @@ require 'rspec/expectations'
 describe 'Parsers' do
 
   def send_request
-    Dagger.get('http://foobar.com/test')
+    Dagger.post('http://foobar.com/test', { foo: 'bar'})
   end
 
   let(:fake_http) { double('Net::HTTP') }
@@ -15,7 +15,7 @@ describe 'Parsers' do
   before do
     allow(Net::HTTP).to receive(:new).and_return(fake_http)
     allow(fake_http).to receive(:verify_mode=).and_return(true)
-    allow(fake_http).to receive(:request).and_return(fake_resp)
+    allow(fake_http).to receive(:post).and_return(fake_resp)
   end
 
   describe 'json' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dagger
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Tomás Pollak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-24 00:00:00.000000000 Z
+date: 2016-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,7 +114,6 @@ files:
 - lib/dagger/response.rb
 - lib/dagger/version.rb
 - test/parsers_spec.rb
-- test/requests_spec.rb
 homepage: https://github.com/tomas/dagger
 licenses: []
 metadata: {}

data/test/requests_spec.rb

@@ -1,48 +0,0 @@
-require './lib/dagger'
-
-require 'rspec/mocks'
-require 'rspec/expectations'
-
-describe 'Requests' do
-
-  describe '.get' do
-
-    def send_request(url)
-      Dagger.get(url)
-    end
-
-    describe 'empty url' do
-
-      it 'raises error' do
-        expect { send_request('') }.to raise_error(ArgumentError)
-      end
-
-    end
-
-    describe 'invalid URL' do
-
-      it 'raises error' do
-        expect { send_request('asd123.rewqw') }.to raise_error(SocketError)
-      end
-
-    end
-
-    describe 'nonexisting host' do
-
-      it 'raises error' do
-        expect { send_request('http://www.foobar1234567890foobar.com/hello') }.to raise_error(SocketError)
-      end
-
-    end
-
-    describe 'valid host' do
-
-      it 'works' do
-        expect(send_request('http://www.google.com')).to be_a(Net::HTTPResponse)
-      end
-
-    end
-
-  end
-
-end