ancestry 4.2.0 → 4.3.0

data/lib/ancestry/class_methods.rb

@@ -46,8 +46,10 @@ module Ancestry
       end
     end
 
-    # Arrange array of nodes into a nested hash of the form
-    # {node => children}, where children = {} if the node has no children
+    # arranges array of nodes to a hierarchical hash
+    #
+    # @param nodes [Array[Node]] nodes to be arranged
+    # @returns Hash{Node => {Node => {}, Node => {}}}
     # If a node's parent is not included, the node will be included as if it is a top level node
     def arrange_nodes(nodes)
       node_ids = Set.new(nodes.map(&:id))
@@ -60,6 +62,18 @@ module Ancestry
       end
     end
 
+    # convert a hash of the form {node => children} to an array of nodes, child first
+    #
+    # @param arranged [Hash{Node => {Node => {}, Node => {}}}] arranged nodes
+    # @returns [Array[Node]] array of nodes with the parent before the children
+    def flatten_arranged_nodes(arranged, nodes = [])
+      arranged.each do |node, children|
+        nodes << node
+        flatten_arranged_nodes(children, nodes) unless children.empty?
+      end
+      nodes
+    end
+
      # Arrangement to nested array for serialization
      # You can also supply your own serialization logic using blocks
      # also allows you to pass the order just as you can pass it to the arrange method
@@ -89,29 +103,21 @@ module Ancestry
     end
 
     # Pseudo-preordered array of nodes.  Children will always follow parents,
+    # This is deterministic unless the parents are missing *and* a sort block is specified
     def sort_by_ancestry(nodes, &block)
       arranged = nodes if nodes.is_a?(Hash)
 
       unless arranged
         presorted_nodes = nodes.sort do |a, b|
-          a_cestry, b_cestry = a.ancestry || '0', b.ancestry || '0'
-
-          if block_given? && a_cestry == b_cestry
-            yield a, b
-          else
-            a_cestry <=> b_cestry
-          end
+          rank = (a.ancestry || ' ') <=> (b.ancestry || ' ')
+          rank = yield(a, b) if rank == 0 && block_given?
+          rank
         end
 
         arranged = arrange_nodes(presorted_nodes)
       end
 
-      arranged.inject([]) do |sorted_nodes, pair|
-        node, children = pair
-        sorted_nodes << node
-        sorted_nodes += sort_by_ancestry(children, &block) unless children.blank?
-        sorted_nodes
-      end
+      flatten_arranged_nodes(arranged)
     end
 
     # Integrity checking

data/lib/ancestry/has_ancestry.rb

@@ -4,15 +4,25 @@ module Ancestry
       # Check options
       raise Ancestry::AncestryException.new(I18n.t("ancestry.option_must_be_hash")) unless options.is_a? Hash
       options.each do |key, value|
-        unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch, :counter_cache, :primary_key_format, :update_strategy, :strategy].include? key
+        unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch, :counter_cache, :primary_key_format, :update_strategy, :ancestry_format].include? key
           raise Ancestry::AncestryException.new(I18n.t("ancestry.unknown_option", key: key.inspect, value: value.inspect))
         end
       end
 
+      if options[:ancestry_format].present? && ![:materialized_path, :materialized_path2].include?( options[:ancestry_format] )
+        raise Ancestry::AncestryException.new(I18n.t("ancestry.unknown_format", value: options[:ancestry_format]))
+      end
+
       # Create ancestry column accessor and set to option or default
       cattr_accessor :ancestry_column
       self.ancestry_column = options[:ancestry_column] || :ancestry
 
+      cattr_accessor :ancestry_primary_key_format
+      self.ancestry_primary_key_format = options[:primary_key_format].presence || Ancestry.default_primary_key_format
+
+      cattr_accessor :ancestry_delimiter
+      self.ancestry_delimiter = '/'
+
       # Save self as base class (for STI)
       cattr_accessor :ancestry_base_class
       self.ancestry_base_class = self
@@ -27,14 +37,19 @@ module Ancestry
       # Include dynamic class methods
       extend Ancestry::ClassMethods
 
-      if options[:strategy] == :materialized_path2
-        validates_format_of self.ancestry_column, :with => derive_materialized2_pattern(options[:primary_key_format]), :allow_nil => false
+      cattr_accessor :ancestry_format
+      self.ancestry_format = options[:ancestry_format] || Ancestry.default_ancestry_format
+
+      if ancestry_format == :materialized_path2
         extend Ancestry::MaterializedPath2
       else
