splay_tree 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3fb742e0b556b47b38822511385221c6b753f7ff
-  data.tar.gz: 3b4815cae5de148ff8ca12b8b780ad3713d2a406
+  metadata.gz: c66b504221015b64dc0e1ea92bfe583eb279a9e3
+  data.tar.gz: d7a06439164029d713e38135ffff5786435675aa
 SHA512:
-  metadata.gz: 202309dfa438b35db3e859167679a8bba623ac1f0d50c94ba0d335b05a75421d2978567991646dc637a7fa0bfabdd1b07af3d66d1f9952c7e352635a81c270cd
-  data.tar.gz: 88fa044eb915009af13333272c38c868c10fb2d915b25b0396eb61d20be19ca1ac0157d451ccbc6d09820906688ce4aec1cb4e63dff8399ea86a73edca932cdb
+  metadata.gz: 074fe40542d0b6665e01a8dc5a31b2efe7402676c5d7e78cb95a30da616e146cd83801d9f5a401cc76bf90cf7a29c2f1adf36f9c6b1c33a433aff3c720189ef7
+  data.tar.gz: 4f0d1375ef8aed9e1d30fc632a3fe1e44eb3f4765f4411314de5fd6eaf8e6df7a9fc896494ce16b3152a4d35f9901a64690c539189791b52c3dd57238797b64f

data/.travis.yml

@@ -5,6 +5,7 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.0
+  - 2.2.0
   - ruby-head
 matrix:
   include:

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+0.2.0 (January 3, 2015)
+
+* Add ability to set default through value and block
+* Add ability to iterate over keys and values
+* Add to_hash export

data/Gemfile

@@ -7,6 +7,7 @@ group :development do
   gem 'rspec',   '~> 3.1.0'
   gem 'yard',    '~> 0.8.7'
   gem 'timecop', '~> 0.7.1'
+  gem 'benchmark-ips', '~> 2.0.0'
 end
 
 group :metrics do

data/README.md

