hana 1.0.1 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5593991a2078ce9a518e6815df0eae13a5a6b016
+  data.tar.gz: b03db1e4ec9245bde4757190b51ec19b5084a932
+SHA512:
+  metadata.gz: 9a71e96247335c047ba05d71beb6eab4f65813e667c021b9e6a36769b0564d93a099326a1a06ac474dbf7a645978255ca4d193ada800e32837bcd7bf601edb0c
+  data.tar.gz: 86379cd00f01187cd5e504ba301c1041170b36f05b6d1ef53c8025cea539577375edc3b4d6f69d94a6fefa60df1d61417ceccfa4792a882b4fcd6ad5f62718f8

data/Manifest.txt

@@ -5,5 +5,8 @@ README.md
 Rakefile
 lib/hana.rb
 test/helper.rb
+test/json-patch-tests/README.md
+test/json-patch-tests/spec_tests.json
+test/json-patch-tests/tests.json
 test/test_hana.rb
-test/test_patch.rb
+test/test_ietf.rb

data/lib/hana.rb

@@ -1,5 +1,5 @@
 module Hana
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 
   class Pointer
     include Enumerable
@@ -8,23 +8,24 @@ module Hana
       @path = Pointer.parse path
     end
 
-    def each
-      @path.each { |x| yield x }
-    end
-
-    def to_a; @path.dup; end
+    def each(&block); @path.each(&block); end
+    def to_a;         @path.dup; end
 
     def eval object
       Pointer.eval @path, object
     end
 
+    ESC = {'^/' => '/', '^^' => '^', '~0' => '~', '~1' => '/'} # :nodoc:
+
     def self.eval list, object
       list.inject(object) { |o, part| o[(Array === o ? part.to_i : part)] }
     end
 
     def self.parse path
