hash_tree 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b474a91f66ef7115da2bd73b98c436c6409301e332de18ed2439d4262e3cda6
-  data.tar.gz: 3314e15480623ee8e9a984b0054835bea8c1d77d48cc885eedf653dfa4346ba6
+  metadata.gz: 6e76908b94b4a03beeb674da5e4e4b810094198e216d5be3b43f4acbd672f8e3
+  data.tar.gz: 3e83394d0f76fb228895a15b5953bff081ae5e853e648d6ca0b0cd18ae5a95a0
 SHA512:
-  metadata.gz: d92a9ec50b0032e3b8a675336d70ec3a5e238905ce71e990750997691bf776104f80d083be7cd59b32c1f59c08c2333f6f4f7ddd2970b9e8e03fb1af16c1965b
-  data.tar.gz: e2bfbd59bcbede4045e7aaae6b68a837cec99395ef00562732af9819581b981d9fde25c3b7c3d3e777c5f86fac931754760fa74e5d2dc7c0d8a90dd674b5b331
+  metadata.gz: d90748a40a23b0d8d1648649b41124a3ad8ae55896dfe73ff95173648c9913142844d0b20aff1a8709cdeae39d1483da648183c40e13d56f8ae709ae321dc0cd
+  data.tar.gz: 5a52fb194d2de6d47298a2fa36391c82f945e255412d5175cdd04c3a76990d0872421cb0e3e5d4ef04208b373eef71078bceaa633c39757f8af48c150b212127

data/.ruby-version

@@ -1 +1 @@
-ruby-2.6.6
+ruby-2.7.1

data/hash_tree.gemspec

@@ -36,8 +36,17 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "bundler", "~> 2.2.10"
   spec.add_development_dependency "rake", "~> 12.3.3"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "indented_io"
+
+  # In development mode override load paths for gems whose source are located
+  # as siblings of this project directory
+  if File.directory?("#{__dir__}/.git")
+    local_projects = Dir["../*"].select { |path| 
+      File.directory?(path) && File.exist?("#{path}/Gemfile")
+    }.map { |relpath| "#{File.absolute_path(relpath)}/lib" }
+    $LOAD_PATH.unshift *local_projects
+  end
 end

data/lib/hash_tree/version.rb

@@ -1,3 +1,3 @@
 module HashTree
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/hash_tree.rb

@@ -4,17 +4,34 @@ require "indented_io"
 # Simple tree of hashes
 #
 # TODO
-#   o each
-#   o traverse
-#   o #ancestors and #parents as enumerators
-#   o HashTree::Set, HashTree::Map, HashTree::Array
+#   o Different interfaces:
+#       Stable (the default - attributes are cached recursively)
+#       Dynamic (for trees with non-trivial edits - attributes are cached dynamically)
+#       Dot (for dot functionality
+#       Algorithms
+#
+#   o XPath?!
+#   o enumerators: descendants, ancestors, preorder, etc. etc.
+#   o HashTree::Array
 #   o Semantics of <=>: strictly partial so it returns nil on no common path?
 #   o Drop <=> ?
 #   o Implement #common to return common path of two elements
-#   o modularize?
+#   o Make is possible to include HashTree as a module instead of deriving from class
+#   o []=
+#   o #traverse filter?
+#   o more elaborate selectors - emit, skip
+#       :include => emit node and continue to children
+#       :fetch => emit node but skip children
+#       :exclude => skip node and continue to children
+#       :prune => skip node and children
 #
+#   + each
+#   + traverse
+#   + HashTree::Set, HashTree::Map
+
 module HashTree
   class Error < StandardError; end
+  class KeyNotFound < Error; end
 
   # The base Node type for HashTree implementations. It is not supposed to be called
   # from user-code
@@ -25,9 +42,13 @@ module HashTree
     # Hash from key to child node
     attr_reader :children
 
-    def initialize(parent, key)
+    def initialize(parent, key, attach: true)
       @children = {}
-      parent&.do_attach(key, self)
+      if attach
+        parent&.do_attach(key, self)
+      else
+        @parent = parent
+      end
     end
     
     # Attach a child to self
@@ -52,8 +73,14 @@ module HashTree
     # Returns true iff key is included in children
     def key?(key) @children.key?(key) end
 
+    # List of keys
+    def keys() @children.keys end
+
+    # List of values
+    def values() @children.values end
+
     # The root object or self if parent is nil
-    def root() @root ||= parents.last || self end
+    def root() @root ||= (parent&.root || self) end
 
     # List of parents up to the root element. If include_self is true, also
     # include self as the first element
@@ -67,17 +94,73 @@ module HashTree
       (@ancestors ||= parents(false).reverse) + (include_self ? [self] : [])
     end
 
