filigree 0.3.0 → 0.3.1

data/test/tc_match.rb

@@ -18,66 +18,66 @@ require 'filigree/match'
 #######################
 
 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)
@@ -86,7 +86,7 @@ class MatchTester < Minitest::Test
 			with(:b) { :SYM }
 		end
 	end
-	
+
 	def match_tester_guard(o)
 		match o do
 			with(n, -> { n < 0 }) { :NEG  }
@@ -94,7 +94,7 @@ class MatchTester < Minitest::Test
 			with(n, -> { n > 0 }) { :POS  }
 		end
 	end
-	
+
 	def match_tester_class_pattern(o)
 		match o do
 			with(Fixnum.as a) { [:Fixnum, a] }
@@ -102,7 +102,7 @@ class MatchTester < Minitest::Test
 			with(String.as a) { [:String, a] }
 		end
 	end
-	
+
 	def match_tester_literal(o)
 		match o do
 			with(Literal(Fixnum)) { :Fixnum }
@@ -110,7 +110,15 @@ class MatchTester < Minitest::Test
 			with(Literal(/a/))    { :Regexp }
 		end
 	end
-	
+
+	def match_tester_bang_bind(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_manual_bind(o)
 		match o do
 			with(Fixnum.as(Bind(:a))) { [:Fixnum, a] }
@@ -118,7 +126,7 @@ class MatchTester < Minitest::Test
 			with(String.as(Bind(:a))) { [:String, a] }
 		end
 	end
-	
+
 	def match_tester_mixed(o)
 		match o do
 			with('hello') { :hello0 }
@@ -127,14 +135,14 @@ class MatchTester < Minitest::Test
 			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   }
@@ -142,7 +150,7 @@ class MatchTester < Minitest::Test
 			with(3) { :three }
 		end
 	end
-	
+
 	def match_tester_tuple(*touple)
 		match *touple do
 			with(1, 2) { :FOO }
@@ -150,7 +158,7 @@ class MatchTester < Minitest::Test
 			with(5)    { :BAF }
 		end
 	end
-	
+
 	def match_tester_tuple_wildcard(*touple)
 		match *touple do
 			with(1)
@@ -159,7 +167,7 @@ class MatchTester < Minitest::Test
 			with(_)    { :WILD }
 		end
 	end
-	
+
 	def match_tester_wildcard(o)
 		match o do
 			with(1) { 1 }
@@ -167,140 +175,146 @@ class MatchTester < Minitest::Test
 			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_bang_bind
+		assert_equal [:Fixnum, 42],    match_tester_bang_bind(42)
+		assert_equal [:Float, 42.0],   match_tester_bang_bind(42.0)
+		assert_equal [:String, 'foo'], match_tester_bang_bind('foo')
+	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

data/test/tc_object.rb

@@ -19,25 +19,25 @@ require 'filigree/object'
 
 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

@@ -18,7 +18,7 @@ require 'filigree/string'
 #######################
 
 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.
@@ -26,10 +26,10 @@ Hello, I am a test string.
   the string segmentation
   code can be tested.
 eos
-	
+
 	def setup
 	end
-	
+
 	def test_segmentation
 		assert_equal SEGMENTED.chomp, ORIGINAL.segment(2, 30)
 	end

data/test/tc_types.rb

@@ -18,99 +18,99 @@ require 'filigree/types'
 #######################
 
 class TypeTester < Minitest::Test
-	
+
 	class Foo
 		include Filigree::TypedClass
-		
+
 		typed_ivar :foo, Integer
 		typed_ivar :bar, String
 		typed_ivar :baf, [Integer]
 	end
-	
+
 	class Bar
 		include Filigree::TypedClass
-		
+
 		typed_ivar :foo, Integer
 		typed_ivar :bar, String
-		
+
 		default_constructor
 	end
-	
+
 	class Baf
 		include Filigree::TypedClass
-		
+
 		typed_ivar :foo, Integer
 		typed_ivar :bar, String, true
-		
+
 		default_constructor
 	end
-	
+
 	class Baz
 		include Filigree::TypedClass
-		
+
 		typed_ivar :foo, Integer
 		typed_ivar :bar, String
-		
+
 		default_constructor true
 	end
-	
+
 	def setup
-		
+
 	end
-	
+
 	def test_check_type
 		assert check_type([], Array)
-		
+
 		assert check_type(1, Fixnum)
 		assert check_type(nil, Fixnum, nil, true).nil?
 		assert check_type(1, Fixnum, nil, false, true)
 		assert check_type(nil, Fixnum, nil, true, true).nil?
 		assert check_type(1, Integer)
-		
+
 		assert_raises(TypeError) { check_type(1, Integer, nil, false, true) }
 		assert_raises(TypeError) { check_type(1, Array) }
 	end
-	
+
 	def test_check_array_type
 		assert check_array_type([1, 2, 3], Fixnum)
 		assert check_array_type([1, 2, 3], Fixnum, nil, true)
 		assert check_array_type([1, 2, 3], Integer)
-		
+
 		assert_raises(TypeError) { check_array_type([1, 2, 3], Integer, nil, false, true) }
 		assert_raises(TypeError) { check_array_type([1, :hello, 'world'], Fixnum) }
 		assert_raises(TypeError) { check_array_type([1, 2, 3], Float, 'foo') }
 	end
-	
+
 	def test_default_constructor
 		v0 = Bar.new(1, 'hello')
-		
+
 		assert_equal 1, v0.foo
 		assert_equal 'hello', v0.bar
-		
+
 		v1 = Baf.new(2)
-		
+
 		assert_equal 2, v1.foo
 		assert_nil v1.bar
-		
+
 		assert_raises(ArgumentError) { Baz.new(3) }
-		
+
 		v2 = Baz.new(2, 'world')
-		
+
 		assert_equal 2, v2.foo
 		assert_equal 'world', v2.bar
 	end
-	
+
 	def test_typed_instance_vars
 		v0 = Foo.new
-		
+
 		v0.foo = 1
 		v0.bar = 'hello'
 		v0.baf = [1,2,3]
-		
+
 		assert_equal 1, v0.foo
 		assert_equal 'hello', v0.bar
 		assert_equal [1,2,3], v0.baf
-		
+
 		assert_raises(TypeError) { v0.foo = 'world' }
 	end
 end