y_support 1.0.0

data/test/misc_test.rb

@@ -0,0 +1,289 @@
+#! /usr/bin/ruby
+#encoding: utf-8
+
+require 'test/unit'
+require 'shoulda'
+
+class MiscTest < Test::Unit::TestCase
+  context "Object" do
+    setup do
+      require 'y_support/core_ext/object'
+    end
+
+    should "have #const_set_if_not_defined" do
+      ( ◉ = Object.new ).const_set_if_not_defined :KOKO, 42
+      assert_equal 42, ◉.singleton_class::KOKO
+      ◉.const_set_if_not_defined :KOKO, 43
+      assert_equal 42, ◉.singleton_class::KOKO
+    end
+
+    should "have #const_redef_without_warning" do
+      ( ◉ = Object.new ).const_set_if_not_defined :KOKO, 42
+      ◉.const_redefine_without_warning :KOKO, 43
+      assert_equal 43, ◉.singleton_class::KOKO
+    end
+  end # context Object
+  
+  context "Module" do
+    setup do
+      require 'y_support/core_ext/module'
+    end
+
+    should "have working #attr_accessor_with_default" do
+      class Klass
+        attr_accessor_with_default :hello do "world" end
+      end
+      assert_equal "world", Klass.new.hello
+      instance = Klass.new
+      instance.hello = "certain string"             # testing setter
+      assert_equal "certain string", instance.hello # testing getter
+    end
+    
+    should "have working autoreq" do
+      module TestModule
+        autoreq :fixture_class, descending_path: '.', ascending_path_prefix: '.'
+      end
+      assert_equal "world", TestModule::FixtureClass.new.hello
+    end
+  end # context Module
+
+  context "Enumerable" do
+    setup do
+      require 'y_support/core_ext/enumerable'
+    end
+
+    should "introduce #all_kind_of? collection qualifier" do
+      assert_equal true, [ 1, 1.0 ].all_kind_of?( Numeric )
+      assert_equal false, [ 1, [1.0] ].all_kind_of?( Numeric )
+    end
+    
+    should "introduce #all_numeric? collection qualifier" do
+      assert_equal true, [1, 1.0].all_numeric?
+      assert_equal false, [:a, 1].all_numeric?
+    end
+    
+    should "have #subset_of? collection qualifier" do
+      assert_equal( true, [1,2].subset_of?( [1,2,3,4] ) )
+      assert_equal( false, [1,2].subset_of?( [2,3] ) )
+      assert_equal( true, [1,2].subset_of?( [1,2] ) )
+      assert_equal( true, [1, 1.0].subset_of?( [1.0, 2.0] ) )
+    end
+  end # context Enumerable
+
+  context "Array" do
+    setup do
+      require 'y_support/core_ext/array'
+    end
+
+    should "have #to_hash" do
+      assert_equal( {a: :b, c: :d}, [[:a, :b],[:c, :d]].to_hash )
+      assert_equal( {k: :kokot, p: :pica}, [[:k, :o, :kokot], [:p, :i, :pica]].to_hash(2) )
+    end
+
+    should "have #each_consecutive_pair iterator" do
+      assert_kind_of Enumerator, [].each_consecutive_pair
+      assert_kind_of Enumerator, [:a].each_consecutive_pair
+      assert_kind_of Enumerator, [:a, :b].each_consecutive_pair
+      assert_kind_of Enumerator, [:a, :b, :c].each_consecutive_pair
+      assert_equal [], [].each_consecutive_pair.collect{|e| e }
+      assert_equal [], [:a].each_consecutive_pair.collect{|e| e }
+      assert_equal [[:a, :b]], [:a, :b].each_consecutive_pair.collect{|e| e }
+      assert_equal [[:a, :b], [:b, :c]], [:a, :b, :c].each_consecutive_pair.collect{|e| e }
+    end
+
+    should "have #to_proc in style &[ function, *arguments ]" do
+      assert_equal [2, 3], [1, 2].map( &[:+, 1] )
+    end
+  end # context Array
+
+  context "Hash" do
+    setup do
+      require 'y_support/core_ext/hash'
+    end
+
+    should "have #default! custom defaulter" do
+      defaults = { a: 1, b: nil }
+      test = {}
+      result = test.default!( defaults )
+      assert_equal defaults, result
+      assert_equal result.object_id, test.object_id
+      test = { a: 11, b: 22 }
+      assert_equal( { a: 11, b: 22 }, test.default!( defaults ) )
+      test = { a: 11, c: 22 }
+      assert_equal( { a: 11, b: nil, c: 22 }, test.default!( defaults ) )
+    end
+    
+    should "have #with_keys and #modify_keys" do
+      assert_equal( {"a" => :b, "c" => :d}, {a: :b, c: :d}.with_keys( &:to_s ) )
+      assert_equal( {"a1" => 1, "c2" => 2}, {a: 1, c: 2}.modify_keys { |k, v|
+                      k.to_s + v.to_s } )
+      assert_equal( {"a1" => 1, "c2" => 2}, {a: 1, c: 2}.modify_keys {|p|
+                      p[0].to_s + p[1].to_s } )
+      assert_equal( {2 => 1, 4 => 2}, {1 => 1, 2 => 2}.modify_keys { |k, v|
+                      k + v } )
+      assert_equal( {2 => 1, 4 => 2}, {1 => 1, 2 => 2}.modify_keys { |p|
+                      p[0] + p[1] } )
+    end
+    
+    should "have #with_values and #modify_values" do
+      assert_equal( { a: "b", c: "d" }, {a: :b, c: :d}.with_values( &:to_s ) )
+      assert_equal( {a: "ab", c: "cd"}, {a: :b, c: :d}.modify_values { |k, v|
+                      k.to_s + v.to_s } )
+      assert_equal( {a: "ab", c: "cd"}, {a: :b, c: :d}.modify_values { |p|
+                      p[0].to_s + p[1].to_s } )
+      hh = { a: 1, b: 2 }
+      hh.with_values! &:to_s
+      assert_equal ["1", "2"], hh.values
+      hh.modify_values! &:join
+      assert_equal ["a1", "b2"], hh.values
+    end
+
+    should "have #modify" do
+      assert_equal( { ab: "ba", cd: "dc" },
+                    { a: :b, c: :d }
+                      .modify { |k, v| ["#{k}#{v}".to_sym, "#{v}#{k}"] } )
+    end
+    
+    should "have #dot! meta patcher for dotted access to keys" do
+      h = Hash.new.merge!(aaa: 1, taint: 2)
+      assert_raise ArgumentError do h.dot! end
+      assert_nothing_raised do h.dot!( overwrite_methods: true ) end
+      assert_equal( {aaa: 1}, {aaa: 1}.dot! )
+    end
+  end # context Hash
+  
+  context "Matrix" do
+    setup do
+      require 'y_support/stdlib_ext/matrix'
+    end
+    
+    should "have #pp method" do
+      assert_respond_to Matrix[[1, 2], [3, 4]], :pretty_print
+      assert_respond_to Matrix[[1, 2], [3, 4]], :pp
+    end
+
+    should "have #correspondence_matrix method" do
+      assert_respond_to Matrix, :correspondence_matrix
+      assert_equal Matrix[[1, 0, 0], [0, 1, 0]],
+                   Matrix.correspondence_matrix( [:a, :b, :c], [:a, :b] )
+      assert_equal Matrix.column_vector( [1, 2] ),
+                   Matrix.correspondence_matrix( [:a, :b, :c], [:a, :b] ) *
+                     Matrix.column_vector( [1, 2, 3] )
+      assert_equal 2, Matrix.correspondence_matrix( [1, 2], [1] ).column_size
+    end
+
+    should "have #column_to_a & #row_to_a" do
+      assert_equal [1, 2, 3], Matrix[[1], [2], [3]].column_to_a
+      assert_equal [2, 3, 4], Matrix[[1, 2], [2, 3], [3, 4]].column_to_a( 1 )
+      assert_equal nil, Matrix.empty( 5, 0 ).column_to_a
+      assert_equal [1], Matrix[[1], [2], [3]].row_to_a
+      assert_equal [3], Matrix[[1], [2], [3]].row_to_a( 2 )
+    end
+
+    should "have aliased #row_vector, #column_vector methods" do
+      assert_equal Matrix.column_vector( [1, 2, 3] ),
+                   Matrix.cv( [1, 2, 3] )
+      assert_equal Matrix.row_vector( [1, 2, 3] ),
+                   Matrix.rv( [1, 2, 3] )
+    end
+
+    should "have #join_bottom and #join_right" do
+      assert_equal Matrix[[1, 2], [3, 4]],
+                   Matrix[[1, 2]].join_bottom( Matrix[[3, 4]] )
+      assert_equal Matrix[[1, 2, 3, 4]],
+                   Matrix[[1, 2]].join_right( Matrix[[3, 4]] )
+    end
+
+    should "have aliased #row_size, #column_size methods" do
+      assert_equal 3, Matrix.zero(3, 2).height
+      assert_equal 3, Matrix.zero(3, 2).number_of_rows
+      assert_equal 2, Matrix.zero(3, 2).width
+      assert_equal 2, Matrix.zero(3, 2).number_of_columns
+    end
+  end # context Matrix
+  
+  context "String" do
+    setup do
+      require 'y_support/core_ext/string'
+    end
+
+    should "have #can_be_integer? returning the integer or false if not convertible" do
+      assert_equal 33, "  33".to_Integer
+      assert_equal 8, " 010 ".to_Integer
+      assert_equal false, "garbage".to_Integer
+    end
+    
+    should "have #can_be_float? returning the float or false if not convertible" do
+      assert_equal 22.2, ' 2.22e1'.to_Float
+      assert_equal 10, " 010 ".to_Float
+      assert_equal false, "garbage".to_Float
+    end
+    
+    should "have #default! defaulter" do
+      assert_equal "default", "".default!("default")
+      assert_equal "default", " ".default!(:default)
+      assert_equal "default", " \n ".default!("default")
+      assert_equal "kokot", "kokot".default!("default")
+      a = ""
+      assert_equal a.object_id, a.default!("tata").object_id
+    end
+    
+    should "have #stripn upgrade of #strip, which also strips newlines" do
+      assert_equal "test test", " \n test test \n\n  \n ".stripn
+    end
+    
+    should "have #compact for joining indented lines (esp. heredocs)" do
+      assert_equal "test test test",
+                   "test\n test\n\n   \n   test\n  ".wring_heredoc
+      funny_string = <<-FUNNY_STRING.wring_heredoc
+                        This
+                          is
+                            a funny string.
+                        FUNNY_STRING
+      assert_equal( 'This is a funny string.', funny_string )
+    end
+    
+    should "be able #underscore_spaces" do
+      assert_equal "te_st_test", "te st test".underscore_spaces
+    end
+    
+    should "have #symbolize stripping, removing capitalization and diacritics " \
+    'as if to make a suitable symbol material' do
+      assert_equal "Yes_sir!", " \nYes, sir!.; \n \n".standardize
+    end
+    
+    should "have #to_standardized_sym chaining #standardize and #to_sym" do
+      assert_equal :Yes,  " \nYes,.; \n \n".to_standardized_sym
+    end
+  end # context String
+
+  context "Symbol" do
+    setup do
+      require 'y_support/core_ext/symbol'
+    end
+
+    should "have #default! defaulter going through String#default!" do
+      assert_equal :default, "".to_sym.default!(:default)
+      assert_equal :default, "".to_sym.default!("default")
+      assert_equal :default, " ".to_sym.default!("default")
+      assert_equal :default, " \n ".to_sym.default!("default")
+      assert_equal :kokot, :kokot.default!("default")
+    end
+    
+    should "have #to_standardized_sym" do
+      assert_equal :Yes, (:" \nYes, \n").to_standardized_sym
+    end
+  end # context Symbol
+
+  context "Numeric" do
+    setup do
+      require 'y_support/core_ext/numeric'
+    end
+
+    should "have #zero public class methods" do
+      assert_equal 0, Integer.zero
+      assert_equal 0.0, Float.zero
+      assert_equal Complex(0, 0), Complex.zero
+    end
+  end
+end # class YSupportTest

