hpath 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48e68e9a43e8aa6503dfe2d32f11d7f23d64c91c
-  data.tar.gz: 38d8d636bd3036953d60ad0a6aed7f26630fee60
+  metadata.gz: ad0d4d96a06f668bfa028932de928241d21d8aae
+  data.tar.gz: c92b4b2d8d677a084691274c693f42f6b4638956
 SHA512:
-  metadata.gz: 6712f8e3953f4956553e8bfb562a06d56276d0186ceaae1d0e4df06ac12c74db9b804ab27c18795833f99e81c4da86ec4fae138728174e65598b82c06b5108e5
-  data.tar.gz: 2a6a9cc297711ca0554b2b124faadfffa2ade0b57374bf44485369a0a5fc519169e7ef6e0937a9c1c8f55bb617919073706f47012b10eb3e56ae05787b8af14c
+  metadata.gz: 910e80b2f6345207a9797bd685ece086339a393dc0682a1de716bab213cda1b89b3a2b136767b0da7775e7b0af6f7f10660b64c41040cb8f7b8658a32d02ca53
+  data.tar.gz: 6e167078fd602383453230d92f99481be3fbc41609955ade712e864f66ef5cf82b48ec63d70fb231129f377f6fa73d58ec13af16efa8e224d3926fa227f30936

data/hpath.gemspec

@@ -16,8 +16,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "parslet", ">= 1.6.1"
-
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec",   ">= 3.0.0", "< 4.0.0"

data/lib/hpath.rb

@@ -1,16 +1,15 @@
 module Hpath
-  require "hpath/filter"
   require "hpath/parser"
   require "hpath/version"
 
   def self.get(object, hpath_string)
-    hpath = Hpath::Parser.parse(hpath_string)
-    _get(object, hpath[:path])
+    parsed_hpath = Hpath::Parser.parse(hpath_string)
+    _get(object, parsed_hpath)
   end
 
   def self.set(object, hpath_string, value)
-    hpath = Hpath::Parser.parse(hpath_string)
-    _set(object, hpath[:path], value)
+    parsed_hpath = Hpath::Parser.parse(hpath_string)
+    _set(object, parsed_hpath, value)
   end
 
   #
@@ -37,13 +36,9 @@ module Hpath
       path = paths.shift
     end
 
-    if path[:filter]
-      filter = Hpath::Filter.new(path[:filter])
-    end
-
     if path[:identifier]
       if path[:identifier] == "**"
-        object = _dfs(object, filter)
+        object = _dfs(object, path[:filter])
       else
         object = _resolve_identifier(object, path[:identifier])
       end
@@ -51,14 +46,33 @@ module Hpath
       object = parent
     end
 
-    if path[:indices]
-      object = _resolve_indices(object, path[:indices])
-    elsif path[:keys]
-      object = _resolve_keys(object, path[:keys])
-    end
+    if path[:filter] && !(path[:identifier] && path[:identifier] == "**")
+      filter = path[:filter]
+
+      object =
+      if filter.type == :index
+        indices = path[:filter].operands
 
-    if filter && !(path[:identifier] && path[:identifier] == "**")
-      object = _apply_filters(object, Hpath::Filter.new(path[:filter]))
+        if object.is_a?(Array)
+          if indices.length == 1
+            object[indices.first]
+          elsif indices.length > 1
+            indices.map { |index| object[index] }
+          end
+        elsif object.is_a?(Hash)
+          object.select do |key, value|
+            indices.include?(key.to_s) || indices.include?(key.to_sym)
+          end
+        end
+      else
+        if object.is_a?(Array)
+          object.select do |element|
+            filter.applies?(element)
+          end
+        else
+          # TODO
+        end
+      end
     end
 
     self._get(object, paths, _object)
@@ -73,22 +87,14 @@ module Hpath
 
     if (_object = self._get(object, [path])).nil?
       if object.is_a?(Array)
