surrealist 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 936bf35d7c1f0511db6d2f9458ade02330ec2246d444f9c0c7f9069ed7f24d73
-  data.tar.gz: 1b91381b04081fb2e4cd6af4167cd41907f982c9a1f713077e76d78ec51a82c4
+  metadata.gz: 18d601273dc48757785a2356db0353254bf692deb46ed7df9e128aa329eef928
+  data.tar.gz: 20bdde30e93d282483c88beb6de145fb198e332a3cf73379fa0f96d176a99895
 SHA512:
-  metadata.gz: d058ddf6a4314ee51c09fc2bd7866302971d9a8f9171430189d95df37871331883237519579c9044a4e720435bdf99702e134e9af992cddb4b5a241db528a92e
-  data.tar.gz: ccee664c6cadf85ec84e5584a8ac1c9490f43a5dfb7308ecf7d8d883daa5f4bbc6c6f1a2836c58f30677bb1ca6a5cfb1c5111f03db9ca6e0b9fade5420a11998
+  metadata.gz: bec9aaebea9985002b24625c3d99316137344794cbab43a2e04d8fa685eda6c46a10f7dc072b37cbfef2428e6a3a0abbb5a7223823feb0ca546fd31128aab7a2
+  data.tar.gz: 9c47eb33373325982ab09eeba0aae2dacf963bdf27f0291d79301ea3f5cf1495369d9c7d9f808288cc6dcf596e4dcab409481255909e6dcc266acdf4e43b6c2b

data/.rubocop.yml

@@ -2,6 +2,12 @@ AllCops:
   TargetRubyVersion: 2.2
   Exclude:
     - './gemfiles/*gemfile'
+    - './tmp/*'
+
+Documentation:
+  Exclude:
+    - benchmarks/*rb
+    - spec/**/*rb
 
 # Layout
 
@@ -51,6 +57,7 @@ Lint/RescueType:
 Metrics/BlockLength:
   Exclude:
     - spec/**/*rb
+    - benchmarks
 
 Metrics/CyclomaticComplexity:
   Enabled: false
@@ -59,6 +66,7 @@ Metrics/MethodLength:
   Max: 15
 
 Metrics/LineLength:
+  Exclude: [benchmarks/*rb]
   Max: 110
 
 Metrics/PerceivedComplexity:

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 1.0.0
+
+## Added
+* `#build_schema` for collections from `Surrealist::Serializer` (@nesaulov) #74
+* Oj dependency
+* Multiple serializers API (@nulldef) #66
+
+## Miscellaneous
+* Benchmarks for Surrealist vs AMS
+* A lot of memory & performance optimizations (@nesaulov) #64
+
 # 0.4.0
 
 ## Added

data/Gemfile

@@ -4,7 +4,9 @@ source 'https://rubygems.org'
 gemspec
 
 group :development, :test do
+  gem 'active_model_serializers', '~> 0.10.0'
   gem 'activerecord'
+  gem 'benchmark-ips'
   gem 'coveralls', require: false
   gem 'dry-struct'
   gem 'dry-types'

data/README.md

@@ -3,6 +3,7 @@
 [![Coverage Status](https://coveralls.io/repos/github/nesaulov/surrealist/badge.svg?branch=master)](https://coveralls.io/github/nesaulov/surrealist?branch=master)
 [![Inline docs](http://inch-ci.org/github/nesaulov/surrealist.svg?branch=master)](http://inch-ci.org/github/nesaulov/surrealist)
 [![Gem Version](https://badge.fury.io/rb/surrealist.svg)](https://rubygems.org/gems/surrealist)
+[![Open Source Helpers](https://www.codetriage.com/nesaulov/surrealist/badges/users.svg)](https://www.codetriage.com/nesaulov/surrealist)
 
 ![Surrealist](surrealist-icon.png)
  
@@ -22,15 +23,21 @@ to serialize nested objects and structures. [Introductory blogpost.](https://med
   * [Simple example](#simple-example)
   * [Nested structures](#nested-structures)
   * [Nested objects](#nested-objects)
-  * [Delegating Surrealization](#delegating-surrealization)
-  * [Usage with Dry::Types](#usage-with-drytypes)
+  * [Collection Surrealization](#collection-surrealization)
   * [Defining custom serializers](#defining-custom-serializers)
+  * [Multiple serializers](#multiple-serializers)
   * [Build schema](#build-schema)
-  * [Camelization](#camelization)
-  * [Include root](#include-root)
-  * [Include namespaces](#include-namespaces)
-  * [Collection Surrealization](#collection-surrealization)
-  * [Root](#root)
+  * [Working with ORMs](#working-with-orms)
+    * [ActiveRecord](#activerecord)
+    * [ROM](#rom)
+    * [Sequel](#sequel)
+  * [Usage with Dry::Types](#usage-with-drytypes)  
+  * [Delegating Surrealization](#delegating-surrealization)
+  * [Optional arguments](#optional-arguments)
+    * [Camelization](#camelization)
+    * [Include root](#include-root)
+    * [Root](#root)
+    * [Include namespaces](#include-namespaces)
   * [Bool and Any](#bool-and-any)
   * [Type errors](#type-errors)
   * [Undefined methods in schema](#undefined-methods-in-schema)
@@ -38,6 +45,7 @@ to serialize nested objects and structures. [Introductory blogpost.](https://med
 * [Roadmap](#roadmap)  
 * [Contributing](#contributing)
 * [Credits](#credits)
+* [Authors](#authors)
 * [License](#license)
 
 
@@ -59,7 +67,7 @@ Or install it yourself as:
 
 ## Usage
 Schema should be defined with a block that contains a hash. Every key of the schema should be
-either a name of a method of the surrealizable object (or it's parents/mixins),
+either a name of a method of the surrealizable object (or it's ancestors/mixins),
 or - in case you want to build json structure independently from object's structure - a symbol.
 Every value of the hash should be a constant that represents a Ruby class,
 that will be used for type-checks.
@@ -151,101 +159,33 @@ User.new.surrealize
 
 ```
 
-### Delegating surrealization
-You can share the `json_schema` between classes:
+### Collection Surrealization
+Since 0.2.0 Surrealist has API for collection serialization. Example for ActiveRecord:
 ``` ruby
-class Host
+class User < ActiveRecord::Base
   include Surrealist
  
   json_schema do
-    { name: String }
-  end
- 
-  def name
-    'Host'
+    { name: String, age: Integer }
   end
 end
-
-class Guest
-  delegate_surrealization_to Host
  
-  def name
-    'Guest'
-  end
-end
-
-Host.new.surrealize
-# => '{ "name": "Host" }'
-Guest.new.surrealize
-# => '{ "name": "Guest" }'
-```
-Schema delegation works without inheritance as well, so if you wish you can
-delegate surrealization not only to parent classes, but to any class. Please note that
-in this case you have to `include Surrealist` in class that delegates schema as well.
-``` ruby
-class Potato
-  include Surrealist
-  delegate_surrealization_to Host
+users = User.all
+# => [#<User:0x007fa1485de878 id: 1, name: "Nikita", age: 23>, #<User:0x007fa1485de5f8 id: 2, name: "Alessandro", age: 24>]
  
-  def name
-    'Potato'
-  end
-end
-
-Potato.new.surrealize
-# => '{ "name": "Potato" }'
+Surrealist.surrealize_collection(users)
+# => '[{ "name": "Nikita", "age": 23 }, { "name": "Alessandro", "age": 24 }]'
 ```
+You can find motivation behind introducing new API versus monkey-patching [here](https://alessandrominali.github.io/monkey_patching_real_example).  
+`#surrealize_collection` works for all data structures that respond to `#each`. All ActiveRecord
+features (like associations, inheritance etc) are supported and covered. Further reading: [working with ORMs](#working-with-orms).
+All optional arguments (`camelize`, `include_root` etc) are also supported.
 
-
-### Usage with Dry::Types
-You can use `Dry::Types` for type checking. Note that Surrealist does not ship
-with dry-types by default, so you should do the [installation and configuration](http://dry-rb.org/gems/dry-types/)
-by yourself. All built-in features of dry-types work, so if you use, say, `Types::Coercible::String`,
-your data will be coerced if it is able to, otherwise you will get a TypeError.
-Assuming that you have defined module called `Types`:
-
-``` ruby
-require 'dry-types'
-
-class Car
-  include Surrealist
- 
-  json_schema do
-    {
-      age:            Types::Coercible::Int,
-      brand:          Types::Coercible::String,
-      doors:          Types::Int.optional,
-      horsepower:     Types::Strict::Int.constrained(gteq: 20),
-      fuel_system:    Types::Any,
-      previous_owner: Types::String,
-    }
-  end
- 
-  def age;
-    '7'
-  end
- 
-  def previous_owner;
-    'John Doe'
-  end
- 
-  def horsepower;
-    140
-  end
- 
-  def brand;
-    'Toyota'
-  end
- 
-  def doors; end
- 
-  def fuel_system;
-    'Direct injection'
-  end
-end
-
-Car.new.surrealize
-# => '{ "age": 7, "brand": "Toyota", "doors": null, "horsepower": 140, "fuel_system": "Direct injection", "previous_owner": "John Doe" }'
+An additional and unique argument for `#surrealize_collection` is `raw` which is evaluated as a Boolean.
+If this option is 'truthy' then the results will be an array of surrealized hashes (i.e. NOT a JSON string).
+```
+Surrealist.surrealize_collection(users, raw: true)
+# => [{ "name": "Nikita", "age": 23 }, { "name": "Alessandro", "age": 24 }]
 ```
 
 ### Defining custom serializers
@@ -314,6 +254,43 @@ IncomeSerializer.new(income, current_user: User.find(3)).surrealize
 # => '{ "amount": 200 }'
 ```
 
+### Multiple serializers
+
+You can define several custom serializers for one object and use it in different cases. Just mark it with a tag:
+
+``` ruby
+class PostSerializer < Surrealist::Serializer
+  json_schema { { id: Integer, title: String, author: { name: String } } }
+end
+
+class PreviewSerializer < Surrealist::Serializer
+  json_schema { { id: Integer, title: String } }
+end
+
+class Post
+  include Surrealist
+ 
+  surrealize_with PostSerializer
+  surrealize_with PreviewSerializer, tag: :preview
+ 
+  attr_reader :id, :title, :author
+end
+```
+
+And then specify serializer's tag with `for` argument:
+``` ruby
+author = Struct.new(:name).new("John")
+post = Post.new(1, "Ruby is awesome", author)
+post.surrealize # => '{ "id": 1, "title": "Ruby is awesome", author: { name: "John" } }'
+ 
+post.surrealize(for: :preview) # => '{ "id": 1, "title": "Ruby is awesome" }'
+```
+Or specify serializer explicitly with `serializer` argument:
+
+``` ruby
+post.surrealize(serializer: PreviewSerializer) # => '{ "id": 1, "title": "Ruby is awesome" }'
+```
+
 ### Build schema
 If you don't need to dump the hash to json, you can use `#build_schema`
 method on the instance. It calculates values and checks types, but returns
@@ -324,7 +301,256 @@ Car.new.build_schema
 # => { age: 7, brand: "Toyota", doors: nil, horsepower: 140, fuel_system: "Direct injection", previous_owner: "John Doe" }
 ```
 
-### Camelization
+### Working with ORMs
+
+There are two kinds of return values of ORM methods: some return collections of objects, while others return instances.
+For the first ones one should use `instance#surrealize`, whereas for the second ones `Surrealist.surrealize_collection(collection)`
+Please keep in mind that if your serialization logic is [kept in a separate class](#defining-custom-serializers) which is inherited from
+`Surrealist::Serializer`, than usage boils down to `YourSerializer.new(instance || collection).surrealize`.
+
+#### ActiveRecord
+All associations work as expected: `.has_many`, `.has_and_belongs_to_many` return collections,
+`.has_one`, `.belongs_to` return instances.
+
+Methods that return instances:
+``` ruby
+.find
+.find_by
+.find_by!
+.take!
+.first 
+.first!
+.second 
+.second!
+.third 
+.third!
+.fourth 
+.fourth!
+.fifth 
+.fifth!
+.forty_two 
+.forty_two!
+.last 
+.last!
+.third_to_last 
+.third_to_last!
+.second_to_last 
+.second_to_last!
+```
+Methods that return collections:
+``` ruby
+.all
+.where  
+.where_not 
+.order  
+.take  
+.limit  
+.offset  
+.lock  
+.readonly 
+.reorder  
+.distinct 
+.find_each 
+.select  
+.group  
+.order  
+.except  
+.extending 
+.having  
+.references
+.includes
+.joins
+```
+
+#### ROM
+
+For detailed usage example (covering ROM 3.x and ROM 4.x) please see `spec/orms/rom/`.
+Under the hood ROM uses Sequel, and Sequel returns instances only on `.first`, `.last`, `.[]` and `.with_pk!`.
+Collections are returned for all other methods.
+``` ruby
+container = ROM.container(:sql, ['sqlite::memory']) do |conf|
+  conf.default.create_table(:users) do
+    primary_key :id
+    column :name, String, null: false
+    column :email, String, null: false
+  end
+  # ...
+end
+ 
+users = UserRepo.new(container).users
+# => #<ROM::Relation[Users] name=ROM::Relation::Name(users) dataset=#<Sequel::SQLite::Dataset: "SELECT `users`.`id`, `users`.`name`, `users`.`email` FROM `users` ORDER BY `users`.`id`">>
+```
+Basically, there are several ways to fetch/represent data in ROM:
+``` ruby
+# With json_schema defined in ROM::Struct::User
+class ROM::Struct::User < ROM::Struct
+  include Surrealist
+ 
+  json_schema { { name: String } }
+end 
+ 
+users.to_a.first # => #<ROM::Struct::User id=1 name="Jane Struct" email="jane@struct.rom">
+users.to_a.first.surrealize # => "{\"name\":\"Jane Struct\"}"
+ 
+users.where(id: 1).first # => #<ROM::Struct::User id=1 name="Jane Struct" email="jane@struct.rom">
+users.where(id: 1).first.surrealize # => "{\"name\":\"Jane Struct\"}"
+ 
+Surrealist.surrealize_collection(users.to_a) # => "[{\"name\":\"Jane Struct\"},{\"name\":\"Dane As\"},{\"name\":\"Jack Mapper\"}]"
+ 
+# using ROM::Struct::Model#as(Representative) with json_schema defined in representative
+class RomUser < Dry::Struct
+  include Surrealist
+ 
+  attribute :name, String
+  attribute :email, String
+ 
+  json_schema { { email: String } }
+end
+ 
+# ROM 3.x
+rom_users = users.as(RomUser).to_a
+ 
+# ROM 4.x
+rom_users = users.map_to(RomUser).to_a
+ 
+rom_users[1].surrealize # => "{\"email\":\"dane@as.rom\"}"
+Surrealist.surrealize_collection(rom_users) # => "[{\"email\":\"jane@struct.rom\"},{\"email\":\"dane@as.rom\"},{\"email\":\"jack@mapper.rom\"}]"
+   
+# using Mappers
+class UserModel
+  include Surrealist
+ 
+  json_schema { { id: Integer, email: String } }
+ 
+  attr_reader :id, :name, :email
+ 
+  def initialize(attributes)
+    @id, @name, @email = attributes.values_at(:id, :name, :email)
+  end
+end
+ 
+class UsersMapper < ROM::Mapper
+  register_as :user_obj
+  relation :users
+  model UserModel
+end
+  
+# ROM 3.x
+mapped = users.as(:user_obj)
+# ROM 4.x
+mapped = users.map_with(:user_obj)
+  
+mapped.to_a[2] # => #<UserModel:0x00007f8ec19fb3c8 @email="jack@mapper.rom", @id=3, @name="Jack Mapper">
+mapped.where(id: 3).first # => #<UserModel:0x00007f8ec19fb3c8 @email="jack@mapper.rom", @id=3, @name="Jack Mapper">
+mapped.to_a[2].surrealize # => "{\"id\":3,\"email\":\"jack@mapper.rom\"}"
+Surrealist.surrealize_collection(mapped.to_a) # => "[{\"email\":\"jane@struct.rom\"},{\"email\":\"dane@as.rom\"},{\"email\":\"jack@mapper.rom\"}]"  
+Surrealist.surrealize_collection(mapped.where { id < 4 }.to_a) # => "[{\"email\":\"jane@struct.rom\"},{\"email\":\"dane@as.rom\"},{\"email\":\"jack@mapper.rom\"}]" 
+``` 
+
+#### Sequel
+Basically, Sequel returns instances only on `.first`, `.last`, `.[]` and `.with_pk!`. Collections are returned for all other methods.
+Most of them are covered in `spec/orms/sequel` specs, please refer to them for code examples.
+Associations serialization works the same way as it does with ActiveRecord.
+
+### Usage with Dry::Types
+You can use `Dry::Types` for type checking. Note that Surrealist does not ship
+with dry-types by default, so you should do the [installation and configuration](http://dry-rb.org/gems/dry-types/)
+by yourself. All built-in features of dry-types work, so if you use, say, `Types::Coercible::String`,
+your data will be coerced if it is able to, otherwise you will get a TypeError.
+Assuming that you have defined module called `Types`:
+
+``` ruby
+require 'dry-types'
+
+class Car
+  include Surrealist
+ 
+  json_schema do
+    {
+      age:            Types::Coercible::Int,
+      brand:          Types::Coercible::String,
+      doors:          Types::Int.optional,
+      horsepower:     Types::Strict::Int.constrained(gteq: 20),
+      fuel_system:    Types::Any,
+      previous_owner: Types::String,
+    }
+  end
+ 
+  def age;
+    '7'
+  end
+ 
+  def previous_owner;
+    'John Doe'
+  end
+ 
+  def horsepower;
+    140
+  end
+ 
+  def brand;
+    'Toyota'
+  end
+ 
+  def doors; end
+ 
+  def fuel_system;
+    'Direct injection'
+  end
+end
+
+Car.new.surrealize
+# => '{ "age": 7, "brand": "Toyota", "doors": null, "horsepower": 140, "fuel_system": "Direct injection", "previous_owner": "John Doe" }'
+```
+
+### Delegating surrealization
+You can share the `json_schema` between classes:
+``` ruby
+class Host
+  include Surrealist
+ 
+  json_schema do
+    { name: String }
+  end
+ 
+  def name
+    'Host'
+  end
+end
+
+class Guest
+  delegate_surrealization_to Host
+ 
+  def name
+    'Guest'
+  end
+end
+
+Host.new.surrealize
+# => '{ "name": "Host" }'
+Guest.new.surrealize
+# => '{ "name": "Guest" }'
+```
+Schema delegation works without inheritance as well, so if you wish you can
+delegate surrealization not only to parent classes, but to any class. Please note that
+in this case you have to `include Surrealist` in class that delegates schema as well.
+``` ruby
+class Potato
+  include Surrealist
+  delegate_surrealization_to Host
+ 
+  def name
+    'Potato'
+  end
+end
+
+Potato.new.surrealize
+# => '{ "name": "Potato" }'
+```
+
+### Optional arguments
+
+#### Camelization
 If you need to have keys in camelBack, you can pass optional `camelize` argument
 to `#surrealize or #build_schema`. From the previous example:
 
@@ -333,7 +559,7 @@ Car.new.surrealize(camelize: true)
 # => '{ "age": 7, "brand": "Toyota", "doors": null, "horsepower": 140, "fuelSystem": "Direct injection", "previousOwner": "John Doe" }'
 ```
 
-### Include root
+#### Include root
 If you want to wrap the resulting JSON into a root key, you can pass optional `include_root` argument
 to `#surrealize` or `#build_schema`. The root key in this case will be taken from the class name of the
 surrealizable object.
@@ -373,62 +599,7 @@ Animal::Dog.new.surrealize(include_root: true)
 # => '{ "dog": { "breed": "Collie" } }'
 ```
 
-### Include namespaces
-You can build wrap schema into a nested hash from namespaces of the object's class.
-``` ruby
-class BusinessSystem::Cashout::ReportSystem::Withdraws
-  include Surrealist
- 
-  json_schema do
-    { withdraws_amount: Integer }
-  end
- 
-  def withdraws_amount
-    34
-  end
-end
- 
-withdraws = BusinessSystem::Cashout::ReportSystem::Withdraws.new
- 
-withdraws.surrealize(include_namespaces: true)
-# => '{ "business_system": { "cashout": { "report_system": { "withdraws": { "withdraws_amount": 34 } } } } }' 
-```
-By default all namespaces will be taken. If you want you can explicitly specify the level of nesting:
-``` ruby
-withdraws.surrealize(include_namespaces: true, namespaces_nesting_level: 2)
-# => '{ "report_system": { "withdraws": { "withdraws_amount": 34 } } }'
-```
-
-### Collection Surrealization
-Since 0.2.0 Surrealist has API for collection serialization. Example for ActiveRecord:
-``` ruby
-class User < ActiveRecord::Base
-  include Surrealist
- 
-  json_schema do
-    { name: String, age: Integer }
-  end
-end
- 
-users = User.all
-# => [#<User:0x007fa1485de878 id: 1, name: "Nikita", age: 23>, #<User:0x007fa1485de5f8 id: 2, name: "Alessandro", age: 24>]
- 
-Surrealist.surrealize_collection(users)
-# => '[{ "name": "Nikita", "age": 23 }, { "name": "Alessandro", "age": 24 }]'
-```
-You can find motivation behind introducing new API versus monkey-patching [here](https://alessandrominali.github.io/monkey_patching_real_example).  
-`#surrealize_collection` works for all data structures that respond to `#each`. All ActiveRecord
-features (like associations, inheritance etc) are supported and covered. Other ORMs should work without
-issues as well, tests are in progress. All optional arguments (`camelize`, `include_root` etc) are also supported.
-
-An additional and unique arguement for `#surrealize_collection` is `raw` which is evalauted as a Boolean. If this option is 'truthy' then the results will be an array of surrealized hashes (ie. NOT a JSON string).
-```
-Surrealist.surrealize_collection(users, raw: true)
-# => [{ "name": "Nikita", "age": 23 }, { "name": "Alessandro", "age": 24 }]
-```
-Guides on where to use `#surrealize_collection` vs `#surrealize` for all ORMs are coming.
-
-### Root
+#### Root
 If you want to wrap the resulting JSON into a specified root key, you can pass optional `root` argument
 to `#surrealize` or `#build_schema`. The `root` argument will be stripped of whitespaces.
 ``` ruby
@@ -457,6 +628,32 @@ Animal::Cat.new.surrealize(include_namespaces: true, root: 'kitten')
 # => '{ "kitten": { "weight": "3 kilos" } }'
 ```
 
+#### Include namespaces
+You can build wrap schema into a nested hash from namespaces of the object's class.
+``` ruby
+class BusinessSystem::Cashout::ReportSystem::Withdraws
+  include Surrealist
+ 
+  json_schema do
+    { withdraws_amount: Integer }
+  end
+ 
+  def withdraws_amount
+    34
+  end
+end
+ 
+withdraws = BusinessSystem::Cashout::ReportSystem::Withdraws.new
+ 
+withdraws.surrealize(include_namespaces: true)
+# => '{ "business_system": { "cashout": { "report_system": { "withdraws": { "withdraws_amount": 34 } } } } }' 
+```
+By default all namespaces will be taken. If you want you can explicitly specify the level of nesting:
+``` ruby
+withdraws.surrealize(include_namespaces: true, namespaces_nesting_level: 2)
+# => '{ "report_system": { "withdraws": { "withdraws_amount": 34 } } }'
+```
+
 ### Bool and Any
 If you have a parameter that is of boolean type, or if you don't care about the type, you
 can use `Bool` and `Any` respectively.
@@ -518,7 +715,9 @@ type check will be passed. If you want to be strict about `nil`s consider using
 
 ## Roadmap
 Here is a list of features that are not implemented yet (contributions are welcome):
-* [Benchmarks](https://github.com/nesaulov/surrealist/issues/40)
+* [Having a config that would keep serialization parameters](https://github.com/nesaulov/surrealist/issues/76)
+* [DSL for serializer contexts](https://github.com/nesaulov/surrealist/issues/67) 
+* Memoization/caching
 
 ## Contributing
 Bug reports and pull requests are welcome on GitHub at https://github.com/nesaulov/surrealist.
@@ -528,5 +727,12 @@ to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of
 ## Credits
 The icon was created by [Simon Child from Noun Project](https://thenounproject.com/term/salvador-dali/124566/) and is published under [Creative Commons License](https://creativecommons.org/licenses/by/3.0/us/)
 
+## Authors
+Created by [Nikita Esaulov](https://github.com/nesaulov) with help from [Alessandro Minali](https://github.com/AlessandroMinali) and [Alexey Bespalov](https://github.com/nulldef).
+
+<a href="https://github.com/umbrellio/">
+<img style="float: left;" src="https://umbrellio.github.io/Umbrellio/supported_by_umbrellio.svg" alt="Supported by Umbrellio" width="439" height="72">
+</a>
+
 ## License
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).