doubly_linked_list 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d7076f1fe66bdbee71d9f8ab23203733c7f302d
-  data.tar.gz: 8994066abb5e143f78a14f84e1a1aabe0ecaa0bd
+  metadata.gz: 0872378b46d546aec11ec96d3675082b099fe887
+  data.tar.gz: 0922c01e2fd25b855c904824152d7cf99b9f5bca
 SHA512:
-  metadata.gz: dab92466e5d1affe6b07a8f1a2e0dd7494b1d2e9e2ccfd98b076fe277db743111f86e827fac62633693e0e091c9445ab864e774c2015dcabb4c7d29d09ba7c83
-  data.tar.gz: 22cdf33047c74811c85d3730a204d8a3f42dd660803ee4196204679213fb5d01ac839ea5c1c553b1862df759ba4abca3de2b8673784974cb06b073277a69f491
+  metadata.gz: 018b32fc622f2ed204602a51a90cc9a94360f6357efe20dd89e0756f127570264ad1ff2ad62cf410d92b3e952a38ee54c822c0055b27e65a6397ec4b32e44a2a
+  data.tar.gz: 98fbb16c4415b0dbed687b3e9e1076fa6289d7237c2b036c8ec6d6c7ddf0f7fbd76b537e7b7b9c833bc176d5eb6e555909e413aa4b102c5c151cca8eb62f3302

data/doubly_linked_list.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'doubly_linked_list'
-  spec.version       = '0.0.5'
+  spec.version       = '0.0.6'
   spec.authors       = ["E. Lynette Rayle"]
   spec.email         = ["elr37@cornell.edu"]
   spec.platform      = Gem::Platform::RUBY

data/lib/doubly_linked_list.rb

@@ -19,15 +19,64 @@ class DoublyLinkedList
   attr_accessor :list_info
   # attr_writer   :node_update_callback   # TODO Add callback to update node info
 
+  @clear_first  = nil   # ( list_info )           returns nothing
+  @clear_last   = nil   # ( list_info )           returns nothing
+  @update_first = nil   # ( list_info, list )     returns nothing
+  @update_last  = nil   # ( list_info, list )     returns nothing
+
+  @clear_next   = nil   # ( list, item_idx )      returns nothing
+  @clear_prev   = nil   # ( list, item_idx )      returns nothing
+  @update_next  = nil   # ( list, item_idx )      returns nothing
+  @update_prev  = nil   # ( list, item_idx )      returns nothing
+
+  @find_first   = nil   # ( list_info, list )     returns instance of item in list
+  @find_last    = nil   # ( list_info, list )     returns instance of item in list
+  @find_next    = nil   # ( list, current_item )  returns instance of item in list
+  @find_prev    = nil   # ( list, current_item )  returns instance of item in list
+
   def initialize(*args)
     @list      = []
-    @list      = args[0][:items] if ! args.empty? && args[0].is_a?(Hash) && args[0].key?(:items)
-    raise ArgumentError, "items list must be an Array" unless @list.kind_of?(Array)
     @list_info = nil
-    @list_info = args[0][:list_info] if ! args.empty? && args[0].is_a?(Hash) && args[0].key?(:list_info)
+
+    if !args.empty? && args[0].is_a?(Hash)
+      @list      = args[0][:items]              if args[0].key?(:items)
+      @list_info = args[0][:list_info]          if args[0].key?(:list_info)
+
+      # set callbacks
+      @clear_first  = args[0][:clear_first_callback]  if args[0].key?(:clear_first_callback)
+      @clear_last   = args[0][:clear_last_callback]   if args[0].key?(:clear_last_callback)
+      @update_first = args[0][:update_first_callback] if args[0].key?(:update_first_callback)
+      @update_last  = args[0][:update_last_callback]  if args[0].key?(:update_last_callback)
+
+      @clear_next   = args[0][:clear_next_callback]   if args[0].key?(:clear_next_callback)
+      @clear_prev   = args[0][:clear_prev_callback]   if args[0].key?(:clear_prev_callback)
+      @update_next  = args[0][:update_next_callback]  if args[0].key?(:update_next_callback)
+      @update_prev  = args[0][:update_prev_callback]  if args[0].key?(:update_prev_callback)
+
+      @find_first   = args[0][:find_first_callback]   if args[0].key?(:find_first_callback)
+      @find_last    = args[0][:find_last_callback]    if args[0].key?(:find_last_callback)
+      @find_next    = args[0][:find_next_callback]    if args[0].key?(:find_next_callback)
+      @find_prev    = args[0][:find_prev_callback]    if args[0].key?(:find_prev_callback)
+
+      unless @list.empty?
+        @list = organize_list
+        update_first_in_listinfo
+        update_last_in_listinfo
+      end
+    end
+    raise ArgumentError, "items list must be an Array" unless @list.kind_of?(Array)
     self
   end
 
+  ##
+  # Get the number of items in the list.
+  #
+  # @return the number of items
+  def size
+    @list.size
+  end
+  alias_method :count, :size
+
   ##
   # Get the first element of the list.
   #
@@ -53,7 +102,17 @@ class DoublyLinkedList
   #
   # @return position where added
   def add_last(data)
+    raise ArgumentError 'data must have non-nil value' unless data
     @list << data
+    if @list.size > 1
+      update_next_in_listitem(tail-1)
+      update_prev_in_listitem(tail)
+    else
+      clear_prev_in_listitem(tail)
+      update_first_in_listinfo
+    end
+    clear_next_in_listitem(tail)
+    update_last_in_listinfo
     @list.size
   end
   alias_method :<<, :add_last
@@ -65,7 +124,17 @@ class DoublyLinkedList
   #
   # @return position where added
   def add_first(data)
+    raise ArgumentError 'data must have non-nil value' unless data
     @list.insert(0,data)
+    if @list.size > 1
+      update_prev_in_listitem(head+1)
+      update_next_in_listitem(head)
+    else
+      clear_next_in_listitem(head)
+      update_last_in_listinfo
+    end
+    clear_prev_in_listitem(head)
+    update_first_in_listinfo
     @list.size
   end
 
@@ -75,7 +144,15 @@ class DoublyLinkedList
   # @return data stored in the removed node
   def remove_last
     return nil if @list.empty?
-    @list.delete_at(tail)
+    item = @list.delete_at(tail)
+    if @list.size > 0
+      clear_next_in_listitem(tail)
+      update_last_in_listinfo
+    else
+      clear_first_in_listinfo
+      clear_last_in_listinfo
+    end
+    item
   end
 
   ##
@@ -84,7 +161,15 @@ class DoublyLinkedList
   # @return data stored in the removed node
   def remove_first
     return nil if @list.empty?
-    @list.delete_at(head)
+    item = @list.delete_at(head)
+    if @list.size > 0
+      clear_prev_in_listitem(head)
+      update_first_in_listinfo
+    else
+      clear_first_in_listinfo
+      clear_last_in_listinfo
+    end
+    item
   end
 
   # Returns list array without list info.
@@ -111,11 +196,84 @@ class DoublyLinkedList
 
 private
 
+  # head returns the first index into the array list.  See first method to get the first item in the list.
   def head
     @list && @list.size > 0 ? 0 : nil
   end
 
+  # tail returns the last index into the array list.  See last method to get the last item in the list.
   def tail
     @list && @list.size > 0 ? @list.size-1 : nil
   end