-        validates_format_of self.ancestry_column, :with => derive_materialized_pattern(options[:primary_key_format]), :allow_nil => true
         extend Ancestry::MaterializedPath
       end
 
+      attribute self.ancestry_column, default: self.ancestry_root
+
+      validates self.ancestry_column, ancestry_validation_options
+
       update_strategy = options[:update_strategy] || Ancestry.default_update_strategy
       include Ancestry::MaterializedPathPg if update_strategy == :sql
 
@@ -45,8 +60,8 @@ module Ancestry
       # Validate that the ancestor ids don't include own id
       validate :ancestry_exclude_self
 
-      # Update descendants with new ancestry before save
-      before_save :update_descendants_with_new_ancestry
+      # Update descendants with new ancestry after update
+      after_update :update_descendants_with_new_ancestry
 
       # Apply orphan strategy before destroy
       before_destroy :apply_orphan_strategy
@@ -99,31 +114,10 @@ module Ancestry
       return super if defined?(super)
       has_ancestry(*args)
     end
-
-    private
-
-    def derive_materialized_pattern(primary_key_format, delimiter = '/')
-      primary_key_format ||= '[0-9]+'
-
-      if primary_key_format.to_s.include?('\A')
-        primary_key_format
-      else
-        /\A#{primary_key_format}(#{delimiter}#{primary_key_format})*\Z/
-      end
-    end
-
-    def derive_materialized2_pattern(primary_key_format, delimiter = '/')
-      primary_key_format ||= '[0-9]+'
-
-      if primary_key_format.to_s.include?('\A')
-        primary_key_format
-      else
-        /\A#{delimiter}(#{primary_key_format}#{delimiter})*\Z/
-      end
-    end
   end
 end
 
+require 'active_support'
 ActiveSupport.on_load :active_record do
   extend Ancestry::HasAncestry
 end

data/lib/ancestry/instance_methods.rb

@@ -5,15 +5,15 @@ module Ancestry
       errors.add(:base, I18n.t("ancestry.exclude_self", class_name: self.class.name.humanize)) if ancestor_ids.include? self.id
     end
 
-    # Update descendants with new ancestry (before save)
+    # Update descendants with new ancestry (after update)
     def update_descendants_with_new_ancestry
       # If enabled and node is existing and ancestry was updated and the new ancestry is sane ...
       if !ancestry_callbacks_disabled? && !new_record? && ancestry_changed? && sane_ancestor_ids?
         # ... for each descendant ...
-        unscoped_descendants.each do |descendant|
+        unscoped_descendants_before_save.each do |descendant|
           # ... replace old ancestry with new ancestry
           descendant.without_ancestry_callbacks do
-            new_ancestor_ids = path_ids + (descendant.ancestor_ids - path_ids_in_database)
+            new_ancestor_ids = path_ids + (descendant.ancestor_ids - path_ids_before_last_save)
             descendant.update_attribute(:ancestor_ids, new_ancestor_ids)
           end
         end
@@ -133,8 +133,8 @@ module Ancestry
       ancestor_ids + [id]
     end
 
-    def path_ids_in_database
-      ancestor_ids_in_database + [id]
+    def path_ids_before_last_save
+      ancestor_ids_before_last_save + [id]
     end
 
     def path depth_options = {}
@@ -190,7 +190,7 @@ module Ancestry
 
     def root
       if has_parent?
-        unscoped_where { |scope| scope.find_by(id: root_id) } || self
+        unscoped_where { |scope| scope.find_by(scope.primary_key => root_id) } || self
       else
         self
       end
@@ -312,10 +312,16 @@ module Ancestry
       end
     end
 
+    def unscoped_descendants_before_save
+      unscoped_where do |scope|
+        scope.where self.ancestry_base_class.descendant_before_save_conditions(self)
+      end
+    end
+
     # works with after save context (hence before_last_save)
     def unscoped_current_and_previous_ancestors
       unscoped_where do |scope|
-        scope.where id: (ancestor_ids + ancestor_ids_before_last_save).uniq
+        scope.where scope.primary_key => (ancestor_ids + ancestor_ids_before_last_save).uniq
       end
     end
 

data/lib/ancestry/locales/en.yml

@@ -9,6 +9,7 @@ en:
 
     option_must_be_hash: "Options for has_ancestry must be in a hash."
     unknown_option: "Unknown option for has_ancestry: %{key} => %{value}."