-    # Recursively lookup object by dot-separated list of keys
+    # Recursively lookup object by dot-separated list of keys. Note that for
+    # this to work, key names must not contain dot characters ('.')
     #
-    # Note that for this to work, keys may not contain a dots ('.')
-    def dot(path)
-      path.split(".").inject(self) { |a,e| 
-        a[e] or raise Error, "Can't lookup '#{e}' in #{a.path.inspect}" 
-      }
+    # The reverse method, #path, is only defined for HashTree::Set because a
+    # HashTree::Map node doesn't know its own key
+    def dot(path_or_keys, raise_on_not_found: true)
+      keys = path_or_keys.is_a?(String) ? path_or_keys.split(".") : path_or_keys
+      key = keys.shift or return self
+      if child = dot_lookup(key)
+        child.send(:dot, keys, raise_on_not_found: raise_on_not_found)
+      elsif raise_on_not_found
+        raise KeyNotFound, "Can't lookup '#{key}' in #{self.path.inspect}"
+      else
+        nil
+      end
+    end
+
+    # True if path_or_keys address a node
+    def dot?(path_or_keys)
+      !dot(path_or_keys, raise_on_not_found: false).nil?
+    end
+
+    # List of [key, child] tuples
+    def each(&block)
+      if block_given?
+        children.each { |key, child| yield(key, child) }
+      else
+        children.each
+      end
+    end
+
+    # Return list of nodes in preorder
+    def preorder
+      [self] + values.inject([]) { |a,e| a + e.preorder }
+    end
+
+    # Return list of nodes in postorder
+    def postorder
+      values.inject([]) { |a,e| a + e.postorder } + [self]
+    end
+
+    # EXPERIMENTAL
+    #
+    # Process nodes in preorder. The block is called with the current node as
+    # argument and can return true to process its child nodes or false or nil
+    # to skip them. #traverse doesn't accumulate a result, this is the
+    # responsibily of the block
+    def traverse(&block)
+      values.each { |child| child.traverse(&block) } if yield(self)
+    end
+
+    # EXPERIMENTAL
+    #
+    # Process nodes in postorder (bottom-up). The block is called with the
+    # current node and a list of aggregated children. The optional filter
+    # argument is a lambda.  The lambda is called with the current node as
+    # argument and the node if skipped if the lambda returns falsy
+    def aggregate(filter = lambda { |node| true }, &block)
+      if filter.nil? || filter.call(self)
+        yield(self, values.map { |child| child.aggregate(filter, &block) }.compact)
+      else
+        nil
+      end
     end
 
   protected
-    # Attach a child node to self
+    # Attach a child node
     def do_attach(key, child)
       !@children.key?(key) or raise Error, "Duplicate child key: #{key.inspect}"
       !child.parent or raise Error, "Child is already attached"
@@ -86,6 +169,13 @@ module HashTree
       child.send(:clear_cached_properties)
     end
 
+    # Lookup key in current object. This method is used by #dot to lookup a
+    # child element and can be overridden to make #dot cross branches in the
+    # hierarchy. This is useful when you use HashTree to implement a graph
+    def dot_lookup(key)
+      self[key]
+    end
+
   private
     # Recursively clear cached properties like @parents in each node in the
     # tree. Should be called whenever the node is attached or detached from a
@@ -96,7 +186,7 @@ module HashTree
     # themselves constructed recursively so that iff a node has a cached
     # property, then all its parents will also cache it
     def clear_cached_properties()
-      if@root || @parents || @ancestors || @path
+      if @root || @parents || @ancestors || @path
         @root = nil
         @parents = nil
         @ancestors = nil
@@ -109,15 +199,21 @@ module HashTree
   class Set < Node
     alias node_attach attach
 
-    # Key of this node
+    # Key of this node. 
+    # TODO: Make it possible/required to alias this method to provide an internal key
     attr_reader :key
 
-    def initialize(parent, key)
-      super(parent, @key = key)
+    def initialize(parent, key, attach: true)
+      super(parent, @key = key, attach: attach)
     end
 
     def attach(child) do_attach(child.key, child) end
 
+    def retach(node)
+      node.parent.detach(node.key)
+      attach(node)
+    end
+
     # Unique dot-separated list of keys leading from the root object to 
     # self. Note that the root object is not included in the path so that
     #
@@ -126,7 +222,7 @@ module HashTree
     # is always true
     #
     # Note that for this to work, keys may not contain a dots ('.')
-    def path() @path ||= ancestors(true)[1..-1].join(".") end
+    def path() @path ||= ancestors(true)[1..-1].map(&:key).join(".") end
 
     # A set node is rendered as its key
     def to_s() key.to_s end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_tree
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-10 00:00:00.000000000 Z
+date: 2022-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: 2.2.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: 2.2.10
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -104,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.2.26
 signing_key: 
 specification_version: 4
 summary: A tree implemented as nested hashes