+
+  def valid_list?
+    @list && !@list.empty?
+  end
+
+  def item_idx_in_range(item_idx)
+    item_idx >= head && item_idx <= tail
+  end
+
+  def clear_first_in_listinfo
+    @clear_first.call(@list_info,@list)  if @clear_first && @list_info
+  end
+
+  def update_first_in_listinfo
+    @update_first.call(@list_info,@list) if @update_first && @list_info && valid_list?
+  end
+
+  def clear_last_in_listinfo
+    @clear_last.call(@list_info,@list)   if @clear_last && @list_info
+  end
+
+  def update_last_in_listinfo
+    @update_last.call(@list_info,@list)  if @update_last && @list_info && valid_list?
+  end
+
+  def clear_next_in_listitem(item_idx)
+    @clear_next.call(@list,item_idx)     if @clear_next && valid_list? && item_idx_in_range(item_idx)
+  end
+
+  def update_next_in_listitem(item_idx)
+    @update_next.call(@list,item_idx)    if @update_next && valid_list? && item_idx_in_range(item_idx)
+  end
+
+  def clear_prev_in_listitem(item_idx)
+    @clear_prev.call(@list,item_idx)     if @clear_prev && valid_list? && item_idx_in_range(item_idx)
+  end
+
+  def update_prev_in_listitem(item_idx)
+    @update_prev.call(@list,item_idx)    if @update_prev && valid_list? && item_idx_in_range(item_idx)
+  end
+
+  def find_first_in_listinfo
+    @find_first.call(@list_info,@list)   if @find_first && (@list_info || valid_list?)
+  end
+
+  def find_last_in_listinfo
+    @find_last.call(@list_info,@list)   if @find_last && (@list_info || valid_list?)
+  end
+
+  def find_next_listitem(current_item)
+    @find_next.call(@list,current_item) if @find_next && valid_list? && current_item
+  end
+
+  def find_prev_listitem(current_item)
+    @find_prev.call(@list,current_item) if @find_prev && valid_list? && current_item
+  end
+
+  def organize_list
+    return @list unless @find_first && @find_next
+    first_item = find_first_in_listinfo
+    return @list unless first_item
+    organized = []
+    organized[0] = first_item
+    1.upto(@list.length-1) do |idx|
+      current_item = organized[idx-1]
+      next_item = find_next_listitem(current_item)
+      organized[idx] = next_item
+    end
+    organized
+  end
+
 end

data/spec/complex_doubly_linked_list_spec.rb

