linked_list 1.0.0

data/Benchmarks.txt

@@ -0,0 +1,26 @@
+(in /Users/francois/Documents/work/linked_list)
+Loaded suite -e
+Started
+.................................................................................................
+Finished in 0.015711 seconds.
+
+97 tests, 97 assertions, 0 failures, 0 errors
+Building a list of 1 million random strings
+Took 4.389 seconds
+Converting to an array
+Took 1.686 seconds
+                      user     system      total        real
+list#push/pop     0.350000   0.000000   0.350000 (  0.364001)
+array#push/pop    0.000000   0.000000   0.000000 (  0.009894)
+                      user     system      total        real
+list#last         0.000000   0.000000   0.000000 (  0.000027)
+array#last        0.000000   0.000000   0.000000 (  0.000012)
+                      user     system      total        real
+list#first        0.010000   0.000000   0.010000 (  0.001188)
+array#first       0.000000   0.000000   0.000000 (  0.000449)
+                      user     system      total        real
+list#reverse      7.540000   0.170000   7.710000 (  7.806306)
+array#reverse     0.010000   0.010000   0.020000 (  0.008443)
+                      user     system      total        real
+list#dup         23.080000   0.380000  23.460000 ( 24.039316)
+array#dup         0.000000   0.000000   0.000000 (  0.000017)

data/History.txt

@@ -0,0 +1,4 @@
+== 1.0.0 2008-11-12
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,14 @@
+History.txt
+Manifest.txt
+Benchmarks.txt
+README.rdoc
+Rakefile
+lib/linked_list.rb
+lib/linked_list/node.rb
+script/console
+script/destroy
+script/generate
+tasks/benchmark.rake
+test/test_helper.rb
+test/test_linked_list.rb
+test/test_linked_list_node.rb

data/README.rdoc

@@ -0,0 +1,58 @@
+= LinkedList
+
+* http://linkedlist.rubyforge.org/
+
+== DESCRIPTION:
+
+A simple linked list implementation that follows Ruby's conventions.
+
+== FEATURES/PROBLEMS:
+
+* FIXME: #dup is implemented by reversing the list twice.  This should be pretty slow...  Untested, not benchmarked.
+* This implementation isn't thread safe.
+
+== SYNOPSIS:
+
+  list = LinkedList.new
+  list << "a"
+  list.push "b"
+  list.unshift "c"
+  list.inspect
+  #=> ("c" ("b" ("a" nil)))
+  list.pop
+  #=> ("b" ("a" nil))
+  list.map {|v| v*2}
+  #=> ("bb" ("aa" nil))
+
+== REQUIREMENTS:
+
+* Ruby 1.8.6+
+
+== INSTALL:
+
+* sudo gem install linked_list
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 François Beausoleil
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,22 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/linked_list'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('linked_list', LinkedList::VERSION) do |p|
+  p.developer('François Beausoleil', 'francois@teksol.info')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name       = "linkedlist"
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"],
+    ['francois-shoulda', ">= 2.0.5"]
+  ]
+
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }

data/lib/linked_list.rb

