json_patch 0.2.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm use "ruby-1.9.2-p180@json_patch"

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/README.md

@@ -0,0 +1,10 @@
+# json_patch
+
+An implementation of the JSON patch spec.
+
+http://tools.ietf.org/html/draft-pbryan-json-patch-01
+
+
+Utilities for applying JSON patches to arbitary objects. To
+participate in the patch protocol, classes can implement #apply_patch
+

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/json_patch.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "json/patch/version"
+
+Gem::Specification.new do |s|
+  s.name        = "json_patch"
+  s.version     = JSON::Patch::VERSION
+  s.authors     = ["Travis Vachon"]
+  s.email       = ["travis@copious.com"]
+  s.homepage    = ""
+  s.summary     = %q{JSON patch implementation in ruby}
+  s.description = %q{An implementation of JSON patch in Ruby.
+
+http://tools.ietf.org/html/draft-pbryan-json-patch-01
+
+Utilities for applying JSON patches to arbitary objects. To
+participate in the patch protocol, classes can implement #apply_patch
+}
+
+  s.rubyforge_project = "json_patch"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "bson_ext"
+  s.add_development_dependency "mongoid"
+  s.add_development_dependency "gemfury"
+end

data/lib/json/patch.rb

@@ -0,0 +1,69 @@
+require "json/patch/version"
+
+module JSON
+  class Patch
+    attr_reader :hunks
+
+    def initialize(hunks)
+      @hunks = hunks.map {|h| Hunk.new(h)}
+    end
+
+    # Apply this patch to an object
+    #
+    # The object to be modified (which may be nested inside the object
+    # in the method signature) MUST implement #apply_patch.
+    #
+    # #apply_patch should return true if the patch can be succesfully
+    # applied and false otherwise.
+    #
+    # If any hunk in the patch cannot be applied successfully, the
+    # PATCH rfc dictates that the entire patch MUST not be
+    # applied. This atomicity must be handled by the #apply_patch
+    # implementation.
+    def apply_to(object)
+      object.apply_patch(self)# if object.respond_to?(:apply_patch)
+    end
+  end
+
+  class Hunk
+    attr_reader :op, :path, :value
+
+    def initialize(attributes={})
+      op = case
+           when attributes.has_key?('add') then 'add'
+           when attributes.has_key?('remove') then 'remove'
+           when attributes.has_key?('replace') then 'replace'
+           end
+      if op
+        @op = op.to_sym
+      else
+        raise ArgumentError
+      end
+      self.path = attributes[op]
+      @value = attributes['value']
+    end
+
+    def path=(path_string)
+      raise ArgumentError if path_string and not path_string[0] == '/'
+      path_string ||= ''
+      @path = path_string.split('/').drop(1).map {|section| section.to_sym}
+    end
+
+    # Given a root object, resolve the paths in this patch.
+    # Return a tuple of the object and element to be modified.
+    #
+    # For example (from the specs):
+    #
+    # OpenStruct.new(:foo => 1, :bar => OpenStruct.new(:baz => 2))
+    # JSON::Hunk.new('add' => '/bar/baz').resolve_path(obj).should == [obj.bar, :baz]
+    def resolve_path(object)
+      path_to_element = path[0..-2]
+      element = path[-1]
+      [path_to_element.inject(object) {|o, e| o.send(e) }, element]
+    end
+
+    def ==(other)
+      op == other.op and path == other.path and value = other.value
+    end
+  end
+end

data/lib/json/patch/version.rb

@@ -0,0 +1,5 @@
+module JSON
+  class Patch
+    VERSION = "0.2.1"
+  end
+end

data/lib/mongoid/patchable.rb

