hpath 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae758397369c5c2d912cd7a10b7377683709574d
-  data.tar.gz: e55ba308d80557c51374868351b2a74c65abc61c
+  metadata.gz: 48e68e9a43e8aa6503dfe2d32f11d7f23d64c91c
+  data.tar.gz: 38d8d636bd3036953d60ad0a6aed7f26630fee60
 SHA512:
-  metadata.gz: 4fd4f632561c47eb0518b37b28ee9b1d4fcac108ba9f2758378128c7921f1f5ddf957fa9d33651ab2f50afb4c36c996b2df01b21bfa61cbcb074a102b3285ca5
-  data.tar.gz: 6dd7f7123466bebc8dcbdbdb96b6272f6ca29568f565bf4a5a1aeddca53701fb6e84dbab3e073552b5dcbe77487cf799b6e8ea81826fb942f319c543d8505601
+  metadata.gz: 6712f8e3953f4956553e8bfb562a06d56276d0186ceaae1d0e4df06ac12c74db9b804ab27c18795833f99e81c4da86ec4fae138728174e65598b82c06b5108e5
+  data.tar.gz: 2a6a9cc297711ca0554b2b124faadfffa2ade0b57374bf44485369a0a5fc519169e7ef6e0937a9c1c8f55bb617919073706f47012b10eb3e56ae05787b8af14c

data/TODO.md

@@ -0,0 +1,7 @@
+# TODO
+
+* detection of scalar datatypes
+  * integers, floats, strings, bool
+  * string overwrite with [key="value"]
+* functions
+  * /search(foo)/price/sum()

data/lib/hpath.rb

@@ -16,6 +16,18 @@ module Hpath
   #
   private
   #
+  def self._dfs(object, filter)
+    if filter.applies?(object)
+      object
+    elsif object.is_a?(Array)
+      object.map { |e| _dfs(e, filter) }
+      .tap { |o| o.compact! }
+      .tap { |o| o.flatten!(1) }
+    elsif object.is_a?(Hash)
+      _dfs(object.values, filter)
+    end
+  end
+  
   def self._get(object, paths, parent = object)
     _object = object
 
@@ -25,8 +37,16 @@ module Hpath
       path = paths.shift
     end
 
+    if path[:filter]
+      filter = Hpath::Filter.new(path[:filter])
+    end
+
     if path[:identifier]
-      object = _resolve_identifier(object, path[:identifier])
+      if path[:identifier] == "**"
+        object = _dfs(object, filter)
+      else
+        object = _resolve_identifier(object, path[:identifier])
+      end
     elsif path[:axis] == "parent"
       object = parent
     end
@@ -37,7 +57,7 @@ module Hpath
       object = _resolve_keys(object, path[:keys])
     end
 
-    unless path[:filter].nil?
+    if filter && !(path[:identifier] && path[:identifier] == "**")
       object = _apply_filters(object, Hpath::Filter.new(path[:filter]))
     end
 

data/lib/hpath/filter.rb

@@ -7,6 +7,8 @@ class Hpath::Filter
       @children = filter_hash.values.first.map do |element|
         Hpath::Filter.new(element)
       end
+    elsif @type == :key_existence_filter
+      @key = filter_hash[:key_existence_filter][:key]
     elsif @type == :key_value_filter
       @key = filter_hash[:key_value_filter][:key]
       @value = filter_hash[:key_value_filter][:value]
@@ -18,6 +20,10 @@ class Hpath::Filter
       @children.all? { |child_filter| child_filter.applies?(object) }
     elsif @type == :or_filter
       @children.any? { |child_filter| child_filter.applies?(object) }
+    elsif @type == :key_existence_filter
+      if object.is_a?(Hash)
+        object.keys.include?(@key.to_s) || object.keys.include?(@key.to_sym)
+      end
     elsif @type == :key_value_filter
       if object.is_a?(Hash) && (@value.is_a?(String) || @value.is_a?(Symbol))
         object[@key.to_s] == @value.to_s || object[@key.to_sym] == @value.to_s ||

data/lib/hpath/parser.rb

@@ -34,6 +34,10 @@ class Hpath::Parser
       rule(:space)  { match('\s').repeat(1) }
       rule(:space?) { space.maybe }
 
