filigree 0.1.2

data/test/tc_commands.rb

@@ -0,0 +1,78 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Filigree
+# Date:		2013/05/17
+# Description:	Test cases the Commands module.
+
+############
+# Requires #
+############
+
+# Standard Library
+require 'minitest/autorun'
+
+# Filigree
+require 'filigree/commands'
+
+#######################
+# Classes and Modules #
+#######################
+
+class CommandTester < Minitest::Test
+	class TestCommands
+		include Filigree::Commands
+		
+		command 'foo' do
+			:foo
+		end
+		
+		command 'foo bar' do
+			:foobar
+		end
+		
+		command 'hello1' do |subject|
+			"hello #{subject}"
+		end
+		
+		config do
+			default 'world'
+			option 'subject', 's', conversions: [:to_s]
+		end
+		command 'hello2' do
+			"hello #{subject}"
+		end
+		
+		command 'add' do |x, y|
+			x.to_i + y.to_i
+		end
+	end
+	
+	def setup
+		@commander = TestCommands.new
+	end
+	
+	def test_command_not_found
+		assert_raises(CommandNotFoundError) { @commander.('bar') }
+	end
+	
+	def test_command_args
+		assert_equal 'hello world', @commander.('hello1 world')
+		assert_equal 42, @commander.('add 27 15')
+	end
+	
+	def test_command_with_wrong_args
+		assert_raises(ArgumentError) { @commander.('hello1 cat dog') }
+	end
+	
+	def test_configured_command
+		assert_equal 'hello world', @commander.('hello2')
+		assert_equal 'hello dog', @commander.('hello2 -s dog')
+	end
+	
+	def test_subcommand
+		assert_equal :foobar, @commander.('foo bar')
+	end
+	
+	def test_zero_arg_command
+		assert_equal :foo, @commander.('foo')
+	end
+end

data/test/tc_configuration.rb

@@ -0,0 +1,173 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Filigree
+# Date:		2013/05/15
+# Description:	Test cases the Configuration module.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Filigree
+require 'filigree/configuration'
+
+#######################
+# Classes and Modules #
+#######################
+
+class ConfigurationTester < Minitest::Test
+	class TestConfig
+		include Filigree::Configuration
+		
+		help 'Does foo.'
+		default { moo.to_s }
+		string_option 'foo', 'f'
+		
+		help 'This is a longer help message to test and see how the string segmentation works. I hope it is long enough.'
+		default 42
+		option 'bar', 'b', conversions: [:to_i]
+		
+		help 'Does baz.'
+		option 'baz', 'z', conversions: [:to_sym, :to_sym]
+		
+		help 'Does moo.'
+		required
+		option 'moo', 'm' do |i|
+			i.to_i * 6
+		end
+		
+		help 'This does daf'
+		option 'daf', 'd' do |*syms|
+			syms.map { |syms| syms.to_sym }
+		end
+		
+		bool_option :bool
+		
+		auto :cow do
+			self.moo / 3
+		end
+	end
+	
+	def setup
+		@defaults = ['--moo', '10']
+	end
+	
+	def test_auto
+		conf = TestConfig.new @defaults
+		
+		assert_equal 20, conf.cow
+	end
+	
+	def test_bool_option
+		conf = TestConfig.new @defaults.clone
+		assert !conf.bool, 'Boolean flag set in config object'
+				
+		conf = TestConfig.new(@defaults.clone << '--bool')
+		assert conf.bool, 'Boolean flag not set in config object'
+	end
+	
+	def test_defaults
+		conf = TestConfig.new @defaults
+		
+		assert_equal 42, conf.bar
+		assert_equal '60', conf.foo
+	end
+	
+	def test_long_option
+		conf = TestConfig.new @defaults
+		
+		assert_equal 60, conf.moo
+	end
+	
+	def test_proc_handler
+		conf = TestConfig.new (@defaults + ['--foo', 'hello world'])
+		
+		assert_equal 'hello world', conf.foo
+	end
+	
+	def test_required
+		assert_raises(ArgumentError)	{ TestConfig.new([]) }
+		TestConfig.new(@defaults)
+	end
+	
+	def test_serialization
+		require 'tempfile'
+		
+		conf = TestConfig.new (@defaults + ['-f', 'hello world', '-b', '32', '-z', 'a', 'b'])
+		
+		yaml_string = conf.dump
+		
+		conf = TestConfig.new yaml_string
+		
+		assert_equal 60,            conf.moo
+		assert_equal 'hello world',	conf.foo
+		assert_equal 32,            conf.bar
+		assert_equal [:a, :b],      conf.baz
+		
+		yaml_file      = Tempfile.new 'tc_configuration_serialization'
+		yaml_file_path = yaml_file.path
+		yaml_file.close
+		
+		# Dump the file.
+		File.open(yaml_file_path, 'w') { |f| conf.dump f }
+		
+		# Load the configuration from the file.
+		conf = File.open(yaml_file_path, 'r') { |f| TestConfig.new f }
+		
+		assert_equal 60,            conf.moo
+		assert_equal 'hello world', conf.foo
+		assert_equal 32,            conf.bar
+		assert_equal [:a, :b],      conf.baz
+		
+		# Remove the file.
+		FileUtils.rm yaml_file_path
+		
+		# Re-create an empty file.
+		FileUtils.touch yaml_file_path
+		
+		# Dump the config again.
+		conf.dump yaml_file_path
+		
+		# Load the configuration again.
+		conf = TestConfig.new yaml_file_path
+		
+		assert_equal 60,            conf.moo
+		assert_equal 'hello world', conf.foo
+		assert_equal 32,            conf.bar
+		assert_equal [:a, :b],      conf.baz
+		
+		#########################
+		# Partial Serialization #
+		#########################
+		
+		yaml_string = conf.dump nil, :moo, :foo, :bar
+		
+		conf = TestConfig.new yaml_string
+		
+		assert_equal 60,			conf.moo
+		assert_equal 'hello world',	conf.foo
+		assert_equal 32,			conf.bar
+	end
+	
+	def test_short_option
+		conf = TestConfig.new ['-m', 10]
+		
+		assert_equal 60, conf.moo
+	end
+	
+	def test_splat
+		conf = TestConfig.new (['-d', 'a', 'b', 'c'] + @defaults)
+		
+		assert_equal [:a, :b, :c], conf.daf
+	end
+	
+	def test_symbol_handler
+		conf = TestConfig.new (@defaults + ['-b', '32'])
+		assert_equal 32, conf.bar
+		
+		conf = TestConfig.new (@defaults + ['-z', 'a', 'b'])
+		assert_equal [:a, :b], conf.baz
+	end
+end

data/test/tc_match.rb

@@ -0,0 +1,307 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Filigree
+# Date:		2013/05/04
+# Description:	Test cases for the match method.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Filigree
+require 'filigree/match'
+
+#######################
+# Classes and Modules #
+#######################
+
+class MatchTester < Minitest::Test
+	
+	####################
+	# Internal Classes #
+	####################
+	
+	class Foo
+		extend Filigree::Destructurable
+		
+		attr_reader :a
+		
+		def initialize(a)
+			@a = a
+		end
+		
+		def destructure(_)
+			[@a]
+		end
+	end
+	
+	class Bar
+		extend Filigree::Destructurable
+		
+		def initialize(a, b)
+			@a = a
+			@b = b
+		end
+		
+		def destructure(_)
+			[@a, @b]
+		end
+	end
+	
+	def setup
+		
+	end
+	
+	###########
+	# Helpers #
+	###########
+	
+	def match_tester_array_destructure(o)
+		match o do
+			with(Array.(x, [])) {       x }
+			with(Array.(x, xs)) { [x, xs] }
+		end
+	end
+	
+	def match_tester_destructure(o)
+		match o do
+			with(Foo.( 1))           {    :one }
+			with(Foo.(:a))           { |a| a.a }
+			with(Foo.(Foo.(:b)))     {      :b }
+			
+			with(Foo.(Foo.(a).as b)) { [a, b] }
+			
+			with(Foo.(a))
+			with(Bar.(a, _))         { a }
+		end
+	end
+	
+	def match_tester_deferred(o)
+		match o do
+			with(1)
+			with(2)  { :NUM }
+			with(:a)
+			with(:b) { :SYM }
+		end
+	end
+	
+	def match_tester_guard(o)
+		match o do
+			with(n, -> { n < 0 }) { :NEG  }
+			with(0)               { :ZERO }
+			with(n, -> { n > 0 }) { :POS  }
+		end
+	end
+	
+	def match_tester_class_pattern(o)
+		match o do
+			with(Fixnum.as a) { [:Fixnum, a] }
+			with(Float.as a)  { [:Float,  a] }
+			with(String.as a) { [:String, a] }
+		end
+	end
+	
+	def match_tester_literal(o)
+		match o do
+			with(Literal(Fixnum)) { :Fixnum }
+			with(Literal(Float))  { :Float  }
+			with(Literal(/a/))    { :Regexp }
+		end
+	end
+	
+	def match_tester_manual_bind(o)
+		match o do
+			with(Fixnum.as(Bind(:a))) { [:Fixnum, a] }
+			with(Float.as(Bind(:a)))  { [:Float,  a] }
+			with(String.as(Bind(:a))) { [:String, a] }
+		end
+	end
+	
+	def match_tester_mixed(o)
+		match o do
+			with('hello') { :hello0 }
+			with('hello') { :hello1 }
+			with(:world)  { :world  }
+			with(1)       { :one    }
+		end
+	end
+	
+	def match_tester_regexp(s)
+		match s do
+			with(/(ab)+/)  { :a }
+			with(/[abc]+/) { :b }
+		end
+	end
+	
+	def match_tester_simple(o)
+		match o do
+			with(1) { :one   }
+			with(2) { :two   }
+			with(3) { :three }
+		end
+	end
+	
+	def match_tester_tuple(*touple)
+		match *touple do
+			with(1, 2) { :FOO }
+			with(3, 4) { :BAR }
+			with(5)    { :BAF }
+		end
+	end
+	
+	def match_tester_tuple_wildcard(*touple)
+		match *touple do
+			with(1)
+			with(2, 3) { :DEF }
+			with(4, _) { :PART_WILD }
+			with(_)    { :WILD }
+		end
+	end
+	
+	def match_tester_wildcard(o)
+		match o do
+			with(1) { 1 }
+			with(2) { 2 }
+			with(n) { n }
+		end
+	end
+	
+	#########
+	# Tests #
+	#########
+	
+	def test_array_destructure
+		assert_equal             42, match_tester_array_destructure([42])
+		assert_equal [1, [2, 3, 4]], match_tester_array_destructure([1, 2, 3, 4])
+	end
+	
+	def test_as
+		v0 = Foo.new(:dog)
+		v1 = Foo.new(v0)
+		
+		assert_equal([:dog, v0], match_tester_destructure(v1))
+	end
+	
+	def test_class_pattern
+		assert_equal [:Fixnum, 42],    match_tester_class_pattern(42)
+		assert_equal [:Float, 42.0],   match_tester_class_pattern(42.0)
+		assert_equal [:String, 'foo'], match_tester_class_pattern('foo')
+	end
+	
+	def test_constants
+		assert_equal :one,   match_tester_simple(1)
+		assert_equal :two,   match_tester_simple(2)
+		assert_equal :three, match_tester_simple(3)
+		
+		assert_raises(MatchError) { match_tester_simple(4) }
+		
+		assert_equal :hello0, match_tester_mixed('hello')
+		assert_equal :world,  match_tester_mixed(:world)
+		assert_equal :one,    match_tester_mixed(1)
+	end
+	
+	def test_deconstructor
+		assert_equal :one, match_tester_destructure(Foo.new(   1))
+		assert_equal :a,   match_tester_destructure(Foo.new(  :a))
+		assert_equal 42.0, match_tester_destructure(Foo.new(42.0))
+		
+		assert_equal :b,   match_tester_destructure(Foo.new(Foo.new(:b)))
+		assert_equal 42,   match_tester_destructure(Bar.new(42, nil))
+	end
+	
+	def test_deferred_block
+		assert_equal :NUM, match_tester_deferred(1)
+		assert_equal :NUM, match_tester_deferred(2)
+		
+		assert_equal :SYM, match_tester_deferred(:a)
+		assert_equal :SYM, match_tester_deferred(:b)
+	end
+	
+	def test_guards
+		assert_equal :NEG,  match_tester_guard(-5)
+		assert_equal :ZERO, match_tester_guard(0)
+		assert_equal :POS,  match_tester_guard(6)
+	end
+	
+	def test_literals
+		assert_equal :Fixnum, match_tester_literal(Fixnum)
+		assert_equal :Float,  match_tester_literal(Float)
+		assert_equal :Regexp, match_tester_literal(/a/)
+	end
+	
+	def test_manual_bind
+		assert_equal [:Fixnum, 42],    match_tester_manual_bind(42)
+		assert_equal [:Float, 42.0],   match_tester_manual_bind(42.0)
+		assert_equal [:String, 'foo'], match_tester_manual_bind('foo')
+	end
+	
+	def test_match_array
+		result =
+		match [1,2,3,4] do
+		with(Array.(a, b, c))	{ [a, b, c] }
+		end
+		
+		assert_equal [1, 2, [3, 4]], result
+	end
+	
+	def test_regexp
+		assert_equal :a, match_tester_regexp('abab')
+		assert_equal :b, match_tester_regexp('acba')
+		
+		assert_raises(MatchError) { match_tester_regexp('def') }
+		
+		actual =
+		match 'a42' do
+			with(/a([0-9]+)/) { match_data[1].to_i }
+		end
+		
+		assert_equal 42, actual
+	end
+	
+	def test_tuple_wildcard
+		assert_equal :DEF, match_tester_tuple_wildcard(1)
+		assert_equal :DEF, match_tester_tuple_wildcard(2, 3)
+		
+		assert_equal :PART_WILD, match_tester_tuple_wildcard(4, 1)
+		assert_equal :PART_WILD, match_tester_tuple_wildcard(4, :cat)
+		
+		assert_equal :WILD, match_tester_tuple_wildcard(5)
+		assert_equal :WILD, match_tester_tuple_wildcard(5, 6)
+		assert_equal :WILD, match_tester_tuple_wildcard(5, 6, 7)
+	end
+	
+	def test_tuples
+		assert_equal :FOO, match_tester_tuple(1, 2)
+		assert_equal :BAR, match_tester_tuple(3, 4)
+		assert_equal :BAF, match_tester_tuple(5)
+		
+		assert_raises(MatchError) { match_tester_tuple(1, 2, 3) }
+		assert_raises(MatchError) { match_tester_tuple(6)		}
+	end
+	
+	def test_variable_comparison
+		var = 42
+		
+		actual =
+		match 42 do
+			with(var) { :hoopy }
+			with(_)   { :other }
+		end
+		
+		assert_equal :hoopy, actual
+	end
+	
+	def test_wildcard_pattern
+		result =
+		match 42 do
+			with(n) { n }
+		end
+		
+		assert_equal 42, result
+		
+		assert_equal  1, match_tester_wildcard(1)
+		assert_equal 42, match_tester_wildcard(42)
+	end
+end

data/test/tc_object.rb

@@ -0,0 +1,43 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Filigree
+# Date:		2013/05/04
+# Description:	Test cases for the Object extensions.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Filigree
+require 'filigree/object'
+
+#######################
+# Classes and Modules #
+#######################
+
+class ObjectTester < Minitest::Test
+	Foo = Struct.new :a, :b
+	
+	def setup
+		
+	end
+	
+	def test_returning
+		assert( returning(true) { false } )
+	end
+	
+	def test_with
+		v0 = Foo.new(1, 2)
+		v1 = v0.clone_with { self.a = 3 }
+		
+		assert_equal 1, v0.a
+		assert_equal 2, v0.b
+		
+		assert_equal 3, v1.a
+		assert_equal 2, v1.b
+		
+		refute_equal v0.object_id, v1.object_id
+	end
+end

data/test/tc_string.rb

@@ -0,0 +1,36 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Filigree
+# Date:		2014/02/05
+# Description:	Test cases for the String extensions.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Filigree
+require 'filigree/string'
+
+#######################
+# Classes and Modules #
+#######################
+
+class ObjectTester < Minitest::Test
+	
+	ORIGINAL = 'Hello, I am a test string. I am really long so that the string segmentation code can be tested.'
+	SEGMENTED = <<eos
+Hello, I am a test string.
+  I am really long so that
+  the string segmentation
+  code can be tested.
+eos
+	
+	def setup
+	end
+	
+	def test_segmentation
+		assert_equal SEGMENTED.chomp, ORIGINAL.segment(2, 30)
+	end
+end