data/test/name_magic_test.rb

@@ -0,0 +1,57 @@
+#! /usr/bin/ruby
+#encoding: utf-8
+
+require 'test/unit'
+require 'shoulda'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'y_support/name_magic'
+
+describe NameMagic do
+  before do
+    mod = Module.new do include NameMagic end
+    @ç = Class.new do include mod end
+    @reporter = Object.new
+    puts "..."
+    @reporter.singleton_class.class_exec { attr_reader :report, :naming }
+    @ç.new_instance_closure do |instance|
+      @reporter.define_singleton_method :report do
+        "New instance reported"
+      end
+    end
+    @ç.name_set_closure do |name, instance, old_name|
+      @reporter.define_singleton_method :name_set do
+        "Name of the new instance was #{name}"
+      end
+      name
+    end
+    @ç.name_get_closure do |name_object|
+      @reporter.define_singleton_method :name_get do
+        "Name get closure called on #{name_object}"
+      end
+      name_object
+    end
+  end
+  
+  it "should work" do
+    @ç.must_respond_to :const_magic
+    @ç.instances.must_be_empty
+    @ç.nameless_instances.must_be_empty
+    @reporter.report.must_equal nil
+    x = @ç.new( name: "Boris" )
+    @reporter.report.must_equal "New instance reported"
+    @reporter.name_set.must_equal "Name of the new instance was Boris"
+    x.name.must_equal :Boris
+    @reporter.name_get.must_equal "Name get closure called on Boris"
+    ufo = @ç.new
+    @ç.nameless_instances.must_equal [ufo]
+    UFO = @ç.new
+    @reporter.report.must_equal "New instance reported"
+    @reporter.name_set.must_equal "Name of the new instance was Boris"
+    UFO.name
+    @reporter.name_set.must_equal "Name of the new instance was UFO"
+    @reporter.name_get.must_equal "Name get closure called on UFO"
+    Elaine = @ç.new
+    Elaine.name.must_equal :Elaine
+  end
+end