+    unknown_format: "Unknown ancestry format: %{value}."
     named_scope_depth_cache: "Named scope '%{scope_name}' is only available when depth caching is enabled."
 
     exclude_self: "%{class_name} cannot be a descendant of itself."

data/lib/ancestry/materialized_path.rb

@@ -3,11 +3,6 @@ module Ancestry
   # root a=nil,id=1   children=id,id/%      == 1, 1/%
   # 3: a=1/2,id=3     children=a/id,a/id/%  == 1/2/3, 1/2/3/%
   module MaterializedPath
-    BEFORE_LAST_SAVE_SUFFIX = '_before_last_save'.freeze
-    IN_DATABASE_SUFFIX = '_in_database'.freeze
-    ANCESTRY_DELIMITER='/'.freeze
-    ROOT=nil
-
     def self.extended(base)
       base.send(:include, InstanceMethods)
     end
@@ -17,7 +12,7 @@ module Ancestry
     end
 
     def roots
-      where(arel_table[ancestry_column].eq(ROOT))
+      where(arel_table[ancestry_column].eq(ancestry_root))
     end
 
     def ancestors_of(object)
@@ -42,19 +37,26 @@ module Ancestry
     def indirects_of(object)
       t = arel_table
       node = to_node(object)
-      where(t[ancestry_column].matches("#{node.child_ancestry}#{ANCESTRY_DELIMITER}%", nil, true))
+      where(t[ancestry_column].matches("#{node.child_ancestry}#{ancestry_delimiter}%", nil, true))
     end
 
     def descendants_of(object)
-      node = to_node(object)
-      indirects_of(node).or(children_of(node))
+      where(descendant_conditions(object))
     end
 
-    # deprecated
-    def descendant_conditions(object)
+    def descendants_by_ancestry(ancestry)
       t = arel_table
+      t[ancestry_column].matches("#{ancestry}#{ancestry_delimiter}%", nil, true).or(t[ancestry_column].eq(ancestry))
+    end
+
+    def descendant_conditions(object)
       node = to_node(object)
-      t[ancestry_column].matches("#{node.child_ancestry}/%", nil, true).or(t[ancestry_column].eq(node.child_ancestry))
+      descendants_by_ancestry( node.child_ancestry )
+    end
+
+    def descendant_before_save_conditions(object)
+      node = to_node(object)
+      descendants_by_ancestry( node.child_ancestry_before_save )
     end
 
     def subtree_of(object)
@@ -86,35 +88,48 @@ module Ancestry
       ordered_by_ancestry(order)
     end
 
+    def ancestry_root
+      nil
+    end
+
+    private
+
+    def ancestry_validation_options
+      {
+        format: { with: ancestry_format_regexp },
+        allow_nil: ancestry_nil_allowed?
+      }
+    end
+
+    def ancestry_nil_allowed?
+      true
+    end
+
+    def ancestry_format_regexp
+      /\A#{ancestry_primary_key_format}(#{Regexp.escape(ancestry_delimiter)}#{ancestry_primary_key_format})*\z/.freeze
+    end
+
     module InstanceMethods
       # optimization - better to go directly to column and avoid parsing
       def ancestors?
-        read_attribute(self.ancestry_base_class.ancestry_column) != ROOT
+        read_attribute(self.ancestry_base_class.ancestry_column) != self.ancestry_base_class.ancestry_root
       end
       alias :has_parent? :ancestors?
 
       def ancestor_ids=(value)
-        col = self.ancestry_base_class.ancestry_column
-        value.present? ? write_attribute(col, generate_ancestry(value)) : write_attribute(col, ROOT)
+        write_attribute(self.ancestry_base_class.ancestry_column, generate_ancestry(value))
       end
 
       def ancestor_ids
         parse_ancestry_column(read_attribute(self.ancestry_base_class.ancestry_column))
       end
 
-      def ancestor_ids_in_database
-        parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}"))
-      end
-
       def ancestor_ids_before_last_save
-        parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}#{BEFORE_LAST_SAVE_SUFFIX}"))
+        parse_ancestry_column(attribute_before_last_save(self.ancestry_base_class.ancestry_column))
       end
 
       def parent_id_before_last_save
-        ancestry_was = send("#{self.ancestry_base_class.ancestry_column}#{BEFORE_LAST_SAVE_SUFFIX}")
-        return if ancestry_was == ROOT
-
-        parse_ancestry_column(ancestry_was).last
+        parse_ancestry_column(attribute_before_last_save(self.ancestry_base_class.ancestry_column)).last
       end
 
       # optimization - better to go directly to column and avoid parsing
