multiset 0.3.0 → 0.4.0

data/multiset.gemspec

@@ -1,66 +0,0 @@
-# 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_ported.rb

@@ -1,528 +0,0 @@
-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