linked 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eec1f197c1ffec1b6a1e47edc5c2a1c75e0967b3
+  data.tar.gz: 826b07b940721256814a4e21613b88d26a485982
+SHA512:
+  metadata.gz: a25ecac7d54d74faa3360b2e487287d3875b57633924be4d7f57d0cd9d0ce01ebe86d53dce49fe81db33b2b978fae9296f4f93006a67cf92abd16e145d68341a
+  data.tar.gz: 50e9953c0936dc3e2825106c4ce77e14ee161848ec451607a062662c3c7f799b131352e0348189bcfdfb83aacdf07e808c3148079c2a9199b3e8334b38d67675

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in linked.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sebastian Lindberg
+
+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/README.md

@@ -0,0 +1,76 @@
+# Linked
+
+[![Build Status](https://travis-ci.org/seblindberg/ruby-linked.svg?branch=master)](https://travis-ci.org/seblindberg/ruby-linked)
+[![Coverage Status](https://coveralls.io/repos/github/seblindberg/ruby-linked/badge.svg?branch=master)](https://coveralls.io/github/seblindberg/ruby-linked?branch=master)
+[![Inline docs](http://inch-ci.org/github/seblindberg/ruby-linked.svg?branch=master)](http://inch-ci.org/github/seblindberg/ruby-linked)
+
+Yet another Linked List implementation for Ruby (hence the somewhat awkward name). The library is still under development. The intention is to
+
+1. nail down the functionality,
+2. start porting the methods over to c and finally
+3. try to optimize for speed, as much as possible.
+
+The project is still in phase 1.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'linked'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install linked
+
+## Usage
+
+A basic use case is show below. For more details, for now, see the docs.
+
+```ruby
+require 'linked'
+
+# Include the List module in a class
+class ListLike
+  include Linked::List    
+end
+
+# Create a list
+list = ListLike.new
+
+# Append values
+list << :value
+list << 'value'
+
+# Or create list items manually
+item = Linked::Item.new 42
+list.unshift item
+
+# Remove items with #pop and #shift
+list.pop.value # => 'value'
+
+# The list behaves much like an Array
+list.count # => 2
+list.map(&:value) # => [42, :value]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/linked.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "linked"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/linked/item.rb

@@ -0,0 +1,313 @@
+module Linked
+  # Item
+  #
+  # This class implements doubly linked list items, designed to work both on
+  # their own and as children of list.
+  #
+  #  +- - - +    +------+------+            +- - - +
+  #  | Head | <--| prev | next |--> ... --> | Tail |
+  #  + - - -+    +------+------+            + - - -+
+  # (optional)     First Item     N Items  (optional)
+  #
+  # An object is considered a list if it responds to #head, #tail, #grow and
+  # #shrink. The latter facilitate counting of the items and will be called
+  # everytime an item is appended, prepended or deleted. #head and #tail are
+  # expected to return two objects that, respectivly
+  # a) responds to #next= and #append, or #prev= and #prepend and
+  # b) returns true for #nil?.
+
+  class Item
+    # Access the list (if any) that the item belongs to. Writing to this
+    # attribute is protected and should be avoided.
+    #
+    # Returns the item's list, or nil
+
+    attr_accessor :list
+    protected :list=
+
+    # The Item can hold an arbitrary object as its value and it will stay with
+    # the item.
+
+    attr_accessor :value
+
+    # Calling either #prev= or #next= directly is not recommended, since can
+    # corrupt the chain.
+
+    attr_writer :prev, :next
+    protected :prev=, :next=
+
+    # Creates a new item. If a list is given the item will be considered a part
+    # of that list and appended to the end of it.
+    #
+    # value - an arbitrary object to store with the item.
+    # list - an object responding to #head and #tail.
+    #
+    # Returns a new Item.
+
+    def initialize(value = nil, list: nil)
+      @value = value
+      @list = list
+      if list
+        list.tail.append self
+      else
+        @next = nil
+        @prev = nil
+      end
+    end
+
+    # Check if this is the first item in the list. It is crucial that tail#nil?
+    # returns true for the first item to be identified correctly.
+    #
+    # Returns true if no item come before this one.
+
+    def first?
+      @prev.nil?
+    end
+
+    # Check if this is the last item in the list. It is crucial that head#nil?
+    # returns true for the last item to be identified correctly.
+    #
+    # Returns true if no item come after this one.
+
+    def last?
+      @next.nil?
+    end
+
+    # Access the next item in the list. If this is the last one a StopIteration
+    # will be raised, so that items may be iterated over safely in a loop.
+    #
+    # Example
+    #   loop do
+    #     item = item.next
+    #   end
+    #
+    # Returns the item that come after this.
+
+    def next
+      raise StopIteration if last?
+      @next
+    end
+
+    # Unsafe accessor of the next item in the list. It is preferable to use
+    # #next.
+    #
+    # Returns the item that come after this, or nil if this is the last one.
+
+    def next!
+      @next
+    end
+
+    # Access the previous item in the list. If this is the first one a
+    # StopIteration will be raised, so that items may be iterated over safely in
+    # a loop.
+    #
+    # Example
+    #   loop do
+    #     item = item.prev
+    #   end
+    #
+    # Returns the item that come before this.
+
+    def prev
+      raise StopIteration if first?
+      @prev
+    end
+
+    alias previous prev
+
+    # Unsafe accessor of the previous item in the list. It is preferable to use
+    # #prev.
+    #
+    # Returns the item that come before this, or nil if this is the first one.
+
+    def prev!
+      @prev
+    end
+
+    alias previous! prev!
+
+    # Split the chain of items in two. If the chain belongs to a list this item
+    # and all that stay connected to it will continue to belong to it, while the
+    # rest are removed from it.
+    #
+    # By default all items followng this one will be kept together, but if given
+    # the argument after: true, the split will instead happen after this item
+    # and it will instead be kept with those before it.
+    #
+    # Example
+    #
+    #   item_b.split(after: false) => ~item_a~ |> item_b     item_c
+    #   item_b.split(after: true)  =>  item_a     item_b <| ~item_c~
+    #
+    # after - determine wheter to split the chain before or after this item.
+    #
+    # Returns self.
+
+    def split after: false
+      if after
+        unless last?
+          if @list
+            item = self
+            count = 1 + loop.count do
+              item = item.next
+              item.list = nil
+            end
+
+            tail = @list.tail
+            tail.prev = self
+            @next = tail
+            @list.shrink count
+          else
+            @next.prev = nil
+            @next = nil
+          end
+        end
+      else
+        unless first?
+          if @list
+            item = self
+            count = 1 + loop.count do
+              item = item.prev
+              item.list = nil
+            end
+
+            head = @list.head
+            head.next = self
+            @prev = head
+            @list.shrink count
+          else
+            @prev.next = nil
+            @prev = nil
+          end
+        end
+      end
+
+      self
+    end
+
+    # Inserts the given item between this one and the one after it (if any). If
+    # the given item is part of a chain, all items following it will be moved to
+    # this one, and added to the list if one is set.
+    #
+    # Alternativly the argument can be an arbitrary object, in which case a new
+    # item will be created around it.
+    #
+    # If this item is part of a list #grow will be called on it with the
+    # number of added items as an argument. Should it also be the last item
+    # #prev= will be called on the list tail.
+    #
+    # sibling - the item to append, or an arbitrary object to be wraped in a new
+    #           item.
+    #
+    # Returns the last item that was appended.
+
+    def append(sibling)
+      if sibling.is_a? Item
+        sibling.split
+      else
+        sibling = self.class.new sibling
+      end
+
+      sibling.prev = self
+      after_sibling = @next
+      @next = sibling
+
+      count = 1 + loop.count do
+        sibling.list = @list
+        sibling = sibling.next
+      end
+
+      @list.send :grow, count if @list
+
+      sibling.next = after_sibling
+      after_sibling.prev = sibling if after_sibling
+      sibling
+    end
+
+    # Inserts the given item between this one and the one before it (if any). If
+    # the given item is part of a chain, all items preceeding it will be moved
+    # to this one, and added to the list if one is set.
+    #
+    # Alternativly the argument can be an arbitrary object, in which case a new
+    # item will be created around it.
+    #
+    # If this item is part of a list #grow will be called on it with the
+    # number of added items as an argument. Should it also be the first item
+    # #next= will be called on the list head.
+    #
+    # sibling - the item to prepend. or an arbitrary object to be wraped in a
+    #           new item.
+    #
+    # Returns the last item that was prepended.
+
+    def prepend(sibling)
+      if sibling.is_a? Item
+        sibling.split after: true
+      else
+        sibling = self.class.new sibling
+      end
+
+      sibling.next = self
+      before_sibling = @prev
+      @prev = sibling
+
+      count = 1 + loop.count do
+        sibling.list = @list
+        sibling = sibling.prev
+      end
+
+      @list.send :grow, count if @list
+
+      sibling.prev = before_sibling
+      before_sibling.next = sibling if before_sibling
+      sibling
+    end
+
+    # Remove an item from the chain. If this item is part of a list and is
+    # either first, last or both in that list, #next= and #prev= will be called
+    # on the list head and tail respectivly.
+    #
+    # If this item is part of a list #shrink will be called on it.
+    #
+    # Returns self.
+
+    def delete
+      @next.prev = @prev if @next
+      @prev.next = @next if @prev
+      @list.send :shrink if @list
+
+      @next = @prev = @list = nil
+      self
+    end
+
+    # Iterates over each item before this, in reverse order. If a block is not
+    # given an enumerator is returned.
+
+    def before
+      return to_enum(__callee__) unless block_given?
+      return if first?
+
+      item = self.prev
+
+      loop do
+        yield item
+        item = item.prev
+      end
+    end
+
+    # Iterates over each item after this. If a block is not given an enumerator
+    # is returned.
+
+    def after
+      return to_enum(__callee__) unless block_given?
+      return if last?
+
+      item = self.next
+
+      loop do
+        yield item
+        item = item.next
+      end
+    end
+  end
+end

data/lib/linked/list/eol.rb

@@ -0,0 +1,82 @@
+module Linked
+  module List
+    # End Of List
+    #
+    # This class implements a special list item that is placed at both the end
+    # and the beginning of a chain of regular items to form a list. The naming
+    # (end of list) comes from the fact that this object, by returning true for
+    # calls to #nil?, signifies the end of a list of Items. In both directions
+    # as a matter of fact, which is why the head and tail objects defined by
+    # Item is combined into one.
+    #
+    # In a nutshell, the structure looks something like this:
+    #
+    #   +-------------------- EOL --------------------+
+    #   | (head)                               (tail) |
+    #   +---------------------------------------------+
+    #     ^ +-- Item 1 ---+         +-- Item N ---+ ^
+    #     +-| prev | next |<- ... ->| prev | next |-+
+    #       +------+------+         +------+------+
+
+    class EOL < Item
+      private :value, :value=, :delete, :first?, :last?
+
+      def initialize(list:)
+        super()
+        @list = list
+        @prev = @next = self
+      end
+
+      # EOL objects will return true when asked if they are nil. This is
+      # foremost an implementation detail to comply with the requirements of the
+      # Item class, but also logical in the sense that end-of-list objects are
+      # not really part of the list, and should therefore be considered nil.
+      #
+      # Returns true.
+
+      def nil?
+        true
+      end
+
+      # Inserts one or more items at the end of the list. If the given object is
+      # not an Item, or a decendant of Item, it will be treated as a value.
+      # Depending on the state of the list the value will be
+      # a) wraped in a new instance of Item if the list is empty or
+      # b) wraped in an object of the same class as the last item in the list.
+      #
+      # sibling - the item or value to be appended.
+      #
+      # Returns the item that was appended. In case of a string of items the
+      # last one is returned.
+
+      def append(sibling)
+        if @prev == self
+          sibling = Item.new sibling unless sibling.is_a? Item
+          super sibling
+        else
+          @prev.append sibling
+        end
+      end
+
+      # Inserts one or more items at the beginning of the list. If the given
+      # object is not an Item, or a decendant of Item, it will be treated as a
+      # value. Depending on the state of the list the value will be
+      # a) wraped in a new instance of Item if the list is empty or
+      # b) wraped in an object of the same class as the last item in the list.
+      #
+      # sibling - the item or value to be prepended.
+      #
+      # Returns the item that was prepended. In case of a string of items the
+      # first one is returned.
+
+      def prepend(sibling)
+        if @next == self
+          sibling = Item.new sibling unless sibling.is_a? Item
+          super sibling
+        else
+          @next.prepend sibling
+        end
+      end
+    end
+  end
+end

data/lib/linked/list.rb

@@ -0,0 +1,204 @@
+module Linked
+  # List
+  #
+  # This module can be included in any class to give it list like behaviour.
+  # Most importantly, the methods #head, #tail, #grow and #shrink are
+  # implemented to comply with the requirements defined by Item.
+  #
+  # Example
+  #
+  #   class ListLike
+  #     include Linked::List
+  #
+  #     def initialize
+  #       super
+  #       ...
+  #
+  # A key implementation detail is the End-Of-List, or EOL object that sits
+  # between the list and the actual list items. It provides separation between
+  # the list and the actual list items.
+
+  module List
+    include Enumerable
+
+    # Private accessor method for the End-Of-List object.
+    #
+    # Returns a List::EOL object.
+
+    attr_reader :eol
+    private :eol
+
+    # Returns an object that responds to #next= and #prepend.
+
+    alias head eol
+
+    # Returns an object that responds to #prev= and #append.
+
+    alias tail eol
+
+    # Initializes the list by setting the two instance variable @item_count and
+    # @eol. It is important that this method be called during the initialization
+    # of the including class, and that the instance variables never be accessed
+    # directly.
+
+    def initialize(*)
+      super
+
+      @eol = EOL.new list: self
+      @item_count = 0
+    end
+
+    # Access the first n item(s) in the list.
+    #
+    # n - the number of items to return.
+    #
+    # Returns the first item, or an array of items if n > 1.
+
+    def first(*args)
+      if args.empty?
+        eol.next!
+      else
+        super
+      end
+    end
+
+    # Access the last n item(s) in the list. When n > 1 the resulting array of
+    # items will have their order preserved.
+    #
+    # When n is zero an empty array will be returned, in order to comply with
+    # the behaviour of #first. Negative values will raise an ArgumentError.
+    #
+    # n - the number of items to return.
+    #
+    # Returns the last item, or an array of items if n > 1.
+
+    def last(n = 1)
+      if n == 1
+        eol.prev!
+      else
+        raise ArgumentError, 'n cannot be negative' if n < 0
+
+        n = count if n > count
+        res = Array.new n
+
+        return res if n == 0
+
+        item = eol.prev!
+        loop do
+          n -= 1
+          res[n] = item
+          item = item.prev
+        end
+
+        res
+      end
+    end
+
+    # Overrides the Enumerable#count method when given no argument to provide a
+    # fast item count. Instead of iterating over each item, the internal item
+    # count is returned.
+    #
+    # args - see Enumerable#count
+    #
+    # Returns the number of items counted.
+
+    def count(*args)
+      if args.empty? && !block_given?
+        @item_count
+      else
+        super
+      end
+    end
+
+    # Returns true if the list does not contain any items.
+
+    def empty?
+      @item_count == 0
+    end
+
+    # Insert an item at the end of the list. If the given object is not an Item,
+    # or a decendant of Item, it will be treated as a value. Depending on the
+    # state of the list the value will be
+    # a) wraped in a new instance of Item if the list is empty or
+    # b) wraped in an object of the same class as the last item in the list.
+    #
+    # item - the item to insert, or an arbitrary value.
+    #
+    # Returns self.
+
+    def push(item)
+      eol.append item
+      self
+    end
+
+    alias << push
+
+    # Pop the last item off the list.
+    #
+    # Returns the last item in the list, or nil if the list is empty.
+
+    def pop
+      return nil if empty?
+      last.delete
+    end
+
+    # Insert an item at the beginning of the list. If the given object is not an
+    # Item, or a decendant of Item, it will be treated as a value. Depending on
+    # the state of the list the value will be
+    # a) wraped in a new instance of Item if the list is empty or
+    # b) wraped in an object of the same class as the last item in the list.
+    #
+    # item - the item to insert, or an arbitrary value.
+    #
+    # Returns self.
+
+    def unshift(item)
+      eol.prepend item
+      self
+    end
+
+    # Shift the first item off the list.
+    #
+    # Returns the first item in the list, or nil if the list is empty.
+
+    def shift
+      return nil if empty?
+      first.delete
+    end
+
+    # Iterates over each item in the list, either in normal or reverse order. If
+    # a block is not given an enumerator is returned.
+    #
+    # reverse - flips the iteration order if true.
+
+    def each(reverse: false, &block)
+      if reverse
+        eol.before(&block)
+      else
+        eol.after(&block)
+      end
+    end
+
+    # Internal method to grow the list with n elements. Never call this method
+    # without also inserting the n elements.
+    #
+    # n - the number of items that has been/will be added to the list.
+    #
+    # Returns updated the item count.
+
+    private def grow(n = 1)
+      @item_count += n
+    end
+
+    # Internal method to shrink the list with n elements. Never call this method
+    # without also deleting the n elements.
+    #
+    # n - the number of items that has been/will be removed from the list.
+    #
+    # Returns updated the item count.
+
+    private def shrink(n = 1)
+      @item_count -= n
+    end
+  end
+end

data/lib/linked/version.rb

@@ -0,0 +1,3 @@
+module Linked
+  VERSION = '0.1.0'
+end

data/lib/linked.rb

@@ -0,0 +1,8 @@
+require 'linked/version'
+require 'linked/item'
+require 'linked/list/eol'
+require 'linked/list'
+
+module Linked
+
+end

data/linked.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'linked/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "linked"
+  spec.version       = Linked::VERSION
+  spec.authors       = ["Sebastian Lindberg"]
+  spec.email         = ["seb.lindberg@gmail.com"]
+
+  spec.summary       = %q{Yet another linked list implementation in Ruby.}
+  spec.description   = %q{Yes, there are a lot of linked list implementaions out there but I wrote my own all the same. This library is ment to be subclassed/included by other objects that that behave like linked lists.}
+  spec.homepage      = "https://github.com/seblindberg/ruby-linked"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "coveralls", "~> 0.8"
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: linked
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sebastian Lindberg
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-08-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Yes, there are a lot of linked list implementaions out there but I wrote
+  my own all the same. This library is ment to be subclassed/included by other objects
+  that that behave like linked lists.
+email:
+- seb.lindberg@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/linked.rb
+- lib/linked/item.rb
+- lib/linked/list.rb
+- lib/linked/list/eol.rb
+- lib/linked/version.rb
+- linked.gemspec
+homepage: https://github.com/seblindberg/ruby-linked
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Yet another linked list implementation in Ruby.
+test_files: []