forester 4.3.0 → 5.0.0

data/lib/forester/tree_node.rb

@@ -1,110 +1,98 @@
 module Forester
   class TreeNode < Tree::TreeNode
-
-    extend Forwardable
-    def_delegators :@content, :fields, :has?, :put!, :add!, :del!
-
-    include Aggregators
-    include Validators
+    include Iterators
     include Mutators
-    include Views
+    include Validators
+    include Serializers
 
-    alias_method :max_level, :node_height
+    def node_level
+      node_depth + 1
+    end
+
+    def nodes_of_depth(d) # relative to this node
+      d.between?(0, node_height) ? each_level.take(d + 1).last : []
+    end
 
     def nodes_of_level(l)
-      l.between?(0, max_level) ? each_level.take(l + 1).last : []
-    end
-
-    def each_node(options = {})
-      default_options = {
-        traversal: :breadth_first
-      }
-      options = default_options.merge(options)
-
-      case options[:traversal]
-      when :breadth_first
-        breadth_each
-      when :depth_first
-        each
-      when :postorder
-        postordered_each
-      when :preorder
-        preordered_each
-      else
-        raise ArgumentError, "invalid traversal mode: #{options[:traversal]}"
-      end
+      nodes_of_depth(l - 1)
     end
 
-    def each_content(options = {})
-      node_enumerator = each_node(options)
+    def path_from_root
+      (parentage || []).reverse + [self]
+    end
 
-      Enumerator.new do |yielder|
-        stop = false
-        until stop
-          begin
-            yielder << node_enumerator.next.content
-          rescue StopIteration
-            stop = true
-          end
-        end
-      end
+    def paths_to_leaves
+      paths_to(leaves)
     end
 
-    def each_level
-      Enumerator.new do |yielder|
-        level = [self]
-        until level.empty?
-          yielder << level
-          level = level.flat_map(&:children)
-        end
-      end
+    def paths_to(descendants)
+      descendants.map { |node| node.path_from_root.drop(node_depth) }
     end
 
-    def get(field, options = {}, &if_missing)
-      default_options = {
-        default: :raise,
-        subtree: false, # if false, traversal is ignored
-        traversal: :depth_first
-      }
-      options = default_options.merge(options)
+    def leaf?
+      is_leaf?
+    end
 
-      return own_and_descendants(field, { traversal: options[:traversal] }, &if_missing) if options[:subtree]
+    def leaves
+      each_leaf
+    end
 
-      if has?(field)
-        content.get(field)
-      elsif block_given?
-        yield self
-      elsif options[:default] != :raise
-        options[:default]
-      else
-        raise ArgumentError, "the node \"#{best_name}\" does not have \"#{field}\""
+    def paths_of_length(l)
+      paths_to(nodes_of_depth(l))
+    end
+
+    def leaves_when_pruned_to_depth(d)
+      ret = []
+      each_node(traversal: :breadth_first) do |node|
+        relative_depth_of_descendant = node.node_depth - node_depth
+        break if relative_depth_of_descendant > d
+        ret.push(node) if node.leaf? || (relative_depth_of_descendant == d)
       end
+
+      ret
     end
 
-    def contents(options = {})
-      each_node(options).map(&:content)
+    def leaves_when_pruned_to_level(l)
+      leaves_when_pruned_to_depth(l - 1)
     end
 
-    def same_as?(other)
-      return false unless content == other.content
-      return false unless    size == other.size
-      nodes_of_other = other.each_node.to_a
-      each_node.with_index do |n, i|
-        next if i == 0
-        return false unless n.same_as?(nodes_of_other[i])
-      end
-      true
+    def paths_to_leaves_when_pruned_to_depth(d)
+      paths_to(leaves_when_pruned_to_depth(d))
     end
 
-    private
+    def paths_to_leaves_when_pruned_to_level(l)
+      paths_to(leaves_when_pruned_to_level(l))
+    end
+
+    def get(field, default = :raise)
+      if has_field?(field)
+        content[field]
+      elsif block_given?
+        yield(field, self)
+      elsif default != :raise
+        default
+      else
+        missing_key =
+          if field.is_a?(Symbol)
+            ":#{field}"
+          elsif field.is_a?(String)
+            "'#{field}'"
+          else
+            field
+          end
+        error_message = "key not found: #{missing_key} in node content \"#{content}\""
+        raise KeyError, error_message
+      end
+    end
 
-    def best_name
-      get(:name, default: name)
+    def has_field?(field)
+      content.key?(field)
     end
 
+    private
+
     def as_array(object)
       [object].flatten(1)
     end
-
   end
 end

data/lib/forester/tree_node_ext/iterators.rb

@@ -0,0 +1,57 @@
+module Forester
+  module Iterators
+    TRAVERSAL_MODES = {
+      depth_first: :each,
+      breadth_first: :breadth_each,
+      preorder: :preordered_each,
+      postorder: :postordered_each
+    }.freeze
+
+    def each_node(options = {}, &block)
+      default_options = {
+        traversal: :depth_first
+      }
+      options = default_options.merge(options)
+
+      method_name = traversal_modes[options[:traversal]]
+
+      if method_name
+        send(method_name, &block)
+      else
+        available = traversal_modes.keys.join(', ')
+        raise ArgumentError, "invalid traversal mode: #{options[:traversal]} (#{available})"
+      end
+    end
+
+    def each_content(options = {})
+      node_enumerator = each_node(options)
+
+      Enumerator.new do |yielder|
+        stop = false
+        until stop
+          begin
+            yielder << node_enumerator.next.content
+          rescue StopIteration
+            stop = true
+          end
+        end
+      end
+    end
+
+    def each_level
+      Enumerator.new do |yielder|
+        level = [self]
+        until level.empty?
+          yielder << level
+          level = level.flat_map(&:children)
+        end
+      end
+    end
+
+    private
+
+    def traversal_modes
+      TRAVERSAL_MODES
+    end
+  end
+end

data/lib/forester/tree_node_ext/mutators.rb

@@ -1,7 +1,6 @@
 module Forester
   module Mutators
-
-    def change_parent_to!(new_parent_node, options = {})
+    def change_parent_to(new_parent_node, options = {})
       default_options = {
         subtree: true
       }
@@ -12,70 +11,64 @@ module Forester
       new_parent_node.add(self) # always as its last child
     end
 
-    def add_child_content!(content, options = {}, &block)
-      new_node = TreeFactory.node_from_hash(content, options, &block)
+    def add_child_content(content)
+      new_node = Forester.tree_factory.node_from_content(content)
       add(new_node)
     end
 
-    def add_field!(name, definition, options = {})
-      add_fields!([name: name, definition: definition], options)
-    end
-
-    def add_fields!(fields, options = {})
-      default_options = {
-        subtree: true
-      }
-      options = default_options.merge(options)
-
-      target_nodes = options[:subtree] ? each_node : [self]
+    def add_field_in_node(name, definition)
+      value = definition.respond_to?(:call) ? definition.call(self) : definition
 
-      target_nodes.each { |node| node.add_fields_to_root!(fields) }
+      content[name] = value
     end
 
-    def add_fields_to_root!(fields)
+    def add_fields_in_node(fields)
       fields.each do |field|
-        value = field[:definition]
-        value = value.call(self) if value.respond_to?(:call)
-
-        put!(field[:name], value)
+        add_field_in_node(field[:name], field[:definition])
       end
     end
 
-    def delete_values!(field, values, options = {})
+    def add_field_in_subtree(name, definition)
+      add_fields_in_subtree([name: name, definition: definition])
+    end
+
+    def add_fields_in_subtree(fields)
+      each_node { |node| node.add_fields_in_node(fields) }
+    end
+
+    def delete_values_in_node(field, values, options = {})
       default_options = {
-        percolate: false,
-        subtree:   true
+        percolate: false
       }
       options = default_options.merge(options)
 
-      target_nodes = options[:subtree] ? each_node : [self]
-
-      target_nodes.each { |node| node.delete_values_from_root!(field, values, options[:percolate]) }
-    end
-
-    def delete_values_from_root!(field, values, percolate)
-      return unless has?(field)
+      return unless has_field?(field)
       current_value = get(field)
-      return unless current_value.is_a?(Array)
 
-      new_value =
-        if percolate
-          current_value & as_array(values)
-        else
-          current_value - as_array(values)
-        end
+      operation = options[:percolate] ? :& : :-
+      return unless current_value.respond_to?(operation)
+
+      new_value = current_value.public_send(operation, as_array(values))
 
-      put!(field, new_value)
+      content[field] = new_value
     end
 
-    def percolate_values!(field, values, options = {})
-      delete_values!(field, values, options.merge(percolate: true))
+    def delete_values_in_subtree(field, values, options = {})
+      default_options = {
+        percolate: false
+      }
+      options = default_options.merge(options)
+
+      each_node { |node| node.delete_values_in_node(field, values, options) }
     end
 
-    def remove_levels_past!(last_level_to_keep)
+    def remove_levels_past(last_level_to_keep)
+      unless last_level_to_keep >= 1
+        raise ArgumentError, "expected a positive integer, got #{last_level_to_keep}"
+      end
+
       nodes_of_level(last_level_to_keep).map(&:remove_all!)
       self
     end
-
   end
 end

data/lib/forester/tree_node_ext/serializers.rb

@@ -0,0 +1,48 @@
+module Forester
+  module Serializers
+    def as_root_hash(options = {})
+      default_options = {
+        max_depth:      :none,
+        children_key:   'children',
+        stringify_keys: false,
+        symbolize_keys: false,
+        include_fields: :all,
+        exclude_fields: :none
+      }
+      options = default_options.merge(options)
+
+      max_depth = options[:max_depth]
+      max_depth = -1 if max_depth == :none
+
+      adjusted_content = content.each_with_object(content.class.new) do |(k, v), h|
+        adjusted_key = k
+        adjusted_key = k.to_s   if options[:stringify_keys]
+        adjusted_key = k.to_sym if options[:symbolize_keys]
+
+        unless options[:include_fields] == :all
+          next unless options[:include_fields].include?(adjusted_key)
+        end
+
+        unless options[:exclude_fields] == :none
+          next if options[:exclude_fields].include?(adjusted_key)
+        end
+
+        h[adjusted_key] = v
+      end
+
+      children_key = options[:children_key]
+      children_key = children_key.to_s   if options[:stringify_keys]
+      children_key = children_key.to_sym if options[:symbolize_keys]
+
+      next_children =
+        if max_depth == 0
+          []
+        else
+          next_options = options.merge(max_depth: max_depth - 1)
+          children.map { |node| node.as_root_hash(next_options) }
+        end
+
+      adjusted_content.merge(children_key => next_children)
+    end
+  end
+end

data/lib/forester/tree_node_ext/validators.rb

@@ -1,32 +1,21 @@
 module Forester
   module Validators
-
     def validate_uniqueness_of_field(field, options = {})
       validate_uniqueness_of_fields([field], options)
     end
 
     def validate_uniqueness_of_fields(fields, options = {})
-      default_options = {
-        combination:              false,
-        first_failure_only:       false,
-        within_subtrees_of_level: 0,
-        among_siblings_of_level:  :not_siblings,
-        field_for_failures:       :name,
-        as_failure: ->(node) { node.get(options[:field_for_failures]) }
-      }
-      options = default_options.merge(options)
-
-      return of_combination_of_fields(fields, options) if options[:combination]
+      options = default_validator_options.merge(options)
 
       failures = Hash.new(Hash.new([]))
 
-      nodes_of_level(options[:within_subtrees_of_level]).each do |subtree|
+      nodes_of_depth(options[:within_subtrees_of_depth]).each do |subtree|
         visited_nodes = []
         nodes_to_visit =
-          if options[:among_siblings_of_level] == :not_siblings
+          if options[:among_siblings_of_depth] == :not_siblings
             subtree.each_node
           else
-            nodes_of_level(options[:among_siblings_of_level])
+            nodes_of_depth(options[:among_siblings_of_depth])
           end
 
         nodes_to_visit.each  do |node|
@@ -53,18 +42,18 @@ module Forester
       result(failures)
     end
 
-    private
+    def validate_uniqueness_of_fields_combination(fields, options = {})
+      options = default_validator_options.merge(options)
 
-    def of_combination_of_fields(fields, options)
       failures = Hash.new(Hash.new([]))
 
-      nodes_of_level(options[:within_subtrees_of_level]).each do |subtree|
+      nodes_of_depth(options[:within_subtrees_of_depth]).each do |subtree|
         visited_nodes = []
         nodes_to_visit =
-          if options[:among_siblings_of_level] == :not_siblings
+          if options[:among_siblings_of_depth] == :not_siblings
             subtree.each_node
           else
-            nodes_of_level(options[:among_siblings_of_level])
+            nodes_of_depth(options[:among_siblings_of_depth])
           end
 
         nodes_to_visit.each  do |node|
@@ -91,12 +80,21 @@ module Forester
 
     private
 
+    def default_validator_options
+      {
+        first_failure_only: false,
+        within_subtrees_of_depth: 0,
+        among_siblings_of_depth: :not_siblings,
+        as_failure: ->(node) { node }
+      }
+    end
+
     def all_have?(field, nodes)
       all_have_all?([field], nodes)
     end
 
     def all_have_all?(fields, nodes)
-      nodes.all? { |n| fields.all? { |f| n.has?(f) } }
+      nodes.all? { |n| fields.all? { |f| n.has_field?(f) } }
     end
 
     def same_values?(field, nodes)
@@ -110,8 +108,8 @@ module Forester
     end
 
     def prepare_hash(hash, key, subkey)
-      hash[key]         = {} unless hash.has_key?(key)
-      hash[key][subkey] = [] unless hash[key].has_key?(subkey)
+      hash[key]         = {} unless hash.key?(key)
+      hash[key][subkey] = [] unless hash[key].key?(subkey)
     end
 
     def add_failure_if_new(failures, key, subkey, value)
@@ -129,6 +127,5 @@ module Forester
         failures: failures
       }
     end
-
   end
 end