object_patch 0.8.1

data/lib/object_patch/operations/add.rb

@@ -0,0 +1,57 @@
+
+module ObjectPatch::Operations
+
+  # A representation of a JSON pointer add operation.
+  class Add
+
+    # Apply this operation to the provided document and return the updated
+    # document. Please note that the changes will be reflected not only in the
+    # returned value but the original document that was passed in as well.
+    #
+    # @param [Object] target_doc The document that will be modified by this
+    #   patch.
+    # @return [Object] The modified document
+    def apply(target_doc)
+      key = processed_path.last
+      inner_obj = ObjectPatch::Pointer.eval(processed_path[0...-1], target_doc)
+      
+      raise MissingTargetException, @path unless inner_obj
+
+      if key
+        ObjectPatch::Operations.add_op(inner_obj, key, @value)
+      else
+        inner_obj.replace(@value)
+      end
+
+      target_doc
+    end
+
+    # Setup the add operation with any required arguments.
+    #
+    # @param [Hash] patch_data Parameters necessary to build the operation.
+    # @option patch_data [String] path The location in the target document to
+    #   add.
+    # @option patch_data [Object] value The value to insert into the target.
+    # @return [void]
+    def initialize(patch_data)
+      @path  = patch_data.fetch('path')
+      @value = patch_data.fetch('value')
+    end
+
+    # Returns the path after being expanded by the JSON pointer semantics.
+    #
+    # @return [Array<String>] Expanded pointer path
+    def processed_path
+      ObjectPatch::Pointer.parse(@path)
+    end
+
+    # Covert this operation to a format that can be built into a full on JSON
+    # patch.
+    #
+    # @return [Hash<String => String>] JSON patch add operation
+    def to_patch
+      { 'op' => 'add', 'path' => @path, 'value' => @value }
+    end
+  end
+end
+

data/lib/object_patch/operations/copy.rb

@@ -0,0 +1,69 @@
+
+module ObjectPatch::Operations
+
+  # A representation of a JSON pointer copy operation.
+  class Copy
+
+    # Apply this operation to the provided document and return the updated
+    # document. Please note that the changes will be reflected not only in the
+    # returned value but the original document that was passed in as well.
+    #
+    # @param [Object] target_doc The document that will be modified by this
+    #   patch.
+    # @return [Object] The modified document
+    def apply(target_doc)
+      src_key = processed_from.last
+      dst_key = processed_path.last
+
+      src_obj = ObjectPatch::Pointer.eval(processed_from[0...-1], target_doc)
+      dst_obj = ObjectPatch::Pointer.eval(processed_path[0...-1], target_doc)
+
+      if src_obj.is_a?(Array)
+        raise ObjectPatch::InvalidIndexError unless src_key =~ /\A\d+\Z/
+        copied_obj = src_obj.fetch(src_key.to_i)
+      else
+        copied_obj = src_obj.fetch(src_key)
+      end
+
+      ObjectPatch::Operations.add_op(dst_obj, dst_key, copied_obj)
+
+      target_doc
+    end
+
+    # Setup the replace operation with any required arguments.
+    #
+    # @param [Hash] patch_data Parameters necessary to build the operation.
+    # @option patch_data [String] path The location in the target document to
+    #   duplicate the data to.
+    # @option patch_data [String] from The source data that will be copied into
+    #   the new location.
+    # @return [void]
+    def initialize(patch_data)
+      @from = patch_data.fetch('from')
+      @path = patch_data.fetch('path')
+    end
+
+    # Returns the from field after being expanded by the JSON pointer semantics.
+    #
+    # @return [Array<String>] Expanded pointer path
+    def processed_from
+      ObjectPatch::Pointer.parse(@from)
+    end
+
+    # Returns the path after being expanded by the JSON pointer semantics.
+    #
+    # @return [Array<String>] Expanded pointer path
+    def processed_path
+      ObjectPatch::Pointer.parse(@path)
+    end
+
+    # Covert this operation to a format that can be built into a full on JSON
+    # patch.
+    #
+    # @return [Hash<String => String>] JSON patch copy operation
+    def to_patch
+      { 'op' => 'copy', 'from' => @from, 'path' => @path }
+    end
+  end
+end
+

data/lib/object_patch/operations/move.rb

