y_support 2.1.5 → 2.1.12

data/test/typing_test.rb

@@ -1,23 +1,22 @@
-#! /Usr/Bin/ruby
-#encoding: utf-8
+#! /usr/bin/ruby
+# encoding: utf-8
 
-require 'test/unit'
-require 'shoulda'
-require 'y_support/typing'
+require 'minitest/autorun'
 
-class TypingTest < Test::Unit::TestCase
-  P = Class.new
-  K = Class.new
-  L = Module.new
+describe "y_support/typing" do
+  before do
+    require './../lib/y_support/typing'
+    P = Class.new unless defined? P
+    K = Class.new unless defined? K
+    L = Module.new unless defined? L
+  end
 
-  context "with some classes" do
-    setup do
-      @p = P.new
-      @k = K.new
-      @l = L
+  describe "with some classes" do
+    before do
+      @p, @k, @l = P.new, K.new, L
     end
 
-    should "have working class compliance methods" do
+    it "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
@@ -32,124 +31,122 @@ class TypingTest < Test::Unit::TestCase
     end
   end
 
-  context "general" do
-    should "have AErr alias for ArgumentError" do
-      assert_equal ::ArgumentError, ::AErr
-    end
-    
-    should "have #aT raising TypeError if block falsey" do
-      assert_raise TypeError do 0.aT "yada yada" do |rcvr| rcvr == 1 end end
-      assert_nothing_raised do 0.aT "yada yada" do |rcvr| rcvr == 0 end end
+  describe "in general" do
+    it "should have #aT raising TypeError if block falsey" do
+      -> { 0.aT "yada yada" do |rcvr| rcvr == 1 end }.must_raise TypeError
+      assert 0.aT "yada yada" do |rcvr| rcvr == 0 end
       assert_equal( "hello",
                     "hello".aT( "have 4 unique letters" ) { |str|
                       str.each_char.map { |e| e }.uniq.join.size == 4
                     } )
-      assert_nothing_raised do 2.aT &:even? end
-      assert_raise TypeError do 3.aT &:even? end
-      assert_raise TypeError do nil.aT end
+      assert 2.aT &:even?
+      -> { 3.aT &:even? }.must_raise TypeError
+      -> { nil.aT }.must_raise TypeError
     end
-    
-    should "have #aT_not raising TypeError if block truey" do
-      assert_raise TypeError do 0.aT_not { |rcvr| rcvr < 1 } end
-      assert_nothing_raised do 1.aT_not { |rcvr| rcvr == 2 } end
+
+    it "should have #aT_not raising TypeError if block truey" do
+      -> { 0.aT_not { |rcvr| rcvr < 1 } }.must_raise TypeError
+      assert 1.aT_not { |rcvr| rcvr == 2 }
       assert_equal( "hello", "hello".aT_not( "have x" ) { |rcvr| rcvr.include? 'x' } )
-      assert_nothing_raised do 3.aT_not &:even? end
-      assert_raise TypeError do 2.aT_not &:even? end
-      assert_raise TypeError do "".aT_not end
+      assert 3.aT_not &:even?
+      -> { 2.aT_not &:even? }.must_raise TypeError
+      -> { "".aT_not }.must_raise TypeError
     end
     
-    should "have #aT_kind_of, alias #aT_is_a TypeError enforcers" do
-      assert_raise TypeError 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 TypeError 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 ) )
+    it "should have #aT_kind_of, alias #aT_is_a TypeError enforcers" do
+      -> { :o.aT_kind_of Numeric }.must_raise TypeError
+      assert 0.aT_kind_of Numeric
+      assert_equal "hello", "hello".aT_kind_of( String )
+      -> { :o.aT_is_a Numeric }.must_raise TypeError
+      assert 0.aT_is_a Numeric
+      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
+    it "should have #aT_complies" do
+      Koko, Pipi = Class.new, Class.new
+      koko, pipi = Koko.new, Pipi.new
+      assert Koko.compliance.include? Object
+      assert Koko.complies? Object
+      assert koko.class_complies? Object
+      assert koko.aT_class_complies koko.class
+      assert pipi.aT_class_complies pipi.class
+      -> { koko.aT_class_complies pipi.class }.must_raise TypeError
       pipi.declare_class_compliance! koko.class
-      assert_raise TypeError 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 TypeError 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 pipi.aT_class_complies koko.class
+      -> { koko.aT_class_complies Pipi }.must_raise TypeError
+      assert pipi.aT_class_complies Pipi
+      assert pipi.aT_class_complies Koko
       assert_equal koko, koko.aT_class_complies( Koko )
     end
     
-    should "have #aT_respond_to assertion" do
-      assert_raise TypeError do :o.aT_respond_to :each end
-      assert_nothing_raised do {}.aT_respond_to :each end
-      assert_equal( [:hello], [:hello].aT_respond_to( :each ) )
+    it "should have #aT_respond_to assertion" do
+      -> { :o.aT_respond_to :each }.must_raise TypeError
+      assert( {}.aT_respond_to :each )
+      assert_equal [:hello], [:hello].aT_respond_to( :each )
     end
     
-    should "have #aT_equal enforcer" do
-      assert_raise TypeError do 0.aT_equal 1 end
-      assert_nothing_raised do 1.aT_equal 2.0/2.0 end
+    it "should have #aT_equal enforcer" do
+      -> { 0.aT_equal 1 }.must_raise TypeError
+      assert 1.aT_equal 2.0/2.0
       assert_equal( "hello", "hello".aT_equal( " hello ".strip ) )
     end
     
-    should "have #aT_not_equal enforcer" do
-      assert_raise TypeError do 1.aT_not_equal 1.0 end
-      assert_nothing_raised do 7.aT_not_equal 42 end
+    it "should have #aT_not_equal enforcer" do
+      -> { 1.aT_not_equal 1.0 }.must_raise TypeError
+      assert 7.aT_not_equal 42
       assert_equal( "hello", "hello".aT_not_equal( "goodbye" ) )
     end
     
-    should "have #aT_blank enforcer" do
-      assert_raise TypeError do "x".aT_blank end
-      assert_nothing_raised do ["", []].each{|e| e.aT_blank } end
+    it "should have #aT_blank enforcer" do
+      -> { "x".aT_blank }.must_raise TypeError
+      assert ["", []].each{|e| e.aT_blank }
       assert_equal( {}, {}.aT_blank )
     end
     
-    should "have #aT_present enforcer" do
-      assert_raise TypeError do nil.aT_present end
-      assert_nothing_raised do 0.aT_present end
+    it "should have #aT_present enforcer" do
+      -> { nil.aT_present }.must_raise TypeError
+      assert 0.aT_present
       assert_equal( "hello", "hello".aT_present )
     end
   end
-    
-  context "Enumerable" do
-    should "have #aT_all enforcer" do
-      assert_raise TypeError do [1, 2, 7].aT_all { |e| e < 5 } end
-      assert_nothing_raised do [1, 2, 4].aT_all { |e| e < 5 } end
+
+  describe "Enumerable" do
+    it "should have #aT_all enforcer" do
+      -> { [1, 2, 7].aT_all { |e| e < 5 } }.must_raise TypeError
+      assert [1, 2, 4].aT_all { |e| e < 5 }
     end
 
-    should "have #aT_all_kind_of enforcer" do
-      assert_raise TypeError 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
+    it "should have #aT_all_kind_of enforcer" do
+      -> { [1.0, 2.0, :a].aT_all_kind_of Numeric }.must_raise TypeError
+      assert [1.0, 2.0, 3].aT_all_kind_of Numeric
     end
 
-    should "have #aT_all_comply class compliance enforcer" do
-      assert_raise TypeError 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
+    it "should have #aT_all_comply class compliance enforcer" do
+      -> { [1.0, 2.0, :a].aT_all_comply Numeric }.must_raise TypeError
+      assert [1.0, 2.0, 3].aT_all_comply Numeric
     end
 
-    should "have #aT_all_numeric enforcer" do
-      assert_raise TypeError do [:a].aT_all_numeric end
-      assert_nothing_raised do [1, 2.0].aT_all_numeric end
+    it "should have #aT_all_numeric enforcer" do
+      -> { [:a].aT_all_numeric }.must_raise TypeError
+      assert [1, 2.0].aT_all_numeric
     end
     
-    should "have #aT_subset_of enforcer" do
-      assert_raise TypeError do [6].aT_subset_of [*0..5] end
-      assert_nothing_raised do [1,2].aT_subset_of [*0..5] end
+    it "should have #aT_subset_of enforcer" do
+      -> { [6].aT_subset_of [*0..5] }.must_raise TypeError
+      assert [1,2].aT_subset_of [*0..5]
     end
-  end # context Enumerable
+  end # describe "Enumerable"
 
-  context "Array" do
-    should "have #aT_includes (alias #aT_include) enforcer" do
-      assert_raise TypeError 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 )
+  describe "Array" do
+    it "should have #aT_includes (alias #aT_include) enforcer" do
+      -> { [1, 2, 4].aT_include 3 }.must_raise TypeError
+      assert [1, 2, 4].aT_include( 4 )
       assert_equal [6, 7], [6, 7].aT_include( 6 )
     end
-  end # context Array
+  end # describe Array
 
-  context "Hash" do
-    should "have #merge_synonym_keys! method" do
+  describe "Hash" do
+    it "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!
@@ -160,18 +157,18 @@ class TypingTest < Test::Unit::TestCase
       assert_equal true, a.merge_synonym_keys!( :k, :o, :t )
       assert_equal( { a: 'a', b: 'b', k: 'k' }, a )
       old = a.dup
-      assert_raise TypeError do a.merge_synonym_keys!( :a, :b ) end
+      -> { a.merge_synonym_keys!( :a, :b ) }.must_raise TypeError
       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
