y_support 2.1.18 → 2.4.4

data/lib/y_support/typing/object/typing.rb

@@ -1,6 +1,8 @@
 require 'active_support/core_ext/object/blank'
-require File.dirname( __FILE__ ) + '/../../core_ext/object/inspection'
-require File.dirname( __FILE__ ) + '/../../core_ext/string/misc'
+# require File.dirname( __FILE__ ) + '/../../core_ext/object/inspection'
+# require File.dirname( __FILE__ ) + '/../../core_ext/string/misc'
+require_relative '../../core_ext/object/inspection'
+require_relative '../../core_ext/string/misc'
 
 class Object
   # === Typing by declaration
@@ -46,7 +48,7 @@ class Object
   # the receiver (using +#instance_exec+ method). If no block is given, it is
   # checked, whether the object is truey.
   # 
-  def aT what_is_receiver=insp, how_comply=nil, &b
+  def aT what_is_receiver=y_inspect, how_comply=nil, &b
     return tap { fail TypeError unless self } unless b
     return self if b.( self )
     m = "%s fails " + ( how_comply ? "to #{how_comply}" : "its check" )
@@ -62,7 +64,7 @@ class Object
   # inside the singleton class of the receiver (using #instance_exec method). If
   # no block is given, it is checked, whether the object is falsey.
   # 
-  def aT_not what_is_receiver=insp, how_comply=nil, &b
+  def aT_not what_is_receiver=y_inspect, how_comply=nil, &b
     return tap { fail TypeError if self } unless b
     return self unless b.( self )
     m = how_comply ? "%s must not #{how_comply}" : "%s fails its check"
@@ -72,7 +74,7 @@ class Object
   # Fails with +TypeError+ unless the receiver is of the prescribed class. Second
   # optional argument customizes the error message (receiver description).
   # 
-  def aT_kind_of klass, what_is_receiver=insp
+  def aT_kind_of klass, what_is_receiver=y_inspect
     return self if is_a? klass
     fail TypeError, "%s not a #{klass}".X!( what_is_receiver )
   end
@@ -82,7 +84,7 @@ class Object
   # given class, or is a descendant of that class. Second optional argument
   # customizes the error message (receiver description).
   # 
-  def aT_complies klass, what_is_receiver=insp
+  def aT_complies klass, what_is_receiver=y_inspect
     return self if class_complies? klass
     fail TypeError, "%s does not comply with #{klass}".X!( what_is_receiver )
   end
@@ -91,7 +93,7 @@ class Object
   # Fails with +TypeError+ unless the receiver responds to the given method.
   # Second optional argument customizes the error message (receiver description).
   # 
-  def aT_respond_to method_name, what_is_receiver=insp
+  def aT_respond_to method_name, what_is_receiver=y_inspect
     return self if respond_to? method_name
     fail TypeError,
          "%s does not respond to '#{method_name}'".X!( what_is_receiver )
@@ -102,9 +104,9 @@ class Object
   # equal to the argument. Two more optional arguments customize the error
   # message (receiver description and the description of the other object).
   # 
-  def aT_equal other, what_is_receiver=insp, what_is_other=nil
+  def aT_equal other, what_is_receiver=y_inspect, what_is_other=nil
     return self if self == other
-    wo = what_is_other || "the prescribed value (#{other.insp})"
+    wo = what_is_other || "the prescribed value (#{other.y_inspect})"
     fail TypeError, "%s must be equal to %s".X!( [ what_is_receiver, wo ] )
   end
 
@@ -112,37 +114,37 @@ class Object
   # differs from to the argument. Two more optional arguments customize the error
   # message (receiver description and the description of the other object).
   # 
-  def aT_not_equal other, what_is_receiver=insp, what_is_other=nil
+  def aT_not_equal other, what_is_receiver=y_inspect, what_is_other=nil
     return self unless self == other
-    wo = what_is_other || "the prescribed value (#{other.insp})"
+    wo = what_is_other || "the prescribed value (#{other.y_inspect})"
     fail TypeError, "%s must not == %s".X!( [ what_is_receiver, wo ] )
   end
 
   # Fails with +TypeError+ unless activesupport's +#blank+ returns true for
   # the receiver.
   # 
-  def aT_blank what_is_receiver=insp
+  def aT_blank what_is_receiver=y_inspect
     tap { blank? or fail TypeError, "%s not blank".X!( what_is_receiver ) }
   end
 
   # Fails with +TypeError+ unless activesupport's +#present+ returns true for
   # the receiver.
   # 
