doubly_linked_list 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a60119aac53e771266ee26d0800d7f2f5c0f3594
+  data.tar.gz: a6e536f8ce4e2875fa9f82126054182ac26378f9
+SHA512:
+  metadata.gz: 569c6d1e4c393fc235344a93d52fa4da7550d51bc25855939e9fc71ab759a7e43fdb2132970465e66bed22d2a8e133139584155ec9e110c59472a4db6749e8e4
+  data.tar.gz: 219a455c841d653e158eaea842a11d96d5529f8d923301b680bcd484623dbe2c02906a28d947adb18f95600b10dd3b424b4f72d1e2bf077e61a9dc3adff895e3

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,25 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea
+.ruby-gemset
+.ruby-version

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+cache: bundler

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,14 @@
+Copyright (c) 2014 Cornell University
+
+##########################################################################
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

data/README.md

@@ -0,0 +1,80 @@
+# DoublyLinkedList
+
+[![Build Status](https://travis-ci.org/elrayle/doubly_linked_list.png?branch=master)](https://travis-ci.org/elrayle/doubly_linked_list) 
+[![Coverage Status](https://coveralls.io/repos/elrayle/doubly_linked_list/badge.png?branch=master)](https://coveralls.io/r/elrayle/doubly_linked_list?branch=master)
+[![Gem Version](https://badge.fury.io/rb/doubly_linked_list.svg)](http://badge.fury.io/rb/doubly_linked_list)
+[![Dependency Status](https://www.versioneye.com/ruby/doubly_linked_list/0.0.4/badge.svg)](https://www.versioneye.com/ruby/doubly_linked_list/0.0.4)
+
+
+Ruby implementation of doubly linked list, following some Ruby idioms.
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'doubly_linked_list'
+    
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install doubly_linked_list 
+
+
+## Usage
+
+```ruby
+l = DoublyLinkedList.new
+l.add_last('cat')
+l.add_last('dog')
+l.add_first('fish')
+l.to_a
+# => ['fish','cat','dog']
+l.size
+# => 3
+
+l = DoublyLinkedList.new :items => ['cat','dog','fish']
+l.to_a
+# => ['cat','dog','fish']
+
+l = DoublyLinkedList.new :list_info => {:title =>'test list', :description => 'Test out my doubly linked list.'},
+                   :items => ['cat','dog','rabbit','fish']
+l.to_a
+# => ['cat','dog','rabbit','fish']
+l.list_info
+# => {:title =>'test list', :description => 'Test out my doubly linked list.'}
+
+l.remove_first
+#=> 'cat'
+l.remove_last
+#=> 'fish'
+```
+
+
+## TODO
+
+* Insert / delete in the middle
+* Batch add in the middle
+* Move item to different position
+
+
+## Tests
+
+Run test with
+
+```shell
+$ rspec
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/doubly_linked_list/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/doubly_linked_list.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'doubly_linked_list'
+  spec.version       = '0.0.1'
+  spec.authors       = ["E. Lynette Rayle"]
+  spec.email         = ["elr37@cornell.edu"]
+  spec.platform      = Gem::Platform::RUBY
+  spec.summary       = %q{Ruby implementation of doubly_linked_lists using an array to hold and manipulate items.}
+  spec.description   = %q{Ruby implementation of doubly_linked_lists using an array to hold and manipulate items.}
+  spec.homepage      = "https://github.com/elrayle/doubly_linked_list"
+  spec.license       = "APACHE2"
+  spec.required_ruby_version     = '>= 1.9.3'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+
+  spec.add_development_dependency('pry')
+  spec.add_development_dependency('pry-byebug')    # Works with ruby > 2
+  # spec.add_development_dependency('pry-debugger')  # Works with ruby < 2
+  spec.add_development_dependency('rdoc')
+  spec.add_development_dependency('rspec')
+  spec.add_development_dependency('coveralls')
+
+  spec.extra_rdoc_files = [
+      "LICENSE.txt",
+      "README.md"
+  ]
+end
+

data/lib/doubly_linked_list.rb

@@ -0,0 +1,148 @@
+class Array
+  def move(from,to)
+    insert(to, delete_at(from))
+  end
+end
+
+class DoublyLinkedList
+  ## Doubly Linked List implementation
+  #
+  # The list is implemented using an array such that the following linked list concepts are represented as...
+  #    * head is the first item in the list
+  #    * tail is the last item in the list
+  #    * next is the next array element
+  #    * prev is the previous array element
+  #
+
+  # include Conversions
+
+  attr_accessor :list_info
+  # attr_writer   :node_update_callback   # TODO Add callback to update node info
+
+  def initialize(*args)
+    @list      = []
+    @list      = args[0][:items] if ! args.empty? && args[0].is_a?(Hash) && args[0].key?(:items)
+    @list_info = nil
+    @list_info = args[0][:list_info] if ! args.empty? && args[0].is_a?(Hash) && args[0].key?(:list_info)
+    self
+  end
+
+  ##
+  # Get the first element of the list.
+  #
+  # @return first node in the list or nil
+  def first
+    return nil if @list.empty?
+    @list[head]
+  end
+
+  ##
+  # Get the last element of the list.
+  #
+  # @return last node in the list or nil
+  def last
+    return nil if @list.empty?
+    @list[tail]
+  end
+
+  ##
+  # Add data to the end of the list.
+  #
+  # @parameter [Object] data - any object
+  #
+  # @return position where added
+  def add_last(data)
+    @list << data
+    @list.size
+  end
+  alias_method :<<, :add_last
+
+  ##
+  # Add data as the first item in the list.
+  #
+  # @parameter [Object] data - any object
+  #
+  # @return position where added
+  def add_first(data)
+    @list.insert(0,data)
+    @list.size
+  end
+
+  ##
+  # Remove node from the end of the list.
+  #
+  # @return data stored in the removed node
+  def remove_last
+    return nil if @list.empty?
+    @list.delete_at(tail)
+  end
+
+  ##
+  # Removes data from the beginning of the list.
+  #
+  # @return data stored in the removed node
+  def remove_first
+    return nil if @list.empty?
+    @list.delete_at(head)
+  end
+
+  ##
+  # Iterates over nodes from top to bottom 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 each
+    return to_enum(__callee__) unless block_given?
+    __each { |node| yield(node.data) }
+  end
+
+  # Returns list array without list info.
+  #
+  def to_a
+    @list
+  end
+  alias_method :to_ary, :to_a
+
+  # Passing all missing methods to the list so all array operations can be performed.
+  def method_missing method_id, *args
+# binding.pry
+    begin
+      return @list.send(method_id,*args)
+    rescue
+      super
+    end
+  end
+
+  def inspect
+    sprintf('#<%s:%#x %s>', self.class, self.__id__, to_a.inspect)
+  end
+
+  # # Conversion function, see +Conversions.List+.
+  # #
+  # # == Returns:
+  # # +self+
+  # #
+  # def to_list
+  #   self
+  # end
+
+  private
+
+  def head
+    @list && @list.size > 0 ? 0 : nil
+  end
+
+  def tail
+    @list && @list.size > 0 ? @list.size-1 : nil
+  end
+
+  def __each
+    curr_node = @head
+    while(curr_node)
+      yield curr_node
+      curr_node = curr_node.next
+    end
+  end
+end

data/spec/doubly_linked_list_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe 'DoublyLinkedList' do
+
+  describe '#new' do
+    it "should initialize to empty list" do
+      l = DoublyLinkedList.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 = DoublyLinkedList.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
+      l = DoublyLinkedList.new :items => ['cat','dog','rabbit','fish']
+      expect(l.size).to eq 4
+      expect(l.first).to eq 'cat'
+      expect(l.last).to eq 'fish'
+      expect(l.to_a).to eq ['cat','dog','rabbit','fish']
+    end
+
+    it "should initialize with list info and items" do
+      l = DoublyLinkedList.new :list_info => {:title =>'test list', :description => 'Test out my doubly linked list.'},
+                         :items => ['cat','dog','rabbit','fish']
+      expect(l.size).to eq 4
+      expect(l.first).to eq 'cat'
+      expect(l.last).to eq 'fish'
+      expect(l.to_a).to eq ['cat','dog','rabbit','fish']
+      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
+  end
+
+  describe '#add_last' do
+    it "should create list and add item when list is empty" do
+      l = DoublyLinkedList.new
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+
+      expect(l.add_last('cat')).to eq 1
+      expect(l.size).to eq 1
+      expect(l.first).to eq 'cat'
+      expect(l.last).to eq 'cat'
+      expect(l.to_a).to eq ['cat']
+    end
+
+    it "should add item after last when one item list" do
+      l = DoublyLinkedList.new :items => ['dog']
+      expect(l.size).to eq 1
+      expect(l.first).to eq 'dog'
+      expect(l.last).to eq 'dog'
+
+      expect(l.add_last('cat')).to eq 2
+      expect(l.size).to eq 2
+      expect(l.first).to eq 'dog'
+      expect(l.last).to eq 'cat'
+      expect(l.to_a).to eq ['dog','cat']
+    end
+
+    it "should add item after last when multiple item list" do
+      l = DoublyLinkedList.new :items => ['cat','dog','rabbit','fish']
+      expect(l.size).to eq 4
+      expect(l.first).to eq 'cat'
+      expect(l.last).to eq 'fish'
+
+      expect(l.add_last('gerbil')).to eq 5
+      expect(l.size).to eq 5
+      expect(l.first).to eq 'cat'
+      expect(l.last).to eq 'gerbil'
+      expect(l.to_a).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 = DoublyLinkedList.new
+      expect(l.size).to eq 0
+      expect(l.first).to be_nil
+      expect(l.last).to be_nil
+
+      expect(l.add_first('cat')).to eq 1
+      expect(l.size).to eq 1
+      expect(l.first).to eq 'cat'
+      expect(l.last).to eq 'cat'
+      expect(l.to_a).to eq ['cat']
+    end
+
+    it "should add item before first when one item list" do
+      l = DoublyLinkedList.new :items => ['dog']
+      expect(l.size).to eq 1
+      expect(l.first).to eq 'dog'
+      expect(l.last).to eq 'dog'
+
+      expect(l.add_first('cat')).to eq 2
+      expect(l.size).to eq 2
+      expect(l.first).to eq 'cat'
+      expect(l.last).to eq 'dog'
+      expect(l.to_a).to eq ['cat','dog']
+    end
+
+    it "should add item before first when multiple item list" do
+      l = DoublyLinkedList.new :items => ['cat','dog','rabbit','fish']
+      expect(l.size).to eq 4
+      expect(l.first).to eq 'cat'
+      expect(l.last).to eq 'fish'
+
+      expect(l.add_first('gerbil')).to eq 5
+      expect(l.size).to eq 5
+      expect(l.first).to eq 'gerbil'
+      expect(l.last).to eq 'fish'
+      expect(l.to_a).to eq ['gerbil','cat','dog','rabbit','fish']
+    end
+  end
+
+  describe '#remove_last' do
+    it "should return nil when list is empty" do
+      l = DoublyLinkedList.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 = DoublyLinkedList.new :items => ['dog']
+      expect(l.size).to eq 1
+      expect(l.first).to eq 'dog'
+      expect(l.last).to eq 'dog'
+
+      expect(l.remove_last).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 = DoublyLinkedList.new :items => ['cat','dog','rabbit','fish']
+      expect(l.size).to eq 4
+      expect(l.first).to eq 'cat'
+      expect(l.last).to eq 'fish'
+
+      expect(l.remove_last).to eq 'fish'
+      expect(l.size).to eq 3
+      expect(l.first).to eq 'cat'
+      expect(l.last).to eq 'rabbit'
+      expect(l.to_a).to eq ['cat','dog','rabbit']
+    end
+  end
+
+  describe '#remove_first' do
+    it "should return nil when list is empty" do
+      l = DoublyLinkedList.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 = DoublyLinkedList.new :items => ['dog']
+      expect(l.size).to eq 1
+      expect(l.first).to eq 'dog'
+      expect(l.last).to eq 'dog'
+
+      expect(l.remove_first).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 = DoublyLinkedList.new :items => ['cat','dog','rabbit','fish']
+      expect(l.size).to eq 4
+      expect(l.first).to eq 'cat'
+      expect(l.last).to eq 'fish'
+
+      expect(l.remove_first).to eq 'cat'
+      expect(l.size).to eq 3
+      expect(l.first).to eq 'dog'
+      expect(l.last).to eq 'fish'
+      expect(l.to_a).to eq ['dog','rabbit','fish']
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'pry'
+require 'doubly_linked_list'
+
+Dir['./spec/support/**/*.rb'].each { |f| require f }
+
+RSpec.configure do |config|
+  config.color = true
+  config.tty = true
+
+  # Uncomment the following line to get errors and backtrace for deprecation warnings
+  # config.raise_errors_for_deprecations!
+
+  # Use the specified formatter
+  config.formatter = :progress
+end
+

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: doubly_linked_list
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- E. Lynette Rayle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: 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'
+description: Ruby implementation of doubly_linked_lists using an array to hold and
+  manipulate items.
+email:
+- elr37@cornell.edu
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- doubly_linked_list.gemspec
+- lib/doubly_linked_list.rb
+- spec/doubly_linked_list_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/elrayle/doubly_linked_list
+licenses:
+- APACHE2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+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/spec_helper.rb