dense 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f1a1474f7754c17da61c379303adc4c454412cf
-  data.tar.gz: 14721003a79f251faf0ae7fe3ab48a50cbf12133
+  metadata.gz: bebe1c11161f7007a745279fd573cb11591b9325
+  data.tar.gz: '082cb4ac9f1e6412ecf44445bd1e51206a094faf'
 SHA512:
-  metadata.gz: b526940155800dca33200004b9e21b68a0c9edd4292507f3c9156f34326f8663fdb4edf6a0d46d3214c5caa2f42ec49850c4ca9949391933c44d7cd9f165a605
-  data.tar.gz: 51f6622e8a5bb399946c78fe4028d2d045a9786f65192dddfd7da6d33844c805dc4b582fe7b4cabdb3b7e70d7cd4ffd0bae44004ed7b097123941723f40e7d64
+  metadata.gz: 2e5bbd4c1f7e915b66228cb2e494d46fd43338b9d0f822e42051c36864a45d08a18e2637d6b320cf238512fedad0e10d0f289b99727d7c850c2d18e204f7b63f
+  data.tar.gz: f7250e6416b6f781d00c7c1f094adfea7dc4983aad5fc37984f64614748a0c1e36a5b8623d52eed5056e37fa71464a4d4cf550ad16ec0e26451365e4c9cbf6a2

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+
+# dense
+
+
+## dense 1.0.0  released 2017-09-29
+
+* Accept `owner[age]` (unquoted key name in bracket index)
+* Accept '=' and '?' in key names
+* Introduce Dense::Path#last
+* Introduce Dense::Path indexation and equality
+* Introduce Dense::Path #length and #size
+* Introduce Dense::Path::NotIndexableError#relabel
+* Introduce Dense::Path::NotIndexableError
+* Differentiate `Dense.get(col, path)` from `Dense.fetch(col, path[, default])`
+* Provide Dense::Path.to_s
+* Introduce Dense.has_key?(collection, path)
+* Introduce Dense.insert(collection, path, value)
+* Accept `.first` and `.last` when indexing arrays
+* Introduce Dense.unset(collection, path)
+* Introduce Dense.set(collection, path, value)
+* Introduce Dense.get(collection, path)
+
+
+## dense 0.1.0  released 2017-08-06
+
+* initial release
+

data/LICENSE.txt

@@ -19,3 +19,6 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
+
+Made in Japan
+

data/README.md

@@ -1,7 +1,10 @@
 
 # dense
 