-  def aT_present what_is_receiver=insp
+  def aT_present what_is_receiver=y_inspect
     tap { present? or fail TypeError, "%s not present".X!( what_is_receiver ) }
   end
 
   # Fails with +ArgumentError+ unless the +ActiveSupport+ method +#blank+ returns
   # true for the receiver.
   # 
-  def aA_blank what_is_receiver=insp
+  def aA_blank what_is_receiver=y_inspect
     tap { blank? or fail ArgumentError, "%s not blank".X!( what_is_receiver ) }
   end
 
   # Fails with +ArgumentError+ unless the +ActiveSupport+ method #present returns
   # true for the receiver.
   # 
-  def aA_present what_is_receiver=insp
+  def aA_present what_is_receiver=y_inspect
     tap {
       present? or fail ArgumentError, "%s not present".X!( what_is_receiver )
     }

data/lib/y_support/typing/object.rb

@@ -1 +1 @@
-require File.dirname( __FILE__ ) + '/object/typing'
+require_relative 'object/typing'

data/lib/y_support/typing.rb

@@ -1,21 +1,25 @@
 # encoding: utf-8
 
-require 'y_support'
+require_relative '../y_support'
 
 # Typing library.
 #
-# Apart from typing objects <em>by class and ancestry</em> (+#kind_of?+),
-# y_support typing library provides support for typing <em>by declaration</em>,
-# and for runtime assertions.
+# A collection of helper methods mainly for argument validation. We often want
+# to validate that arguments are of certain class, or that they fulfill some
+# other criteria, and raise sufficiently informative error messages when not.
+# I've been also experimenting with what I call "typing by declaration", that
+# is, when a class declares compliance with another class without actually
+# being its descendant, but this idea is still experimental. Basically,
+# 'y_support/typing' remains a library of runtime assertions.
 
 directories_to_look_in = [ :typing ]
 
-# The fololowing code looks into the specified directory(ies) and requires
+# The following code looks into the specified directory(ies) and requires
 # all the files in it (them).
 # 
-directories_to_look_in.each do |part|
-  Dir["#{File.dirname( __FILE__ )}/#{part}/*/typing.rb"].sort.each { |path|
-    dir = File.dirname( path ).match( "y_support/#{part}" ).post_match
-    require "y_support/#{part}#{dir}/typing"
-  }
+directories_to_look_in.each do |name|
+  Dir["#{File.dirname( __FILE__ )}/#{name}/*/typing.rb"].sort.each do |path|
+    dir = File.dirname( path ).match( "y_support/#{name}" ).post_match
+    require_relative "#{name}#{dir}/typing"
+  end
 end

data/lib/y_support/unicode.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require 'y_support'
+require_relative '../y_support'
 
 # +y_support/unicode+ defines a small number of Unicode 1-character aliases to
 # make code more concise.

data/lib/y_support/version.rb

@@ -1,4 +1,4 @@
 module YSupport
-  VERSION = "2.1.18"
+  VERSION = "2.4.4"
   DEBUG = false
 end

data/lib/y_support/x.rb

@@ -1,4 +1,5 @@
-require 'y_support'
+require 'gtk2'
+require_relative '../y_support'
 
 # Assets related to X windows control.
 # 

data/test/flex_coerce_test.rb