@@ -128,18 +143,27 @@ module Ancestry
       def child_ancestry
         # New records cannot have children
         raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
-        path_was = self.send("#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}")
-        path_was.blank? ? id.to_s : "#{path_was}#{ANCESTRY_DELIMITER}#{id}"
+        [attribute_in_database(self.ancestry_base_class.ancestry_column), id].compact.join(self.ancestry_base_class.ancestry_delimiter)
+      end
+
+      def child_ancestry_before_save
+        # New records cannot have children
+        raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
+        [attribute_before_last_save(self.ancestry_base_class.ancestry_column), id].compact.join(self.ancestry_base_class.ancestry_delimiter)
       end
 
       def parse_ancestry_column(obj)
-        return [] if obj == ROOT
-        obj_ids = obj.split(ANCESTRY_DELIMITER)
+        return [] if obj.nil? || obj == self.ancestry_base_class.ancestry_root
+        obj_ids = obj.split(self.ancestry_base_class.ancestry_delimiter).delete_if(&:blank?)
         self.class.primary_key_is_an_integer? ? obj_ids.map!(&:to_i) : obj_ids
       end
 
       def generate_ancestry(ancestor_ids)
-        ancestor_ids.join(ANCESTRY_DELIMITER)
+        if ancestor_ids.present? && ancestor_ids.any?
+          ancestor_ids.join(self.ancestry_base_class.ancestry_delimiter)
+        else
+          self.ancestry_base_class.ancestry_root
+        end
       end
     end
   end

data/lib/ancestry/materialized_path2.rb

@@ -1,53 +1,62 @@
 module Ancestry
   # store ancestry as /grandparent_id/parent_id/
-  # root: a=/,id=1    children=a.id/% == /1/%
-  # 3:    a=/1/2/,id=3 children=a.id/% == /1/2/3/%
-  module MaterializedPath2 < MaterializedPath
-    def indirects_of(object)
-      t = arel_table
-      node = to_node(object)
-      where(t[ancestry_column].matches("#{node.child_ancestry}%#{ANCESTRY_DELIMITER}%", nil, true))
-    end
+  # root: a=/,id=1    children=#{a}#{id}/% == /1/%
+  # 3:    a=/1/2/,id=3 children=#{a}#{id}/% == /1/2/3/%
+  module MaterializedPath2
+    include MaterializedPath
 
-    def subtree_of(object)
-      t = arel_table
-      node = to_node(object)
-      where(descendant_conditions(node).or(t[primary_key].eq(node.id)))
+    def self.extended(base)
+      base.send(:include, MaterializedPath::InstanceMethods)
+      base.send(:include, InstanceMethods)
     end
 
-    def siblings_of(object)
+    def indirects_of(object)
       t = arel_table
       node = to_node(object)
-      where(t[ancestry_column].eq(node[ancestry_column]))
+      where(t[ancestry_column].matches("#{node.child_ancestry}%#{ancestry_delimiter}%", nil, true))
     end
 
     def ordered_by_ancestry(order = nil)
       reorder(Arel::Nodes::Ascending.new(arel_table[ancestry_column]), order)
     end
 
-    # deprecated
-    def descendant_conditions(object)
-      t = arel_table
-      node = to_node(object)
-      t[ancestry_column].matches("#{node.child_ancestry}%", nil, true)
+    def descendants_by_ancestry(ancestry)
+      arel_table[ancestry_column].matches("#{ancestry}%", nil, true)
+    end
+
+    def ancestry_root
+      ancestry_delimiter
+    end
+
+    private
+
+    def ancestry_nil_allowed?
+      false
+    end
+
+    def ancestry_format_regexp
+      /\A#{Regexp.escape(ancestry_delimiter)}(#{ancestry_primary_key_format}#{Regexp.escape(ancestry_delimiter)})*\z/.freeze
     end
 
     module InstanceMethods
       def child_ancestry
         # New records cannot have children
-        raise Ancestry::AncestryException.new('No child ancestry for new record. Save record before performing tree operations.') if new_record?
-        path_was = self.send("#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}")
-        "#{path_was}#{id}#{ANCESTRY_DELIMITER}"
+        raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
+        "#{attribute_in_database(self.ancestry_base_class.ancestry_column)}#{id}#{self.ancestry_base_class.ancestry_delimiter}"
       end
 
-      def parse_ancestry_column(obj)
-        return [] if obj == ROOT
-        obj_ids = obj.split(ANCESTRY_DELIMITER).delete_if(&:blank?)
-        self.class.primary_key_is_an_integer? ? obj_ids.map!(&:to_i) : obj_ids
+      def child_ancestry_before_save
+        # New records cannot have children
+        raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
+        "#{attribute_before_last_save(self.ancestry_base_class.ancestry_column)}#{id}#{self.ancestry_base_class.ancestry_delimiter}"
       end
 
       def generate_ancestry(ancestor_ids)
-        "#{ANCESTRY_DELIMITER}#{ancestor_ids.join(ANCESTRY_DELIMITER)}#{ANCESTRY_DELIMITER}"
+        if ancestor_ids.present? && ancestor_ids.any?
+          "#{self.ancestry_base_class.ancestry_delimiter}#{ancestor_ids.join(self.ancestry_base_class.ancestry_delimiter)}#{self.ancestry_base_class.ancestry_delimiter}"
+        else
+          self.ancestry_base_class.ancestry_root
+        end
       end
     end
   end

data/lib/ancestry/materialized_path_pg.rb

@@ -1,22 +1,22 @@
 module Ancestry
   module MaterializedPathPg
-    # Update descendants with new ancestry (before save)
+    # Update descendants with new ancestry (after update)
     def update_descendants_with_new_ancestry
       # If enabled and node is existing and ancestry was updated and the new ancestry is sane ...
       if !ancestry_callbacks_disabled? && !new_record? && ancestry_changed? && sane_ancestor_ids?
         ancestry_column = ancestry_base_class.ancestry_column
-        old_ancestry = path_ids_in_database.join(Ancestry::MaterializedPath::ANCESTRY_DELIMITER)
-        new_ancestry = path_ids.join(Ancestry::MaterializedPath::ANCESTRY_DELIMITER)
+        old_ancestry = generate_ancestry( path_ids_before_last_save )
+        new_ancestry = generate_ancestry( path_ids )
         update_clause = [
-          "#{ancestry_column} = regexp_replace(#{ancestry_column}, '^#{old_ancestry}', '#{new_ancestry}')"
+          "#{ancestry_column} = regexp_replace(#{ancestry_column}, '^#{Regexp.escape(old_ancestry)}', '#{new_ancestry}')"
         ]
 
         if ancestry_base_class.respond_to?(:depth_cache_column) && respond_to?(ancestry_base_class.depth_cache_column)
           depth_cache_column = ancestry_base_class.depth_cache_column.to_s
-          update_clause << "#{depth_cache_column} = length(regexp_replace(regexp_replace(ancestry, '^#{old_ancestry}', '#{new_ancestry}'), '\\d', '', 'g')) + 1"
+          update_clause << "#{depth_cache_column} = length(regexp_replace(regexp_replace(ancestry, '^#{Regexp.escape(old_ancestry)}', '#{new_ancestry}'), '[^#{ancestry_base_class.ancestry_delimiter}]', '', 'g')) #{ancestry_base_class.ancestry_format == :materialized_path2 ? '-' : '+'} 1"
         end
 
-        unscoped_descendants.update_all update_clause.join(', ')
+        unscoped_descendants_before_save.update_all update_clause.join(', ')
       end
     end
   end

data/lib/ancestry/materialized_path_string.rb

@@ -0,0 +1,46 @@
+module Ancestry
+  class MaterializedPathString < ActiveRecord::Type::Value
+    def initialize(casting: :to_i, delimiter: '/')
+      @casting = casting&.to_proc
+      @delimiter = delimiter
+    end
+
+    def type
+      :materialized_path_string
+    end
+
+    # convert to database type
+    def serialize(value)
+      if value.kind_of?(Array)
+        value.map(&:to_s).join(@delimiter).presence
+      elsif value.kind_of?(Integer)
+        value.to_s
+      elsif value.nil? || value.kind_of?(String)
+        value
+      else
+        byebug
+        puts "curious type: #{value.class}"
+      end
+    end
+
+    def cast(value)
+      cast_value(value) #unless value.nil? (want to get rid of this - fix default value)
+    end
+
+    # called by cast (form or setter) or deserialize (database)
+    def cast_value(value)
+      if value.kind_of?(Array)
+        super
+      elsif value.nil?
+        # would prefer to use default here
+        # but with default, it kept thinking the field had changed when it hadn't
+        # (that may be a rails bug though)
+        super([])
+      else
+        #TODO: test ancestry=1
+        super(value.to_s.split(@delimiter).map(&@casting))
+      end
+    end
+  end
+end
+ActiveRecord::Type.register(:materialized_path_string, Ancestry::MaterializedPathString)

