madderlib 0.1.0

data/spec/conditional_allowed_spec.rb

@@ -0,0 +1,130 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+
+describe MadderLib::Conditional::Allowed do
+
+	it "supports single assumption" do
+		one, two = nil, nil
+
+		builder = madderlib do
+			say(:one).assuming {|test| one }
+			say(:two).presuming {|test| two }
+			say(:three).if { false }
+		end
+
+		[nil, true].each do |t|
+			two = t
+			[false, true].each do |o|
+				one = o
+
+				words = []
+				words << 'one' if one
+				words << 'two' if two
+
+				builder.words.should eql(words)
+			end
+		end
+	end
+
+	it "supports multiple assumptions" do
+		one, two = nil, nil
+
+		builder = madderlib do
+			say(:something).if {|test| one }.assuming {|test| two }
+		end
+
+		[nil, true].each do |t|
+			two = t
+			[false, true].each do |o|
+				one = o
+
+				words = []
+				words << 'something' if one && two
+
+				builder.words.should eql(words)
+			end
+		end
+	end
+
+	it "supports id-based assumption" do
+		#	will say first = yes
+		builder = madderlib do
+			say(:yes).assuming(:spoken)
+			first(:spoken).say(:said)
+		end
+
+		builder.words.should eql(%w{ said yes })
+
+		#	will say last = no
+		builder = madderlib do
+			say(:yes).if(:spoken)
+			last(:spoken).say(:said)
+		end
+
+		builder.words.should eql(%w{ said })
+	end
+
+
+
+	it "supports single forbiddance" do
+		one, two = nil, nil
+
+		builder = madderlib do
+			say(:one).forbidding {|test| one }
+			say(:two).forbidding {|test| two }
+			say(:three).unless { true }
+		end
+
+		[nil, true].each do |t|
+			two = t
+			[false, true].each do |o|
+				one = o
+
+				words = []
+				words << 'one' unless one
+				words << 'two' unless two
+
+				builder.words.should eql(words)
+			end
+		end
+	end
+
+	it "supports multiple forbiddance" do
+		one, two = nil, nil
+
+		builder = madderlib do
+			say(:something).unless {|test| one }.forbidding {|test| two }
+		end
+
+		[nil, true].each do |t|
+			two = t
+			[false, true].each do |o|
+				one = o
+
+				words = []
+				words << 'something' unless one || two
+
+				builder.words.should eql(words)
+			end
+		end
+	end
+
+	it "supports id-based forbiddance" do
+		#	will say first = no
+		builder = madderlib do
+			say(:yes).forbidding(:spoken)
+			first(:spoken).say(:said)
+		end
+
+		builder.words.should eql(%w{ said })
+
+		#	will say last = yes
+		builder = madderlib do
+			say(:yes).unless(:spoken)
+			last(:spoken).say(:said)
+		end
+
+		builder.words.should eql(%w{ yes said })
+	end
+end

data/spec/conditional_helper_spec.rb