@@ -0,0 +1,134 @@
+#! /usr/bin/ruby
+# encoding: utf-8
+
+require 'minitest/autorun'
+require_relative '../lib/y_support/flex_coerce'
+
+describe "user class that defines no coercion whatsoever" do
+  before do
+    @c = Class.new do include FlexCoerce end
+  end
+  
+  it "must be extended by FlexCoerce::ClassMethods" do
+    @c.singleton_class.ancestors.must_include FlexCoerce::ClassMethods
+  end
+
+  it "must have a parametrized subclass of FlexProxy" do
+    assert @c.FlexProxy < FlexCoerce::FlexProxy
+    @c.FlexProxy.host_class.must_equal @c
+  end
+
+  describe "object of that class" do
+    before do
+      @object = @c.new
+    end
+
+    it "should provide to the user class #coerce method returning a proxy" do
+      o1, o2 = @object.coerce 42
+      o1.must_be_kind_of FlexCoerce::FlexProxy
+      o2.must_equal @object
+    end
+
+    it "should raise TypeError for all operators and binary methods" do
+      -> { 42 + @object }.must_raise TypeError
+      -> { 42 - @object }.must_raise TypeError
+      -> { 42 * @object }.must_raise TypeError
+      -> { 42 / @object }.must_raise TypeError
+      -> { 42 % @object }.must_raise TypeError
+      -> { 42.div @object }.must_raise TypeError
+      -> { 42.divmod @object }.must_raise TypeError
+      -> { 42.fdiv @object }.must_raise TypeError
+      -> { 42 ** @object }.must_raise TypeError
+      -> { 42 & @object }.must_raise TypeError
+      -> { 42 | @object }.must_raise TypeError
+      -> { 42 ^ @object }.must_raise TypeError
+      -> { 42 > @object }.must_raise TypeError
+      -> { 42 >= @object }.must_raise TypeError
+      -> { 42 < @object }.must_raise TypeError
+      -> { 42 <= @object }.must_raise TypeError
+      -> { 42 <=> @object }.must_raise TypeError
+      # Operator #=== is too liberal to call #coerce.
+      -> { @object.coerce( 42 ).first === @object }.must_raise TypeError
+    end
+  end
+end
+
+describe "user class that allows Numeric#* and nothing else" do
+  before do
+    @c = Class.new do
+      include FlexCoerce
+      def + number; 10 + number end
+      def - number; 10 - number end
+      def * number; 10 * number end
+      def / number; 10 / number end
+    end
+
+    @c.define_coercion Fixnum, method: :* do |left_operand, right_operand|
+      right_operand * left_operand
+    end
+  end
+
+  it "must have coercion table with :* entry" do
+    @c.coercion_table.keys.must_equal [ :* ]
+    table_entry = @c.FlexProxy.new( 42 ).host_class.coercion_table[ :* ]
+    table_entry.size.must_equal 1
+    table_entry.find { |type, closure| type === 42 }.must_be_kind_of Array
+    assert table_entry.find { |type, _| type == :foobar }.nil?
+  end
+
+  describe "object of that class" do
+    before do
+      @object = @c.new
+    end
+
+    it "is defined to behave as number 10 with 4 basic operators" do
+      ( @object + 2 ).must_equal 12
+      ( @object - 2 ).must_equal 8
+      ( @object * 2 ).must_equal 20
+      ( @object / 2 ).must_equal 5
+    end
+
+    it "must have working coercion with  Fixnum#*, but not other classes" do
+      ( 2 * @object ).must_equal 20
+      ( 3 * @object ).must_equal 30
+      -> { 3.0 * @object }.must_raise TypeError
+    end
+
+    it "should not define coercion for other operators" do
+      -> { 42 + @object }.must_raise TypeError
+      -> { 42 - @object }.must_raise TypeError
+      -> { 42 / @object }.must_raise TypeError
+      -> { 42 % @object }.must_raise TypeError
+    end
+  end
+end
+
+describe "class that includes FlexCoerce via another module" do
+  before do
+    m = Module.new do include FlexCoerce end
+    @c = Class.new do
+      include m
+      def + arg; 10 + arg end
+    end
+  end
+
+  it "should still allow defining coercion" do
+    @c.methods.must_include :define_coercion
+  end
+
+  describe "object of such class" do
+    before do
+      @c.define_coercion Integer, method: :+ do |operand_1, operand_2|
+        operand_2 + operand_1
+      end
+      @object = @c.new
+    end
+
+    it "should function as expected" do
+      ( 1 + @c.new ).must_equal 11
+    end
+  end
+end
+   
+
+

data/test/literate_test.rb

@@ -0,0 +1,231 @@
+#! /usr/bin/ruby
+# coding: utf-8
+
+require 'minitest/autorun'
+# require 'y_support/literate'     # tested component itself
+require './../lib/y_support/literate'
+
+describe Literate::Attempt do
+  before do
+    @str = "lorem ipsum dolor sit amet"
+    @txt = "split the sentence into words"
+    # A simple attempt block.
+    @a = Literate::Attempt.new subject: @str, text: @txt do
+      note is: "natural language sentence"
+      split ' '
+    end
+    # More verbose attempt block.
+    chosen_word = 3
+    @b = Literate::Attempt.new subject: @str, text: @txt do
+      » is: "natural language sentence"
+      » has: "#{size} characters"
+      words = split ' '
+      » "number of words", is: words.size
+      » "chosen word", is: words[ chosen_word ]
+      words
+    end
+  end
+
+  it "should have 4 basic properties" do
+    @a.__text__.must_equal @txt
+    @a.__subject__.must_equal @str
+    @a.__block__.must_be_kind_of Proc
+    @a.__knowledge_base__.must_be_empty
+    # Fact list is empty because the block hasn't been run yet.
+    # Let's run the block:
+    @a.__run__
+    # Now the fact list includes the comment made in the block.
+    @a.__knowledge_base__.size.must_equal 1
+  end
+
+  describe "#__run__" do
+    it "must run the attempt's block" do
+      expected_result = "lorem", "ipsum", "dolor", "sit", "amet"
+      @a.__run__.must_equal expected_result
+    end
+  end
+
+  describe "Object#try method" do
+    before do
+      error = false
+      @error_switch = -> arg { error = arg }
+      @text = "to split into words"
+      @block = proc do
+        note is: "a string with several words"
+        fail error if error
+        split ' '
+      end
+    end
+
+    it "must execute the block allowing subject's methods" do
+      "hello world".try( @text, &@block )
+        .must_equal [ "hello", "world" ]
+      @error_switch.( TypeError )
+      -> { "hello world".try @text, &@block }.must_raise TypeError
+      @error_switch.( NameError )
+      -> { "hello world".try @text, &@block }.must_raise NameError
+    end
+
+    it "must allow Literate::Attempt#comment inside the block" do
+      begin
+        @error_switch.( TypeError )
+        "hello world".try @text, &@block
+      rescue => error
+        # Proof that Literate::Attemp#comment activated.
+        m = error.message
+        m.must_include "When trying to split into words"
+        m.must_include "a string with several words"
+      else
+        flunk "Error expected but nothing raised!"
+      end
+    end
+  end
+
+  describe "#note" do
+    it "must write entries into @__knowledge_base__" do
+      @a.__run__
+      x = { @str => [ is: "natural language sentence" ] }
+      @a.__knowledge_base__.must_equal x
+    end
+
+    it "must write entries into @__knowledge_base__" do
+      @b.__run__
+      x = { @str => [ is: "natural language sentence",
+                      has: "26 characters" ],
+            "number of words" => [ is: 5 ],
+            "chosen word" => [ is: "sit" ] }
+      @b.__knowledge_base__ .must_equal x
+    end
+  end
+
+  describe "#__describe__" do
+    it "must produce description of the main subject" do
+      @a.__run__
+      @a.__describe__( @a.__subject__ )
+        .must_equal [ "lorem ipsum dolor sit amet",
+                      { is: "natural language sentence" } ]
+      @b.__run__
+      @b.__describe__( @a.__subject__ )
+        .must_equal [ "lorem ipsum dolor sit amet",
+                      { is: "natural language sentence",
+                        has: "26 characters" } ]
+    end
+  end
+
+  describe "#__circumstances__" do
+    it "..." do
+      @a.__run__
+      @a.__circumstances__.must_equal ""
+      @b.__run__
+      @b.__circumstances__
+        .must_equal "number of words being 5, " +
+                    "chosen word being sit"
+    end
+  end
+end
+
+describe "usecase 1: name validator" do
+  before do
+    @name_validator = Object.new
+    @name_validator.define_singleton_method :validate do |name|
+      name.to_s.try "to validate the requested name" do
+        note "rejecting non-capitalized names"
+        fail NameError unless ( ?A..?Z ) === self[0]
+        note "rejecting names with spaces"
+        fail NameError unless split( ' ' ).size == 1
+      end
+      return name
+    end
+  end
+
+  it "should validate good names" do
+    @name_validator.validate( :Fred ).must_equal :Fred
+    @name_validator.validate( "Su_san" ).must_equal "Su_san"
+  end
+
+  it "should reject bad names with a good error message" do
+    expected_message =
+      "When trying to validate the requested name, rejecting " +
+      "non-capitalized names: NameError!"
+    begin
+      @name_validator.validate( :fred )
+    rescue => error
+      error.message.must_equal expected_message
+    end
+  end
+end
+
+# describe 'case 1' do
+#   it "should work" do
+#     # begin
+#     #   @a.__run__
+#     # rescue TypeError => err
+#     #   expected_msg = "When trying concatenation of an array " +
+#     #                  "with 2 elements, TypeError occurred: " +
+#     #                  "Lorem ipsum dolor sit amet!"
+#     #   # Make sure the last 45 characters is OK.
+#     #   assert_equal expected_msg[-45..-1], err.message[-45..-1]
+#     #   # # Make sure that whole message is as expected.
+#     #   # assert_equal expected_msg, err.message
+#     # else
+#     #   flunk "Expected TypeError error not raised!"
+#     # end
+#   end
+# end
+
+# describe 'case 2' do
+#   it "should work" do
+#     begin
+#       try "to call constant Nothing" do Nothing end
+#     rescue NameError => err
+#       expected_msg = 'When trying to call constant Nothing, ' +
+#         'NameError occurred: uninitialized constant Nothing'
+#       assert_equal( expected_msg, err.message )
+#     else
+#       flunk "Expected NameError error not raised!"
+#     end
+#   end
+# end
+
+# describe 'case 3' do
+#   it "should work" do
+#     o = Object.new
+#     class << o
+#       def to_s; "THIS OBJECT" end
+#       def hello!; "hello hello" end
+#     end
+#     # Object's methods must be callable
+#     o.try "to say hello" do hello! end.must_equal "hello hello"
+#     begin
+#       o.try "to call a weird method" do goodbye! end
+#     rescue NoMethodError => err
+#       err.message.must_include "When trying to call a weird " +
+#         "method, NoMethodError occurred: undefined method"
+#       err.message.must_include "goodbye!"
+#     end
+#   end
+# end
+
+# describe 'case 4' do
+#   it "should work" do
+#     begin
+#       "FooBar".try "to do something" do
+#         comment has: "#{size} letters",
+#                 is: "a #{self.class} instance"
+#         unless include? "Quux"
+#           comment "Quux", is: "not a part of it"
+#           try "to append Quux to it" do
+#             self << "Quux"
+#             fail "EPIC FAIL"
+#           end
+#         end
+#       end
+#     rescue => err
+#       err.message.must_equal "When trying to do something, " +
+#         "FooBar having 6 letters, being a String instance, " +
+#         "Quux being not a part of it, RuntimeError occurred: " +
+#         "When trying to append Quux to it, RuntimeError " +
+#         "occurred: EPIC FAIL"
+#     end
+#   end
+# end