+      rule(:key_existence_filter) {
+        space? >> match['0-9a-zA-Z@_'].repeat(1).as(:key) >> str("?") >> space?
+      }
+
       rule(:key_value_filter) {
         space? >> match['0-9a-zA-Z@_'].repeat(1).maybe.as(:key) >> (str("<") | str(">") | str("=").repeat(1,3)).as(:operator) >> match['a-zA-Z0-9'].repeat(1).as(:value) >> space?
       }
@@ -53,7 +57,7 @@ class Hpath::Parser
       }
 
       rule(:filter) {
-        space? >> (or_filter.as(:or_filter) | and_filter.as(:and_filter) | key_value_filter.as(:key_value_filter)).as(:filter) >> space?
+        space? >> (or_filter.as(:or_filter) | and_filter.as(:and_filter) | key_existence_filter.as(:key_existence_filter) | key_value_filter.as(:key_value_filter)).as(:filter) >> space?
       }
 
       rule(:keys) {
@@ -99,6 +103,10 @@ class Hpath::Parser
         }
       }
 
+      rule(key: simple(:key)) {
+        { key: key.nil? ? nil : key.to_sym }
+      }
+
       rule(key: simple(:key), operator: simple(:operator), value: simple(:value)) {
         { key: key.nil? ? nil : key.to_sym, operator: operator.to_s, value: value.to_s }
       }

data/lib/hpath/version.rb

@@ -1,3 +1,3 @@
 module Hpath
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/spec/hpath/filter_spec.rb

@@ -1,4 +1,16 @@
 describe Hpath::Filter do
+  describe "key exists filter \"[foobar?\"]" do
+    context "when object is a array of hashes" do
+      let(:filter) { Hpath::Filter.new(key_existence_filter: { key: "foobar"} ) }
+      let(:array_of_hashes) { [{foobar: 1}, {foo: 2}, {bar: 3}, {foobar: "foobar"}]}
+
+      it "returns hashes, which include the given key" do
+        filtered_array = array_of_hashes.select{ |e| filter.applies?(e) }
+        expect(filtered_array).to eq([{foobar: 1}, {foobar: "foobar"}])
+      end
+    end
+  end
+
   context "initialized with a (nested) filter hash" do
     let(:filter_hash) { Hpath::Parser.new.parse("/array/*[a=b,c=d,(e=d|e=f)]")[:path].first[:filter] }
 

data/spec/hpath_spec.rb

@@ -30,7 +30,7 @@ describe Hpath do
 
       it "processes \"/*\" for a hash" do
         hpath_result = Hpath.get({a: "b", c: "d"}, "/*")
-        expect(hpath_result).to eq([{a: "b"}, {c: "d"}])
+        expect(hpath_result).to eq([{:a=>"b"}, {:c=>"d"}])
       end
       
       it "processes \"/[key1, key2]\" for a hash" do
@@ -67,6 +67,42 @@ describe Hpath do
         hpath_result = Hpath.get([{ foo: { bar: "foobar" } }],  "/[0]/::parent")
         expect(hpath_result).to eq([{ foo: { bar: "foobar" } }])
       end
+
+      it "processes \"/**[filter]\"" do
+        hpath_result = Hpath.get({
+          query: {
+            bool: {
+              must: [
+                {
+                  query_string: {
+                    query: "linux",
+                    fields: ["_all", "title^2"]
+                  }
+                },
+                {
+                  query_string: {
+                    query: "kofler",
+                    fields: ["creator"]
+                  }
+                }
+              ],
+              should: [
+                {
+                  query_string: {
+                    query: "linux",
+                    fields: ["subject"]
+                  }
+                }
+              ]
+            }
+          }
+        }, "/**[query_string?]")
+        expect(hpath_result).to eq(
+          [{:query_string=>{:query=>"linux", :fields=>["_all", "title^2"]}},
+           {:query_string=>{:query=>"kofler", :fields=>["creator"]}},
+           {:query_string=>{:query=>"linux", :fields=>["subject"]}}]
+        )
+      end
     end
 
     describe "returns nil for non-matching hpath expressions" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hpath
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Michael Sievers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-10 00:00:00.000000000 Z
+date: 2014-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -84,6 +84,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- TODO.md
 - hpath.gemspec
 - lib/hpath.rb
 - lib/hpath/filter.rb