stupidedi 1.1.0

data/lib/stupidedi/zipper/dangling_cursor.rb

@@ -0,0 +1,103 @@
+module Stupidedi
+  module Zipper
+
+    class DanglingCursor < AbstractCursor
+
+      # @return [AbstractCursor]
+      attr_reader :parent
+
+      def initialize(parent)
+        @parent = parent
+      end
+
+      # (see AbstractCursor#node)
+      def node
+        raise Exceptions::ZipperError,
+          "DanglingCursor#node should not be called"
+      end
+
+      # (see AbstractCursor#path)
+      def path
+        Hole.new([], @parent.path.parent, [])
+      end
+
+      # @group Querying the Tree Location
+      #########################################################################
+
+      # (see AbstractCursor#leaf?)
+      def leaf?
+        true
+      end
+
+      # (see AbstractCursor#root?)
+      def root?
+        false
+      end
+
+      # (see AbstractCursor#depth)
+      def depth
+        @parent.depth + 1
+      end
+
+      # (see AbstractCursor#first?)
+      def first?
+        true
+      end
+
+      # (see AbstractCursor#last?)
+      def last?
+        true
+      end
+
+      # @group Traversing the Tree
+      #########################################################################
+
+      # @return [AbstractCursor]
+      def up
+        @parent
+      end
+
+      # (see AbstractCursor#next)
+      def next
+        raise Exceptions::ZipperError,
+          "cannot move to next after last node"
+      end
+
+      # (see AbstractCursor#prev)
+      def prev
+        raise Exceptions::ZipperError,
+          "cannot move to prev before first node"
+      end
+
+      # (see AbstractCursor#first)
+      def first
+        self
+      end
+
+      # (see AbstractCursor#last)
+      def last
+        self
+      end
+
+      # @group Editing the Tree
+      #########################################################################
+
+      # (see AbstractCursor#replace)
+      def replace(node)
+        @parent.append_child(node)
+      end
+
+      alias prepend replace
+      alias append  replace
+
+      # (see AbstractCursor#delete)
+      def delete
+        self
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/zipper/edited_cursor.rb

@@ -0,0 +1,157 @@
+module Stupidedi
+  module Zipper
+
+    class EditedCursor < AbstractCursor
+
+      # (see AbstractCursor#node)
+      attr_reader :node
+
+      # @return [Hole]
+      attr_reader :path
+
+      # @return [AbstractCursor]
+      attr_reader :parent
+
+      def initialize(node, path, parent)
+        @node, @path, @parent =
+          node, path, parent
+      end
+
+      # @group Querying the Tree Location
+      #########################################################################
+
+      # (see AbstractCursor#leaf?)
+      def leaf?
+        @node.leaf? or @node.children.empty?
+      end
+
+      # (see AbstractCursor#root?)
+      def root?
+        false
+      end
+
+      # @group Traversing the Tree
+      #########################################################################
+
+      # (see AbstractCursor#up)
+      # @return [AbstractCursor]
+      def up
+        node =
+          @parent.node.copy(:children =>
+            @path.left.reverse.concat(@node.cons(@path.right)))
+
+        if parent.root?
+          RootCursor.new(node)
+        else
+          EditedCursor.new(node, @path.parent, @parent.parent)
+        end
+      end
+
+      # (see AbstractCursor#next)
+      # @return [EditedCursor]
+      def next
+        if last?
+          raise Exceptions::ZipperError,
+            "cannot move to next after last node"
+        end
+
+        head, *tail = @path.right
+
+        EditedCursor.new(head,
+          Hole.new(@node.cons(@path.left), @path.parent, tail), @parent)
+      end
+
+      # (see AbstractCursor#prev)
+      # @return [EditedCursor]
+      def prev
+        if first?
+          raise Exceptions::ZipperError,
+            "cannot move to prev before first node"
+        end
+
+        head, *tail = @path.left
+
+        EditedCursor.new(head,
+          Hole.new(tail, @path.parent, @node.cons(@path.right)), @parent)
+      end
+
+      # (see AbstractCursor#first)
+      # @return [EditedCursor]
+      def first
+        if first?
+          return self
+        end
+
+        right = @path.left.init.reverse.concat(@node.cons(@path.right))
+
+        EditedCursor.new(@path.left.last,
+          Hole.new([], @path.parent, right), @parent)
+      end
+
+      # (see AbstractCursor#last)
+      # @return [EditedCursor]
+      def last
+        if last?
+          return self
+        end
+
+        left = @node.cons(@path.right.init.reverse).concat(@path.left)
+
+        EditedCursor.new(@path.right.last,
+          Hole.new(left, @path.parent, []), @parent)
+      end
+
+      # @group Editing the Tree
+      #########################################################################
+
+      # (see AbstractCursor#last)
+      # @return [EditedCursor]
+      def append(node)
+        EditedCursor.new(node,
+          Hole.new(@node.cons(@path.left), @path.parent, @path.right), @parent)
+      end
+
+      # (see AbstractCursor#last)
+      # @return [EditedCursor]
+      def prepend(node)
+        EditedCursor.new(node,
+          Hole.new(@path.left, @path.parent, @node.cons(@path.right)), @parent)
+      end
+
+      # (see AbstractCursor#last)
+      # @return [EditedCursor]
+      def replace(node)
+        EditedCursor.new(node, @path, @parent)
+      end
+
+      # (see AbstractCursor#last)
+      # @return [EditedCursor]
+      def delete
+        if not last?
+          # Move to `next`
+          head, *tail = @path.right
+
+          EditedCursor.new(head,
+            Hole.new(@path.left, @path.parent, tail), @parent)
+        elsif not first?
+          # Move to `prev`
+          head, *tail = @path.left
+
+          EditedCursor.new(head,
+            Hole.new(tail, @path.parent, @path.right), @parent)
+        else
+          # Deleting the only child
+          parent =
+            @parent.node.copy(:children =>
+              @path.left.reverse.concat(@path.right))
+
+          EditedCursor.new(parent, @path.parent, @parent.parent).dangle
+        end
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/zipper/memoized_cursor.rb

@@ -0,0 +1,131 @@
+module Stupidedi
+  module Zipper
+
+    class MemoizedCursor < AbstractCursor
+
+      # @return [#leaf?, #children, #copy]
+      attr_reader :node
+
+      # @return [Hole]
+      attr_reader :path
+
+      # @private
+      # @return [AbstractCursor]
+      attr_reader :parent
+
+      def initialize(node, path, parent)
+        @node, @path, @parent =
+          node, path, parent
+      end
+
+      # @group Querying the Tree Location
+      #########################################################################
+
+      def leaf?
+        @node.leaf? or @node.children.empty?
+      end
+
+      def root?
+        false
+      end
+
+      # @group Traversing the Tree
+      #########################################################################
+
+      # @return [AbstractCursor]
+      def up
+        @parent
+      end
+
+      # @return [MemoizedCursor]
+      def next
+        @__next ||= begin
+          if last?
+            raise Exceptions::ZipperError,
+              "cannot move to next after last node"
+          end
+
+          head, *tail = @path.right
+
+          MemoizedCursor.new(head,
+            Hole.new(@node.cons(@path.left), @path.parent, tail), @parent)
+        end
+      end
+
+      # @return [MemoizedCursor]
+      def prev
+        @__prev ||= begin
+          if first?
+            raise Exceptions::ZipperError,
+              "cannot move to prev before first node"
+          end
+
+          head, *tail = @path.left
+
+          MemoizedCursor.new(head,
+            Hole.new(tail, @path.parent, @node.cons(@path.right)), @parent)
+        end
+      end
+
+      # @return [MemoizedCursor]
+      def first
+        @parent.down
+      end
+
+      # @return [MemoizedCursor]
+      def last
+        current = self
+        current = current.next until current.last?
+        current
+      end
+
+      # @group Editing the Tree
+      #########################################################################
+
+      # @return [EditedCursor]
+      def append(node)
+        EditedCursor.new(node,
+          Hole.new(@node.cons(@path.left), @path.parent, @path.right), @parent)
+      end
+
+      # @return [EditedCursor]
+      def prepend
+        EditedCursor.new(node,
+          Hole.new(@path.left, @path.parent, @node.cons(@path.right)), @parent)
+      end
+
+      # @return [EditedCursor]
+      def replace(node)
+        EditedCursor.new(node, @path, @parent)
+      end
+
+      # @return [EditedCursor]
+      def delete
+        if not last?
+          # Move to `next`
+          head, *tail = @path.right
+
+          EditedCursor.new(head,
+            Hole.new(@path.left, @path.parent, tail), @parent)
+        elsif not first?
+          # Move to `prev`
+          head, *tail = @path.left
+
+          EditedCursor.new(head,
+            Hole.new(tail, @path.parent, @path.right), @parent)
+        else
+          # Deleting the only child
+          parent =
+            @parent.node.copy(:children =>
+              @path.left.reverse.concat(@path.right))
+
+          EditedCursor.new(parent, @path.parent, @parent.parent).dangle
+        end
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/zipper/path.rb

@@ -0,0 +1,124 @@
+module Stupidedi
+  module Zipper
+
+    class AbstractPath
+
+      # @return [AbstractPath]
+      abstract :parent
+
+      # Contains the node's leftward siblings, sorted nearest to furthest
+      #
+      # @return [Array<#leaf?, #children, #copy>]
+      abstract :left
+
+      # Contains the node's rightward siblings, sorted nearest to furthest
+      #
+      # @return [Array<#leaf?, #children, #copy>]
+      abstract :right
+
+      # True when the node has no rightward siblings
+      abstract :last?
+
+      # True when the node has no leftward siblings
+      abstract :first?
+
+      # Distance from the root node
+      #
+      # @return [Integer]
+      abstract :depth
+    end
+
+    # @private
+    Root = Class.new(AbstractPath) do
+
+      # @return self
+      def parent
+        self
+      end
+
+      # (see AbstractPath#left)
+      def left
+        []
+      end
+
+      # (see AbstractPath#right)
+      def right
+        []
+      end
+
+      # (see AbstractPath#last?)
+      # @return true
+      def last?
+        true
+      end
+
+      # (see AbstractPath#first?)
+      # @return true
+      def first?
+        true
+      end
+
+      # (see AbstractPath#depth)
+      def depth
+        0
+      end
+
+      def position
+        nil
+      end
+
+      # @return [String]
+      def inspect
+        "root"
+      end
+    end.new
+
+    class Hole < AbstractPath
+
+      # (see AbstractPath#right)
+      attr_reader :left
+
+      # @return [AbstractPath]
+      attr_reader :parent
+
+      # (see AbstractPath#left)
+      attr_reader :right
+
+      def initialize(left, parent, right)
+        @left, @parent, @right =
+          left, parent, right
+      end
+
+      # (see AbstractPath#last?)
+      def last?
+        @right.empty?
+      end
+
+      # (see AbstractPath#first?)
+      def first?
+        @left.empty?
+      end
+
+      # (see AbstractPath#depth)
+      def depth
+        1 + @parent.depth
+      end
+
+      def position
+        @left.length
+      end
+
+      # @return [String]
+      def inspect
+        "#{@parent.inspect}/#{@left.length}"
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        depth    == other.depth and
+        position == other.position
+      end
+    end
+
+  end
+end

data/lib/stupidedi/zipper/root_cursor.rb

@@ -0,0 +1,120 @@
+module Stupidedi
+  module Zipper
+
+    class RootCursor < AbstractCursor
+
+      # @return [AbstractNode]
+      attr_reader :node
+
+      # @return [AbstractPath]
+      attr_reader :path
+
+      def initialize(node)
+        @node, @path =
+          node, Root
+      end
+
+      # @group Query the Tree Location
+      #########################################################################
+
+      # (see AbstractCursor#depth)
+      def depth
+        0
+      end
+
+      # (see AbstractCursor#first?)
+      def first?
+        true
+      end
+
+      # (see AbstractCursor#last?)
+      def last?
+        true
+      end
+
+      # (see AbstractCursor#leaf?)
+      def leaf?
+        @node.leaf? or @node.children.empty?
+      end
+
+      # (see AbstractCursor#root?)
+      def root?
+        true
+      end
+
+      # @group Traversing the Tree
+      #########################################################################
+
+      # (see AbstractCursor#first)
+      def first
+        self
+      end
+
+      # (see AbstractCursor#last)
+      def last
+        self
+      end
+
+      # (see AbstractCursor#next)
+      # @return [void]
+      def next
+        raise Exceptions::ZipperError,
+          "root node has no siblings"
+      end
+
+      # (see AbstractCursor#prev)
+      # @return [void]
+      def prev
+        raise Exceptions::ZipperError,
+          "root node has no siblings"
+      end
+
+      # (see AbstractCursor#root)
+      # @return [RootCursor]
+      def root
+        self
+      end
+
+      # (see AbstractCursor#up)
+      # @return [void]
+      def up
+        raise Exceptions::ZipperError,
+          "root node has no parent"
+      end
+
+      # @group Editing the Tree
+      #########################################################################
+
+      # (see AbstractCursor#append)
+      # @return [void]
+      def append(node)
+        raise Exceptions::ZipperError,
+          "root node has no siblings"
+      end
+
+      # (see AbstractCursor#prepend)
+      # @return [void]
+      def prepend(node)
+        raise Exceptions::ZipperError,
+          "root node has no siblings"
+      end
+
+      # (see AbstractCursor#replace)
+      # @return [RootCursor]
+      def replace(node)
+        RootCursor.new(node)
+      end
+
+      # (see AbstractCursor#delete)
+      # @return [void]
+      def delete
+        raise Exceptions::ZipperError,
+          "cannot delete root node"
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/zipper.rb

@@ -0,0 +1,25 @@
+module Stupidedi
+  module Zipper
+    autoload :AbstractCursor, "stupidedi/zipper/abstract_cursor"
+    autoload :DanglingCursor, "stupidedi/zipper/dangling_cursor"
+    autoload :EditedCursor,   "stupidedi/zipper/edited_cursor"
+    autoload :MemoizedCursor, "stupidedi/zipper/memoized_cursor"
+    autoload :RootCursor,     "stupidedi/zipper/root_cursor"
+
+    autoload :AbstractPath, "stupidedi/zipper/path"
+    autoload :Hole,         "stupidedi/zipper/path"
+    autoload :Root,         "stupidedi/zipper/path"
+  end
+
+  class << Zipper
+
+    # @group Constructors
+    ###########################################################################
+
+    # @return [AbstractCursor]
+    def build(node)
+      Zipper::RootCursor.new(node)
+    end
+  end
+
+end