skn_utils 3.3.1 → 3.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb741d6ef4692e94ee1f7649bc655bdac1fcc068
-  data.tar.gz: da995ac562de18cea5b4c8950e6ae37349926947
+  metadata.gz: d2f654cc636fb8d2694432b991fc8c145dd81d01
+  data.tar.gz: 3f7a28e3be152907b0b25949a371855cb739de2b
 SHA512:
-  metadata.gz: 0c9c7ce7644387a73836ceb91fa9efd184c65e0ad8ca35702be2539d94aff52edaac42b579fa18eb7a858d3283d6fd103c27aabf6210f5d8b2b0419052a9e4c3
-  data.tar.gz: 5623acf078e653111cc05a56e5a195758e9ef8908722a71ae3ac8a1ba31340fcbbe204ae9612a8140540863d4765dd4cd21d6b4fc9473ae7ee1c7dd1cf8b5d4f
+  metadata.gz: e5e65ca3ada647ad23c5a26d224b025b2e14a00e63e0f15d2ce35823c7df69e77720d43fa53c40af0abf6e5297346c98b321dd2bc244f20ed012b3633296a8bf
+  data.tar.gz: e68c4b224458eb5aa669fd776177c433812705e54006f0fcf12c5b122d1f4a1b9ba1f9fc5744800cb83d158bdb587492ac2eebf88fb4fedf848afe3115afb630

data/lib/skn_utils/lists/circular_linked_list.rb

@@ -7,13 +7,18 @@ module SknUtils
     class CircularLinkedList
       attr_accessor :size
 
-      def initialize(*values)
+      def initialize(*vargs, &block)
         @current = nil
         @head = nil
         @tail = nil
         @size = 0
-        values.each {|value| insert(value) }
-        first if values.size > 1
+
+        @sort_ascending  = lambda {|a_obj,b_obj| a_obj >= b_obj}
+        @sort_descending = lambda {|a_obj,b_obj| a_obj <= b_obj}
+        @sort_condition  = block_given? ? block : @sort_ascending
+
+        vargs.each {|value| insert(value) }
+        first if vargs.size > 1
       end
 
       #
@@ -189,6 +194,25 @@ module SknUtils
         result
       end
 
+      # block format: sort condition : {|a_obj,b_obj| a_obj >= b_obj}
+      def sort!(direction_sym=:default, &block)
+        active_sort_condition = block_given? ? block :
+                                    (
+                                    case direction_sym
+                                      when :asc
+                                        @sort_ascending
+                                      when :desc
+                                        @sort_descending
+                                      else
+                                        @sort_condition
+                                    end
+                                    )
+        sorted = merge_sort(to_a, active_sort_condition)
+        clear
+        sorted.each {|item| insert(item) }
+        size
+      end
+
     private
 
       attr_accessor :head, :tail
@@ -213,6 +237,35 @@ 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, sort_cond)
+        return arr if arr.size < 2
+
+        middle = arr.size / 2
+
+        left = merge_sort(arr[0...middle], sort_cond)
+        right = merge_sort(arr[middle..arr.size], sort_cond)
+
+        merge(left, right, sort_cond)
+      end
+
+      def merge(left, right, sort_cond)
+        sorted = []
+
+        while left.any? && right.any?
+
+          if sort_cond.call(left.first, right.first)  # replace this condition with a proc
+            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

@@ -8,13 +8,18 @@ module SknUtils
     class DoublyLinkedList
       attr_accessor :size
 
-      def initialize(*values)
+      def initialize(*vargs, &block)
         @current = nil
         @head = nil
         @tail = nil
         @size = 0
-        values.each {|value| insert(value) }
-        first if values.size > 1
+
+        @sort_ascending  = lambda {|a_obj,b_obj| a_obj >= b_obj}
+        @sort_descending = lambda {|a_obj,b_obj| a_obj <= b_obj}
+        @sort_condition  = block_given? ? block : @sort_ascending
+
+        vargs.each {|value| insert(value) }
+        first if vargs.size > 1
       end
 
       #
@@ -187,6 +192,25 @@ module SknUtils
         result
       end
 
+      # block format: sort condition : {|a_obj,b_obj| a_obj >= b_obj}
+      def sort!(direction_sym=:default, &block)
+        active_sort_condition = block_given? ? block :
+                                    (
+                                    case direction_sym
+                                      when :asc
+                                        @sort_ascending
+                                      when :desc
+                                        @sort_descending
+                                      else
+                                        @sort_condition
+                                    end
+                                    )
+        sorted = merge_sort(to_a, active_sort_condition)
+        clear
+        sorted.each {|item| insert(item) }
+        size
+      end
+
     private
 
       attr_accessor :head, :tail
@@ -211,6 +235,35 @@ 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, sort_cond)
+        return arr if arr.size < 2
+
+        middle = arr.size / 2
+
+        left = merge_sort(arr[0...middle], sort_cond)
+        right = merge_sort(arr[middle..arr.size], sort_cond)
+
+        merge(left, right, sort_cond)
+      end
+
+      def merge(left, right, sort_cond)
+        sorted = []
+
+        while left.any? && right.any?
+
+          if sort_cond.call(left.first, right.first)  # replace this condition with a proc
+            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/linked_list.rb

@@ -8,13 +8,19 @@ module SknUtils
     class LinkedList
       attr_accessor :size
 
-      def initialize(*values)
+      def initialize(*vargs, &block)
+        @sort_condition = nil
         @current = nil
         @head = nil
         @tail = nil
         @size = 0