data/test/misc_test.rb

@@ -29,6 +29,13 @@ describe Object do
     o.bar.ancestors[1].must_equal( m )
     o.bar.mother.must_equal( o )
   end
+
+  it "should have #insp method to facilitate inspection" do
+    module Quux; class Foo; def to_s; "bar" end end end
+    Quux::Foo.new.y_inspect.must_equal "Quux::Foo:bar"
+    Quux::Foo.new.y_inspect( :full ).must_equal "#<Quux::Foo:bar>"
+    Quux::Foo.new.y_inspect( :short ).must_equal "Foo:bar"
+  end
 end
 
 
@@ -52,7 +59,8 @@ describe Module do
     m.const_reset! :Foo, 43
     m::Foo.must_equal 43
     m.module_exec do
-      def a; 42 end
+      selector :a
+      def initialize; @a = 42 end
       chain b: :a, &:to_s
     end
     Class.new do include m end.new.b.must_equal "42"
@@ -65,6 +73,14 @@ describe Class do
     require './../lib/y_support/core_ext/class'
   end
 
+  it "has #selector alias for #attr_reader method" do
+    o = Class.new do
+      selector :a
+      def initialize a; @a = a end
+    end.new( 42 )
+    o.a.must_equal( 42 )
+  end
+
   it "has #parametrize method" do
     a = Class.new
     -> { a.foo }.must_raise NoMethodError
@@ -174,32 +190,38 @@ describe Hash do
     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
-
-  it "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
-
-  it "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
+    { a: 11, b: nil, c: 22 }.must_equal test.default! defaults
+  end
+
+  it "should have #with_keys and #with_keys!" do
+    test = { "a" => :b, "c" => :d }
+    test.with_keys( &:to_sym ).must_equal( { a: :b, c: :d } )
+    test.must_equal( { "a" => :b, "c" => :d } )
+    test.with_keys! &:to_sym
+    test.must_equal( { a: :b, c: :d } )
+  end
+
+  it "should have #change_keys" do
+    test = { a: 1, c: 2 }
+    test.change_keys { |k, v| k.to_s + v.to_s }
+      .must_equal( { "a1" => 1, "c2" => 2 } )
+  end
+
+  it "should have #with_values and #with_values!" do
+    test = { a: :b, c: :d }
+    test.with_values( &:to_s ).must_equal( { a: "b", c: "d" } )
+    test.must_equal( { a: :b, c: :d } )
+    test.with_values!( &:to_s )
+    test.must_equal( { a: "b", c: "d" } )
+  end
+
+  it "should have #change_values and #change_values!" do
+    test = { a: :b, c: :d }
+    test.modify_values do |k, v| k.to_s + v.to_s end
+      .must_equal( {a: "ab", c: "cd"} )
+    test.must_equal( { a: :b, c: :d } )
+    test.modify_values! { |k, v| k.to_s + v.to_s }
+    test.must_equal( {a: "ab", c: "cd"} )
   end
 
   it "should have #modify" do