@@ -0,0 +1,131 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+
+describe MadderLib::Conditional::Helper do
+
+	it "a TestBlock fails with invalid arguments" do
+		#	arg or block, not both
+		lambda {
+			MadderLib::Conditional::Helper::TestBlock.new(1) {|count| count < 1 }
+		}.should raise_error MadderLib::Error
+
+		#	unsupported
+		lambda {
+			MadderLib::Conditional::Helper::TestBlock.new(:symbol)
+		}.should raise_error MadderLib::Error
+	end
+
+	it "a TestBlock with a block" do
+		tester = MadderLib::Conditional::Helper::TestBlock.new {|count| count < 1 }
+
+		built = tester.block
+
+		built.call(0).should be_true
+
+		tester.invoke(0, :ignore).should be_true
+		tester.invoke(1, :ignore).should_not be_true
+	end
+
+	it "a TestBlock with a fixed limit" do
+		tester = MadderLib::Conditional::Helper::TestBlock.new(2)
+
+		built = tester.block
+
+		built.call(1).should be_true
+		built.call(2).should_not be_true
+
+		tester.invoke(1, :ignore).should be_true
+		tester.invoke(2, :ignore).should_not be_true
+	end
+
+	it "a TestBlock with a Range" do
+		tester = MadderLib::Conditional::Helper::TestBlock.new(2, 4)
+
+		pound_on do
+			built = tester.block
+
+			built.call(1).should be_true
+			built.call(4).should_not be_true
+		end
+
+		tester.invoke(1, :ignore).should be_true
+		tester.invoke(4, :ignore).should_not be_true
+
+		tester = MadderLib::Conditional::Helper::TestBlock.new(Range.new(3, 5))
+
+		pound_on do
+			built = tester.block
+
+			built.call(2).should be_true
+			built.call(5).should_not be_true
+		end
+
+		tester.invoke(2, :ignore).should be_true
+		tester.invoke(5, :ignore).should_not be_true
+	end
+
+
+
+	it "a TestBlock in minutes" do
+		tester = MadderLib::Conditional::Helper::TestBlock.new(2, :minute)
+
+		pound_on do
+			built = tester.block
+
+			#	0, 1 ...
+			built.call(1).should be_true
+			built.call(2).should_not be_true
+		end
+
+		tester = MadderLib::Conditional::Helper::TestBlock.new(2, 4, :minute)
+
+		pound_on do
+			built = tester.block
+
+			#	0, 1 ...
+			built.call(1).should be_true
+			built.call(4).should_not be_true
+		end
+	end
+
+
+
+	it "can convert a TestBlock criterion into an integer" do
+		context = MadderLib::Context.new
+
+		tester = MadderLib::Conditional::Helper::TestBlock.new(1)
+		tester.to_i(context).should eql(1)
+
+		tester = MadderLib::Conditional::Helper::TestBlock.new(1, 2)
+		tester.to_i(context).should eql(2)
+
+		tester = MadderLib::Conditional::Helper::TestBlock.new(Range.new(3, 4))
+		tester.to_i(context).should eql(4)
+
+		tester = MadderLib::Conditional::Helper::TestBlock.new { 2 + 2 }
+		tester.to_i(context).should eql(4)
+
+		context.data[:value] = 5
+		tester = MadderLib::Conditional::Helper::TestBlock.new {|context| context.data[:value] }
+		tester.to_i(context).should eql(5)
+	end
+
+	it "invokes the contained block, or one explicitly provided" do
+		#	arity < 1
+		tester = MadderLib::Conditional::Helper::TestBlock.new { 2 }
+		tester.invoke.should eql(2)
+		tester.invoke { 0 }.should eql(0)
+
+		#	arity = 1
+		tester = MadderLib::Conditional::Helper::TestBlock.new {|value| value + 1 }
+		tester.invoke(1).should eql(2)
+		tester.invoke(1) {|value| value - 1 }.should eql(0)
+
+		#	arity = 2, discard ignored
+		tester = MadderLib::Conditional::Helper::TestBlock.new {|a, b| a + b }
+		tester.invoke(1, 1, :ignored).should eql(2)
+		tester.invoke(1, 1, :ignored) {|a, b| a - b }.should eql(0)
+	end
+
+end

data/spec/conditional_likely_spec.rb

@@ -0,0 +1,138 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+
+describe MadderLib::Conditional::Likely do
+	def distribution(words, map=nil)
+		map ||= {}
+		words.each do |word|
+			map[word] = (map[word] || 0) + 1
+		end
+
+		return map
+	end
+
+
+
+	it "by default has a 50/50 split" do
+		builder = madderlib do
+			say 'buffalo'
+			it.alternately.says 'fish'
+		end
+
+		refs = %w{ buffalo fish }
+		map = nil
+		pound_on do
+			map = distribution(builder.words, map)
+		end
+
+		#	now that'we re done
+		#		should have hit each once
+		#		and should have a reasonable distribution (though who can tell)
+		map.should have(refs.size).items
+		map.keys.each {|key| refs.include?(key).should be_true }
+
+		map['buffalo'].should be_close(50, 20)
+		map['fish'].should be_close(50, 20)
+	end
+
+	it "supports nothing" do
+		builder = madderlib do
+			say 'something nice'
+			alternately.nothing
+		end
+
+		map = nil
+		pound_on(100) do
+			map = distribution(builder.words, map)
+		end
+
+		#	now that'we re done
+		#		should have hit each once
+		#		and should have a reasonable distribution (though who can tell)
+		map.should have(1).items
+		map['something nice'].should_not be_nil
+
+		map['something nice'].should be_close(50, 20)
+	end
+
+
+
+	it "getting a 2/1 split" do
+		#	testing out various alias formats, etc
+		builder = madderlib :split_2_1 do
+			say 'buffalo'
+			it.alternately.says('fish').likely(2)
+		end
+
+		refs = %w{ buffalo fish }
+		map = nil
+		pound_on do
+			words = builder.words
+			map = distribution(words, map)
+		end
+
+		#	now that'we re done
+		#		should have hit each once
+		#		and should have a reasonable distribution (though who can tell)
+		map.should have(refs.size).items
+		map.keys.each {|key| refs.include?(key).should be_true }
+
+		map['buffalo'].should be_close(33, 20)
+		map['fish'].should be_close(66, 20)
+	end
+
+	it "getting a 3/1 split" do
+		#	testing out various alias formats, etcnext
+		builder = madderlib :split_3_1 do
+			say 'buffalo'
+			it.alternately.says('fish').weighing { 2 + 1 }
+		end
+
+		refs = %w{ buffalo fish }
+		map = nil
+		pound_on do
+			words = builder.words
+			map = distribution(words, map)
+		end
+
+		#	now that'we re done
+		#		should have hit each once
+		#		and should have a reasonable distribution (though who can tell)
+		map.should have(refs.size).items
+		map.keys.each {|key| refs.include?(key).should be_true }
+
+		map['buffalo'].should be_close(25, 20)
+		map['fish'].should be_close(75, 20)
+	end
+
+
+
+	it "getting a 3/2/1 split" do
+		#	testing out transferrence from 'or' operation to likelihood
+		builder = madderlib :split_3_2_1 do
+			say 'faith'
+			alternately(2).says('hope')
+			#	range is supported, but not recommended
+			it.or(0..3).says('charity')
+		end
+
+		refs = %w{ faith hope charity }
+		map = nil
+		pound_on 150 do
+			words = builder.words
+			map = distribution(words, map)
+		end
+
+		#	now that'we re done
+		#		should have hit each once
+		#		and should have a reasonable distribution (though who can tell)
+		map.should have(refs.size).items
+		map.keys.each {|key| refs.include?(key).should be_true }
+
+		map['faith'].should be_close(25, 20)
+		map['hope'].should be_close(50, 20)
+		map['charity'].should be_close(75, 20)
+	end
+
+end

data/spec/conditional_recur_spec.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+
+describe MadderLib::Conditional::Recur do
+
+	it "only occurs once if not told otherwise" do
+		builder = madderlib do
+			#	give it boundaries
+			say(:start)
+			anytime.say(:any)
+			say(:end)
+		end
+
+		builder.phrases.each do |phrase|
+			phrase.recurs?.should be_false if phrase.respond_to?(:recurs?)
+		end
+
+		builder.words.should eql(%w{ start any end })
+	end
+
+	it "supports simple recurrence" do
+		builder = madderlib do
+			#	give it boundaries
+			say(:start)
+			anytime.recurring(2).say(:any)
+			say(:end)
+		end
+
+		builder.phrases.each do |phrase|
+			phrase.recurs?.should be_true if phrase.respond_to?(:recurs?)
+		end
+
+		builder.words.should eql(%w{ start any any end })
+	end
+
+	it "supports a 0-recurrence, which blocks the phrase" do
+		builder = madderlib do
+			say(:start)
+			anytime.recur(0).say(:never)
+			say(:end)
+		end
+
+		builder.words.should eql(%w{ start end })
+	end
+
+	it "supports Ranged recurrence" do
+		builder = madderlib do
+			#	give it boundaries
+			say(:start)
+			anytime.recurring(Range.new(3, 5)).say(:few)
+			anytime.recurring(3, 5).say(:couple)
+			say(:end)
+		end
+
+		pound_on do
+			words = builder.words
+
+			words.shift.should eql('start')
+			words.pop.should eql('end')
+
+			count = 0
+			words.each {|word| count += 1 if word == 'few' }
+			count.should be_close(4, 1.1)
+
+			count = 0
+			words.each {|word| count += 1 if word == 'couple' }
+			count.should be_close(4, 1.1)
+		end
+	end
+
+	it "supports arbitrary recurrence" do
+		spices = [:parsley, :sage, :rosemary, :thyme]
+		shoulds = spices.clone
+
+		builder = madderlib :repeat_exhausting do
+			say(:start)
+			#	if these don't exist, positioning isn't random
+			#		it's just a visual confirmation from initial testing
+			say(:salt)
+			say(:pepper)
+			say(:flour)
+			say(:end)
+
+			anytime.recur { ! spices.empty? }.say { spices.shift }
+		end
+
+		words = builder.words
+		words.shift.should eql('start')
+		words.pop.should eql('end')
+
+		#	and all of the others should be present
+		shoulds << :salt << :pepper << :flour
+		shoulds.each do |spice|
+			words.index(spice.to_s).should_not be_nil
+		end
+
+		#	the next pass should be exhausted
+		builder.words.should eql(%w{ start salt pepper flour end })
+	end
+
+end