@@ -0,0 +1,462 @@
+require 'spec_helper'
+
+describe 'DoublyLinkedList' do
+
+  before(:all) do
+    class DummyList < DoublyLinkedList
+
+      @@clear_first_callback  = lambda { |list_info| list_info.first_item = nil }
+      @@clear_last_callback   = lambda { |list_info| list_info.last_item  = nil }
+      @@update_first_callback = lambda { |list_info, list| list_info.first_item = list.first.item_id }
+      @@update_last_callback  = lambda { |list_info, list| list_info.last_item  = list.last.item_id }
+
+      @@clear_next_callback   = lambda { |list, item_idx| list[item_idx].next_item = nil }
+      @@clear_prev_callback   = lambda { |list, item_idx| list[item_idx].prev_item = nil }
+      @@update_next_callback  = lambda { |list, item_idx| list[item_idx].next_item = list[item_idx+1].item_id }
+      @@update_prev_callback  = lambda { |list, item_idx| list[item_idx].prev_item = list[item_idx-1].item_id }
+
+      @@find_first_callback   = lambda do |list_info, list|
+        if list_info
+          first_id  = list_info.first_item
+          first_idx = list.index { |item| item.item_id == first_id }
+          return list[first_idx] if first_idx
+        end
+
+        # if first isn't set, try to figure out first by looking for an item with prev_item == nil
+        # NOTE: If multiple items have prev_item == nil, it will return the first one it finds.
+        first_idx = list.index { |item| item.prev_item == nil }
+        first_idx ? list[first_idx] : nil
+      end
+
+      @@find_last_callback    = lambda do |list_info, list|
+        if list_info
+          last_id  = list_info.last_item
+          last_idx = list.index { |item| item.item_id == last_id }
+          return list[last_idx] if last_idx && last_idx >= 0 && last_idx < list.size
+        end
+
+        # if last isn't set, try to figure out last by looking for an item with next_item == nil
+        # NOTE: If multiple items have next_item == nil, it will return the first one it finds.
+        last_idx = list.index { |item| item.next_item == nil }
+        last_idx ? list[last_idx] : nil
+      end
+
+      @@find_next_callback    = lambda do |list, current_item|
+        next_id  = current_item.next_item
+        next_idx = list.index { |item| item.item_id == next_id }
+        next_idx ? list[next_idx] : nil
+      end
+      @@find_prev_callback    = lambda do |list, current_item|
+        prev_id  = current_item.prev_item
+        prev_idx = list.index { |item| item.item_id == prev_id }
+        prev_idx ? list[prev_idx] : nil
+      end
+
+      def initialize(*args)
+        new_args = args[0].dup unless args.empty?
+        new_args = {}  if args.empty?
+
+        # set callbacks
+        new_args[:clear_first_callback]  = @@clear_first_callback
+        new_args[:clear_last_callback]   = @@clear_last_callback
+        new_args[:update_first_callback] = @@update_first_callback
+        new_args[:update_last_callback]  = @@update_last_callback
+
+        new_args[:clear_next_callback]   = @@clear_next_callback
+        new_args[:clear_prev_callback]   = @@clear_prev_callback
+        new_args[:update_next_callback]  = @@update_next_callback
+        new_args[:update_prev_callback]  = @@update_prev_callback
+
+        new_args[:find_first_callback]   = @@find_first_callback
+        new_args[:find_last_callback]    = @@find_last_callback
+        new_args[:find_next_callback]    = @@find_next_callback
+        new_args[:find_prev_callback]    = @@find_prev_callback
+
+        super(new_args)
+      end
+
+      def self.get_item_by_id(list,id)
+        list.index { |item| item.item_id == id }
+      end
+
+    end
+
+    class DummyListInfo
+      attr_accessor :first_item, :last_item, :item_ids
+      def initialize(info)
+        @first_item = info[:first_item]  if info.has_key? :first_item
+        @last_item  = info[:last_item]   if info.has_key? :last_item
+        @item_ids   = info[:item_ids]    if info.has_key? :item_ids
+      end
+    end
+
+    class DummyListItem
+      attr_accessor :next_item, :prev_item, :value, :item_id
+      def initialize(item)
+        @next_item = item[:next_item]   if item.has_key? :next_item
+        @prev_item = item[:prev_item]   if item.has_key? :prev_item
+        @value     = item[:value]       if item.has_key? :value
+        @item_id   = item[:item_id]     if item.has_key? :item_id
+      end
+    end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, "DummyList")
+    Object.send(:remove_const, "DummyListInfo")
+    Object.send(:remove_const, "DummyListItem")
+  end
+
+
+  describe '#new' do
+    it "should initialize to empty list" do
+      l = DummyList.new
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+    end
+
+    it "should initialize with list info" do
+      l = DummyList.new :list_info => {:title =>'test list', :description => 'Test out my doubly linked list.'}
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+      expect(l.list_info).to be_kind_of(Hash)
+      expect(l.list_info).to eq( {:title =>'test list', :description => 'Test out my doubly linked list.'} )
+    end
+
+    it "should initialize with items" do
+      # info  = DummyListInfo.new( :first_item => 2, :last_item => 4, :item_ids => [1,2,3,4] )
+      items = []
+      items << DummyListItem.new( :item_id => 1, :prev_item => 2,   :next_item => 3,   :value => 'cat' )
+      items << DummyListItem.new( :item_id => 2, :prev_item => nil, :next_item => 1,   :value => 'dog' )
+      items << DummyListItem.new( :item_id => 3, :prev_item => 1,   :next_item => 4,   :value => 'rabbit' )
+      items << DummyListItem.new( :item_id => 4, :prev_item => 3,   :next_item => nil, :value => 'fish' )
+      l = DummyList.new :items => items
+      # l = DummyList.new :items => items, :list_info => info
+      expect(l.size).to eq 4
+      expect(l.first.value).to eq 'dog'
+      expect(l.last.value).to eq 'fish'
+      list_items = l.to_a.collect {|i| i.value }
+      expect(list_items).to eq ['dog','cat','rabbit','fish']
+    end
+
+    it "should initialize with list info and items" do
+      info  = DummyListInfo.new( :first_item => 4, :last_item => 3, :item_ids => [1,2,3,4] )
+      items = []
+      items << DummyListItem.new( :item_id => 1, :prev_item => 2,   :next_item => 3,   :value => 'cat' )
+      items << DummyListItem.new( :item_id => 2, :prev_item => 4,   :next_item => 1,   :value => 'dog' )
+      items << DummyListItem.new( :item_id => 3, :prev_item => 1,   :next_item => nil, :value => 'rabbit' )
+      items << DummyListItem.new( :item_id => 4, :prev_item => nil, :next_item => 2,   :value => 'fish' )
+      l = DummyList.new :items => items, :list_info => info
+      expect(l.first_item).to eq 4
+      expect(l.last_item).to eq 3
+      expect(l.size).to eq 4
+      expect(l.first.value).to eq 'fish'
+      expect(l.last.value).to eq 'rabbit'
+      list_items = l.to_a.collect {|i| i.value }
+      expect(list_items).to eq ['fish','dog','cat','rabbit']
+    end
+  end
+
+  describe '#add_last' do
+    it "should create list and add item when list is empty" do
+      l = DummyList.new
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+
+      new_item = DummyListItem.new({:value=>'cat',:item_id=>'c1'})
+      expect(l.add_last(new_item)).to eq 1
+      expect(l.size).to eq 1
+      expect(l.first.value).to eq 'cat'
+      expect(l.last.value).to eq 'cat'
+      list_items = l.to_a.collect {|i| i.value }
+      expect(list_items).to eq ['cat']
+    end
+
+    it "should add item after last when one item list" do
+      l = DummyList.new :items => [
+          DummyListItem.new({:value=>'dog',:item_id=>'d1',:prev_item=>nil,:next_item=>nil}) ]
+      expect(l.size).to eq 1
+      expect(l.first.value).to eq 'dog'
+      expect(l.last.value).to eq 'dog'
+
+      new_item = DummyListItem.new({:value=>'cat',:item_id=>'c1'})
+      expect(l.add_last(new_item)).to eq 2
+      expect(l.size).to eq 2
+      expect(l.first.value).to eq 'dog'
+      expect(l.last.value).to eq 'cat'
+      list_items = l.to_a.collect {|i| i.value }
+      expect(list_items).to eq ['dog','cat']
+    end
+
+    it "should add item after last when multiple item list" do
+      l = DummyList.new :items => [
+          DummyListItem.new({:value=>'cat',    :item_id=>'c1', :prev_item=>nil,  :next_item=>'d1'}),
+          DummyListItem.new({:value=>'dog',    :item_id=>'d1', :prev_item=>'c1', :next_item=>'r1'}),
+          DummyListItem.new({:value=>'rabbit', :item_id=>'r1', :prev_item=>'d1', :next_item=>'f1'}),
+          DummyListItem.new({:value=>'fish',   :item_id=>'f1', :prev_item=>'r1', :next_item=>nil })]
+      expect(l.size).to eq 4
+      expect(l.first.value).to eq 'cat'
+      expect(l.last.value).to eq 'fish'
+
+      new_item = DummyListItem.new({:value=>'gerbil',:item_id=>'g1'})
+      expect(l.add_last(new_item)).to eq 5
+      expect(l.size).to eq 5
+      expect(l.first.value).to eq 'cat'
+      expect(l.last.value).to eq 'gerbil'
+      list_items = l.to_a.collect {|i| i.value }
+      expect(list_items).to eq ['cat','dog','rabbit','fish','gerbil']
+    end
+  end
+
+  describe '#add_first' do
+    it "should create list and add item when list is empty" do
+      l = DummyList.new
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+
+      new_item = DummyListItem.new({:value=>'cat',:item_id=>'c1'})
+      expect(l.add_first(new_item)).to eq 1
+      expect(l.size).to eq 1
+      expect(l.first.value).to eq 'cat'
+      expect(l.last.value).to eq 'cat'
+      list_items = l.to_a.collect {|i| i.value }
+      expect(list_items).to eq ['cat']
+    end
+
+    it "should add item before first when one item list" do
+      l = DummyList.new :items => [
+          DummyListItem.new({:value=>'dog',:item_id=>'d1',:prev_item=>nil,:next_item=>nil}) ]
+      expect(l.size).to eq 1
+      expect(l.first.value).to eq 'dog'
+      expect(l.last.value).to eq 'dog'
+
+      new_item = DummyListItem.new({:value=>'cat',:item_id=>'c1'})
+      expect(l.add_first(new_item)).to eq 2
+      expect(l.size).to eq 2
+      expect(l.first.value).to eq 'cat'
+      expect(l.last.value).to eq 'dog'
+      list_items = l.to_a.collect {|i| i.value }
+      expect(list_items).to eq ['cat','dog']
+    end
+
+    it "should add item before first when multiple item list" do
+      l = DummyList.new :items => [
+          DummyListItem.new({:value=>'cat',    :item_id=>'c1', :prev_item=>nil,  :next_item=>'d1'}),
+          DummyListItem.new({:value=>'dog',    :item_id=>'d1', :prev_item=>'c1', :next_item=>'r1'}),
+          DummyListItem.new({:value=>'rabbit', :item_id=>'r1', :prev_item=>'d1', :next_item=>'f1'}),
+          DummyListItem.new({:value=>'fish',   :item_id=>'f1', :prev_item=>'r1', :next_item=>nil })]
+      expect(l.size).to eq 4
+      expect(l.first.value).to eq 'cat'
+      expect(l.last.value).to eq 'fish'
+
+      new_item = DummyListItem.new({:value=>'gerbil',:item_id=>'g1'})
+      expect(l.add_first(new_item)).to eq 5
+      expect(l.size).to eq 5
+      expect(l.first.value).to eq 'gerbil'
+      expect(l.last.value).to eq 'fish'
+      list_items = l.to_a.collect {|i| i.value }
+      expect(list_items).to eq ['gerbil','cat','dog','rabbit','fish']
+    end
+  end
+
+  describe '#remove_last' do
+    it "should return nil when list is empty" do
+      l = DummyList.new
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+
+      expect(l.remove_last).to be_nil
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+    end
+
+    it "should remove item emptying the list and return item's data when one item list" do
+      l = DummyList.new :items => [
+          DummyListItem.new({:value=>'dog',:item_id=>'d1',:prev_item=>nil,:next_item=>nil}) ]
+      expect(l.size).to eq 1
+      expect(l.first.value).to eq 'dog'
+      expect(l.last.value).to eq 'dog'
+
+      expect(l.remove_last.value).to eq 'dog'
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+    end
+
+    it "should add item before first when multiple item list" do
+      l = DummyList.new :items => [
+          DummyListItem.new({:value=>'cat',    :item_id=>'c1', :prev_item=>nil,  :next_item=>'d1'}),
+          DummyListItem.new({:value=>'dog',    :item_id=>'d1', :prev_item=>'c1', :next_item=>'r1'}),
+          DummyListItem.new({:value=>'rabbit', :item_id=>'r1', :prev_item=>'d1', :next_item=>'f1'}),
+          DummyListItem.new({:value=>'fish',   :item_id=>'f1', :prev_item=>'r1', :next_item=>nil })]
+      expect(l.size).to eq 4
+      expect(l.first.value).to eq 'cat'
+      expect(l.last.value).to eq 'fish'
+
+      expect(l.remove_last.value).to eq 'fish'
+      expect(l.size).to eq 3
+      expect(l.first.value).to eq 'cat'
+      expect(l.last.value).to eq 'rabbit'
+      list_items = l.to_a.collect {|i| i.value }
+      expect(list_items).to eq ['cat','dog','rabbit']
+    end
+  end
+
+  describe '#remove_first' do
+    it "should return nil when list is empty" do
+      l = DummyList.new
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+
+      expect(l.remove_first).to be_nil
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+    end
+
+    it "should remove item emptying the list and return item's data when one item list" do
+      l = DummyList.new :items => [
+          DummyListItem.new({:value=>'dog',:item_id=>'d1',:prev_item=>nil,:next_item=>nil}) ]
+      expect(l.size).to eq 1
+      expect(l.first.value).to eq 'dog'
+      expect(l.last.value).to eq 'dog'
+
+      expect(l.remove_first.value).to eq 'dog'
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+    end
+
+    it "should add item before first when multiple item list" do
+      l = DummyList.new :items => [
+          DummyListItem.new({:value=>'cat',    :item_id=>'c1', :prev_item=>nil,  :next_item=>'d1'}),
+          DummyListItem.new({:value=>'dog',    :item_id=>'d1', :prev_item=>'c1', :next_item=>'r1'}),
+          DummyListItem.new({:value=>'rabbit', :item_id=>'r1', :prev_item=>'d1', :next_item=>'f1'}),
+          DummyListItem.new({:value=>'fish',   :item_id=>'f1', :prev_item=>'r1', :next_item=>nil })]
+      expect(l.size).to eq 4
+      expect(l.first.value).to eq 'cat'
+      expect(l.last.value).to eq 'fish'
+
+      expect(l.remove_first.value).to eq 'cat'
+      expect(l.size).to eq 3
+      expect(l.first.value).to eq 'dog'
+      expect(l.last.value).to eq 'fish'
+      list_items = l.to_a.collect {|i| i.value }
+      expect(list_items).to eq ['dog','rabbit','fish']
+    end
+  end
+
+  describe '#missing_method' do
+    before(:all) do
+      class Dummy < DummyListInfo
+        def hello
+          "hello back at you"
+        end
+        def size
+          "very large indeed"
+        end
+      end
+    end
+    after(:all) do
+      Object.send(:remove_const, "Dummy")
+    end
+
+    context "when list responds to missing method" do
+      it "should pass method to list and succeed" do
+        l = DummyList.new :list_info => Dummy.new({}), :items => [
+            DummyListItem.new({:value=>'cat',    :item_id=>'c1', :prev_item=>nil,  :next_item=>'d1'}),
+            DummyListItem.new({:value=>'dog',    :item_id=>'d1', :prev_item=>'c1', :next_item=>'r1'}),
+            DummyListItem.new({:value=>'rabbit', :item_id=>'r1', :prev_item=>'d1', :next_item=>'f1'}),
+            DummyListItem.new({:value=>'fish',   :item_id=>'f1', :prev_item=>'r1', :next_item=>nil })]
+        list_items = l.values_at(1..2).collect {|i| i.value }
+        expect(list_items).to eq ['dog','rabbit']
+        sort_list = l.sort { |x,y| x.value <=> y.value }
+        list_items = sort_list.to_a.collect {|i| i.value }
+        expect(list_items).to eq ['cat','dog','fish','rabbit']
+      end
+
+      it "should pass method to list only even if list_info has the same method and succeed" do
+        l = DummyList.new :list_info => Dummy.new({}), :items => [
+            DummyListItem.new({:value=>'cat',    :item_id=>'c1', :prev_item=>nil,  :next_item=>'d1'}),
+            DummyListItem.new({:value=>'dog',    :item_id=>'d1', :prev_item=>'c1', :next_item=>'r1'}),
+            DummyListItem.new({:value=>'rabbit', :item_id=>'r1', :prev_item=>'d1', :next_item=>'f1'}),
+            DummyListItem.new({:value=>'fish',   :item_id=>'f1', :prev_item=>'r1', :next_item=>nil })]
+        expect(l.size).to eq 4
+      end
+
+      it "should pass method each to the list" do
+        l = DummyList.new :list_info => Dummy.new({}), :items => [
+            DummyListItem.new({:value=>'cat',    :item_id=>'c1', :prev_item=>nil,  :next_item=>'d1'}),
+            DummyListItem.new({:value=>'dog',    :item_id=>'d1', :prev_item=>'c1', :next_item=>'r1'}),
+            DummyListItem.new({:value=>'rabbit', :item_id=>'r1', :prev_item=>'d1', :next_item=>'f1'}),
+            DummyListItem.new({:value=>'fish',   :item_id=>'f1', :prev_item=>'r1', :next_item=>nil })]
+        a = []
+        l.each do |i|
+          a << i
+          list_items = l.to_a.collect {|i| i.value }
+          expect(list_items).to include i.value
+        end
+        list_items = a.to_a.collect {|i| i.value }
+        expect(list_items).to eq ['cat','dog','rabbit','fish']
+      end
+
+      it "should pass method each to the list when block is inline" do
+        l = DummyList.new :list_info => Dummy.new({}), :items => [
+            DummyListItem.new({:value=>'cat',    :item_id=>'c1', :prev_item=>nil,  :next_item=>'d1'}),
+            DummyListItem.new({:value=>'dog',    :item_id=>'d1', :prev_item=>'c1', :next_item=>'r1'}),
+            DummyListItem.new({:value=>'rabbit', :item_id=>'r1', :prev_item=>'d1', :next_item=>'f1'}),
+            DummyListItem.new({:value=>'fish',   :item_id=>'f1', :prev_item=>'r1', :next_item=>nil })]
+        a = []
+        l.each { |i| a<<i; list_items = l.to_a.collect {|i| i.value }; expect(list_items).to include i.value }
+        list_items = a.to_a.collect {|i| i.value }
+        expect(list_items).to eq ['cat','dog','rabbit','fish']
+      end
+    end
+
+    context "when list does not respond to missing method" do
+      it "should pass method to list_info and succeed if list_info responds to that method" do
+        l = DummyList.new :list_info => Dummy.new({}), :items => [
+            DummyListItem.new({:value=>'cat',    :item_id=>'c1', :prev_item=>nil,  :next_item=>'d1'}),
+            DummyListItem.new({:value=>'dog',    :item_id=>'d1', :prev_item=>'c1', :next_item=>'r1'}),
+            DummyListItem.new({:value=>'rabbit', :item_id=>'r1', :prev_item=>'d1', :next_item=>'f1'}),
+            DummyListItem.new({:value=>'fish',   :item_id=>'f1', :prev_item=>'r1', :next_item=>nil })]
+        expect(l.hello).to eq 'hello back at you'
+      end
+
+      it "should not pass array method to list_info when @list is empty and succeed if list_info responds to that method" do
+        l = DummyList.new :list_info => Dummy.new({})
+        expect(l.size).not_to eq 'very large indeed'
+        expect(l.size).to eq 0
+      end
+    end
+
+    context "when neither list nor list_info respond to missing method" do
+      it "should raise an error if it is not an array method nor list_info method" do
+        l = DummyList.new :list_info => Dummy.new({}), :items => [
+            DummyListItem.new({:value=>'cat',    :item_id=>'c1', :prev_item=>nil,  :next_item=>'d1'}),
+            DummyListItem.new({:value=>'dog',    :item_id=>'d1', :prev_item=>'c1', :next_item=>'r1'}),
+            DummyListItem.new({:value=>'rabbit', :item_id=>'r1', :prev_item=>'d1', :next_item=>'f1'}),
+            DummyListItem.new({:value=>'fish',   :item_id=>'f1', :prev_item=>'r1', :next_item=>nil })]
+        expect{ l.foo }.to raise_error(NoMethodError, /undefined method `foo'/)
+      end
+    end
+  end
+
+  describe '#inspect' do
+    it "should return class and items" do
+      l = DummyList.new :list_info => DummyListInfo.new({}), :items => [
+          DummyListItem.new({:value=>'cat',    :item_id=>'c1', :prev_item=>nil,  :next_item=>'d1'}),
+          DummyListItem.new({:value=>'dog',    :item_id=>'d1', :prev_item=>'c1', :next_item=>'r1'}),
+          DummyListItem.new({:value=>'rabbit', :item_id=>'r1', :prev_item=>'d1', :next_item=>nil })]
+      expect(l.inspect).to match /#<DummyList:0x(\d|[abcdef])* \[(\s|\S)*@value="cat"(\s|\S)*@value="dog"(\s|\S)*@value="rabbit"(\s|\S)*/
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: doubly_linked_list
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - E. Lynette Rayle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-30 00:00:00.000000000 Z
+date: 2015-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -85,7 +85,8 @@ files:
 - Rakefile
 - doubly_linked_list.gemspec
 - lib/doubly_linked_list.rb
-- spec/doubly_linked_list_spec.rb
+- spec/complex_doubly_linked_list_spec.rb
+- spec/simple_doubly_linked_list_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/elrayle/doubly_linked_list
 licenses:
@@ -113,5 +114,6 @@ specification_version: 4
 summary: Ruby implementation of doubly_linked_lists using an array to hold and manipulate
   items.
 test_files:
-- spec/doubly_linked_list_spec.rb
+- spec/complex_doubly_linked_list_spec.rb
+- spec/simple_doubly_linked_list_spec.rb
 - spec/spec_helper.rb