data/lib/ancestry/materialized_path_string2.rb

@@ -0,0 +1,46 @@
+  # used for materialized path
+  class MaterializedPathString2 < ActiveRecord::Type::Value
+    def initialize(casting: :to_i, delimiter: '/')
+      @casting = casting&.to_proc
+      @delimiter = delimiter
+    end
+
+    def type
+      :materialized_path_string2
+    end
+
+    # convert to database type
+    def serialize(value)
+      if value.kind_of?(Array)
+        # TODO: check all values to ensure no extra slashes
+        value.empty? ? @delimiter : "#{@delimiter}#{value.map(&:to_s).join(@delimiter)}#{@delimiter}"
+      elsif value.kind_of?(Integer)
+        value.to_s
+      elsif value.nil? || value.kind_of?(String)
+        value
+      else
+        byebug
+        puts "curious type: #{value.class}"
+      end
+    end
+
+    def cast(value)
+      cast_value(value) #unless value.nil? (want to get rid of this - fix default value)
+    end
+
+    # called by cast (form or setter) or deserialize (database)
+    def cast_value(value)
+      if value.kind_of?(Array)
+        super
+      elsif value.nil?
+        # would prefer to use default here
+        # but with default, it kept thinking the field had changed when it hadn't
+        super([])
+      else
+        #TODO: test ancestry=1
+        super(value.to_s.split(@delimiter).map(&@casting))
+      end
+    end
+  end
+end
+ActiveRecord::Type.register(:materialized_path_string2, Ancestry::MaterializedPathString)

data/lib/ancestry/version.rb

@@ -1,3 +1,3 @@
 module Ancestry
-  VERSION = '4.2.0'
+  VERSION = '4.3.0'
 end

data/lib/ancestry.rb

@@ -4,6 +4,7 @@ require_relative 'ancestry/instance_methods'
 require_relative 'ancestry/exceptions'
 require_relative 'ancestry/has_ancestry'
 require_relative 'ancestry/materialized_path'
+require_relative 'ancestry/materialized_path2'
 require_relative 'ancestry/materialized_path_pg'
 
 I18n.load_path += Dir[File.join(File.expand_path(File.dirname(__FILE__)),
@@ -11,6 +12,8 @@ I18n.load_path += Dir[File.join(File.expand_path(File.dirname(__FILE__)),
 
 module Ancestry
   @@default_update_strategy = :ruby
+  @@default_ancestry_format = :materialized_path
+  @@default_primary_key_format = '[0-9]+'
 
   # @!default_update_strategy
   #   @return [Symbol] the default strategy for updating ancestry
@@ -26,7 +29,6 @@ module Ancestry
   #
   #        Child records are updated in sql and callbacks will not get called.
   #        Associated records in memory will have the wrong ancestry value
-
   def self.default_update_strategy
     @@default_update_strategy
   end
@@ -34,4 +36,39 @@ module Ancestry
   def self.default_update_strategy=(value)
     @@default_update_strategy = value
   end
+
+  # @!default_ancestry_format
+  #   @return [Symbol] the default strategy for updating ancestry
+  #
+  # The value changes the default way that ancestry is stored in the database
+  #
+  #    :materialized_path (default and legacy)
+  #
+  #        Ancestry is of the form null (for no ancestors) and 1/2/ for children
+  #
+  #    :materialized_path2 (preferred)
+  #
+  #        Ancestry is of the form '/' (for no ancestors) and '/1/2/' for children
+  def self.default_ancestry_format
+    @@default_ancestry_format
+  end
+
+  def self.default_ancestry_format=(value)
+    @@default_ancestry_format = value
+  end
+
+  # @!default_primary_key_format
+  #   @return [Symbol] the regular expression representing the primary key
+  #
+  # The value represents the way the id looks for validation
+  #
+  #    '[0-9]+' (default) for integer ids
+  #    '[-A-Fa-f0-9]{36}'    for uuids (though you can find other regular expressions)
+  def self.default_primary_key_format
+    @@default_primary_key_format
+  end
+
+  def self.default_primary_key_format=(value)
+    @@default_primary_key_format = value
+  end
 end