skn_utils 3.5.2 → 3.6.0

data/spec/lib/skn_utils/exploring/configuration_spec.rb

@@ -1,52 +0,0 @@
-##
-# spec/lib/skn_utils/exploring/configuration_spec.rb
-#
-
-describe "Gem Configuration Example." do
-
-  let!(:subject) { SknUtils::Exploring::Configuration }
-
-
-  context "Initializers Feature. " do
-    before(:each) do
-      subject.reset!
-    end
-
-    it "#configure can be called without a block." do
-      expect( subject.configure ).to be_a(SknUtils::Exploring::Configuration::Options)
-    end
-
-    it "#configure can be called with a block." do
-      expect( subject.configure() {|c| c.one = 'One'} ).to be_a(SknUtils::Exploring::Configuration::Options)
-    end
-
-    it "#reset! allows new defaults to be applied." do
-      subject.option_defaults = {four: 4, five: 5, six: 6}
-      subject.reset!
-      expect( subject.config.five ).to eq(5)
-      subject.option_defaults = nil # remove prior defaults
-      subject.reset!
-      expect( subject.config.one ).to eq(1)
-    end
-
-  end
-
-  context "Runtime Features. " do
-    before(:each) do
-      subject.reset!
-    end
-
-    it "#config returns the selected value." do
-      subject.config.one = 1
-      expect( subject.config.one ).to eq(1)
-    end
-
-    it "#config overrides the selected value." do
-      subject.config.three = 12
-      expect( subject.config.three ).to eq(12)
-    end
-
-  end
-
-
-end

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