data/test/null_object_test.rb

@@ -0,0 +1,50 @@
+#! /usr/bin/ruby
+#encoding: utf-8
+
+require 'test/unit'
+require 'shoulda'
+
+class NullObjectTest < Test::Unit::TestCase
+  context 'Object' do
+    setup do
+      require 'y_support/null_object'
+    end
+
+    should "Object have #null_object? (alias #null?)" do
+      require 'y_support/null_object'
+      assert_equal true, (class Koko < NullObject; self end).new.null_object?
+      assert_equal true, (class Koko < NullObject; self end).new.null?
+      assert_equal [false, false], [nil.null_object?, nil.null?]
+      assert_equal true, NullObject.new( :koko ).null?( :koko )
+      assert_equal false, NullObject.new( :koko ).null?( :pipi )
+    end
+
+    should "Object have #Maybe() constructor for something / NullObject" do
+      assert_equal NullObject, Maybe(nil).class
+      assert_equal 42, Maybe(42)
+    end
+    
+    should "Object have #Null() constructor always returning NullObject" do
+      assert_equal NullObject, Null().class
+    end
+  end # context Object
+  
+  context "NullObject" do
+    setup do
+      require 'y_support/null_object'
+    end
+
+    should "NullObject exist and comply" do
+      n = NullObject.new
+      assert_equal [[], "#<NullObject>", 0.0, 0], [n.to_a, n.to_s, n.to_f, n.to_i]
+      assert_equal [false, true], [n.present?, n.empty?]
+      assert_nothing_raised { NullObject.new.
+        must_have_attr_reader( :recorded_messages ) }
+      assert_respond_to NullObject.new, :arbitrary_message
+      n = NullObject.new :x
+      n.arbitrary_message( :a, :b ) { "hello" }
+      assert_equal :x, n.null_object_signature
+      assert_equal "#<NullObject kokotina>", NullObject.new( :kokotina ).inspect
+    end
+  end # context NullObject
+end # class NullObjectTest

