hpath 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d97f5894eb225d22238c604ab0fc4e06a31e5fa1
-  data.tar.gz: a52d7400d901e41584dafb8613048358cfb78a2f
+  metadata.gz: 8a89f4dea22fe5b719e3f2c4402806bc07eb0676
+  data.tar.gz: 8a49750d03f96bfaf46c1a50181778d99eecea08
 SHA512:
-  metadata.gz: 7ed6a57ed11bd16a296a6572ea282190960f0f60ca925d7226c469c461948c9bdc89e10972fed14221316c0fa138382cabf6c10b9a05485bbcf524b1b49f3bc1
-  data.tar.gz: 3e0bb084b7274f51c8c53bd175ee3992f7049d3689d257f9851a31376ce88bd01cc8e6800d3a105c761869fd3e8f7fb3497b064c66b004f3f3c2abbf16368af4
+  metadata.gz: ffed5bced9a44c68d3d7d85b54580bec011178371519b4827daae79236d9230decf7ffcd6eb58eba2a8596be83490434ec1559032fe8a4308534ff1840c7c1f8
+  data.tar.gz: a777601d83a4633630ff28ce802577e25fe702a8ff767aa30cc20b922d51814ec986c39d1bbd8690ebd68429ee1a0d6361e24656a3f08d71dc84547952985741

data/lib/hpath.rb

@@ -8,6 +8,11 @@ module Hpath
     _get(object, hpath[:path])
   end
 
+  def self.set(object, hpath_string, value)
+    hpath = Hpath::Parser.parse(hpath_string)
+    _set(object, hpath[:path], value)
+  end
+
   #
   private
   #
@@ -39,18 +44,46 @@ module Hpath
     self._get(object, paths, _object)
   end
 
+  def self._set(object, paths, value)
+    if paths.empty?
+      if object.is_a?(Array)
+        object.push(value)
+      elsif object.is_a?(Hash)
+        object.merge!(value)
+      end
+
+      return
+    else
+      path = paths.shift
+    end
+
+    if (_object = self._get(object, [path])).nil?
+      if object.is_a?(Array)
+        if path[:type] == Array
+          object.push(_object = [])
+        elsif path[:type] == Hash
+          object.push({ path[:identifier].to_sym => (_object = {}) })
+        end
+      elsif object.is_a?(Hash)
+        object[path[:identifier].to_sym] = (_object = path[:type].new)
+      end
+    end
+
+    self._set(_object, paths, value)
+  end
+
   def self._apply_filters(object, filter)
     if object.is_a?(Array)
       object.select do |element|
         filter.applies?(element)
       end
     else
-      #binding.pry
+      # TODO
     end
   end
 
   def self._resolve_identifier(object, identifier)
-    if object.is_a?(Array)
+    if object.is_a?(Array) && !object.empty?
       if identifier.to_s == "*"
         object
       else
@@ -71,14 +104,14 @@ module Hpath
         object[identifier.to_s] || object[identifier.to_sym]
       end
     else
-      #binding.pry
+      # TODO
     end
   end
 
   def self._resolve_indices(object, indices)
     if indices.length == 1
       object[indices.first]
-    else
+    elsif indices.length > 1
       indices.map { |index| object[index] }
     end
   end

data/lib/hpath/parser.rb

@@ -21,6 +21,7 @@ class Hpath::Parser
       element[:indices] = [element[:indices]] if !element[:indices].nil? && !element[:indices].is_a?(Array)
       element[:keys] ||= nil
       element[:keys] = [element[:keys]] if !element[:keys].nil? && !element[:keys].is_a?(Array)
+      element[:type] = element[:type] == "[]" || element[:indices].is_a?(Array) ? Array : Hash
       element
     end
 
@@ -68,7 +69,7 @@ class Hpath::Parser
       }
 
       rule(:node) {
-        str("/") >> (identifier.as(:identifier) | (str("::") >> identifier.as(:axis))).maybe >> (str("[") >> space? >> (indices.as(:indices) | filter | keys.as(:keys)) >> space? >> str("]")).maybe
+        str("/") >> (identifier.as(:identifier) | (str("::") >> identifier.as(:axis))).maybe >> (str("[]").as(:type) | (str("[") >> space? >> (indices.as(:indices) | filter | keys.as(:keys)) >> space? >> str("]"))).maybe
       }
 
       rule(:path) {
@@ -87,13 +88,14 @@ class Hpath::Parser
   def transformation
     @transformation ||=
     Class.new(Parslet::Transform) do
-      rule(axis: simple(:axis), identifier: simple(:identifier), filter: subtree(:filter), indices: subtree(:indices), keys: subtree(:keys)) {
+      rule(axis: simple(:axis), identifier: simple(:identifier), filter: subtree(:filter), indices: subtree(:indices), keys: subtree(:keys), type: simple(:type)) {
         {
           axis: axis.nil? ? nil : axis.to_s,
           identifier: identifier.nil? ? nil : identifier.to_s,
           filter: filter,
           indices: indices.nil? ? nil : indices.map { |element| Integer(element[:index]) },
-          keys: keys.nil? ? nil : keys.map { |element| element[:key].to_s.to_sym }
+          keys: keys.nil? ? nil : keys.map { |element| element[:key].to_s.to_sym },
+          type: type
         }
       }
 

data/lib/hpath/version.rb

@@ -1,3 +1,3 @@
 module Hpath
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/hpath_spec.rb

@@ -66,5 +66,31 @@ describe Hpath do
         expect(hpath_result).to eq([{ foo: { bar: "foobar" } }])
       end
     end
+
+    describe "returns nil for non-matching hpath expressions" do
+      it "does not process \"/key1\" for an empty array" do
+        hpath_result = Hpath.get([], "/foo")
+        expect(hpath_result).to eq(nil)
+      end
+    end
+  end
+
+  describe "#set" do
+    describe "sets the object identified by its hpath to the given value" do
+      it "processes \"/key1/key2\" for a hash" do
+        Hpath.set(hash = {}, "/foo/bar", { muff: "foobar"})
+        expect(hash).to eq({foo: { bar: { muff: "foobar"} }})
+      end
+
+      it "processes \"/[]/key2\" for a array" do
+        Hpath.set(array = [], "/[]/bar", { foo: "bar"})
+        expect(array).to eq([{ bar: {foo: "bar"} }])
+      end
+
+      it "processes \"/key1[]/key2\" for a array" do
+        Hpath.set(hash = {}, "/key1[]/bar", { foo: "bar"})
+        expect(hash).to eq({key1: [{bar: {foo: "bar"}}]})
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hpath
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Michael Sievers