@@ -0,0 +1,110 @@
+module Mongoid
+  module Patchable
+    # Apply a patch this this document.
+    #
+    # Currently assumes add_to_set and set operations will succeed.
+    #
+    # TODO: is there a better way to ensure atomicity of multiple
+    # operations while avoiding race conditions from multiple clients?
+    #
+    # it looks like
+    #
+    # Preferences.collection.update({'user_id' => 1}, {'$addToSet' => {'follow_suggest_blacklist' => 4}, '$set' => {'hams' => 2}})
+    #
+    # would do this, but a) it needs to deal with multiple hunks
+    # acting on the same attribute and b) it looks like mongoid
+    # doesn't support this ootb. more research needed...
+    #
+    # TODO: handle numeric path segments
+    def apply_patch(patch)
+      # compile operation information for verification
+      ops = patch.hunks.map do |hunk|
+        (obj, element) = hunk.resolve_path(self)
+        [hunk, obj, element, obj.fields[element.to_s]]
+      end
+
+      if patch_ops_valid?(ops)
+        # if something goes wrong here, raise an error to let the client
+        # know the patch may be partially applied
+        ops.each_with_index do |(hunk, obj, element, field), index|
+          value = hunk.value
+          case hunk.op
+          when :add
+            process_add(obj, field, element, value)
+          when :replace
+            process_replace(obj, field, element, value)
+          when :remove
+            process_remove(obj, field, element, value)
+          else
+            raise "Illegal operation #{hunk.op} in hunk #{index}"
+          end
+        end
+        true
+      end
+    end
+
+    protected
+
+    def process_add(obj, field, element, value)
+      case field.type.name
+      when 'Array'
+        obj.add_to_set(element, (value.is_a?(Array) ? {'$each' => value} : value))
+      when 'Hash'
+        (key, val) = destructure_hash_value(value)
+        obj.send("#{element}=", {}) if obj.send(element).nil?
+        obj.send(element)[key] = val
+        obj.save(validate: false)
+      else
+        obj.write_attribute(element, value)
+        obj.save
+      end
+    end
+
+    def process_replace(obj, field, element, value)
+      case field.type.name
+      when 'Array'
+        obj.add_to_set(element, (value.is_a?(Array) ? {'$each' => value} : value))
+      when 'Hash'
+        (key, val) = destructure_hash_value(value)
+        obj.send("#{element}=", {}) if obj.send(element).nil?
+        obj.send(element)[key] = val
+        obj.save(validate: false)
+      else
+        obj.write_attribute(element, value)
+        obj.save
+      end
+    end
+
+    def process_remove(obj, field, element, value = nil)
+      case field.type.name
+      when 'Array'
+        obj.pull_all(element, (value.is_a?(Array) ? value : [value]))
+      when 'Hash'
+        (key, val) = destructure_hash_value(value)
+        if obj.send(element).nil?
+          obj.send("#{element}=", {})
+        else
+          obj.send(element).delete(key)
+        end
+        obj.save(validate: false)
+      else
+        obj.write_attribute(element, nil)
+        obj.save
+      end
+    end
+
+    def patch_ops_valid?(ops)
+      ops.inject(true) do |valid, (hunk, obj, element, field)|
+        return false unless valid && hunk && obj && element && field
+        return !hunk.value.nil? if [:add, :replace].include?(hunk.op)
+        return true if hunk.op == :remove
+        false
+      end
+    end
+
+    def destructure_hash_value(value)
+      (key, value) = value.split(/\=/, 2)
+      key.ends_with?('[]') ? [key.slice(0..-3), value.split(',')] : [key, value]
+    end
+  end
+end

data/spec/json/patch_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'ostruct'
+
+def os(a); OpenStruct.new(a) end
+
+describe JSON::Patch do
+  let(:hunk) { { 'add' => '/foo/bar', 'value' => 'hams'} }
+  subject {JSON::Patch.new([hunk])}
+
+  describe '#initialize' do
+    its(:hunks) { should eq([JSON::Hunk.new(hunk)])}
+  end
+
+  describe '#apply_to' do
+    let(:obj) { os(:foo => 1, :bar => os(:baz => 2)) }
+    it 'should call apply_patch on the target' do
+      obj.expects(:apply_patch).with(subject).returns(true)
+      subject.apply_to(obj).should == true
+    end
+  end
+end
+
+describe JSON::Hunk do
+  subject {JSON::Hunk.new('add' => '/foo/bar', 'value' => 'hams')}
+
+  describe "#initialize" do
+    its(:op) { should eq(:add)}
+    its(:path) { should eq([:foo, :bar])}
+    its(:value) { should eq('hams')}
+  end
+
+  describe '#path=' do
+    it 'should split paths' do
+      subject.path = '/foo/bar'
+      subject.path.should == [:foo, :bar]
+    end
+
+    it 'should set paths to an empty list when given nil' do
+      subject.path = nil
+      subject.path.should == []
+    end
+
+    it 'should raise an argument error if path without starting slash is passed' do
+      lambda { subject.path = 'foo/bar' }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe '#resolve_path' do
+    let(:obj) { os(:foo => 1, :bar => os(:baz => 2)) }
+    it "should resolve paths" do
+      JSON::Hunk.new('add' => '/foo').resolve_path(obj).should == [obj, :foo]
+      JSON::Hunk.new('add' => '/bar/baz').resolve_path(obj).should == [obj.bar, :baz]
+    end
+  end
+end

