hamster 0.1.8 → 0.1.11

data/lib/hamster/set.rb

@@ -1,31 +1,31 @@
+require 'hamster/trie'
+
 module Hamster
 
-  class Set
+  def self.set(*items)
+    items.reduce(Set.new) { |set, item| set.add(item) }
+  end
 
-    def self.[](*items)
-      items.reduce(self.new) { |set, item| set.add(item) }
-    end
+  class Set
 
     def initialize(trie = Trie.new)
       @trie = trie
     end
 
-    # Returns the number of items in the set.
-    def size
-      @trie.size
-    end
-
-    # Returns <tt>true</tt> if the set contains no items.
     def empty?
       @trie.empty?
     end
 
-    # Returns <tt>true</tt> if the given item is present in the set.
+    def size
+      @trie.size
+    end
+    alias_method :length, :size
+
     def include?(item)
       @trie.has_key?(item)
     end
+    alias_method :member?, :include?
 
-    # Returns a copy of <tt>self</tt> with the given item added. If already exists, returns <tt>self</tt>.
     def add(item)
       if include?(item)
         self
@@ -33,36 +33,91 @@ module Hamster
         self.class.new(@trie.put(item, nil))
       end
     end
+    alias_method :<<, :add
 
-    # Returns a copy of <tt>self</tt> with the given item removed. If not found, returns <tt>self</tt>.
     def remove(key)
-      copy = @trie.remove(item)
-      if !copy.equal?(@trie)
-        self.class.new(copy)
+      trie = @trie.remove(key)
+      if !trie.equal?(@trie)
+        self.class.new(trie)
       else
         self
       end
     end
 
-    # Calls <tt>block</tt> once for each item in the set, passing the item as the only parameter.
-    # Returns <tt>self</tt>
     def each
       block_given? or return enum_for(__method__)
-      @trie.each { |entry| yield entry.key }
+      @trie.each { |entry| yield(entry.key) }
       self
     end
 
-    # Returns <tt>true</tt> if . <tt>eql?</tt> is synonymous with <tt>==</tt>
+    def map
+      block_given? or return enum_for(:each)
+      if empty?
+        self
+      else
+        self.class.new(@trie.reduce(Trie.new) { |trie, entry| trie.put(yield(entry.key), nil) })
+      end
+    end
+    alias_method :collect, :map
+
+    def reduce(memo)
+      block_given? or return memo
+      @trie.reduce(memo) { |memo, entry| yield(memo, entry.key) }
+    end
+    alias_method :inject, :reduce
+
+    def filter
+      block_given? or return enum_for(__method__)
+      trie = @trie.filter { |entry| yield(entry.key) }
+      if !trie.equal?(@trie)
+        self.class.new(trie)
+      else
+        self
+      end
+    end
+    alias_method :select, :filter
+
+    def reject
+      block_given? or return enum_for(__method__)
+      select { |item| !yield(item) }
+    end
+
+    def any?
+      if block_given?
+        each { |item| return true if yield(item) }
+      else
+        each { |item| return true if item }
+      end
+      false
+    end
+
+    def all?
+      if block_given?
+        each { |item| return false unless yield(item) }
+      else
+        each { |item| return false unless item }
+      end
+      true
+    end
+
+    def none?
+      if block_given?
+        each { |item| return false if yield(item) }
+      else
+        each { |item| return false if item }
+      end
+      true
+    end
+
     def eql?(other)
       other.is_a?(self.class) && @trie.eql?(other.instance_eval{@trie})
     end
-    alias :== :eql?
+    alias_method :==, :eql?
 
-    # Returns <tt>self</tt>
     def dup
       self
     end
-    alias :clone :dup
+    alias_method :clone, :dup
 
   end
 

data/lib/hamster/stack.rb

@@ -1,52 +1,51 @@
+require 'hamster/list'
+
 module Hamster
 
+  def self.stack
+    Stack.new
+  end
+
   class Stack
 
