skn_utils 3.3.5 → 3.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 84cb7bcd483e3369c94109704c491658263a497d
-  data.tar.gz: 0fefb9e19e864638acfeaa605dd315e12db33a0c
+  metadata.gz: 1fd1ca93fc5fbcbdf6d22f5c45851fcd36e19e88
+  data.tar.gz: 0aeaade9f44e5a69c701946d24542c9c88f2995e
 SHA512:
-  metadata.gz: 66f1414ed28fae1ab9e2701c6d21590e9ea463303964c23de9ffd0f3eabe5df701bc18bb6cceb9c98752d353038d79bbffb97909d1dd447c683eeafc88c9cb12
-  data.tar.gz: 3552bd034096bc4c60f339082af9a22f09bfe57e4c53b589507306e3e190e7598a5b765da62f7ad561fa5270df14652f6272d9d939359c32901cc10802c54abe
+  metadata.gz: 5a934d2d35f6680f15b923df769e3da95795d122317fe15bb49b26aa5917b077c7fa81040b02ef637a26d4bef15791cc447538c663c187b83681e5c698dc6627
+  data.tar.gz: a05eae70e269463828a96e6c8e714cd214bacb5bf1256caee2220cdf1c62d634bc58a61e7f42f556e08c2a4254ae27547149186cbf3cd632b85ca871b1c6b1da

data/README.md

@@ -17,8 +17,8 @@ Ruby Gem containing a Ruby PORO (Plain Old Ruby Object) that can be instantiated
 
 ## New Features
     08/2017  V3.3.0
-    Added Linked List classes which implement value based Singular, Doubly, and Circular linked lists patterns.  Value based implies
-    the internal nodes of a linked list are never returned through the public interface, only node contents or values.
+    Added Linked List classes which implement Single, Double, and Circular linked lists patterns.  LinkedLists are implemented
+    with method results returning node values or the nodes themselves.
 
     07/2017  V3.1.5
     Added SknSettings class for use as a replacement to the popular, but obsolete, Config.gem
@@ -70,9 +70,13 @@ Ruby Gem containing a Ruby PORO (Plain Old Ruby Object) that can be instantiated
 
 
 ## Public Methods: SknUtils::Lists::LinkedList, SknUtils::Lists::DoublyLinkedList, and SknUtils::Lists::CircularLinkedList
-    Each concrete Class supports the following methods:
-
+#### Each concrete Class supports the following methods: Value based interface
+    Value based interface presumes a direct reference to the object is maintained and the following methods will be called on that
+    object instance as needed.  Each method will generally return the value contained in the node, Nil, or the int number of nodes 
+    remaining.
+    
     Navigation: return related value from relative positon in list, stops on first/last node for Single/Double, wraps for Circular.
+    
       #first                       -- returns first value in list
       #next                        -- returns next value from current position
       #current                     -- returns current value
@@ -94,6 +98,7 @@ Ruby Gem containing a Ruby PORO (Plain Old Ruby Object) that can be instantiated
                                       block format is:  {|a,b| a >= b };  example: 'll.sort(:default) {|a,b| a <= b}'
 
     Modification: returns number of elements in the list after the operation
+    
       #insert(value)                        -- inserts value after node at current positon, or appends
       #append(value)                        -- inserts value after node at current positon
       #prepend(value)                       -- inserts value before node at current positon
@@ -102,9 +107,36 @@ Ruby Gem containing a Ruby PORO (Plain Old Ruby Object) that can be instantiated
       #remove(value)                        -- finds first node matching value, then destroys it
 
     Initialization: optional &block to identify data key
+    
       #new(*vargs, &block)         -- Instansiates new list and optionally creates nodes from each comma-seperated value;
                                       also, assigns &block as default value identifier for find and sort operations
