madderlib 0.1.0

data/spec/error_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+
+describe MadderLib::Error do
+	it "takes a simple message" do
+		e = nil
+		message = 'message'
+
+		lambda { raise MadderLib::Error, message }.should raise_error {|error| e = error }
+		e.message.should eql(message)
+		e.cause.should be_nil
+	end
+
+	it "takes a cause, sans message" do
+		e = nil
+		cause = Exception.new('cause')
+
+		lambda { raise MadderLib::Error.new(cause) }.should raise_error {|error| e = error }
+		e.message.should eql('cause')
+		e.cause.should equal(cause)
+	end
+
+	it "takes both a cause and message" do
+		e = nil
+		message = 'message'
+		cause = Exception.new('cause')
+
+		lambda { raise MadderLib::Error.new(message, cause) }.should raise_error {|error| e = error }
+		e.message.should eql(message)
+		e.cause.should equal(cause)
+	end
+end

data/spec/examples_spec.rb

@@ -0,0 +1,151 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+
+describe MadderLib::KernelMethods, "simple examples" do
+
+	it "README.doc" do
+		puts madderlib {
+			say 'hello,'
+			say('welcome to').or.say("you're viewing")
+			say('the README.doc')
+		}.sentence
+	end
+
+
+
+	it "Snake 'n' Bacon" do
+		builder = madderlib do
+			say "i'm"
+
+			#	build method #1
+			#		empty un-said phrase
+			#		then batch inject all options
+			#		includes 'nothing' -- nil or ''
+			and_then
+			['sometimes', 'always', nil].each {|word| alternately.say(word) }
+
+			#	build method #2
+			#		englicized
+			#		alternates, some with weights, or nothing
+			say('quite').or(2).say('rather').or(2).say('so').or.nothing
+
+			#	build method #3
+			#		single start, then batch complete
+			#		say one thing, add likely / weight if needed
+			#		alternates, with weights if needed
+			say 'salty'
+			['smoky', 'peppery'].each {|word| alternately(2).say(word) }
+		end
+		builder.validate
+
+		5.times { puts builder.sentence }
+
+		#	just to clarify what we've done
+		builder.should have(4).phrases
+		builder.phrases[1].should have(3).instructions
+		builder.phrases[2].should have(4).instructions
+		builder.phrases[3].should have(3).instructions
+
+		nothing_time = 0
+		nothing_degree = 0
+		pound_on do
+			words = builder.words
+
+			#	guaranteed
+			words.include?("i'm").should be_true
+
+			match = words.find do |item|
+				%{ sometimes always }.include? item
+			end
+			nothing_time += 1 unless match
+
+			match = words.find do |item|
+				%{ quite rather so }.include? item
+			end
+			nothing_degree += 1 unless match
+
+			#	something or other
+			match = words.find do |item|
+				%{ salty smoky peppery }.include? item
+			end
+			match.should_not be_nil
+		end
+
+		nothing_time.should be_close(33, 20)
+		nothing_degree.should be_close(25, 20)
+	end
+
+
+
+	it "The Conet Project" do
+		builder = madderlib do
+			meta[:audio] = [
+				'http://www.archive.org/download/ird059/tcp_d1_06_the_lincolnshire_poacher_mi5_irdial.mp3',
+				'http://www.archive.org/download/ird059/tcp_d3_02_iran_iraq_jamming_efficacy_testting_irdial.mp3',
+			]
+
+			digits = lambda do |len|
+				s = rand(10 ** len).to_s
+				s = ('0' * (len - s.size)) + s
+				s
+			end
+
+			say 'Lincolnshire Poacher'
+			say { digits.call(5) }.repeat(10)
+
+			say('~').repeat(6)
+
+			200.times do
+				say { s = digits.call(5); [s, s] }
+			end
+
+			say('~').repeat(6)
+
+			say 'Lincolnshire Poacher'
+		end
+		builder.validate
+
+		5.times { puts builder.sentence }
+	end
+
+
+
+	it "time-based user greeting" do
+		user = Struct.new(:name)
+
+		builder = madderlib do
+			setup {|context| context[:hour] ||= Time.new.hour }
+			a(:morning).says('top of the morning,').if {|c| Range.new(8, 12).include?(c[:hour]) }
+			say('good afternoon,').if {|c| Range.new(12, 17).include?(c[:hour]) }
+			say("g'night").if {|c| Range.new(19, 24).include?(c[:hour]) }
+			say {|c| c[:user].name + '.' }
+		end
+		builder.validate
+
+		puts builder.sentence {|c| c[:user] = user.new('joe')}
+
+		puts builder.sentence {|c|
+			c[:user] = user.new('fred')
+			c[:hour] = 13
+		}
+
+		extended = builder.clone.extend { say('have a nice day!').if(:morning) }
+		puts extended.sentence {|c|
+			c[:user] = user.new('charlie')
+			c[:hour] = 8
+		}
+	end
+
+
+
+	it "combinatorial ranges" do
+		#	useless, but at leasts tests composite operations
+		builder = madderlib do
+			say 'hello', 'and'
+			say('never').if { false }.or.say('likely').likely(2).or.say('repeat').repeat(3).or(99).nothing
+		end
+		builder.validate
+	end
+
+end

data/spec/extensions_spec.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+
+describe Range do
+	it "still doesn't handle floats" do
+		range = Range.new(0, 1.9)
+		range.max.should eql(1)
+	end
+
+	it "still doesn't inverted orders" do
+		range = Range.new(6, 4)
+		range.min.should be_nil
+		range.max.should be_nil
+	end
+
+	it "provides a random value, with optional precision" do
+		#	trial by fire
+		[Range.new(1, 3), Range.new(-1, 5)].each do |range|
+			span = [range.min, range.max]
+			#	high precision, to increase remainder likelihood
+			[0, 5].each do |precision|
+				pound_on do
+					#	exclusive
+					value = range.rand(precision)
+					(value.to_f == value.to_i.to_f).should equal(precision == 0)
+					value.should satisfy {|v| (v >= span.min) && (v < span.max) }
+
+					#	inclusive
+					value = range.rand_inclusive(precision)
+					(value.to_f == value.to_i.to_f).should equal(precision == 0)
+					value.should satisfy {|v| (v >= span.min) && (v < (span.max + 1)) }
+				end
+			end
+		end
+	end
+end
+
+describe Array do
+	it "has to_byte_s, which requires all integers" do
+		(lambda { [32, 32, '32'].to_byte_s }).should raise_error
+	end
+
+	it "has to_byte_s" do
+		[32, 32, 32].to_byte_s.should eql(' ' * 3)
+	end
+end

data/spec/grammar_spec.rb

@@ -0,0 +1,101 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+
+describe MadderLib::Grammar do
+	before(:each) do
+		@class = MadderLib::Grammar
+
+		#	close any pre-existing grammar
+		madderlib_grammar.close
+	end
+
+
+
+	it "get_instance returns a singleton" do
+		@class.get_instance.should equal(@class.get_instance)
+	end
+
+	it "retains a list of unique Builders, and a map of id'd Builders" do
+		grammar = @class.get_instance
+
+		grammar.should have(0).builders
+		grammar.builder_map.should have(0).builders
+
+		#	un-id'd
+		builder = MadderLib::Builder.new
+		grammar << builder
+
+		grammar.should have(1).builders
+		grammar.builders.last.should equal(builder)
+		grammar.builder_map.should have(0).builders
+
+		#	duplicate
+		grammar << builder
+
+		grammar.should have(1).builders
+		grammar.builder_map.should have(0).builders
+
+		#	id'd
+		builder = MadderLib::Builder.new(:named)
+		grammar << builder
+
+		grammar.should have(2).builders
+		grammar.builders.last.should equal(builder)
+		grammar.builder_map.should have(1).builders
+		grammar.builder_map[builder.id].should equal(builder)
+	end
+
+
+
+	it "can be closed, even using the Kernel context" do
+		madderlib :one do
+			say :one
+		end
+		madderlib :two do
+			say :two
+		end
+
+		held = madderlib_grammar
+		held.close
+
+		held.builders.should have(2).builders
+		[:one, :two].each {|key| held.builder_map[key].should_not be_nil }
+
+		#	more builders
+		madderlib :three do
+			say :three
+		end
+
+		open = madderlib_grammar
+		open.builders.should have(1).builder
+		[:three].each {|key| open.builder_map[key].should_not be_nil }
+
+		#	does not impact the one we locked down
+		held.builders.should have(2).builders
+		[:one, :two].each {|key| held.builder_map[key].should_not be_nil }
+
+		#	sorry, you're frozen
+		lambda { held.add :anything }.should raise_error TypeError
+	end
+
+	it "has many ways to add a Builder" do
+		grammar = @class.new
+
+		builder = grammar.add MadderLib::Builder.new :explicit
+		builder.should equal(grammar.builders.last)
+
+		builder.id.should equal(:explicit)
+		grammar.add(:implicit) { say('implicit') }
+		builder = grammar.builders.last
+		builder.id.should equal(:implicit)
+		builder.to_s.should eql('implicit')
+
+		builder = grammar.add { say('no-id') }
+		builder.should equal(grammar.builders.last)
+
+		builder.id.should be_nil
+		builder.to_s.should eql('no-id')
+	end
+
+end

data/spec/instruction_spec.rb

