tidied up README.md

renamed has! to has?

added JSONPointer.Utils to the doctest party

changed add return value so that it brings back the
list that was changed

Author: odogono

CHANGELOG.md

@@ -4,16 +4,21 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
-## Added
+### Added
 - add/add! - adds values indicated by pointers
 - options can be passed to operations. only option so far is :strict which affects set/add behaviour
+- test - checks whether the given pointer has the given value
 
-## Changed
-- has/3 changed to test/3
+### Changed
+- has changed to has? as it returns a single value
 - stricter parsing of integer indexes
 - increased terseness of error messages
 - remove now actually reduces the list size, rather than replace with nil
 
+### Fixed
+- corrected parsing of /~01
+
+
 ## v2.5.0
 ### Added
 - support for special array rules - /01 is not evaluated to an integer

README.md

@@ -12,147 +12,56 @@ An implementation of [JSON Pointer (RFC 6901)](http://tools.ietf.org/html/draft-
 Add a dependency to your project `mix.exs`:
 
 ```Elixir
-
 def deps do
   [{:odgn_json_pointer, "~> 2.5"}]
 end
-
 ```
 
-Then update your dependencies:
-
-```sh-session
-$ mix deps.get
-```
-
-
-## API
-
-### JSONPointer.get(object, pointer)
-
-Retrieves the value indicated by the pointer from the object
+## Basic Usage
 
 ```Elixir
-JSONPointer.get( %{ "fridge" => %{ "door" => "milk" } }, "/fridge/door" )
-# => {:ok, "milk"}
-```
+iex> JSONPointer.get( %{ "fridge" => %{ "door" => "milk" } }, "/fridge/door" )
+{:ok, "milk"}
 
-### JSONPointer.get!(object,pointer)
 
-Retrieves the value indicated by the pointer from the object, and raises an error if not found
+iex> JSONPointer.set( %{}, "/example/msg", "hello")
+{:ok, %{ "example" => %{ "msg" => "hello" }}, nil }
 
-```Elixir
-JSONPointer.get!( %{}, "/fridge/milk" )
-** (ArgumentError) json pointer key not found: fridge
-```
 
-### JSONPointer.set(object, pointer, value)
+iex> JSONPointer.add( %{ "fridge" => [ "milk", "cheese" ]}, "/fridge/1", "salad")
+{:ok, %{ "fridge" => [ "milk", "salad", "cheese" ]}, [ "milk", "cheese" ] }
 
-Sets the value indicated by the pointer in the object
 
-```Elixir
-JSONPointer.set( %{}, "/example/msg", "hello")
-# => {:ok, %{ "example" => %{ "msg" => "hello" }}, nil }
-```
+iex> JSONPointer.has?( %{ "milk" => true, "butter" => false}, "/butter" )
+true
 
-### JSONPointer.set!(object, pointer, value)
 
-Sets the value indicated by the pointer in the object, raises an exception on error
+iex> JSONPointer.test( %{ "milk" => "skimmed", "butter" => false}, "/milk", "skimmed" )
+{:ok, %{ "milk" => "skimmed", "butter" => false} }
 
-```Elixir
-JSONPointer.set!( %{}, "/example/msg", "hello")
-# => %{ "example" => %{ "msg" => "hello" }}
-```
 
-### JSONPointer.dehydrate(object)
+iex> JSONPointer.remove( %{"fridge" => %{ "milk" => true, "butter" => true}}, "/fridge/butter" )
+{:ok, %{"fridge" => %{"milk"=>true}}, true }
 
-Returns an array of JSON pointer paths mapped to their values
 
-```Elixir
-JSONPointer.dehydrate( %{"a"=>%{"b"=>["c","d"]}} )
-# => {:ok, [{"/a/b/0", "c"}, {"/a/b/1", "d"}] }
-```
+iex> JSONPointer.dehydrate( %{"a"=>%{"b"=>["c","d"]}} )
+{:ok, [{"/a/b/0", "c"}, {"/a/b/1", "d"}] }
 
-### JSONPointer.dehydrate!(object)
 
-Returns an array of JSON pointer paths mapped to their values, raises an exception on error
+iex> iex> JSONPointer.hydrate( [ {"/a/1/b", "single"} ] )
+{:ok, %{"a" => %{"1" => %{"b" => "single"}}}}
 
-```Elixir
-JSONPointer.dehydrate!( %{"a"=>%{"b"=>["c","d"]}} )
-# => [{"/a/b/0", "c"}, {"/a/b/1", "d"}]
-```
 
-### JSONPointer.hydrate(container, paths)
+iex> JSONPointer.merge( %{"a"=>1}, %{"b"=>2} )
+{:ok, %{"a"=>1,"b"=>2} }
 
-Applies the given list of paths to the given container
 
-```Elixir
-iex> JSONPointer.hydrate( [ {"/a/1/b", "single"} ] )
-# => {:ok, %{"a" => %{"1" => %{"b" => "single"}}}}
-```
+iex> JSONPointer.transform( %{ "a"=>4, "b"=>%{ "c" => true }}, [ {"/b/c", "/valid"}, {"/a","/count", fn val -> val*2 end} ] )
+{:ok, %{"count" => 8, "valid" => true}}
 
-### JSONPointer.hydrate!(container, paths)
-
-Applies the given list of paths to the given container, raises an exception on error
-
-```Elixir
-iex> JSONPointer.hydrate!( %{}, [ {"/a/b/1", "find"} ] )
-# => {:ok, %{"a"=>%{"b"=>[nil,"find"]} } }
 ```
 
-### JSONPointer.merge(src,dst)
-
-Merges the dst container into src
-
-```Elixir
-JSONPointer.merge( %{"a"=>1}, %{"b"=>2} )
-# => {:ok, %{"a"=>1,"b"=>2} }
-```
-
-### JSONPointer.merge!(src,dst)
-
-Merges the dst container into src, raises an exception on error
-
-```Elixir
-JSONPointer.merge!( %{"a"=>1}, %{"b"=>2} )
-# => %{"a"=>1,"b"=>2}
-```
-
-### JSONPointer.has(object, pointer)
-
-Returns true if the given value exists in the object indicated by the pointer
-
-```Elixir
-JSONPointer.has( %{ "milk" => true, "butter" => false}, "/butter" )
-# => true
-```
-
-### JSONPointer.remove(object, pointer)
-
-Removes the value from the object indicated by the pointer
-
-```Elixir
-JSONPointer.remove( %{"fridge" => %{ "milk" => true, "butter" => true}}, "/fridge/butter" )
-# => {:ok, %{"fridge" => %{"milk"=>true}}, true }
-```
-
-### JSONPointer.transform(src,mapping)
-
-Applies a mapping of source paths to destination paths in the result
-
-```Elixir
-JSONPointer.transform( %{ "a"=>4, "b"=>%{ "c" => true }}, [ {"/b/c", "/valid"}, {"/a","/count", fn val -> val*2 end} ] )
-# => {:ok, %{"count" => 8, "valid" => true}}
-```
-
-### JSONPointer.transform!(src,mapping)
-
-Applies a mapping of source paths to destination paths in the result, raises an error on exception
-
-```Elixir
-JSONPointer.transform!( %{ "a"=>5, "b"=>%{ "is_valid" => true }}, [ {"/b/is_valid", "/valid"}, {"/a","/count", fn val -> val*2 end} ] )
-# => %{"count" => 10, "valid" => true}
-```
+Full documentation can be found at https://hexdocs.pm/odgn_json_pointer.
 
 
 

lib/json_pointer.ex

@@ -111,14 +111,14 @@ defmodule JSONPointer do
   Returns true if the given JSON Pointer resolves to a value
 
   ## Examples
-      iex> JSONPointer.has!( %{ "milk" => true, "butter" => false}, "/butter" )
+      iex> JSONPointer.has?( %{ "milk" => true, "butter" => false}, "/butter" )
       true
 
-      iex> JSONPointer.has!( %{ "milk" => true, "butter" => false}, "/cornflakes" )
+      iex> JSONPointer.has?( %{ "milk" => true, "butter" => false}, "/cornflakes" )
       false
   """
-  @spec has!(container, pointer, options) :: boolean
-  def has!(obj, pointer, options \\ @default_options) do
+  @spec has?(container, pointer, options) :: boolean
+  def has?(obj, pointer, options \\ @default_options) do
     case walk_container(:has, obj, pointer, nil, options) do
       {:ok, _obj, _existing} -> true
       {:error, _, _} -> false
@@ -128,21 +128,15 @@ defmodule JSONPointer do
   @doc """
   Tests whether a JSON Pointer equals the given value
 
+  ## Examples
+    iex> JSONPointer.test( %{ "milk" => "skimmed", "butter" => false}, "/milk", "skimmed" )
+    {:ok, %{ "milk" => "skimmed", "butter" => false} }
+
   """
   @spec test(container, pointer, t, options) :: {:ok, t} | error_message
   def test(obj, pointer, value, options \\ @default_options) do
-    # with {:ok, result, existing} <- walk_container(:has, obj, pointer, nil, options)
-    #   is_equal <- are_equal?
-    #   do
-
-    #   else
-    #     {:error, msg, _ } -> {:error, msg}
-    #   end
-
     case walk_container(:get, obj, pointer, nil, options) do
       {:ok, result, _} ->
-        # IO.puts("are_equal?  #{pointer} => '#{value}' '#{result}'")
-
         case are_equal?(value, result) do
           {:ok, _} -> {:ok, obj}
           {:error, msg} -> {:error, msg}
@@ -153,27 +147,22 @@ defmodule JSONPointer do
     end
   end
 
-  # defp are_equal?(val1, val2) when is_binary(val1) and is_binary(val2),
-  #   do:
-  #     if(String.equivalent?(val1, val2), do: {:ok, true}, else: {:error, "string not equivalent"})
-
-  defp are_equal?(val1, val2) when is_binary(val1) and is_number(val2),
-    do: {:error, "number is not equal to string"}
+  @doc """
+  Tests whether a JSON Pointer equals the given value, raises an error if they don't
 
-  defp are_equal?(val1, val2) when is_number(val1) and is_binary(val2),
-    do: {:error, "string is not equal to number"}
+  ## Examples
+    iex> JSONPointer.test!( %{ "milk" => "skimmed", "butter" => false}, "/butter", "unsalted" )
+    ** (ArgumentError) not equal
 
-  defp are_equal?(val1, val2) do
-    if val1 == val2 do
-      {:ok, true}
-    else
-      are_not_equal_error(val1,val2)
+  """
+  @spec test!(container, pointer, t, options) :: t | no_return
+  def test!(obj, pointer, value, options \\ @default_options) do
+    case test(obj, pointer, value, options) do
+      {:ok, result} -> result
+      {:error, msg} -> raise ArgumentError, message: msg
     end
   end
 
-  defp are_not_equal_error(val1,val2) when is_binary(val1) and is_binary(val2), do: {:error, "string not equivalent"}
-  defp are_not_equal_error(_val1,_val2), do: {:error, "not equal"}
-
   @doc """
   Removes an attribute of object referenced by pointer
 
@@ -238,6 +227,9 @@ defmodule JSONPointer do
   Follows the JSON patch behaviour specified in rfc6902
 
   ## Examples
+      iex> JSONPointer.add( %{ "fridge" => [ "milk", "cheese" ] }, "/fridge/1", "salad")
+      {:ok, %{ "fridge" => [ "milk", "salad", "cheese" ]}, [ "milk", "cheese" ] }
+
       iex> JSONPointer.add( %{ "a" => %{"b" => %{}}}, "/a/b/c", ["foo", "bar"] )
       {:ok, %{"a" => %{"b" => %{"c" => ["foo", "bar"]}}}, nil}
   """
@@ -624,7 +616,8 @@ defmodule JSONPointer do
         if is_strict && (index < 0 || index > Enum.count(list)) do
           {:error, "index out of bounds: #{index}", list}
         else
-          {:ok, insert_into(list, index, value), Enum.at(list, index)}
+          # Enum.at(list, index)}
+          {:ok, insert_into(list, index, value), list}
         end
     end
   end
@@ -863,7 +856,6 @@ defmodule JSONPointer do
           if (operation == :get or operation == :has) and index >= Enum.count(list) do
             {:error, "index out of bounds: #{index}", list}
           else
-
             {res, sub, rem} =
               walk_container(
                 operation,
@@ -876,7 +868,10 @@ defmodule JSONPointer do
               )
 
             # a sublety of adding over setting
-            if operation == :add, do: {res, apply_into( list, index, sub ), list}, else: {res, sub, rem}
+            if operation == :add,
+              do: {res, apply_into(list, index, sub), list},
+              else: {res, sub, rem}
+
             # {res, [sub], list}
           end
       end