-               compare_key_block example:  LinkedList.new({:key=>"Z"},{:key=>"S"},{:key=>"N"}) {|a| a[:key]}  
+                                      returns a class instance.
+               compare_key_block example:  instance = LinkedList.new({:key=>"Z"},{:key=>"S"},{:key=>"N"}) {|a| a[:key]}
+               
+#### Each concrete Class supports the following methods: Node based interface
+    Node based interface presumes a node is retrieved from the LinkedList, then using that/any available node all other methods
+    may be used.  Methods in play will include the LinkedNode (#next, #value, and #prev), along with all public methods from
+    the main class.
+                 
+    Navigation: return related Node from relative positon in list, stops on first/last node for Single/Double, wraps for Circular.
+    
+      #first_node                  -- returns first node
+      #next_node                   -- returns next node from current position
+      #current_node                -- returns current or last accessed node
+      #prev_node                   -- returns previous node from current position (*not supported in Single)
+      #last_node                   -- returns last node in list
+      #node_value                  -- returns value of the current/receiver node:  $ receiver.node_value
+      #node_request(method_sym, *vargs, &block) 
+                                   -- executes any method on the Value based Interface, returning a node
+      #node_value_request(method_sym, *vargs, &block) 
+                                   -- executes any method on the Value based Interface, returning result value
+
+    Initialization: optional &block to identify data key
+    
+      #call(*vargs, &block)         -- Instansiates new list and optionally creates nodes from each comma-seperated value;
+                                      also, assigns &block as default value identifier for find and sort operations
+                                      returns the first node when initialized with vargs -- else class instance 
+               compare_key_block example:  node = LinkedList.call({:key=>"Z"},{:key=>"S"},{:key=>"N"}) {|a| a[:key]}
 
 
 ## Public Methods: SknSettings ONLY

data/lib/skn_utils/lists/circular_linked_list.rb

@@ -27,54 +27,24 @@ module SknUtils
     # Circularly Linked List
     # Forward (#next) and Backwards (#prev) navigation
     # No Head or Tail
-    class CircularLinkedList
-      attr_accessor :size
 
-      def initialize(*vargs, &compare_key_proc)
-        @current = nil
-        @head = nil
-        @tail = nil
-        @size = 0
-
-        @match_value     = block_given? ? compare_key_proc : lambda {|obj| obj }
-        @sort_ascending  = lambda {|a_obj,b_obj| @match_value.call(a_obj) >= @match_value.call(b_obj)}
-        @sort_descending = lambda {|a_obj,b_obj| @match_value.call(a_obj) <= @match_value.call(b_obj)}
-        @sort_condition  = @sort_ascending
-
-        vargs.each {|value| insert(value) }
-        first if vargs.size > 1
-      end
+    # LinkedCommons provides;
+    # - #initialize, #first, #next, #current, #last, #at_index,
+    #   #insert, #prepend, #append, #empty?, #clear,
+    #   #each, #to_a, and #sort!
+    #
+    class CircularLinkedList < LinkedCommons
 
       #
       # Navigation
       #
 
-      # return values and position current to last node accessed
-      # prevent @current from nil assignment
-      def first
-        @current = self.head if self.head
-        @current.value rescue nil
-      end
-
-      def next
-        @current = @current.next if @current and @current.next
-        @current.value rescue nil
-      end
-
-      def current
-        @current.value rescue nil
-      end
 
       def prev
         @current = @current.prev if @current and @current.prev
         @current.value rescue nil
       end
 
-      def last
-        @current = self.tail if self.tail
-        @current.value rescue nil
-      end
-
       # -+ int position from current node
       def nth(index)
         node = @current
@@ -97,41 +67,14 @@ module SknUtils
         current
       end
 
-      # return node at positive index from head
-      def at_index(index)
-        find_by_index(index)
-        current
-      end
-
-      def empty?
-        self.size == 0
-      end
-
       #
       # Modifications
       #
 
-      # return new size
-      def insert(value)
-        temp = @current.value rescue nil
-        insert_after(temp, value)
-      end
-
-      # return new size
-      def prepend(value)
-        temp = self.head.value rescue nil
-        insert_before(temp, value)
-      end
-      # return new size
-      def append(value)
-        temp = self.tail.value rescue nil
-        insert_after(temp, value)
-      end
-
       # return new size
       def insert_before(position_value, value)
         target = find_by_value(position_value)
-        node = LinkNode.new(value, target, :circle_before, &@match_value)
+        node = LinkNode.new(value, target, :circle_before, self,  &@match_value)
         @current = node
         if self.size == 0           # only
           self.head =  node
@@ -151,7 +94,7 @@ module SknUtils
       # return new size
       def insert_after(position_value, value)
         target = find_by_value(position_value)
-        node = LinkNode.new(value, target, :circle_after, &@match_value)
+        node = LinkNode.new(value, target, :circle_after, self,  &@match_value)
         @current = node
         if self.size == 0           # only
           self.head =  node
@@ -197,83 +140,8 @@ module SknUtils
       end
 
 
-      # return number cleared
-      def clear
-        rc = 0
-        node = self.head
-        position = node
-        while node do
-          node = node.remove!
-          rc += 1
-          break if position.equal?(node)
-        end
-
-        @current = nil
-        self.head = nil
-        self.tail = nil
-        self.size = 0
-        rc
-      end
-
-      #
-      # Enumerate
-      #
-
-      # perform each() or return enumerator
-      def each(&block)
-        @current = self.head
-        position = self.head
-        if block_given?
-          while position do
-            block.call( position.value.dup )
-            position = position.next
-            break if position === @current
-          end
-        else
-          Enumerator.new do |yielder|
-            while position do
-              yielder << position.value.dup
-              position = position.next
-              break if position === @current
-            end
-          end
-        end
-      end
-
-      # convert self to a value array
-      def to_a
-        @current = self.head
-        position = self.head
-        result = []
-        while position do
-          result << position.value.dup
-          position = position.next
-          break if position.equal?(@current)
-        end
-        result
-      end
-
-      # block format: sort condition : {|a_obj,b_obj| a_obj >= b_obj}
-      def sort!(direction_sym=:default, &compare_sort_proc)
-        @active_sort_condition = block_given? ? compare_sort_proc :
-                                     case direction_sym
-                                       when :asc
-                                         @sort_ascending
-                                       when :desc
-                                         @sort_descending
-                                       else
-                                         @sort_condition
-                                     end
-        sorted = merge_sort(self.to_a)
-        clear
-        sorted.each {|item| insert(item) }
-        self.size
-      end
-
     protected
 
-      attr_accessor :head, :tail
-
       def find_by_value(value)
         return nil if value.nil? || self.size == 0
         stop_node = self.head
@@ -295,29 +163,6 @@ module SknUtils
         node
       end
 
-      # Merged Sort via Ref: http://rubyalgorithms.com/merge_sort.html
-      # arr is Array to be sorted, sort_cond is Proc expecting a/b params returning true/false
-      def merge_sort(arr)
-        return arr if arr.size < 2
-        middle = arr.size / 2
-          left = merge_sort(arr[0...middle])
-          right = merge_sort(arr[middle..arr.size])
-        merge(left, right)
-      end
-
-      def merge(left, right)
-        sorted = []
-        while left.any? && right.any?
-          if @active_sort_condition.call(left.first, right.first)
-            sorted.push right.shift
-          else
-            sorted.push left.shift
-          end
-        end
-
-        sorted + left + right
-      end
-
     end # end class
   end # module
 end # end module

data/lib/skn_utils/lists/doubly_linked_list.rb

@@ -28,54 +28,23 @@ module SknUtils
     # Forward (#next) and Backwards (#prev) navigation
     # Head when (prev == nil)
     # Tail when (next == nil)
-    class DoublyLinkedList
-      attr_accessor :size
 
-      def initialize(*vargs, &compare_key_proc)
-        @current = nil
-        @head = nil
-        @tail = nil
-        @size = 0
-
-        @match_value     = block_given? ? compare_key_proc : lambda {|obj| obj }
-        @sort_ascending  = lambda {|a_obj,b_obj| @match_value.call(a_obj) >= @match_value.call(b_obj)}
-        @sort_descending = lambda {|a_obj,b_obj| @match_value.call(a_obj) <= @match_value.call(b_obj)}
-        @sort_condition  = @sort_ascending
-
-        vargs.each {|value| insert(value) }
-        first if vargs.size > 1
-      end
+    # LinkedCommons provides;
+    # - #initialize, #first, #next, #current, #last, #at_index,
+    #   #insert, #prepend, #append, #empty?, #clear,
+    #   #each, #to_a, and #sort!
+    #
+    class DoublyLinkedList < LinkedCommons
 
       #
       # Navigation
       #
 
-      # return values and position current to last node accessed
-      # prevent @current from nil assignment
-      def first
-        @current = head if head
-        @current.value rescue nil
-      end
-
-      def next
-        @current = @current.next if @current and @current.next
-        @current.value rescue nil
-      end
-
-      def current
-        @current.value rescue nil
-      end
-
       def prev
         @current = @current.prev if @current and @current.prev
         @current.value rescue nil
       end
 
-      def last
-        @current = tail if tail
-        @current.value rescue nil
-      end
-
       # -+ int position from current node
       def nth(index)
         node = @current
@@ -95,54 +64,27 @@ module SknUtils
         current
       end
 
-      # return node at positive index from head
-      def at_index(index)
-        find_by_index(index)
-        current
-      end
-
-      def empty?
-        size == 0
-      end
-
       #
       # Modifications
       #
 
-      # return new size
-      def insert(value)
-        temp = @current.value rescue nil
-        insert_after(temp, value)
-      end
-
-      # return new size
-      def prepend(value)
-        temp = head.value rescue nil
-        insert_before(temp, value)
-      end
-      # return new size
-      def append(value)
-        temp = tail.value rescue nil
-        insert_after(temp, value)
-      end
-
       # return new size
       def insert_before(position_value, value)
         target = find_by_value(position_value)
-        node = LinkNode.new(value, target, :before, &@match_value)
+        node = LinkNode.new(value, target, :before, self,  &@match_value)
         @current = node if target
-        self.head = node if head === target
-        self.tail = node if tail.nil?
+        self.head = node if self.head === target
+        self.tail = node if self.tail.nil?
         self.size += 1
       end
 
       # return new size
       def insert_after(position_value, value)
         target = find_by_value(position_value)
-        node = LinkNode.new(value, target, :after, &@match_value)
+        node = LinkNode.new(value, target, :after, self,  &@match_value)
         @current = node
-        self.head = node if head.nil?
-        self.tail = node if tail === target
+        self.head = node if self.head.nil?
+        self.tail = node if self.tail === target
         self.size += 1
       end
 
@@ -150,7 +92,7 @@ module SknUtils
       def remove(value)
         target_node = find_by_value(value)
         if target_node
-          if size == 1                           # will become zero
+          if self.size == 1                           # will become zero
             @current = nil
             self.head = nil
             self.tail = nil
@@ -172,86 +114,11 @@ module SknUtils
         end
       end
 
-      # return number cleared
-      def clear
-        rc = 0
-        node = head
-        position = head
-        while node do
-          node = node.remove!
-          rc += 1
-          break if position === node
-        end
-
-        @current = nil
-        self.head = nil
-        self.tail = nil
-        self.size = 0
-        rc
-      end
-
-      #
-      # Enumerate
-      #
-
-      # perform each() or return enumerator
-      def each(&block)
-        @current = head
-        position = head
-        if block_given?
-          while position do
-            block.call( position.value.dup )
-            position = position.next
-            break if position === @current
-          end
-        else
-          Enumerator.new do |yielder|
-            while position do
-              yielder << position.value.dup
-              position = position.next
-              break if position === @current
-            end
-          end
-        end
-      end
-
-      # convert self to a value array
-      def to_a
-        @current = head
-        position = head
-        result = []
-        while position do
-          result << position.value.dup
-          position = position.next
-          break if position === @current
-        end
-        result
-      end
-
-      # block format: sort condition : {|a_obj,b_obj| a_obj >= b_obj}
-      def sort!(direction_sym=:default, &compare_sort_proc)
-        @active_sort_condition = block_given? ? compare_sort_proc :
-                                     case direction_sym
-                                       when :asc
-                                         @sort_ascending
-                                       when :desc
-                                         @sort_descending
-                                       else
-                                         @sort_condition
-                                     end
-        sorted = merge_sort(to_a)
-        clear
-        sorted.each {|item| insert(item) }
-        size
-      end
-
-    private
-
-      attr_accessor :head, :tail
+    protected
 
       def find_by_value(value)
-        return nil if head.nil? || value.nil? || size == 0
-        prior = head
+        return nil if self.head.nil? || value.nil? || self.size == 0
+        prior = self.head
         target = prior
         while target and not target.match_by_value(value)
           prior = target
@@ -261,42 +128,13 @@ module SknUtils
       end
 
       def find_by_index(index)
-        return nil if head.nil? or index < 1 or index > size
-        node = head
+        return nil if self.head.nil? or index < 1 or index > self.size
+        node = self.head
         node = node.next while ((index -= 1) > 0 and node.next)
         @current = node if node
         node
       end
 
-      # Merged Sort via Ref: http://rubyalgorithms.com/merge_sort.html
-      # arr is Array to be sorted, sort_cond is Proc expecting a/b params returning true/false
-      def merge_sort(arr)
-        return arr if arr.size < 2
-
-        middle = arr.size / 2
-
-        left = merge_sort(arr[0...middle])
-        right = merge_sort(arr[middle..arr.size])
-
-        merge(left, right)
-      end
-
-      def merge(left, right)
-        sorted = []
-
-        while left.any? && right.any?
-
-          if @active_sort_condition.call(left.first, right.first)
-            sorted.push right.shift
-          else
-            sorted.push left.shift
-          end
-
-        end
-
-        sorted + left + right
-      end
-
     end # end class
   end # module
 end # end module

data/lib/skn_utils/lists/link_node.rb

@@ -8,10 +8,11 @@ module SknUtils
     class LinkNode
       attr_accessor :prev, :next, :value
 
-      def initialize(val, anchor_node=nil, strategy=:after, &cmp_key)
+      def initialize(val, anchor_node=nil, strategy=:after, mgr=nil, &cmp_key)
         @value = val
         @prev = nil
         @next = nil
+        @provider = mgr
         @cmp_proc = block_given? ? cmp_key : lambda {|a| a }
 
         case strategy
@@ -55,6 +56,41 @@ module SknUtils
       def to_s
         "Node with value: #{@value}"
       end
+
+      # Reverse API to Parent Linked List Class
+      def node_value
+        node_request.value
+      end
+      def first_node
+        node_request(:first)
+      end
+      def next_node
+        node_request(:next)
+      end
+      def current_node
+        node_request(:current)
+      end
+      def prev_node
+        node_request(:prev)
+      end
+      def last_node
+        node_request(:last)
+      end
+
+      protected()
+
+      def respond_to_missing?(method, include_private=false)
+        @provider && @provider.protected_methods(true).include?(method) || super
+      end
+
+      def method_missing(method, *args, &block)
+        if @provider and @provider.protected_methods(true).include?(method)
+          block_given? ? @provider.send(method, *args, block) :
+              (args.size == 0 ?  @provider.send(method) : @provider.send(method, *args))
+        else
+          super
+        end
+      end
     end
   end # module
 end

data/lib/skn_utils/lists/linked_commons.rb

@@ -0,0 +1,202 @@
+##
+# File <SknUtils>/lib/skn_utils/lists/linked_commons.rb
+#
+# Common routines for Linked List:
+#   #initialize, #first, #next, #current, #last, #at_index,
+#   #insert, #prepend, #append, #empty?, #clear,
+#   #each, #to_a, and #sort!
+##
+
+module SknUtils
+  module Lists
+
+    class LinkedCommons
+      attr_accessor :size
+
+      # Initialize and return first node if nodes are available
+      def self.call(*vargs, &compare_key_proc)
+        target = self.new(*vargs, &compare_key_proc)
+        return target.instance_variable_get(:@current) if vargs.size > 1
+        target
+      end
+
+      def initialize(*vargs, &compare_key_proc)
+        @current = nil
+        @head = nil
+        @tail = nil
+        @size = 0
+
+        @match_value     = block_given? ? compare_key_proc : lambda {|obj| obj }
+        @sort_ascending  = lambda {|a_obj,b_obj| @match_value.call(a_obj) >= @match_value.call(b_obj)}
+        @sort_descending = lambda {|a_obj,b_obj| @match_value.call(a_obj) <= @match_value.call(b_obj)}
+        @sort_condition  = @sort_ascending
+
+        vargs.each {|value| insert(value) }
+        first if vargs.size > 1
+      end
+
+
+      # return values and position current to last node accessed
+      # prevent @current from nil assignment
+      def first
+        @current = self.head if self.head
+        @current.value rescue nil
+      end
+
+      def next
+        @current = @current.next if @current and @current.next
+        @current.value rescue nil
+      end
+
+      def current
+        @current.value rescue nil
+      end
+
+      def last
+        @current = self.tail if self.tail
+        @current.value rescue nil
+      end
+
+      # return node at positive index from head
+      def at_index(index)
+        find_by_index(index)
+        current
+      end
+
+      def empty?
+        self.size == 0
+      end
+
+      # return number cleared
+      def clear
+        rc = 0
+        node = self.head
+        position = node
+        while node do
+          node = node.remove!
+          rc += 1
+          break if position.equal?(node)
+        end
+
+        @current = nil
+        self.head = nil
+        self.tail = nil
+        self.size = 0
+        rc
+      end
+
+      # return new size
+      def insert(value)
+        temp = @current.value rescue nil
+        insert_after(temp, value)
+      end
+
+      # return new size
+      def prepend(value)
+        temp = self.head.value rescue nil
+        insert_before(temp, value)
+      end
+      # return new size
+      def append(value)
+        temp = self.tail.value rescue nil
+        insert_after(temp, value)
+      end
+
+      #
+      # Enumerate
+      #
+
+      # perform each() or return enumerator
+      def each(&block)
+        @current = self.head
+        position = self.head
+        if block_given?
+          while position do
+            block.call( position.value.dup )
+            position = position.next
+            break if position === @current
+          end
+        else
+          Enumerator.new do |yielder|
+            while position do
+              yielder << position.value.dup
+              position = position.next
+              break if position === @current
+            end
+          end
+        end
+      end
+
+      # convert self to a value array
+      def to_a
+        @current = self.head
+        position = self.head
+        result = []
+        while position do
+          result << position.value.dup
+          position = position.next
+          break if position.equal?(@current)
+        end
+        result
+      end
+
+      # block format: sort condition : {|a_obj,b_obj| a_obj >= b_obj}
+      def sort!(direction_sym=:default, &compare_sort_proc)
+        @active_sort_condition = block_given? ? compare_sort_proc :
+                                     case direction_sym
+                                       when :asc
+                                         @sort_ascending
+                                       when :desc
+                                         @sort_descending
+                                       else
+                                         @sort_condition
+                                     end
+        sorted = merge_sort(self.to_a)
+        clear
+        sorted.each {|item| insert(item) }
+        self.size
+      end
+
+
+    protected
+
+      attr_accessor :head, :tail
+
+      # Merged Sort via Ref: http://rubyalgorithms.com/merge_sort.html
+      # arr is Array to be sorted, sort_cond is Proc expecting a/b params returning true/false
+      def merge_sort(arr)
+        return arr if arr.size < 2
+        middle = arr.size / 2
+        left = merge_sort(arr[0...middle])
+        right = merge_sort(arr[middle..arr.size])
+        merge(left, right)
+      end
+
+      def merge(left, right)
+        sorted = []
+        while left.any? && right.any?
+          if @active_sort_condition.call(left.first, right.first)
+            sorted.push right.shift
+          else
+            sorted.push left.shift
+          end
+        end
+
+        sorted + left + right
+      end
+
+      # Retrieves requested node, not value
+      def node_request(method_sym=:current, *vargs, &block)
+        position_value = block_given? ? send(method_sym, *vargs, block) :
+                             (vargs.size == 0 ?  send(method_sym) : send(method_sym, *vargs))
+        @current
+      end
+      # Retrieves requested value, not node
+      def node_value_request(method_sym=:current, *vargs, &block)
+        position_value = block_given? ? send(method_sym, *vargs, block) :
+                             (vargs.size == 0 ?  send(method_sym) : send(method_sym, *vargs))
+      end
+
+    end
+  end # module
+end

data/lib/skn_utils/lists/linked_list.rb

@@ -28,51 +28,18 @@ module SknUtils
     # Forward or #next navigation only
     # Head is absolute via #first
     # Tail when (next == nil)
-    class LinkedList
-      attr_accessor :size
 
-      # &compare_key_proc supplies an method to identify
-      # the key of an object for comparison purposes
-      def initialize(*vargs, &compare_key_proc)
-        @sort_condition = nil
-        @current = nil
-        @head = nil
-        @tail = nil
-        @size = 0
-
-        @match_value     = block_given? ? compare_key_proc : lambda {|obj| obj }
-        @sort_ascending  = lambda {|a_obj,b_obj| @match_value.call(a_obj) >= @match_value.call(b_obj)}
-        @sort_descending = lambda {|a_obj,b_obj| @match_value.call(a_obj) <= @match_value.call(b_obj)}
-        @sort_condition  = @sort_ascending
-
-        vargs.each {|value| insert(value) }
-        first if vargs.size > 1
-      end
+    # LinkedCommons provides;
+    # - #initialize, #first, #next, #current, #last, #at_index,
+    #   #insert, #prepend, #append, #empty?, #clear,
+    #   #each, #to_a, and #sort!
+    #
+    class LinkedList < LinkedCommons
 
       #
       # Navigation
       #
 
-      # return values and position current to last node accessed
-      def first
-        @current = head if head
-        @current.value rescue nil
-      end
-
-      def next
-        @current = @current.next if @current and @current.next
-        @current.value rescue nil
-      end
-
-      def current
-        @current.value rescue nil
-      end
-
-      def last
-        @current = tail if tail
-        @current.value rescue nil
-      end
-
       # +int position from current node
       def nth(index)
         node = @current
@@ -85,45 +52,17 @@ module SknUtils
         current
       end
 
-      # return node at positive index from head
-      def at_index(index)
-        find_by_index(index)
-        current
-      end
-
-      def empty?
-        size == 0
-      end
-
       #
       # Modifications
       #
 
-      # return new size
-      def insert(value)
-        temp = @current.value rescue nil
-        insert_after(temp, value)
-      end
-
-      # return new size
-      def prepend(value)
-        temp = head.value rescue nil
-        insert_before(temp, value)
-      end
-
-      # return new size
-      def append(value)
-        temp = tail.value rescue nil
-        insert_after(temp, value)
-      end
-
       # return new size
       def insert_before(position_value, value)
         prior, target = find_by_value(position_value)
-        node = LinkNode.new(value, prior, :single, &@match_value)
+        node = LinkNode.new(value, prior, :single, self,  &@match_value)
         node.next = target if target
-        self.head = node if head === target
-        self.tail = node if tail.nil?
+        self.head = node if self.head === target
+        self.tail = node if self.tail.nil?
         @current = node
         self.size += 1
       end
@@ -131,9 +70,9 @@ module SknUtils
       # return new size
       def insert_after(position_value, value)
         prior, target = find_by_value(position_value)
-        node = LinkNode.new(value, target, :single, &@match_value)
-        self.head = node if head.nil?
-        self.tail = node if tail === target
+        node = LinkNode.new(value, target, :single, self,  &@match_value)
+        self.head = node if self.head.nil?
+        self.tail = node if self.tail === target
         @current = node
         self.size += 1
       end
@@ -143,90 +82,16 @@ module SknUtils
         prior, target_node = find_by_value(value)
         @current = prior.nil? ? target_node.next : prior
         @current.next = target_node.remove! if @current && target_node
-        self.tail = @current.next if @current && tail === target_node
-        self.head = @current.next if @current && head === target_node
+        self.tail = @current.next if @current && self.tail === target_node
+        self.head = @current.next if @current && self.head === target_node
         self.size -= 1
       end
 
-      # return number cleared
-      def clear
-        rc = 0
-        node = head
-        position = head
-        while node do
-          node = node.remove!
-          rc += 1
-          break if position === node
-        end
-
-        @current = nil
-        self.head = nil
-        self.tail = nil
-        self.size = 0
-        rc
-      end
-
-      #
-      # Enumerate
-      #
-
-      # perform each() or return enumerator
-      def each(&block)
-        @current = head
-        position = head
-        if block_given?
-          while position do
-            block.call(position.value.dup )
-            position = position.next
-          end
-        else
-          Enumerator.new do |yielder|
-            while position do
-              yielder << position.value.dup
-              position = position.next
-            end
-          end
-        end
-      end
-
-      # convert self to a value array
-      def to_a
-        @current = head
-        position = head
-        result = []
-        while position do
-          result << position.value.dup
-          position = position.next
-          break if position === @current
-        end
-        result
-      end
-
-      # block format: sort condition : {|a_obj,b_obj| a_obj >= b_obj}
-      def sort!(direction_sym=:default, &compare_sort_proc)
-        @active_sort_condition = block_given? ? compare_sort_proc :
-                                     case direction_sym
-                                       when :asc
-                                         @sort_ascending
-                                       when :desc
-                                         @sort_descending
-                                       else
-                                         @sort_condition
-                                     end
-
-        sorted = merge_sort(to_a)
-        clear
-        sorted.each {|item| insert(item) }
-        size
-      end
-
-    private
-
-      attr_accessor :head, :tail
+    protected
 
       def find_by_value(value)
-        return [@current, nil] if head.nil? || value.nil?
-        prior  = head
+        return [@current, nil] if self.head.nil? || value.nil?
+        prior  = self.head
         target = prior
         while target and not target.match_by_value(value)
           prior = target
@@ -237,42 +102,13 @@ module SknUtils
       end
 
       def find_by_index(index)
-        return nil if head.nil? || index < 1 || index > size
-        node = head
+        return nil if self.head.nil? || index < 1 || index > self.size
+        node = self.head
         node = node.next while ((index -= 1) > 0 and node.next)
         @current = node if node
         node
       end
 
-      # Merged Sort via Ref: http://rubyalgorithms.com/merge_sort.html
-      # arr is Array to be sorted, sort_cond is Proc expecting a/b params returning true/false
-      def merge_sort(arr)
-        return arr if arr.size < 2
-
-        middle = arr.size / 2
-
-        left = merge_sort(arr[0...middle])
-        right = merge_sort(arr[middle..arr.size])
-
-        merge(left, right)
-      end
-
-      def merge(left, right)
-        sorted = []
-
-        while left.any? && right.any?
-
-          if @active_sort_condition.call(left.first, right.first)
-            sorted.push right.shift
-          else
-            sorted.push left.shift
-          end
-
-        end
-
-        sorted + left + right
-      end
-
     end # end class
   end # end module
 end # end module

data/lib/skn_utils/version.rb

@@ -3,7 +3,7 @@ module SknUtils
   class Version
     MAJOR = 3
     MINOR = 3
-    PATCH = 5
+    PATCH = 6
 
     def self.to_s
       [MAJOR, MINOR, PATCH].join('.')

data/lib/skn_utils.rb

@@ -5,6 +5,7 @@ require 'skn_utils/page_controls'
 require 'skn_utils/null_object'
 require 'skn_utils/notifier_base'
 require 'skn_utils/skn_configuration'
+require 'skn_utils/lists/linked_commons'
 require 'skn_utils/lists/link_node'
 require 'skn_utils/lists/linked_list'
 require 'skn_utils/lists/doubly_linked_list'

data/spec/lib/skn_utils/lists/node_based_linked_list_spec.rb

@@ -0,0 +1,85 @@
+##
+# spec/lib/skn_utils/node_based_linked_list_spec.rb
+#
+
+RSpec.describe SknUtils::Lists::DoublyLinkedList, "DoublyLinkedList using node interface " do
+
+  context "Node Interface Edge Cases " do
+    let(:node) { described_class.call(10,20, 30, 40, 50, 60, 70, 80, 90, 100) {|a| a} }
+
+    context "Node Retrieval " do
+
+      it "#node_request(:first) returns a LinkedNode object." do
+        expect(node.send(:node_request,:first)).to be_a SknUtils::Lists::LinkNode
+      end
+      it "#first_node returns a LinkedNode object." do
+        expect(node.first_node).to be_a SknUtils::Lists::LinkNode
+      end
+      it "#next_node returns a LinkedNode object." do
+        expect(node.next_node).to be_a SknUtils::Lists::LinkNode
+      end
+      it "#current_node returns a LinkedNode object." do
+        expect(node.current_node).to be_a SknUtils::Lists::LinkNode
+      end
+      it "#prev_node returns a LinkedNode object." do
+        expect(node.prev_node).to be_a SknUtils::Lists::LinkNode
+      end
+      it "#last_node returns a LinkedNode object." do
+        expect(node.last_node).to be_a SknUtils::Lists::LinkNode
+      end
+    end
+
+    context "Node Values " do
+
+      it "#methods with params are supported through #{}node_request() interface. " do
+        expect(node.first_node.node_value_request(:at_index, 5)).to eq(50)
+      end
+      it "First node has the expected value. " do
+        expect(node.first_node.value).to eq(10)
+      end
+      it "Next node has the expected value. " do
+        expect(node.next_node.value).to eq(20)
+      end
+      it "Current node has the expected value. " do
+        3.times { node.next_node }
+        expect(node.current_node.value).to eq(40)
+      end
+      it "Last node has the expected value. " do
+        expect(node.last_node.value).to eq(100)
+      end
+      it "#node_value collected match #to_a output. " do
+        nav_ary = []
+        node.node_value_request(:size).times do
+          nav_ary << node.node_value
+          node.next_node
+        end
+
+        expect(nav_ary).to eq(node.node_value_request(:to_a))
+      end
+    end
+
+    context "Node Navigation " do
+
+      it "Can navigate to each mode in list, forward. " do
+        node.node_value_request(:size).times do
+          expect(node.next_node).to be_a SknUtils::Lists::LinkNode
+        end
+      end
+      it "Can navigate to each mode in list, backward. " do
+        node.last_node.node_value_request(:size).times do
+          expect(node.prev_node).to be_a SknUtils::Lists::LinkNode
+        end
+      end
+      it "Values collected match #to_a output. " do
+        nav_ary = []
+        node.node_value_request(:size).times do
+          nav_ary << node.node_value
+          node.next_node
+        end
+
+        expect(node.node_value_request(:to_a)).to eq(nav_ary)
+      end
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: skn_utils
 version: !ruby/object:Gem::Version
-  version: 3.3.5
+  version: 3.3.6
 platform: ruby
 authors:
 - James Scott Jr
@@ -140,6 +140,7 @@ files:
 - lib/skn_utils/lists/circular_linked_list.rb
 - lib/skn_utils/lists/doubly_linked_list.rb
 - lib/skn_utils/lists/link_node.rb
+- lib/skn_utils/lists/linked_commons.rb
 - lib/skn_utils/lists/linked_list.rb
 - lib/skn_utils/nested_result.rb
 - lib/skn_utils/notifier_base.rb
@@ -159,6 +160,7 @@ files:
 - spec/lib/skn_utils/lists/Circular_linked_list_spec.rb
 - spec/lib/skn_utils/lists/doubly_linked_list_spec.rb
 - spec/lib/skn_utils/lists/linked_list_spec.rb
+- spec/lib/skn_utils/lists/node_based_linked_list_spec.rb
 - spec/lib/skn_utils/nested_result_spec.rb
 - spec/lib/skn_utils/notifier_base_spec.rb
 - spec/lib/skn_utils/null_object_spec.rb
@@ -204,6 +206,7 @@ test_files:
 - spec/lib/skn_utils/lists/Circular_linked_list_spec.rb
 - spec/lib/skn_utils/lists/doubly_linked_list_spec.rb
 - spec/lib/skn_utils/lists/linked_list_spec.rb
+- spec/lib/skn_utils/lists/node_based_linked_list_spec.rb
 - spec/lib/skn_utils/nested_result_spec.rb
 - spec/lib/skn_utils/notifier_base_spec.rb
 - spec/lib/skn_utils/null_object_spec.rb