@@ -0,0 +1,204 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "linked_list/node"
+
+# Linked list implementation.
+# Linked lists have O(1) insertions and pops.  Traversal is O(n).
+#
+# == Implementation Notes
+# This implementation isn't thread safe.  In fact, traversal is thread safe, but insertions and removals aren't.
+#
+# This implementation has problems with #dup, but beyond that, it looks fine.  It needs to be battle tested though.
+# As a performance optimization, #size is cached and maintained locally, instead of being recalculated everytime.
+class LinkedList
+  VERSION = '1.0.0'
+  include Enumerable
+
+  attr_reader :cdr, :size
+  alias_method :length, :size
+
+  def initialize
+    clear
+  end
+
+  # Two lists are equal if they have the same values in the same positions.
+  def ==(other)
+    cdr == other.cdr
+  end
+
+  # A list is empty if it doesn't have any nodes.
+  def empty?
+    cdr.nil?
+  end
+
+  # Returns a duplicate of this list, where the nodes are also copied.
+  # FIXME: Performance hog...  The implementation sucks big time.
+  def dup
+    reverse.reverse
+  end
+
+  # Yields each value
+  def each
+    each_node do |node|
+      yield node.value
+    end
+  end
+
+  # Yields each LinkedList::Node (or subclass)
+  def each_node
+    node = cdr
+    while node
+      yield node
+      node = node.cdr
+    end
+  end
+  protected :each_node
+
+  # Returns an Array that has the same values as this LinkedList
+  def to_a
+    inject(Array.new) do |memo, value|
+      memo << value
+    end
+  end
+
+  def at(index)
+    index = normalize_index(index)
+    each_with_index do |value, idx|
+      return value if index == idx
+    end
+    nil
+  end
+  
+  def normalize_index(index)
+    index < 0 ? (length + index) : index
+  end
+  protected :normalize_index
+
+  def [](*args)
+    case args.length
+    when 1
+      case args.first
+      when Range
+        indexes = args.first
+        start, stop = normalize_index(indexes.first), normalize_index(indexes.exclude_end? ? indexes.last - 1 : indexes.last)
+        indexes = (start .. stop)
+        result = []
+        each_with_index do |value, idx|
+          next unless indexes.include?(idx)
+          result << value
+        end
+        result
+      else
+        at(args.first)
+      end
+    when 2
+      index = normalize_index(args.first)
+      return nil unless (0 .. length).include?(index)
+      count = args.last
+      self[index ... (index + count)]
+    else
+      raise ArgumentError, "Expected (index), (index, length) or (index0..index1), received #{args.inspect}"
+    end
+  end
+
+  # Returns a new instance of self with a reverse insertion order
+  def reverse
+    list = new_species
+    each do |value|
+      list << value
+    end
+    list
+  end
+
+  # Destructively maps this list's values to the return value of the block
+  def map!
+    each_node do |node|
+      node.value = yield(node.value)
+    end
+  end
+
+  # Returns a new instance of self where the values have been replaced with the results of the block's
+  def map(&block)
+    list = dup
+    list.map!(&block)
+    list
+  end
+
+  # Pushes a new value at the head of this list
+  def <<(value)
+    @cdr = new_node(value, cdr)
+    @lcdr = @cdr if @lcdr.nil?
+    @size += 1
+    self
+  end
+  alias_method :push, :<<
+  alias_method :unshift, :<<
+
+  # Pops the head of the list, returning the value
+  def pop
+    return nil if empty?
+    @size -= 1
+    value = cdr.value
+    @cdr = cdr.cdr
+    @lcdr = nil if empty?
+    value
+  end
+  alias_method :shift, :pop
+
+  # Initializes this list to the empty state
+  def clear
+    @cdr, @lcdr, @size = nil, nil, 0
+  end
+
+  # Returns the first value of this list
+  def first
+    cdr.nil? ? nil : cdr.value
+  end
+
+  # Returns the last value of this list
+  def last
+    return nil if empty?
+    @lcdr.value
+  end
+
+  def concat(other)
+    result = new_species
+    other.reverse.each do |value|
+      result << value
+    end
+    self.reverse.each do |value|
+      result << value
+    end
+    result
+  end
+  alias_method :+, :concat
+
+  # Returns a new instance of the same class as self.
+  def new_species
+    self.class.new
+  end
+  protected :new_species
+
+  # Returns a new node instance.
+  def new_node(value, cdr)
+    node_class.new(value, cdr)
+  end
+  protected :new_node
+
+  # Returns the class of node to use.  Defaults to LinkedList::Node.
+  def node_class
+    LinkedList::Node
+  end
+  protected :node_class
+
+  # Returns a nice looking view of this list.
+  #  list = LinkedList.new
+  #  list.push "a"
+  #  list.push "b"
+  #  list.inspect
+  #  #=> ("b" ("a" nil))
+  def inspect
+    cdr.inspect
+  end
+end

data/lib/linked_list/node.rb