+    it "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 ! a.may_have( :z )
+      assert ! a.has?( :z )
       assert_raises TypeError do a.may_have( :a, syn!: :b ) end
       assert_raises TypeError do a.has?( :a, syn!: :b ) end
       assert_equal false, a.has?( :z )
@@ -188,26 +185,26 @@ class TypingTest < Test::Unit::TestCase
       assert_equal( { a: 'a', c: 'b', k: 'k' }, a )
     end
     
-    should "have #aT_has synonymizing enforcer" do
+    it "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 TypeError 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
+      assert a.aT_has :infile
+      assert a.aT_has :csv_out_file
       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 TestClass.new a
       assert_raises TypeError 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 TypeError do a.aT_has(:c) {|val| val == 'c'} end
-      assert_nothing_raised do a.aT_has(:c) {|val| val == 'b'} end
+      assert a.aT_has(:c) {|val| val == 'b'}
     end
-  end # context Hash
-end # class ScruplesTest
+  end # describe Hash
+end

data/test/x_test.rb

@@ -1,24 +1,21 @@
 #! /usr/local/bin/ruby
-#encoding: utf-8
+# encoding: utf-8
 
-require 'test/unit'
-require 'shoulda'
-require './../lib/y_support/x'
+require 'minitest/autorun'
 
-class XTest < Test::Unit::TestCase
-  context "X" do
-    setup do
-      YSupport::X.echo_primary_clipboard '"foo"'
-      YSupport::X.echo_secondary_clipboard "bar"
-    end
+describe "y_support/x" do
+  before do
+    require './../lib/y_support/x'
+    YSupport::X.echo_primary_clipboard '"foo & bar"'
+    YSupport::X.echo_secondary_clipboard "baz"
+  end
 
-    should "have clipboard as expected" do
-      assert_equal '"foo" bar', [`xsel -b`, `xsel -s`].join(' ')
-    end
+  it "should have clipboard as expected" do
+    assert_equal '"foo & bar" baz', [`xsel -b`, `xsel -s`].join(' ')
+  end
 
-    should "know #query_box and #message_box methods" do
-      assert_respond_to YSupport::X, :query_box
-      assert_respond_to YSupport::X, :message_box
-    end
-  end # context X
-end # class XTest
+  it "should know #query_box and #message_box methods" do
+    assert_respond_to YSupport::X, :query_box
+    assert_respond_to YSupport::X, :message_box
+  end
+end # describe "y_support/x"

data/y_support.gemspec

@@ -1,22 +1,26 @@
-#encoding: utf-8
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'y_support/version'
 
-require File.expand_path('../lib/y_support/version', __FILE__)
+Gem::Specification.new do |spec|
+  spec.name          = "y_support"
+  spec.version       = YSupport::VERSION
+  spec.authors       = ["boris"]
+  spec.email         = ["\"boris@iis.sinica.edu.tw\""]
+  spec.summary       = %q{Support library used by Y gems.}
+  spec.description   = %q{LocalObject, RespondTo, InertRecorder, NullObject, NameMagic, core extensions, typing etc.}
+  spec.homepage      = ""
+  spec.license       = "GPLv3"
 
-Gem::Specification.new do |gem|
-  gem.authors       = ["boris"]
-  gem.email         = ["\"boris@iis.sinica.edu.tw\""]
-  gem.description   = %q{Support library used by y_... gems.}
-  gem.summary       = %q{LocalObject, RespondTo, InertRecorder, NullObject, NameMagic, core extensions, typing etc.}
-  gem.homepage      = ""
-
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "y_support"
-  gem.require_paths = ["lib"]
-  gem.version       = YSupport::VERSION
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
   
-  gem.add_dependency "activesupport"
+  spec.add_dependency "activesupport"
 
-  gem.add_development_dependency "shoulda"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "shoulda"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: y_support
 version: !ruby/object:Gem::Version
-  version: 2.1.5
+  version: 2.1.12
 platform: ruby
 authors:
 - boris
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-01 00:00:00.000000000 Z
+date: 2014-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: shoulda
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +66,8 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Support library used by y_... gems.
+description: LocalObject, RespondTo, InertRecorder, NullObject, NameMagic, core extensions,
+  typing etc.
 email:
 - '"boris@iis.sinica.edu.tw"'
 executables: []
@@ -47,7 +76,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
-- LICENSE
+- LICENSE.txt
 - README.md
 - Rakefile
 - lib/y_support.rb
@@ -117,7 +146,8 @@ files:
 - test/x_test.rb
 - y_support.gemspec
 homepage: ''
-licenses: []
+licenses:
+- GPLv3
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -135,11 +165,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
-summary: LocalObject, RespondTo, InertRecorder, NullObject, NameMagic, core extensions,
-  typing etc.
+summary: Support library used by Y gems.
 test_files:
 - test/abstract_algebra_test.rb
 - test/inert_recorder_test.rb

data/LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2012 boris
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.