data/test/respond_to_test.rb

@@ -0,0 +1,46 @@
+#! /usr/bin/ruby
+#encoding: utf-8
+
+require 'test/unit'
+require 'shoulda'
+
+class RespondToTest < Test::Unit::TestCase
+  context "Object" do
+    setup do
+      require 'y_support/respond_to'
+    end
+
+    should "have RespondTo() constructor" do
+      assert_equal RespondTo, RespondTo( :inspect ).class
+    end
+  end # context Object
+
+  context "RespondTo" do
+    should "work" do
+      assert_respond_to( RespondTo.new(:hello), :=== )
+      assert RespondTo.new(:each_char) === "arbitrary string"
+      assert ! ( RespondTo.new(:each_char) === Object.new )
+      assert ! ( RespondTo.new(:improbab_method_name) === Object.new )
+      # Now testing the intended RespondTo usage in case statements.
+      assert case ?x
+             when RespondTo.new(:each_char) then 1
+             else false end
+      assert ! case ?x
+               when RespondTo.new(:improbab_method_name) then 1
+               else false end
+    end
+  end # context RespondTo
+
+  context "Symbol" do
+    should "have Symbol#~@ for .respond_to? case statements" do
+      assert_kind_of RespondTo, ~:hello
+      assert RespondTo(:<<) === "testing"
+      assert case ?x
+             when ~:each_char then 1
+             else false end
+      assert ! case ?x
+               when ~:improbab_method_name then 1
+               else false end
+    end
+  end # context Symbol
+end # class RespondToTest