@@ -0,0 +1,23 @@
+class LinkedList
+  # Implements a single node of the linked list.
+  class Node
+    attr_accessor :cdr, :value
+
+    def initialize(value, cdr)
+      @cdr, @value = cdr, value
+    end
+
+    # Two nodes are equal if their values are equal and their cdr's are equal too.
+    def ==(other)
+      cdr == other.cdr && value == other.value
+    end
+
+    # Returns a nice-looking string.
+    #  node = LinkedList::Node.new("a", nil)
+    #  node.inspect
+    #  #=> ("a" nil)
+    def inspect
+      "(#{value.inspect} #{cdr.inspect})"
+    end
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/linked_list.rb'}"
+puts "Loading linked_list gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/tasks/benchmark.rake

@@ -0,0 +1,74 @@
+namespace :test do
+  task :benchmark => %w(test) do
+    require "benchmark"
+    include Benchmark
+    $:.unshift File.dirname(__FILE__) + "/../lib"
+    require "linked_list"
+
+    puts "Building a list of 1 million random strings"
+    list = nil
+    time = realtime do
+      list = list_of_elements(1_000_000)
+    end
+    puts "Took %.3f seconds" % time
+    puts "Converting to an array"
+    array = nil
+    time = realtime do
+      array = list.to_a
+    end
+    puts "Took %.3f seconds" % time
+
+    bm(16) do |x|
+      x.report("list#push/pop")  do
+        20_000.times do
+          list.push "a"
+        end
+        20_000.times do
+          list.pop
+        end
+      end
+      x.report("array#push/pop") do
+        20_000.times do
+          array.push "a"
+        end
+        20_000.times do
+          array.pop
+        end
+      end
+    end
+
+    bm(16) do |x|
+      x.report("list#last")  { 20.times { list.last } }
+      x.report("array#last") { 20.times { array.last } }
+    end
+
+    bm(16) do |x|
+      x.report("list#first")  { 2_000.times { list.first } }
+      x.report("array#first") { 2_000.times { array.first } }
+    end
+
+    bm(16) do |x|
+      x.report("list#reverse")  { list.reverse }
+      x.report("array#reverse") { array.reverse }
+    end
+
+    bm(16) do |x|
+      x.report("list#dup")  { list.dup }
+      x.report("array#dup") { array.dup }
+    end
+  end
+end
+
+def list_of_elements(count)
+  list = LinkedList.new
+  count.times do
+    list <<  nil
+  end
+  list
+end
+
+CHARS = ('a' .. 'z').to_a + ('A' .. 'Z').to_a + ('0' .. '9').to_a
+LENGTH = CHARS.length
+def random_string
+  (0..10).inject("") {|str, _| str << CHARS[rand(LENGTH)]}
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/linked_list'
+require "rubygems"
+
+gem "francois-shoulda"
+require "shoulda"

data/test/test_linked_list.rb

