linked-list 0.0.10 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15032f04d676c41f8dedbb0d911c82a35944826d5469c3a32530548fc55efa5c
-  data.tar.gz: 3f8b4bab1f5d9dca9f88b2e4e9baa78b2e9120eaf41ad7c3095e4072b7609be9
+  metadata.gz: a70c658176bc2e924764731304a3f8dbb376306e35b9e016d41896a7b5790463
+  data.tar.gz: cde342c544b41d53f5c52eb3d592deed28a6bf79736b6a0f2dbb1ef2d78319a7
 SHA512:
-  metadata.gz: c174a97b29c738a4224025639b744c97f086f0cc80afe21f20678ea708be29ff956fd8e81feb4f606d7a1ac9376f2fb334afe7bd730e3b8263af69107255bc50
-  data.tar.gz: 0eeb55908b8b9ddeb7f477262899e1a8d990e013af21d0c723c64a9c92248b4a1964e48450f379de1642906c0f68e08ea4a7f20dda360e45346a4ce9dd057a4d
+  metadata.gz: db29d3d0ec5195c12937ae63332a8dbb3ac891f6510441762f5a42d1acfce8de826d9a20a6af308e9b39a5fe33fcf92527c26d1ffd757c6814fb2c09ed4c34a4
+  data.tar.gz: 7723a09dc0858687eaf4ff6668e024ba8b7efd00cc202ab6eb067baffc52f645f6138d286cec946ccb30896b372345f91b601db5e8dee8900c65582ffe61577b

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
+  - 2.7
 cache: bundler
+env:
+  CI: true

data/CHANGELOG.md

