circular_linked 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7eaddc29746a2d99c05aadcf1e490004f23683178dc49afd5293656c3edceded
+  data.tar.gz: 3c906b3079d972ceadad706bcb3cf93749600c24d3b4ebbad7f91cd19df91555
+SHA512:
+  metadata.gz: d583d18873400eec464d1d708aa3b1d4791c1cc38af6b824a2b9f904be4633882b42eaeda58627608159e6da40f58eed5051824c38cc03f34ca6051b187f513b
+  data.tar.gz: 2034ffcd127a04c5d6b1e4a9fce71580b4caddddf6c92525399fb57e036a8ab931ee4f4e3a72e2e792732894fdfb1578fcbdc6ee707436b4df7d271a08a7344e

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gem "rspec", "~> 3.9"

data/Gemfile.lock

@@ -0,0 +1,26 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.4.4)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  rspec (~> 3.9)
+
+BUNDLED WITH
+   2.2.7

data/lib/circular_linked.rb

@@ -0,0 +1,2 @@
+require_relative "./circular_linked/node.rb"
+require_relative "./circular_linked/list.rb"

data/lib/circular_linked/list.rb

@@ -0,0 +1,84 @@
+module CircularLinked
+  class List
+
+    attr_accessor :head
+  
+    def initialize(*values)
+      nodes = values.map {|v| Node.new(v) }
+      @head = nodes.first
+      nodes.each_with_index {|node, i| node.next = nodes[i+1] || @head }
+    end
+  
+    def add(value)
+      new_node = Node.new(value, head)
+      
+      @head ||= new_node
+      new_node.next ||= head
+      
+      last_node.next = new_node
+    end
+  
+    def last_node
+      return nil unless head
+  
+      node = head
+      node = node.next while node.next != head
+      node
+    end
+  
+    def find(value)
+      return nil unless head
+  
+      node = head
+      while node.value != value
+        node = node.next
+        return nil if node == head
+      end
+      
+      node
+    end
+  
+    def remove(value)
+      node = find(value)
+      return unless node
+  
+      if head.next == head
+        @head = nil
+        return
+      end
+  
+      node_before = head
+      node_before = node_before.next while node_before.next != node
+      node_before.next = node.next
+      
+      @head = node.next if node == head
+    end
+  
+    def items_value
+      values = []
+      return values unless head
+      
+      each {|node| values.push(node.value) }
+      values
+    end
+  
+    def length
+      length = 0
+      return length unless head
+  
+      each { length += 1 }
+      length
+    end
+  
+    def each
+      return unless head 
+      
+      node = head
+      loop do
+        yield(node)
+        node = node.next
+        break if node == head        
+      end
+    end
+  end  
+end

data/lib/circular_linked/node.rb

@@ -0,0 +1,11 @@
+module CircularLinked
+  class Node
+
+    attr_accessor :value, :next
+
+    def initialize(value, next_node = nil)
+      @value = value
+      @next = next_node
+    end
+  end
+end

data/spec/circular_linked/list_spec.rb