@@ -3,11 +3,13 @@
 [![Build Status](https://secure.travis-ci.org/peter-murach/splay_tree.png?branch=master)][travis]
 [![Code Climate](https://codeclimate.com/github/peter-murach/splay_tree.png)][codeclimate]
 [![Coverage Status](https://coveralls.io/repos/peter-murach/splay_tree/badge.png)][coverage]
+[![Inline docs](http://inch-ci.org/github/peter-murach/splay_tree.png)][inchpages]
 
 [gem]: http://badge.fury.io/rb/splay_tree
 [travis]: http://travis-ci.org/peter-murach/splay_tree
 [codeclimate]: https://codeclimate.com/github/peter-murach/splay_tree
 [coverage]: https://coveralls.io/r/peter-murach/splay_tree
+[inchpages]: http://inch-ci.org/github/peter-murach/splay_tree
 
 > Self balancing binary tree that keeps lookup operations fast by optimizing frequently accessed keys. Useful for implementing caches and garbage collection algorithms.
 
@@ -32,6 +34,16 @@ Or install it yourself as:
 
     $ gem install splay_tree
 
+## Contents
+
+* [1. Usage](#1-usage)
+  * [1.1 insert](#11-insert)
+  * [1.2 fetch](#12-fetch)
+  * [1.3 default](#13-default)
+  * [1.4 delete](#14-delete)
+  * [1.5 empty?](#15-empty)
+  * [1.6 each](#16-each)
+
 ## 1. Usage
 
 **SplayTree** operations are similar to that of `Hash`:
@@ -46,28 +58,66 @@ tree.size    # => 1
 
 ### 1.1 insert
 
-In order to add two elements:
+In order to associate the value with the given key do:
 
 ```ruby
-tree['a'] = 1
-tree['b'] = 2
+tree = SplayTree.new
+tree["a"] = 1
+tree["b"] = 2
 ```
 
+Note: Inserted key will be subjected to splaying, which means the tree will be rearranged to help with quicker access on subsequent calls.
+
 ### 1.2 fetch
 
-To read value under key:
+To retrieve a value from the tree corresponding to the key do:
+
+```ruby
+tree = SplayTree.new
+tree["a"]    #  => nil
+
+tree["a"] = 1
+tree["a"]    #  => 1
+```
+
+Note: Frequently accessed keys will move nearer to the root where they can be accessed more quickly.
+
+### 1.3 default
+
+**SplayTree** allows you to set default value if key does not exist. This can be done during initialization or using `default` method:
+
+```ruby
+tree = SplayTree.new
+tree.default          # => UndefinedValue
+
+tree = SplayTree.new("foo")
+tree.default          # => "foo"
+tree["a"]             # => "foo"
+```
+
+You can also use block to set default value:
 
 ```ruby
-tree['a']
+tree = SplayTree.new
+tree.default_proc    # => nil
+
+tree = SplayTree.new { "foo" }
+tree.default_proc    # => "foo"
+tree["a"]            # => "foo"
 ```
 
-### 1.3 delete
+### 1.4 delete
+
+In order to remove an entry from the splay tree use `delete`. If the value is not found the default value is returned and `nil` otherwise.
 
 ```ruby
+tree = SplayTree.new
+tree['a'] = 1
 tree.delete('a')   # => 1
+tree.delete('z')   # => nil
 ```
 
-### 1.4 empty?
+### 1.5 empty?
 
 To check if `tree` contains any elements call `empty?` like so:
 
@@ -75,10 +125,31 @@ To check if `tree` contains any elements call `empty?` like so:
 tree = SplayTree.new
 tree.empty?   # => true
 
-tree['a'] = 1
+tree["a"] = 1
 tree.empty?   # => false
 ```
 
+### 1.6 each
+
+In order to iterate over all tree nodes use `each` method like so:
+
+```ruby
+tree = SplayTree.new
+tree['a'] = 1
+tree['b'] = 2
+
+tree.each { |key, value| puts "#{key}: #{value}" }
+```
+
+In addition you can use `each_key`, `each_value` to enumerate only keys and values respectively.
+
+```ruby
+tree.each_key { |key| ... }
+tree.each_value { |value| ... }
+```
+
+If no block is provided, an enumerator is returned instead.
+
 ## Contributing
 
 1. Fork it ( https://github.com/peter-murach/splay_tree/fork )
@@ -89,4 +160,4 @@ tree.empty?   # => false
 
 ## Copyright
 
-Copyright (c) 2014 Piotr Murach. See LICENSE for further details.
+Copyright (c) 2014-2015 Piotr Murach. See LICENSE for further details.

data/benchmarks/speed.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+require 'benchmark/ips'
+require 'splay_tree'
+require 'securerandom'
+
+def generate_key(size)
+  SecureRandom.hex(size)
+end
+
+def insert_key(tree)
+  key = generate_key(10)
+  tree[key] = 1
+  key
+end
+
+def run(bench, object)
+  name = object.class.name
+
+  key = nil
+
+  bench.report("#{name} insert") do
+    key = insert_key(object)
+  end
+
+  bench.report("#{name} find") do
+    object[key]
+  end
+
+  bench.report("#{name} delete") do
+    object.delete(key)
+  end
+end
+
+Benchmark.ips do |bench|
+  bench.config(time: 5, warmpu: 2)
+
+  run(bench, SplayTree.new)
+  run(bench, Hash.new)
+end

data/lib/splay_tree/node.rb

@@ -43,6 +43,29 @@ class SplayTree
       @key <=> other.key
     end
 
+    # Iterate over subtree nodes
+    #
+    # @api private
+    def each(&block)
+      @left.each(&block)
+      yield [@key, @value]
+      @right.each(&block)
+    end
+
+    # Iterate over subtree nodes
+    #
+    # @api private
+    def each_key(&block)
+      each { |k, v| yield k }
+    end
+
+    # Iterate over subtree nodes
+    #
+    # @api private
+    def each_value(&block)
+      each { |k, v| yield v }
+    end
+
     # Dump the subtree structure starting from this node
     #
     # @return [String]
@@ -121,11 +144,11 @@ class SplayTree
         0
       end
 
-      def to_s
-      end
+      def to_s; end
 
-      def dump
-      end
+      def dump; end
+
+      def each(&block); end
 
       def insert(key, value)
         Node.new(key, value)

data/lib/splay_tree/version.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
 
 class SplayTree
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'
 end # SplayTree

data/lib/splay_tree.rb

@@ -4,10 +4,26 @@ require 'splay_tree/node'
 require 'splay_tree/version'
 
 class SplayTree
+  include Enumerable
+
   UndefinedValue = Module.new
 
+  # The default value for non existent key
+  #
+  # @api public
   attr_accessor :default
 
+  # The default block for non existent key
+  #
+  # @api public
+  attr_accessor :default_proc
+
+  # Create a SplayTree
+  #
+  # @param [Object] default
+  #   the default value for missing key
+  #
+  # @api public
   def initialize(default = UndefinedValue, &block)
     if !UndefinedValue.equal?(default) && block
       fail ArgumentError,
@@ -16,7 +32,7 @@ class SplayTree
     @root  = Node::EMPTY
     @subtree = Node.new(nil, nil)
     @default = default
-    @default_block = block
+    @default_proc = block
   end
 
   # @api public
@@ -30,6 +46,91 @@ class SplayTree
   end
   alias_method :length, :size
 
+  # Iterate over each key & value pair in the tree
+  #
+  # @example
+  #   tree = SplayTree.new
+  #   tree.each { |key, val| ... }
+  #
+  # @yield [key, value]
+  #
+  # @yieldparam [Object] key
+  # @yieldparam [Object] value
+  #
+  # @return [self]
+  #
+  # @api public
+  def each(&block)
+    if block_given?
+      @root.each(&block)
+      self
+    else
+      @root.to_enum
+    end
+  end
+
+  # Iterate over each key in the tree
+  #
+  # @example
+  #   tree = SplayTree.new
+  #   tree.each_key { |key| ... }
+  #
+  # @yield [key]
+  #
+  # @yieldparam [Object] key
+  #
+  # @return [self]
+  #
+  # @api public
+  def each_key(&block)
+    if block_given?
+      @root.each_key(&block)
+      self
+    else
+      @root.to_enum(:each_key)
+    end
+  end
+
+  # Iterate over each value in the tree
+  #
+  # @example
+  #   tree = SplayTree.new
+  #   tree.each_value { |val| ... }
+  #
+  # @yield [value]
+  #
+  # @yieldparam [Object] value
+  #
+  # @return [self]
+  #
+  # @api public
+  def each_value(&block)
+    if block_given?
+      @root.each_value(&block)
+      self
+    else
+      @root.to_enum(:each_value)
+    end
+  end
+
+  # Return a new array of all the keys in the tree
+  #
+  # @return [Array[Object]]
+  #
+  # @api public
+  def keys
+    each_key.to_a
+  end
+
+  # Return a new array of all the values in the tree
+  #
+  # @return [Array[Object]]
+  #
+  # @api public
+  def values
+    each_value.to_a
+  end
+
   # Insert a node into a tree with the given key and value
   # provided that the tree does not already contain the key.
   # The node becomes the root of the tree.
@@ -127,14 +228,23 @@ class SplayTree
     @root.dump || ''
   end
 
+  # Export tree as hash
+  #
+  # @return [Hash]
+  #
+  # @api public
+  def to_hash
+    reduce({}) { |acc, (k, v)| acc[k] = v; acc }
+  end
+
   private
 
   # @api private
   def default_value
     if @default != UndefinedValue
       @default
-    elsif @default_block
-      @default_block.call
+    elsif @default_proc
+      @default_proc.call
     end
   end
 

data/spec/unit/default_spec.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe SplayTree, '.default' do
+  it "sets the default value on initialize" do
+    tree = SplayTree.new('foo')
+    expect(tree.default).to eq('foo')
+    expect(tree['a']).to eq('foo')
+    expect(tree.default_proc).to eq(nil)
+  end
+
+  it "sets the default value on assigment" do
+    tree = SplayTree.new
+    tree.default = 'foo'
+    expect(tree.default).to eq('foo')
+    expect(tree['a']).to eq('foo')
+    expect(tree.default_proc).to eq(nil)
+  end
+
+  it "sets the default_proc to be executed on each key lookup" do
+    block = -> { 'foo' }
+    tree = SplayTree.new(&block)
+    expect(tree.default).to eq(SplayTree::UndefinedValue)
+    expect(tree.default_proc).to eq(block)
+    expect(tree['a']).to eq('foo')
+  end
+end

data/spec/unit/each_spec.rb

@@ -0,0 +1,55 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe SplayTree, '.each' do
+  subject(:tree) { described_class.new }
+
+  before {
+    tree['a'] = 1
+    tree['b'] = 2
+    tree['c'] = 3
+  }
+
+  it "enumartes all pairs" do
+    yielded = []
+    expect {
+      tree.each { |k, v| yielded << [k, v] }
+    }.to change { yielded }.from([]).to([['a', 1], ['b', 2], ['c', 3]])
+    expect(tree.to_a).to eq(yielded)
+  end
+
+  it "returns enumerator for all pairs without block" do
+    expect(tree.each.to_a).to eq([['a', 1], ['b', 2], ['c', 3]])
+  end
+
+  it "enumerates all keys" do
+    yielded = []
+    expect {
+      tree.each_key { |k| yielded << k }
+    }.to change { yielded }.from([]).to(['a', 'b', 'c'])
+  end
+
+  it "returns enumerator for all keys without block" do
+    expect(tree.each_key.to_a).to eq(['a', 'b', 'c'])
+  end
+
+  it "enumerates all values" do
+    yielded = []
+    expect {
+      tree.each_value { |v| yielded << v }
+    }.to change { yielded }.from([]).to([1, 2, 3])
+  end
+
+  it "returns enumerator for all values without block" do
+    expect(tree.each_value.to_a).to eq([1, 2, 3])
+  end
+
+  it "populates all keys" do
+    expect(tree.keys).to eq(['a', 'b', 'c'])
+  end
+
+  it "populates all values" do
+    expect(tree.values).to eq([1, 2, 3])
+  end
+end

data/spec/unit/to_hash_spec.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe SplayTree, '.to_hash' do
+  it "exports tree as hash" do
+    tree = SplayTree.new
+    hash = {'a' => 1, 'ab' => 2, 'abc' => 3, 'abd' => 4, 'ac' => 5, 'b' => 6}
+    hash.each { |k, v| tree[k] = v }
+    expect(tree.to_hash).to eq(hash)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splay_tree
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-27 00:00:00.000000000 Z
+date: 2015-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -37,18 +37,23 @@ files:
 - .rspec
 - .ruby-version
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/speed.rb
 - lib/splay_tree.rb
 - lib/splay_tree/node.rb
 - lib/splay_tree/version.rb
 - spec/spec_helper.rb
+- spec/unit/default_spec.rb
 - spec/unit/delete_spec.rb
+- spec/unit/each_spec.rb
 - spec/unit/fetch_spec.rb
 - spec/unit/insert_spec.rb
 - spec/unit/new_spec.rb
+- spec/unit/to_hash_spec.rb
 - splay_tree.gemspec
 - tasks/console.rake
 - tasks/coverage.rake
@@ -79,8 +84,11 @@ specification_version: 4
 summary: A self-balancing binary tree with amortized access.
 test_files:
 - spec/spec_helper.rb
+- spec/unit/default_spec.rb
 - spec/unit/delete_spec.rb
+- spec/unit/each_spec.rb
 - spec/unit/fetch_spec.rb
 - spec/unit/insert_spec.rb
 - spec/unit/new_spec.rb
+- spec/unit/to_hash_spec.rb
 has_rdoc: