dense 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bebe1c11161f7007a745279fd573cb11591b9325
-  data.tar.gz: '082cb4ac9f1e6412ecf44445bd1e51206a094faf'
+  metadata.gz: 314a76ad0969382d65813cfa4ab3eb62db8a1ecf
+  data.tar.gz: ff138616d42d086fd7abbd1beee76c9f81c55172
 SHA512:
-  metadata.gz: 2e5bbd4c1f7e915b66228cb2e494d46fd43338b9d0f822e42051c36864a45d08a18e2637d6b320cf238512fedad0e10d0f289b99727d7c850c2d18e204f7b63f
-  data.tar.gz: f7250e6416b6f781d00c7c1f094adfea7dc4983aad5fc37984f64614748a0c1e36a5b8623d52eed5056e37fa71464a4d4cf550ad16ec0e26451365e4c9cbf6a2
+  metadata.gz: bcc1ff383a330a6da5068fd16774663e65577290bc7737a02d5102188f5c79d0fb2cbd24a627d607c7366ec13262d738b12121d61ac62042cbdf37883d7d0cf7
+  data.tar.gz: '098e9342bec870d2f21339c89e70d8825aaa24381234276d1e22f20391fd9488009589dcc1e1d01a1a75c57a0048dd8cb62b591ba2db55c5989519695dc86dff'

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 # dense
 
 
+## dense 1.1.0  released 2018-04-29
+
+* Add Dense.path(path) and Dense.gather(collection, path)
+* Use but enhance KeyError and TypeError
+* Differentiate between `*` and `.*`
+* Complete ework around Path#gather
+* Straighten Dense.fetch
+
+
 ## dense 1.0.0  released 2017-09-29
 
 * Accept `owner[age]` (unquoted key name in bracket index)

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2017-2017, John Mettraux, jmettraux+flor@gmail.com
+Copyright (c) 2017-2018, John Mettraux, jmettraux+flor@gmail.com
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -6,6 +6,319 @@
 
 Fetching deep in a dense structure. A kind of bastard of [JSONPath](http://goessner.net/articles/JsonPath/).
 
+## usage
+
+Let
+```ruby
+  data = # taken from http://goessner.net/articles/JsonPath/
+    { 'store' => {
+        'book' => [
+          { 'category' => 'reference',
+            'author' => 'Nigel Rees',
+            'title' => 'Sayings of the Century',
+            'price' => 8.95
+          },
+          { 'category' => 'fiction',
+            'author' => 'Evelyn Waugh',
+            'title' => 'Sword of Honour',
+            'price' => 12.99
+          },
+          { 'category' => 'fiction',
+            'author' => 'Herman Melville',
+            'title' => 'Moby Dick',
+            'isbn' => '0-553-21311-3',
+            'price' => 8.99
+          },
+          { 'category' => 'fiction',
+            'author' => 'J. R. R. Tolkien',
+            'title' => 'The Lord of the Rings',
+            'isbn' => '0-395-19395-8',
+            'price' => 22.99
+          }
+        ],
+        'bicycle' => {
+          'color' => 'red',
+          'price' => 19.95,
+          '7' => 'seven'
+        }
+      }
+    }
+```
+
+### paths
+
+```ruby
+"store.book.1.title"            # the title of the second book in the store
+"store.book[1].title"           # the title of the second book in the store
+"store.book.1['french title']"  # the french title of the 2nd book
+"store.book.1[title,author]"    # the title and the author of the 2nd book
+"store.book[1,3].title"         # the titles of the 2nd and 4th books
+"store.book[1:8:2].title"       # titles of books at offset 1, 3, 5, 7
+"store.book[::3].title"         # titles of books at offset 0, 3, 6, 9, ...
+"store.book[:3].title"          # titles of books at offset 0, 1, 2, 3
+"store.*.price"                 # the price of everything directly in the store
+"store..price"                  # the price of everything in the store
+# ...
+```
+
+### `Dense.get(collection, path)`
+
+```ruby
+Dense.get(data, 'store.book.1.title')
+  # => "Sword of Honour"
+
+Dense.get(data, 'store.book.*.title')
+  # => [
+  #  'Sayings of the Century',
+  #  'Sword of Honour',
+  #  'Moby Dick',
+  #  'The Lord of the Rings' ]
+
+Dense.get(data, 'store.bicycle.7')
+  # => "seven"
+```
+
+When `Dense.get(collection, path)` doesn't find, it returns `nil`.
+
+As seen above `Dense.get` might return a single value or an array of values. A "single" path like `"store.book.1.title"` will return a single value, while a "multiple" path like `"store.book.*.title"` or `"store.book[1,2].title"` will return an array of values.
+
+
+### `Dense.has_key?(collection, path)`
+
+```ruby
+Dense.has_key?(data, 'store.book.1.title')
+  # => true
+Dense.has_key?(data, 'store.book.1["social security number"]')
+  # => false
+```
+
+
+### `Dense.fetch(collection, path)`
+
+`Dense.fetch` is modelled after `Hash.fetch`.
+
+```ruby
+Dense.fetch(data, 'store.book.1.title')
+  # => 'Sword of Honour'
+
+Dense.fetch(data, 'store.book.*.title')
+  # => [ 'Sayings of the Century', 'Sword of Honour', 'Moby Dick',
+  #      'The Lord of the Rings' ]
+
+Dense.fetch(data, 'store.bicycle.7')
+  # => 'seven'
+
+Dense.fetch(data, 'store.bicycle[7]')
+  # => 'seven'
+```
+
+When it doesn't find, it raises an instance of `KeyError`:
+
+```ruby
+Dense.fetch({}, 'a.0.b')
+  # raises
+  #   KeyError: Found nothing at "a" ("0.b" remains)
+```
+
+It might instead raise an instance of `TypeError` if a non-integer key is requested of an array:
+
+```ruby
+Dense.fetch({ 'a' => [] }, 'a.k.b')
+  # raises
+  #   TypeError: No key "k" for Array at "a"
+```
+
+See KeyError and TypeError below for more details.
+
+`Dense.fetch(collection, path)` raises when it doesn't find, while `Dense.get(collection, path)` returns `nil`.
+
+
+### `Dense.fetch(collection, path, default)`
+
+`Dense.fetch` is modelled after `Hash.fetch` so it features a `default` optional argument.
+
+If `fetch` doesn't find, it will return the provided default value.
+
+```ruby
+Dense.fetch(data, 'store.book.1.title', -1)
+  # => "Sword of Honour" (found)
+Dense.fetch(data, 'a.0.b', -1)
+  # => -1
+Dense.fetch(data, 'store.nada', 'x')
+  # => "x"
+Dense.fetch(data, 'store.bicycle.seven', false)
+  # => false
+```
+
+
+### `Dense.fetch(collection, path) { block }`
+
+`Dense.fetch` is modelled after `Hash.fetch` so it features a 'default' optional block.
+
+```ruby
+Dense.fetch(data, 'store.book.1.title') do |coll, path|
+  "len:#{coll.length},path:#{path}"
+end
+  # => "Sword of Honour" (found)
+
+Dense.fetch(@data, 'store.bicycle.otto') do |coll, path|
+  "len:#{coll.length},path:#{path}"
+end
+  # => "len:18,path:store.bicycle.otto" (not found)
+
+not_found = lambda { |coll, path| "not found!" }
+  #
+Dense.fetch(@data, 'store.bicycle.otto', not_found)
+  # => "not found!"
+Dense.fetch(@data, 'store.bicycle.sept', not_found)
+  # => "not found!"
+```
+
+
+### `Dense.set(collection, path, value)`
+
+Sets a value "deep" in a collection. Returns the value if successful.
+
+```ruby
+c = {}
+r = Dense.set(c, 'a', 1)
+c   # => { 'a' => 1 }
+r   # => 1
+
+c = { 'h' => {} }
+r = Dense.set(c, 'h.i', 1)
+c   # => { 'h' => { 'i' => 1 } }
+r   # => 1
+
+c = { 'a' => [ 1, 2, 3 ] }
+r = Dense.set(c, 'a.1', 1)
+c   # => { 'a' => [ 1, 1, 3 ] }
+r   # => 1
+
+c = { 'h' => { 'a' => [ 1, 2, 3 ] } }
+r = Dense.set(c, 'h.a.first', 'one')
+c   # => { 'h' => { 'a' => [ "one", 2, 3 ] } }
+r   # => 'one'
+
+c = { 'h' => { 'a' => [ 1, 2, 3 ] } }
+r = Dense.set(c, 'h.a.last', 'three')
+c   # => { 'h' => { 'a' => [ 1, 2, 'three' ] } }
+r   # => 'three'
+
+c = { 'a' => [] }
+Dense.set(c, 'a.b', 1)
+  # => TypeError: No key "b" for Array at "a"
+
+
+c = { 'a' => {} }
+r = Dense.set(c, 'a.1', 1)
+c   # => { 'a' => { '1' => 1 } }
+r   # => 1
+
+c = {}
+Dense.set(c, 'a.0', 1)
+  # => KeyError: Found nothing at "a" ("0" remains)
+```
+
+Setting at multiple places in one go is possible:
+```ruby
+c = { 'h' => {} }
+Dense.set(c, 'h[k0,k1,k2]', 123)
+c
+  # => { 'h' => { 'k0' => 123, 'k1' => 123, 'k2' => 123 } }
+```
+
+
+### `Dense.insert(collection, path, value)`
+
+```ruby
+c = { 'a' => [ 0, 1, 2, 3 ] }
+r = Dense.insert(c, 'b', 1234)
+c
+  # => { "a" => [ 0, 1, 2, 3 ], "b" => 1234 }
+
+c = { 'a' => [ 0, 1, 2, 3 ] }
+r = Dense.insert(c, 'a.1', 'ONE')
+c
+  # => { "a" => [ 0, "ONE", 1, 2, 3 ] }
+
+c = { 'a' => [ 0, 1, 2, 3 ], 'a1' => [ 0, 1 ] }
+r = Dense.insert(c, '.1', 'ONE')
+c
+  # => { "a" => [ 0, "ONE", 1, 2, 3 ], "a1" => [ 0, "ONE", 1 ] }
+```
+
+
+### `Dense.unset(collection, path)`
+
+Removes an element deep in a collection.
+```ruby
+c = { 'a' => 1 }
+r = Dense.unset(c, 'a')
+c   # => {}
+r   # => 1
+
+c = { 'h' => { 'i' => 1 } }
+r = Dense.unset(c, 'h.i')
+c   # => { 'h' => {} }
+r   # => 1
+
+c = { 'a' => [ 1, 2, 3 ] }
+r = Dense.unset(c, 'a.1')
+c   # => { 'a' => [ 1, 3 ] }
+r   # => 2
+
+c = { 'h' => { 'a' => [ 1, 2, 3 ] } }
+r = Dense.unset(c, 'h.a.first')
+c   # => { 'h' => { 'a' => [ 2, 3 ] } }
+r   # => 1
+
+c = { 'h' => { 'a' => [ 1, 2, 3 ] } }
+r = Dense.unset(c, 'h.a.last')
+c   # => { 'h' => { 'a' => [ 1, 2 ] } }
+r   # => 3
+```
+
+It fails with a `KeyError` or a `TypeError` if it cannot unset.
+```ruby
+Dense.unset({}, 'a')
+  # => KeyError: Found nothing at "a"
+Dense.unset([], 'a')
+  # => TypeError: No key "a" for Array at root
+Dense.unset([], '1')
+  # => KeyError: Found nothing at "1"
+```
+
+Unsetting multiple values is OK:
+
+```ruby
+c = { 'h' => { 'a' => [ 1, 2, 3, 4, 5 ] } }
+r = Dense.unset(c, 'h.a[2,3]')
+c
+  # => { 'h' => { 'a' => [ 1, 2, 5 ] } }
+```
+
+### KeyError and TypeError
+
+Dense might raise instances of `KeyError` and `TypeError`. Those instances have extra `#full_path` and `#miss` methods.
+
+```ruby
+e =
+  begin
+    Dense.fetch({}, 'a.b')
+  rescue => err
+    err
+  end
+  # => #<KeyError: Found nothing at "a" ("b" remains)>
+e.full_path
+  # => "a"
+e.miss
+  # => [false, [], {}, "a", [ "b" ]]
+```
+
+The "miss" is an array `[ false, path-to-miss, collection-at-miss, key-at-miss, path-post-miss ]`.
+
+
 ## LICENSE
 
 MIT, see [LICENSE.txt](LICENSE.txt)

data/lib/dense.rb

@@ -1,11 +1,12 @@
 
 module Dense
 
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end
 
 require 'raabro'
 
 require 'dense/path'
+require 'dense/parser'
 require 'dense/methods'
 

data/lib/dense/methods.rb

@@ -3,141 +3,172 @@ module Dense; class << self
 
   def get(o, path)
 
-    Dense::Path.new(path).walk(o) { nil }
+    pa = Dense::Path.new(path)
+    r = pa.gather(o).inject([]) { |a, e| a << e[2][e[3]] if e.first; a }
+
+    pa.narrow(r)
   end
 
-  def fetch(o, path, default=IndexError, &block)
+  def fetch(o, path, default=::KeyError, &block)
 
-    Dense::Path.new(path).walk(o, default, &block)
-  end
+    pa = Dense::Path.new(path)
+    r = pa.gather(o).partition(&:first)
 
-  def set(o, path, value)
+    if r[0].empty?
+
+      return pa.narrow(
+        r[1].collect { |m| call_default_block(o, path, block, m) }
+      ) if block
 
-    path = Dense::Path.new(path)
-    key = path.pop
+      return pa.narrow(
+        r[1].collect { |m| default }
+      ) if default != KeyError
 
-    case c = path.walk(o)
-    when Array then array_set(c, key, value)
-    when Hash then c[key.to_s] = value
-    else fail KeyError.new("Found no collection at #{path.to_s.inspect}")
+      fail miss_error(path, r[1].first)
     end
 
+    pa.narrow(r[0].collect { |e| e[2][e[3]] })
+  end
+
+  def set(o, path, value)
+
+    Dense::Path.new(path)
+      .gather(o)
+      .each { |hit|
+        fail_miss_error(path, hit) if hit[0] == false
+        hit[2][hit[3]] = value }
+
     value
   end
 
-  def unset(o, path)
+  def unset(o, path, nofail=false)
 
-    path = Dense::Path.new(path)
-    key = path.pop
+    pa = Dense::Path.new(path)
+    hits = pa.gather(o)
 
-    case c = path.walk(o)
-    when Array then array_unset(c, key)
-    when Hash then hash_unset(c, key.to_s)
-    else fail KeyError.new("Found no collection at #{path.to_s.inspect}")
-    end
+    hits.each { |h| fail miss_error(path, h) unless h[0] } unless nofail
+
+    r = hits
+      .sort_by { |e| "#{e[2].hash}|#{e[3]}" }
+      .reverse
+      .inject([]) { |a, e|
+        next a.push(nil) unless e[0]
+        k = e[3]
+        a.push(e[2].is_a?(Array) ? e[2].delete_at(k) : e[2].delete(k)) }
+      .reverse
+
+    pa.narrow(r)
   end
 
   def insert(o, path, value)
 
-    path = Dense::Path.new(path)
-    key = path.pop
-
-    case c = path.walk(o)
-    when Array then array_insert(c, key, value)
-    when Hash then c[key.to_s] = value
-    else fail KeyError.new("Found no collection at #{path.to_s.inspect}")
-    end
+    Dense::Path.new(path)
+      .gather(o)
+      .each { |hit|
+        fail_miss_error(path, hit) if hit[0] == false
+        if hit[2].is_a?(Array)
+          hit[2].insert(hit[3], value)
+        else
+          hit[2][hit[3]] = value
+        end }
 
     value
   end
 
   def has_key?(o, path)
 
-    path = Dense::Path.new(path)
-    key = path.pop
-
-    case c = path.walk(o)
-    when Array then array_has_key?(c, key)
-    when Hash then hash_has_key?(c, key)
-    else fail IndexError.new("Found no collection at #{path.to_s.inspect}")
-    end
+    !! Dense::Path.new(path).gather(o).find { |m| m[0] }
   end
 
-  protected
-
-  def array_i(k, may_fail=true)
+  def path(path)
 
-    case k
-    when 'first' then 0
-    when 'last' then -1
-    when Integer then k
-    else
-      may_fail ?
-        fail(IndexError.new("Cannot index array at #{k.inspect}")) :
-        nil
-    end
+    Dense::Path.new(path)
   end
 
-  def array_index(a, k)
+  def gather(o, path)
 
-    i = array_i(k)
-    i = a.length + i if i < 0
+    Dense::Path.new(path).gather(o)
+  end
+
+  protected
 
-    fail IndexError.new(
-      "Array has length of #{a.length}, index is at #{k.inspect}"
-    ) if i < 0 || i >= a.length
+  module DenseError
 
-    i
-  end
+    attr_accessor :full_path, :miss
 
-  def array_set(a, k, v)
+    # Used by some "clients" (like flor) to relabel (change the error message)
+    # a reraise.
+    #
+    def relabel(message)
 
-    i = array_index(a, k)
+      err = self.class.new(message)
+      class << err; include DenseError; end
+      err.set_backtrace(self.backtrace)
+      err.full_path = self.full_path
+      err.miss = self.miss
 
-    a[i] = v
+      err
+    end
   end
 
-  def array_unset(a, k)
+  def make_error(error_class, message, path, miss)
 
-    i = array_index(a, k)
+    err = error_class.new(message)
+    class << err; include DenseError; end
+    err.full_path = path
+    err.miss = miss
 
-    a.delete_at(i)
+    err
   end
 
-  def hash_unset(h, k)
+  def key_error(path, miss)
+
+    path1 = Dense::Path.make(miss[1] + [ miss[3] ]).to_s.inspect
+    path2 = Dense::Path.make(miss[4]).to_s.inspect
 
-    fail KeyError.new("No key #{k.inspect} for hash") unless h.has_key?(k)
+    msg = "Found nothing at #{path1}"
+    msg = "#{msg} (#{path2} remains)" if path2 != '""'
 
-    h.delete(k)
+    make_error(KeyError, msg, path, miss)
   end
 
-  def array_insert(a, k, v)
+  def type_error(path, miss)
 
-    i = array_i(k)
+    key = miss[3].inspect
+    cla = miss[2].class
+    pat = miss[1].empty? ? 'root' : Dense::Path.make(miss[1]).to_s.inspect
 
-    a.insert(i, v)
+    make_error(TypeError, "No key #{key} for #{cla} at #{pat}", path, miss)
   end
 
-  def array_has_key?(a, k)
+  def miss_error(path, miss)
 
-    i =
-      array_i(k, false)
-    i =
-      if i.nil?
-        -1
-      elsif i < 0
-        a.length + i
-      else
-        i
-      end
+    if miss[2].is_a?(Array) && ! miss[3].is_a?(Integer)
+      type_error(path, miss)
+    else
+      key_error(path, miss)
+    end
+  end
+
+  def fail_miss_error(path, miss)
 
-    i > -1 && i < a.length
+    fail miss_error(path, miss) \
+      if miss[4].any?
+    fail type_error(path, miss) \
+      if miss[2].is_a?(Array) && ! miss[2].is_a?(Integer)
   end
 
-  def hash_has_key?(h, k)
+  def call_default_block(o, path, block, miss)
+
+      # [ collection, path,
+      #   path before miss, collection at miss, key at miss, path after miss ]
+      #
+    args = [
+      o, path,
+      Dense::Path.make(miss[1]), miss[2], miss[3], Dense::Path.make(miss[4])
+    ][0, block.arity]
 
-    return true if k.is_a?(Integer) && h.has_key?(k.to_s)
-    h.has_key?(k)
+    block.call(*args)
   end
-end; end
+end; end # Dense
 

data/lib/dense/parser.rb

@@ -0,0 +1,102 @@
+
+module Dense::Path::Parser include ::Raabro
+
+  # piece parsers bottom to top
+
+  def dqname(i)
+
+    rex(:qname, i, %r{
+      "(
+        \\["\\\/bfnrt] |
+        \\u[0-9a-fA-F]{4} |
+        [^"\\\b\f\n\r\t]
+      )*"
+    }x)
+  end
+
+  def sqname(i)
+
+    rex(:qname, i, %r{
+      '(
+        \\['\\\/bfnrt] |
+        \\u[0-9a-fA-F]{4} |
+        [^'\\\b\f\n\r\t]
+      )*'
+    }x)
+  end
+
+  def dot(i); str(nil, i, '.'); end
+  def comma(i); rex(nil, i, / *, */); end
+  def bend(i); str(nil, i, ']'); end
+  def bstart(i); str(nil, i, '['); end
+  def blank(i); str(:blank, i, ''); end
+
+  def name(i); rex(:name, i, /[-+%^<>a-zA-Z0-9_\/\\=?]+/); end
+  def off(i); rex(:off, i, /-?\d+/); end
+
+  def star(i); str(:star, i, '*'); end
+
+  def ses(i) # start:end:step
+    rex(
+      :ses,
+      i,
+      /(
+        (-?\d+)?:(-?\d+)?:(-?\d+)? |
+        (-?\d+)?:(-?\d+)? |
+        -?\d+
+      )/x)
+  end
+
+  def escape(i); rex(:esc, i, /\\[.*]/); end
+
+  def bindex(i); alt(:index, i, :dqname, :sqname, :star, :ses, :name, :blank); end
+  def bindexes(i); jseq(:bindexes, i, :bindex, :comma); end
+  def simple_index(i); alt(:index, i, :off, :escape, :star, :name); end
+
+  def dotdot(i); str(:dotdot, i, '.'); end
+  def dotdotstar(i); rex(:dotdotstar, i, /(\.\.\*|\.\[\*\])/); end
+  def bracket_index(i); seq(nil, i, :bstart, :bindexes, :bend); end
+  def dot_then_index(i); seq(nil, i, :dot, :simple_index); end
+
+  def index(i)
+    alt(nil, i, :dot_then_index, :bracket_index, :dotdotstar, :dotdot)
+  end
+
+  def path(i); rep(:path, i, :index, 1); end # it starts here
+
+  # rewrite parsed tree
+
+  def rewrite_ses(t)
+    a = t.string.split(':').collect { |e| e.empty? ? nil : e.to_i }
+    return a[0] if a[1] == nil && a[2] == nil
+    { start: a[0], end: a[1], step: a[2] }
+  end
+  def rewrite_esc(t); t.string[1, 1]; end
+  def rewrite_star(t); :star; end
+  def rewrite_dotdot(t); :dot; end
+  def rewrite_dotdotstar(t); :dotstar; end
+  def rewrite_off(t); t.string.to_i; end
+  def rewrite_index(t); rewrite(t.sublookup); end
+  def rewrite_bindexes(t);
+    indexes = t.subgather.collect { |tt| rewrite(tt) }
+    indexes.length == 1 ? indexes[0] : indexes.compact
+  end
+
+  def rewrite_blank(t); nil; end
+
+  def rewrite_qname(t); t.string[1..-2]; end
+  def rewrite_name(t); t.string; end
+
+  def rewrite_path(t)
+
+    t.subgather
+      .collect { |tt|
+        rewrite(tt) }
+      .inject([]) { |a, e| # remove double :dot
+        next (a << e) unless a.last == :dot
+        a.pop if e == :dotstar
+        a << e unless e == :dot
+        a }
+  end
+end # Dense::Path::Parser
+

data/lib/dense/path.rb

@@ -11,9 +11,10 @@ class Dense::Path
       "Argument is a #{s.class}, not a String"
     ) unless s.is_a?(String)
 
-    s = ".#{s}" unless s[0, 1] == '[' || s[0, 2] == '.['
+    s = ".#{s}" \
+      unless s[0, 1] == '[' || s[0, 2] == '.['
 
-#Raabro.pp(Parser.parse(s, debug: 3))
+#Raabro.pp(Parser.parse(s, debug: 3), colors: true)
     @path = Parser.parse(s)
 
 #Raabro.pp(Parser.parse(s, debug: 3), colors: true) unless @path
@@ -34,94 +35,14 @@ class Dense::Path
     path
   end
 
-  module Parser include Raabro
+  def single?
 
-    # piece parsers bottom to top
-
-    def dqname(i)
-
-      rex(:qname, i, %r{
-        "(
-          \\["\\\/bfnrt] |
-          \\u[0-9a-fA-F]{4} |
-          [^"\\\b\f\n\r\t]
-        )*"
-      }x)
-    end
-
-    def sqname(i)
-
-      rex(:qname, i, %r{
-        '(
-          \\['\\\/bfnrt] |
-          \\u[0-9a-fA-F]{4} |
-          [^'\\\b\f\n\r\t]
-        )*'
-      }x)
-    end
-
-    def dot(i); str(nil, i, '.'); end
-    def comma(i); rex(nil, i, / *, */); end
-    def bend(i); str(nil, i, ']'); end
-    def bstart(i); str(nil, i, '['); end
-    def blank(i); str(:blank, i, ''); end
-
-    def name(i); rex(:name, i, /[-+%^<>a-zA-Z0-9_\/\\=?]+/); end
-    def off(i); rex(:off, i, /-?\d+/); end
-
-    def star(i); str(:star, i, '*'); end
-
-    def ses(i) # start:end:step
-      rex(
-        :ses,
-        i,
-        /(
-          (-?\d+)?:(-?\d+)?:(-?\d+)? |
-          (-?\d+)?:(-?\d+)? |
-          -?\d+
-        )/x)
-    end
-
-    def escape(i); rex(:esc, i, /\\[.*]/); end
-
-    def bindex(i); alt(:index, i, :dqname, :sqname, :star, :ses, :name, :blank); end
-    def bindexes(i); jseq(:bindexes, i, :bindex, :comma); end
-    def bracket_index(i); seq(nil, i, :bstart, :bindexes, :bend); end
-    def simple_index(i); alt(:index, i, :off, :escape, :star, :name); end
-
-    def dotdot(i); str(:dotdot, i, '.'); end
-
-    def dot_then_index(i); seq(nil, i, :dot, :simple_index); end
-    def index(i); alt(nil, i, :dot_then_index, :bracket_index, :dotdot); end
-
-    def path(i); rep(:path, i, :index, 1); end
-
-    # rewrite parsed tree
-
-    def rewrite_ses(t)
-      a = t.string.split(':').collect { |e| e.empty? ? nil : e.to_i }
-      return a[0] if a[1] == nil && a[2] == nil
-      { start: a[0], end: a[1], step: a[2] }
-    end
-    def rewrite_esc(t); t.string[1, 1]; end
-    def rewrite_star(t); :star; end
-    def rewrite_dotdot(t); :dot; end
-    def rewrite_off(t); t.string.to_i; end
-    def rewrite_index(t); rewrite(t.sublookup); end
-    def rewrite_bindexes(t);
-      indexes = t.subgather.collect { |tt| rewrite(tt) }
-      indexes.length == 1 ? indexes[0] : indexes.compact
-    end
-
-    def rewrite_blank(t); nil; end
-
-    def rewrite_qname(t); t.string[1..-2]; end
-    def rewrite_name(t); t.string; end
+    ! @path.find { |e| e.is_a?(Symbol) || e.is_a?(Hash) || e.is_a?(Array) }
+  end
 
-    def rewrite_path(t)
-      t.subgather.collect { |tt| rewrite(tt) }
-    end
+  def multiple?
 
+    ! single?
   end
 
   def to_a
@@ -132,6 +53,15 @@ class Dense::Path
   def length; @path.length; end
   alias size length
 
+  def any?; @path.any?; end
+  def empty?; @path.empty?; end
+
+  def first; @path.first; end
+  def last; @path.last; end
+
+  def pop; @path.pop; end
+  def shift; @path.shift; end
+
   def to_s
 
     o = StringIO.new
@@ -146,20 +76,6 @@ class Dense::Path
     s[0, 2] == '..' ? s[1..-1] : s
   end
 
-  def walk(data, default=nil, &block)
-
-    _walk(data, @path)
-
-  rescue IndexError => ie
-
-    return yield(@original, self) if block
-    return default if default != nil && default != IndexError
-
-    fail ie.expand(self) if ie.respond_to?(:expand)
-
-    raise
-  end
-
   def [](offset, count=nil)
 
     if count == nil && offset.is_a?(Integer)
@@ -177,70 +93,150 @@ class Dense::Path
     other.to_a == @path
   end
 
-  def last
+  def -(path)
 
-    @path.last
+    self.class.make(subtract(@path.dup, path.to_a.dup))
   end
 
-  def pop
+  def narrow(outcome)
 
-    @path.pop
+    single? ? outcome.first : outcome
   end
 
-  def -(path)
+  def gather(data)
 
-    self.class.make(subtract(@path.dup, path.to_a.dup))
+    _gather(0, [], nil, data, @path, [])
+      .inject({}) { |h, hit| h[(hit[1] + [ hit[3] ]).inspect] ||= hit; h }
+      .values
   end
 
   protected
 
-  class NotIndexableError < ::IndexError
+  def _keys(o)
 
-    attr_reader :container_class, :root_path, :remaining_path
+    return (0..o.length - 1).to_a if o.is_a?(Array)
+    return o.keys if o.is_a?(Hash)
+    nil
+  end
 
-    def initialize(container, root_path, remaining_path, message=nil)
+  def _resolve_hash_key(o, k)
 
-      @container_class = container.is_a?(Class) ? container : container.class
+    return [ nil ] unless o.is_a?(Array)
 
-      @root_path = Dense::Path.make(root_path)
-      @remaining_path = Dense::Path.make(remaining_path)
+    be = k[:start] || 0
+    en = k[:end] || o.length - 1
+    st = k[:step] || 1
 
-      if message
-        super(
-          message)
-      elsif @root_path
-        super(
-          "Found nothing at #{fail_path.to_s.inspect} " +
-          "(#{@remaining_path.original.inspect} remains)")
-      else
-        super(
-          "Cannot index instance of #{container_class} " +
-          "with #{@remaining_path.original.inspect}")
-      end
-    end
+    Range.new(be, en).step(st).to_a
+  end
+
+  def _resolve_key(o, k)
 
-    def expand(root_path)
+    return _resolve_hash_key(o, k) if k.is_a?(Hash)
 
-      err = self.class.new(container_class, root_path, remaining_path, nil)
-      err.set_backtrace(self.backtrace)
+    return [ k.to_s ] if o.is_a?(Hash)
 
-      err
+    case k
+    when /\Afirst\z/i then [ 0 ]
+    when /\Alast\z/i then [ -1 ]
+    else [ k ]
     end
+  end
+
+  def _resolve_keys(o, k)
 
-    def relabel(message)
+    ks = k.is_a?(Hash) ? [ k ] : Array(k)
+    ks = ks.inject([]) { |a, kk| a.concat(_resolve_key(o, kk)) }
+  end
 
-      err = self.class.new(container_class, root_path, remaining_path, message)
-      err.set_backtrace(self.backtrace)
+  def _stars(data0, data, key, path=[], acc=[])
 
-      err
+#p [ :_stars, key, path, data0, data ]
+    acc.push([ path, data0, data ]) if path.any?
+
+    return acc unless data.is_a?(Hash) || data.is_a?(Array)
+
+    return acc unless key
+    key = key == :dotstar ? key : nil
+
+    if data.is_a?(Array)
+      data.each_with_index { |e, i| _stars(data, e, key, path + [ i ], acc) }
+    else
+      data.each { |k, v| _stars(data, v, key, path + [ k ], acc) }
     end
 
-    def fail_path
+    acc
+  end
+
+  def _dot_gather(depth, path0, data0, data, path, acc)
 
-      @fail_path ||= (@root_path ? @root_path - @remaining_path : nil)
+#ind = '  ' * depth
+#puts ind + "+--- _dot_gather()"
+#puts ind + "| path0: #{path0.inspect}"
+#puts ind + "| data: #{data.inspect}"
+#puts ind + "| depth: #{depth} / path: #{path.inspect}"
+
+    a = _gather(depth, path0, data0, data, path, []).select { |r| r.first }
+    return acc.concat(a) if a.any?
+
+    keys = _keys(data)
+
+    return acc unless keys
+
+    keys.each { |k|
+      _dot_gather(depth + 1, path0 + [ k ], data, data[k], path, acc) }
+
+    acc
+  end
+
+  def _index(o, k)
+
+    case o
+    when Array then k.is_a?(Integer) ? o[k] : nil
+    when Hash then o[k]
+    else nil
     end
   end
 
+  def _gather(depth, path0, data0, data, path, acc)
+
+    k = path.first
+#ind = '  ' * depth
+#print [ LG, DG, LB ][depth % 3]
+#puts ind + "+--- _gather()"
+#puts ind + "| path0: #{path0.inspect}"
+#puts ind + "| data: #{data.inspect}"
+#puts ind + "| depth: #{depth} / path: #{path.inspect}"
+#puts ind + "| k: " + k.inspect
+
+#puts RD + ind + "| -> " + [ false, path0[0..-2], data0, path0.last, path ].inspect if k.nil? && data.nil?
+    return acc.push([ false, path0[0..-2], data0, path0.last, path ]) \
+      if data.nil?
+
+#puts GN + ind + "| -> " + [ true, path0[0..-2], data0, path0.last ].inspect if k.nil? && data.nil?
+    return acc.push([ true, path0[0..-2], data0, path0.last ]) \
+      if k.nil?
+
+#puts RD + ind + "| -> " + [ false, path0[0..-2], data0, path0.last, path ].inspect unless data.is_a?(Array) || data.is_a?(Hash)
+    return acc.push([ false, path0[0..-2], data0, path0.last, path ]) \
+      unless data.is_a?(Array) || data.is_a?(Hash)
+
+    return _dot_gather(depth, path0, data0, data, path[1..-1], acc) \
+      if k == :dot
+
+#puts ind + "| stars:\n" + _stars(data0, data, k).collect(&:first).to_pp if k == :star || k == :dotstar
+    return _stars(data0, data, k).inject(acc) { |a, (pa, da0, da)|
+      _gather(depth + 1, path0 + pa, da0, da, path[1..-1], a)
+    } if k == :star || k == :dotstar
+
+    keys = _resolve_keys(data, k)
+#puts ind + "| keys: " + keys.inspect
+
+    keys.inject(acc) { |a, kk|
+      _gather(
+        depth + 1, path0 + [ kk ], data, _index(data, kk), path[1..-1], a) }
+  end
+
   def subtract(apath0, apath1)
 
     while apath0.any? && apath1.any? && apath0.last == apath1.last
@@ -260,13 +256,13 @@ class Dense::Path
     when Array
       "[#{elt.map { |e| _to_s(e, true) }.join(',')}#{elt.size < 2 ? ',' : ''}]"
     when String
-      #in_array ? elt.inspect : elt.to_s
-      #in_array ? _quote_s(elt) : _maybe_quote_s(elt)
       _str_to_s(elt, in_array)
     when :star
       '*'
     when :dot
       '.'
+    when :dotstar
+      '..*'
     else
       elt.to_s
     end
@@ -282,103 +278,5 @@ class Dense::Path
     return "[#{elt.inspect}]" if s =~ /["']/
     s
   end
-
-  def _walk(data, path)
-
-    return data if path.empty?
-
-    case pa = path.first
-    when :dot then _walk_dot(data, pa, path)
-    when :star then _walk_star(data, pa, path)
-    when Hash then _walk_start_end_step(data, pa, path)
-    when Integer then _walk_int(data, pa, path)
-    when String then _walk(_sindex(data, pa), path[1..-1])
-    else fail IndexError.new("Unwalkable index in path: #{pa.inspect}")
-    end
-  end
-
-  def _walk_star(data, pa, path)
-
-    case data
-    when Array then data.collect { |d| _walk(d, path[1..-1]) }
-    when Hash then data.values.collect { |d| _walk(d, path[1..-1]) }
-    else data
-    end
-  end
-
-  def _walk_dot(data, pa, path)
-
-    _run(data, path[1])
-      .inject([]) { |a, d|
-        a.concat(
-          begin
-            [ _walk(d, path[2..-1]) ]
-          rescue NotIndexableError
-            []
-          end) }
-  end
-
-  def _walk_start_end_step(data, pa, path)
-
-    be = pa[:start] || 0
-    en = pa[:end] || data.length - 1
-    st = pa[:step] || 1
-    Range.new(be, en).step(st).collect { |i| _walk(data[i], path[1..-1]) }
-  end
-
-  def _walk_int(data, pa, path)
-
-    if data.is_a?(Array)
-      return _walk(data[pa], path[1..-1])
-    end
-
-    if data.is_a?(Hash)
-      return _walk(data[pa], path[1..-1]) if data.has_key?(pa)
-      pa = pa.to_s
-      return _walk(data[pa], path[1..-1]) if data.has_key?(pa)
-    end
-
-    fail NotIndexableError.new(data, nil, path)
-  end
-
-  def _sindex(data, key)
-
-    case data
-    when Hash
-      data[key]
-    when Array
-      case key
-        when /\Afirst\z/i then data[0]
-        when /\Alast\z/i then data[-1]
-        else fail IndexError.new("Cannot index array with #{key.inspect}")
-      end
-    else
-      fail IndexError.new("Cannot index #{data.class} with #{key.inspect}")
-    end
-  end
-
-  def _run(d, key)
-
-    case d
-    when Hash then _run_hash(d, key)
-    when Array then _run_array(d, key)
-    else key == :star ? [ d ] : []
-    end
-  end
-
-  def _run_hash(d, key)
-
-    if key == :star
-      [ d ] + d.values.inject([]) { |a, v| a.concat(_run(v, key)) }
-    else
-      d.inject([]) { |a, (k, v)| a.concat(k == key ? [ v ] : _run(v, key)) }
-    end
-  end
-
-  def _run_array(d, key)
-
-    (key == :star ? [ d ] : []) +
-    d.inject([]) { |r, e| r.concat(_run(e, key)) }
-  end
-end
+end # Dense::Path
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dense
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-29 00:00:00.000000000 Z
+date: 2018-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: raabro
@@ -52,6 +52,7 @@ files:
 - dense.gemspec
 - lib/dense.rb
 - lib/dense/methods.rb
+- lib/dense/parser.rb
 - lib/dense/path.rb
 homepage: http://github.com/floraison/dense
 licenses: