linked-list 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 203cf979a2f074eaa22dd987096ecf8ec298198344ddf1f8cafafca20be8552b
-  data.tar.gz: e8fc8a7584f411444d4685aa3c9ecc7328a2ba59f1f0e0de55a1abb2130ff63f
+  metadata.gz: 1d11a48bdb387744768bf129513fce5e6f31001988e8cf45bf8b974009938e98
+  data.tar.gz: 9ba15ea4897065b9a111e6add68d6a60dac5ab61b9e3aba0ab83c7b42e91f8b5
 SHA512:
-  metadata.gz: 4e87238b13c8a4621ff4b30502f6d4295df7f9ad7a219144bfcdbea24c7676b859767f53b3070ac11707576f639a8f1323bd1e96903bcba76403c1a865a2d552
-  data.tar.gz: 9419f5694a938f436084247464b016c213b8914fdbcc3a255eed8fffbe21164938f6b10f27aac2187d985995c1120b6bbc581ea6c295a8fd7da45f5acbe01655
+  metadata.gz: 13f2b676935b4b18a9302e9a484f888c9c4730e81cab6fb6a891e4da5cc721fd0adf07d3f62b7a490fe985d32ed6143fdd9e01f586904214824c29c1cc8ed6f6
+  data.tar.gz: 5f844ebe95b710614b30ebc6a0a732c361987882ea661cc30e3773432f1702c347a2cf8979f63c6b50e6011cdd348adff1f458d0a81d22cab67aaf3b15528c36

data/.travis.yml

@@ -3,3 +3,5 @@ rvm:
   - 2.3.0
   - 2.5.0
 cache: bundler
+env:
+  CI: true

data/CHANGELOG.md

@@ -1,9 +1,20 @@
-# 0.0.11 / 2018-04-02
+# 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

data/README.md

@@ -41,20 +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.delete(object)
+list.delete { |n| n == 'foo' }
+
 list.delete_all(object)
+list.delete_all { |n| n == 'foo' }
 
-list.each      # Enumerator object
+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
 ```
@@ -79,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 in the middle
-
 ## Tests
 
 Run test with

data/lib/linked-list/list.rb

@@ -69,6 +69,65 @@ 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.
     #
     # == Returns:
@@ -76,8 +135,8 @@ module LinkedList
     #
     def delete(val = nil, &block)
       each_node.find(&__to_matcher(val, &block)).tap do |node_to_delete|
-        return if node_to_delete.blank?
-        __unlink(node_to_delete)
+        return unless node_to_delete
+        __unlink_node(node_to_delete)
       end.data
     end
 
@@ -88,8 +147,8 @@ module LinkedList
     #
     def delete_all(val = nil, &block)
       each_node.select(&__to_matcher(val, &block)).each do |node_to_delete|
-        next if node_to_delete.blank?
-        __unlink(node_to_delete)
+        next unless node_to_delete
+        __unlink_node(node_to_delete)
       end.map(&:data)
     end
 
@@ -171,6 +230,30 @@ module LinkedList
       __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
@@ -191,19 +274,52 @@ module LinkedList
       self
     end
 
-    private
+    # Inserts data after passed node.
+    #
+    # == 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
 
-    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) }
+
+    # Inserts data before passed node.
+    #
+    # == 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
 
-    def __unlink(node)
-      if node.prev.blank?
+    private
+
+    def __unlink_node(node)
+      if node.prev.nil?
         node.next.prev = nil if node.next
         @head = node.next
-      elsif node.next.blank?
+      elsif node.next.nil?
         node.prev.next = nil if node.prev
         @tail = node.prev
       else
@@ -212,6 +328,13 @@ module LinkedList
       @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
@@ -226,6 +349,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.11'
+    VERSION = '0.0.12'
   end
 end

data/linked-list.gemspec

@@ -19,8 +19,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler', '>= 1.3', '<= 2.0'
-  spec.add_development_dependency 'coveralls'
-  spec.add_development_dependency 'm', '~> 1.5.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 'rake'
+  spec.add_development_dependency 'rake', '~> 0'
 end

data/test/list_test.rb

@@ -134,6 +134,229 @@ 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
@@ -149,12 +372,14 @@ describe LinkedList::List do
       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| d == 'foo' }
-        assert_equal ['foo', 'bar', 'foo'], list.to_a
+        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
@@ -189,7 +414,6 @@ describe LinkedList::List do
           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
@@ -416,6 +640,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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: linked-list
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Yury Velikanau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-23 00:00:00.000000000 Z
+date: 2018-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -34,14 +34,14 @@ dependencies:
   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
@@ -49,6 +49,9 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.0
   type: :development
@@ -56,6 +59,9 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.0
 - !ruby/object:Gem::Dependency
@@ -82,14 +88,14 @@ dependencies:
   name: rake
   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'
 description: Ruby implementation of Doubly Linked List, following some Ruby idioms.