-        if path[:type] == Array
-          unless paths.empty?
-            object.push(_object = [])
-          else
-            object.push(_object = value)
-          end
-        elsif path[:type] == Hash
-          unless paths.empty?
-            object.push({ path[:identifier].to_sym => (_object = {}) })
-          else
-            object.push({ path[:identifier].to_sym => (_object = value) })
-          end
+        unless paths.empty?
+          object.push({ path[:identifier].to_sym => (_object = {}) })
+        else
+          object.push({ path[:identifier].to_sym => (_object = value) })
         end
       elsif object.is_a?(Hash)
         unless paths.empty?
-          object[path[:identifier].to_sym] = (_object = path[:type].new)
+          object[path[:identifier].to_sym] = (_object = {})
         else
           object[path[:identifier].to_sym] = (_object = value)
         end
@@ -98,16 +104,6 @@ module Hpath
     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
-      # TODO
-    end
-  end
-
   def self._resolve_identifier(object, identifier)
     if object.is_a?(Array) && !object.empty?
       if identifier.to_s == "*"
@@ -135,20 +131,4 @@ module Hpath
       # TODO
     end
   end
-
-  def self._resolve_indices(object, indices)
-    if indices.length == 1
-      object[indices.first]
-    elsif indices.length > 1
-      indices.map { |index| object[index] }
-    end
-  end
-
-  def self._resolve_keys(object, keys)
-    if object.is_a?(Hash)
-      object.select { |key, value| keys.include?(key.to_s) || keys.include?(key.to_sym) }
-    else
-      raise "Cannot resolve keys for non-hash objects!"
-    end
-  end
 end

data/lib/hpath/filter.rb

@@ -1,39 +1,46 @@
 class Hpath::Filter
+  attr_accessor :operands
+  attr_accessor :type
 
-  def initialize(filter_hash)
-    @type = filter_hash.keys.first
-    
-    if @type == :and_filter || @type == :or_filter
-      @children = filter_hash.values.first.map do |element|
-        Hpath::Filter.new(element)
+  def initialize(string = nil)
+    string = string.dup unless string.nil? # we should not use the referenced string
+
+    @type, @operands =
+    if string.nil?
+      [:and, []]
+    else
+      case string
+      when /=/  then [:equality, string.split("=")]
+      when /</  then [:less_than, string.split("<")]
+      when />/  then [:greater_than, string.split(">")]
+      when /\?/ then [:existence, string.split("?")]
+      else [:index, [string[/^\d+$/] ? string.to_i : string]] # convert strings to integer of possible
       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]
     end
+
+    @operands.select! { |operand| operand != "" } if @operands.is_a?(Array)
   end
 
   def applies?(object)
-    if @type == :and_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 @type == :and
+      @operands.all? { |filter| filter.applies?(object) }
+    elsif @type == :or
+      @operands.any? { |filter| filter.applies?(object) }
+    elsif @type == :existence
+      key = operands.first
+      
       if object.is_a?(Hash)
-        object.keys.include?(@key.to_s) || object.keys.include?(@key.to_sym)
+        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 ||
-        object[@key.to_s] == @value.to_sym || object[@key.to_sym] == @value.to_sym
-      else
-        if object.respond_to(@key)
-          object.send(@key) == @value
-        end
+    elsif @type == :equality
+      key, value = @operands
+      
+      if object.is_a?(Hash)
+        object[key.to_s] == value.to_s || object[key.to_sym] == value.to_s ||
+        object[key.to_s] == value.to_sym || object[key.to_sym] == value.to_sym
+      elsif object.respond_to(key)
+        object.send(key) == value
       end
     end
   end
-
 end

data/lib/hpath/parser.rb

@@ -1,115 +1,23 @@
-require "parslet"
-
 class Hpath::Parser
+  require_relative "./parser/filter_expression_parser"
+
   def self.parse(string)
     self.new.parse(string)
   end
 
   def parse(string)
-    transform(normalize(parser.parse(string)))
-  end
-
-  #
-  private
-  #
-  def normalize(result_tree) # to ease transformation
-    result_tree[:path].map! do |element|
-      element[:axis] ||= nil
-      element[:identifier] ||= nil
-      element[:filter] ||= nil
-      element[:indices] ||= nil
-      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
+    string
+    .split("/")
+    .delete_if { |path_element| path_element.empty? }
+    .map! do |path_element|
+      identifier, filter_expression = path_element.gsub("]", "").split("[")
+      filter = FilterExpressionParser.parse(filter_expression) if filter_expression
+
+      {
+        identifier: identifier == "" ? nil : identifier,
+        filter: filter
+      }
+      .select { |key, value| !value.nil? }
     end
-
-    result_tree
-  end
-
-  def parser
-    @parser ||=
-    Class.new(Parslet::Parser) do
-      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?
-      }
-
-      rule(:or_filter) {
-        ((and_filter.as(:and_filter) | key_value_filter.as(:key_value_filter)) >> str("|")).repeat(1) >> (and_filter.as(:and_filter) | key_value_filter.as(:key_value_filter))
-      }
-
-      rule(:primary) {
-        str("(") >> or_filter.as(:or_filter) >> str(")")
-      }
-
-      rule(:and_filter) {
-        ((primary | key_value_filter.as(:key_value_filter)) >>
-        str(",")).repeat(1) >>
-        (primary | key_value_filter.as(:key_value_filter))
-      }
-
-      rule(:filter) {
-        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) {
-        match('[a-zA-Z0-9]').repeat(1).as(:key) >> (space? >> str(",") >> space? >> match('[a-zA-Z0-9]').repeat(1).as(:key)).repeat
-      }
-
-      rule(:indices) {
-        match('[0-9]').repeat(1).as(:index) >> (space? >> str(",") >> match('[0-9]').repeat(1).as(:index)).repeat
-      }
-
-      rule(:identifier) {
-        match('[a-zA-Z0-9*_]').repeat(1)
-      }
-
-      rule(:node) {
-        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) {
-        node.repeat(1).as(:path)
-      }
-
-      # root
-      root(:path)
-    end.new
-  end
-
-  def transform(result_tree)
-    transformation.apply(result_tree)
-  end
-
-  def transformation
-    @transformation ||=
-    Class.new(Parslet::Transform) do
-      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 },
-          type: type
-        }
-      }
-
-      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 }
-      }
-    end.new
   end
 end

data/lib/hpath/parser/filter_expression_parser.rb

@@ -0,0 +1,104 @@
+class Hpath::Parser::FilterExpressionParser
+  require "hpath/filter"
+
+  def self.parse(string)
+    self.new.parse(string)
+  end
+
+  def flush_char_buffer(char_buffer, filter)
+    unless char_buffer.empty?
+      new_filter = Hpath::Filter.new(char_buffer)
+
+      if
+      new_filter.type == :index &&
+      !filter.operands.empty? &&
+      filter.operands.all? { |operand| operand.type == :index }
+        filter.operands.first.operands << new_filter.operands.first
+      else
+        filter.operands << new_filter
+      end
+
+      char_buffer.clear
+    end
+  end
+
+  def parse(string)
+    # reset parser
+    char_buffer = ""
+    current_filter = Hpath::Filter.new
+    parent = {} # look up table    
+    
+    string.gsub(/\s/, "").each_char do |char|
+      unless special_character?(char)
+        char_buffer << char
+      else
+        flush_char_buffer(char_buffer, current_filter)
+        
+        if char == "("
+          new_filter = Hpath::Filter.new
+          parent[new_filter] = current_filter
+          current_filter.operands << new_filter
+          current_filter = new_filter
+        elsif char == ")"
+          # replace operation by operand in parent if only one operand
+          if current_filter.operands.length == 1
+            parent[current_filter].operands.map! do |operand|
+              operand == current_filter ? current_filter.operands.first : operand
+            end
+          end
+
+          current_filter = parent[current_filter]
+        elsif char == "," || char == "|"
+          operator =
+          case char
+          when "," then :and
+          when "|" then :or
+          end
+
+          unless current_filter.operands.length == 2
+            current_filter.type = operator
+          else
+            if current_filter.type == :or && operator == :and
+              new_filter = Hpath::Filter.new.tap do |filter|
+                filter.operands << current_filter.operands.pop
+                filter.type = operator
+              end
+
+              parent[new_filter] = current_filter
+              current_filter.operands << new_filter
+            else
+              new_filter = Hpath::Filter.new.tap do |filter|
+                filter.operands << current_filter
+                filter.type = operator
+              end
+
+              parent[new_filter] = parent[current_filter]
+              parent[current_filter] = new_filter
+            end
+
+            current_filter = new_filter
+          end
+        end
+      end
+    end
+
+    flush_char_buffer(char_buffer, current_filter)
+
+    while parent[current_filter] != nil
+      current_filter = parent[current_filter]
+    end
+
+    if current_filter.operands.length == 1
+      current_filter.operands.first
+    else
+      current_filter
+    end
+  end
+
+  #
+  private
+  #
+  def special_character?(char)
+    char[/[(),\|]/] == nil ? false : true
+  end
+end