@@ -1,184 +0,0 @@
-##
-# spec/lib/skn_utils/circular_linked_list_spec.rb
-#
-
-require "support/shared_examples_for_linked_list"
-
-RSpec.describe SknUtils::Lists::CircularLinkedList, "Circular LinkedList " do
-
-  it_behaves_like "a linked list", 'circular'
-
-  context "CircularLinkedList Specific" do
-
-    context "Navigation" do
-      let(:list) { described_class.new(10,20, 30, 40, 50, 60, 70, 80, 90, 100) }
-
-      it "#prev returns the prior value" do
-        expect(list.prev).to eq(100)
-      end
-      it "#nth(6) returns the sixth value" do
-        expect(list.nth(6)).to eq(60)
-        expect(list.nth(-2)).to eq(40)
-      end
-      it "#at_index(6) returns the sixth value" do
-        expect(list.at_index(6)).to eq(60)
-      end
-    end
-
-    context "Edge cases " do
-      let(:list) { described_class.new(10,20, 30, 40, 50, 60, 70, 80, 90, 100) }
-
-      it "#at_index(-999) fails and returns the current element. " do
-        expect(list.at_index(-999)).to eq(10)
-      end
-      it "#at_index(0) fails and returns the current element. " do
-        expect(list.at_index(0)).to eq(10)
-      end
-      it "#at_index(999) fails and returns the current element. " do
-        expect(list.at_index(999)).to eq(10)
-      end
-      it "#at_index(n) returns the proper element. " do
-        expect(list.at_index(1)).to eq(10)
-        expect(list.at_index(list.size / 2)).to eq(50)
-        expect(list.at_index(list.size)).to eq(100)
-      end
-      it "#at_index(n) returns the proper element for linkedlist with one element. " do
-        only = described_class.new(55)
-        expect(only.at_index(1)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-        expect(only.at_index(10)).to eq(55)
-      end
-
-      it "#nth(-999) fails and returns current value." do
-        expect(list.nth(-999)).to eq(10)
-      end
-      it "#nth(0) fails and returns current value." do
-        expect(list.nth(0)).to eq(10)
-      end
-      it "#nth(999) fails and returns current value." do
-        expect(list.nth(999)).to eq(10)
-      end
-
-      it "#current equals first initialization value." do
-        expect(list.current).to eq(10)
-      end
-      it "#next after initialization returns correctly. " do
-        expect(list.next).to eq(20)
-        expect(list.next).to eq(30)
-        expect(list.next).to eq(40)
-      end
-      it "#prev after first returns proper sequence of values. " do
-        expect(list.first).to eq(10)
-        expect(list.prev).to eq(100)
-        expect(list.prev).to eq(90)
-      end
-
-      it "#first, #next, #current, #prev, #nth, and #last return same value when size == 1. " do
-        only = described_class.new(55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.prev).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#first, #next, #current, #prev, #nth, and #last return nil value when size == 0. " do
-        only = described_class.new
-        expect(only.first).to be nil
-        expect(only.next).to be nil
-        expect(only.prev).to be nil
-        expect(only.last).to be nil
-        expect(only.current).to be nil
-        expect(only.nth(2)).to be nil
-        expect(only.at_index(2)).to be nil
-      end
-      it "#prepend enables navigation methods normal operations. " do
-        only = described_class.new
-        only.prepend(55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.prev).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#append enables navigation methods normal operations. " do
-        only = described_class.new
-        only.append(55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.prev).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#insert_before enables navigation methods normal operations. " do
-        only = described_class.new
-        only.insert_before(nil, 55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.prev).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#insert_after enables navigation methods normal operations. " do
-        only = described_class.new
-        only.insert_after(nil, 55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.prev).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#remove does not make navigation methods unstable when removing 2:2. " do
-        only = described_class.new(55,60)
-        only.remove(60)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#remove does not make navigation methods unstable when removing 1:2. " do
-        only = described_class.new(55,60)
-        only.remove(55)
-        expect(only.first).to eq(60)
-        expect(only.next).to eq(60)
-        expect(only.last).to eq(60)
-        expect(only.current).to eq(60)
-        expect(only.nth(2)).to eq(60)
-        expect(only.at_index(2)).to eq(60)
-      end
-      it "#remove does not make navigation methods unstable if empty?. " do
-        only = described_class.new(55)
-        only.remove(55)
-        expect(only.first).to be nil
-        expect(only.next).to be nil
-        expect(only.last).to be nil
-        expect(only.current).to be nil
-        expect(only.nth(2)).to be nil
-        expect(only.at_index(2)).to be nil
-      end
-      it "#remove does not make navigation methods unstable when target not found. " do
-        only = described_class.new(55)
-        only.remove(20)
-        expect(only.to_a).to eq([55])
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-    end
-  end
-
-end

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

@@ -1,182 +0,0 @@
-##
-# spec/lib/skn_utils/doubly_linked_list_spec.rb
-#
-
-require "support/shared_examples_for_linked_list"
-
-RSpec.describe SknUtils::Lists::DoublyLinkedList, "Double-Ended LinkedList " do
-
-  it_behaves_like "a linked list", 'double'
-
-  context "DoublyLinkedList Specific" do
-
-    context "Navigation" do
-      let(:list) { described_class.new(10,20, 30, 40, 50, 60, 70, 80, 90, 100) }
-
-      it "#prev returns the prior value" do
-        expect(list.prev).to eq(10)
-      end
-      it "#nth(6) returns the sixth value" do
-        expect(list.nth(6)).to eq(60)
-        expect(list.nth(-2)).to eq(40)
-      end
-      it "#at_index(6) returns the sixth value" do
-        expect(list.at_index(6)).to eq(60)
-      end
-    end
-
-    context "Edge cases " do
-      let(:list) { described_class.new(10,20, 30, 40, 50, 60, 70, 80, 90, 100) }
-
-      it "#at_index(-999) fails and returns the current element. " do
-        expect(list.at_index(-999)).to eq(10)
-      end
-      it "#at_index(0) fails and returns the current element. " do
-        expect(list.at_index(0)).to eq(10)
-      end
-      it "#at_index(999) fails and returns the current element. " do
-        expect(list.at_index(999)).to eq(10)
-      end
-      it "#at_index(n) returns the proper element. " do
-        expect(list.at_index(1)).to eq(10)
-        expect(list.at_index(list.size / 2)).to eq(50)
-        expect(list.at_index(list.size)).to eq(100)
-      end
-      it "#at_index(n) returns the proper element for linkedlist with one element. " do
-        only = described_class.new(55)
-        expect(only.at_index(1)).to eq(55)
-        expect(only.at_index(10)).to eq(55)
-        expect(only.at_index(-10)).to eq(55)
-      end
-
-      it "#nth(-999) returns first initialization value." do
-        expect(list.nth(-999)).to eq(10)
-      end
-      it "#nth(0) returns current value, or last initialization value." do
-        expect(list.nth(0)).to eq(10)
-      end
-      it "#nth(999) returns last initialization value." do
-        expect(list.nth(999)).to eq(100)
-      end
-      it "#current equals first initialization value." do
-        expect(list.current).to eq(10)
-      end
-      it "#next after initialization equals last initialization value. " do
-        expect(list.next).to eq(20)
-        expect(list.next).to eq(30)
-        expect(list.next).to eq(40)
-      end
-      it "#prev after first returns first value repeatably. " do
-        expect(list.first).to eq(10)
-        expect(list.prev).to eq(10)
-        expect(list.prev).to eq(10)
-      end
-      it "#first, #next, #current, #prev, #nth, and #last return same value after initialization with one value. " do
-        only = described_class.new(55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.prev).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(1)).to eq(55)
-        expect(only.nth(11)).to eq(55)
-      end
-      it "#first, #next, #current, #prev, #nth, and #last return same value after initialization with no values. " do
-        only = described_class.new
-        expect(only.first).to be nil
-        expect(only.next).to be nil
-        expect(only.prev).to be nil
-        expect(only.last).to be nil
-        expect(only.current).to be nil
-        expect(only.nth(1)).to be nil
-        expect(only.nth(-1)).to be nil
-      end
-      it "#prepend enables navigation methods normal operations. " do
-        only = described_class.new
-        only.prepend(55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.prev).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(1)).to eq(55)
-        expect(only.nth(11)).to eq(55)
-      end
-      it "#append enables navigation methods normal operations. " do
-        only = described_class.new
-        only.append(55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.prev).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(1)).to eq(55)
-        expect(only.nth(11)).to eq(55)
-      end
-      it "#insert_before enables navigation methods normal operations. " do
-        only = described_class.new
-        only.insert_before(nil, 55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.prev).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(1)).to eq(55)
-        expect(only.nth(11)).to eq(55)
-      end
-      it "#insert_after enables navigation methods normal operations. " do
-        only = described_class.new
-        only.insert_after(nil, 55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.prev).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(1)).to eq(55)
-        expect(only.nth(11)).to eq(55)
-      end
-      it "#remove does not make navigation methods unstable when removing 2:2. " do
-        only = described_class.new(55,60)
-        only.remove(60)
-        expect(only.to_a).to eq([55])
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#remove does not make navigation methods unstable when removing 1:2. " do
-        only = described_class.new(55,60)
-        only.remove(55)
-        expect(only.first).to eq(60)
-        expect(only.next).to eq(60)
-        expect(only.last).to eq(60)
-        expect(only.current).to eq(60)
-        expect(only.nth(2)).to eq(60)
-        expect(only.at_index(2)).to eq(60)
-      end
-      it "#remove does not make navigation methods unstable if empty?. " do
-        only = described_class.new(55)
-        only.remove(55)
-        expect(only.first).to be nil
-        expect(only.next).to be nil
-        expect(only.last).to be nil
-        expect(only.current).to be nil
-        expect(only.nth(2)).to be nil
-        expect(only.at_index(2)).to be nil
-      end
-      it "#remove does not make navigation methods unstable when target not found. " do
-        only = described_class.new(55)
-        only.remove(20)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-    end
-  end
-
-end

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

