double_linked_list 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4bd1278ef39c3b852ef5993fbf7dd68da8cf6165
-  data.tar.gz: c150f49470d1bd86df704fca5a484774a2e73f25
+  metadata.gz: 2d32b4473a261613c917ec8481da96bc7eaca8e4
+  data.tar.gz: 60e714c5a3baf1318412f3c5817f373ddc0e6d57
 SHA512:
-  metadata.gz: 01058c5d4f74e50be1c3e2fb5b569b5bcdf5023686a928161f09e4d9458c5e1ff3f235c5faa4a6fa69e3a52476b5dfa733faf86033b3a72376102ca458a9f365
-  data.tar.gz: 7f9bb129aa3efeb4b66e9f48e7ddd8569f5c95f918c4f8af678180a8c40ad116931e926f62443b31109f072865da515ce8079eedce62a959c30356db9a943aa0
+  metadata.gz: 885e97ebc16d00e86142e1c5bc4ca6a9d4b9e7528be2e7bba8d618b18f2b1a2bb80613a167673a6bccdf56142efceebc6189fb34265a1bd29186108a4201d721
+  data.tar.gz: 682228a274f17a1849fc1824ec71a3778f5b93b07739e0878e2ae3af74e996b80e42b0ac3c8fde4f2f932a360d4ed84e9939cc3b404cd3b0df8f26f76192d3fd

data/.travis.yml

@@ -1,5 +1,33 @@
 sudo: false
+cache: bundler
 language: ruby
 rvm:
-  - 2.2.0
-before_install: gem install bundler -v 1.12.5
+  - 2.1
+  - 2.1.6
+  - 2.2
+  - 2.3.0
+  - ruby-head
+  - jruby-19mode
+  - jruby-9.0.1.0
+  - rbx-3
+env:
+  # this doesn't do anything for MRI or RBX, but it doesn't hurt them either
+  # for JRuby, it enables us to get more accurate coverage data
+  - JRUBY_OPTS="--debug"
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: rbx-3
+    - rvm: jruby-19mode
+    - rvm: jruby-9.0.1.0
+    - rvm: 1.9.3
+    - rvm: 2.0.0
+  fast_finish: true
+before_install: gem update --remote bundler
+install:
+  - bundle install --retry=3
+script:
+  - bundle exec rspec
+addons:
+  code_climate:
+    repo_token: 9bc6cf480824676f6f459544eb93d3ad09b4a69e9b42c57c5e657748c38b779a

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in double_linked_list.gemspec
 gemspec
+
+gem 'pry'

data/README.md

@@ -1,5 +1,11 @@
 # DoubleLinkedList
 