@@ -0,0 +1,63 @@
+
+module ObjectPatch::Operations
+
+  # A representation of a JSON pointer move operation.
+  class Move
+
+    # Apply this operation to the provided document and return the updated
+    # document. Please note that the changes will be reflected not only in the
+    # returned value but the original document that was passed in as well.
+    #
+    # @param [Object] target_doc The document that will be modified by this
+    #   patch.
+    # @return [Object] The modified document
+    def apply(target_doc)
+      src_key = processed_from.last
+      dst_key = processed_path.last
+
+      src_obj = ObjectPatch::Pointer.eval(processed_from[0...-1], target_doc)
+      dst_obj = ObjectPatch::Pointer.eval(processed_path[0...-1], target_doc)
+
+      moved_value = ObjectPatch::Operations.rm_op(src_obj, src_key)
+      ObjectPatch::Operations.add_op(dst_obj, dst_key, moved_value)
+
+      target_doc
+    end
+
+    # Setup the replace operation with any required arguments.
+    #
+    # @param [Hash] patch_data Parameters necessary to build the operation.
+    # @option patch_data [String] path The location in the target document to
+    #   place moved data.
+    # @option patch_data [String] from The location that will be moved to a new
+    #   path.
+    # @return [void]
+    def initialize(patch_data)
+      @from = patch_data.fetch('from')
+      @path = patch_data.fetch('path')
+    end
+
+    # Returns the from field after being expanded by the JSON pointer semantics.
+    #
+    # @return [Array<String>] Expanded pointer path
+    def processed_from
+      ObjectPatch::Pointer.parse(@from)
+    end
+
+    # Returns the path after being expanded by the JSON pointer semantics.
+    #
+    # @return [Array<String>] Expanded pointer path
+    def processed_path
+      ObjectPatch::Pointer.parse(@path)
+    end
+
+    # Covert this operation to a format that can be built into a full on JSON
+    # patch.
+    #
+    # @return [Hash<String => String>] JSON patch move operation
+    def to_patch
+      { 'op' => 'move', 'from' => @from, 'path' => @path }
+    end
+  end
+end
+

data/lib/object_patch/operations/remove.rb

@@ -0,0 +1,49 @@
+
+module ObjectPatch::Operations
+
+  # A representation of a JSON pointer remove operation.
+  class Remove
+
+    # Apply this operation to the provided document and return the updated
+    # document. Please note that the changes will be reflected not only in the
+    # returned value but the original document that was passed in as well.
+    #
+    # @param [Object] target_doc The document that will be modified by this
+    #   patch.
+    # @return [Object] The modified document
+    def apply(target_doc)
+      key = processed_path.last
+      inner_obj = ObjectPatch::Pointer.eval(processed_path[0...-1], target_doc)
+
+      ObjectPatch::Operations.rm_op(inner_obj, key)
+
+      target_doc
+    end
+
+    # Setup the remove operation with any required arguments.
+    #
+    # @param [Hash] patch_data Parameters necessary to build the operation.
+    # @option patch_data [String] path The location in the target document to
+    #   remove.
+    # @return [void]
+    def initialize(patch_data)
+      @path = patch_data.fetch('path')
+    end
+
+    # Returns the path after being expanded by the JSON pointer semantics.
+    #
+    # @return [Array<String>] Expanded pointer path
+    def processed_path
+      ObjectPatch::Pointer.parse(@path)
+    end
+
+    # Covert this operation to a format that can be built into a full on JSON
+    # patch.
+    #
+    # @return [Hash<String => String>] JSON patch remove operation
+    def to_patch
+      { 'op' => 'remove', 'path' => @path }
+    end
+  end
+end
+

data/lib/object_patch/operations/replace.rb

@@ -0,0 +1,59 @@
+
+module ObjectPatch::Operations
+
+  # A representation of a JSON pointer replace operation.
+  class Replace
+
+    # Apply this operation to the provided document and return the updated
+    # document. Please note that the changes will be reflected not only in the
+    # returned value but the original document that was passed in as well.
+    #
+    # @param [Object] target_doc The document that will be modified by this
+    #   patch.
+    # @return [Object] The modified document
+    def apply(target_doc)
+      return @value if processed_path.empty?
+
+      key = processed_path.last
+      inner_obj = ObjectPatch::Pointer.eval(processed_path[0...-1], target_doc)
+
+      if inner_obj.is_a?(Array)
+        raise ObjectPatch::InvalidIndexError unless key =~ /\A\d+\Z/
+        inner_obj[key.to_i] = @value
+      else
+        inner_obj[key] = @value
+      end
+
+      target_doc
+    end
+
+    # Setup the replace operation with any required arguments.
+    #
+    # @param [Hash] patch_data Parameters necessary to build the operation.
+    # @option patch_data [String] path The location in the target document to
+    #   replace with the provided data.
+    # @option patch_data [String] value The value that should be written over
+    #   whatever is at the provided path.
+    # @return [void]
+    def initialize(patch_data)
+      @path  = patch_data.fetch('path')
+      @value = patch_data.fetch('value')
+    end
+
+    # Returns the path after being expanded by the JSON pointer semantics.
+    #
+    # @return [Array<String>] Expanded pointer path
+    def processed_path
+      ObjectPatch::Pointer.parse(@path)
+    end
+
+    # Covert this operation to a format that can be built into a full on JSON
+    # patch.
+    #
+    # @return [Hash<String => String>] JSON patch replace operation
+    def to_patch
+      { 'op' => 'replace', 'path' => @path, 'value' => @value }
+    end
+  end
+end
+

data/lib/object_patch/operations/test.rb

@@ -0,0 +1,47 @@
+
+module ObjectPatch::Operations
+
+  # An implementation of the JSON patch test operation.
+  class Test
+
+    # A simple test to validate the value at the expected location matches the
+    # value in the patch information. Will raise an error if the test fails.
+    #
+    # @param [Object] target_doc
+    # @return [Object] Unmodified version of the document.
+    def apply(target_doc)
+      unless @value == ObjectPatch::Pointer.eval(processed_path, target_doc)
+        raise ObjectPatch::FailedTestException.new(@value, @path)
+      end
+
+      target_doc
+    end
+
+    # Setup the test operation with any required arguments.
+    #
+    # @param [Hash] patch_data Parameters necessary to build the operation.
+    # @option patch_data [String] path The location in the target document to
+    #   test.
+    # @return [void]
+    def initialize(patch_data)
+      @path = patch_data.fetch('path')
+      @value = patch_data.fetch('value')
+    end
+
+    # Returns the path after being expanded by the JSON pointer semantics.
+    #
+    # @return [Array<String>] Expanded pointer path
+    def processed_path
+      ObjectPatch::Pointer.parse(@path)
+    end
+
+    # Covert this operation to a format that can be built into a full on JSON
+    # patch.
+    #
+    # @return [Hash<String => String>] JSON patch test operation
+    def to_patch
+      { 'op' => 'test', 'path' => @path, 'value' => @value }
+    end
+  end
+end
+

data/lib/object_patch/pointer.rb

@@ -0,0 +1,90 @@
+
+module ObjectPatch
+
+  # This module contains the code to convert between an JSON pointer path
+  # representation and the keys required to traverse an array. It can make use
+  # of an a path and evaluate it against a provided (potentially deeply nested)
+  # array or hash.
+  #
+  # This is mostly compliant with RFC6901, however, a few small exceptions have
+  # been made, though they shouldn't break compatibility with pure
+  # implementations.
+  module Pointer
+
+    # Given a parsed path and an object, get the nested value within the object.
+    #
+    # @param [Array<String,Fixnum>] path Key path to traverse to get the value.
+    # @param [Hash,Array] obj The document to traverse.
+    # @return [Object] The value at the provided path.
+    def eval(path, obj)
+      path.inject(obj) do |o, p|
+        if o.is_a?(Hash)
+          raise MissingTargetException unless o.keys.include?(p)
+          o[p]
+        elsif o.is_a?(Array)
+          # The last element +1 is technically how this is interpretted. This
+          # will always trigger the index error so it may not be valuable to
+          # set...
+          p = o.size if p == "-1"
+          # Technically a violation of the RFC to allow reverse access to the
+          # array but I'll allow it...
+          raise ObjectOperationOnArrayException unless p.to_s.match(/\A-?\d+\Z/)
+          raise InvalidIndexError unless p.to_i.abs < o.size
+          o[p.to_i]
+        else
+          # We received a Scalar value from the prior iteration... we can't do
+          # anything with this...
+          raise TraverseScalarException
+        end
+      end
+    end
+
+    # Given an array of keys this will provide a properly escaped JSONPointer
+    # path.
+    #
+    # @param [Array<String,Fixnum>] ary_path
+    # @return [String]
+    def encode(ary_path)
+      ary_path = Array(ary_path).map { |p| p.is_a?(String) ? escape(p) : p }
+      "/" << ary_path.join("/")
+    end
+
+    # Escapes reserved characters as defined by RFC6901. This is intended to
+    # escape individual segments of the pointer and thus should not be run on an
+    # already generated path.
+    #
+    # @see [Pointer#unescape]
+    # @param [String] str
+    # @return [String]
+    def escape(str)
+      str.gsub(/~|\//, { '~' => '~0', '/' => '~1' })
+    end
+
+    # Convert a JSON pointer into an array of keys that can be used to traverse
+    # a parsed JSON document.
+    #
+    # @param [String] path
+    # @return [Array<String,Fixnum>]
+    def parse(path)
+      # I'm pretty sure this isn't quite valid but it's a holdover from
+      # tenderlove's code. Once the operations are refactored I believe this
+      # won't be necessary.
+      return [""] if path == "/"
+      # Strip off the leading slash
+      path = path.sub(/^\//, '')
+      path.split("/").map { |p| unescape(p) }
+    end
+
+    # Unescapes any reserved characters within a JSON pointer segment.
+    #
+    # @see [Pointer#escape]
+    # @param [String] str
+    # @return [String]
+    def unescape(str)
+      str.gsub(/~[01]/, { '~0' => '~', '~1' => '/' })
+    end
+
+    module_function :eval, :encode, :escape, :parse, :unescape
+  end
+end
+

data/lib/object_patch/version.rb

@@ -0,0 +1,4 @@
+
+module ObjectPatch
+  VERSION = "0.8.1" # The current gem version.
+end