@@ -1,155 +0,0 @@
-##
-# spec/lib/skn_utils/linked_list_spec.rb
-#
-
-require "support/shared_examples_for_linked_list"
-
-RSpec.describe SknUtils::Lists::LinkedList, "Singular LinkedList " do
-
-  it_behaves_like "a linked list", 'single'
-
-  context "LinkedList Specific" do
-
-    context "Edge cases " do
-      let(:list) { described_class.new(10,20, 30, 40, 50, 60, 70, 80, 90, 100) }
-
-      it "#at_index(-999) fails and returns the current element. " do
-        expect(list.at_index(-999)).to eq(10)
-      end
-      it "#at_index(0) fails and returns the current element. " do
-        expect(list.at_index(0)).to eq(10)
-      end
-      it "#at_index(999) fails and returns the current element. " do
-        expect(list.at_index(999)).to eq(10)
-      end
-      it "#at_index(n) returns the proper element. " do
-        expect(list.at_index(1)).to eq(10)
-        expect(list.at_index(list.size / 2)).to eq(50)
-        expect(list.at_index(list.size)).to eq(100)
-      end
-      it "#at_index(n) returns the proper element for linkedlist with one element. " do
-        only = described_class.new(55)
-        expect(only.at_index(1)).to eq(55)
-        expect(only.at_index(10)).to eq(55)
-        expect(only.at_index(-10)).to eq(55)
-      end
-
-      it "#nth(-9) returns first value because backward movement is not supported" do
-        expect(list.nth(-9)).to eq(10)
-      end
-      it "#nth(0) returns current value." do
-        expect(list.nth(0)).to eq(10)
-      end
-      it "#nth(999) returns last value." do
-        expect(list.nth(999)).to eq(100)
-      end
-      it "#current equals first value." do
-        expect(list.current).to eq(10)
-      end
-      it "#next after initialization returns proper order. " do
-        expect(list.next).to eq(20)
-        expect(list.next).to eq(30)
-        expect(list.next).to eq(40)
-      end
-      it "#first, #next, #current, #nth, and #last return same  value when size eq 1. " do
-        only = described_class.new(55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#first, #next, #current, #nth, #at_index, and #last return same value when size eq 0. " do
-        only = described_class.new
-        expect(only.first).to be nil
-        expect(only.next).to be nil
-        expect(only.last).to be nil
-        expect(only.current).to be nil
-        expect(only.nth(2)).to be nil
-        expect(only.at_index(2)).to be nil
-      end
-      it "#prepend enables navigation methods normal operations. " do
-        only = described_class.new
-        only.prepend(55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#append enables navigation methods normal operations. " do
-        only = described_class.new
-        only.append(55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#insert_before enables navigation methods normal operations. " do
-        only = described_class.new
-        only.insert_before(nil, 55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#insert_after enables navigation methods normal operations. " do
-        only = described_class.new
-        only.insert_after(nil, 55)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#remove does not make navigation methods unstable when removing 2:2. " do
-        only = described_class.new(55,60)
-        only.remove(60)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-      it "#remove does not make navigation methods unstable when removing 1:2. " do
-        only = described_class.new(55,60)
-        only.remove(55)
-        expect(only.first).to eq(60)
-        expect(only.next).to eq(60)
-        expect(only.last).to eq(60)
-        expect(only.current).to eq(60)
-        expect(only.nth(2)).to eq(60)
-        expect(only.at_index(2)).to eq(60)
-      end
-      it "#remove does not make navigation methods unstable if empty?. " do
-        only = described_class.new(55)
-        only.remove(55)
-        expect(only.first).to be nil
-        expect(only.next).to be nil
-        expect(only.last).to be nil
-        expect(only.current).to be nil
-        expect(only.nth(2)).to be nil
-        expect(only.at_index(2)).to be nil
-      end
-      it "#remove does not make navigation methods unstable when target not found. " do
-        only = described_class.new(55)
-        only.remove(20)
-        expect(only.first).to eq(55)
-        expect(only.next).to eq(55)
-        expect(only.last).to eq(55)
-        expect(only.current).to eq(55)
-        expect(only.nth(2)).to eq(55)
-        expect(only.at_index(2)).to eq(55)
-      end
-    end
-  end
-
-end

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

@@ -1,86 +0,0 @@
-##
-# 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, 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))
-        expect(nav_ary).to eq([10, 20, 30, 40, 50, 60, 60, 70, 80, 90, 100])
-      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