+[![Build Status](https://travis-ci.org/arturictus/double_linked_list.svg?branch=master)](https://travis-ci.org/arturictus/double_linked_list)
+[![Gem Version](https://badge.fury.io/rb/double_linked_list.svg)](https://badge.fury.io/rb/double_linked_list)
+[![Code Climate](https://codeclimate.com/github/arturictus/double_linked_list/badges/gpa.svg)](https://codeclimate.com/github/arturictus/double_linked_list)
+[![Test Coverage](https://codeclimate.com/github/arturictus/double_linked_list/badges/coverage.svg)](https://codeclimate.com/github/arturictus/double_linked_list/coverage)
+[![Issue Count](https://codeclimate.com/github/arturictus/double_linked_list/badges/issue_count.svg)](https://codeclimate.com/github/arturictus/double_linked_list)
+
 The missing Ruby Linked list
 
 ## Installation
@@ -39,7 +45,7 @@ llist = DoubleLinkedList.from_a(1, 2, 3)
 llist.last.datum #=> 3
 ```
 
-__find:___
+__find:__
 
 ```ruby
 llist = DoubleLinkedList.from_a(1, 2, 3)
@@ -50,13 +56,16 @@ llist.find(3).datum #=> 3
 llist.find(9) #=> nil
 ```
 
-__find_previous:__
-
+__find_by:__
 ```ruby
-llist = DoubleLinkedList.from_a(1, 2, 3)
-llist.find_previous(3).datum #=> 2
-llist.find_previous(2).datum #=> 1
-llist.find_previous(1) #=> nil
+User = Struct.new(:id)
+users = [
+  User.new(1),
+  User.new(2),
+  User.new(3)
+]
+llist = DoubleLinkedList.from_a(users)
+llist.find_by{ |elem| elem.datum.id == 1 }.datum.id #=> 1
 ```
 
 __append:__
@@ -69,13 +78,74 @@ llist.last.next #=> be_nil
 llist.last.previous.datum #=> 3
 ```
 
+## Enumerable
+
+- `map`
+- `each`
+- `reverse_each`
+
+__each:__
+```ruby
+DoubleLinkedList.from_a(1, 2, 3).each { |e| puts e.datum }
+# 1
+# 2
+# 3
+```
+
+__map:__
+```ruby
+DoubleLinkedList.from_a(1, 2, 3).map { |e| e.datum + 1}
+#=> [2, 3, 4]
+```
+
+__reverse_each:__
+```ruby
+DoubleLinkedList.from_a(1, 2, 3).reverse_each { |e| puts e.datum }
+# 3
+# 2
+# 1
+```
+
+__chunk_by:__
+
+It will split the Double linked list in multiple linked list if the block
+returns `truly`.
+The first element of the splitted array are the elememts that return true in the block.
+
+```ruby
+llist = DoubleLinkedList.from_a(1, 2, 3, 4)
+chunked = llist.chunk_by do |e, current_llist|
+  e.datum == 3 && current_llist.head.datum == 1
+end
+chunked.first.is_a? DoubleLinkedList #=> true
+chunked.first.head.datum #=> 1
+chunked.first.last.datum #=> 2
+chunked.map{|ll| ll.to_a } #=> [[1, 2], [3, 4]]
+```
+
+__select_by:__
+
+For selecting fractions of the linked list avoiding the elements not returned in between the selected head and last sequences.
+In the block must be returned a `DoubleLinkedList::Sequence` instance and head and last in the `DoubleLinkedList::Sequence` must be a `DoubleLinkedList::Element` (the element is passed to the block)
+
+```ruby
+llist = DoubleLinkedList.from_a(1, 2, 3, 4)
+select = llist.select_by do |e|
+  if e.datum == 2 && e.next.datum == 3
+    DoubleLinkedList::Sequence.new(head: e, last: e.next)
+  end
+end
+select.is_a? Array #=> true
+select.first.is_a? DoubleLinkedList #=> true
+select.map{|ll| ll.to_a } #=> [[2, 3]]
+```
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false ---` 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).
+To install this gem onto your local machine, run `bundle exec rake install`. [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/double_linked_list.
+Bug reports and pull requests are welcome on GitHub at https://github.com/arturictus/double_linked_list.

data/double_linked_list.gemspec

@@ -21,5 +21,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.5"
+  spec.add_development_dependency "contextuable"
   # spec.add_development_dependency "false ---", "~> "
 end

data/lib/double_linked_list/element.rb

@@ -0,0 +1,100 @@
+class DoubleLinkedList
+  class Element < Struct.new(:datum, :previous, :_next)
+    include Enumerable
+    alias_method :next, :_next
+    alias_method :prev, :previous
+
+    def each(&block)
+      block.call self
+      _next.each(&block) if _next
+    end
+
+    def find(datum)
+      find_next_by do |elem|
+        elem.datum == datum
+      end
+    end
+
+    def find_previous_by(&block)
+      _finder(:reverse_each, &block)
+    end
+
+    def find_next_by(&block)
+      _finder(:each, &block)
+    end
+
+    def reverse_each(&block)
+      block.call self
+      previous.reverse_each(&block) if previous
+    end
+
+    def append(datum)
+      new_last = Element.new(datum, self, nil)
+      self._next = new_last
+      new_last
+    end
+
+    def chunk_by(acc, &block)
+      if acc.empty?
+        acc << DoubleLinkedList.from_a(self.datum)
+      else
+        if block.call(self, acc.last, acc)
+          acc << DoubleLinkedList.from_a(self.datum)
+        else
+          acc.last << self.datum
+        end
+      end
+      _next ? _next.chunk_by(acc, &block) : acc
+    end
+
+    def select_by(acc, &block)
+      sequences = []
+      find_multiple do |e|
+        head_tail = block.call(e)
+        if head_tail
+          sequences << head_tail
+        end
+        head_tail
+      end
+      extract_sequences(sequences)
+    end
+
+    protected
+
+    def find_multiple(&block)
+      found = each_until_found(&block)
+      found.next.find_multiple(&block) if found && found.next?
+    end
+
+    def each_until_found(&block)
+      found = block.call(self)
+      return found if found
+      _next.each_until_found(&block) if _next
+    end
+
+    def extract_sequences(sequences)
+      sequences.each_with_object([]) do |seq, coll|
+        head = seq.head
+        head_datum = head.datum
+        list = DoubleLinkedList.from_a(head_datum)
+        last = nil
+        head.find_multiple do |elem|
+          next if head_datum == elem.datum
+          list << elem.datum
+          last = elem.datum if elem.datum == seq.last.datum
+          break if last
+        end
+        coll << list
+      end
+    end
+
+    def _finder(direction, &block)
+      found = nil
+      send(direction) do |elem|
+        found = elem if block.call(elem)
+        break if found
+      end
+      found
+    end
+  end
+end

data/lib/double_linked_list/sequence.rb

@@ -0,0 +1,18 @@
+class DoubleLinkedList
+  class Sequence
+    attr_reader :head, :last
+    def initialize(head:, last:)
+      @head = head
+      @last = last
+    end
+
+    def next
+      return unless next?
+      last.next
+    end
+
+    def next?
+      last.next ? true : false
+    end
+  end
+end

data/lib/double_linked_list/version.rb

@@ -1,3 +1,3 @@
 class DoubleLinkedList
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/double_linked_list.rb

@@ -3,7 +3,17 @@ require 'forwardable'
 class DoubleLinkedList
   extend Forwardable
   attr_accessor :head, :last
-  delegate [:datum, :next] => :head
+  delegate [
+    :datum,
+    :next,
+    :map,
+    :each,
+    :reduce,
+  ] => :head
+
+  delegate [
+    :reverse_each,
+  ] => :last
 
   def initialize(datum)
     @head = (datum.is_a?(Element) ? datum : Element.new(datum))
@@ -11,8 +21,9 @@ class DoubleLinkedList
 
   class << self
     def from_a(*ary)
-      head = Element.new(ary.first)
-      last = ary.drop(1).reduce(head) do |cur_last, datum|
+      elems = ary.flatten
+      head = Element.new(elems.first)
+      last = elems.drop(1).reduce(head) do |cur_last, datum|
         cur_last.append(datum)
       end
       new(head).tap do |o|
@@ -24,46 +35,43 @@ class DoubleLinkedList
   def append(datum)
     self.last = last.append(datum)
   end
-
+  alias_method :<<, :append
 
   def find(datum)
-    found = nil
-    head.each do |elem|
-      found = elem if elem.datum == datum
-      break if found
+    find_by do |elem|
+      elem.datum == datum
     end
-    found
   end
 
-  def find_previous(datum)
-    found = nil
-    last.reverse_each do |elem|
-      found = elem.previous if elem.datum == datum
-      break if found
+  def find_by(&block)
+    head.find_next_by(&block)
+  end
+
+  def reverse_find(datum)
+    reverse_find_by do |elem|
+      elem.datum == datum
     end
-    found
   end
 
-  class Element < Struct.new(:datum, :previous, :_next)
-    include Enumerable
-    alias_method :next, :_next
-    alias_method :prev, :previous
+  def reverse_find_by(&block)
+    last.find_previous_by(&block)
+  end
 
-    def each(&block)
-      block.call self
-      _next.each(&block) if _next
-    end
+  def chunk_by(&block)
+    head.chunk_by([], &block)
+  end
 
-    def each_from_last(&block)
-      block.call self
-      previous.each_from_last(&block) if previous
-    end
-    alias_method :reverse_each, :each_from_last
+  def select_by(&block)
+    head.select_by([], &block)
+  end
 
-    def append(datum)
-      new_last = Element.new(datum, self, nil)
-      self._next = new_last
-      new_last
+  def to_a
+    [].tap do |ary|
+      each{ |elem| ary << elem.datum }
     end
   end
+
 end
+
+require 'double_linked_list/element'
+require 'double_linked_list/sequence'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: double_linked_list
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Artur Pañach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-01 00:00:00.000000000 Z
+date: 2016-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: contextuable
+  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: The missing Ruby Double Linked List.
 email:
 - arturictus@gmail.com
@@ -69,6 +83,8 @@ files:
 - bin/setup
 - double_linked_list.gemspec
 - lib/double_linked_list.rb
+- lib/double_linked_list/element.rb
+- lib/double_linked_list/sequence.rb
 - lib/double_linked_list/version.rb
 homepage: https://github.com/arturictus/double_linked_list
 licenses: []
@@ -89,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: The missing Ruby Double Linked List