-        values.each {|value| insert(value) }
-        first if values.size > 1
+
+        @sort_ascending  = lambda {|a_obj,b_obj| a_obj >= b_obj}
+        @sort_descending = lambda {|a_obj,b_obj| a_obj <= b_obj}
+        @sort_condition  = block_given? ? block : @sort_ascending
+
+        vargs.each {|value| insert(value) }
+        first if vargs.size > 1
       end
 
       #
@@ -171,6 +177,24 @@ module SknUtils
         result
       end
 
+      # block format: sort condition : {|a_obj,b_obj| a_obj >= b_obj}
+      def sort!(direction_sym=:default, &block)
+        active_sort_condition = block_given? ? block :
+                                     case direction_sym
+                                       when :asc
+                                         @sort_ascending
+                                       when :desc
+                                         @sort_descending
+                                       else
+                                         @sort_condition
+                                     end
+
+        sorted = merge_sort(to_a, active_sort_condition)
+        clear
+        sorted.each {|item| insert(item) }
+        size
+      end
+
     private
 
       attr_accessor :head, :tail
@@ -195,6 +219,35 @@ 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, sort_cond)
+        return arr if arr.size < 2
+
+        middle = arr.size / 2
+
+        left = merge_sort(arr[0...middle], sort_cond)
+        right = merge_sort(arr[middle..arr.size], sort_cond)
+
+        merge(left, right, sort_cond)
+      end
+
+      def merge(left, right, sort_cond)
+        sorted = []
+
+        while left.any? && right.any?
+
+          if sort_cond.call(left.first, right.first)  # replace this condition with a proc
+            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 = 1
+    PATCH = 2
 
     def self.to_s
       [MAJOR, MINOR, PATCH].join('.')

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

@@ -236,7 +236,42 @@ RSpec.describe SknUtils::Lists::CircularLinkedList, "Circular LinkedList " do
       expect(only.nth(1)).to be nil
       expect(only.nth(-1)).to be nil
     end
+  end
+
+  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'}
+    ) {|a,b| a[:key] >= b[:key] }
+    }
 
+    it "#sort! redefines numeric list in asending order" do
+      expect(num_list.sort!).to eq(11)
+      expect(num_list.to_a).to eq([10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110])
+    end
+    it "#sort!(:desc) redefines numeric list in descending order" do
+      expect(num_list.sort!(:desc)).to eq(11)
+      expect(num_list.to_a).to eq([110, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10])
+    end
+    it "#sort! redefines alpha numeric list in asending order" do
+      expect(alpha_list.sort!).to eq(10)
+      expect(alpha_list.to_a).to eq(["A", "K", "N", "S", "Z", "k", "n", "o", "s", "z"])
+    end
+    it "#sort!(:desc) redefines alpha numeric list in descending order" do
+      expect(alpha_list.sort!(:desc)).to eq(10)
+      expect(alpha_list.to_a).to eq(["z", "s", "o", "n", "k", "Z", "S", "N", "K", "A"])
+    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"}])
+    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"}])
+    end
   end
 
 end

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

@@ -236,7 +236,42 @@ RSpec.describe SknUtils::Lists::DoublyLinkedList, "Double-Ended LinkedList " do
       expect(only.nth(1)).to be nil
       expect(only.nth(-1)).to be nil
     end
+  end
+
+  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'}
+    ) {|a,b| a[:key] >= b[:key] }
+    }
 
+    it "#sort! redefines numeric list in asending order" do
+      expect(num_list.sort!).to eq(11)
+      expect(num_list.to_a).to eq([10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110])
+    end
+    it "#sort!(:desc) redefines numeric list in descending order" do
+      expect(num_list.sort!(:desc)).to eq(11)
+      expect(num_list.to_a).to eq([110, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10])
+    end
+    it "#sort! redefines alpha numeric list in asending order" do
+      expect(alpha_list.sort!).to eq(10)
+      expect(alpha_list.to_a).to eq(["A", "K", "N", "S", "Z", "k", "n", "o", "s", "z"])
+    end
+    it "#sort!(:desc) redefines alpha numeric list in descending order" do
+      expect(alpha_list.sort!(:desc)).to eq(10)
+      expect(alpha_list.to_a).to eq(["z", "s", "o", "n", "k", "Z", "S", "N", "K", "A"])
+    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"}])
+    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"}])
+    end
   end
 
 end

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

@@ -229,7 +229,42 @@ RSpec.describe SknUtils::Lists::LinkedList, "Singular LinkedList " do
       expect(only.nth(1)).to be nil
       expect(only.nth(-1)).to be nil
     end
+  end
+
+  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'}
+    ) {|a,b| a[:key] >= b[:key] }
+    }
 
+    it "#sort! redefines numeric list in asending order" do
+      expect(num_list.sort!).to eq(11)
+      expect(num_list.to_a).to eq([10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110])
+    end
+    it "#sort!(:desc) redefines numeric list in descending order" do
+      expect(num_list.sort!(:desc)).to eq(11)
+      expect(num_list.to_a).to eq([110, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10])
+    end
+    it "#sort! redefines alpha numeric list in asending order" do
+      expect(alpha_list.sort!).to eq(10)
+      expect(alpha_list.to_a).to eq(["A", "K", "N", "S", "Z", "k", "n", "o", "s", "z"])
+    end
+    it "#sort!(:desc) redefines alpha numeric list in descending order" do
+      expect(alpha_list.sort!(:desc)).to eq(10)
+      expect(alpha_list.to_a).to eq(["z", "s", "o", "n", "k", "Z", "S", "N", "K", "A"])
+    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"}])
+    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"}])
+    end
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: skn_utils
 version: !ruby/object:Gem::Version
-  version: 3.3.1
+  version: 3.3.2
 platform: ruby
 authors:
 - James Scott Jr