json-patch 1.0.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.rvmrc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "test/json-patch-tests"]
+	path = test/json-patch-tests
+	url = git://github.com/json-patch/json-patch-tests.git

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode
+before_install:
+  - git submodule update --init --recursive

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in json-patch.gemspec
+gem 'minitest'
+gem 'coveralls', require: false
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Guille Carlos 
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# JSON::Patch (Version 1 Coming Soon)
+[![Build Status](https://travis-ci.org/guillec/json-patch.png)](https://travis-ci.org/guillec/json-patch)
+[![Code Climate](https://codeclimate.com/github/guillec/json-patch.png)](https://codeclimate.com/github/guillec/json-patch)
+[![Coverage Status](https://coveralls.io/repos/guillec/json-patch/badge.png)](https://coveralls.io/r/guillec/json-patch)
+
+
+This gem augments Ruby's built-in JSON library to support JSON Patch
+(identified by the json-patch+json media type). http://tools.ietf.org/html/rfc6902
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'json-patch'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install json-patch
+
+## Usage
+
+Then, use it:
+
+```ruby
+# The example from http://tools.ietf.org/html/rfc6902#appendix-A
+
+# Add Object Member
+target_document = <<-JSON
+  { "foo": "bar"}
+JSON
+
+operations_document = <<-JSON
+[
+  { "op": "add", "path": "/baz", "value": "qux" }
+]
+JSON
+
+JSON.patch(target_document, operations_document)
+# => 
+{ "baz": "qux", "foo": "bar" }
+
+
+# Add Array Element
+target_document = <<-JSON
+  { "foo": [ "bar", "baz" ] }
+JSON
+
+operations_document = <<-JSON
+[
+  { "op": "add", "path": "/foo/1", "value": "qux" }
+]
+JSON
+
+JSON.patch(target_document, operations_document)
+# => 
+{ "foo": [ "bar", "qux", "baz" ] }
+```
+
+If you'd prefer to operate on pure Ruby objects rather than JSON
+strings, you can construct a JSON::Patch object instead.
+
+```ruby
+target_document = { "foo" => [ "bar", "baz" ] }
+operations_document = [{ "op" => "add", "path" => "/foo/1", "value" => "qux" }]
+
+JSON::Patch.new(target_document, operations_document).call
+# => 
+{ "foo" => [ "bar", "qux", "baz" ] }
+```
+
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.ruby_opts = ["-w"]
+  t.verbose = true
+end
+task :default => :test

data/json-patch.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'json/patch/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "json-patch"
+  spec.version       = Json::Patch::VERSION
+  spec.authors       = ["Guille Carlos"]
+  spec.email         = ["guille@bitpop.in"]
+  spec.description   = %q{An implementation of RFC 6902: JSON Patch.}
+  spec.summary       = %q{An implementation of RFC 6902: JSON Patch.}
+  spec.homepage      = "https://github.com/guillec/json-patch"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/json/patch.rb

@@ -0,0 +1,187 @@
+require 'json'
+require 'json/patch/railtie' if defined?(Rails)
+
+module JSON
+  PatchError                           = Class.new(StandardError)
+  PatchOutOfBoundException             = Class.new(StandardError)
+  PatchObjectOperationOnArrayException = Class.new(StandardError)
+
+  def self.patch(target_doc, operations_doc)
+    target_doc            = JSON.parse(target_doc)
+    operations_doc        = JSON.parse(operations_doc)
+    result_doc            = JSON::Patch.new(target_doc, operations_doc).call
+    JSON.dump(result_doc)
+  end
+
+  class Patch
+
+    def initialize(target_doc, operations_doc)
+      @target_doc     = target_doc
+      @operations_doc = operations_doc
+    end
+
+    def call
+      return @target_doc if @operations_doc.empty?
+      @operations_doc.each do |operation|
+        operation = operation.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+        if allowed?(operation)
+          @target_doc = send(operation[:op].to_sym, @target_doc, operation)
+        end
+      end
+      return @target_doc
+    end
+
+    private
+    def allowed?(operation)
+      operation.fetch(:op) { raise JSON::PatchError }
+      raise JSON::PatchError unless ["add","remove","replace","move","copy","test"].include?(operation[:op])
+      operation.fetch(:path) { raise JSON::PatchError }
+      true
+    end
+
+    def add(target_doc, operation_doc)
+      path  = operation_doc[:path]
+      value = operation_doc.fetch(:value) { raise JSON::PatchError  }
+
+      add_operation(target_doc, path, value)
+      target_doc
+    end
+
+    def remove(target_doc, operation_doc)
+      path = operation_doc.fetch(:path) { raise JSON::PatchError }
+
+      remove_operation(target_doc, path)
+      target_doc
+    end
+
+    def replace(target_doc, operation_doc)
+      remove(target_doc, operation_doc)
+      add(target_doc, operation_doc)
+      target_doc
+    end
+
+    def move(target_doc, operation_doc)
+      src   = operation_doc.fetch(:from) { raise JSON::PatchError }
+      dest  = operation_doc[:path]
+      value = remove_operation(target_doc, src)
+
+      add_operation(target_doc, dest, value)
+      target_doc
+    end
+
+    def copy(target_doc, operation_doc)
+      src   = operation_doc.fetch(:from) { raise JSON::PatchError }
+      dest  = operation_doc[:path]
+      value = find_value(target_doc, operation_doc, src)
+
+      add_operation(target_doc, dest, value)
+      target_doc
+    end
+
+    def test(target_doc, operation_doc)
+      path       = operation_doc[:path]
+      value      = find_value(target_doc, operation_doc, path)
+      test_value = operation_doc.fetch(:value) { raise JSON::PatchError }
+
+      raise JSON::PatchError if value != test_value
+      target_doc if value == test_value
+    end
+
+    def add_operation(target_doc, path, value)
+      path_array  = split_path(path)
+      ref_token   = path_array.pop
+      target_item = build_target_array(path_array, target_doc)
+
+      add_array(target_doc, path_array, target_item, ref_token, value) if target_item.kind_of? Array
+      add_object(target_doc, target_item, ref_token, value) unless target_item.kind_of? Array
+    end
+
+    def add_object(target_doc, target_item, ref_token, value)
+      raise JSON::PatchError if target_item.nil? 
+      if ref_token.nil?
+        target_doc.replace(value)
+      else
+        target_item[ref_token] = value
+      end
+    end
+
+    def add_array(doc, path_array, target_item, ref_token, value)
+      return unless valid_index?(target_item, ref_token)
+      if ref_token == "-"
+        new_array = target_item << value
+      else
+        new_array = target_item.insert ref_token.to_i, value
+      end
+      add_to_target_document(doc, path_array, target_item, new_array)
+    end
+
+    def valid_index?(item_array, index)
+      raise JSON::PatchObjectOperationOnArrayException unless index =~ /\A-?\d+\Z/ || index == "-"
+      index = index == "-" ? item_array.length : index.to_i
+      raise JSON::PatchOutOfBoundException if index.to_i > item_array.length || index.to_i < 0
+      true
+    end
+
+    def remove_operation(target_doc, path)
+      path_array  = split_path(path)
+      ref_token   = path_array.pop
+      target_item = build_target_array(path_array, target_doc)
+      raise JSON::PatchObjectOperationOnArrayException if target_item.nil?
+
+      if Array === target_item
+        target_item.delete_at ref_token.to_i if valid_index?(target_item, ref_token)
+      else
+        target_item.delete ref_token
+      end
+    end
+
+    def find_value(target_doc, operation_doc, path)
+      path_array  = split_path(path)
+      ref_token   = path_array.pop
+      target_item = build_target_array(path_array, target_doc)
+      if Array === target_item
+        if is_a_number?(ref_token)
+        target_item.at ref_token.to_i
+        else
+          raise JSON::PatchObjectOperationOnArrayException
+        end
+      else
+        target_item[ref_token]
+      end
+    end
+
+    def is_a_number?(s)
+      s.to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/) == nil ? false : true 
+    end
+
+    def build_target_array(path_array, target_doc)
+      path_array.inject(target_doc) do |doc, item|
+        key = (doc.kind_of?(Array) ? item.to_i : item)
+        if doc.kind_of?(Array)
+          doc[key] 
+        else
+          doc.has_key?(key) ? doc[key] : doc[key.to_sym] unless doc.kind_of?(Array)
+        end
+      end
+    end
+
+    def add_to_target_document(doc, path, target_item, array)
+      path.inject(doc) do |obj, part|
+        key = (Array === doc ? part.to_i : part)
+        doc[key]
+      end
+    end
+
+    def split_path(path)
+      escape_characters = {'^/' => '/', '^^' => '^', '~0' => '~', '~1' => '/'}
+      if path == '/'
+        ['']
+      else
+        path.sub(/^\//, '').split(/(?<!\^)\//).map! { |part|
+          part.gsub!(/\^[\/^]|~[01]/) { |m| escape_characters[m] }
+          part
+        }
+      end
+    end
+  end
+end

data/lib/json/patch/railtie.rb

@@ -0,0 +1,14 @@
+require 'rails'
+
+module JSON
+  class Patch
+    # This class registers our gem with Rails.
+    class Railtie < ::Rails::Railtie
+      # When the application loads, this will cause Rails to know
+      #       # how to serve up the proper type.
+      initializer 'json-patch' do
+        Mime::Type.register 'application/json-patch+json', :json_patch
+      end
+    end
+  end
+end

data/lib/json/patch/version.rb

@@ -0,0 +1,5 @@
+module Json
+  module Patch
+    VERSION = "1.0.0"
+  end
+end

data/test/ietf_spec_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+require 'json/patch'
+
+describe "IETF JSON Patch Test" do
+
+  TESTDIR   = File.dirname File.expand_path __FILE__
+  spec_json = File.read File.join TESTDIR, 'json-patch-tests', 'spec_tests.json'
+  specs     = JSON.load spec_json
+
+  describe "JSON.patch" do
+    specs.each_with_index do |spec, index|
+      next unless spec['doc']
+
+
+      #This test I am skipping
+      #Because it test if a operations object has two op members
+      #Since the first step in the process is to convert to hash 
+      #it gets rid of the similar keys.
+      next if spec['comment'] == 'A.13 Invalid JSON Patch Document'
+
+
+      comment = spec['comment']
+      unless spec['disabled']
+
+        describe "A JSON String " do
+          it "#{comment || spec['error'] || index}" do
+
+            target_doc     = JSON.dump(spec['doc']) if spec['doc']
+            operations_doc = JSON.dump(spec['patch']) if spec['patch']
+            expected_doc   = JSON.dump(spec['expected']) if spec['expected']
+
+            if spec['error']
+              assert_raises(ex(spec['error'])) do
+                JSON.patch(target_doc, operations_doc)
+              end
+            else
+              result_doc = JSON.patch(target_doc, operations_doc)
+              assert_equal JSON.parse(expected_doc || target_doc), JSON.parse(result_doc)
+            end
+          end
+        end
+
+        describe "JSON::Patch.new" do
+          it "#{comment || spec['error'] || index}" do
+
+            target_doc     = eval(spec['doc'].to_s) if spec['doc']
+            operations_doc = eval(spec['patch'].to_s) if spec['patch']
+            expected_doc   = eval(spec['expected'].to_s) if spec['expected']
+
+            if spec['error']
+              assert_raises(ex(spec['error'])) do
+                JSON::Patch.new(target_doc, operations_doc).call
+              end
+            else
+              result_doc = JSON::Patch.new(target_doc, operations_doc).call
+              assert_equal (expected_doc || target_doc), result_doc
+            end
+          end
+        end
+
+      end
+    end
+  end
+
+  private
+  def ex msg
+    case msg
+    when /Out of bounds/i then
+      JSON::PatchOutOfBoundException
+    when /Object operation on array target/ then
+      JSON::PatchObjectOperationOnArrayException
+    else
+      JSON::PatchError
+    end
+  end
+
+end

data/test/ietf_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+require 'json/patch'
+
+describe "IETF JSON Patch Test" do
+
+  TESTDIR   = File.dirname File.expand_path __FILE__
+  spec_json = File.read File.join TESTDIR, 'json-patch-tests', 'tests.json'
+  specs     = JSON.load spec_json
+
+  describe "Test JSON File" do
+    specs.each_with_index do |spec, index|
+      next unless spec['doc']
+      comment = spec['comment']
+      unless spec['disabled']
+
+        describe "JSON.patch" do
+          it "#{comment || spec['error'] || index}" do
+
+            target_doc     = JSON.dump(spec['doc']) if spec['doc']
+            operations_doc = JSON.dump(spec['patch']) if spec['patch']
+            expected_doc   = JSON.dump(spec['expected']) if spec['expected']
+
+            if spec['error']
+              assert_raises(ex(spec['error'])) do
+                JSON.patch(target_doc, operations_doc)
+              end
+            else
+              result_doc = JSON.patch(target_doc, operations_doc)
+              assert_equal JSON.parse(expected_doc || target_doc), JSON.parse(result_doc)
+            end
+          end
+        end
+
+        describe "JSON::Patch.new" do
+          it "#{comment || spec['error'] || index}" do
+
+            target_doc     = spec['doc'] if spec['doc']
+            operations_doc = spec['patch'] if spec['patch']
+            expected_doc   = spec['expected'] if spec['expected']
+
+            if spec['error']
+              assert_raises(ex(spec['error'])) do
+                JSON::Patch.new(target_doc, operations_doc).call
+              end
+            else
+              result_doc = JSON::Patch.new(target_doc, operations_doc).call
+              assert_equal (expected_doc || target_doc), result_doc
+            end
+          end
+        end
+      end
+    end
+  end
+
+  private
+  def ex msg
+    case msg
+    when /Out of bounds/i then
+      JSON::PatchOutOfBoundException
+    when /Object operation on array target/i then
+      JSON::PatchObjectOperationOnArrayException
+    when /with bad number/i then
+      JSON::PatchObjectOperationOnArrayException
+    when /get array element 1/ then
+      JSON::PatchObjectOperationOnArrayException
+    else
+      JSON::PatchError
+    end
+  end
+
+end

data/test/json-patch_test.rb

@@ -0,0 +1,355 @@
+require 'test_helper'
+require 'json/patch'
+
+describe "Section 4: Operation objects" do
+
+  describe "Operation objects MUST have at least one 'op' member" do
+    let(:target_document) { %q'{}' }
+    let(:operation_document) { %q'[{"path":"/a/b/c"}]' }
+
+    it "will raise exception when no 'op' member exist" do
+      assert_raises(JSON::PatchError) do 
+        JSON.patch(target_document, operation_document)
+      end
+    end
+  end
+
+  describe "Operation objects 'op' member MUST be one of the correct values" do
+    let(:target_document) { %q'{ "foo":["bar","baz"] }' }
+    let(:add_operation_document) { %q'[{"op":"add","path":"/foo/1","value":"qux"}]' }
+    let(:remove_operation_document) { %q'[{ "op": "remove", "path": "/baz" }]' }
+    let(:replace_operation_document) { %q'[{"op":"replace","path":"/foo/1","value":"qux"}]' }
+    let(:move_operation_document) { %q'[{"op":"replace","from":"foo","path":"/foo/1","value":"qux"}]' }
+    let(:copy_operation_document) { %q'[{"op":"replace","from":"foo","path":"/foo/1","value":"qux"}]' }
+    let(:test_operation_document) { %q'[{"op":"test", "path":"/foo/1","value":"baz"}]' }
+    let(:error_operation_document) { %q'[{"op": "hammer time"}]' }
+
+    it "can contain a 'add' value" do
+      assert JSON.patch(target_document, add_operation_document)
+    end
+
+    it "can contain a 'remove' value" do
+      assert JSON.patch(target_document, remove_operation_document)
+    end
+
+    it "can contain a 'replace' value" do
+      assert JSON.patch(target_document, replace_operation_document)
+    end
+
+    it "can contain a 'move' value" do
+      assert JSON.patch(target_document, move_operation_document)
+    end
+
+    it "can contain a 'copy' value" do
+      assert JSON.patch(target_document, copy_operation_document)
+    end
+
+    it "can contain a 'test' value" do
+      assert JSON.patch(target_document, test_operation_document)
+    end
+
+    it "will raise exception when 'op' member contains invalid 'hammer time' value" do
+      assert_raises(JSON::PatchError) do 
+        JSON.patch(target_document, error_operation_document)
+      end
+    end
+  end
+
+  describe "Operation objects MUST have at least one path member" do
+    let(:target_document) { %q'{ "foo":["bar","baz"] }' }
+    let(:operation_document) { %q'[{"op":"add", "value":"qux"}]' }
+
+    it "will raise exception when no 'path' member exist" do
+      assert_raises(JSON::PatchError) do
+        JSON.patch(target_document, operation_document)
+      end
+    end
+  end
+
+  describe "Operation members not define by the action MUST be ignored" do
+    let(:target_document) { %q'{ "foo":["bar","baz"] }' }
+    let(:operation_document) { %q'[{"op":"add","path":"/foo/1","value":"qux", "ignore":"This please"}]' }
+
+    it "ignores the 'ignore' member of the add operation_document" do
+      expected  = %q'{"foo":["bar","qux","baz"]}'
+      assert_equal expected, JSON.patch(target_document, operation_document)
+    end
+  end
+
+end
+
+describe "Section 4.1: The add operation" do
+
+  describe "If the target location specifies an array index" do
+    let(:target_document) { %q'{ "foo":["bar","baz"] }' }
+    let(:operation_document) { %q'[{"op":"add","path":"/foo/1","value":"qux"}]' }
+
+    it "inserts the value into the array at specified index" do
+      expected  = %q'{"foo":["bar","qux","baz"]}'
+      assert_equal expected, JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "If the target location species a object member that does not exist" do
+    let(:target_document) { %q'{"foo":"bar"}' }
+    let(:operation_document) { %q'[{ "op": "add", "path": "/baz", "value": "qux" }]' }
+
+    it "it will add the object to the target_document" do
+      expected  = %q'{"foo":"bar","baz":"qux"}'
+      assert_equal expected, JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "If the target location species a member that does exist" do
+    let(:target_document) { %q'{"foo":"bar","baz":"wat"}' }
+    let(:operation_document) { %q'[{ "op": "add", "path": "/baz", "value": "qux" }]' }
+
+    it "it replaces the value" do
+      expected  = %q'{"foo":"bar","baz":"qux"}'
+      assert_equal expected, JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "The add operation MUST contina a 'value' member" do
+    let(:target_document) { %q'{"foo":"bar","baz":"wat"}' }
+    let(:operation_document) { %q'[{ "op": "add", "path": "/baz" }]' }
+
+    it "will raise exception if no 'value' member" do
+      assert_raises(JSON::PatchError) do
+        JSON.patch(target_document, operation_document)
+      end
+    end
+  end
+
+=begin
+TODO
+When the operation is applied, the target location MUST reference one of:
+
+1. The root of the target document - whereupon the specified value
+becomes the entire content of the target document.
+
+2. A member to add to an existing object - whereupon the supplied
+value is added to that object at the indicated location.  If the
+member already exists, it is replaced by the specified value.
+
+3.  An element to add to an existing array - whereupon the supplied
+value is added to the array at the indicated location.  Any
+elements at or above the specified index are shifted one position
+to the right.  The specified index MUST NOT be greater than the
+number of elements in the array.  If the "-" character is used to
+index the end of the array (see [RFC6901]), this has the effect of
+appending the value to the array.
+=end
+
+end
+
+describe "Section 4.2: The remove operation" do
+
+  describe "Removing a object member" do
+    let(:target_document) { %q'{"foo":"bar","baz":"qux"}' }
+    let(:operation_document) { %q'[{ "op": "remove", "path": "/baz" }]' }
+
+    it "will remove memeber of object at the target location" do
+      expected = %q'{"foo":"bar"}'
+      assert_equal expected, JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "Removing a array element" do
+    let(:target_document) { %q'{"foo":["bar","qux","baz"]}' }
+    let(:operation_document) { %q'[{ "op": "remove", "path": "/foo/1" }]' }
+
+    it "will remove object in array at the target location" do
+      expected = %q'{"foo":["bar","baz"]}'
+      assert_equal expected, JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "Target location MUST exist for the remove operation" do
+    let(:target_document) { %q'{"foo":["bar","qux","baz"]}' }
+    let(:operation_document) { %q'[{ "op": "remove"}]' }
+
+    it "will raise an exception if no target is specified" do
+      assert_raises(JSON::PatchError) do
+       JSON.patch(target_document, operation_document)
+      end
+    end
+  end
+
+end
+
+describe "Section 4.3: The replace operation" do
+
+  describe "Replacing a value" do
+    let(:target_document) { %q'{"foo":"bar","baz":"qux"}' }
+    let(:operation_document) { %q'[{ "op": "replace", "path": "/baz", "value": "boo" }]' }
+
+    it "will replace old value with a new value at target location" do
+      expected  = %q'{"foo":"bar","baz":"boo"}'
+      assert_equal expected, JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "The replace operation document MUST contain a 'value' member" do
+    let(:target_document) { %q'{"foo":"bar","baz":"qux"}' }
+    let(:operation_document) { %q'[{ "op": "replace", "path": "/baz" }]' }
+
+    it "will raise an exception if no 'value' is specified" do
+      assert_raises(JSON::PatchError) do
+       JSON.patch(target_document, operation_document)
+      end
+    end
+  end
+
+  describe "The replace operation MUST have a target location" do
+    let(:target_document) { %q'{"foo":"bar","baz":"qux"}' }
+    let(:operation_document) { %q'[{ "op": "replace", "value": "boo" }]' }
+
+    it "will raise an exception if no target is specified" do
+      assert_raises(JSON::PatchError) do
+       JSON.patch(target_document, operation_document)
+      end
+    end
+  end
+end
+
+describe "Section 4.4: The move operation" do
+
+  describe "The move operation" do
+    let(:target_document) { %q'{"foo":{"bar":"baz","waldo":"fred"},"qux":{"corge":"grault"}}' }
+    let(:operation_document) { %q'[{ "op": "move", "from":"/foo/waldo", "path": "/qux/thud" }]' }
+
+    it "will remove the value at a specified location and add it to the target location" do
+      expected  = %q'{"foo":{"bar":"baz"},"qux":{"corge":"grault","thud":"fred"}}'
+      assert_equal expected, JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "The move operation" do
+    let(:target_document) { %q'{"foo":["add","grass","cows","eat"]}' }
+    let(:operation_document) { %q'[{ "op": "move", "from":"/foo/1", "path": "/foo/3" }]' }
+
+    it "will move a array element to new location" do
+      expected  = %q'{"foo":["add","cows","eat","grass"]}'
+      assert_equal expected, JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "The move operation MUST hav a 'from' memeber" do
+    let(:target_document) { %q'{"foo":"bar","baz":"qux"}' }
+    let(:operation_document) { %q'[{ "op": "move", "value": "boo" }]' }
+
+    it "will raise an exception if no from 'from' location is specified" do
+      assert_raises(JSON::PatchError) do
+       JSON.patch(target_document, operation_document)
+      end
+    end
+  end
+
+=begin
+TODO The "from" location MUST NOT be a proper prefix of the "path"
+   location; i.e., a location cannot be moved into one of its children.
+=end
+
+end
+
+describe "Section 4.5: The copy operation" do
+
+  describe "The copy operation" do
+    let(:target_document) { %q'{"foo":{"bar":"baz","waldo":"fred"},"qux":{"corge":"grault"}}' }
+    let(:operation_document) { %q'[{ "op": "copy", "from":"/foo/waldo", "path": "/qux/waldo" }]' }
+
+    it "will copy a value from a specified location to the target location" do
+      expected  = %q'{"foo":{"bar":"baz","waldo":"fred"},"qux":{"corge":"grault","waldo":"fred"}}'
+      assert_equal expected, JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "The copy operation MUST have a 'from' member" do
+    let(:target_document) { %q'{"foo":"bar","baz":"qux"}' }
+    let(:operation_document) { %q'[{ "op": "copy", "path": "/foo" }]' }
+
+    it "will raise an exception if no 'from' location is specified" do
+      assert_raises(JSON::PatchError) do
+       JSON.patch(target_document, operation_document)
+      end
+    end
+  end
+
+end
+
+describe "Section 4.6: The test operation" do
+
+#The "test" operation tests that a value at the target location is equal to a specified value.
+
+  describe "The test operation MUST contain a 'value' member" do
+    let(:target_document) { %q'{"baz":"qux","foo":["a",2,"c"]}' }
+    let(:operation_document) { %q'[{ "op": "test", "path": "/baz"}, {"op": "test", "path": "/foo/1"}]' }
+
+    it "will raise a exception if no 'value' is specified" do
+      assert_raises(JSON::PatchError) do
+        JSON.patch(target_document, operation_document)
+      end
+    end
+  end
+
+  describe "Testing that strings have the same number of Unicode characters and their code points are byte-to-byte equal" do
+    let(:target_document) { %q'{"baz":"qux","foo":["a",2,"c"]}' }
+    let(:operation_document) { %q'[{ "op": "test", "path": "/baz", "value": "qux"}]' }
+
+    it "will return true since the strings are equal" do
+      assert JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "Testing that numbers are equal if their values are numerically equal" do
+    let(:target_document) { %q'{"baz": 1,"foo":["a",2,"c"]}' }
+    let(:operation_document) { %q'[{ "op": "test", "path": "/baz", "value": 1}]' }
+
+    it "will return true since the numbers are equal" do
+      assert JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "Testing that arrays are equal if they contain then same number of values and these values are equal" do
+    let(:target_document) { %q'{"baz": 1,"foo":["a",2,"c"]}' }
+    let(:operation_document) { %q'[{"op": "test", "path": "/foo", "value": ["a",2,"c"]}]' }
+
+    it "will return true since arrays and values are equal" do
+      assert JSON.patch(target_document, operation_document)
+    end
+  end
+
+  describe "Testing that objects are equal if they contain then same number of members and each member has same keys and values" do
+    let(:target_document) { %q'{"baz": 1,"foo":{"foo": "bar","hammer": "time"}}' }
+    let(:operation_document) { %q'[{"op": "test", "path": "/foo", "value": {"foo": "bar", "hammer":"time"}}]' }
+
+    it "will return true since objects equal" do
+      assert JSON.patch(target_document, operation_document)
+    end
+  end
+
+=begin
+  TODO
+  5  literals (false, true, and null): are considered equal if they are
+     the same.
+
+  Also, note that ordering of the serialization of object members is
+     not significant.
+=end
+
+end
+
+describe "JSON::Patch object" do
+
+  describe "JSON::Patch.new " do
+    let(:target_document) { {"foo" => { "bar" => "baz", "waldo" => "fred" }, "qux" => { "corge" => "grault" } } }
+    let(:operation_document) { [{ "op"=> "copy", "from" => "/foo/waldo", "path" => "/qux/waldo" }] }
+
+    it "can handle plain ruby objects" do
+      expected  = {"foo"=>{"bar"=>"baz","waldo"=>"fred"},"qux"=>{"corge"=>"grault","waldo"=>"fred"}}
+      assert_equal expected, JSON::Patch.new(target_document, operation_document).call
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter do |source_file|
+    source_file.filename =~ /test/
+  end
+end
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'minitest/autorun'

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: json-patch
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Guille Carlos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'An implementation of RFC 6902: JSON Patch.'
+email:
+- guille@bitpop.in
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .gitmodules
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- json-patch.gemspec
+- lib/json/patch.rb
+- lib/json/patch/railtie.rb
+- lib/json/patch/version.rb
+- test/ietf_spec_test.rb
+- test/ietf_test.rb
+- test/json-patch_test.rb
+- test/ruby_ietf_spec_test.rb
+- test/test_helper.rb
+homepage: https://github.com/guillec/json-patch
+licenses:
+- MIT
+post_install_message: 
+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: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: ! 'An implementation of RFC 6902: JSON Patch.'
+test_files:
+- test/ietf_spec_test.rb
+- test/ietf_test.rb
+- test/json-patch_test.rb
+- test/ruby_ietf_spec_test.rb
+- test/test_helper.rb
+has_rdoc: