skn_utils 3.3.8 → 3.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f10dfc4c9162c2474d86f6961282a02ab528531
-  data.tar.gz: c569459266e141b396aacec9d1eb03c1b8e6c8c8
+  metadata.gz: a858152ce4dbee2e8d75935809054ce1794e4865
+  data.tar.gz: 81d7e5210977626a919d06b9f43dee354f44e85c
 SHA512:
-  metadata.gz: c03a36fa7b827f1d15b163a1e6729d29b7db4a182047eac5c88ebbcecc8d30528ed37352c33c0f4369aec50c85d83ffd983849c729da647549bc9d8bb4a6218b
-  data.tar.gz: 430b175bc1d8e700a1ae424fe0eabdd8fbb0fa9cdef2979dd24bec04452d97db954a9d74c97c447ad17e3f1a9ce02a6d7df7e8ed921073e06165958c1265c6d4
+  metadata.gz: 31c5cfda536c02ac7a783fc7f9bf45d1bb0f098b5acee96a30ec4312a0121151de5e6886d6d70f0df337f3a09603c634c9fe2ffb11b4283530d3b0c0013dd1a9
+  data.tar.gz: fe52c36f44ad71a09e9d5ea5aac0e973f9c6eabf2b15d7f0b19a98495a5933b8ecba476c172a6646cf33f85378b918ee0ccfe2084be04b9393b724bd139c4222

data/bin/bench_linklists.rb

@@ -54,20 +54,40 @@ Benchmark.ips do |x|
   vargs  = [70, 71, 72, 73, 74, 75, 76, 77, 78, 79]
   cproc  = lambda {|a| a}
 
-  x.report('LinkedList Ops') do
+  x.report('Array Ops') do
+    ary = Array.new(vargs)
+    # adders.each {|x| ary.push(x) }
+    adders.each {|x| ary.insert(5, x) }
+    value = ary.sort!
+    ary.first
+    ary.clear
+  end
+
+  x.report('Single Ops') do
     ll = SknUtils::Lists::LinkedList.new(*vargs, &cproc)
-    adders.each {|x| ll.insert_after(74, x)}
+    # adders.each {|x| ll.insert(x) }
+    adders.each {|x| ll.insert_after(74, x) }
     value = ll.sort!
     ll.first
     ll.clear
   end
 
-  x.report('Array Ops') do
-    ary = Array.new(vargs)
-    adders.each {|x| ary.insert(5, x)}
-    value = ary.sort!
-    ary.first
-    ary.clear
+  x.report('Double Ops') do
+    dll = SknUtils::Lists::DoublyLinkedList.new(*vargs, &cproc)
+    # adders.each {|x| dll.insert(x) }
+    adders.each {|x| dll.insert_after(74, x) }
+    value = dll.sort!
+    dll.first
+    dll.clear
+  end
+
+  x.report('Circulat Ops') do
+    cl = SknUtils::Lists::CircularLinkedList.new(*vargs, &cproc)
+    # adders.each {|x| cl.insert(x) }
+    adders.each {|x| cl.insert_after(74, x) }
+    value = cl.sort!
+    cl.first
+    cl.clear
   end
 
   x.compare!

data/lib/skn_utils/lists/circular_linked_list.rb

@@ -70,6 +70,21 @@ module SknUtils
       #
       # Modifications
       #
+      # return new size
+      def insert(value)
+        node = @current
+        @current = LinkNode.new(value, node, :circle_after, self,  &@match_value)
+        if self.size == 0           # only
+          self.head      =  @current
+          self.tail      =  @current
+        elsif self.tail == node
+          self.tail      =  @current
+          @current.next      = self.head
+          self.head.prev = @current
+        end
+        self.size += 1
+      end
+      alias_method  :append, :insert
 
       # return new size
       def insert_before(position_value, value)
@@ -131,22 +146,8 @@ module SknUtils
         end
       end
 
-
     protected
 
-      def find_by_value(value)
-        return nil if value.nil? || self.size == 0
-        stop_node = self.head
-        target = stop_node
-        rtn_node = nil
-        while !target.match_by_value(value)
-          target = target.next
-          break if stop_node.equal?(target)
-        end
-        target = nil unless target.match_by_value(value)
-        target
-      end
-
       def find_by_index(index)
         return nil if ( index > self.size || index < 1 )
         node = self.head

data/lib/skn_utils/lists/doubly_linked_list.rb

@@ -68,6 +68,16 @@ module SknUtils
       # Modifications
       #
 
+      # return new size
+      def insert(value)
+        node = @current
+        @current = LinkNode.new(value, node, :after, self,  &@match_value)
+        self.head = @current if self.head.nil?
+        self.tail = @current if self.tail.equal?(node)
+        self.size += 1
+      end
+      alias_method  :append, :insert
+
       # return new size
       def insert_before(position_value, value)
         target = find_by_value(position_value)
@@ -116,17 +126,6 @@ module SknUtils
 
     protected
 
-      def find_by_value(value)
-        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
-          target = prior.next
-        end
-        target
-      end
-
       def find_by_index(index)
         return nil if self.head.nil? or index < 1 or index > self.size
         node = self.head

data/lib/skn_utils/lists/link_node.rb

@@ -10,6 +10,10 @@ module SknUtils
 
       attr_accessor :prev, :next, :value
 
+      def self.call(val, anchor_node=nil, strategy=:after, mgr=nil, &cmp_key)
+        self.new(val, anchor_node, strategy, mgr, &cmp_key)
+      end
+
       def initialize(val, anchor_node=nil, strategy=:after, mgr=nil, &cmp_key)
         @value = val
         @prev = nil
@@ -43,7 +47,7 @@ module SknUtils
       end
 
       def match_by_value(other_value)
-        @cmp_proc.call(self.value) === @cmp_proc.call(other_value)
+        @cmp_proc.call(self.value) == @cmp_proc.call(other_value)
       end
 
       # Returns
@@ -77,7 +81,7 @@ module SknUtils
 
       # Reverse API to Parent Linked List Class
       def node_value
-        node_request.value
+        node_value_request(:current)
       end
       def first_node
         node_request(:first)
@@ -95,20 +99,22 @@ module SknUtils
         node_request(:last)
       end
 
-      protected()
-
-      def respond_to_missing?(method, include_private=false)
-        @provider && @provider.protected_methods(true).include?(method) || super
+      # Retrieves requested node, not value
+      def node_request(method_sym=:current, *vargs, &block)
+        block_given? ? @provider.send(method_sym, *vargs, &block) :
+            (vargs.size == 0 ?  @provider.send(method_sym) : @provider.send(method_sym, *vargs))
+        @provider.instance_variable_get(:@current)
+      rescue
+        nil
       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
+      # Retrieves requested value, not node
+      def node_value_request(method_sym=:current, *vargs, &block)
+        position_value = block_given? ? @provider.send(method_sym, *vargs, &block) :
+                             (vargs.size == 0 ?  @provider.send(method_sym) : @provider.send(method_sym, *vargs))
+      rescue
+        nil
       end
+
     end
   end # module
 end

data/lib/skn_utils/lists/linked_commons.rb

@@ -31,7 +31,7 @@ module SknUtils
     class LinkedCommons
       attr_accessor :size
 
-      # Initialize and return first node if nodes are available
+      # Initialize and return first node if nodes are available, else class instance
       def self.call(*vargs, &compare_key_proc)
         target = self.new(*vargs, &compare_key_proc)
         return target.instance_variable_get(:@current) if vargs.size > 1
@@ -103,22 +103,11 @@ module SknUtils
         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
@@ -127,7 +116,7 @@ module SknUtils
       # perform each() or return enumerator
       def each(&block)
         @current = self.head
-        position = self.head
+        position = @current
         if block_given?
           while position do
             block.call( position.value.dup )
@@ -180,6 +169,19 @@ module SknUtils
 
       attr_accessor :head, :tail
 
+      # scan for first occurance of matching value
+      def find_by_value(value)
+        return nil if value.nil? || self.size == 0
+        stop_node = self.head
+        target = stop_node
+        while target && !target.match_by_value(value)
+          target = target.next
+          break if stop_node.equal?(target)
+        end
+        target = nil unless target && target.match_by_value(value)
+        target
+      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)
@@ -203,18 +205,6 @@ module SknUtils
         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

@@ -56,10 +56,19 @@ module SknUtils
       # Modifications
       #
 
+      def insert(value)
+        node = @current
+        @current = LinkNode.call(value, node, :single, self,  &@match_value)
+        self.head = @current if self.head.nil?
+        self.tail = @current if self.tail.equal?(node)
+        self.size += 1
+      end
+      alias_method  :append, :insert
+
       # return new size
       def insert_before(position_value, value)
         prior, target = find_by_value(position_value)
-        node = LinkNode.new(value, prior, :single, self,  &@match_value)
+        node = LinkNode.call(value, prior, :single, self,  &@match_value)
         node.next = target if target
         self.head = node if self.head.equal?(target)
         self.tail = node if self.tail.nil?
@@ -70,7 +79,7 @@ module SknUtils
       # return new size
       def insert_after(position_value, value)
         prior, target = find_by_value(position_value)
-        node = LinkNode.new(value, target, :single, self,  &@match_value)
+        node = LinkNode.call(value, target, :single, self,  &@match_value)
         self.head = node if self.head.nil?
         self.tail = node if self.tail.equal?(target)
         @current = node
@@ -93,10 +102,9 @@ module SknUtils
         return [@current, nil] if self.head.nil? || value.nil?
         prior  = self.head
         target = prior
-        while target and not target.match_by_value(value)
+        while target && !target.match_by_value(value)
           prior = target
           target = target.next
-          @current = prior if target
         end
         [prior, target]
       end

data/lib/skn_utils/version.rb

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

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

@@ -5,7 +5,7 @@
 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} }
+    let(:node) { described_class.call(10, 20, 30, 40, 50, 60, 60, 70, 80, 90, 100) {|a| a} }
 
     context "Node Retrieval " do
 
@@ -55,6 +55,7 @@ RSpec.describe SknUtils::Lists::DoublyLinkedList, "DoublyLinkedList using node i
         end
 
         expect(nav_ary).to eq(node.node_value_request(:to_a))
+        expect(nav_ary).to eq([10, 20, 30, 40, 50, 60, 60, 70, 80, 90, 100])
       end
     end
 

data/spec/support/shared_examples_for_linked_list.rb

@@ -120,8 +120,8 @@ RSpec.shared_examples "a linked list" do |list_type|
   context "Sort Feature" do
     let(:num_list)   { described_class.new(100, 50, 10, 40, 80, 30, 60, 90, 70, 20, 110) }
     let(:alpha_list) { described_class.new('Z', 'K', 'S', 'n', 's', 'z', 'k', 'N', 'o', 'A') }
-    let(:hash_list)  { described_class.new({key: 'Z'}, {key: 'K'}, {key: 'S'}, {key: 'n'}, {key: 's'},
-                                           {key: 'z'}, {key: 'k'}, {key: 'N'}, {key: 'o'}, {key: 'A'}
+    let(:hash_list)  { described_class.new({key: 'Z'}, {key: 'K'}, {key: 'S'}, {:key=>"S"}, {key: 'n'}, {key: 's'},
+                                           {key: 'z'}, {key: 'k'}, {key: 'N'}, {key: 'A'}
                                           ) {|a| a[:key]}
     }
 
@@ -143,13 +143,13 @@ RSpec.shared_examples "a linked list" do |list_type|
     end
     it "#sort!() redefines hash object values in default order" do
       expect(hash_list.sort!).to eq(10)
-      expect(hash_list.to_a).to eq([{:key=>"A"}, {:key=>"K"}, {:key=>"N"}, {:key=>"S"}, {:key=>"Z"},
-                                    {:key=>"k"}, {:key=>"n"}, {:key=>"o"}, {:key=>"s"}, {:key=>"z"}])
+      expect(hash_list.to_a).to eq([{:key=>"A"}, {:key=>"K"}, {:key=>"N"}, {:key=>"S"}, {:key=>"S"}, {:key=>"Z"},
+                                    {:key=>"k"}, {:key=>"n"}, {:key=>"s"}, {:key=>"z"}])
     end
     it "#sort!() lambda overrides sort_condifiton and sorts hash object values in custom order" do
       expect(hash_list.sort!() {|a,b| a[:key] <= b[:key] }).to eq(10)
-      expect(hash_list.to_a).to eq([{:key=>"z"}, {:key=>"s"}, {:key=>"o"}, {:key=>"n"}, {:key=>"k"},
-                                    {:key=>"Z"}, {:key=>"S"}, {:key=>"N"}, {:key=>"K"}, {:key=>"A"}])
+      expect(hash_list.to_a).to eq([{:key=>"z"}, {:key=>"s"}, {:key=>"n"}, {:key=>"k"},
+                                    {:key=>"Z"}, {:key=>"S"}, {:key=>"S"}, {:key=>"N"}, {:key=>"K"}, {:key=>"A"}])
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skn_utils
 version: !ruby/object:Gem::Version
-  version: 3.3.8
+  version: 3.3.9
 platform: ruby
 authors:
 - James Scott Jr
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-17 00:00:00.000000000 Z
+date: 2017-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_merge