skn_utils 3.2.1 → 3.3.0

data/lib/skn_utils/lists/linked_list.rb

@@ -0,0 +1,199 @@
+
+module SknUtils
+  module Lists
+    # Singly Linked List
+    # Forward or #next navigation only
+    # Head is absolute via #first
+    # Tail when (next == nil)
+    class LinkedList
+      attr_accessor :size
+
+      def initialize(*values)
+        @current = nil
+        @head = nil
+        @tail = nil
+        @size = 0
+        values.each {|value| insert(value) }
+      end
+
+      #
+      # 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
+        while index > 1 and node and node.next
+          node = node.next
+          index -= 1
+          @current = node
+        end
+        # no reverse or prev for Single List
+        current
+      rescue NoMethodError
+        nil
+      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)
+        node.next = target if target
+        self.head = node if head === target
+        self.tail = node if tail.nil?
+        @current = node
+        self.size += 1
+      end
+
+      # return new size
+      def insert_after(position_value, value)
+        prior, target = find_by_value(position_value)
+        node = LinkNode.new(value, target, :single)
+        self.head = node if head.nil?
+        self.tail = node if tail === target
+        @current = node
+        self.size += 1
+      end
+
+      # return remaining size
+      def remove(value)
+        @current, target_node = find_by_value(value)
+        @current.next = target_node.remove!
+        tail = @current.next if tail === target_node
+        head = @current if 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
+            yield position.value.dup
+            position = position.next
+          end
+        else
+          Enumerator.new do |yielder, val|
+            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
+
+    private
+
+      attr_accessor :head, :tail
+
+      def find_by_value(value)
+        return [nil,nil] if head.nil?
+        prior = head
+        target = prior
+        while not target.match_by_value(value)
+          prior = target
+          target = prior.next
+          @current = target if target
+        end
+        [prior, target]
+      end
+
+      def find_by_index(index)
+        return nil if head.nil? or index < 1 or index > size
+        node = head
+        node = node.next while ((index -= 1) > 0 and node.next)
+        @current = node if node
+        node
+      end
+
+    end # end class
+  end # end module
+end # end module

data/lib/skn_utils/notifier_base.rb

@@ -23,16 +23,16 @@ module SknUtils
     def self.attribute(*attrs)
       attrs.each do |attr|
         instance_variable_set("@#{attr}", nil)
-        define_method(attr) {
+        define_method(attr) do
           instance_variable_get("@#{attr}")
-        }
+        end
         define_method("#{attr}=") do |value|
           old_value = instance_variable_get("@#{attr}")
           return if (value == old_value)
-          @listeners.each { |listener|
-            listener.attribute_changed(attr, old_value, value)
-          }
           instance_variable_set("@#{attr}", value)
+          @listeners.each do |listener|
+            listener.attribute_changed(attr, old_value, value)
+          end
         end
       end # loop on attrs
     end # end of attribute method

data/lib/skn_utils/version.rb

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

data/lib/skn_utils.rb

@@ -5,6 +5,10 @@ require 'skn_utils/page_controls'
 require 'skn_utils/null_object'
 require 'skn_utils/notifier_base'
 require 'skn_utils/skn_configuration'
+require 'skn_utils/lists/link_node'
+require 'skn_utils/lists/linked_list'
+require 'skn_utils/lists/doubly_linked_list'
+require 'skn_utils/lists/circular_linked_list'
 require 'skn_utils/exploring/commander'
 require 'skn_utils/exploring/action_service'
 require 'psych'

data/skn_utils.gemspec

@@ -13,7 +13,7 @@ SknUtils contains a small collection of Ruby utilities, the first being a Nested
 EOF
 
   spec.description   = <<-EOF
