necromancer 0.3.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0ab93f1c0f77de5f9d0643fee2136e1a18448509
-  data.tar.gz: 44e07300b65361d813dfa3e4d36381ef44cb0d8b
+SHA256:
+  metadata.gz: ab3ba9bfe1c011b3ecf087642ff05a74b51939fa7fb881bbcdb7acec618e9d76
+  data.tar.gz: 4323c173f67da37e1eab170642aff2b8f179b8dc55f777b5424f487271bef105
 SHA512:
-  metadata.gz: 9049c66ec36a5f139de3ffd32d14232eaf95118437c9323fec32cd34054722ea0106c7e1b59d7d284fb53ab52d14a1c3dc723cad07431f541f591200a84f167e
-  data.tar.gz: 9471c9273853b50e269e9aa96efe7f3ae87d99236a7b222d8eb95fd03371a15485d7070fe903eba95949e524b68fec516d0746e05a9b1094c588d6029b52d9c2
+  metadata.gz: bbf17295bcc8268d93805f7b3e1fb6233358db0bdfb91bd5f7de644a5a7546e735e5f046430b1dbed3a85cffcba0dba3d38b107e12e5f4c366b89b71c8882d1e
+  data.tar.gz: 644eb159ae79c9a7f394b858ea2b367692959562979ad7e2c4befc45006f90ab014c3aa2e222469754f71687fee7ebd549dc6e2fe6ea5bc3439b11bf8bec9332

data/CHANGELOG.md

@@ -1,11 +1,78 @@
-0.3.0 (December 14, 2014)
+# Change log
 
+## [v0.7.0] - 2020-12-29
+
+### Added
+* Add HashConverters for transforming string into hash of string, integer, float or boolean values
+* Add converters for transforming string to array of booleans, integers, floats and numeric
+
+### Changed
+* Change StringToRange converter to work with decimal numbers and spaces
+* Change :strict to be a keyword argument
+* Change StringToNumeric converter to allow numbers with space characters
+
+## [v0.6.0] - 2020-03-08
+
+### Changed
+* Change gemspec to remove test artifacts
+
+## [v0.5.1] - 2019-11-24
+
+### Changed
+* Change gemspec to include metadata
+
+### Fixed
+* Fix Ruby 2.7 warnings by Ryan Davis(@zenspider)
+
+## [v0.5.0] - 2019-03-23
+
+### Changed
+* Change to use Ruby >= 2.0.0
+* Change to load files directly without git
+* Change to raise on error in place of fail
+
+## [v0.4.0] - 2017-02-18
+
+### Added
+* Add :string -> :time conversion
+* Add inspection methods to Context and ConversionTarget
+* Add module level Necromancer#convert for convenience and more functional style
+* Add ConversionTarget#>> call for functional style converions
+
+### Changed
+* Change fail to raise in ConversionTarget#for
+* Change fail to raise in Conversions
+* Change ConversionTarget#detect to handle Class type coercion
+
+### Fixed
+* Fix bug with type detection
+* Fix Ruby 2.4.0 warning about Fixnum & Bignum type
+
+## [v0.3.0] - 2014-12-14
+
+### Added
 * Add array converters for :hash, :set and :object conversions
 * Add ability to configure global conversion settings per instance
 
-0.2.0 (December 7, 2014)
+## [v0.2.0] - 2014-12-07
 
+### Added
 * Add #fail_conversion_type to Converter and use in converters
 * Add DateTimeConverters
-* Change IntegerConverters & FloatConverters into Numeric Converters
 * Add string to numeric type conversion
+
+### Changed
+* Change IntegerConverters & FloatConverters into Numeric Converters
+
+## [v0.1.0] - 2014-11-30
+
+* Initial implementation and release
+
+[v0.7.0]: https://github.com/piotrmurach/necromancer/compare/v0.6.0...v0.7.0
+[v0.6.0]: https://github.com/piotrmurach/necromancer/compare/v0.5.1...v0.6.0
+[v0.5.1]: https://github.com/piotrmurach/necromancer/compare/v0.5.0...v0.5.1
+[v0.5.0]: https://github.com/piotrmurach/necromancer/compare/v0.4.0...v0.5.0
+[v0.4.0]: https://github.com/piotrmurach/necromancer/compare/v0.3.0...v0.4.0
+[v0.3.0]: https://github.com/piotrmurach/necromancer/compare/v0.2.0...v0.3.0
+[v0.2.0]: https://github.com/piotrmurach/necromancer/compare/v0.1.0...v0.2.0
+[v0.1.0]: https://github.com/piotrmurach/necromancer/compare/v0.1.0

data/README.md

@@ -1,17 +1,22 @@
 # Necromancer
-[![Gem Version](https://badge.fury.io/rb/necromancer.png)][gem]
-[![Build Status](https://secure.travis-ci.org/peter-murach/necromancer.png?branch=master)][travis]
-[![Code Climate](https://codeclimate.com/github/peter-murach/necromancer.png)][codeclimate]
-[![Coverage Status](https://coveralls.io/repos/peter-murach/necromancer/badge.png)][coverage]
+
+[![Gem Version](https://badge.fury.io/rb/necromancer.svg)][gem]
+[![Actions CI](https://github.com/piotrmurach/tty-runner/workflows/CI/badge.svg?branch=master)][gh_actions_ci]
+[![Build status](https://ci.appveyor.com/api/projects/status/qj3xn5gbbfi4puet?svg=true)][appveyor]
+[![Code Climate](https://codeclimate.com/github/piotrmurach/necromancer/badges/gpa.svg)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/github/piotrmurach/necromancer/badge.svg?branch=master)][coverage]
+[![Inline docs](http://inch-ci.org/github/piotrmurach/necromancer.svg?branch=master)][inchpages]
 
 [gem]: http://badge.fury.io/rb/necromancer
-[travis]: http://travis-ci.org/peter-murach/necromancer
-[codeclimate]: https://codeclimate.com/github/peter-murach/necromancer
-[coverage]: https://coveralls.io/r/peter-murach/necromancer
+[gh_actions_ci]: https://github.com/piotrmurach/tty-runner/actions?query=workflow%3ACI
+[appveyor]: https://ci.appveyor.com/project/piotrmurach/necromancer
+[codeclimate]: https://codeclimate.com/github/piotrmurach/necromancer
+[coverage]: https://coveralls.io/github/piotrmurach/necromancer
+[inchpages]: http://inch-ci.org/github/piotrmurach/necromancer
 
 > Conversion from one object type to another with a bit of black magic.
 
-**Necromancer** provides independent type conversion component for [TTY](https://github.com/peter-murach/tty) toolkit.
+**Necromancer** provides independent type conversion component for [TTY](https://github.com/piotrmurach/tty) toolkit.
 
 ## Motivation
 
@@ -30,7 +35,7 @@ Conversion between Ruby core types frequently comes up in projects but is solved
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'necromancer'
+gem "necromancer"
 ```
 
 And then execute:
@@ -53,51 +58,67 @@ Or install it yourself as:
 * [3. Converters](#3-converters)
   * [3.1 Array](#31-array)
   * [3.2 Boolean](#32-boolean)
-  * [3.3 Hash](#33-hash)
-  * [3.4 Numeric](#34-numeric)
-  * [3.5 Range](#35-range)
-  * [3.6 Custom](#36-custom)
-    * [3.6.1 Using an Object](#361-using-an-object)
-    * [3.6.2 Using a Proc](#362-using-a-proc)
+  * [3.3 DateTime](#33-datetime)
+  * [3.4 Hash](#34-hash)
+  * [3.5 Numeric](#35-numeric)
+  * [3.6 Range](#36-range)
+  * [3.7 Custom](#37-custom)
+    * [3.7.1 Using an Object](#371-using-an-object)
+    * [3.7.2 Using a Proc](#372-using-a-proc)
 
 ## 1. Usage
 
-**Necromancer** requires you to instatiate it:
+**Necromancer** knows how to handle conversions between various types using the `convert` method. The `convert` method takes as an argument the value to convert from.  Then to perform actual coercion use the `to` or more functional style `>>` method that accepts the type for the returned value which can be `:symbol`, `object` or `ClassName`.
+
+For example, to convert a string to a [range](#36-range) type:
 
 ```ruby
-converter = Necromancer.new
+Necromancer.convert("1-10").to(:range)  # => 1..10
+Necromancer.convert("1-10") >> :range   # => 1..10
+Necromancer.convert("1-10") >> Range    # => 1..10
 ```
 
-Once initialized **Necromancer** knows how to handle numerous conversions and also allows you to add your custom type [converters](#35-custom).
-
-For example, to convert a string to a [range](#34-range) type:
+In order to handle [boolean](#32-boolean) conversions:
 
 ```ruby
-converter.convert('1-10').to(:range)  # => 1..10
+Necromancer.convert("t").to(:boolean)   # => true
+Necromancer.convert("t") >> true        # => true
 ```
 
-In order to handle [boolean](#32-boolean) conversions:
+To convert string to [numeric](#35-numeric) value:
 
 ```ruby
-converter.convert('t').to(:boolean)   # => true
+Necromancer.convert("10e1").to(:numeric)  # => 100
 ```
 
-To convert string to [numeric](#34-numeric) value:
+You can convert string to [array](#31-array) of values like `boolean`, `integer` or `float`:
 
 ```ruby
-converter.convert('10e1').to(:numeric)  # => 100
+Necromancer.convert("t,f,t"]).to(:booleans)      # => [true, false, true]
+Necromancer.convert("1,2.3,3.0"]).to(:integers)  # => [1, 2, 3]
+Necromancer.convert("1,2.3,3.0"]).to(:floats)    # => [1.0, 2.3, 3.0]
 ```
 
-or get [array](#31-array) elements into numeric type:
+To convert string to [hash](#34-hash) value:
 
 ```ruby
-converter.convert(['1', '2.3', '3.0']).to(:numeric)  # => [1, 2.3, 3.0]
+Necromancer.convert("a:1 b:2 c:3").to(:hash) # => {a: "1", b: "2", c: "3"}
+Necromancer.convert("a=1 b=2 c=3").to(:hash) # => {a: "1", b: "2", c: "3"}
+````
+
+To provide extra information about the conversion value type use the `from`:
+
+```ruby
+Necromancer.convert(["1", "2.3", "3.0"]).from(:array).to(:numeric) # => [1, 2.3, 3.0]
 ```
 
-However, if you want to tell **Necromancer** about source type use `from`:
+**Necromancer** also allows you to add [custom](#37-custom) conversions.
+
+When conversion isn't possible, a `Necromancer::NoTypeConversionAvailableError` is thrown indicating that `convert` doesn't know how to perform the requested conversion:
 
 ```ruby
-converter.convert(['1', '2.3', '3.0']).from(:array).to(:numeric) # => [1, 2.3, 3.0]
+Necromancer.convert(:foo).to(:float)
+# => Necromancer::NoTypeConversionAvailableError: Conversion 'foo->float' unavailable.
 ```
 
 ## 2. Interface
@@ -109,13 +130,20 @@ converter.convert(['1', '2.3', '3.0']).from(:array).to(:numeric) # => [1, 2.3, 3
 For the purpose of divination, **Necromancer** uses `convert` method to turn source type into target type. For example, in order to convert a string into a range type do:
 
 ```ruby
-converter.convert('1,10').to(:range)  #  => 1..10
+Necromancer.convert("1,10").to(:range)  #  => 1..10
 ```
 
 Alternatively, you can use block:
 
 ```ruby
-converter.convert { '1,10' }.to(:range) # => 1..10
+Necromancer.convert { "1,10" }.to(:range) # => 1..10
+```
+
+Conversion isn't always possible, in which case a `Necromancer::NoTypeConversionAvailableError` is thrown indicating that `convert` doesn't know how to perform the requested conversion:
+
+```ruby
+Necromancer.convert(:foo).to(:float)
+# => Necromancer::NoTypeConversionAvailableError: Conversion 'foo->float' unavailable.
 ```
 
 ### 2.2 from
@@ -123,45 +151,54 @@ converter.convert { '1,10' }.to(:range) # => 1..10
 To specify conversion source type use `from` method:
 
 ```ruby
-converter.convert('1.0').from(:string).to(:numeric)
+Necromancer.convert("1.0").from(:string).to(:numeric)
 ```
 
 In majority of cases you do not need to specify `from` as the type will be inferred from the `convert` method argument and then appropriate conversion will be applied to result in `target` type such as `:numeric`. However, if you do not control the input to `convert` and want to ensure consistent behaviour please use `from`.
 
 The source parameters are:
 
-* :array
-* :boolean
-* :float
-* :integer
-* :numeric
-* :range
-* :string
+* `:array`
+* `:boolean`
+* `:date`
+* `:datetime`
+* `:float`
+* `:integer`
+* `:numeric`
+* `:range`
+* `:string`
+* `:time`
 
 ### 2.3 to
 
-To convert objects between types, **Necromancer** provides several target types. The `to` method allows you to pass target as an argument to perform actual conversion:
+To convert objects between types, **Necromancer** provides several target types. The `to` or functional style `>>` method allows you to pass target as an argument to perform actual conversion. The target can be one of `:symbol`, `object` or `ClassName`:
 
 ```ruby
-converter.convert('yes').to(:boolean)   # => true
+Necromancer.convert("yes").to(:boolean)   # => true
+Necromancer.convert("yes") >> :boolean    # => true
+Necromancer.convert("yes") >> true        # => true
+Necromancer.convert("yes") >> TrueClass   # => true
 ```
 
-By default, when target conversion fails the orignal value is returned. However, you can pass `strict` as an additional argument to ensure failure when conversion cannot be performed:
+By default, when target conversion fails the original value is returned. However, you can pass `strict` as an additional argument to ensure failure when conversion cannot be performed:
 
 ```ruby
-converter.convert('1a').to(:integer, strict: true)
+Necromancer.convert("1a").to(:integer, strict: true)
 # => raises Necromancer::ConversionTypeError
 ```
 
 The target parameters are:
 
-* :array
-* :boolean
-* :float
-* :integer
-* :numeric
-* :range
-* :string
+* `:array`
+* `:boolean`, `:booleans`, `:bools`, `:boolean_hash`, `:bool_hash`
+* `:date`
+* `:datetime`,
+* `:float`, `:floats`, `:float_hash`
+* `:integer`, `:integers`, `:ints`, `:integer_hash`, `:int_hash`
+* `:numeric`, `:numerics`, `:nums`, `:numeric_hash`, `:num_hash`
+* `:range`
+* `:string`
+* `:time`
 
 ### 2.4 can?
 
@@ -183,7 +220,7 @@ Necromancer.new do |config|
 end
 ```
 
-or calling `configure` method:
+Or calling `configure` method:
 
 ```ruby
 converter = Necromancer.new
@@ -194,129 +231,204 @@ end
 
 Available configuration options are:
 
-* strict - ensures correct types for conversion, by default `false`
-* copy - ensures only copy is modified, by default `true`
+* `strict` - ensures correct types for conversion, by default `false`
+* `copy` - ensures only copy is modified, by default `true`
 
 ## 3. Converters
 
-**Necromancer** flexibility means you can register your own converters or use the already defined converters for such types as 'Array', 'Boolean', 'Hash', 'Numeric', 'Range'.
+**Necromancer** flexibility means you can register your own converters or use the already defined converters for such types as `Array`, `Boolean`, `Date`, `DateTime`, `Hash`, `Numeric`, `Range` and `Time`.
 
 ### 3.1 Array
 
 The **Necromancer** allows you to transform arbitrary object into array:
 
 ```ruby
-converter.convert(nil).to(:array)     # => []
-converter.convert({x: 1}).to(:array)  # => [[:x, 1]]
+Necromancer.convert(nil).to(:array)     # => []
+Necromancer.convert({x: 1}).to(:array)  # => [[:x, 1]]
 ```
 
 In addition, **Necromancer** excels at converting `,` or `-` delimited string into an array object:
 
 ```ruby
-converter.convert('a, b, c').to(:array)  # => ['a', 'b', 'c']
+Necromancer.convert("a, b, c").to(:array)  # => ["a", "b", "c"]
 ```
 
 If the string is a list of `-` or `,` separated numbers, they will be converted to their respective numeric types:
 
 ```ruby
-converter.convert('1 - 2 - 3').to(:array)  # => [1, 2, 3]
+Necromancer.convert("1 - 2 - 3").to(:array)  # => [1, 2, 3]
+```
+
+It handles conversion of string into an array of boolean values as well:
+
+```ruby
+Necromancer.convert("yes,no,t").to(:booleans)    # => [true, false, true]
+Necromancer.convert("1 - f - FALSE").to(:bools)  # => [true, false, false]
 ```
 
 You can also convert array containing string objects to array containing numeric values:
 
 ```ruby
-converter.convert(['1', '2.3', '3.0']).to(:numeric)
+Necromancer.convert(["1", "2.3", "3.0"]).to(:numerics) # => [1, 2.3, 3.0]
+Necromancer.convert(["1", "2.3", "3.0"]).to(:nums)     # => [1, 2.3, 3.0]
+```
+
+Or you can be more specific by using `:integers` and `:floats` as the resulting type:
+
+```ruby
+Necromancer.convert(["1", "2.3", "3.0"]).to(:integers) # => [1, 2, 3]
 ```
 
 When in `strict` mode the conversion will raise a `Necromancer::ConversionTypeError` error like so:
 
 ```ruby
-converter.convert(['1', '2.3', false]).to(:numeric, strict: true)
-# => Necromancer::ConversionTypeError: false cannot be converted from `array` to `numeric`
+Necromancer.convert(["1", "2.3", false]).to(:numerics, strict: true)
+# => Necromancer::ConversionTypeError: false cannot be converted from `array` to `numerics`
 ```
 
 However, in `non-strict` mode the value will be simply returned unchanged:
 
 ```ruby
-converter.convert(['1', '2.3', false]).to(:numeric, strict: false)
+Necromancer.convert(["1", "2.3", false]).to(:numerics, strict: false)
 # => [1, 2.3, false]
 ```
 
 ### 3.2 Boolean
 
-The **Necromancer** allows you to convert a string object to boolean object. The `1`, `'1'`, `'t'`, `'T'`, `'true'`, `'TRUE'`, `'y'`, `'Y'`, `'yes'`, `'Yes'`, `'on'`, `'ON'` values are converted to `TrueClass`.
+The **Necromancer** allows you to convert a string object to boolean object. The `1`, `"1"`, `"t"`, `"T"`, `"true"`, `"TRUE"`, `"y"`, `"Y"`, `"yes"`, `"Yes"`, `"on"`, `"ON"` values are converted to `TrueClass`.
 
 ```ruby
-converter.convert('yes').to(:boolean)  # => true
+Necromancer.convert("yes").to(:boolean)  # => true
 ```
 
-Similarly, the `0`, `'0'`, `'f'`, `'F'`, `'false'`, `'FALSE'`, `'n'`, `'N'`, `'no'`, `'No'`, `'off'`, `'OFF'` values are converted to `FalseClass`.
+Similarly, the `0`, `"0"`, `"f"`, `"F"`, `"false"`, `"FALSE"`, `"n"`, `"N"`, `"no"`, `"No"`, `"off"`, `"OFF"` values are converted to `FalseClass`.
 
 ```ruby
-converter.convert('no').to(:boolean) # => false
+Necromancer.convert("no").to(:boolean) # => false
 ```
 
 You can also convert an integer object to boolean:
 
 ```ruby
-converter.convert(1).to(:boolean)  # => true
-converter.convert(0).to(:boolean)  # => false
+Necromancer.convert(1).to(:boolean)  # => true
+Necromancer.convert(0).to(:boolean)  # => false
+```
+
+### 3.3 DateTime
+
+**Necromancer** knows how to convert string to `date` object:
+
+```ruby
+Necromancer.convert("1-1-2015").to(:date)    # => "2015-01-01"
+Necromancer.convert("01/01/2015").to(:date)  # => "2015-01-01"
+```
+
+You can also convert string to `datetime`:
+
+```ruby
+Necromancer.convert("1-1-2015").to(:datetime)          # => "2015-01-01T00:00:00+00:00"
+Necromancer.convert("1-1-2015 15:12:44").to(:datetime) # => "2015-01-01T15:12:44+00:00"
+```
+
+To convert a string to a time instance do:
+
+```ruby
+Necromancer.convert("01-01-2015").to(:time)       # => 2015-01-01 00:00:00 +0100
+Necromancer.convert("01-01-2015 08:35").to(:time) # => 2015-01-01 08:35:00 +0100
+Necromancer.convert("12:35").to(:time)            # => 2015-01-04 12:35:00 +0100
+```
+
+### 3.4 Hash
+
+With **Necromancer** you can convert a string with pairs delimited by `=` or `:` characters into a hash:
+
+```ruby
+Necromancer.convert("a:1 b:2 c:3").to(:hash)
+Necromancer.convert("a=1 b=2 c=3").to(:hash)
+# => {a: "1", b: "2", c: "3"}
+```
+
+The pairs can be separated by `&` symbols and mix `=` and `:` pair delimiters:
+
+```ruby
+Necromancer.convert("a:1 & b=2 & c:3").to(:hash)
+# => {a: "1", b: "2", c: "3"}
 ```
 
-### 3.3 Hash
+You can also convert string to hash with integer values using `:int_hash` type:
 
 ```ruby
-converter.convert({ x: '27.5', y: '4', z: '11'}).to(:numeric)
-# => { x: 27.5, y: 4, z: 11}
+Necromancer.convert("a:1 b:2 c:3").to(:int_hash)     # => {a: 1, b: 2, c: 3}
+Necromancer.convert("a:1 b:2 c:3").to(:integer_hash) # => {a: 1, b: 2, c: 3}
 ```
 
-### 3.4 Numeric
+Similarly you can convert string to hash with `float` or `numeric` values using `:float_hash` and `numeric_hash` types:
+
+```ruby
+Necromancer.convert("a:1 b:2 c:3").to(:float_hash)    # => {a: 1.0, b: 2.0, c: 3.0}
+Necromancer.convert("a:1 b:2.0 c:3").to(:num_hash)    # => {a: 1, b:2.0, c: 3}
+```
+
+String can also be converted to hash with boolean values using `:boolean_hash` or `:bool_hash`:
+
+```ruby
+Necromancer.convert("a:yes b:no c:t").to(:bool_hash)  # => {a: true, b: false, c: true}
+```
+
+### 3.5 Numeric
 
 **Necromancer** comes ready to convert all the primitive numeric values.
 
 To convert a string to a float do:
 
 ```ruby
-converter.convert('1.2a').to(:float)  #  => 1.2
+Necromancer.convert("1.2a").to(:float)  #  => 1.2
 ```
 
 Conversion to numeric in strict mode raises `Necromancer::ConversionTypeError`:
 
 ```ruby
-converter.convert('1.2a').to(:float, strict: true) # => raises error
+Necromancer.convert("1.2a").to(:float, strict: true) # => raises error
 ```
 
 To convert a string to an integer do:
 
 ```ruby
-converter.convert('1a').to(:integer)  #  => 1
+Necromancer.convert("1a").to(:integer)  #  => 1
 ```
 
 However, if you want to convert string to an appropriate matching numeric type do:
 
 ```ruby
-converter.convert('1e1').to(:numeric)   # => 10
+Necromancer.convert("1e1").to(:numeric)   # => 10
 ```
 
-### 3.5 Range
+### 3.6 Range
 
 **Necromancer** is no stranger to figuring out ranges from strings. You can pass `,`, `-`, `..`, `...` characters to denote ranges:
 
 ```ruby
-converter.convert('1,10').to(:range)  # => 1..10
+Necromancer.convert("1,10").to(:range)  # => 1..10
 ```
 
-or to create a range of letters:
+Or to create a range of letters:
 
 ```ruby
-converter.convert('a-z').to(:range)   # => 'a'..'z'
+Necromancer.convert("a-z").to(:range)   # => "a".."z"
 ```
 
-### 3.6 Custom
+It will handle space characters:
+
+```ruby
+Necromancer.convert("1 . . 10") >> :range   # => 1..10
+Necromancer.convert("a . . . z") >> :range  # =>  "a"..."z"
+````
+
+### 3.7 Custom
 
 In case where provided conversions do not match your needs you can create your own and `register` with **Necromancer** by using an `Object` or a `Proc`.
 
-#### 3.6.1 Using an Object
+#### 3.7.1 Using an Object
 
 Firstly, you need to create a converter that at minimum requires to specify `call` method that will be invoked during conversion:
 
@@ -346,10 +458,10 @@ converter.register(upcase_converter)   # => true if successfully registered
 Finally, by invoking `convert` method and specifying `:upcase` as the target for the conversion we achieve the result:
 
 ```ruby
-converter.convert('magic').to(:upcase)   # => 'MAGIC'
+converter.convert("magic").to(:upcase)   # => "MAGIC"
 ```
 
-#### 3.6.2 Using a Proc
+#### 3.7.2 Using a Proc
 
 Using a Proc object you can create and immediately register a converter. You need to pass `source` and `target` of the conversion that will be used later on to match the conversion. The `convert` allows you to specify the actual conversion in block form. For example:
 
@@ -366,17 +478,23 @@ end
 Then by invoking the `convert` method and passing the `:upcase` conversion type you can transform the string like so:
 
 ```ruby
-converter.convert('magic').to(:upcase)   # => 'MAGIC'
+converter.convert("magic").to(:upcase)   # => "MAGIC"
 ```
 
 ## Contributing
 
-1. Fork it ( https://github.com/peter-murach/necromancer/fork )
+Bug reports and pull requests are welcome on GitHub at https://github.com/piotrmurach/necromancer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+1. Fork it ( https://github.com/piotrmurach/necromancer/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
 
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
 ## Copyright
 
 Copyright (c) 2014 Piotr Murach. See LICENSE for further details.