@@ -0,0 +1,185 @@
+require_relative '../../lib/circular_linked/node.rb'
+require_relative '../../lib/circular_linked/list.rb'
+
+RSpec.describe CircularLinked::List do
+  let(:value1) { "Node1" }
+  let(:value2) { "Node2" }
+  let(:value3) { "Node3" }
+  let(:empty_list) { described_class.new }
+  let(:head_list) { described_class.new(value1) }
+  let(:two_item_list) { described_class.new(value1, value2) }
+  let(:three_item_list) { described_class.new(value1, value2, value3) }
+
+  describe "#initialize" do
+    context "with no params" do
+      it "just initializes empty list" do
+        expect(empty_list.head).to eq(nil)
+      end
+    end
+
+    context "with 1 item" do
+      it "initializes list with just a head" do
+        expect(head_list.head.value).to eq(value1)
+        expect(head_list.head.next).to eq(head_list.head)
+      end
+    end
+    
+    context "with two items" do
+      it "initializes a circular list" do
+        expect(two_item_list.head.value).to eq(value1)
+        expect(two_item_list.head.next.value).to eq(value2)
+        expect(two_item_list.head.next.next).to eq(two_item_list.head)
+      end
+    end
+  end
+
+  describe "#last_node" do
+    context "when list is empty" do
+      it "returns nil" do
+        expect(empty_list.last_node).to eq(nil)
+      end
+    end
+
+    context "when list has only head" do
+      it "returns head" do
+        expect(head_list.last_node.value).to eq(value1)
+      end
+    end
+
+    context "when list has three nodes" do
+      it "returns last node" do
+        expect(three_item_list.last_node.value).to eq(value3)        
+      end
+    end
+  end
+
+  describe "#add" do
+    let(:new_value) { "New Value" }
+
+    context "when list is empty" do
+      it "adds the element as the head" do
+        expect{empty_list.add(new_value)}.to change{empty_list.head&.value}
+          .from(nil).to(new_value)
+        expect(empty_list.head.next).to eq(empty_list.head)
+      end
+    end
+
+    context "when list has only head" do      
+      it "adds another element" do
+        expect{head_list.add(new_value)}.to change{head_list.last_node.value}
+          .from(head_list.head.value).to(new_value)
+        expect(head_list.head.next).not_to eq(head_list.head)
+        expect(head_list.last_node.next).to eq(head_list.head)
+      end
+    end
+
+    context "when list has already three nodes" do
+      let!(:old_last_node) { three_item_list.last_node }
+
+      it "adds fourth node" do
+        expect{three_item_list.add(new_value)}.to change{three_item_list.last_node.value}
+          .from(old_last_node.value).to(new_value)
+        expect(old_last_node.next).not_to eq(three_item_list.head)
+        expect(three_item_list.last_node.next).to eq(three_item_list.head)    
+      end
+    end
+  end
+
+  describe "#find" do
+    let(:value_outside_list) { "MissingNode" }
+
+    context "when list is empty" do
+      it "returns nil" do
+        expect(empty_list.find(value_outside_list)).to eq(nil)
+      end
+    end
+
+    context "when list has only head" do
+      it "returns nil if head is not the element" do
+        expect(head_list.find(value_outside_list)).to eq(nil)
+      end
+
+      it "returns the node if head is the element" do
+        expect(head_list.find(value1)).to eq(head_list.head)        
+      end
+    end
+
+    context "when list has three elements" do
+      it "returns nil if value is not in list" do
+        expect(three_item_list.find(value_outside_list)).to eq(nil)        
+      end
+
+      it "returns the node if value is in list" do
+        expect(three_item_list.find(value3)).to eq(three_item_list.last_node)
+      end
+    end
+  end
+
+  describe "#remove" do
+    context "when trying to remove non existing value" do
+      it "does nothing" do
+        expect{two_item_list.remove("Non existing Node")}.not_to change{two_item_list.head}
+        expect{two_item_list.remove("Non existing Node")}.not_to change{two_item_list.head.next}
+        expect{empty_list.remove("Non existing Node")}.not_to change{empty_list.head}
+      end
+    end
+
+    context "when removing a value" do
+      it "removes the node and update the links" do
+        expect{three_item_list.remove(value2)}.to change{three_item_list.head.next.value}
+          .from(value2).to(value3)
+        expect(three_item_list.find(value2)).to eq(nil)
+        expect(three_item_list.head.value).to eq(value1)
+        expect(three_item_list.last_node.value).to eq(value3)
+      end
+
+      it "removes the head when is a head_list" do
+        head_list.remove(value1)
+        expect(head_list.head).to eq(nil)
+        expect(head_list.find(value1)).to eq(nil)
+      end
+
+      it "removes the head when the removed value is the head" do
+        expect{two_item_list.remove(value1)}.to change{two_item_list.head.value}
+          .from(value1).to(value2)
+        expect(two_item_list.find(value1)).to eq(nil)
+        expect(two_item_list.last_node.value).to eq(value2)
+      end
+
+      it "removes the last note when the removed value is it" do
+        expect{three_item_list.remove(value3)}.to change{three_item_list.head.next.next.value}
+          .from(value3).to(value1)
+        expect(three_item_list.find(value3)).to eq(nil)
+        expect(three_item_list.head.value).to eq(value1)
+        expect(three_item_list.last_node.value).to eq(value2)
+      end
+    end
+  end
+
+  describe "#items_value" do
+    context "when list is empty" do
+      it "returns empty array" do
+        expect(empty_list.items_value).to eq([])
+      end
+    end
+    
+    context "when list has only head" do
+      it "returns array with one value" do
+        expect(head_list.items_value).to eq([value1])
+      end
+    end
+    
+    context "when list has three items" do
+      it "returns array with three values" do
+        expect(three_item_list.items_value).to eq([value1, value2, value3])        
+      end
+    end
+  end
+
+  describe "#length" do
+    it { expect(empty_list.length).to eq(0) }
+    it { expect(head_list.length).to eq(1) }
+    it { expect(two_item_list.length).to eq(2) }
+    it { expect(three_item_list.length).to eq(3) }
+  end  
+end

data/spec/circular_linked/node_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../../lib/circular_linked/node.rb'
+
+RSpec.describe CircularLinked::Node do
+  describe "#initialize" do
+    let(:value) { "Value" }
+
+    context "when there is no next_node" do
+      let(:value) { "Value" }
+      subject(:new_node) { described_class.new(value) }
+
+      it "saves the params passed" do
+        expect(new_node.value).to eq(value)
+        expect(new_node.next).to eq(nil)
+      end
+    end
+
+    context "when there is next_node" do
+      let(:next_node) { described_class.new("Next node value")}
+      subject(:new_node) { described_class.new(value, next_node) }
+
+      it "saves the params passed" do
+        expect(new_node.value).to eq(value)
+        expect(new_node.next).to eq(next_node)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: circular_linked
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gabriela Guedes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-02-02 00:00:00.000000000 Z
+dependencies: []
+description: Provides a circular linked list data structure for Ruby with the most
+  common methods
+email: gabriela.guedes.gmg@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- lib/circular_linked.rb
+- lib/circular_linked/list.rb
+- lib/circular_linked/node.rb
+- spec/circular_linked/list_spec.rb
+- spec/circular_linked/node_spec.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: Circular Linked List implementation
+test_files: []