-    def initialize(list = List.new)
+    def initialize(list = Hamster.list)
       @list = list
     end
 
-    # Returns <tt>true</tt> if the stack contains no items.
     def empty?
       @list.empty?
     end
 
-    # Returns the number of items on the stack.
     def size
       @list.size
     end
 
-    # Returns the item at the top of the stack.
     def top
-      @list.car
+      @list.head
     end
 
-    # Returns a copy of <tt>self</tt> with the given item as the new top
     def push(item)
       self.class.new(@list.cons(item))
     end
 
-    # Returns a copy of <tt>self</tt> without the top item.
     def pop
-      copy = @list.cdr
-      if !copy.equal?(@list)
-        self.class.new(copy)
+      list = @list.tail
+      if !list.equal?(@list)
+        self.class.new(list)
       else
         self
       end
     end
 
-    # Returns <tt>true</tt> if . <tt>eql?</tt> is synonymous with <tt>==</tt>
     def eql?(other)
       other.is_a?(self.class) && @list.eql?(other.instance_eval{@list})
     end
-    alias :== :eql?
+    alias_method :==, :eql?
 
-    # Returns <tt>self</tt>
     def dup
       self
     end
-    alias :clone :dup
+    alias_method :clone, :dup
 
   end
 

data/lib/hamster/trie.rb

@@ -27,12 +27,21 @@ module Hamster
 
     # Calls <tt>block</tt> once for each entry in the trie, passing the key-value pair as parameters.
     def each
-      @entries.each { |entry| yield entry if entry }
+      @entries.each { |entry| yield(entry) if entry }
       @children.each do |child|
-        child.each { |entry| yield entry } if child
+        child.each { |entry| yield(entry) } if child
       end
     end
 
+    def reduce(memo)
+      each { |entry| memo = yield(memo, entry) }
+      memo
+    end
+
+    def filter
+      reduce(self) { |trie, entry| yield(entry) ? trie : trie.remove(entry.key) }
+    end
+
     # Returns a copy of <tt>self</tt> with the given value associated with the key.
     def put(key, value)
       index = index_for(key)
@@ -86,7 +95,7 @@ module Hamster
       end
       true
     end
-    alias :== :eql?
+    alias_method :==, :eql?
 
     protected
 
@@ -120,7 +129,7 @@ module Hamster
 
     # Returns a replacement instance after removing the specified entry. If empty, returns <tt>nil</tt>
     def remove_at(index = @entries.index { |e| e })
-      yield @entries[index] if block_given?
+      yield(@entries[index]) if block_given?
       if size > 1
         entries = @entries.dup
         child = @children[index]

data/lib/hamster/version.rb

@@ -1,5 +1,5 @@
 module Hamster
 
-  VERSION = "0.1.8".freeze
+  VERSION = "0.1.11".freeze
 
 end

data/spec/hamster/hash/all_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Hamster::Hash do
+
+  describe "#all?" do
+
+    describe "when empty" do
+
+      before do
+        @hash = Hamster.hash
+      end
+
+      it "with a block returns true" do
+        @hash.all? {}.should be_true
+      end
+
+      it "with no block returns true" do
+        @hash.all?.should be_true
+      end
+
+    end
+
+    describe "when not empty" do
+
+      before do
+        @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
+      end
+
+      describe "with a block" do
+
+        it "returns true if the block always returns true" do
+          @hash.all? { |item| true }.should be_true
+        end
+
+        it "returns false if the block ever returns false" do
+          @hash.all? { |key, value| key == "D" || value == "dee" }.should be_false
+        end
+
+      end
+
+      describe "with no block" do
+
+        it "returns true" do
+          @hash.all?.should be_true
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/hash/any_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Hamster::Hash do
+
+  describe "#any?" do
+
+    describe "when empty" do
+
+      before do
+        @hash = Hamster.hash
+      end
+
+      it "with a block returns false" do
+        @hash.any? {}.should be_false
+      end
+
+      it "with no block returns false" do
+        @hash.any?.should be_false
+      end
+
+    end
+
+    describe "when not empty" do
+
+      before do
+        @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL")
+      end
+
+      describe "with a block" do
+
+        [
+          ["A", "aye"],
+          ["B", "bee"],
+          ["C", "see"],
+          [nil, "NIL"],
+        ].each do |pair|
+
+          it "returns true if the block ever returns true (#{pair.inspect})" do
+            @hash.any? { |key, value| key == pair.first && value == pair.last }.should be_true
+          end
+
+          it "returns false if the block always returns false" do
+            @hash.any? { |key, value| key == "D" && value == "dee" }.should be_false
+          end
+
+        end
+
+      end
+
+      describe "with no block" do
+
+        it "returns true" do
+          @hash.any?.should be_true
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/hash/construction_spec.rb