-Fetching deep in a dense structure. A kind of bastard of JSONPath.
+[![Build Status](https://secure.travis-ci.org/floraison/dense.svg)](http://travis-ci.org/floraison/dense)
+[![Gem Version](https://badge.fury.io/rb/dense.svg)](http://badge.fury.io/rb/dense)
+
+Fetching deep in a dense structure. A kind of bastard of [JSONPath](http://goessner.net/articles/JsonPath/).
 
 ## LICENSE
 

data/dense.gemspec

@@ -27,7 +27,7 @@ Fetching deep in a dense structure. A kind of bastard of JSONPath.
     "#{s.name}.gemspec",
   ]
 
-  s.add_runtime_dependency 'raabro', '~> 1.1'
+  s.add_runtime_dependency 'raabro', '>= 1.1.5'
 
   s.add_development_dependency 'rspec', '~> 3.4'
 

data/lib/dense.rb

@@ -1,6 +1,11 @@
 
 module Dense
 
-  VERSION = '0.0.1'
+  VERSION = '1.0.0'
 end
 
+require 'raabro'
+
+require 'dense/path'
+require 'dense/methods'
+

data/lib/dense/methods.rb

@@ -0,0 +1,143 @@
+
+module Dense; class << self
+
+  def get(o, path)
+
+    Dense::Path.new(path).walk(o) { nil }
+  end
+
+  def fetch(o, path, default=IndexError, &block)
+
+    Dense::Path.new(path).walk(o, default, &block)
+  end
+
+  def set(o, path, value)
+
+    path = Dense::Path.new(path)
+    key = path.pop
+
+    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}")
+    end
+
+    value
+  end
+
+  def unset(o, path)
+
+    path = Dense::Path.new(path)
+    key = path.pop
+
+    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
+  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
+
+    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
+  end
+
+  protected
+
+  def array_i(k, may_fail=true)
+
+    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
+  end
+
+  def array_index(a, k)
+
+    i = array_i(k)
+    i = a.length + i if i < 0
+
+    fail IndexError.new(
+      "Array has length of #{a.length}, index is at #{k.inspect}"
+    ) if i < 0 || i >= a.length
+
+    i
+  end
+
+  def array_set(a, k, v)
+
+    i = array_index(a, k)
+
+    a[i] = v
+  end
+
+  def array_unset(a, k)
+
+    i = array_index(a, k)
+
+    a.delete_at(i)
+  end
+
+  def hash_unset(h, k)
+
+    fail KeyError.new("No key #{k.inspect} for hash") unless h.has_key?(k)
+
+    h.delete(k)
+  end
+
+  def array_insert(a, k, v)
+
+    i = array_i(k)
+
+    a.insert(i, v)
+  end
+
+  def array_has_key?(a, k)
+
+    i =
+      array_i(k, false)
+    i =
+      if i.nil?
+        -1
+      elsif i < 0
+        a.length + i
+      else
+        i
+      end
+
+    i > -1 && i < a.length
+  end
+
+  def hash_has_key?(h, k)
+
+    return true if k.is_a?(Integer) && h.has_key?(k.to_s)
+    h.has_key?(k)
+  end
+end; end
+

data/lib/dense/path.rb

@@ -0,0 +1,384 @@
+
+class Dense::Path
+
+  attr_reader :original
+
+  def initialize(s)
+
+    @original = s
+
+    fail ArgumentError.new(
+      "Argument is a #{s.class}, not a String"
+    ) unless s.is_a?(String)
+
+    s = ".#{s}" unless s[0, 1] == '[' || s[0, 2] == '.['
+
+#Raabro.pp(Parser.parse(s, debug: 3))
+    @path = Parser.parse(s)
+
+#Raabro.pp(Parser.parse(s, debug: 3), colors: true) unless @path
+    fail ArgumentError.new(
+      "couldn't determine path from #{s.inspect}"
+    ) unless @path
+  end
+
+  def self.make(path_array)
+
+    return nil if path_array.nil?
+    return path_array if path_array.is_a?(Dense::Path)
+
+    path = Dense::Path.allocate
+    path.instance_eval { @path = path_array }
+    path.instance_eval { @original = path.to_s }
+
+    path
+  end
+
+  module 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 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
+
+    def rewrite_path(t)
+      t.subgather.collect { |tt| rewrite(tt) }
+    end
+
+  end
+
+  def to_a
+
+    @path
+  end
+
+  def length; @path.length; end
+  alias size length
+
+  def to_s
+
+    o = StringIO.new
+
+    @path.each { |e|
+      s = _to_s(e, false)
+      o << '.' unless o.size == 0 || '[.'.index(s[0, 1])
+      o << s }
+
+    s = o.string
+
+    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)
+      @path[offset]
+    elsif count
+      self.class.make(@path[offset, count])
+    else
+      self.class.make(@path[offset])
+    end
+  end
+
+  def ==(other)
+
+    other.class == self.class &&
+    other.to_a == @path
+  end
+
+  def last
+
+    @path.last
+  end
+
+  def pop
+
+    @path.pop
+  end
+
+  def -(path)
+
+    self.class.make(subtract(@path.dup, path.to_a.dup))
+  end
+
+  protected
+
+  class NotIndexableError < ::IndexError
+
+    attr_reader :container_class, :root_path, :remaining_path
+
+    def initialize(container, root_path, remaining_path, message=nil)
+
+      @container_class = container.is_a?(Class) ? container : container.class
+
+      @root_path = Dense::Path.make(root_path)
+      @remaining_path = Dense::Path.make(remaining_path)
+
+      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
+
+    def expand(root_path)
+
+      err = self.class.new(container_class, root_path, remaining_path, nil)
+      err.set_backtrace(self.backtrace)
+
+      err
+    end
+
+    def relabel(message)
+
+      err = self.class.new(container_class, root_path, remaining_path, message)
+      err.set_backtrace(self.backtrace)
+
+      err
+    end
+
+    def fail_path
+
+      @fail_path ||= (@root_path ? @root_path - @remaining_path : nil)
+    end
+  end
+
+  def subtract(apath0, apath1)
+
+    while apath0.any? && apath1.any? && apath0.last == apath1.last
+      apath0.pop
+      apath1.pop
+    end
+
+    apath0
+  end
+
+  def _to_s(elt, in_array)
+
+    case elt
+    when Hash
+      s = [ "#{elt[:start]}:#{elt[:end]}", elt[:step] ].compact.join(':')
+      in_array ? s : "[#{s}]"
+    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
+      '.'
+    else
+      elt.to_s
+    end
+  end
+
+  def _str_to_s(elt, in_array)
+
+    return elt.inspect if in_array
+
+    s = elt.to_s
+
+    return "\\#{s}" if s == '.' || s == '*'
+    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
+

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dense
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-05 00:00:00.000000000 Z
+date: 2017-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: raabro
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 1.1.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 1.1.5
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -45,11 +45,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - Makefile
 - README.md
 - dense.gemspec
 - lib/dense.rb
+- lib/dense/methods.rb
+- lib/dense/path.rb
 homepage: http://github.com/floraison/dense
 licenses:
 - MIT
@@ -70,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: fetching deep in a dense structure