dagger 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0cafd73f6378598d9ce5a095b498f19239d8bf23
+  data.tar.gz: 11dd75fb2942eb8da1f6cdcb53f33000478157f1
+SHA512:
+  metadata.gz: 00aa7321875d852c6e7daad0312371455566630a7af8f21e35d011a7c9c8258c86e7956eab77baad47002585b34da8764a1cd700ac2d7191394cbc4953e14408
+  data.tar.gz: 53677a981090e05d60c13c082eaa9e4571014c24d22df7d09e6ba4d1613f21186d3a8411ef47a39c4a530391f4c0a452a5b8c2501cfa9d27a2db0f04de568743

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+# specified in tuktuk.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/dagger

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'dagger'
+
+method = ARGV[0] or abort "Usage: dagger [method] [url] [data]"
+
+if ARGV[1].nil?
+  method = 'get'
+else
+  method = ARGV.shift
+end
+
+def parse_data(str)
+  {} # not ready yet.
+end
+
+url  = ARGV[0]
+data = parse_data(ARGV[1])
+
+options = {
+  :follow => true
+}
+
+# puts "#{method} #{url}"
+resp = Dagger.send(method, url, data, options)
+
+# puts resp.status
+# puts resp.headers
+puts resp.body

data/dagger.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/dagger/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "dagger"
+  s.version     = Dagger::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Tomás Pollak']
+  s.email       = ['tomas@forkhq.com']
+  s.homepage    = "https://github.com/tomas/dagger"
+  s.summary     = "Simplified Net::HTTP wrapper."
+  s.description = "Dagger.post(url, params).body"
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "dagger"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+  # s.bindir       = 'bin'
+end

data/lib/dagger.rb

@@ -0,0 +1,126 @@
+# Dagger.
+# Simple Net::HTTP wrapper (in less than 100 LOC)
+# Written by Tomas Pollak
+
+# Example Usage ---------------------------------
+#
+# resp, body = Dagger.get('http://google.com')
+# puts body if resp.code == 200
+#
+# opts = { username: 'foobar', password: 'secret' }
+# resp, body = Dagger.get('http://api.server.com', opts)
+#
+# opts = { verify_ssl: false, open_timeout: 30 }
+# resp, body = Dagger.post('http://twitter.com', { foo: 'bar' }, opts)
+
+require 'dagger/version'
+require 'dagger/response'
+require 'dagger/parsers'
+
+require 'net/https'
+require 'base64'
+
+module Dagger
+  
+  DEFAULT_HEADERS = {
+    'User-Agent' => "Dagger/#{VERSION} (Ruby Net::HTTP Wrapper, like curl)" 
+  }
+  
+  def self.get(uri, query = nil, opts = {})
+    raise ArgumentError.new("Empty URL!") if (uri || '').strip == ''
+
+    opts[:follow] = 10 if opts[:follow] == true
+    uri = parse_uri(uri)
+    uri.query = encode(opts[:query]) if opts[: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))
+    end
+
+    resp, data = http.request(request)
+
+    if [301,302].include?(resp.code.to_i) && resp['Location'] && (opts[:follow] && opts[:follow] > 0)
+      opts[:follow] -= 1
+      return get(resp['Location'], nil, opts)
+    end
+      
+    build_response(resp, data || resp.body) # 1.8 vs 1.9 style responses 
+  end
+
+  def self.post(uri, params = {}, options = {})
+    request('post', uri, params, options)
+  end
+
+  def self.put(uri, params = {}, options = {})
+    request('put', uri, params, options)
+  end
+
+  def self.delete(uri, params = {}, options = {})
+    request('delete', uri, params, options)
+  end
+
+  def self.request(method, url, params = {}, options = {})
+    return get(url, options) if method.to_s.downcase == 'get'
+    request(method.to_s.downcase, url, params, options)
+  end
+
+  private
+
+  def self.request(method, uri, params, opts = {})
+    # raise "Params should be a hash." unless params.is_a?(Hash)
+    uri = parse_uri(uri)
+    query = params.is_a?(String) ? params : encode(params)
+
+    headers = opts[:headers] || {}
+
+    if opts[:username] && opts[:password]
+      headers['Authorization'] = "Basic " + Base64.encode64("#{opts[:username]}:#{opts[:password]}")
+    end
+
+    args = [method, uri.path, query, headers]
+    args.delete_at(2) if method.to_s == 'delete' # Net::HTTP's delete does not accept data
+
+    resp, data = client(uri, opts).send(*args)
+    build_response(resp, data || resp.body) # 1.8 vs 1.9 style responses
+  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)
+    http.open_timeout = opts[:open_timeout] if opts[:open_timeout]
+    http.read_timeout = opts[:read_timeout] if opts[:read_timeout]
+    http.use_ssl = true if uri.port == 443
+    http.verify_mode = opts[:verify_ssl] ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+    http
+  end
+  
+  def self.parse_uri(uri)
+    uri = 'http://' + uri unless uri.to_s['http']
+    uri = URI.parse(uri)
+    uri.path = '/' if uri.path == ''
+    uri
+  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)}"
+    end
+  end
+
+  def self.append_key(root_key, key)
+    root_key.nil? ? key : "#{root_key}[#{key.to_s}]"
+  end
+
+end

data/lib/dagger/parsers.rb

@@ -0,0 +1,20 @@
+require 'json'
+
+class Parsers
+  
+  def initialize(response)
+    @body = response.body
+    @normalized = response.content_type.to_s.sub('/', '_')
+  end
+  
+  def process
+    send(@normalized, @body) if respond_to?(@normalized)
+  end
+  
+  def application_json(body)
+    JSON.parse(body)
+  end
+  
+  alias_method :text_javascript, :application_json
+  
+end

data/lib/dagger/response.rb

@@ -0,0 +1,44 @@
+module Dagger
+
+  module Response
+
+    attr_reader :body
+    
+    def self.extended(base)
+      # puts base.inspect
+    end
+  
+    def set_body(string)
+      raise "Body is set!" if body
+      @body = string
+    end
+    
+    def headers
+      to_hash # from Net::HTTPHeader module
+    end
+    
+    def code
+      super.to_i
+    end
+    
+    def content_type
+      self['Content-Type']
+    end
+    
+    alias_method :status, :code
+
+    def to_s
+      body.to_s
+    end
+    
+    def to_a
+      [code, headers, to_s]
+    end
+    
+    def data
+      @data ||= Parsers.new(self).process || body 
+    end
+
+  end
+
+end

data/lib/dagger/version.rb

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

data/test/requests_spec.rb

@@ -0,0 +1,48 @@
+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') }.not_to raise_error
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: dagger
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tomás Pollak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-03 00:00:00.000000000 Z
+dependencies: []
+description: Dagger.post(url, params).body
+email:
+- tomas@forkhq.com
+executables:
+- dagger
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Rakefile
+- bin/dagger
+- dagger.gemspec
+- lib/dagger.rb
+- lib/dagger/parsers.rb
+- lib/dagger/response.rb
+- lib/dagger/version.rb
+- test/requests_spec.rb
+homepage: https://github.com/tomas/dagger
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: dagger
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Simplified Net::HTTP wrapper.
+test_files: []