@@ -0,0 +1,516 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestLinkedList < Test::Unit::TestCase
+  context "An empty LinkedList" do
+    setup do
+      @list = LinkedList.new
+    end
+
+    context "#push'ing a value of nil" do
+      setup do
+        @list.push nil
+      end
+
+      should "have a length of 1" do
+        assert_equal 1, @list.length
+      end
+
+      should "be equal to [nil]" do
+        assert_equal [nil], @list.to_a
+      end
+    end
+
+    context "#push'ing an element" do
+      setup do
+        @list.push "a"
+      end
+
+      should "be equal to ['a']" do
+        assert_equal %w(a), @list.to_a
+      end
+    end
+
+    context "calling #reverse" do
+      setup do
+        @other = @list.reverse
+      end
+
+      should "return another list instance" do
+        assert_not_same @list, @other
+      end
+
+      should "return an empty list" do
+        assert @other.empty?
+      end
+    end
+
+    context "calling #to_a" do
+      setup do
+        @other = @list.to_a
+      end
+
+      should "be an Array" do
+        assert_kind_of Array, @other
+      end
+
+      should "be empty" do
+        assert @other.empty?
+      end
+    end
+
+    should "return nil on #at(0)" do
+      assert_nil @list.at(0)
+    end
+
+    should "return nil on #at(-1)" do
+      assert_nil @list.at(-1)
+    end
+
+    should "return nil on #[](1)" do
+      assert_nil @list[1]
+    end
+
+    should "return nil on #[](-1)" do
+      assert_nil @list[-1]
+    end
+
+    should "return nil on #[](0, 1)" do
+      assert_equal [], @list[0, 1]
+    end
+
+    should "return nil on #[](0..1)" do
+      assert_equal [], @list[0..1]
+    end
+
+    should "return nil on #[](0)" do
+      assert_nil @list[0]
+    end
+
+    should "return a new instance when calling #dup" do
+      assert_not_same @list, @list.dup
+    end
+
+    should "return nil for #first" do
+      assert_nil @list.first
+    end
+
+    should "return nil for #last" do
+      assert_nil @list.last
+    end
+
+    should "be empty" do
+      assert @list.empty?
+    end
+
+    should "have a length of 0" do
+      assert_equal 0, @list.length
+    end
+
+    should "have a size of 0" do
+      assert_equal 0, @list.size
+    end
+
+    should "never call the #each block" do
+      yielded = 0
+      @list.each do |value|
+        yielded += 1
+      end
+      assert yielded.zero?
+    end
+
+    context "calling #concat(['a'])" do
+      setup do
+        @other = @list.concat(%w(a))
+      end
+
+      should "return a new list" do
+        assert_not_same @other, @list
+      end
+
+      should "return a list with one more element" do
+        assert_equal @list.length + 1, @other.length
+      end
+
+      should "return a list equal to ('a' nil)" do
+        assert_equal LinkedList.new << "a", @other
+      end
+    end
+  end
+
+  context "A linked list with one element" do
+    setup do
+      @list = LinkedList.new
+      @list << "a"
+    end
+
+    context "calling #pop" do
+      setup do
+        @element = @list.pop
+      end
+
+      should "be empty?" do
+        assert @list.empty?
+      end
+
+      should "return the element" do
+        assert_equal "a", @element
+      end
+
+      should "have a size of 0" do
+        assert @list.size.zero?
+      end
+
+      should "return nil from #last" do
+        assert_nil @list.last
+      end
+
+      should "return nil from #first" do
+        assert_nil @list.first
+      end
+
+      context "pushing 'b'" do
+        setup do
+          @list.push "b"
+        end
+
+        should "NOT be empty" do
+          assert !@list.empty?
+        end
+
+        should "be ['b']" do
+          assert_equal %w(b), @list.to_a
+        end
+
+        should "return 'b' from #last" do
+          assert_equal "b", @list.last
+        end
+
+        should "return 'b' from #first" do
+          assert_equal "b", @list.first
+        end
+      end
+    end
+
+    context "calling #to_a" do
+      setup do
+        @other = @list.to_a
+      end
+
+      should "be equal to ['a']" do
+        assert_equal %w(a), @other
+      end
+    end
+
+    context "calling #reverse" do
+      setup do
+        @other = @list.reverse
+      end
+
+      should "be equal to the initial list" do
+        assert_equal @list, @other
+      end
+    end
+
+    context "calling #dup" do
+      setup do
+        @other = @list.dup
+      end
+
+      should "be a new instance" do
+        assert_not_same @list, @other
+      end
+
+      should "have duplicated the nodes" do
+        @list.map! {|value| value*2}
+        assert_not_equal @list, @other
+      end
+    end
+
+    should "return 'a' for #at(-1)" do
+      assert_equal "a", @list.at(-1)
+    end
+
+    should "return 'a' for #at(0)" do
+      assert_equal "a", @list.at(0)
+    end
+
+    should "return nil for #at(2)" do
+      assert_nil @list.at(2)
+    end
+
+    should "return nil for #at(-2)" do
+      assert_nil @list.at(-2)
+    end
+
+    should "return nil for #at(1)" do
+      assert_nil @list.at(1)
+    end
+
+    should "return 'a' for #first" do
+      assert_equal "a", @list.first
+    end
+
+    should "return 'a' for #last" do
+      assert_equal "a", @list.last
+    end
+
+    should "NOT be empty?" do
+      assert !@list.empty?
+    end
+
+    should "have a size of 1" do
+      assert_equal 1, @list.size
+    end
+
+    should "yield the single element to the #each block" do
+      @list.each do |value|
+        assert_equal "a", value
+      end
+    end
+
+    should "yield once calling #each" do
+      yielded = 0
+      @list.each do |value|
+        yielded += 1
+      end
+      assert_equal 1, yielded
+    end
+
+    should "yield the value and the index when calling #each_with_index" do
+      yields = []
+      @list.each_with_index do |value, index|
+        yields << [value, index]
+      end
+      assert_equal [["a", 0]], yields
+    end
+
+    should "include?('a')" do
+      assert @list.include?("a")
+    end
+
+    should "NOT include?('b')" do
+      assert !@list.include?("b")
+    end
+  end
+
+  context "A list with 2 elements" do
+    setup do
+      @list = LinkedList.new
+      @list << "a"
+      @list << "b"
+    end
+
+    context "calling #to_a" do
+      setup do
+        @other = @list.to_a
+      end
+
+      should "be equal to ['b', 'a']" do
+        assert_equal %w(b a), @other
+      end
+    end
+
+    context "calling #reverse" do
+      setup do
+        @other = @list.reverse
+      end
+
+      should "return the elements in insertion order" do
+        assert_equal %w(a b), @other.to_a
+      end
+    end
+
+    context "cleared" do
+      setup do
+        @list.clear
+      end
+
+      should "be empty?" do
+        assert @list.empty?
+      end
+    end
+
+    context "#map" do
+      setup do
+        @other = @list.map {|f| f*2}
+      end
+
+      should "return a list of 2 elements" do
+        assert_equal 2, @other.length
+      end
+
+      should "include?('aa')" do
+        assert @other.include?("aa")
+      end
+
+      should "include?('bb')" do
+        assert @other.include?("bb")
+      end
+
+      should "NOT have reversed the list" do
+        assert_equal %w(bb aa), @other.to_a
+      end
+    end
+
+    context "calling #pop" do
+      setup do
+        @element = @list.pop
+      end
+
+      should "NOT be empty?" do
+        assert !@list.empty?
+      end
+
+      should "return the moast recently pushed element" do
+        assert_equal "b", @element
+      end
+
+      should "have a size of 1" do
+        assert_equal 1, @list.size
+      end
+    end
+
+    should "return 'b' for #at(0)" do
+      assert_equal "b", @list.at(0)
+    end
+
+    should "return 'a' for #at(1)" do
+      assert_equal "a", @list.at(1)
+    end
+
+    should "return 'a' for #at(-1)" do
+      assert_equal "a", @list.at(-1)
+    end
+
+    should "return 'b' for #at(-2)" do
+      assert_equal "b", @list.at(-2)
+    end
+
+    should "return 'b' for #first" do
+      assert_equal "b", @list.first
+    end
+
+    should "return 'a' for #last" do
+      assert_equal "a", @list.last
+    end
+
+    should "include?('b')" do
+      assert @list.include?("b")
+    end
+
+    should "have a length of 2" do
+      assert_equal 2, @list.length
+    end
+
+    should "yield the value and the index when calling #each_with_index" do
+      yields = []
+      @list.each_with_index do |value, index|
+        yields << [value, index]
+      end
+      assert_equal [["b", 0], ["a", 1]], yields
+    end
+  end
+
+  context "A list with 5 elements" do
+    setup do
+      @list = LinkedList.new
+      @list << "a" << "b" << "c" << "d" << "e"
+    end
+
+    should "have a length of 5" do
+      assert_equal 5, @list.length
+    end
+
+    should "return 'a' for #at(-1)" do
+      assert_equal "a", @list.at(-1)
+    end
+
+    should "return 'e' for #at(-5)" do
+      assert_equal "e", @list.at(-5)
+    end
+
+    should "return ['e', 'd', 'c', 'b', 'a'] for #[](0..10)" do
+      assert_equal %w(e d c b a), @list[0..10]
+    end
+
+    should "return ['e', 'd'] for #[](0..1)" do
+      assert_equal %w(e d), @list[0..1]
+    end
+
+    should "return ['e'] for #[](0..0)" do
+      assert_equal %w(e), @list[0..0]
+    end
+
+    should "return ['e', 'd', 'c'] for #[](0..2)" do
+      assert_equal %w(e d c), @list[0..2]
+    end
+
+    should "return ['e', 'd', 'c', 'b', 'a'] for #[](0, 10)" do
+      assert_equal %w(e d c b a), @list[0, 10]
+    end
+
+    should "return ['e'] for #[](0, 1)" do
+      assert_equal %w(e), @list[0, 1]
+    end
+
+    should "return ['e', 'd'] for #[](0, 2)" do
+      assert_equal %w(e d), @list[0, 2]
+    end
+
+    should "return nil for #[](-240)" do
+      assert_nil @list[-240]
+    end
+
+    should "return nil for #[](240)" do
+      assert_nil @list[240]
+    end
+
+    should "return nil for #[](-240, 100)" do
+      assert_nil @list[-240, 100]
+    end
+
+    should "return nil for #[](240, 100)" do
+      assert_nil @list[240, 100]
+    end
+
+    should "return ['b', 'a'] for #[](-2..-1)" do
+      assert_equal %w(b a), @list[-2..-1]
+    end
+
+    should "return ['c', 'b'] for #[](-3, 2)" do
+      assert_equal %w(c b), @list[-3, 2]
+    end
+
+    context "calling #concat(['x', 'y', 'z'])" do
+      setup do
+        @other = @list.concat(%w(x y z))
+      end
+
+      should "return a new list" do
+        assert_not_same @list, @other
+      end
+
+      should "return a list of 8 elements" do
+        assert_equal 8, @other.length
+      end
+
+      should "return a LinkedList" do
+        assert_kind_of LinkedList, @other
+      end
+
+      should "return ['e', 'd', 'c', 'b', 'a', 'x', 'y', 'z']" do
+        assert_equal %w(e d c b a x y z), @other.to_a
+      end
+    end
+
+    context "calling #+(('z' nil))" do
+      setup do
+        @other = @list + (LinkedList.new << "z")
+      end
+
+      should "return ['e', 'd', 'c', 'b', 'a', 'z']" do
+        assert_equal %w(e d c b a z), @other.to_a
+      end
+    end
+  end
+end