-      path.sub(/^\//, '').split(/(?<!\^)\//).map { |part|
-        part.gsub(/\^([\/^])/, '\1')
+      return [''] if path == '/'
+
+      path.sub(/^\//, '').split(/(?<!\^)\//).map! { |part|
+        part.gsub!(/\^[\/^]|~[01]/) { |m| ESC[m] }; part
       }
     end
   end
@@ -33,73 +34,119 @@ module Hana
     class Exception < StandardError
     end
 
+    class FailedTestException < Exception
+      attr_accessor :path, :value
+
+      def initialize path, value
+        super "expected #{value} at #{path}"
+        @path  = path
+        @value = value
+      end
+    end
+
+    class OutOfBoundsException < Exception
+    end
+
+    class ObjectOperationOnArrayException < Exception
+    end
+
     def initialize is
       @is = is
     end
 
-    VALID = Hash[%w{ add move test replace remove }.map { |x| [x,x]}] # :nodoc:
+    VALID = Hash[%w{ add move test replace remove copy }.map { |x| [x,x]}] # :nodoc:
 
     def apply doc
-      @is.each_with_object(doc) { |ins, doc|
-        send VALID.fetch(ins.keys.sort.first) { |k|
+      @is.each_with_object(doc) { |ins, d|
+        send VALID.fetch(ins['op'].strip) { |k|
           raise Exception, "bad method `#{k}`"
-        }, ins, doc
+        }, ins, d
       }
     end
 
     private
 
     def add ins, doc
-      list = Pointer.parse ins['add']
+      list = Pointer.parse ins['path']
       key  = list.pop
-      obj  = Pointer.eval list, doc
+      dest = Pointer.eval list, doc
+      obj  = ins['value']
 
-      if Array === obj
-        obj.insert key.to_i, ins['value']
-      else
-        obj[key] = ins['value']
-      end
+      add_op dest, key, obj
     end
 
     def move ins, doc
-      from     = Pointer.parse ins['move']
-      to       = Pointer.parse ins['to']
+      from     = Pointer.parse ins['from']
+      to       = Pointer.parse ins['path']
       from_key = from.pop
-      to_key   = to.pop
+      key      = to.pop
+      src      = Pointer.eval from, doc
+      dest     = Pointer.eval to, doc
 
-      src  = Pointer.eval(from, doc)
+      obj = rm_op src, from_key
+      add_op dest, key, obj
+    end
+
+    def copy ins, doc
+      from     = Pointer.parse ins['from']
+      to       = Pointer.parse ins['path']
+      from_key = from.pop
+      key      = to.pop
+      src      = Pointer.eval from, doc
+      dest     = Pointer.eval to, doc
 
       if Array === src
-        obj = src.delete_at from_key.to_i
+        obj = src.fetch from_key.to_i
       else
-        obj = src.delete from_key
+        obj = src.fetch from_key
       end
 
-      dest = Pointer.eval(to, doc)
-
-      if Array === dest
-        dest.insert to_key.to_i, obj
-      else
-        dest[to_key] = obj
-      end
+      add_op dest, key, obj
     end
 
     def test ins, doc
-      expected = Pointer.new(ins['test']).eval doc
-      raise Exception unless expected == ins['value']
+      expected = Pointer.new(ins['path']).eval doc
+
+      unless expected == ins['value']
+        raise FailedTestException.new(ins['value'], ins['path'])
+      end
     end
 
     def replace ins, doc
-      list = Pointer.parse ins['replace']
+      list = Pointer.parse ins['path']
       key  = list.pop
-      Pointer.eval(list, doc)[key] = ins['value']
+      obj  = Pointer.eval list, doc
+
+      if Array === obj
+        obj[key.to_i] = ins['value']
+      else
+        obj[key] = ins['value']
+      end
     end
 
     def remove ins, doc
-      list = Pointer.parse ins['remove']
+      list = Pointer.parse ins['path']
       key  = list.pop
       obj  = Pointer.eval list, doc
+      rm_op obj, key
+    end
+
+    def check_index obj, key
+      raise ObjectOperationOnArrayException unless key =~ /\A-?\d+\Z/
+      idx = key.to_i
+      raise OutOfBoundsException if idx > obj.length || idx < 0
+      idx
+    end
+
+    def add_op dest, key, obj
+      if Array === dest
+        dest.insert check_index(dest, key), obj
+      else
+        dest[key] = obj
+      end
+    end
 
+    def rm_op obj, key
       if Array === obj
         obj.delete_at key.to_i
       else

data/test/json-patch-tests/README.md

@@ -0,0 +1,50 @@
+JSON Patch Tests
+================
+
+These are test cases for implementations of the [IETF JSON Patch
+draft](http://tools.ietf.org/html/draft-ietf-appsawg-json-patch).
+
+
+Test Format
+-----------
+
+Each test file is a JSON document that contains an array of test records. A
+test record is an object with the following members:
+
+- doc: The JSON document to test against
+- patch: The patch(es) to apply
+- expected: The expected resulting document, OR
+- error: A string describing an expected error
+- comment: A string describing the test
+- disabled: True if the test should be skipped
+
+All fields except 'doc' and 'patch' are optional. Test records consisting only
+of a comment are also OK.
+
+These tests are not complete, or even correct - help welcome!
+
+
+Credits
+-------
+
+The seed test set was adapted from Byron Ruth's
+[jsonpatch-js](https://github.com/bruth/jsonpatch-js/blob/master/test.js) and
+extended by [Mike McCabe](https://github.com/mikemccabe).
+
+
+License
+-------
+
+   Copyright 2012 The Authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/test/json-patch-tests/spec_tests.json

@@ -0,0 +1,203 @@
+[
+  {
+    "comment": "A.1.  Adding an Object Member",
+    "doc": {
+  "foo": "bar"
+},
+    "patch": [
+  { "op": "add", "path": "/baz", "value": "qux" }
+],
+    "expected": {
+  "baz": "qux",
+  "foo": "bar"
+}
+  },
+
+  {
+    "comment": "A.2.  Adding an Array Element", 
+    "doc": {
+  "foo": [ "bar", "baz" ]
+},
+    "patch": [
+  { "op": "add", "path": "/foo/1", "value": "qux" }
+],
+    "expected": {
+  "foo": [ "bar", "qux", "baz" ]
+}
+  },
+
+  {
+    "comment": "A.3.  Removing an Object Member",
+    "doc": {
+  "baz": "qux",
+  "foo": "bar"
+},
+    "patch": [
+  { "op": "remove", "path": "/baz" }
+],
+    "expected": {
+  "foo": "bar"
+}
+  },
+
+  {
+    "comment": "A.4.  Removing an Array Element",
+    "doc": {
+  "foo": [ "bar", "qux", "baz" ]
+},
+    "patch": [
+  { "op": "remove", "path": "/foo/1" }
+],
+    "expected": {
+  "foo": [ "bar", "baz" ]
+}
+  },
+
+  {
+    "comment": "A.5.  Replacing a Value",
+    "doc": {
+  "baz": "qux",
+  "foo": "bar"
+}, 
+    "patch": [
+  { "op": "replace", "path": "/baz", "value": "boo" }
+],
+    "expected": {
+  "baz": "boo",
+  "foo": "bar"
+}
+  },
+
+  {
+    "comment": "A.6.  Moving a Value",
+    "doc": {
+  "foo": {
+    "bar": "baz",
+    "waldo": "fred"
+  },
+  "qux": {
+    "corge": "grault"
+  }
+}, 
+    "patch": [
+  { "op": "move", "from": "/foo/waldo", "path": "/qux/thud" }
+], 
+    "expected": {
+  "foo": {
+    "bar": "baz"
+  },
+  "qux": {
+    "corge": "grault",
+    "thud": "fred"
+  }
+}
+  },
+
+  {
+    "comment": "A.7.  Moving an Array Element",
+    "doc": {
+  "foo": [ "all", "grass", "cows", "eat" ]
+}, 
+    "patch": [
+  { "op": "move", "from": "/foo/1", "path": "/foo/3" }
+], 
+    "expected": {
+  "foo": [ "all", "cows", "eat", "grass" ]
+}
+
+  },
+
+  {
+    "comment": "A.8.  Testing a Value: Success",
+    "doc": {
+  "baz": "qux",
+  "foo": [ "a", 2, "c" ]
+},
+    "patch": [
+  { "op": "test", "path": "/baz", "value": "qux" },
+  { "op": "test", "path": "/foo/1", "value": 2 }
+],
+    "expected": {
+     "baz": "qux",
+     "foo": [ "a", 2, "c" ]
+    }
+  },
+
+  {
+    "comment": "A.9.  Testing a Value: Error",
+    "doc": {
+  "baz": "qux"
+},
+    "patch": [
+  { "op": "test", "path": "/baz", "value": "bar" }
+],
+    "error": "string not equivalent" 
+  },
+
+  {
+    "comment": "A.10.  Adding a nested Member Object",
+    "doc": {
+  "foo": "bar"
+},
+    "patch": [
+  { "op": "add", "path": "/child", "value": { "grandchild": { } } }
+],
+    "expected": {
+  "foo": "bar",
+  "child": {
+    "grandchild": {
+    }
+  }
+}
+  },
+  
+  {
+    "comment": "A.11.  Ignoring Unrecognized Elements",
+    "doc": {
+  "foo":"bar"
+}, 
+    "patch": [
+  { "op": "add", "path": "/baz", "value": "qux", "xyz": 123 }
+],
+    "expected": {
+  "foo":"bar", 
+  "baz":"qux"
+}
+  },
+  
+ {
+    "comment": "A.12.  Adding to a Non-existant Target",
+    "doc": {
+  "foo": "bar"
+},
+    "patch": [
+  { "op": "add", "path": "/baz/bat", "value": "qux" }
+],
+    "error": "add to a non-existant target"
+  },
+  
+ {
+    "comment": "Invalid JSON Patch Document",
+    "doc": {
+     "foo": "bar"
+    },
+    "patch": [
+  { "op": "add", "path": "/baz", "value": "qux", "op": "remove" }
+],
+    "error": "operation has two 'op' members"
+  },
+  
+  { 
+    "comment": "~ Escape Ordering",
+    "doc": {
+       "/": 9,
+       "~1": 10 
+    },
+    "patch": [{"op": "test", "path": "/~01", "value":"10"}],
+    "expected": {
+       "/": 9,
+       "~1": 10 
+    }
+  }
+    
+]

data/test/json-patch-tests/tests.json

@@ -0,0 +1,242 @@
+[
+    { "comment": "empty list, empty docs",
+      "doc": {},
+      "patch": [],
+      "expected": {} },
+
+    { "comment": "empty patch list",
+      "doc": {"foo": 1},
+      "patch": [],
+      "expected": {"foo": 1} },
+
+    { "comment": "rearrangements OK?",
+      "doc": {"foo": 1, "bar": 2},
+      "patch": [],
+      "expected": {"bar":2, "foo": 1} },
+
+    { "comment": "rearrangements OK?  How about one level down ... array",
+      "doc": [{"foo": 1, "bar": 2}],
+      "patch": [],
+      "expected": [{"bar":2, "foo": 1}] },
+
+    { "comment": "rearrangements OK?  How about one level down...",
+      "doc": {"foo":{"foo": 1, "bar": 2}},
+      "patch": [],
+      "expected": {"foo":{"bar":2, "foo": 1}} },
+
+    { "comment": "add replaces any existing field",
+      "doc": {"foo": null},
+      "patch": [{"op": "add", "path": "/foo", "value":1}],
+      "expected": {"foo": 1} },
+
+    { "comment": "toplevel array",
+      "doc": [],
+      "patch": [{"op": "add", "path": "/0", "value": "foo"}],
+      "expected": ["foo"] },
+
+    { "comment": "toplevel array, no change",
+      "doc": ["foo"],
+      "patch": [],
+      "expected": ["foo"] },
+
+    { "comment": "toplevel object, numeric string",
+      "doc": {},
+      "patch": [{"op": "add", "path": "/foo", "value": "1"}],
+      "expected": {"foo":"1"} },
+
+    { "comment": "toplevel object, integer",
+      "doc": {},
+      "patch": [{"op": "add", "path": "/foo", "value": 1}],
+      "expected": {"foo":1} },
+
+    { "comment": "Toplevel scalar values OK?",
+      "doc": "foo",
+      "patch": [{"op": "replace", "path": "", "value": "bar"}],
+      "expected": "bar",
+      "disabled": true },
+
+    { "comment": "Add, / target",
+      "doc": {},
+      "patch": [ {"op": "add", "path": "/", "value":1 } ],
+      "expected": {"":1} },
+
+    { "comment": "Add composite value at top level",
+      "doc": {"foo": 1},
+      "patch": [{"op": "add", "path": "/bar", "value": [1, 2]}],
+      "expected": {"foo": 1, "bar": [1, 2]} },
+
+    { "comment": "Add into composite value",
+      "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
+      "patch": [{"op": "add", "path": "/baz/0/foo", "value": "world"}],
+      "expected": {"foo": 1, "baz": [{"qux": "hello", "foo": "world"}]} },
+
+    { "doc": {"bar": [1, 2]},
+      "patch": [{"op": "add", "path": "/bar/8", "value": "5"}],
+      "error": "Out of bounds (upper)" },
+
+    { "doc": {"bar": [1, 2]},
+      "patch": [{"op": "add", "path": "/bar/-1", "value": "5"}],
+      "error": "Out of bounds (lower)" },
+
+    { "doc": {"foo": 1},
+      "patch": [{"op": "add", "path": "/bar", "value": true}],
+      "expected": {"foo": 1, "bar": true} },
+
+    { "doc": {"foo": 1},
+      "patch": [{"op": "add", "path": "/bar", "value": false}],
+      "expected": {"foo": 1, "bar": false} },
+
+    { "doc": {"foo": 1},
+      "patch": [{"op": "add", "path": "/bar", "value": null}],
+      "expected": {"foo": 1, "bar": null} },
+
+    { "comment": "0 can be an array index or object element name",
+      "doc": {"foo": 1},
+      "patch": [{"op": "add", "path": "/0", "value": "bar"}],
+      "expected": {"foo": 1, "0": "bar" } },
+
+    { "doc": ["foo"],
+      "patch": [{"op": "add", "path": "/1", "value": "bar"}],
+      "expected": ["foo", "bar"] },
+
+    { "doc": ["foo", "sil"],
+      "patch": [{"op": "add", "path": "/1", "value": "bar"}],
+      "expected": ["foo", "bar", "sil"] },
+
+    { "doc": ["foo", "sil"],
+      "patch": [{"op": "add", "path": "/0", "value": "bar"}],
+      "expected": ["bar", "foo", "sil"] },
+
+    { "doc": ["foo", "sil"],
+      "patch": [{"op":" add", "path": "/2", "value": "bar"}],
+      "expected": ["foo", "sil", "bar"] },
+
+    { "doc": ["foo", "sil"],
+      "patch": [{"op": "add", "path": "/bar", "value": 42}],
+      "error": "Object operation on array target" },
+
+    { "doc": ["foo", "sil"],
+      "patch": [{"op": "add", "path": "/1", "value": ["bar", "baz"]}],
+      "expected": ["foo", ["bar", "baz"], "sil"],
+      "comment": "value in array add not flattened" },
+
+    { "doc": {"foo": 1, "bar": [1, 2, 3, 4]},
+      "patch": [{"op": "remove", "path": "/bar"}],
+      "expected": {"foo": 1} },
+
+    { "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
+      "patch": [{"op": "remove", "path": "/baz/0/qux"}],
+      "expected": {"foo": 1, "baz": [{}]} },
+
+    { "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
+      "patch": [{"op": "replace", "path": "/foo", "value": [1, 2, 3, 4]}],
+      "expected": {"foo": [1, 2, 3, 4], "baz": [{"qux": "hello"}]} },
+
+    { "doc": {"foo": [1, 2, 3, 4], "baz": [{"qux": "hello"}]},
+      "patch": [{"op": "replace", "path": "/baz/0/qux", "value": "world"}],
+      "expected": {"foo": [1, 2, 3, 4], "baz": [{"qux": "world"}]} },
+
+    { "doc": ["foo"],
+      "patch": [{"op": "replace", "path": "/0", "value": "bar"}],
+      "expected": ["bar"] },
+
+    { "doc": [""],
+      "patch": [{"op": "replace", "path": "/0", "value": 0}],
+      "expected": [0] },
+
+    { "doc": [""],
+      "patch": [{"op": "replace", "path": "/0", "value": true}],
+      "expected": [true] },
+
+    { "doc": [""],
+      "patch": [{"op": "replace", "path": "/0", "value": false}],
+      "expected": [false] },
+
+    { "doc": [""],
+      "patch": [{"op": "replace", "path": "/0", "value": null}],
+      "expected": [null] },
+
+    { "doc": ["foo", "sil"],
+      "patch": [{"op": "replace", "path": "/1", "value": ["bar", "baz"]}],
+      "expected": ["foo", ["bar", "baz"]],
+      "comment": "value in array replace not flattened" },
+
+    { "comment": "spurious patch properties",
+      "doc": {"foo": 1},
+      "patch": [{"op": "test", "path": "/foo", "value": 1, "spurious": 1}],
+      "expected": {"foo": 1} },
+
+    { "doc": {"foo": null},
+      "patch": [{"op": "test", "path": "/foo", "value": null}],
+      "comment": "null value should still be valid obj property" },
+
+    { "doc": {"foo": {"foo": 1, "bar": 2}},
+      "patch": [{"op": "test", "path": "/foo", "value": {"bar": 2, "foo": 1}}],
+      "comment": "test should pass despite rearrangement" },
+
+    { "doc": {"foo": [{"foo": 1, "bar": 2}]},
+      "patch": [{"op": "test", "path": "/foo", "value": [{"bar": 2, "foo": 1}]}],
+      "comment": "test should pass despite (nested) rearrangement" },
+
+    { "doc": {"foo": {"bar": [1, 2, 5, 4]}},
+      "patch": [{"op": "test", "path": "/foo", "value": {"bar": [1, 2, 5, 4]}}],
+      "comment": "test should pass - no error" },
+
+    { "doc": {"foo": {"bar": [1, 2, 5, 4]}},
+      "patch": [{"op": "test", "path": "/foo", "value": [1, 2]}],
+      "error": "test op should fail" },
+
+    { "comment": "json-pointer tests" },
+
+    { "comment": "Whole document",
+      "doc": { "foo": 1 },
+      "patch": [{"op": "test", "path": "", "value": {"foo": 1}}],
+      "disabled": true },
+
+    { "comment": "Empty-string element",
+      "doc": { "": 1 },
+      "patch": [{"op": "test", "path": "/", "value": 1}] },
+
+    { "doc": {
+            "foo": ["bar", "baz"],
+            "": 0,
+            "a/b": 1,
+            "c%d": 2,
+            "e^f": 3,
+            "g|h": 4,
+            "i\\j": 5,
+            "k\"l": 6,
+            " ": 7,
+            "m~n": 8
+            },
+      "patch": [{"op": "test", "path": "/foo", "value": ["bar", "baz"]},
+                {"op": "test", "path": "/foo/0", "value": "bar"},
+                {"op": "test", "path": "/", "value": 0},
+                {"op": "test", "path": "/a~1b", "value": 1},
+                {"op": "test", "path": "/c%d", "value": 2},
+                {"op": "test", "path": "/e^f", "value": 3},
+                {"op": "test", "path": "/g|h", "value": 4},
+                {"op": "test", "path":  "/i\\j", "value": 5},
+                {"op": "test", "path": "/k\"l", "value": 6},
+                {"op": "test", "path": "/ ", "value": 7},
+                {"op": "test", "path": "/m~0n", "value": 8}] },
+
+    { "comment": "Move to same location has no effect",
+      "doc": {"foo": 1},
+      "patch": [{"op": "move", "from": "/foo", "path": "/foo"}],
+      "expected": {"foo": 1} },
+
+    { "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
+      "patch": [{"op": "move", "from": "/foo", "path": "/bar"}],
+      "expected": {"baz": [{"qux": "hello"}], "bar": 1} },
+
+    { "doc": {"baz": [{"qux": "hello"}], "bar": 1},
+      "patch": [{"op": "move", "from": "/baz/0/qux", "path": "/baz/1"}],
+      "expected": {"baz": [{}, "hello"], "bar": 1} },
+
+    { "doc": {"baz": [{"qux": "hello"}], "bar": 1},
+      "patch": [{"op": "copy", "from": "/baz/0", "path": "/boo"}],
+      "expected": {"baz":[{"qux":"hello"}],"bar":1,"boo":{"qux":"hello"}} },
+
+    { "comment": "tests complete" }
+]

data/test/test_hana.rb

@@ -1,6 +1,15 @@
 require 'helper'
 
 class TestHana < Hana::TestCase
+  def test_no_eval
+    patch = Hana::Patch.new [
+      { 'op' => 'eval', 'value' => '1' }
+    ]
+    assert_raises(Hana::Patch::Exception) do
+      patch.apply('foo' => 'bar')
+    end
+  end
+
   def test_split_many
     pointer = Hana::Pointer.new '/foo/bar/baz'
     assert_equal %w{ foo bar baz }, pointer.to_a
@@ -8,7 +17,7 @@ class TestHana < Hana::TestCase
 
   def test_root
     pointer = Hana::Pointer.new '/'
-    assert_equal [], pointer.to_a
+    assert_equal [''], pointer.to_a
   end
 
   def test_escape

data/test/test_ietf.rb

@@ -0,0 +1,42 @@
+require 'helper'
+require 'json'
+
+module Hana
+  class TestIETF < TestCase
+    TESTDIR = File.dirname File.expand_path __FILE__
+    json    = File.read File.join TESTDIR, 'json-patch-tests', 'tests.json'
+    tests = JSON.load json
+    tests.each_with_index do |test, i|
+      next unless test['doc']
+
+      define_method("test_#{test['comment'] || i }") do
+        skip "disabled" if test['disabled']
+
+        doc   = test['doc']
+        patch = test['patch']
+
+        patch = Hana::Patch.new patch
+
+        if test['error']
+          assert_raises(ex(test['error'])) do
+            patch.apply doc
+          end
+        else
+          assert_equal(test['expected'] || doc, patch.apply(doc))
+        end
+      end
+    end
+
+    private
+
+    def ex msg
+      case msg
+      when /Out of bounds/i then Hana::Patch::OutOfBoundsException
+      when /Object operation on array/ then
+        Hana::Patch::ObjectOperationOnArrayException
+      else
+        Hana::Patch::FailedTestException
+      end
+    end
+  end
+end

metadata

@@ -1,64 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: hana
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 1.1.0
 platform: ruby
 authors:
 - Aaron Patterson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-08 00:00:00.000000000 Z
+date: 2013-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: hoe
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.6'
 description: Implementation of [JSON Patch][1] and [JSON Pointer][2] drafts.
 email:
 - aaron@tenderlovemaking.com
@@ -67,6 +60,7 @@ extensions: []
 extra_rdoc_files:
 - CHANGELOG.rdoc
 - Manifest.txt
+- README.md
 files:
 - .autotest
 - CHANGELOG.rdoc
@@ -75,11 +69,15 @@ files:
 - Rakefile
 - lib/hana.rb
 - test/helper.rb
+- test/json-patch-tests/README.md
+- test/json-patch-tests/spec_tests.json
+- test/json-patch-tests/tests.json
 - test/test_hana.rb
-- test/test_patch.rb
+- test/test_ietf.rb
 - .gemtest
 homepage: http://github.com/tenderlove/hana
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options:
 - --main
@@ -87,23 +85,21 @@ rdoc_options:
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: hana
-rubygems_version: 1.8.24
+rubygems_version: 2.0.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Implementation of [JSON Patch][1] and [JSON Pointer][2] drafts.
 test_files:
 - test/test_hana.rb
-- test/test_patch.rb
+- test/test_ietf.rb

data/test/test_patch.rb

@@ -1,162 +0,0 @@
-require 'helper'
-
-module Hana
-  class TestPatch < TestCase
-    def test_no_eval
-      patch = Hana::Patch.new [
-        { 'eval' => '1' }
-      ]
-      assert_raises(Hana::Patch::Exception) do
-        patch.apply('foo' => 'bar')
-      end
-    end
-
-    def test_add_member
-      patch = Hana::Patch.new [
-        { 'add' => '/baz', 'value' => 'qux' }
-      ]
-
-      result = patch.apply('foo' => 'bar')
-      assert_equal({'baz' => 'qux', 'foo' => 'bar'}, result)
-    end
-
-    def test_add_array
-      patch = Hana::Patch.new [
-        { "add" => "/foo/1", "value" => "qux" }
-      ]
-
-      result = patch.apply({ "foo" => [ "bar", "baz" ] })
-
-      assert_equal({ "foo" => [ "bar", "qux", "baz" ] }, result)
-    end
-
-    def test_remove_object_member
-      patch = Hana::Patch.new [ { "remove" => "/baz" } ]
-
-      result = patch.apply({ 'baz' => 'qux', 'foo' => 'bar' })
-
-      assert_equal({ "foo" => 'bar' }, result)
-    end
-
-    def test_remove_array_element
-      patch = Hana::Patch.new [ { "remove" => "/foo/1" } ]
-      result = patch.apply({ "foo" => [ "bar", "qux", "baz" ] })
-      assert_equal({ "foo" => [ "bar", "baz" ] }, result)
-    end
-
-    def test_replace_value
-      patch = Hana::Patch.new [ { "replace" => "/baz", "value" => "boo" } ]
-      result = patch.apply({ "baz" => "qux", "foo" => "bar" })
-      assert_equal({ "baz" => "boo", "foo" => "bar" }, result)
-    end
-
-    def test_moving_a_value
-      doc = {
-        "foo" => {
-          "bar"   => "baz",
-          "waldo" => "fred"
-        },
-        "qux" => {
-          "corge" => "grault"
-        }
-      }
-
-      patch = [ { "move" => "/foo/waldo", 'to' => "/qux/thud" } ]
-
-      expected = {
-        "foo" =>  {
-          "bar" =>  "baz"
-        },
-        "qux" =>  {
-          "corge" =>  "grault",
-          "thud" =>  "fred"
-        }
-      }
-
-      patch = Hana::Patch.new patch
-      result = patch.apply doc
-      assert_equal expected, result
-    end
-
-    def test_move_an_array_element
-      # An example target JSON document:
-      doc = {
-        "foo" => [ "all", "grass", "cows", "eat" ]
-      }
-
-      # A JSON Patch document:
-      patch = [
-        { "move" => "/foo/1", "to" => "/foo/3" }
-      ]
-
-      # The resulting JSON document:
-      expected = {
-        "foo" => [ "all", "cows", "eat", "grass" ]
-      }
-
-      patch = Hana::Patch.new patch
-      result = patch.apply doc
-      assert_equal expected, result
-    end
-
-    def test_testing_a_value_success
-      # An example target JSON document:
-      doc = {
-        "baz" => "qux",
-        "foo" => [ "a", 2, "c" ]
-      }
-
-      # A JSON Patch document that will result in successful evaluation:
-      patch = [
-          { "test" => "/baz", "value" => "qux" },
-          { "test" => "/foo/1", "value" => 2 },
-          { "add" => "/bar", "value" => 2 },
-      ]
-
-      expected = {
-        "baz" => "qux",
-        "foo" => [ "a", 2, "c" ],
-        'bar' => 2
-      }
-
-      patch = Hana::Patch.new patch
-      result = patch.apply doc
-      assert_equal expected, result
-    end
-
-    def test_testing_a_value_error
-      # An example target JSON document:
-      doc = { "baz" => "qux" }
-
-      # A JSON Patch document that will result in an error condition:
-      patch = [
-        { "test" => "/baz", "value" => "bar" }
-      ]
-
-      patch = Hana::Patch.new patch
-
-      assert_raises(Hana::Patch::Exception) do
-        patch.apply doc
-      end
-    end
-
-    def test_add_nested_member_object
-      # An example target JSON document:
-      doc = { "foo" => "bar" }
-      # A JSON Patch document:
-      patch = [
-        { "add" => "/child", "value" => { "grandchild" => { } } }
-      ]
-
-      # The resulting JSON document:
-      expected = {
-        "foo" => "bar",
-        "child" => { "grandchild" => { } }
-      }
-
-      patch = Hana::Patch.new patch
-      result = patch.apply doc
-      assert_equal expected, result
-    end
-  end
-end