-The intent of the NestedResult class is to be a container of data results or key/value pairs, 
+The intent of the NestedResult class is to be a container for data values composed of key/value pairs, 
 with easy access to its contents, and on-demand transformation back to the hash (#to_hash).
 
 Review the RSpec tests, and or review the README for more details.
@@ -24,13 +24,6 @@ SknUtils::NestedResult class.  SknUtils::NestedResult replaces those original cl
 
 Please update your existing code in consideration of the above change, or use the prior version 2.0.6.
 
-ATTENTION: **************************************************************** 
-    This version may require the following be added to your Rails Application 'Gemfile',
-    if you are using the SknSettings configuration class.
-
-    gem 'deep_merge', '~> 1.1'
-
-    ************************************************************************
 EOF
   spec.homepage      = "https://github.com/skoona/skn_utils"
   spec.license       = "MIT"

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

@@ -0,0 +1,242 @@
+##
+# spec/lib/skn_utils/circular_linked_list_spec.rb
+#
+
+RSpec.describe SknUtils::Lists::CircularLinkedList, "Circular LinkedList " do
+
+  context "Initialization" do
+    it "can be initialized without params" do
+      expect(subject).to be
+    end
+    it "can insert the first value" do
+      expect(subject.empty?).to be true
+      expect(subject.insert(101)).to eq(1)
+    end
+    it "can be cleared" do
+      subject.insert(101)
+      expect(subject.clear).to eq(1)
+    end
+    it "can be initialized with one or more initial values" do
+      list = described_class.new(10,100,100)
+      expect(list.current).to eq(100)
+    end
+    it "is initially empty?" do
+      expect(subject.empty?).to be true
+    end
+  end
+
+  context "Navigation" do
+    let(:list) { described_class.new(10,20, 30, 40, 50, 60, 70, 80, 90, 100) }
+
+    it "#first returns the first value" do
+      expect(list.first).to eq(10)
+    end
+    it "#next returns the second value" do
+      expect(list.first).to eq(10)
+      expect(list.next).to eq(20)
+    end
+    it "#current returns the last value as a side-effect of initialization via new" do
+      expect(list.current).to eq(100)
+    end
+    it "#prev returns the prior value" do
+      expect(list.prev).to eq(90)
+    end
+    it "#last returns the last value" do
+      expect(list.last).to eq(100)
+    end
+    it "#nth(6) returns the sixth value" do
+      expect(list.first).to eq(10)
+      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 "Insertions" do
+    it "#insert(value) indicates a value was added" do
+      bsize = subject.size
+      expect(subject.insert(110)).to eq(bsize + 1)
+    end
+    it "#prepend(value) indicates a value was added" do
+      bsize = subject.size
+      expect(subject.prepend(110)).to eq(bsize + 1)
+    end
+    it "#append(value) indicates a value was added" do
+      bsize = subject.size
+      expect(subject.append(110)).to eq(bsize + 1)
+    end
+    it "#insert_before(pvalue,value) indicates a value was added" do
+      subject.insert(120)
+      bsize = subject.size
+      expect(subject.insert_before(120, 110)).to eq(bsize + 1)
+      expect(subject.to_a).to eq([110,120])
+    end
+    it "#insert_after(value) indicates a value was added" do
+      subject.insert(120)
+      bsize = subject.size
+      expect(subject.insert_after(120, 125)).to eq(bsize + 1)
+      expect(subject.to_a).to eq([120,125])
+    end
+  end
+
+  context "Removals" do
+    let(:list) { described_class.new(10,20, 30, 40, 50, 60, 70, 80, 90, 100) }
+
+    it "#remove(value) removes first occurance of that value" do
+      bsize = list.size
+      expect(list.remove(30)).to eq(bsize - 1)
+      expect(list.to_a).to eq([10,20, 40, 50, 60, 70, 80, 90, 100])
+    end
+
+    it "#clear removes all elements from list" do
+      expect(list.clear).to eq(10)
+      expect(list.empty?).to be true
+    end
+  end
+
+  context "Enumeration" do
+    let(:list) { described_class.new(10,20, 30, 40, 50, 60, 70, 80, 90, 100) }
+    it "#each works as expected when block is provided" do
+      x = []
+      list.each {|r| x << r}
+      expect(x).to be_a(Array)
+      expect(x).to eq([10,20, 30, 40, 50, 60, 70, 80, 90, 100])
+    end
+    it "#each works as expected when no block is offered" do
+      expect(list.each).to be_a(Enumerator)
+      expect(list.each.first).to eq(10)
+    end
+    it "#to_a returns the contents of linkedlist as an Array" do
+      base = list.to_a
+      expect(base).to be_a(Array)
+      expect(base).to eq([10,20, 30, 40, 50, 60, 70, 80, 90, 100])
+    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(100)
+    end
+    it "#at_index(0) fails and returns the current element. " do
+      expect(list.at_index(0)).to eq(100)
+    end
+    it "#at_index(999) fails and returns the current element. " do
+      expect(list.at_index(999)).to eq(100)
+    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 wraps to starting place, or last initialization value." do
+      expect(list.nth(-999)).to eq(100)
+    end
+    it "#nth(0) returns current value, or last initialization value." do
+      expect(list.nth(0)).to eq(100)
+    end
+    it "#nth(999) returns last initialization value." do
+      expect(list.nth(999)).to eq(100)
+    end
+    it "#current equals last initialization value." do
+      expect(list.current).to eq(100)
+    end
+    it "#next after initialization wraps to first initialization value. " do
+      expect(list.next).to eq(10)
+      expect(list.next).to eq(20)
+      expect(list.next).to eq(30)
+    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 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 if only element. " do
+      only = described_class.new(55)
+      only.remove(55)
+      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
+
+  end
+
+end