data/test/test_linked_list_node.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestLinkedListNode < Test::Unit::TestCase
+  context "A node with the empty string as a value at the end of the chain" do
+    setup do
+      @node = LinkedList::Node.new("", nil)
+    end
+
+    should "be equal to itself" do
+      assert_equal @node, @node
+    end
+
+    should "be equal to another node that is empty" do
+      assert_equal @node, LinkedList::Node.new("", nil)
+    end
+
+    should "NOT be equal to another node that has a different value" do
+      assert_not_equal @node, LinkedList::Node.new("a", nil)
+    end
+
+    should "NOT be equal to another node that has a different cdr" do
+      assert_not_equal @node, LinkedList::Node.new("", LinkedList::Node.new(nil, nil))
+    end
+
+    should "be inspectable" do
+      assert_equal "(\"\" nil)", @node.inspect
+    end
+  end
+
+  context "A node with a value of 'a' and a successor of 'b'" do
+    setup do
+      @tail = LinkedList::Node.new("b", nil)
+      @head = LinkedList::Node.new("a", @tail)
+    end
+
+    should "be inspectable" do
+      assert_equal "(\"a\" (\"b\" nil))", @head.inspect
+    end
+  end
+
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: linked_list
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- "Fran\xC3\xA7ois Beausoleil"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-12 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.7
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: francois-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.5
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: A simple linked list implementation that follows Ruby's conventions.
+email: 
+- francois@teksol.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- Benchmarks.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- Benchmarks.txt
+- README.rdoc
+- Rakefile
+- lib/linked_list.rb
+- lib/linked_list/node.rb
+- script/console
+- script/destroy
+- script/generate
+- tasks/benchmark.rake
+- test/test_helper.rb
+- test/test_linked_list.rb
+- test/test_linked_list_node.rb
+has_rdoc: true
+homepage: http://linkedlist.rubyforge.org/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: linkedlist
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A simple linked list implementation that follows Ruby's conventions.
+test_files: 
+- test/test_helper.rb
+- test/test_linked_list.rb
+- test/test_linked_list_node.rb