data/test/typing_test.rb

@@ -0,0 +1,213 @@
+#! /usr/bin/ruby
+#encoding: utf-8
+
+require 'test/unit'
+require 'shoulda'
+require 'y_support/typing'
+
+class TypingTest < Test::Unit::TestCase
+  P = Class.new
+  K = Class.new
+  L = Module.new
+
+  context "with some classes" do
+    setup do
+      @p = P.new
+      @k = K.new
+      @l = L
+    end
+
+    should "have working class compliance methods" do
+      assert @p.class_complies?( @p.class )
+      assert ! @p.class_complies?( @k.class )
+      @p.declare_class_compliance! @k.class
+      assert @p.class_declares_compliance?( @k.class )
+      assert_equal [ @k.class ], @p.declared_class_compliance
+      assert_equal [], @k.declared_class_compliance
+      assert @p.class_complies? Object
+      o = Object.new
+      assert_equal false, o.class_complies?( @l )
+      o.extend @l
+      assert_equal true, o.class_complies?( @l )
+    end
+  end
+
+  context "general" do
+    should "have AErr alias for ArgumentError" do
+      assert_equal ::ArgumentError, ::AErr
+    end
+    
+    should "have #aE raising ArgumentError if block falsey" do
+      assert_raise TErr do 0.aT "yada yada" do self == 1 end end
+      assert_nothing_raised do 0.aT "yada yada" do self == 0 end end
+      assert_equal( "hello",
+                    "hello".aT( "have 4 unique letters" ) {
+                      each_char.map { |e| e }.uniq.join.size == 4
+                    } )
+      assert_nothing_raised do 2.aT &:even? end
+      assert_raise TErr do 3.aT &:even? end
+      assert_raise TErr do nil.aT end
+    end
+    
+    should "have #aT_not raising TypeError if block truey" do
+      assert_raise TErr do 0.aT_not { self < 1 } end
+      assert_nothing_raised do 1.aT_not { self == 2 } end
+      assert_equal( "hello", "hello".aT_not( "have x" ) { include? 'x' } )
+      assert_nothing_raised do 3.aT_not &:even? end
+      assert_raise TErr do 2.aT_not &:even? end
+      assert_raise TErr do "".aT_not end
+    end
+    
+    should "have #aT_kind_of, alias #aT_is_a TErr enforcers" do
+      assert_raise TErr do :o.aT_kind_of Numeric end
+      assert_nothing_raised do 0.aT_kind_of Numeric end
+      assert_equal( "hello", "hello".aT_kind_of( String ) )
+      assert_raise TErr do :o.aT_is_a Numeric end
+      assert_nothing_raised do 0.aT_is_a Numeric end
+      assert_equal( "hello", "hello".aT_is_a( String ) )
+    end
+    
+    should "have #aT_complies" do
+      Koko = Class.new; Pipi = Class.new
+      koko = Koko.new; pipi = Pipi.new
+      pipi.declare_class_compliance! koko.class
+      assert_raise TErr do koko.aT_class_complies pipi.class end
+      assert_nothing_raised do koko.aT_class_complies koko.class end
+      assert_nothing_raised do pipi.aT_class_complies pipi.class end
+      assert_nothing_raised do pipi.aT_class_complies koko.class end
+      assert_raise TErr do koko.aT_class_complies Pipi end
+      assert_nothing_raised do pipi.aT_class_complies Pipi end
+      assert_nothing_raised do pipi.aT_class_complies Koko end
+      assert_equal koko, koko.aT_class_complies( Koko )
+    end
+    
+    should "have #aT_respond_to enforcer" do
+      assert_raise TErr do :o.aT_respond_to :each end
+      assert_nothing_raised do {}.aT_respond_to :each end
+      assert_equal( [:hello], [:hello].aT_respond_to( :each ) )
+    end
+    
+    should "have #aT_equal enforcer" do
+      assert_raise TErr do 0.aT_equal 1 end
+      assert_nothing_raised do 1.aT_equal 2.0/2.0 end
+      assert_equal( "hello", "hello".aT_equal( " hello ".strip ) )
+    end
+    
+    should "have #aT_not_equal enforcer" do
+      assert_raise TErr do 1.aT_not_equal 1.0 end
+      assert_nothing_raised do 7.aT_not_equal 42 end
+      assert_equal( "hello", "hello".aT_not_equal( "goodbye" ) )
+    end
+    
+    should "have #aT_blank enforcer" do
+      assert_raise TErr do "x".aT_blank end
+      assert_nothing_raised do ["", []].each{|e| e.aT_blank } end
+      assert_equal( {}, {}.aT_blank )
+    end
+    
+    should "have #aT_present enforcer" do
+      assert_raise TErr do nil.aT_present end
+      assert_nothing_raised do 0.aT_present end
+      assert_equal( "hello", "hello".aT_present )
+    end
+  end
+    
+  context "Enumerable" do
+    should "have #aT_all enforcer" do
+      assert_raise TErr do [1, 2, 7].aT_all { |e| e < 5 } end
+      assert_nothing_raised do [1, 2, 4].aT_all { |e| e < 5 } end
+    end
+
+    should "have #aT_all_kind_of enforcer" do
+      assert_raise TErr do [1.0, 2.0, :a].aT_all_kind_of Numeric end
+      assert_nothing_raised do [1.0, 2.0, 3].aT_all_kind_of Numeric end
+    end
+
+    should "have #aT_all_comply class compliance enforcer" do
+      assert_raise TErr do [1.0, 2.0, :a].aT_all_comply Numeric end
+      assert_nothing_raised do [1.0, 2.0, 3].aT_all_comply Numeric end
+    end
+
+    should "have #aT_all_numeric enforcer" do
+      assert_raise TErr do [:a].aT_all_numeric end
+      assert_nothing_raised do [1, 2.0].aT_all_numeric end
+    end
+    
+    should "have #aT_subset_of enforcer" do
+      assert_raise TErr do [6].aT_subset_of [*0..5] end
+      assert_nothing_raised do [1,2].aT_subset_of [*0..5] end
+    end
+  end # context Enumerable
+
+  context "Array" do
+    should "have #aT_includes (alias #aT_include) enforcer" do
+      assert_raise TErr do [1, 2, 4].aT_includes 3 end
+      assert_nothing_raised do [1, 2, 4].aT_includes( 4 ).aT_include( 4 ) end
+      assert_equal [6, 7], [6, 7].aT_includes( 6 )
+      assert_equal [6, 7], [6, 7].aT_include( 6 )
+    end
+  end # context Array
+
+  context "Hash" do
+    should "have #merge_synonym_keys! method" do
+      a = { a: 'a', b: 'b', k: 'k', o: 'k', t: 'k' }
+      old = a.dup
+      assert_respond_to a, :merge_synonym_keys!
+      assert_equal false, a.merge_synonym_keys!( :a, nil )
+      assert_equal old, a
+      assert_equal nil, a.merge_synonym_keys!( :z, nil )
+      assert_equal old, a
+      assert_equal true, a.merge_synonym_keys!( :k, :o, :t )
+      assert_equal( { a: 'a', b: 'b', k: 'k' }, a )
+      old = a.dup
+      assert_raise TErr do a.merge_synonym_keys!( :a, :b ) end
+      assert_equal old, a
+      assert_equal true, a.merge_synonym_keys!( :c, :b )
+      assert_equal( { a: 'a', c: 'b', k: 'k' }, a )
+    end
+    
+    should "have #may_have synonym key merger" do
+      a = { a: 'a', b: 'b', k: 'k', o: 'k', t: 'k' }
+      assert_respond_to a, :may_have
+      old = a.dup
+      assert_nothing_raised do a.may_have :z end
+      assert_nothing_raised do a.has? :z end
+      assert_raises TErr do a.may_have( :a, syn!: :b ) end
+      assert_raises TErr do a.has?( :a, syn!: :b ) end
+      assert_equal false, a.has?( :z )
+      assert_equal nil, a.may_have( :z )
+      assert_equal false, a.has?( :z )
+      assert_equal true, a.has?( :a )
+      assert_equal a[:a], a.may_have( :a )
+      assert_equal true, a.has?( :a )
+      assert_equal old, a
+      assert_equal 'k', a.may_have( :k, syn!: [:o, :t] )
+      assert_equal true, a.has?( :k, syn!: [:o, :t] )
+      assert_equal 'b', a.may_have( :c, syn!: :b )
+      assert_equal true, a.has?( :c, syn!: :b )
+      assert_equal( { a: 'a', c: 'b', k: 'k' }, a )
+    end
+    
+    should "have #aT_has synonymizing enforcer" do
+      a = { infile: 'a', csv_out_file: 'b', k: 'k', o: 'k', t: 'k' }
+      assert_respond_to a, :aT_has
+      old = a.dup
+      assert_raises TErr do a.aT_has :z end
+      assert_nothing_raised do a.aT_has :infile end
+      assert_nothing_raised do a.aT_has :csv_out_file end
+      class TestClass; def initialize( args )
+                         args.aT_has :infile
+                         args.aT_has :csv_out_file
+                         args.aT_has :k
+                       end end
+      assert_nothing_raised do TestClass.new a end
+      assert_raises TErr do a.aT_has( :a, syn!: :b ) end
+      assert_equal "a", a.aT_has( :infile )
+      assert_equal "k", a.aT_has( :k, syn!: [:o, :t] )
+      assert_equal "b", a.aT_has( :c, syn!: :csv_out_file )
+      assert_equal( { infile: 'a', c: 'b', k: 'k' }, a )
+      assert_raises TErr do a.aT_has(:c) {|val| val == 'c'} end
+      assert_nothing_raised do a.aT_has(:c) {|val| val == 'b'} end
+    end
+  end # context Hash
+end # class ScruplesTest

