hubert 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 82674970a036232aa45dbf9a07b2ef0f0650628c
+  data.tar.gz: a944796e70aa1b5079927533137683daa14c41c8
+SHA512:
+  metadata.gz: 46524cde0077bf047a9c0fe4defa29ea67b0b1e652c4da5d3dc375ed662aead1bbcf0952e33c2de7c05cc514efee4923b5d6ba4c262e5fce86396ddf2628f2d6
+  data.tar.gz: 5e0c5069c05665ed04dd637c2fb40f1c0f3a268eccd0a0f46644bd1e03bbda4c7dfea79ba23d8d636fcae83ebea03fb72b6a49dbbaef5505333e872d7b531ae4

data/.gitignore

@@ -0,0 +1 @@
+TODO.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    hubert (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    rake (10.3.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.7)
+  hubert!
+  rake (~> 10.0)
+  rspec (~> 3.0)

data/LICENCE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Andrzej Kajetanowicz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,65 @@
+#Hubert: simple tool for building HTTP URIs
+Hubert makes it easy to generate URLs using simple template strings. Building
+http API clients usually requires some way composing different URLs. This task
+is easy if the API provides only a few endpoints but it becomes more cumbersome
+as the number of available endpoints increases. Clients need to specify correct
+protocols, ports, escape any dynamic values inserted into URI segments and query
+strings.  This gem is attempting to address this problem by providing a simple DSL
+for defining methods that will return desired URLs or paths.
+
+## Example usage:
+```ruby
+require 'hubert'
+
+class MyAwesomeApiClient
+
+  # to make this work you need to extend your class with DSL module
+  extend Hubert::DSL
+  
+  # all URLs will use https protocol (http is the default)
+  https!
+  
+  # specifying hostname is required (unless you only want to generate paths)
+  host 'api.example.com'
+  
+  # any path can be optionally prefixed - this can be usefull
+  # if for example your code uses specific API version or
+  # hits some specific group of endpoints (/users/... etc.) 
+  path_prefix '/v1'
+  
+  # this will allow to call user_url(id: 123) in your class
+  url '/users/:id', as: user
+  
+  # this is a simplified version of the one above
+  # you can use it by calling user_path(id: 123) 
+  path '/users/:id', as: user
+
+  def print_user_url
+    puts user_url(id: 123)
+  end
+  # => 'https://api.example.com/v1/users/123'
+
+  def print_user_path
+    puts user_path(id: 123)
+  end
+  # => '/v1/users/123'
+  
+  # any additional key - value pairs will become a part of the query string
+  # all values will be escaped using CGI.escape
+  def print_user_url_with_additional_ke_value_pairs
+     puts user_url(id: 123, format: 'very pretty', include_description: true)
+  end
+  # => 'https://api.example.com/v1/users/123?format=very+pretty&include_description=true'
+    
+end
+
+```
+
+More examples can be found in spec files.
+
+## Contributing
+1. Fork it
+2. Create your feature branch (git checkout -b feature/my-new-feature)
+3. Commit your changes (git commit -am 'Add some feature')
+4. Push to the branch (git push origin feature/my-new-feature)
+5. Create new Pull Request`

data/Rakefile

@@ -0,0 +1,15 @@
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.verbose = false
+  end
+
+  task default: :spec
+rescue LoadError
+end
+
+task :benchmark do
+  Dir['benchmark/**/*.rb'].each do |benchmark|
+    sh 'ruby', benchmark
+  end
+end

data/benchmark/template.rb

@@ -0,0 +1,13 @@
+require 'benchmark'
+require 'hubert'
+
+probes = 100000
+Benchmark.bm(25) do |b|
+  b.report('Hubert::Template#render') do
+
+    template = Hubert::Template.new('/simple/path/:id/some/:name')
+    context = { id: 123, name: 'hello world', sort: 'name', order: 'asc' }
+
+    probes.times { template.render(context) }
+  end
+end

data/examples/github.rb

@@ -0,0 +1,46 @@
+# Simple github client
+
+require 'net/http'
+require 'hubert'
+
+module Github
+  class User
+    extend Hubert::DSL
+
+    https!
+    host 'api.github.com'
+    path_prefix '/users'
+
+    url '/:username',                 as: 'summary'
+    url '/:username/followers',       as: 'followers'
+    url '/:username/gists',           as: 'gists'
+    url '/:username/gists/:gist_id',  as: 'gist'
+
+   
+    def initialize(username)
+      @username = username
+    end
+
+    def summary
+      get summary_url(username: @username)
+    end
+
+    def followers
+      get followers_url(username: @username)
+    end
+
+    def gists
+      get gists_url(username: @username)
+    end
+
+    def gist(id)
+      get gist_url(username: @username, gist_id: id)
+    end
+
+    private
+
+    def get(uri)
+      Net::HTTP.get URI(uri)
+    end
+  end
+end

data/hubert.gemspec

@@ -0,0 +1,22 @@
+require File.expand_path('../lib/hubert/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'hubert'
+  gem.version       = Hubert::VERSION
+  gem.summary       = 'Hubert: simple http URL builder tool'
+  gem.description   = 'Hubert makes it easy to generate URLs using template strings known from Ruby On Rails framework.'
+
+  gem.authors       = ['Andrzej Kajetanowicz']
+  gem.email         = ['andrzej.kajetanowicz@gmail.com']
+  gem.homepage      = 'https://github.com/kajetanowicz/hubert'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = []
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = ['lib']
+
+  gem.add_development_dependency 'bundler', '~> 1.7'
+  gem.add_development_dependency 'rake', '~> 10.0'
+  gem.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/hubert.rb

@@ -0,0 +1,11 @@
+module Hubert
+
+end
+
+require 'hubert/template'
+require 'hubert/template/context'
+require 'hubert/template/renderer'
+require 'hubert/components'
+require 'hubert/builder'
+require 'hubert/errors'
+require 'hubert/dsl'

data/lib/hubert/builder.rb

@@ -0,0 +1,46 @@
+require 'forwardable'
+
+module Hubert
+  class Builder
+    extend Forwardable
+
+    def_delegators :components, :protocol=, :protocol
+    def_delegators :components, :host=, :host
+    def_delegators :components, :path_prefix=, :path_prefix
+    def_delegators :components, :port=, :port
+    def_delegators :components, :http!, :https!
+
+    def initialize
+      @templates = {}
+      yield(self) if block_given?
+    end
+
+    def path(template, context = {})
+      templates(template).render(context)
+    end
+
+    def url(template, context = {})
+      fail HostNotSet, 'Unable to generate URL without host' if host.nil?
+
+      String.new.tap do|url|
+        url <<  protocol + '://'
+        url << host
+        url << ':' + port unless components.default_port?
+        url << path_prefix
+        url << path(template, context)
+      end
+    end
+
+    def templates(name)
+      @templates.fetch(name) do
+        @templates[name] = Template.new(name)
+      end
+    end
+
+    private
+
+    def components
+      @components ||= Components.new
+    end
+  end
+end

data/lib/hubert/components.rb

@@ -0,0 +1,64 @@
+require 'uri'
+module Hubert
+  class Components
+
+    DEFAULT_PORTS = { 'http' => '80', 'https' => '443' }
+
+    def protocol=(protocol)
+      protocol = protocol.to_s unless protocol.is_a?(String)
+      protocol.strip!
+      if protocol =~ /(http)|(https)/i
+        @protocol = protocol.downcase
+      else
+        fail InvalidProtocol, "Provided protocol: [#{protocol}] is invalid"
+      end
+    end
+
+    def protocol
+      @protocol ||= 'http'
+    end
+
+    def http!
+      @protocol = 'http'
+    end
+
+    def https!
+      @protocol = 'https'
+    end
+
+    def host=(host)
+      host.strip!
+      host = 'http://' + host if URI.parse(host).scheme.nil?
+      @host = URI.parse(host).host
+    end
+
+    def host
+      @host
+    end
+
+    def path_prefix=(path)
+      path.strip!
+      path = URI.parse(path).path
+      path = path[0..-2] if path.end_with?('/')
+      path = path[1..-1] if path.start_with?('/')
+
+      @path_prefix = '/' + path
+    end
+
+    def path_prefix
+      @path_prefix ||= ''
+    end
+
+    def port
+      @port ||= DEFAULT_PORTS.fetch(protocol, '80')
+    end
+
+    def port=(port)
+      @port = port.to_s
+    end
+
+    def default_port?
+      DEFAULT_PORTS.fetch(protocol) == port
+    end
+  end
+end

data/lib/hubert/dsl.rb

@@ -0,0 +1,60 @@
+module Hubert
+  module DSL
+
+    class MethodDefiner
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def define(method, path, options)
+        ensure_alias!(options, method)
+
+        @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{options[:as]}_#{method}(ctx = {})                  # def get_items_path(ctx = {})
+            self.class._hubert_builder.#{method}('#{path}', ctx)   #    self.class._hubert_builder.url('some/:interesting/path:id', ctx)
+          end                                                      # end
+        RUBY
+      end
+
+      private
+
+      def ensure_alias!(options, method)
+        if options.fetch(:as, '') =~ /^\s*$/
+          fail AliasNotSet, "Please specify ':as' option when defining new #{method}"
+        end
+      end
+    end
+
+    def path(path, options = {})
+      MethodDefiner.new(self).define(:path, path, options)
+    end
+
+    def url(path, options = {})
+      MethodDefiner.new(self).define(:url, path, options)
+    end
+
+    def http!
+      _hubert_builder.http!
+    end
+
+    def https!
+      _hubert_builder.https!
+    end
+
+    def host(host)
+      _hubert_builder.host = host
+    end
+
+    def port(port)
+      _hubert_builder.port = port
+    end
+
+    def path_prefix(path_prefix)
+      _hubert_builder.path_prefix = path_prefix
+    end
+
+    def _hubert_builder
+      @_hubert_builder ||= Builder.new
+    end
+  end
+end

data/lib/hubert/errors.rb

@@ -0,0 +1,11 @@
+module Hubert
+  HubertError = Class.new(StandardError)
+
+  KeyNotFound = Class.new(HubertError)
+
+  InvalidProtocol = Class.new(HubertError)
+
+  HostNotSet = Class.new(HubertError)
+
+ AliasNotSet = Class.new(HubertError)
+end

data/lib/hubert/template.rb

@@ -0,0 +1,52 @@
+require 'forwardable'
+
+module Hubert
+  class Template
+    PH = /:[a-zA-Z_]+/
+
+    extend Forwardable
+    def_delegator :@compiled, :map
+
+    def initialize(template)
+      @template = template
+      @compiled = []
+
+      compile!
+    end
+
+    def render(ctx = {})
+      Renderer.new(self, ctx).render
+    end
+
+    def placeholders
+      @compiled.select { |segment| segment.is_a?(Symbol) }
+    end
+
+    private
+
+    def compile!
+      normalize_template!
+      extract_placeholders!
+    end
+
+    def normalize_template!
+      path = @template
+
+      path = path[0..-2] if path.end_with?('/')
+      path = path[1..-1] if path.start_with?('/')
+
+      @template = '/' + path
+    end
+
+    def extract_placeholders!
+      tail = @template
+
+      loop do
+        head, placeholder, tail = tail.partition(PH)
+        @compiled << head
+        break if placeholder.empty?
+        @compiled << placeholder[1..-1].to_sym
+      end
+    end
+  end
+end

data/lib/hubert/template/context.rb

@@ -0,0 +1,28 @@
+module Hubert
+  class Template
+    class Context
+      def initialize(ctx = {})
+        @context = ctx
+        @lookups = []
+      end
+
+      def lookup(key)
+        @lookups << key
+
+        @context.fetch(key) do
+          fail KeyNotFound, "Unable to find a value for a given key [#{key}]"
+        end
+      end
+
+      def unused
+        lookups.reduce(@context.dup) do |ctx, key|
+          ctx.delete(key); ctx
+        end
+      end
+
+      def lookups
+        @lookups.uniq
+      end
+    end
+  end
+end

data/lib/hubert/template/renderer.rb

@@ -0,0 +1,47 @@
+require 'cgi'
+
+module Hubert
+  class Template
+    class Renderer
+
+      def initialize(template, ctx)
+        @template = template
+        @context = Context.new(ctx)
+      end
+
+      def render
+        result = path
+        result << '?' + query if query?
+        result
+      end
+
+      private
+
+      attr_reader :template, :context
+
+      def path
+        template.map do |segment|
+          segment.kind_of?(Symbol) ? lookup(segment) : segment
+        end * ''
+      end
+
+      def query
+        context.unused.map do |key, value|
+          "#{escape(key)}=#{escape(value)}"
+        end * '&'
+      end
+
+      def query?
+        context.unused.any?
+      end
+
+      def lookup(segment)
+        escape(context.lookup(segment))
+      end
+
+      def escape(stringish)
+        CGI.escape(stringish.to_s)
+      end
+    end
+  end
+end

data/lib/hubert/version.rb

@@ -0,0 +1,3 @@
+module Hubert
+  VERSION = '0.0.1'
+end

data/spec/lib/hubert/builder_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module Hubert
+  describe Builder do
+    let(:builder) do
+      Builder.new
+    end
+
+    describe '#path' do
+      it 'renders a path' do
+        expect(builder.path('/foo/bar')).to eq('/foo/bar')
+      end
+
+      it 'replaces placeholders with values' do
+        expect(
+          builder.path('create/:id/some/:name', id: 11, name: 'example')
+        ).to eq('/create/11/some/example')
+      end
+
+      it 'caches templates' do
+        expect(Template).to receive(:new).with('/path/to/resource/:id').once.and_call_original
+
+        builder.path('/path/to/resource/:id', id: 11)
+        builder.path('/path/to/resource/:id', id: 12)
+      end
+    end
+
+    describe '#url' do
+      let(:builder) do
+        Builder.new do |b|
+          b.http!
+          b.host = 'example.com'
+          b.port = port
+          b.path_prefix = 'api'
+        end
+      end
+
+      let(:port) { 80 }
+
+      it 'returns full URL' do
+        expect(builder.url('/path/to/resource/:id', id: 11, sort: 'name'))
+          .to eq('http://example.com/api/path/to/resource/11?sort=name')
+      end
+
+      context 'when using non-default port number' do
+        let(:port) { 8080 }
+
+        it 'creates an url with port number' do
+          expect(builder.url('/path/to/resource/:id', id: 11, sort: 'name'))
+            .to eq('http://example.com:8080/api/path/to/resource/11?sort=name')
+        end
+      end
+
+      context 'when protocol is not set' do
+        let(:builder) do
+          Builder.new do |b|
+            b.host = 'example.com'
+          end
+        end
+
+        it 'uses default http protocol' do
+          expect(builder.url('/path/to/resource'))
+            .to eq('http://example.com/path/to/resource')
+        end
+      end
+
+      context 'when domain is not set' do
+        let(:builder) { Builder.new }
+
+        it 'raises an exception' do
+          expect { builder.url('/path') }.to raise_error(HostNotSet)
+        end
+      end
+    end
+  end
+end

data/spec/lib/hubert/components_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+module Hubert
+  describe Components do
+    let(:components) { Components.new }
+
+    describe '#protocol=' do
+      it 'assigns the protocol' do
+        components.protocol = 'HTTP'
+
+        expect(components.protocol).to eq('http')
+      end
+
+      it 'raises an exception if the protocol is invalid' do
+        expect { components.protocol = 'ftp' }.
+          to raise_error(InvalidProtocol, /\[ftp\]/)
+      end
+
+      context 'when passed as a symbol' do
+        it 'converts protocol to a String' do
+          components.protocol = :http
+
+          expect(components.protocol).to eq('http')
+        end
+      end
+    end
+
+    describe '#http!' do
+      it 'assigns the HTTP protocol' do
+        components.http!
+
+        expect(components.protocol).to eq('http')
+      end
+    end
+
+    describe '#https!' do
+      it 'assigns the HTTPS protocol' do
+        components.https!
+
+        expect(components.protocol).to eq('https')
+      end
+    end
+
+    describe '#host=' do
+      it 'assigns the host' do
+        components.host = 'example.com'
+
+        expect(components.host).to eq('example.com')
+      end
+
+      it 'removes the path component from the host' do
+        components.host = 'example.com/path/to/resource'
+
+        expect(components.host).to eq('example.com')
+      end
+
+      it 'removes the protocol component from the host' do
+        components.host = 'http://example.com/path/to/resource'
+
+        expect(components.host).to eq('example.com')
+      end
+    end
+
+    describe '#path_prefix' do
+      it 'assigns the path prefix' do
+        components.path_prefix = 'foo/bar/baz'
+
+        expect(components.path_prefix).to eq('/foo/bar/baz')
+      end
+
+      it 'removes slashes from the end of the path' do
+        components.path_prefix = '/foo/bar/baz/'
+
+        expect(components.path_prefix).to eq('/foo/bar/baz')
+      end
+    end
+
+    describe '#port' do
+      it 'returns default HTTP port (80)' do
+        expect(components.port).to eq('80')
+      end
+
+      context 'when using HTTPS' do
+        it 'returns the default HTTPS port (443)' do
+          components.https!
+
+          expect(components.port).to eq('443')
+        end
+      end
+
+      context 'when using HTTP' do
+        it 'returns the default HTTP port (80)' do
+          components.http!
+
+          expect(components.port).to eq('80')
+        end
+      end
+    end
+
+    describe '#port=' do
+      it 'assings port' do
+        components.port = 123
+
+        expect(components.port).to eq('123')
+      end
+    end
+  end
+end

data/spec/lib/hubert/dsl_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+module Hubert
+  describe DSL do
+    let(:example_class) do
+      Class.new { extend DSL }
+    end
+
+    %w( path url http! https! port host path_prefix ).each do |method|
+      it "adds '#{method}' method to the host class" do
+        expect(example_class).to respond_to(method)
+      end
+    end
+
+    describe '.path' do
+      before do
+        example_class.class_eval do
+          path 'some/:simple/path/:id', as: :get_items
+        end
+      end
+
+      it 'defines *_path method on any instance of the class' do
+        expect(example_class.new).to respond_to(:get_items_path)
+      end
+
+      context 'when calling new method' do
+        subject do
+          instance.get_items_path(simple: 'foo', id: 1234, sort: 'name', order: 'desc')
+        end
+
+        let(:instance) do
+          example_class.new
+        end
+
+        it 'builds path using passed Hash' do
+          expect(subject).to eq('/some/foo/path/1234?sort=name&order=desc')
+        end
+      end
+
+      context 'when :as key is not present' do
+        it 'raises an exception' do
+          expect {
+            example_class.class_eval do
+              path 'some/:simple/path/:id'
+            end
+          }.to raise_error(AliasNotSet, /:as/)
+        end
+      end
+    end
+
+    describe '.url' do
+      before do
+        example_class.class_eval do
+          url 'some/:simple/path/:id', as: :get_items
+        end
+      end
+
+      it 'defines *_url method on any instance of the class' do
+        expect(example_class.new).to respond_to(:get_items_url)
+      end
+
+      describe 'defined method' do
+        context 'when host is not specified' do
+          it 'raises an exception' do
+            expect { example_class.new.get_items_url }
+              .to raise_error(HostNotSet)
+          end
+        end
+
+        context 'when all path segments are specified' do
+          before do
+            example_class.class_eval do
+              https!; host 'example.com'; port 8080; path_prefix 'api'
+
+              url 'some/:simple/path/:id', as: :get_items
+            end
+          end
+
+          it 'returns a url' do
+            expect(example_class.new.get_items_url(simple: 'foo', id: 'bar'))
+              .to eq('https://example.com:8080/api/some/foo/path/bar')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/hubert/template_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+module Hubert
+  describe Template do
+    let(:template) do
+      Template.new(path)
+    end
+
+    let(:path) do
+      '/first/second/third/'
+    end
+
+    describe '#placeholders' do
+      subject { template.placeholders }
+
+      let(:path) do
+        'simple/:path/:with/some/:placeholders'
+      end
+
+      it' returns a list of placeholders' do
+        expect(subject).to eq([:path, :with, :placeholders])
+      end
+    end
+
+    describe '#render' do
+      subject { template.render({}) }
+
+      it 'returns a string' do
+        expect(subject).to be_kind_of(String)
+      end
+
+      it 'renders a path' do
+        expect(subject).to include('first/second/third')
+      end
+
+      it 'returns a path prefixed with "/"' do
+        expect(subject).to match(/^\/[^\/]/)
+      end
+
+      it 'removes following slash from the path' do
+        expect(subject[-1]).not_to eq('/')
+      end
+
+      context 'when path contains placeholders' do
+        subject do
+          template.render(name: 'test', id: 1234)
+        end
+
+        let(:path) do
+          'a/path/to/:name/followed/by/:id/and/:name/again'
+        end
+
+        it 'substitues all placeholders with provided values' do
+          expect(subject).to eq(
+            '/a/path/to/test/followed/by/1234/and/test/again'
+          )
+        end
+      end
+
+      context 'when hash contains additional keys' do
+        subject do
+          template.render(parent_id: 10, id: 512, sort: 'name', order: 'asc')
+        end
+
+        let(:path) do
+          'a/path/:parent_id/:id/'
+        end
+
+        it 'builds a query string' do
+          expect(subject).to eq('/a/path/10/512?sort=name&order=asc')
+        end
+      end
+
+      context 'when unable to find a placeholder substitution' do
+        subject do
+          template.render(id: 123)
+        end
+
+        let(:path) do
+          'a/path/:id/:name'
+        end
+
+        it 'raises an exception' do
+          expect { subject }.to raise_error(KeyNotFound, /\[name\]/)
+        end
+      end
+
+      context 'when query string contains characters that are not allowed' do
+        subject do
+          template.render(escape: 'all the things', like: 'a boss!!')
+        end
+
+        let(:path) do
+          'a/path/without/placeholders'
+        end
+
+        it 'escapes all illegal characters' do
+          expect(subject).to eq(
+            '/a/path/without/placeholders?escape=all+the+things&like=a+boss%21%21'
+          )
+        end
+      end
+
+      context 'when segments contain illegal characters' do
+        subject do
+          template.render(what: 'all the things', who: 'a boss')
+        end
+
+        let(:path) do
+          'escape/:what/like/:who'
+        end
+
+        it 'escapes all illegal characters' do
+          expect(subject).to eq('/escape/all+the+things/like/a+boss')
+        end
+      end
+    end
+  end
+end

data/spec/lib/hubert_spec.rb

@@ -0,0 +1 @@
+require 'spec_helper'

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'hubert'
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+  config.fail_fast = false
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: hubert
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrzej Kajetanowicz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Hubert makes it easy to generate URLs using template strings known from
+  Ruby On Rails framework.
+email:
+- andrzej.kajetanowicz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENCE
+- README.md
+- Rakefile
+- benchmark/template.rb
+- examples/github.rb
+- hubert.gemspec
+- lib/hubert.rb
+- lib/hubert/builder.rb
+- lib/hubert/components.rb
+- lib/hubert/dsl.rb
+- lib/hubert/errors.rb
+- lib/hubert/template.rb
+- lib/hubert/template/context.rb
+- lib/hubert/template/renderer.rb
+- lib/hubert/version.rb
+- spec/lib/hubert/builder_spec.rb
+- spec/lib/hubert/components_spec.rb
+- spec/lib/hubert/dsl_spec.rb
+- spec/lib/hubert/template_spec.rb
+- spec/lib/hubert_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kajetanowicz/hubert
+licenses:
+- MIT
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: 'Hubert: simple http URL builder tool'
+test_files:
+- spec/lib/hubert/builder_spec.rb
+- spec/lib/hubert/components_spec.rb
+- spec/lib/hubert/dsl_spec.rb
+- spec/lib/hubert/template_spec.rb
+- spec/lib/hubert_spec.rb
+- spec/spec_helper.rb
+has_rdoc: