diff --git a/.credo.exs b/.credo.exs
index 95806420..21eb66be 100644
--- a/.credo.exs
+++ b/.credo.exs
@@ -21,8 +21,8 @@
         # You can give explicit globs or simply directories.
         # In the latter case `**/*.{ex,exs}` will be used.
         #
-        included: ["lib/", "src/", "web/", "apps/"],
-        excluded: [~r"/_build/", ~r"/deps/"]
+        included: ["lib/", "src/", "test/", "web/", "apps/", "bench/", "mix.exs"],
+        excluded: [~r"/_build/", ~r"/deps/", ~r"/node_modules/"]
       },
       #
       # If you create your own checks, you must specify the source files for
@@ -33,7 +33,7 @@
       # If you want to enforce a style guide and need a more traditional linting
       # experience, you can change `strict` to `true` below:
       #
-      strict: false,
+      strict: true,
       #
       # If you want to use uncolored output by default, you can change `color`
       # to `false` below:
@@ -48,6 +48,9 @@
       #     {Credo.Check.Design.DuplicatedCode, false}
       #
       checks: [
+        #
+        ## Consistency Checks
+        #
         {Credo.Check.Consistency.ExceptionNames},
         {Credo.Check.Consistency.LineEndings},
         {Credo.Check.Consistency.ParameterPatternMatching},
@@ -55,11 +58,13 @@
         {Credo.Check.Consistency.SpaceInParentheses},
         {Credo.Check.Consistency.TabsOrSpaces},
 
+        #
+        ## Design Checks
+        #
         # You can customize the priority of any check
         # Priority values are: `low, normal, high, higher`
         #
         {Credo.Check.Design.AliasUsage, priority: :low},
-
         # For some checks, you can also set other parameters
         #
         # If you don't want the `setup` and `test` macro calls in ExUnit tests
@@ -67,7 +72,6 @@
         # set the `excluded_macros` parameter to `[:schema, :setup, :test]`.
         #
         {Credo.Check.Design.DuplicatedCode, excluded_macros: []},
-
         # You can also customize the exit_status of each check.
         # If you don't want TODO comments to cause `mix credo` to fail, just
         # set this value to 0 (zero).
@@ -75,11 +79,15 @@
         {Credo.Check.Design.TagTODO, exit_status: 2},
         {Credo.Check.Design.TagFIXME},
 
+        #
+        ## Readability Checks
+        #
+        {Credo.Check.Readability.AliasOrder},
         {Credo.Check.Readability.FunctionNames},
         {Credo.Check.Readability.LargeNumbers},
         {Credo.Check.Readability.MaxLineLength, priority: :low, max_length: 80},
         {Credo.Check.Readability.ModuleAttributeNames},
-        {Credo.Check.Readability.ModuleDoc, false},
+        {Credo.Check.Readability.ModuleDoc},
         {Credo.Check.Readability.ModuleNames},
         {Credo.Check.Readability.ParenthesesOnZeroArityDefs},
         {Credo.Check.Readability.ParenthesesInCondition},
@@ -93,18 +101,26 @@
         {Credo.Check.Readability.Semicolons},
         {Credo.Check.Readability.SpaceAfterCommas},
 
+        #
+        ## Refactoring Opportunities
+        #
         {Credo.Check.Refactor.DoubleBooleanNegation},
         {Credo.Check.Refactor.CondStatements},
         {Credo.Check.Refactor.CyclomaticComplexity},
         {Credo.Check.Refactor.FunctionArity},
         {Credo.Check.Refactor.LongQuoteBlocks},
+        {Credo.Check.Refactor.MapInto},
         {Credo.Check.Refactor.MatchInCondition},
         {Credo.Check.Refactor.NegatedConditionsInUnless},
         {Credo.Check.Refactor.NegatedConditionsWithElse},
         {Credo.Check.Refactor.Nesting},
-        {Credo.Check.Refactor.PipeChainStart},
+        {Credo.Check.Refactor.PipeChainStart,
+         excluded_argument_types: [:atom, :binary, :fn, :keyword], excluded_functions: []},
         {Credo.Check.Refactor.UnlessWithElse},
 
+        #
+        ## Warnings
+        #
         {Credo.Check.Warning.BoolOperationOnSameValues},
         {Credo.Check.Warning.ExpensiveEmptyEnumCheck},
         {Credo.Check.Warning.IExPry},
@@ -120,8 +136,9 @@
         {Credo.Check.Warning.UnusedRegexOperation},
         {Credo.Check.Warning.UnusedStringOperation},
         {Credo.Check.Warning.UnusedTupleOperation},
-        {Credo.Check.Warning.RaiseInsideRescue, false},
+        {Credo.Check.Warning.RaiseInsideRescue},
 
+        #
         # Controversial and experimental checks (opt-in, just remove `, false`)
         #
         {Credo.Check.Refactor.ABCSize, false},
@@ -130,14 +147,12 @@
         {Credo.Check.Warning.MapGetUnsafePass, false},
         {Credo.Check.Consistency.MultiAliasImportRequireUse, false},
 
+        #
         # Deprecated checks (these will be deleted after a grace period)
         #
-        {Credo.Check.Readability.Specs, false},
-        {Credo.Check.Warning.NameRedeclarationByAssignment, false},
-        {Credo.Check.Warning.NameRedeclarationByCase, false},
-        {Credo.Check.Warning.NameRedeclarationByDef, false},
-        {Credo.Check.Warning.NameRedeclarationByFn, false},
+        {Credo.Check.Readability.Specs, false}
 
+        #
         # Custom checks can be created using `mix credo.gen.check`.
         #
       ]
diff --git a/.tool-versions b/.tool-versions
index a7872366..111f52e6 100644
--- a/.tool-versions
+++ b/.tool-versions
@@ -1,2 +1,2 @@
 erlang 21.0.4
-elixir 1.7.0
+elixir 1.7.1
diff --git a/.travis.yml b/.travis.yml
index d56f2fc8..463084d2 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,6 @@
 language: elixir
 elixir:
+  - 1.7.1
   - 1.7.0
   - 1.6.6
   - 1.6.5
@@ -9,3 +10,10 @@ otp_release:
   - 20.1
   - 20.0
 sudo: false
+before_script:
+  - |
+    if [ "$TRAVIS_ELIXIR_VERSION|$TRAVIS_OTP_RELEASE" == "1.7.1|21.0" ]; then
+      set -e;
+      mix archive.install hex credo '~> 0.9' --force;
+      mix credo --strict;
+    fi
diff --git a/README.md b/README.md
index be958787..085214d7 100644
--- a/README.md
+++ b/README.md
@@ -68,9 +68,9 @@ could simply call `Poison.Parser.parse`.
 ## Parser
 
 ```iex
-iex> Poison.Parser.parse!(~s({"name": "Devin Torres", "age": 27}))
+iex> Poison.Parser.parse!(~s({"name": "Devin Torres", "age": 27}), %{})
 %{"name" => "Devin Torres", "age" => 27}
-iex> Poison.Parser.parse!(~s({"name": "Devin Torres", "age": 27}), keys: :atoms!)
+iex> Poison.Parser.parse!(~s({"name": "Devin Torres", "age": 27}), %{keys: :atoms!})
 %{name: "Devin Torres", age: 27}
 ```
 
@@ -90,7 +90,7 @@ for more info:
 ## Encoder
 
 ```iex
-iex> IO.puts Poison.Encoder.encode([1, 2, 3], [])
+iex> Poison.Encoder.encode([1, 2, 3], %{}) |> IO.iodata_to_binary
 "[1,2,3]"
 ```
 
@@ -148,7 +148,7 @@ ensure that your generated JSON doesn't have this issue, you can pass the
 
 ```iex
 iex> Poison.encode!(%{:foo => "foo1", "foo" => "foo2"}, strict_keys: true)
-** (Poison.EncodeError) duplicate key found: "foo"
+** (Poison.EncodeError) duplicate key found: :foo
 ```
 
 ## Benchmarking
diff --git a/lib/poison.ex b/lib/poison.ex
index 782b28e8..b2f54636 100644
--- a/lib/poison.ex
+++ b/lib/poison.ex
@@ -1,7 +1,11 @@
 defmodule Poison do
-  alias Poison.{Encoder, EncodeError}
-  alias Poison.{Parser, ParseError}
-  alias Poison.{Decode, Decoder, DecodeError}
+  @readme_path [__DIR__, "..", "README.md"] |> Path.join |> Path.expand
+  @external_resource @readme_path
+  @moduledoc @readme_path |> File.read! |> String.trim
+
+  alias Poison.{Decode, DecodeError, Decoder}
+  alias Poison.{EncodeError, Encoder}
+  alias Poison.{ParseError, Parser}
 
   @doc """
   Encode a value to JSON.
diff --git a/lib/poison/encoder.ex b/lib/poison/encoder.ex
index a02e656f..fe57f44a 100644
--- a/lib/poison/encoder.ex
+++ b/lib/poison/encoder.ex
@@ -15,12 +15,12 @@ end
 defmodule Poison.Encode do
   @moduledoc false
 
-  alias Poison.{Encoder, EncodeError}
+  alias Poison.{EncodeError, Encoder}
 
   defmacro __using__(_) do
     quote do
-      alias String.Chars
       alias Poison.EncodeError
+      alias String.Chars
 
       @compile {:inline, encode_name: 1}
 
@@ -53,7 +53,7 @@ defmodule Poison.Pretty do
       @compile {:inline, pretty: 1, indent: 1, offset: 1, offset: 2, spaces: 1}
 
       defp pretty(options) do
-        !!Map.get(options, :pretty)
+        Map.get(options, :pretty) == true
       end
 
       defp indent(options) do
@@ -141,7 +141,7 @@ defimpl Poison.Encoder, for: BitString do
   end
 
   # http://en.wikipedia.org/wiki/UTF-16#Example_UTF-16_encoding_procedure
-  # http://unicodebook.readthedocs.org/unicode_encodings.html#utf-16-surrogate-pairs
+  # http://unicodebook.readthedocs.org/unicode_encodings.html
   defp escape(<<char :: utf8>> <> rest, :unicode) when char > 0xFFFF do
     code = char - 0x10000
     [seq(0xD800 ||| (code >>> 10)),
diff --git a/lib/poison/parser.ex b/lib/poison/parser.ex
index f812c651..87bfb12b 100644
--- a/lib/poison/parser.ex
+++ b/lib/poison/parser.ex
@@ -49,6 +49,14 @@ defmodule Poison.Parser do
 
   @type t :: nil | true | false | list | float | integer | String.t | map
 
+  defmacrop stacktrace do
+    if Version.compare(System.version, "1.7.0") != :lt do
+      quote do: __STACKTRACE__
+    else
+      quote do: System.stacktrace()
+    end
+  end
+
   def parse!(iodata, options) do
     string = IO.iodata_to_binary(iodata)
     keys = Map.get(options, :keys)
@@ -59,8 +67,8 @@ defmodule Poison.Parser do
       {other, pos} -> syntax_error(other, pos)
     end
   rescue
-    _ in [ArgumentError] ->
-      raise %ParseError{value: iodata}
+    ArgumentError ->
+      reraise %ParseError{value: iodata}, stacktrace()
   end
 
   defp value("\"" <> rest, pos, _keys) do
@@ -119,8 +127,8 @@ defmodule Poison.Parser do
   defp object_name(name, pos, :atoms!) do
     String.to_existing_atom(name)
   rescue
-    _ in [ArgumentError] ->
-      raise %ParseError{value: name, pos: pos}
+    ArgumentError ->
+      reraise %ParseError{value: name, pos: pos}, stacktrace()
   end
 
   defp object_name(name, _pos, :atoms), do: String.to_atom(name)
@@ -208,7 +216,7 @@ defmodule Poison.Parser do
   rescue
     ArgumentError ->
       value = iolist |> IO.iodata_to_binary
-      raise %ParseError{pos: pos, value: value}
+      reraise %ParseError{pos: pos, value: value}, stacktrace()
   end
 
   defp number_digits(<<char>> <> rest = string, pos) when char in '0123456789' do
@@ -264,15 +272,16 @@ defmodule Poison.Parser do
   rescue
     ArgumentError ->
       value = <<"\\u", a1, b1, c1, d1, "\\u", a2, b2, c2, d2>>
-      raise %ParseError{pos: pos + 12, value: value}
+      reraise %ParseError{pos: pos + 12, value: value}, stacktrace()
   end
 
   defp string_escape(<<?u, seq :: binary-size(4)>> <> rest, pos, acc) do
-    string_continue(rest, pos + 5, [acc, <<String.to_integer(seq, 16) :: utf8>>])
+    code = String.to_integer(seq, 16)
+    string_continue(rest, pos + 5, [acc, <<code :: utf8>>])
   rescue
     ArgumentError ->
       value = "\\u" <> seq
-      raise %ParseError{pos: pos + 6, value: value}
+      reraise %ParseError{pos: pos + 6, value: value}, stacktrace()
   end
 
   defp string_escape(other, pos, _), do: syntax_error(other, pos)
diff --git a/mix.exs b/mix.exs
index f2263c46..74516493 100644
--- a/mix.exs
+++ b/mix.exs
@@ -1,7 +1,9 @@
 defmodule Poison.Mixfile do
   use Mix.Project
 
-  @version File.read!("VERSION") |> String.trim
+  @version_path Path.join([__DIR__, "VERSION"])
+  @external_resource @version_path
+  @version @version_path |> File.read! |> String.trim
 
   def project do
     [app: :poison,
diff --git a/test/poison/decoder_test.exs b/test/poison/decoder_test.exs
index 91c671a3..f1eb7dbb 100644
--- a/test/poison/decoder_test.exs
+++ b/test/poison/decoder_test.exs
@@ -31,17 +31,20 @@ defmodule Poison.DecoderTest do
 
   test "decoding single :as with string keys" do
     person = %{"name" => "Devin Torres", "age" => 27}
-    assert transform(person, %{as: %Person{}}) == %Person{name: "Devin Torres", age: 27}
+    expected = %Person{name: "Devin Torres", age: 27}
+    assert transform(person, %{as: %Person{}}) == expected
   end
 
   test "decoding single :as with atom keys" do
     person = %{name: "Devin Torres", age: 27}
-    assert transform(person, %{keys: :atoms!, as: %Person{}}) == %Person{name: "Devin Torres", age: 27}
+    expected = %Person{name: "Devin Torres", age: 27}
+    assert transform(person, %{keys: :atoms!, as: %Person{}}) == expected
   end
 
   test "decoding :as list with string keys" do
     person = [%{"name" => "Devin Torres", "age" => 27}]
-    assert transform(person, %{as: [%Person{}]}) == [%Person{name: "Devin Torres", age: 27}]
+    expected = [%Person{name: "Devin Torres", age: 27}]
+    assert transform(person, %{as: [%Person{}]}) == expected
   end
 
   test "decoding nested :as with string keys" do
@@ -67,62 +70,86 @@ defmodule Poison.DecoderTest do
 
   test "decoding into structs with key subset" do
     person = %{"name" => "Devin Torres", "age" => 27, "dob" => "1987-01-29"}
-    assert transform(person, %{as: %Person{}}) == %Person{name: "Devin Torres", age: 27}
+    expected = %Person{name: "Devin Torres", age: 27}
+    assert transform(person, %{as: %Person{}}) == expected
   end
 
   test "decoding into structs with default values" do
     person = %{"name" => "Devin Torres"}
-    assert transform(person, %{as: %Person{age: 50}}) == %Person{name: "Devin Torres", age: 50}
+    expected = %Person{name: "Devin Torres", age: 50}
+    assert transform(person, %{as: %Person{age: 50}}) == expected
   end
 
   test "decoding into structs with unspecified default values" do
     person = %{"name" => "Devin Torres"}
-    assert transform(person, %{as: %Person{}}) == %Person{name: "Devin Torres", age: 42}
+    expected = %Person{name: "Devin Torres", age: 42}
+    assert transform(person, %{as: %Person{}}) == expected
   end
 
   test "decoding into structs with unspecified default values and atom keys" do
     person = %{:name => "Devin Torres"}
-    assert transform(person, %{as: %Person{}, keys: :atoms!}) == %Person{name: "Devin Torres", age: 42}
+    expected = %Person{name: "Devin Torres", age: 42}
+    assert transform(person, %{as: %Person{}, keys: :atoms!}) == expected
   end
 
   test "decoding into structs with nil overriding defaults" do
     person = %{"name" => "Devin Torres", "age" => nil}
-    assert transform(person, %{as: %Person{}}) == %Person{name: "Devin Torres", age: nil}
+    expected = %Person{name: "Devin Torres", age: nil}
+    assert transform(person, %{as: %Person{}}) == expected
   end
 
   test "decoding into nested structs" do
     person = %{"name" => "Devin Torres", "contact" => %{"email" => "devin@torres.com"}}
-    assert transform(person, %{as: %Person{contact: %Contact{}}}) == %Person{name: "Devin Torres", contact: %Contact{email: "devin@torres.com"}}
+    expected = %Person{name: "Devin Torres", contact: %Contact{email: "devin@torres.com"}}
+    assert transform(person, %{as: %Person{contact: %Contact{}}}) == expected
   end
 
   test "decoding into nested struct, empty nested struct" do
     person = %{"name" => "Devin Torres"}
-    assert transform(person, %{as: %Person{contact: %Contact{}}}) == %Person{name: "Devin Torres"}
+    expected = %Person{name: "Devin Torres"}
+    assert transform(person, %{as: %Person{contact: %Contact{}}}) == expected
   end
 
   test "decoding into nested struct list" do
-    person = %{"name" => "Devin Torres", "contacts" => [%{"email" => "devin@torres.com", "call_count" => 10}, %{"email" => "test@email.com"}]}
+    person = %{
+      "name" => "Devin Torres",
+      "contacts" => [
+        %{"email" => "devin@torres.com", "call_count" => 10},
+        %{"email" => "test@email.com"}
+      ]
+    }
+
     expected = %Person2{
       name: "Devin Torres",
       contacts: [
         %Contact2{email: "devin@torres.com", call_count: 10},
         %Contact2{email: "test@email.com", call_count: 0}
-      ]}
+      ]
+    }
 
     decoded = transform(person, %{as: %Person2{contacts: [%Contact2{}]}})
     assert decoded == expected
   end
 
   test "decoding into nested struct list with keys = :atoms" do
-    person = %{name: "Devin Torres", contacts: [%{email: "devin@torres.com", call_count: 10}, %{email: "test@email.com"}]}
+    person = %{
+      name: "Devin Torres",
+      contacts: [
+        %{email: "devin@torres.com", call_count: 10},
+        %{email: "test@email.com"}
+      ]
+    }
+
     expected = %Person2{
       name: "Devin Torres",
       contacts: [
         %Contact2{email: "devin@torres.com", call_count: 10},
         %Contact2{email: "test@email.com", call_count: 0}
-      ]}
+      ]
+    }
 
-    decoded = transform(person, %{as: %Person2{contacts: [%Contact2{}]}, keys: :atoms})
+    as = %Person2{contacts: [%Contact2{}]}
+    decoded = transform(person, %{as: as, keys: :atoms})
     assert decoded == expected
   end
 
@@ -134,17 +161,21 @@ defmodule Poison.DecoderTest do
       contacts: []
     }
 
-    assert transform(person, %{as: %Person2{contacts: [%Contact{}]}}) == expected
+    as = %Person2{contacts: [%Contact{}]}
+    assert transform(person, %{as: as}) == expected
   end
 
   test "decoding into nested structs list with nil overriding default" do
     person = %{"name" => "Devin Torres", "contacts" => nil}
-    assert transform(person, %{as: %Person2{contacts: [%Contact{}]}}) == %Person2{name: "Devin Torres", contacts: nil}
+    expected = %Person2{name: "Devin Torres", contacts: nil}
+    as = %Person2{contacts: [%Contact{}]}
+    assert transform(person, %{as: as}) == expected
   end
 
   test "decoding into nested structs with nil overriding defaults" do
     person = %{"name" => "Devin Torres", "contact" => nil}
-    assert transform(person, %{as: %Person{contact: %Contact{}}}) == %Person{name: "Devin Torres", contact: nil}
+    expected = %Person{name: "Devin Torres", contact: nil}
+    assert transform(person, %{as: %Person{contact: %Contact{}}}) == expected
   end
 
   test "decoding using a defined decoder" do
diff --git a/test/poison/encoder_test.exs b/test/poison/encoder_test.exs
index 433104a9..bb581874 100644
--- a/test/poison/encoder_test.exs
+++ b/test/poison/encoder_test.exs
@@ -1,7 +1,7 @@
 defmodule Poison.EncoderTest do
   use ExUnit.Case, async: true
 
-  alias Poison.EncodeError
+  alias Poison.{EncodeError, Encoder}
 
   test "Atom" do
     assert to_json(nil) == "null"
@@ -53,7 +53,8 @@ defmodule Poison.EncoderTest do
 
     multi_key_map = %{"foo" => "foo1", :foo => "foo2"}
     assert to_json(multi_key_map) == ~s({"foo":"foo1","foo":"foo2"})
-    assert Poison.encode(multi_key_map, strict_keys: true) == {:error, %Poison.EncodeError{message: "duplicate key found: :foo", value: "foo"}}
+    error = %EncodeError{message: "duplicate key found: :foo", value: "foo"}
+    assert Poison.encode(multi_key_map, strict_keys: true) == {:error, error}
   end
 
   test "List" do
@@ -135,14 +136,20 @@ defmodule Poison.EncoderTest do
   end
 
   test "DateTime" do
-    datetime = %DateTime{year: 2000, month: 1, day: 1, hour: 12, minute: 13, second: 14,
-                         microsecond: {0, 0}, zone_abbr: "CET", time_zone: "Europe/Warsaw",
-                         std_offset: -1800, utc_offset: 3600}
+    datetime = %DateTime{
+      year: 2000, month: 1, day: 1, hour: 12, minute: 13, second: 14,
+      microsecond: {0, 0}, zone_abbr: "CET", time_zone: "Europe/Warsaw",
+      std_offset: -1800, utc_offset: 3600
+    }
+
     assert to_json(datetime) == ~s("2000-01-01T12:13:14+00:30")
 
-    datetime = %DateTime{year: 2000, month: 1, day: 1, hour: 12, minute: 13, second: 14,
-                         microsecond: {50000, 3}, zone_abbr: "UTC", time_zone: "Etc/UTC",
-                         std_offset: 0, utc_offset: 0}
+    datetime = %DateTime{
+      year: 2000, month: 1, day: 1, hour: 12, minute: 13, second: 14,
+      microsecond: {50_000, 3}, zone_abbr: "UTC", time_zone: "Etc/UTC",
+      std_offset: 0, utc_offset: 0
+    }
+
     assert to_json(datetime) == ~s("2000-01-01T12:13:14.050Z")
   end
 
@@ -168,8 +175,8 @@ defmodule Poison.EncoderTest do
   test "@derive" do
     derived = %Derived{name: "derived"}
     non_derived = %NonDerived{name: "non-derived"}
-    assert Poison.Encoder.impl_for!(derived) == Poison.Encoder.Poison.EncoderTest.Derived
-    assert Poison.Encoder.impl_for!(non_derived) == Poison.Encoder.Any
+    assert Encoder.impl_for!(derived) == Encoder.Poison.EncoderTest.Derived
+    assert Encoder.impl_for!(non_derived) == Encoder.Any
 
     derived_using_only = %DerivedUsingOnly{name: "derived using :only", size: 10}
     assert Poison.decode!(to_json(derived_using_only)) == %{"name" => "derived using :only"}
@@ -194,7 +201,7 @@ defmodule Poison.EncoderTest do
 
   defp to_json(value, options \\ []) do
     value
-    |> Poison.Encoder.encode(Map.new(options))
+    |> Encoder.encode(Map.new(options))
     |> IO.iodata_to_binary
   end
 end
diff --git a/test/poison/parser_test.exs b/test/poison/parser_test.exs
index 651b2cca..f1568bf4 100644
--- a/test/poison/parser_test.exs
+++ b/test/poison/parser_test.exs
@@ -31,7 +31,7 @@ defmodule Poison.ParserTest do
     assert parse!("0.1e-1") == 0.1e-1
     assert parse!("99.99e99") == 99.99e99
     assert parse!("-99.99e-99") == -99.99e-99
-    assert parse!("123456789.123456789e123") == 123456789.123456789e123
+    assert parse!("123456789.123456789e123") == 123_456_789.123456789e123
   end
 
   test "strings" do