@@ -2,14 +2,30 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Hamster::Hash do
 
-  describe ".[]" do
+  describe ".hash" do
+
+    describe "with nothing" do
+
+      before do
+        @hash = Hamster.hash
+      end
+
+      it "returns an empty hash" do
+        @hash.should be_empty
+      end
 
-    before do
-      @hash = Hamster::Hash["A" => "aye", "B" => "bee", "C" => "see"]
     end
 
-    it "is equivalent to repeatedly using #put" do
-      @hash.should eql(Hamster::Hash.new.put("A", "aye").put("B", "bee").put("C", "see"))
+    describe "with an implicit hash" do
+
+      before do
+        @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
+      end
+
+      it "is equivalent to repeatedly using #put" do
+        @hash.should == Hamster.hash.put("A", "aye").put("B", "bee").put("C", "see")
+      end
+
     end
 
   end

data/spec/hamster/hash/copying_spec.rb

@@ -3,21 +3,17 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe Hamster::Hash do
 
   before do
-    @hash = Hamster::Hash.new
+    @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
   end
 
-  describe "#dup" do
+  [:dup, :clone].each do |method|
 
-    it "returns self" do
-      @hash.dup.should equal(@hash)
-    end
-
-  end
+    describe "##{method}" do
 
-  describe "#clone" do
+      it "returns self" do
+        @hash.send(method).should equal(@hash)
+      end
 
-    it "returns self" do
-      @hash.clone.should equal(@hash)
     end
 
   end

data/spec/hamster/hash/each_spec.rb

@@ -5,11 +5,7 @@ describe Hamster::Hash do
   describe "#each" do
 
     before do
-      @hash = Hamster::Hash.new
-      @expected_pairs = { "A" => "aye", "B" => "bee", "C" => "sea" }
-      @expected_pairs.each do |key, value|
-        @hash = @hash.put(key, value)
-      end
+      @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
     end
 
     describe "with a block (internal iteration)" do
@@ -18,26 +14,18 @@ describe Hamster::Hash do
         @hash.each {}.should equal(@hash)
       end
 
-      it "yields all key value pairs" do
+      it "yields all key/value pairs" do
         actual_pairs = {}
-        @hash.each do |key, value|
-          actual_pairs[key] = value
-        end
-        actual_pairs.should == @expected_pairs
+        @hash.each { |key, value| actual_pairs[key] = value }
+        actual_pairs.should == {"A" => "aye", "B" => "bee", "C" => "see"}
       end
 
     end
 
     describe "with no block (external iteration)" do
 
-      it "returns an enumerator over all key value pairs" do
-        actual_pairs = {}
-        enum = @hash.each
-        loop do
-          key, value = enum.next
-          actual_pairs[key] = value
-        end
-        actual_pairs.should == @expected_pairs
+      it "returns an enumerator over all key/value pairs" do
+        Hash[*@hash.each.to_a.flatten].should == {"A" => "aye", "B" => "bee", "C" => "see"}
       end
 
     end