data/spec/mongoid/patchable_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'mongoid'
+require 'mongoid/patchable'
+require 'json/patch'
+
+class PatchableDoc
+  include Mongoid::Document
+  include Mongoid::Patchable
+  field :foo, type: Array
+  field :bar, type: Hash
+  field :baz, type: Integer
+end
+
+describe Mongoid::Patchable do
+  subject { PatchableDoc.new }
+
+  describe "#apply_patch" do
+    it 'should call process_add' do
+      subject.expects(:process_add).with(subject, subject.fields['foo'], :foo, 12345)
+      subject.apply_patch(JSON::Patch.new([{ 'add' => '/foo', 'value' => 12345}])).should be_true
+    end
+
+    it 'should call process_replace' do
+      subject.expects(:process_replace).with(subject, subject.fields['foo'], :foo, 12345)
+      subject.apply_patch(JSON::Patch.new([{ 'replace' => '/foo', 'value' => 12345}])).should be_true
+    end
+
+    it 'should call process_remove' do
+      subject.expects(:process_remove).with(subject, subject.fields['foo'], :foo, nil)
+      subject.apply_patch(JSON::Patch.new([{ 'remove' => '/foo'}])).should be_true
+    end
+  end
+
+  describe "#process_add" do
+    it "should add a scalar element to an array" do
+      subject.expects(:add_to_set).with(:foo, 12345)
+      subject.send(:process_add, subject, subject.fields['foo'], :foo, 12345)
+    end
+
+    it "should add an array element to an array" do
+      subject.expects(:add_to_set).with(:foo, {'$each' => [12345]})
+      subject.send(:process_add, subject, subject.fields['foo'], :foo, [12345])
+    end
+
+    it "should add an element to a hash" do
+      subject.expects(:save)
+      subject.send(:process_add, subject, subject.fields['bar'], :bar, "rilo=kiley")
+      subject.bar.should == {'rilo' => 'kiley'}
+    end
+
+    it "should set a scalar" do
+      subject.expects(:write_attribute).with(:baz, 12345)
+      subject.expects(:save)
+      subject.send(:process_add, subject, subject.fields['baz'], :baz, 12345)
+    end
+  end
+
+  describe "#process_replace" do
+    it "should replace a scalar element in an array" do
+      subject.expects(:add_to_set).with(:foo, 12345)
+      subject.send(:process_replace, subject, subject.fields['foo'], :foo, 12345)
+    end
+
+    it "should replace an array element in an array" do
+      subject.expects(:add_to_set).with(:foo, {'$each' => [12345]})
+      subject.send(:process_replace, subject, subject.fields['foo'], :foo, [12345])
+    end
+
+    it "should replace an element in a hash" do
+      subject.bar = {'rilo' => 'yelik'}
+      subject.expects(:save)
+      subject.send(:process_replace, subject, subject.fields['bar'], :bar, "rilo=kiley")
+      subject.bar.should == {'rilo' => 'kiley'}
+    end
+
+    it "should replace a scalar" do
+      subject.baz = 54321
+      subject.expects(:write_attribute).with(:baz, 12345)
+      subject.expects(:save)
+      subject.send(:process_replace, subject, subject.fields['baz'], :baz, 12345)
+    end
+  end
+
+  describe "#process_remove" do
+    it "should remove a scalar element from an array" do
+      subject.expects(:pull_all).with(:foo, [12345])
+      subject.send(:process_remove, subject, subject.fields['foo'], :foo, 12345)
+    end
+
+    it "should remove a array element from an array" do
+      subject.expects(:pull_all).with(:foo, [12345])
+      subject.send(:process_remove, subject, subject.fields['foo'], :foo, [12345])
+    end
+
+    it "should remove an element from a hash" do
+      subject.bar = {'rilo' => 'kiley'}
+      subject.expects(:save)
+      subject.send(:process_remove, subject, subject.fields['bar'], :bar, "rilo")
+      subject.bar.should == {}
+    end
+
+    it "should nil a scalar" do
+      subject.baz = 54321
+      subject.expects(:write_attribute).with(:baz, nil)
+      subject.expects(:save)
+      subject.send(:process_remove, subject, subject.fields['baz'], :baz)
+    end
+  end
+
+  describe "#destructure_hash_value" do
+    it "should return array of key and value" do
+      subject.send(:destructure_hash_value, "foo=bar").should == ['foo', 'bar']
+    end
+
+    it "should return removed square brackets from key and array from csv string" do
+      subject.send(:destructure_hash_value, "foo[]=bar,baz").should == ['foo', ['bar', 'baz']]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+
+require 'rspec'
+require 'mocha'
+require 'json/patch'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification 
+name: json_patch
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Travis Vachon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-07 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: gemfury
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: |
+  An implementation of JSON patch in Ruby.
+  
+  http://tools.ietf.org/html/draft-pbryan-json-patch-01
+  
+  Utilities for applying JSON patches to arbitary objects. To
+  participate in the patch protocol, classes can implement #apply_patch
+
+email: 
+- travis@copious.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- json_patch.gemspec
+- lib/json/patch.rb
+- lib/json/patch/version.rb
+- lib/mongoid/patchable.rb
+- spec/json/patch_spec.rb
+- spec/mongoid/patchable_spec.rb
+- spec/spec_helper.rb
+homepage: ""
+licenses: []
+
+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: json_patch
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: JSON patch implementation in ruby
+test_files: 
+- spec/json/patch_spec.rb
+- spec/mongoid/patchable_spec.rb
+- spec/spec_helper.rb