ancestry.rb in psd-3.3.1

- old
+ new
@@ -1,103 +1,99 @@
 class PSD
   module Node
     # Collection of methods to help in traversing the PSD tree structure.
     module Ancestry
-      extend ActiveSupport::Concern
+      # Returns the root node
+      def root
+        return self if is_root?
+        return parent.root
+      end
 
-      included do
-        # Returns the root node
-        def root
-          return self if is_root?
-          return parent.root
-        end
+      # Is this node the root node?
+      def root?
+        self.is_a?(PSD::Node::Root)
+      end
+      alias :is_root? :root?
 
-        # Is this node the root node?
-        def root?
-          self.is_a?(PSD::Node::Root)
-        end
-        alias :is_root? :root?
+      # Returns all ancestors in the path of this node. This
+      # does NOT return the root node.
+      def ancestors
+        return [] if parent.nil? || parent.is_root?
+        return parent.ancestors + [parent]
+      end
 
-        # Returns all ancestors in the path of this node. This
-        # does NOT return the root node.
-        def ancestors
-          return [] if parent.nil? || parent.is_root?
-          return parent.ancestors + [parent]
-        end
+      # Does this node have any children nodes?
+      def has_children?
+        children.length > 0
+      end
 
-        # Does this node have any children nodes?
-        def has_children?
-          children.length > 0
-        end
+      # Inverse of has_children?
+      def childless?
+        !has_children?
+      end
 
-        # Inverse of has_children?
-        def childless?
-          !has_children?
-        end
+      # Returns all sibling nodes including the current node. Can also
+      # be thought of as all children of the parent of this node.
+      def siblings
+        return [] if parent.nil?
+        parent.children
+      end
 
-        # Returns all sibling nodes including the current node. Can also
-        # be thought of as all children of the parent of this node.
-        def siblings
-          return [] if parent.nil?
-          parent.children
-        end
+      def next_sibling
+        return nil if parent.nil?
+        index = siblings.index(self)
+        siblings[index + 1]
+      end
 
-        def next_sibling
-          return nil if parent.nil?
-          index = siblings.index(self)
-          siblings[index + 1]
-        end
+      def prev_sibling
+        return nil if parent.nil?
+        index = siblings.index(self)
+        siblings[index - 1]
+      end
 
-        def prev_sibling
-          return nil if parent.nil?
-          index = siblings.index(self)
-          siblings[index - 1]
-        end
+      # Does this node have any siblings?
+      def has_siblings?
+        siblings.length > 1
+      end
 
-        # Does this node have any siblings?
-        def has_siblings?
-          siblings.length > 1
-        end
+      # Is this node the only descendant of its parent?
+      def only_child?
+        siblings.length == 1
+      end
 
-        # Is this node the only descendant of its parent?
-        def only_child?
-          siblings.length == 1
-        end
+      # Recursively get all descendant nodes, not including this node.
+      def descendants
+        children.map(&:subtree).flatten
+      end
 
-        # Recursively get all descendant nodes, not including this node.
-        def descendants
-          children.map(&:subtree).flatten
-        end
+      # Same as descendants, except it includes this node.
+      def subtree
+        [self] + descendants
+      end
 
-        # Same as descendants, except it includes this node.
-        def subtree
-          [self] + descendants
-        end
+      # Depth from the root node. Root depth is 0.
+      def depth
+        return ancestors.length + 1
+      end
 
-        # Depth from the root node. Root depth is 0.
-        def depth
-          return ancestors.length + 1
-        end
+      def path(as_array = false)
+        path = (ancestors.map(&:name) + [name])
+        as_array ? path : path.join('/')
+      end
 
-        def path(as_array = false)
-          path = (ancestors.map(&:name) + [name])
-          as_array ? path : path.join('/')
+      def method_missing(method, *args, &block)
+        test = /^(.+)_(layers|groups)$/.match(method)
+        if test
+          m = self.respond_to?(test[1]) ? test[1] : "#{test[1]}s"
+          self.send(m).select &method("#{test[2]}_only")
+        else
+          super
         end
+      end
 
-        def method_missing(method, *args, &block)
-          test = /^(.+)_(layers|groups)$/.match(method)
-          if test
-            m = self.respond_to?(test[1]) ? test[1] : "#{test[1]}s"
-            self.send(m).select &method("#{test[2]}_only")
-          else
-            super
-          end
-        end
+      private
 
-        private
-
-        def layers_only(d); d.layer?; end
-        def groups_only(d); d.group?(false); end
-      end
+      def layers_only(d); d.layer?; end
+      def groups_only(d); d.group?(false); end
     end
   end
-end
\ No newline at end of file
+end