@@ -0,0 +1,59 @@
+# 0.0.x / Unreleased
+
+
+# 0.0.15 / 2020-05-26
+
+## Fixed
+
+- Fixed bug when deleting the last node of the list. The @tail value was not updated if the @head value was updated.
+
+[Compare v0.0.14...v0.0.15](https://github.com/spectator/linked-list/compare/v0.0.14...v0.0.15)
+
+# 0.0.14 / 2020-04-17
+
+## Fixed
+
+Forced minimal rake version in gemspec to skip rake versions with security issues.
+
+[Compare v0.0.13...v0.0.14](https://github.com/spectator/linked-list/compare/v0.0.13...v0.0.14)
+
+# 0.0.13 / 2018-11-27
+
+## Fixed
+
+- Delete duplicate method definitions (nex3 in [#7](https://github.com/spectator/linked-list/pull/7))
+
+## Added
+
+- Allow `List#delete` to delete a `Node` in O(1) time (nex3 in [#6](https://github.com/spectator/linked-list/pull/6))
+
+[Compare v0.0.12...v0.0.13](https://github.com/spectator/linked-list/compare/v0.0.12...v0.0.13)
+
+# 0.0.12 / 2018-09-04
+
+## Added
+
+- Added `insert`, `insert_before` and `insert_after` methods (mpospelov in [#3](https://github.com/spectator/linked-list/pull/3))
+- Added `reverse_each` and `reverse_each_node` methods (mpospelov in [#4](https://github.com/spectator/linked-list/pull/4))
+
+[Compare v0.0.11...v0.0.12](https://github.com/spectator/linked-list/compare/v0.0.11...v0.0.12)
+
+# 0.0.11 / 2018-08-23
+
+## Added
+
+- Added `delete` and `delete_all` methods (mpospelov in [#2](https://github.com/spectator/linked-list/pull/2))
+
+[Compare v0.0.10...v0.0.11](https://github.com/spectator/linked-list/compare/v0.0.10...v0.0.11)
+
+# 0.0.10 / 2018-04-02
+
+## Fixed
+
+- Fixed bug when `@tail.prev` was mistekenly set to `nil` instead of `@tail.next` when popping elements off the list (Sonna in [#1](https://github.com/spectator/linked-list/pull/1))
+
+[Compare v0.0.9...v0.0.10](https://github.com/spectator/linked-list/compare/v0.0.9...v0.0.10)
+
+# 0.0.9 / 2013-12-11
+
+Initial release.

data/README.md

@@ -41,17 +41,38 @@ list.unshift(object)
 list.pop
 list.shift
 
+list.insert(object, before: object)
+list.insert(object, before: ->(n) { n == 'foo' })
+
+list.insert(object, after: object)
+list.insert(object, after: ->(n) { n == 'foo' })
+
+list.insert_before(object, node)
+list.insert_after(object, node)
+
 list.reverse
 list.reverse!
 
-list.each      # Enumerator object
+list.delete(object)
+list.delete { |n| n == 'foo' }
+
+list.delete_all(object)
+list.delete_all { |n| n == 'foo' }
+
+list.each  # Enumerator object
 list.each { |e| puts e }
 
-list.first     # head of the list
-list.last      # tail of the list
+list.reverse_each # Enumerator object
+list.reverse_each { |e| puts e }
+
+list.reverse_each_node # Enumerator object
+list.reverse_each_node { |node| puts node.data }
+
+list.first # head of the list
+list.last # tail of the list
 
 list.length
-list.size      # same as `length`
+list.size # same as `length`
 
 list.to_a
 ```
@@ -76,10 +97,6 @@ List([object, object]) # will return new `List` object with two `Node` objects
 Please see `LinkedList::List`, `LinkedList::Node`, and
 `LinkedList::Conversions` for details.
 
-## TODO
-
-* Insert / delete in the middle
-
 ## Tests
 
 Run test with

data/lib/linked-list/conversions.rb

@@ -12,8 +12,7 @@ module LinkedList
     # New +Node+ object.
     #
     def Node(arg)
-      case arg
-      when ->(_arg) { _arg.respond_to?(:to_node) }
+      if arg.respond_to?(:to_node)
         arg.to_node
       else
         Node.new(arg)
@@ -31,10 +30,9 @@ module LinkedList
     # New +List+ object.
     #
     def List(arg)
-      case arg
-      when ->(_arg) { _arg.respond_to?(:to_list) }
+      if arg.respond_to?(:to_list)
         arg.to_list
-      when ->(_arg) { _arg.respond_to?(:to_ary) }
+      elsif arg.respond_to?(:to_ary)
         arg.to_ary.each_with_object(List.new) { |n, l| l.push(Node(n)) }
       else
         List.new.push(Node(arg))

data/lib/linked-list/list.rb

@@ -4,7 +4,7 @@ module LinkedList
   class List
     include Conversions
 
-    attr_reader  :length
+    attr_reader :length
     alias_method :size, :length
 
     def initialize
@@ -69,6 +69,98 @@ module LinkedList
       self
     end
 
+    # Inserts after or before first matched node.data from the the list by passed block or value.
+    #
+    # == Returns:
+    # Inserted node data
+    #
+    def insert(to_add, after: nil, before: nil)
+      if after && before || !after && !before
+        raise ArgumentError, 'either :after or :before keys should be passed'
+      end
+      matcher = after || before
+      matcher_proc = if matcher.is_a?(Proc)
+                       __to_matcher(&matcher)
+                     else
+                       __to_matcher(matcher)
+                     end
+      node = each_node.find(&matcher_proc)
+      return unless node
+      new_node = after ? insert_after_node(to_add, node) : insert_before_node(to_add, node)
+      new_node.data
+    end
+
+    # Inserts data after first matched node.data.
+    #
+    # == Returns:
+    # Inserted node
+    #
+    def insert_after_node(data, node)
+      Node(data).tap do |new_node|
+        new_node.prev = node
+        new_node.next = node.next
+        if node.next
+          node.next.prev = new_node
+        else
+          @tail = new_node
+        end
+        node.next = new_node
+        @length += 1
+      end
+    end
+
+    # Inserts data before first matched node.data.
+    #
+    # == Returns:
+    # Inserted node
+    #
+    def insert_before_node(data, node)
+      Node(data).tap do |new_node|
+        new_node.next = node
+        new_node.prev = node.prev
+        if node.prev
+          node.prev.next = new_node
+        else
+          @head = new_node
+        end
+        node.prev = new_node
+        @length += 1
+      end
+    end
+
+    # Removes first matched node.data from the the list by passed block or value.
+    #
+    # If +val+ is a +Node+, removes that node from the list. Behavior is
+    # undefined if +val+ is a +Node+ that's not a member of this list.
+    #
+    # == Returns:
+    # Deleted node's data
+    #
+    def delete(val = nil, &block)
+      if val.respond_to?(:to_node)
+        node = val.to_node
+        __unlink_node(node)
+        return node.data
+      end
+
+      each_node.find(&__to_matcher(val, &block)).tap do |node_to_delete|
+        return unless node_to_delete
+        __unlink_node(node_to_delete)
+      end.data
+    end
+
+    # Removes all matched data.data from the the list by passed block or value.
+    #
+    # == Returns:
+    # Array of deleted nodes
+    #
+    def delete_all(val = nil, &block)
+      each_node.select(&__to_matcher(val, &block)).each do |node_to_delete|
+        next unless node_to_delete
+        __unlink_node(node_to_delete)
+      end.map(&:data)
+    end
+
     # Removes data from the end of the list.
     #
     # == Returns:
@@ -136,6 +228,41 @@ module LinkedList
       __each { |node| yield(node.data) }
     end
 
+    # Iterates over nodes from top to bottom passing node(LinkedList::Node instance)
+    # to the block if given. If no block given, returns +Enumerator+.
+    #
+    # == Returns:
+    # +Enumerator+ or yields list nodes to the block
+    #
+    def each_node
+      return to_enum(__callee__) unless block_given?
+      __each { |node| yield(node) }
+    end
+
+
+    # Iterates over nodes from bottom to top passing node data to the block if
+    # given. If no block given, returns +Enumerator+.
+    #
+    # == Returns:
+    # +Enumerator+ or yields data to the block stored in every node on the
+    # list.
+    #
+    def reverse_each
+      return to_enum(__callee__) unless block_given?
+      __reverse_each { |node| yield(node.data) }
+    end
+
+    # Iterates over nodes from bottom to top passing node(LinkedList::Node instance)
+    # to the block if given. If no block given, returns +Enumerator+.
+    #
+    # == Returns:
+    # +Enumerator+ or yields list nodes to the block
+    #
+    def reverse_each_node
+      return to_enum(__callee__) unless block_given?
+      __reverse_each { |node| yield(node) }
+    end
+
     # Converts list to array.
     #
     def to_a
@@ -158,6 +285,26 @@ module LinkedList
 
     private
 
+    def __unlink_node(node)
+      @head = node.next if node.prev.nil?
+      @tail = node.prev if node.next.nil?
+
+      if node.prev.nil?
+        node.next.prev = nil if node.next
+      elsif node.next.nil?
+        node.prev.next = nil if node.prev
+      else
+        node.prev.next, node.next.prev = node.next, node.prev
+      end
+      @length -= 1
+    end
+
+    def __to_matcher(val = nil, &block)
+      raise ArgumentError, 'either value or block should be passed' if val && block_given?
+      block = ->(e) { e == val } unless block_given?
+      ->(node) { block.call(node.data) }
+    end
+
     def __shift
       head = @head
       @head = @head.next
@@ -172,6 +319,14 @@ module LinkedList
       tail
     end
 
+    def __reverse_each
+      curr_node = @tail
+      while(curr_node)
+        yield curr_node
+        curr_node = curr_node.prev
+      end
+    end
+
     def __each
       curr_node = @head
       while(curr_node)

data/lib/linked-list/version.rb

@@ -2,6 +2,6 @@
 
 module Linked
   module List
-    VERSION = '0.0.10'
+    VERSION = '0.0.15'
   end
 end

data/linked-list.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Linked::List::VERSION
   spec.authors       = ['Yury Velikanau']
   spec.email         = ['yury.velikanau@gmail.com']
-  spec.description   = %q{Ruby implementation of Doubly Linked List, following some Ruby idioms.}
-  spec.summary       = %q{Ruby implementation of Doubly Linked List, following some Ruby idioms.}
+  spec.description   = %q(Ruby implementation of Doubly Linked List, following some Ruby idioms.)
+  spec.summary       = %q(Ruby implementation of Doubly Linked List, following some Ruby idioms.)
   spec.homepage      = 'https://github.com/spectator/linked-list'
   spec.license       = 'MIT'
 
@@ -18,8 +18,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'bundler',  '>= 1.3', '<= 2.0'
+  spec.add_development_dependency 'bundler', '>= 2.0', '< 3.0'
+  spec.add_development_dependency 'coveralls', '~> 0'
+  spec.add_development_dependency 'm', '~> 1.5', '>= 1.5.0'
   spec.add_development_dependency 'minitest', '>= 5.0', '<= 6.0'
-  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
 end

data/test/list_test.rb

@@ -4,6 +4,7 @@ describe LinkedList::List do
   let(:list)   { create_list }
   let(:node_1) { create_node('foo') }
   let(:node_2) { create_node('bar') }
+  let(:node_3) { create_node('baz') }
 
   describe 'instantiation' do
     it 'assigns first to nil' do
@@ -134,6 +135,486 @@ describe LinkedList::List do
     end
   end
 
+  describe '#insert' do
+    it 'raises error if after and before are passed' do
+      err = assert_raises ArgumentError do
+        assert_nil list.insert(1, after: 'x', before: 'y')
+      end
+      assert_equal err.message, 'either :after or :before keys should be passed'
+    end
+
+    it 'raises error if no after nore before are passed' do
+      err = assert_raises ArgumentError do
+        assert_nil list.insert(1)
+      end
+      assert_equal err.message, 'either :after or :before keys should be passed'
+    end
+
+    describe 'after:' do
+      describe 'by block' do
+        it 'does not add value if insert after not found' do
+          list.push('foo')
+          assert_nil list.insert(1, after: ->(d) { d == 'foo1' })
+          assert_equal ['foo'], list.to_a
+        end
+
+        it 'inserts value after first matching node by block' do
+          list.push('foo')
+          list.push('bar')
+          assert_equal 1, list.insert(1, after: ->(d) { d == 'foo' })
+          assert_equal ['foo', 1, 'bar'], list.to_a
+          assert_equal 3, list.length
+        end
+
+        describe 'position edge cases' do
+          before do
+            list.push(0)
+            list.push(1)
+            list.push(2)
+          end
+
+          it 'inserts after in the middle' do
+            list.insert('foo', after: ->(d) { d == 0 })
+            assert_equal [0, 'foo', 1, 2], list.to_a
+          end
+
+          it 'inserts after the tail' do
+            list.insert('foo', after: ->(d) { d == 2 })
+            assert_equal [0, 1, 2, 'foo'], list.to_a
+            assert_equal 'foo', list.last
+          end
+        end
+      end
+
+      describe 'by value' do
+        it 'does not add value if insert after not found' do
+          list.push('foo')
+          assert_nil list.insert(1, after: 'foo1')
+          assert_equal ['foo'], list.to_a
+        end
+
+        it 'inserts value after first matching node by block' do
+          list.push('foo')
+          list.push('bar')
+          assert_equal 1, list.insert(1, after: 'foo')
+          assert_equal ['foo', 1, 'bar'], list.to_a
+          assert_equal 3, list.length
+        end
+
+        describe 'position edge cases' do
+          before do
+            list.push(0)
+            list.push(1)
+            list.push(2)
+          end
+
+          it 'inserts after in the middle' do
+            list.insert('foo', after: 0)
+            assert_equal [0, 'foo', 1, 2], list.to_a
+          end
+
+          it 'inserts after the tail' do
+            list.insert('foo', after: 2)
+            assert_equal [0, 1, 2, 'foo'], list.to_a
+            assert_equal 'foo', list.last
+          end
+        end
+      end
+    end
+
+    describe ':before' do
+      describe 'by block' do
+        it 'does not add value if insert before not found' do
+          list.push('foo')
+          assert_nil list.insert(1, before: ->(d) { d == 'foo1' })
+          assert_equal ['foo'], list.to_a
+        end
+
+        it 'inserts value before first matching node by block' do
+          list.push('foo')
+          list.push('bar')
+          assert_equal 1, list.insert(1, before: ->(d) { d == 'foo' })
+          assert_equal [1, 'foo', 'bar'], list.to_a
+          assert_equal 3, list.length
+        end
+
+        describe 'position edge cases' do
+          before do
+            list.push(0)
+            list.push(1)
+            list.push(2)
+          end
+
+          it 'inserts before head' do
+            list.insert('foo', before: ->(d) { d == 0 })
+            assert_equal ['foo', 0, 1, 2], list.to_a
+            assert_equal 'foo', list.first
+          end
+
+          it 'inserts before in the middle' do
+            list.insert('foo', before: ->(d) { d == 2 })
+            assert_equal [0, 1, 'foo', 2], list.to_a
+          end
+        end
+      end
+
+      describe 'by value' do
+        it 'does not add value if insert before not found' do
+          list.push('foo')
+          assert_nil list.insert(1, before: 'foo1')
+          assert_equal ['foo'], list.to_a
+        end
+
+        it 'inserts value before first' do
+          list.push('foo')
+          list.push('bar')
+          assert_equal 1, list.insert(1, before: 'foo')
+          assert_equal [1, 'foo', 'bar'], list.to_a
+          assert_equal 3, list.length
+        end
+
+        describe 'position edge cases' do
+          before do
+            list.push(0)
+            list.push(1)
+            list.push(2)
+          end
+
+          it 'inserts before head' do
+            list.insert('foo', before: 0)
+            assert_equal ['foo', 0, 1, 2], list.to_a
+            assert_equal 'foo', list.first
+          end
+
+          it 'inserts before in the middle' do
+            list.insert('foo', before: 2)
+            assert_equal [0, 1, 'foo', 2], list.to_a
+          end
+        end
+      end
+    end
+  end
+
+  describe '#insert_after_node' do
+    it 'inserts value after passed node' do
+      list.push('foo')
+      list.push('bar')
+      node = list.each_node.find { |n| n.data == 'foo' }
+      assert_equal 1, list.insert_after_node(1, node).data
+      assert_equal ['foo', 1, 'bar'], list.to_a
+      assert_equal 3, list.length
+    end
+
+    describe 'position edge cases' do
+      before do
+        list.push(0)
+        list.push(1)
+        list.push(2)
+      end
+
+      it 'inserts after in the middle' do
+        node = list.each_node.find { |n| n.data == 0 }
+        list.insert_after_node('foo', node)
+        assert_equal [0, 'foo', 1, 2], list.to_a
+      end
+
+      it 'inserts after the tail' do
+        node = list.each_node.find { |n| n.data == 2 }
+        list.insert_after_node('foo', node)
+        assert_equal [0, 1, 2, 'foo'], list.to_a
+        assert_equal 'foo', list.last
+      end
+    end
+  end
+
+  describe '#insert_after_node' do
+    it 'inserts value before first' do
+      list.push('foo')
+      list.push('bar')
+      node = list.each_node.find { |n| n.data == 'foo' }
+      assert_equal 1, list.insert_before_node(1, node).data
+      assert_equal [1, 'foo', 'bar'], list.to_a
+      assert_equal 3, list.length
+    end
+
+    describe 'position edge cases' do
+      before do
+        list.push(0)
+        list.push(1)
+        list.push(2)
+      end
+
+      it 'inserts before head' do
+        node = list.each_node.find { |n| n.data == 0 }
+        list.insert_before_node('foo', node)
+        assert_equal ['foo', 0, 1, 2], list.to_a
+        assert_equal 'foo', list.first
+      end
+
+      it 'inserts before in the middle' do
+        node = list.each_node.find { |n| n.data == 2 }
+        list.insert_before_node('foo', node)
+        assert_equal [0, 1, 'foo', 2], list.to_a
+      end
+    end
+  end
+
+  describe '#delete' do
+    it 'raises error if block and value are passed' do
+      err = assert_raises ArgumentError do
+        assert_nil list.delete('x') { |d| d == 'x' }
+      end
+      assert_equal err.message, 'either value or block should be passed'
+    end
+
+    describe 'by block' do
+      it 'returns nil if list is empty' do
+        assert_nil list.delete { |d| d == 'x' }
+      end
+
+      it 'deletes value in first matching node' do
+        calls_count = 0
+        list.push('foo')
+        list.push('foo')
+        list.push('bar')
+        list.push('foo')
+        list.delete { |d| calls_count += 1;d == 'bar' }
+        assert_equal ['foo', 'foo', 'foo'], list.to_a
+        assert_equal 3, calls_count
+      end
+
+      it 'returns deleted value' do
+        list.push('foo')
+        assert_equal 'foo', list.delete { |d| d == 'foo' }
+      end
+
+      it 'decreases length of list' do
+        list.push('foo')
+        list.push('bar')
+        list.push('foo')
+        list.delete { |d| d == 'foo' }
+        assert_equal 2, list.length
+        assert_equal ['bar', 'foo'], list.to_a
+      end
+
+      describe 'position edge cases' do
+        before do
+          list.push(0)
+          list.push(1)
+          list.push(2)
+        end
+
+        it 'deletes value from head' do
+          list.delete { |d| d == 0 }
+          assert_equal [1, 2], list.to_a
+          assert_equal 1, list.first
+        end
+
+        it 'deletes value from middle' do
+          list.delete { |d| d == 1 }
+          assert_equal [0, 2], list.to_a
+        end
+
+        it 'deletes value from tail' do
+          list.delete { |d| d == 2 }
+          assert_equal [0, 1], list.to_a
+          assert_equal 1, list.last
+        end
+      end
+    end
+
+    describe 'by data equality' do
+      it 'returns nil if list is empty' do
+        assert_nil list.delete('x')
+      end
+
+      it 'deletes value in first node' do
+        list.push('foo')
+        list.push('foo')
+        list.push('bar')
+        list.push('foo')
+        list.delete('foo')
+        assert_equal ['foo', 'bar', 'foo'], list.to_a
+      end
+
+      it 'returns deleted value' do
+        list.push('foo')
+        assert_equal 'foo', list.delete('foo')
+      end
+
+      it 'decreases length of list' do
+        list.push('foo')
+        list.push('bar')
+        list.push('foo')
+        list.delete('foo')
+        assert_equal 2, list.length
+        assert_equal ['bar', 'foo'], list.to_a
+      end
+
+      describe 'position edge cases' do
+        before do
+          list.push(0)
+          list.push(1)
+          list.push(2)
+        end
+
+        it 'deletes value from head' do
+          list.delete(0)
+          assert_equal [1, 2], list.to_a
+          assert_equal 1, list.first
+        end
+
+        it 'deletes value from middle' do
+          list.delete(1)
+          assert_equal [0, 2], list.to_a
+        end
+
+
+        it 'deletes value from tail' do
+          list.delete(2)
+          assert_equal [0, 1], list.to_a
+          assert_equal 1, list.last
+        end
+      end
+    end
+
+    describe 'by node' do
+      it 'deletes first node' do
+        list.push(node_1)
+        list.push(node_2)
+        list.push(node_3)
+        list.delete(node_1)
+        assert_equal ['bar', 'baz'], list.to_a
+      end
+
+      it 'returns deleted value' do
+        list.push(node_1)
+        list.delete(node_1)
+        assert_equal node_1.data, list.delete(node_1)
+      end
+
+      it 'decreases length of list' do
+        list.push('foo')
+        list.push('bar')
+        list.push('baz')
+        list.delete('foo')
+        assert_equal 2, list.length
+      end
+
+      describe 'position edge cases' do
+        before do
+          list.push(node_1)
+          list.push(node_2)
+          list.push(node_3)
+        end
+
+        it 'deletes value from head' do
+          list.delete(node_1)
+          assert_equal [node_2.data, node_3.data], list.to_a
+          assert_equal node_2.data, list.first
+          assert_equal node_3.data, list.last
+        end
+
+        it 'deletes value from middle' do
+          list.delete(node_2)
+          assert_equal [node_1.data, node_3.data], list.to_a
+          assert_equal node_1.data, list.first
+          assert_equal node_3.data, list.last
+        end
+
+
+        it 'deletes value from tail' do
+          list.delete(node_3)
+          assert_equal [node_1.data, node_2.data], list.to_a
+          assert_equal node_1.data, list.first
+          assert_equal node_2.data, list.last
+        end
+      end
+
+      describe 'delete edge cases' do
+        it 'resets original list state when deleting the last node of the list' do
+          assert_nil list.first
+          assert_nil list.last
+
+          list.push(node_1)
+          assert_equal node_1.data, list.first
+          assert_equal node_1.data, list.last
+
+          list.delete(node_1)
+          assert_nil list.first
+          assert_nil list.last
+        end
+      end
+    end
+  end
+
+  describe '#delete_all' do
+    it 'raises error if block and value are passed' do
+      err = assert_raises ArgumentError do
+        assert_nil list.delete_all('x') { |d| d == 'x' }
+      end
+      assert_equal err.message, 'either value or block should be passed'
+    end
+
+    describe 'by block' do
+      it 'returns nil if list is empty' do
+        assert_equal list.delete_all { |d| d == 'x' }, []
+      end
+
+      it 'deletes value in first matching node' do
+        list.push('foo')
+        list.push('foo')
+        list.push('bar')
+        list.push('foo')
+        list.delete_all { |d| d == 'foo' }
+        assert_equal ['bar'], list.to_a
+      end
+
+      it 'returns deleted value' do
+        list.push('foo')
+        assert_equal ['foo'], list.delete_all { |d| d == 'foo' }
+      end
+
+      it 'decreases length of list' do
+        list.push('foo')
+        list.push('bar')
+        list.push('foo')
+        list.delete_all { |d| d == 'foo' }
+        assert_equal 1, list.length
+        assert_equal ['bar'], list.to_a
+      end
+    end
+
+    describe 'by data equality' do
+      it 'returns nil if list is empty' do
+        assert_nil list.delete('x')
+      end
+
+      it 'deletes all matched values' do
+        list.push('foo')
+        list.push('foo')
+        list.push('bar')
+        list.push('foo')
+        list.delete_all('foo')
+        assert_equal ['bar'], list.to_a
+      end
+
+      it 'returns deleted value' do
+        list.push('foo')
+        assert_equal ['foo'], list.delete_all('foo')
+      end
+
+      it 'decreases length of list' do
+        list.push('foo')
+        list.push('bar')
+        list.push('foo')
+        list.delete_all('foo')
+        assert_equal 1, list.length
+        assert_equal ['bar'], list.to_a
+      end
+    end
+  end
+
   describe '#shift' do
     it 'returns nil if list is empty' do
       assert_nil list.shift
@@ -200,6 +681,21 @@ describe LinkedList::List do
     end
   end
 
+  describe '#each_node' do
+    it 'returns enumerator if no block given' do
+      assert_instance_of Enumerator, list.each_node
+    end
+
+    it 'pass each node data to the block' do
+      list.push(node_1)
+      list.push(node_2)
+      nodes = []
+      list.each_node { |e| nodes << e }
+      assert_equal %w(foo bar), nodes.map(&:data)
+      assert_equal true, nodes.all? { |n| n.is_a?(LinkedList::Node) }
+    end
+  end
+
   describe '#each' do
     it 'returns enumerator if no block given' do
       assert_instance_of Enumerator, list.each
@@ -214,6 +710,48 @@ describe LinkedList::List do
     end
   end
 
+  describe '#each_node' do
+    it 'returns enumerator if no block given' do
+      assert_instance_of Enumerator, list.each
+    end
+
+    it 'pass each node data to the block' do
+      list.push(node_1)
+      list.push(node_2)
+      nodes = []
+      list.each_node { |e| nodes << e }
+      assert_equal %w(foo bar), nodes.map(&:data)
+    end
+  end
+
+  describe '#reverse_each' do
+    it 'returns enumerator if no block given' do
+      assert_instance_of Enumerator, list.each
+    end
+
+    it 'pass each node data to the block' do
+      list.push(node_1)
+      list.push(node_2)
+      nodes = []
+      list.reverse_each { |e| nodes << e }
+      assert_equal %w(bar foo), nodes
+    end
+  end
+
+  describe '#reverse_each_node' do
+    it 'returns enumerator if no block given' do
+      assert_instance_of Enumerator, list.each
+    end
+
+    it 'pass each node data to the block' do
+      list.push(node_1)
+      list.push(node_2)
+      nodes = []
+      list.reverse_each_node { |e| nodes << e }
+      assert_equal %w(bar foo), nodes.map(&:data)
+    end
+  end
+
   describe '#inspect' do
     it 'includes class name' do
       assert_match(/LinkedList::List/, list.inspect)

data/test/test_helper.rb

@@ -1,5 +1,7 @@
-require 'coveralls'
-Coveralls.wear!
+if ENV['CI']
+  require 'coveralls'
+  Coveralls.wear!
+end
 
 require 'linked-list'
 

metadata

@@ -1,49 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: linked-list
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.15
 platform: ruby
 authors:
 - Yury Velikanau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-03 00:00:00.000000000 Z
+date: 2020-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: m
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
-    - - "<="
+        version: '1.5'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 1.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
-    - - "<="
+        version: '1.5'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -65,19 +85,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 12.3.3
 description: Ruby implementation of Doubly Linked List, following some Ruby idioms.
 email:
 - yury.velikanau@gmail.com
@@ -89,6 +109,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -124,8 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of Doubly Linked List, following some Ruby idioms.