multiset 0.3.0

data/multiset.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{multiset}
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["H.Hiro(Maraigue)"]
+  s.date = %q{2011-03-25}
+  s.description = %q{Ruby implementation of multiset. Unlike ordinary set(see Ruby documentation for "set" library), multiset can contain two or more same items.}
+  s.email = %q{main@hhiro.net}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/multiset.rb",
+    "lib/multiset/libmultimap.rb",
+    "lib/multiset/libmultiset.rb",
+    "multiset.gemspec",
+    "spec/multiset_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/maraigue/multiset}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Multiset library for Ruby}
+  s.test_files = [
+    "spec/multiset_spec.rb",
+    "spec/multiset_spec_ported.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 2.3.0"])
+      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 2.3.0"])
+      s.add_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_dependency(%q<jeweler>, [">= 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 2.3.0"])
+    s.add_dependency(%q<bundler>, [">= 1.0.0"])
+    s.add_dependency(%q<jeweler>, [">= 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/spec/multiset_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# This version is a direct porting from version 0.202 (not for Rubygems).
+# Unit test code will be added from the next version.
+
+require "multiset"
+
+describe Multiset do
+end
+
+describe Multimap do
+end

data/spec/multiset_spec_ported.rb

@@ -0,0 +1,528 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require "multiset"
+
+# -------------------- specs of Multiset --------------------
+describe Multiset, "to be generated" do
+	before do
+		Multiset.parse_string? true
+	end
+	
+	it "should be correctly parsed from a hash" do
+		Multiset.parse({:a => 6, :b => 5}).should == {:a => 6, :b => 5}.to_multiset
+		Multiset.parse([:a, 6, :b, 5]).should_not == {:a => 6, :b => 5}.to_multiset
+		Multiset.parse([:a, 6, :b, 5]).should == Multiset.new([:a, 6, :b, 5])
+	end
+	
+	it "should correctly reject scalar values from being updated (Multiset.parse_string? == true)" do
+		Multiset.parse_string? true
+		
+		lambda{ Multiset.parse(83) }.should raise_error(ArgumentError)
+		lambda{ Multiset.parse("hoge\npiyo\n") }.should_not raise_error(ArgumentError)
+		lambda{ Multiset.parse_force("hoge\npiyo\n") }.should_not raise_error(ArgumentError)
+	end
+	
+	it "should correctly reject scalar values from being updated (Multiset.parse_string? == false)" do
+		Multiset.parse_string? false
+		
+		lambda{ Multiset.parse(83) }.should raise_error(ArgumentError)
+		lambda{ Multiset.parse("hoge\npiyo\n") }.should raise_error(ArgumentError)
+		lambda{ Multiset.parse_force("hoge\npiyo\n") }.should_not raise_error(ArgumentError)
+	end
+end
+
+describe Multiset, "�̐����ɂ‚���" do
+	it "Multiset#new��Hash#to_multiset�œ����C���X�^���X�����������" do
+		Multiset.new([:a,:a,:b]).should == {:a => 2, :b => 1}.to_multiset
+		Multiset[:x,:x,:y,:y].should == {:x => 2, :y => 2, :z => 0}.to_multiset
+	end
+	
+	it "���������������" do
+		tmp = Multiset.new([:a,:a,:b])
+		tmp.should == tmp.dup
+		
+		tmp = Multiset[]
+		tmp.should == tmp.dup
+	end
+	
+	it "�������u�������" do
+		tmp = Multiset[]
+		tmp.replace(Multiset[:a,:b,:b]).should == Multiset[:a,:b,:b]
+	end
+end
+
+describe Multiset, "��2�‚̃C���X�^���X�ɂ‚���" do
+	before do
+		@ms1 = Multiset.new(%w'a a a a b b b c c d')
+		@ms2 = Multiset.new(%w'b c c d d d e e e e')
+	end
+	
+	it "��܊֌W��������" do
+		tmp1 = Multiset.new(%w'a a a a b b b c c d d')
+		tmp2 = Multiset.new(%w'a a a a b b b c c d')
+		tmp3 = Multiset.new(%w'a a a b b b c c d')
+		
+		(@ms1 == @ms2).should be_false
+		(@ms1 == tmp1).should be_false
+		(@ms1 == tmp2).should be_true
+		(@ms1 == tmp3).should be_false
+		
+		(@ms1.subset?(@ms2)).should be_false
+		(@ms1.subset?(tmp1)).should be_true
+		(@ms1.subset?(tmp2)).should be_true
+		(@ms1.subset?(tmp3)).should be_false
+		(@ms2.subset?(@ms1)).should be_false
+		(tmp1.subset?(@ms1)).should be_false
+		(tmp2.subset?(@ms1)).should be_true
+		(tmp3.subset?(@ms1)).should be_true
+		
+		(@ms1.proper_subset?(@ms2)).should be_false
+		(@ms1.proper_subset?(tmp1)).should be_true
+		(@ms1.proper_subset?(tmp2)).should be_false
+		(@ms1.proper_subset?(tmp3)).should be_false
+		(@ms2.proper_subset?(@ms1)).should be_false
+		(tmp1.proper_subset?(@ms1)).should be_false
+		(tmp2.proper_subset?(@ms1)).should be_false
+		(tmp3.proper_subset?(@ms1)).should be_true
+		
+		(@ms1.superset?(@ms2)).should be_false
+		(@ms1.superset?(tmp1)).should be_false
+		(@ms1.superset?(tmp2)).should be_true
+		(@ms1.superset?(tmp3)).should be_true
+		(@ms2.superset?(@ms1)).should be_false
+		(tmp1.superset?(@ms1)).should be_true
+		(tmp2.superset?(@ms1)).should be_true
+		(tmp3.superset?(@ms1)).should be_false
+		
+		(@ms1.proper_superset?(@ms2)).should be_false
+		(@ms1.proper_superset?(tmp1)).should be_false
+		(@ms1.proper_superset?(tmp2)).should be_false
+		(@ms1.proper_superset?(tmp3)).should be_true
+		(@ms2.proper_superset?(@ms1)).should be_false
+		(tmp1.proper_superset?(@ms1)).should be_true
+		(tmp2.proper_superset?(@ms1)).should be_false
+		(tmp3.proper_superset?(@ms1)).should be_false
+	end
+	
+	it "�ϏW����������" do
+		(@ms1 & @ms2).should == Multiset.new(%w'b c c d')
+	end
+	
+	it "�a�W����������" do
+		(@ms1 | @ms2).should == Multiset.new(%w'a a a a b b b c c d d d e e e e')
+	end
+	
+	it "�����̌��ʂ�������" do
+		(@ms1 + @ms2).should == Multiset.new(%w'a a a a b b b b c c c c d d d d e e e e')
+		
+		tmp = @ms1.dup
+		tmp.merge!(@ms2)
+		tmp.should == Multiset.new(%w'a a a a b b b b c c c c d d d d e e e e')
+	end
+	
+	it "���̌��ʂ�������" do
+		(@ms1 - @ms2).should == Multiset.new(%w'a a a a b b')
+		
+		tmp = @ms1.dup
+		tmp.subtract!(@ms2)
+		tmp.should == Multiset.new(%w'a a a a b b')
+	end
+	
+	it "�v�f�̒lj���������" do
+		tmp = @ms1.dup
+		tmp << "a"
+		tmp.should == Multiset.new(%w'a a a a a b b b c c d')
+		
+		tmp = @ms1.dup
+		tmp.add("e", 3)
+		tmp.should == Multiset.new(%w'a a a a b b b c c d e e e')
+		
+		tmp = @ms1.dup
+		tmp.add("a", 3)
+		tmp.should == Multiset.new(%w'a a a a a a a b b b c c d')
+	end
+	
+	it "�v�f�̍폜��������" do
+		tmp = @ms1.dup
+		tmp.delete("a")
+		tmp.should == Multiset.new(%w'a a a b b b c c d')
+		
+		tmp = @ms1.dup
+		tmp.delete("e")
+		tmp.should == @ms1
+		
+		tmp = @ms1.dup
+		tmp.delete_all("a")
+		tmp.should == Multiset.new(%w'b b b c c d')
+		
+		tmp = @ms1.dup
+		tmp.delete_all("e")
+		tmp.should == @ms1
+	end
+end
+
+# -------------------- specs of Multimap --------------------
+describe Multimap, "generated by adding items one by one" do
+	before do
+		Multiset.parse_string? true
+		
+		@empty_multiset = Multiset.new
+		@mm = Multimap.new
+	end
+	
+	it "should be empty when generated without parameters" do
+		@mm[:a].should == empty_multiset
+		@mm[:b].should == empty_multiset
+	end
+	
+	it "should be correctly updated by adding a scalar value" do
+		@mm[:a].add "bar"
+		@mm[:a].should == Multiset["bar"]
+	end
+	
+	it "should not make unsolicited change" do
+		@mm[:a].add "bar"
+		@mm[:b].should == empty_multiset
+	end
+	
+	it "should be correctly updated by setting an array" do
+		@mm[:a] = ["foo", "foo", "bar"]
+		@mm[:a].should == Multiset["foo", "foo", "bar"]
+	end
+	
+	it "should be correctly updated by setting a hash" do
+		@mm[:a] = {"foo" => 3, "bar" => 2}
+		@mm[:a].should == Multiset["foo", "foo", "bar", "foo", "bar"]
+	end
+	
+	it "should not be updated by setting a scalar (other than 'Enumerable' object)"
+		Multiset.parse_string? true
+		lambda{ mm[:a] = "foobar" }.should_not raise_error(ArgumentError)
+		lambda{ mm[:a] = 56 }.should raise_error(ArgumentError)
+	end
+	
+	it "should not be updated by setting a scalar (including strings)"
+		Multiset.parse_string? false
+		lambda{ mm[:a] = "foobar" }.should raise_error(ArgumentError)
+		lambda{ mm[:a] = 56 }.should raise_error(ArgumentError)
+	end
+end
+
+describe Multimap, "generated from a hash" do
+	it "should be correctly generated from hashes (by Hash#to_multimap)"
+		# to_multimap / multimap
+		mm = {:a => [3, 3], :b => [5, 3]}.to_multimap
+		mm[:a].should == Multiset[3, 3]
+		mm[:b].should == Multiset[5, 3]
+	end
+	
+	it "should be correctly generated from hashes (by Hash#multimap)"
+		mm = {:a => [3, 3], :b => [5, 3]}.multimap
+		mm[:a].should == Multiset[[3, 3]]
+		mm[:b].should == Multiset[[5, 3]]
+	end
+end
+
+describe Multimap, "to be compared" do
+	it "should be correctly compared" do
+		mm1 = Multimap.new
+		mm1[:a] = ["foo", "foo", "bar", "hoge", "hoge", "moe"]
+		mm1[:b] = ["foo", "bar", "hoge", "hoge", "bar"]
+		mm2 = Multimap.new
+		mm2[:a] = ["foo", "foo", "bar", "hoge", "hoge", "moe"]
+		mm2[:b] = ["foo", "bar", "hoge", "hoge", "bar"]
+		mm3 = Multimap.new
+		mm3[:a] = ["foo", "foo", "bar", "hoge", "hoge", "moe"]
+		mm3[:b] = ["foo", "bar", "hoge", "hoge", "bar", "buz"]
+		
+		mm1.should == mm2
+		mm1.should_not == mm3
+		
+		mm3.dup.should == mm3
+	end
+	
+	it "should be correctly decided whether it is empty or not"
+		mm = Multimap.new
+		
+		mm[:a] = []
+		mm[:b] = [:a, :b]
+		mm.should_not be_empty
+		
+		mm[:a] = []
+		mm[:b] = []
+		mm.should be_empty
+	end
+	
+	it "should be equal to 'dup'ed multimap" do
+		@mm = Multimap.new
+		@mm[:a] = ["foo", "foo", "bar", "hoge", "hoge", "moe"]
+		@mm[:b] = ["foo", "bar", "hoge", "hoge", "bar"]
+		
+		@mm.dup.should == @mm
+	end
+end
+
+describe Multimap, "to be referred" do
+	before do
+		@mm = Multimap.new
+		@mm[:a] = ["foo", "foo", "bar", "hoge", "hoge", "moe"]
+		@mm[:b] = ["foo", "bar", "hoge", "hoge", "bar"]
+	end
+	
+	it "should be correctly iterated by 'each_pair'" do
+		tmp_a = []
+		tmp_b = []
+		@mm.each_pair do |key, sval|
+			sval.instance_of?(String).should be_true
+			case key
+			when :a
+				tmp_a << sval
+			when :b
+				tmp_b << sval
+			else
+				raise
+			end
+		end
+		tmp_a.sort.should == ["foo", "foo", "bar", "hoge", "hoge", "moe"].sort
+		tmp_b.sort.should == ["foo", "bar", "hoge", "hoge", "bar"].sort
+	end
+	
+	it "should be correctly iterated by 'each_pair_with'" do
+		tmp_a = []
+		tmp_b = []
+		@mm.each_pair_with do |key, val, cnt|
+			val.instance_of?(String).should be_true
+			cnt.instance_of?(Fixnum).should be_true
+			case key
+			when :a
+				tmp_a << val
+			when :b
+				tmp_b << val
+			else
+				raise
+			end
+		end
+		tmp_a.sort.should == ["foo", "foo", "bar", "hoge", "hoge", "moe"].uniq.sort
+		tmp_b.sort.should == ["foo", "bar", "hoge", "hoge", "bar"].uniq.sort
+	end
+	
+	it "should be correctly iterated by 'each_pair_list'" do
+		flag = 0
+		@mm.each_pair_list do |key, vals|
+			case key
+			when :a
+				vals.should == Multiset["foo", "foo", "bar", "hoge", "hoge", "moe"]
+				flag += 1
+			when :b
+				vals.should == Multiset["foo", "bar", "hoge", "hoge", "bar"]
+				flag += 1
+			else
+				raise
+			end
+		end
+		flag.should == 2
+	end
+	
+	it "should be correctly iterated by 'each_key', ignoring non-existent key" do
+		@mm[:c] = []
+		
+		ms = Multiset.new
+		mm.each_key{ |key| ms << key }
+		ms.should == Multiset[:a, :b]
+	end
+	
+	it "should be correctly iterated by 'each_value'"
+		ms = Multiset.new
+		@mm.each_value{ |sval| ms << sval }
+		ms.should == {"foo" => 3, "bar" => 3, "hoge" => 4, "moe" => 1}.to_multiset
+	end
+end
+
+describe Multimap, "to be updated" do
+	before do
+		@mm = Multimap.new
+		@mm[:a] = ["foo", "foo", "bar", "hoge", "hoge", "moe"]
+		@mm[:b] = ["foo", "bar", "hoge", "hoge", "bar"]
+	end
+	
+	it "should release items when 'delete'd" do
+		@mm.delete(:a).should == Multiset["foo", "foo", "bar", "hoge", "hoge", "moe"]
+		@mm[:a].should == Multiset[]
+		@mm[:b].should == Multiset["foo", "bar", "hoge", "hoge", "bar"]
+	end
+	
+	it "should not release items when 'reject'ed ('reject'ed from only return value)" do
+		mm1 = @mm.reject{ |key, sval| sval =~ /o/ }
+		
+		mm1[:a].should == Multiset["bar"]
+		mm1[:b].should == Multiset["bar", "bar"]
+		mm1.should_not == @mm
+	end
+	
+	it "should equal to 'reject!'ed multimap when 'delete_if' is applied" do
+		mm1 = @mm.dup
+		mm2 = @mm.dup
+		
+		mm1.delete_if{ |key, sval| sval =~ /o/ }
+		mm2.reject!{ |key, sval| sval =~ /o/ }
+		mm1.should == mm2
+		
+		mm1.delete_if{ |key, sval| sval =~ /x/ }
+		mm2.reject!{ |key, sval| sval =~ /x/ }
+		mm1.should == mm2
+	end
+	
+	it "should return nil when 'reject!' rejects nothing but 'delete_if' not" do
+		mm1 = @mm.dup
+		mm2 = @mm.dup
+		
+		mm1.delete_if{ |key, sval| sval =~ /o/ }.should == mm1
+		mm2.reject!{ |key, sval| sval =~ /o/ }.should == mm2
+		
+		mm1.delete_if{ |key, sval| sval =~ /x/ }.should == mm1
+		mm2.reject!{ |key, sval| sval =~ /x/ }.should == nil
+	end
+	
+	it "should not release items when 'reject_with' is applied ('reject'ed from only return value)" do
+		# reject_with
+		mm1 = @mm.reject_with{ |key, val, cnt| cnt >= 2 }
+		
+		mm1[:a].should == Multiset["bar", "moe"]
+		mm1[:b].should == Multiset["foo"]
+		mm1.should_not == @mm
+	end
+	
+	if "should release items when 'delete_with' is applied"
+		retval = @mm.delete_with{ |key, val, cnt| cnt >= 2 }
+		retval.should == @mm
+		@mm[:a].should == Multiset["bar", "moe"]
+		@mm[:b].should == Multiset["foo"]
+	end
+	
+	if "should release items when 'delete_with' is applied (but not deleted anything)"
+		retval = @mm.delete_with{ |key, val, cnt| cnt >= 2 && val.length > 4 }
+		retval.should == @mm
+		@mm[:a].should == Multiset["foo", "foo", "bar", "hoge", "hoge", "moe"]
+		@mm[:b].should == Multiset["foo", "bar", "hoge", "hoge", "bar"]
+	end
+	
+	it "Multimap�̗v�f�̓�����������" do
+		mm_base = Multimap.new
+		mm_base[:a] = ["foo", "foo", "bar", "hoge", "hoge", "moe"]
+		mm_base[:b] = ["foo", "bar", "hoge", "hoge", "bar"]
+		
+		# keys, values
+		mm = mm_base.dup
+		mm[:c] = []
+		mm.keys.should satisfy{ |ks| ks == [:a, :b] || ks == [:b, :a] }
+		mm.values.should == {"foo" => 3, "bar" => 3, "hoge" => 4, "moe" => 1}.to_multiset
+		
+		# empty?
+		mm = mm_base.dup
+		mm[:a] = []
+		mm.delete :b
+		mm[:c] = [:x]
+		mm.should_not be_empty
+		mm.delete_if{ |key, sval| sval == :x }
+		mm.should be_empty
+		
+		# has_key?
+		mm = mm_base.dup
+		mm[:c] = []
+		mm[:d] = [:z]
+		mm.should have_key(:a)
+		mm.should have_key(:b)
+		mm.should_not have_key(:c)
+		mm.should be_member(:d)
+		mm.should_not be_member(:x)
+		
+		# has_value?
+		mm = mm_base.dup
+		mm[:c] = []
+		mm[:d] = [:z]
+		mm.should have_value("foo")
+		mm.should have_value(:z)
+		mm.should_not have_value("boo")
+		mm.should be_value("hoge")
+		mm.should_not be_value(:d)
+		
+		# index
+		mm = mm_base.dup
+		mm.index("moe").should == :a
+		[:a, :b].should be_member(mm.index("hoge"))
+		mm.index("boo").should == nil
+		
+		# values_at
+		mm = mm_base.dup
+		mm[:x] = []
+		
+		mm.values_at(:b, :x, :a).should == [
+			Multiset["foo", "bar", "hoge", "hoge", "bar"],
+			Multiset[],
+			Multiset["foo", "foo", "bar", "hoge", "hoge", "moe"],
+		]
+		
+		mm.indexes(:b, :x, :a).map{ |ms|
+			ms.empty? ? nil : ms.to_a.sort }.should == [
+			["foo", "bar", "hoge", "hoge", "bar"].sort,
+			nil,
+			["foo", "foo", "bar", "hoge", "hoge", "moe"].sort,
+		]
+		
+		# length
+		mm = mm_base.dup
+		mm.length.should == 11
+		mm[:c] = [:y]
+		mm.length.should == 12
+	end
+
+	it "Multimap�̕ϊ���������" do
+		# invert
+		mm_base = Multimap.new
+		mm_base[:a] = ["foo", "foo", "bar", "hoge", "hoge", "moe"]
+		mm_base[:b] = ["foo", "bar", "hoge", "hoge", "bar"]
+		
+		imm = mm_base.invert
+		imm["moe"].should == Multiset[:a]
+		imm["foo"].should == Multiset[:a, :a, :b]
+		imm["bar"].should == Multiset[:a, :b, :b]
+		imm["boo"].should == Multiset[]
+		
+		mm1 = mm_base.dup
+		mm2 = Multimap.new
+		mm2[:a] = ["foo", "hoge", "hoge"]
+		mm2[:c] = ["foo"]
+		
+		mm1.replace(mm2)
+		mm1.should == mm2
+		
+		# to_hash
+		mm_base.to_hash
+	end
+	
+	it "Multimap�ւ̉��Z��������" do
+		# merge
+		mm_base = Multimap.new
+		mm_base[:a] = ["foo", "foo", "bar", "hoge", "hoge", "moe"]
+		mm_base[:b] = ["foo", "bar", "hoge", "hoge", "bar"]
+		
+		mm1 = mm_base.dup
+		
+		mm2 = Multimap.new
+		mm2[:a] = ["foo", "hoge", "hoge"]
+		mm2[:c] = ["foo"]
+		
+		mm1.merge(mm2).should == {
+			:a => ["foo", "foo", "bar", "hoge", "hoge", "moe", "foo", "hoge", "hoge"],
+			:b => ["foo", "bar", "hoge", "hoge", "bar"],
+			:c => ["foo"],
+		}.to_multimap
+		mm1.should == mm_base
+		
+		mm1.merge!(mm2).should == {
+			:a => ["foo", "foo", "bar", "hoge", "hoge", "moe", "foo", "hoge", "hoge"],
+			:b => ["foo", "bar", "hoge", "hoge", "bar"],
+			:c => ["foo"],
+		}.to_multimap
+		mm1.should_not == mm_base
+	end