data/test/unicode_test.rb

@@ -0,0 +1,39 @@
+#! /usr/bin/ruby
+#encoding: utf-8
+
+require 'test/unit'
+require 'shoulda'
+# require 'y_support/all'
+
+class UnicodeTest < Test::Unit::TestCase
+  context "Object" do
+    setup do
+      require 'y_support/unicode'
+    end
+
+    should "have a very limited number of one-character Unicode aliases" do
+      ◉ = Object.new
+      assert ◉.singleton_class == ◉.©
+      assert ◉.singleton_class == ◉.ⓒ
+      assert ◉.ç == ◉.class
+      assert 2 == √( 4 )
+      assert 10 == ∑(1..4)
+      assert 10 == Σ(1..4)
+      assert 24 == ∏(1..4)
+      assert 24 == Π(1..4)
+      ɱ = Module.new
+      ɱ.ç_variable_set :@@meaning, 42
+      assert ɱ.class_variable_get( :@@meaning ) == 42
+      assert ɱ.ç_variable_get( :@@meaning ) == 42
+      assert ɱ.ç_variable_defined?( :@@meaning )
+      ɱ.remove_ç_variable :@@meaning
+      assert ! ɱ.ç_variable_defined?( :@@meaning )
+      ll = λ{}
+      assert ll.is_a? Proc
+      assert ll.lambda?
+      lL = Λ{}
+      assert lL.is_a? Proc
+      assert ! lL.lambda?
+    end
+  end
+end