data/lib/hpath/version.rb

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

data/spec/hpath_spec.rb

@@ -1,4 +1,4 @@
-require "some_more_complex_hpath_tests"
+#require "some_more_complex_hpath_tests"
 
 describe Hpath do
   describe "#get" do
@@ -57,7 +57,8 @@ describe Hpath do
         hpath_result = Hpath.get([{a:"1", b:"2", c:"3"}, {a:"1", b:"5", c:"6"}, {a:"2", b:"1", c:"3"}], "/a")
         expect(hpath_result).to eq(["1", "1", "2"])
       end
-      
+
+=begin
       it "processes \"/key1/::parent\" for a hash" do
         hpath_result = Hpath.get({ foo: { bar: "foobar" } },  "/foo/::parent")
         expect(hpath_result).to eq({ foo: { bar: "foobar" } })
@@ -67,6 +68,7 @@ describe Hpath do
         hpath_result = Hpath.get([{ foo: { bar: "foobar" } }],  "/[0]/::parent")
         expect(hpath_result).to eq([{ foo: { bar: "foobar" } }])
       end
+=end
 
       it "processes \"/**[filter]\"" do
         hpath_result = Hpath.get({
@@ -119,7 +121,7 @@ describe Hpath do
         Hpath.set(hash = {}, "/foo/bar", { muff: "foobar"})
         expect(hash).to eq({foo: { bar: { muff: "foobar"} }})
       end
-
+=begin
       it "processes \"/[]/key2\" for a array" do
         Hpath.set(array = [], "/[]/bar", { foo: "bar"})
         expect(array).to eq([{ bar: {foo: "bar"} }])
@@ -134,6 +136,7 @@ describe Hpath do
         Hpath.set(hash = {}, "/key1", 1)
         expect(hash).to eq({key1: 1})
       end
+=end
     end
   end
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: hpath
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Michael Sievers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-12 00:00:00.000000000 Z
+date: 2014-07-08 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: parslet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.6.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.6.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -89,8 +75,8 @@ files:
 - lib/hpath.rb
 - lib/hpath/filter.rb
 - lib/hpath/parser.rb
+- lib/hpath/parser/filter_expression_parser.rb
 - lib/hpath/version.rb
-- spec/hpath/filter_spec.rb
 - spec/hpath/parser_spec.rb
 - spec/hpath_spec.rb
 - spec/some_more_complex_hpath_tests.rb
@@ -120,7 +106,6 @@ signing_key:
 specification_version: 4
 summary: HPath for ruby
 test_files:
-- spec/hpath/filter_spec.rb
 - spec/hpath/parser_spec.rb
 - spec/hpath_spec.rb
 - spec/some_more_complex_hpath_tests.rb

data/spec/hpath/filter_spec.rb

@@ -1,27 +0,0 @@
-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] }
-
-    describe ".filter" do
-      context "when given object is an array containing hashes" do
-        let(:filter) { Hpath::Filter.new(Hpath::Parser.new.parse("/array/*[a=b,c=d,(e=d|e=f)]")[:path][1][:filter]) }
-
-        it "returns only hashes which match the filter" do
-          #w = [{a: "b", c: "d", e: "f"}, {a: "b", c: "d", e: "z"}].select { |e| filter.applies?(e) }
-        end
-      end
-    end
-  end
-end