fr 0.9.1

data/lib/fr/tzipper/dangling_cursor.rb

@@ -0,0 +1,107 @@
+module Fr
+  module TZipper
+
+    class DanglingCursor < AbstractCursor
+
+      # @return [AbstractCursor]
+      attr_reader :parent
+
+      def initialize(parent)
+        @parent = parent
+      end
+
+      # (see AbstractCursor#node)
+      def node
+        raise Errors::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 Errors::ZipperError,
+          "cannot move to next after last node"
+      end
+
+      # (see AbstractCursor#prev)
+      def prev
+        raise Errors::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
+      #########################################################################
+
+      def inspect
+        "Cursor(..., ___)"
+      end
+    end
+
+  end
+end

data/lib/fr/tzipper/edited_cursor.rb

@@ -0,0 +1,161 @@
+module Fr
+  module TZipper
+
+    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 Errors::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 Errors::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
+      #########################################################################
+
+      def inspect
+        "Cursor(..., #{@node.inspect})"
+      end
+    end
+
+  end
+end

data/lib/fr/tzipper/memoized_cursor.rb

@@ -0,0 +1,129 @@
+module Fr
+  module TZipper
+
+    class MemoizedCursor < AbstractCursor
+
+      # @return [#leaf?, #children, #copy]
+      attr_reader :node
+
+      # @return [Hole]
+      attr_reader :path
+
+      # @return [AbstractCursor]
+      attr_reader :up
+
+      def initialize(node, path, up)
+        @node, @path, @up =
+          node, path, up
+      end
+
+      # @group Querying the Tree Location
+      #########################################################################
+
+      def leaf?
+        @node.leaf? or @node.children.empty?
+      end
+
+      def root?
+        false
+      end
+
+      # @group Traversing the Tree
+      #########################################################################
+
+      # @return [MemoizedCursor]
+      def next
+        @__next ||= begin
+          if last?
+            raise Errors::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), @up)
+        end
+      end
+
+      # @return [MemoizedCursor]
+      def prev
+        @__prev ||= begin
+          if first?
+            raise Errors::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)), @up)
+        end
+      end
+
+      # @return [MemoizedCursor]
+      def first
+        @up.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), @up)
+      end
+
+      # @return [EditedCursor]
+      def prepend(node)
+        EditedCursor.new(node,
+          Hole.new(@path.left, @path.parent, @node.cons(@path.right)), @up)
+      end
+
+      # @return [EditedCursor]
+      def replace(node)
+        EditedCursor.new(node, @path, @up)
+      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), @up)
+        elsif not first?
+          # Move to `prev`
+          head, *tail = @path.left
+
+          EditedCursor.new(head,
+            Hole.new(tail, @path.parent, @path.right), @up)
+        else
+          # Deleting the only child
+          parent =
+            @up.node.copy(children:
+              @path.left.reverse.concat(@path.right))
+
+          EditedCursor.new(parent, @path.parent, @up.parent).dangle
+        end
+      end
+
+      # @endgroup
+      #########################################################################
+
+      def inspect
+        "Cursor(..., #{@node.inspect})"
+      end
+    end
+
+  end
+end

data/lib/fr/tzipper/node.rb

@@ -0,0 +1,57 @@
+module Fr
+  module TZipper
+
+    class Node
+
+      attr_reader :value
+
+      attr_reader :children
+
+      def initialize(value, children = [])
+        @value, @children =
+          value, children
+      end
+
+      def copy(changes = {})
+        Node.new \
+          changes.fetch(:value, @value),
+          changes.fetch(:children, @value)
+      end
+
+      # Allow any node to have children
+      def leaf?
+        false
+      end
+
+      # This is implemented in object.rb
+      def cons(tail = [])
+        [self] + tail
+      end
+
+      def inspect
+        if @children.empty?
+          "Leaf(#{@value.inspect})"
+        else
+          "Node(#{@value.inspect}, #{@children.map(&:inspect).join(", ")})"
+        end
+      end
+
+    end
+
+    class << Node
+
+      def build(value, children)
+        Node.new(value, children.map do |c|
+          if Array === c
+            value_, *children_ = c
+            Node.build(value_, children_)
+          else
+            Node.new(c)
+          end
+        end)
+      end
+
+    end
+
+  end
+end