@@ -0,0 +1,133 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+
+describe MadderLib::Instruction do
+
+	it "'say' ignores nils" do
+		phrase = nil
+		context = MadderLib::Context.new
+
+		#	nil, nothing else
+		instruction = MadderLib::Instruction.new(phrase, nil)
+		instruction.speak(context).should eql([])
+
+		#	some counter-balancing value
+		instruction = MadderLib::Instruction.new(phrase, nil, :value)
+		instruction.speak(context).should eql(%w{ value })
+
+		#	late-evaluated nil, array test as well
+		instruction = MadderLib::Instruction.new(phrase, lambda { nil }, :proc)
+		instruction.speak(context).should eql(%w{ proc })
+	end
+
+	it "'say' ignores blanks" do
+		phrase = nil
+		context = MadderLib::Context.new
+
+		#	blank, nothing else
+		instruction = MadderLib::Instruction.new(phrase, "")
+		instruction.speak(context).should eql([])
+
+		#	some counter-balancing value
+		instruction = MadderLib::Instruction.new(phrase, :value, '')
+		instruction.speak(context).should eql(%w{ value })
+
+		#	late-evaluated blank
+		instruction = MadderLib::Instruction.new(phrase, :proc, lambda { '' })
+		instruction.speak(context).should eql(%w{ proc })
+	end
+
+	it "flattens Arrays" do
+		phrase = nil
+		context = MadderLib::Context.new
+
+		instruction = MadderLib::Instruction.new(phrase, :a, [:b, :c])
+		instruction.speak(context).should eql(%w{ a b c })
+
+		instruction = MadderLib::Instruction.new(phrase, [:a, :b, :c])
+		instruction.speak(context).should eql(%w{ a b c })
+
+		instruction = MadderLib::Instruction.new(phrase, :a, [:b, '', [:c, nil, :d]])
+		instruction.speak(context).should eql(%w{ a b c d })
+
+		instruction = MadderLib::Instruction.new(phrase, :a, [1, nil, [lambda { :proc }, lambda { ''}, :d]])
+		instruction.speak(context).should eql(%w{ a 1 proc d })
+	end
+
+	it "handles sub-Builders" do
+		phrase = nil
+		context = MadderLib::Context.new
+
+		#	a nice variety of challenges
+		string = madderlib { say 'string' }
+		one = madderlib { say 1 }
+		array = madderlib { say [:a, :b] }
+		symbol = madderlib { say :symbol }
+		proc = madderlib { say { :proc } }
+
+		#	simple
+		instruction = MadderLib::Instruction.new(phrase, string, one, array, symbol, proc)
+		instruction.speak(context).should eql(%w{ string 1 a b symbol proc })
+
+		#	crazy
+		#		procs returning Builders, arrays of Builders, etc
+		instruction = MadderLib::Instruction.new(phrase, [ string, [ one , lambda { [ array, symbol, proc ] } ]])
+		instruction.speak(context).should eql(%w{ string 1 a b symbol proc })
+	end
+
+	it "handles Procs" do
+		#	this is a pretty serious coverage case
+		#		includes Proc-of-a-Proc, etc
+		words = [ 'one', :two, 3, lambda { :four }, madderlib { say 5 }, [ :six, lambda { 7 } ] ]
+		builder = madderlib do
+			say { words.shift }.repeat { ! words.empty? }
+		end
+		builder.words.should eql(%w{ one two 3 four 5 six 7 })
+	end
+
+
+
+	it "can convert Phrase results into words" do
+		#
+		#	this test may be redundant to the above
+		#	but it's not as thorough
+		#
+
+		context = MadderLib::Context.new
+
+		#	simple values, and a Proc
+		words = ['one', :two, nil, lambda { 3 }].collect do |value|
+			MadderLib::Instruction.wordify(value, context)
+		end
+
+		words.should eql(['one', 'two', nil, '3'])
+
+		#	arrays are stringified but retained
+		#		flattening within array
+		#		nil considerations are retained
+		words = [:a, [:b, [:c, nil]], lambda { [:d, :e] }].collect do |value|
+			MadderLib::Instruction.wordify(value, context)
+		end
+
+		words.should eql(['a', ['b', 'c', nil], ['d', 'e']])
+
+		builder = madderlib do
+			say 'one'
+			say :two
+			say { 3 }
+			#	both ignored
+			say nil
+			say { nil }
+			#	back to real data
+			say 'd', :e
+			say { ['f', :g] }
+		end
+		builder.words.should eql(%w{ one two 3 d e f g })
+
+		words = MadderLib::Instruction.wordify(builder, context)
+		words.should have(7).words
+		words.should eql(%w{ one two 3 d e f g })
+	end
+
+end