golly-utils 0.0.1 → 0.6.0

data/test/unit/attr_declarative_test.rb

@@ -5,32 +5,63 @@ require 'golly-utils/attr_declarative'
 class AttrDeclarativeTest < MiniTest::Unit::TestCase
 
   class Abc
-    include GollyUtils::AttrDeclarative
     attr_declarative :cow
-    attr_declarative :horse, default: 246
+    attr_declarative :horse, :horse2, default: 246
+    attr_declarative :important, required: true
+    attr_declarative :boolean_style?
+    attr_declarative :bang_style!
   end
 
   def test_acts_like_attribute
     a= Abc.new
     assert_nil a.cow
-    a.cow{ 12 }
+    a.cow= 12
     assert_equal 12, a.cow
   end
 
   def test_default
     a= Abc.new
     assert_equal 246, a.horse
-    a.horse{ 'hehe' }
+    assert_equal 246, a.horse2
+    a.horse= 'hehe'
     assert_equal 'hehe', a.horse
+    assert_equal 246, a.horse2
+  end
+
+  def test_boolean_style_attribute
+    a= Abc.new
+    a.boolean_style= true
+    assert_equal true, a.boolean_style?
+    a.boolean_style= false
+    assert_equal false, a.boolean_style?
+    refute a.respond_to? :boolean_style # reader has ?, writer has =
+  end
+
+  def test_bang_style_attribute
+    a= Abc.new
+    a.bang_style= 123
+    assert_equal 123, a.bang_style!
+    refute a.respond_to? :bang_style # reader has !, writer has =
+  end
+
+  class SpecialNames < Abc
+    boolean_style? true
+    bang_style! 987
+  end
+  def test_boolean_style_declared_at_class_level
+    assert_equal true, SpecialNames.new.boolean_style?
+  end
+  def test_bang_style_declared_at_class_level
+    assert_equal 987, SpecialNames.new.bang_style!
   end
 
   class Abc2 < Abc
-    cow{ 777 }
+    cow 777
   end
   def test_subclasses_can_change_defaults
     a= Abc2.new
     assert_equal 777, a.cow
-    a.cow{ 12 }
+    a.cow= 12
     assert_equal 12, a.cow
     assert_equal 777, Abc2.new.cow
     assert_nil Abc.new.cow
@@ -39,16 +70,51 @@ class AttrDeclarativeTest < MiniTest::Unit::TestCase
   class Abc3 < Abc2; end
   def test_subclasses_inherit_parents_declarations
     assert_equal 777, Abc3.new.cow
+    assert_nil Abc.new.cow
   end
 
-  class Dynamic < Abc
-    $cow= 123
-    cow{ $cow }
+  def test_instances_setting_to_nil
+    assert_nil Abc.new.tap{|x| x.cow= nil}.cow
+    assert_nil Abc2.new.tap{|x| x.cow= nil}.cow
+    assert_nil Abc3.new.tap{|x| x.cow= nil}.cow
   end
-  def test_class_declarations_arent_evaluated_until_needed
-    a= Dynamic.new
-    $cow= 456
-    assert_equal 456, a.cow
+
+  class Abc4 < Abc
+    cow nil
+    important 666
+  end
+  def test_subclass_with_nil_default
+    assert_nil Abc.new.cow
+    assert_equal 777, Abc3.new.cow
+    assert_nil Abc4.new.cow
+  end
+
+  class Seikima
+    attr_declarative ok: 'sweet'
+  end
+  def test_quik_syntax
+    assert_equal 'sweet', Seikima.new.ok
+  end
+
+  def test_required_fields_fail_when_undefined
+    e= assert_raises(RuntimeError){ Abc.new.important }
+  end
+
+  def test_error_msg_when_required_field_missing_mentions_subclass_name
+    e= assert_raises(RuntimeError){ Abc2.new.important }
+    assert_match /Abc2/, e.message
   end
 
+  def test_required_fields_works_as_normal_once_defined
+    assert_equal 666, Abc4.new.important
+    x= Abc.new
+    x.important= 135
+    assert_equal 135, x.important
+  end
+
+  def test_required_fields_can_be_set_to_nil
+    x= Abc.new
+    x.important= nil
+    assert_nil x.important
+  end
 end

data/test/unit/callbacks_test.rb

@@ -14,18 +14,16 @@ class CallbacksTest < MiniTest::Unit::TestCase
     include GollyUtils::Callbacks
     define_callback :base
     def self.record(v); CallbacksTest::VALUES << v end
-    def self.run
+    def self.run(*args)
       o= self.new
-      o.run
+      o.run(*args)
       CallbacksTest::VALUES
     end
   end
 
   class Omg < Base
     define_callback :wow
-    def run
-      run_callback :wow
-    end
+    def run; run_callback :wow end
   end
   def test_none; assert_equal [], Omg.run; end
 
@@ -73,4 +71,104 @@ class CallbacksTest < MiniTest::Unit::TestCase
     assert_equal 135, Fail.what
   end
 
+  class Args < Base
+    base{ |i| record (i || 0)+5 }
+  end
+
+  def test_run_callback_with_args
+    Args.new.run_callback :base, args: [4]
+    assert_equal [9], VALUES
+  end
+
+  def test_run_callbacks_with_args_array
+    Args.new.run_callbacks :base, args: [3]
+    assert_equal [8], VALUES
+  end
+
+  def test_run_callbacks_with_args_nonarray
+    Args.new.run_callbacks :base, args: 13
+    flunk "Failure expected."
+  rescue => e
+    assert_match /array/i, e.to_s
+  end
+
+  def test_run_callback_fails_with_unrecognisable_options
+    Args.new.run_callback :base, stuff: [3]
+    flunk "Failure expected."
+  rescue => e
+    assert_match /stuff/, e.to_s
+  end
+
+  def test_run_callbacks_fails_with_unrecognisable_options
+    Args.new.run_callbacks :base, stuff: [3]
+    flunk "Failure expected."
+  rescue => e
+    assert_match /stuff/, e.to_s
+  end
+
+  module TestModule
+    include GollyUtils::Callbacks
+    define_callback :from_mod
+  end
+
+  module TestModule2
+    include TestModule
+    define_callback :from_mod2
+  end
+
+  class WithMod
+    include TestModule
+    define_callback :bru
+    def self.record(v); CallbacksTest::VALUES << v end
+    def self.run(*args)
+      o= self.new
+      o.run_callback :from_mod
+      CallbacksTest::VALUES
+    end
+    from_mod{ record 357 }
+  end
+  def test_with_module; assert_equal [357], WithMod.run; end
+
+  def test_callbacks_class_method
+    assert_equal [:base], Base.callbacks
+    assert_equal [:base, :wow], Omg.callbacks
+    assert_equal [:base, :wow], Omg2.callbacks
+    assert_equal [:base, :dude, :sweet, :wow], Sweet.callbacks
+  end
+  def test_callbacks_module_method
+    assert_equal [:from_mod], TestModule.callbacks
+    assert_equal [:from_mod, :from_mod2], TestModule2.callbacks
+  end
+  def test_callbacks_class_with_module
+    assert_equal [:bru, :from_mod], WithMod.callbacks
+  end
+
+  class Context
+    attr_reader :good
+    def make_good; @good= 'good' end
+  end
+  class ContextCallback
+    include GollyUtils::Callbacks
+    define_callback :go
+    go { make_good }
+  end
+  def test_callback_with_context
+    ctx= Context.new
+    cc= ContextCallback.new
+    cc.run_callback :go, context: ctx
+    assert_equal 'good', ctx.good
+  end
+
+  class ContextCallback2 < ContextCallback
+    attr_reader :local_too
+    def hit_local_too; @local_too= 'yes' end
+    go { hit_local_too }
+  end
+  def test_callback_with_context_can_access_local_too
+    ctx= Context.new
+    cc= ContextCallback2.new
+    cc.run_callback :go, context: ctx
+    assert_equal 'good', ctx.good
+    assert_equal 'yes', cc.local_too
+  end
 end

data/test/unit/delegator_test.rb

@@ -8,6 +8,10 @@ class DelegatorTest < MiniTest::Unit::TestCase
     def a; 1; end
     def c; 10; end
     def add(a,b,c) a+b+c end
+    protected
+    def prot; 666; end
+    private
+    def pri; -1; end
   end
 
   class B
@@ -37,7 +41,7 @@ class DelegatorTest < MiniTest::Unit::TestCase
     assert_equal [10,20], nd(na,nb,delegate_to: :all).c
   end
 
-  def test_respond_to
+  def test_respond_to_checks_delegatable
     d= nd(na,nb)
     assert d.respond_to?(:a)
     assert d.respond_to?(:b)
@@ -45,6 +49,13 @@ class DelegatorTest < MiniTest::Unit::TestCase
     assert !d.respond_to?(:x)
   end
 
+  def test_respond_to_checks_internal
+    d= nd(na,nb)
+    refute d.respond_to?(:xxx)
+    d.instance_eval 'def xxx; end'
+    assert d.respond_to?(:xxx)
+  end
+
   def test_caching
     [true,false].each do |cache|
       a= na
@@ -96,4 +107,17 @@ class DelegatorTest < MiniTest::Unit::TestCase
     assert_raises(NoMethodError){ d.b }
     assert_raises(NoMethodError){ d.add }
   end
+
+  def test_protected_methods_not_allowed_by_default
+    assert_raises(NoMethodError){ nd(na).prot }
+  end
+
+  def test_protected_methods_allowed_when_enabled
+    assert_equal 666, nd(na, allow_protected: true).prot
+  end
+
+  def test_private_methods_not_allowed
+    assert_raises(NoMethodError){ nd(na).pri }
+    assert_raises(NoMethodError){ nd(na, allow_protected: true).pri }
+  end
 end

data/test/unit/ruby_ext/classes_and_types_test.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+require_relative '../../bootstrap/unit'
+require 'golly-utils/ruby_ext/classes_and_types'
+
+class ClassesAndTypesTest < MiniTest::Unit::TestCase
+  class A; end
+  class B < A; end
+  class C < A; end
+  class B1 < B; end
+  class B2 < B; end
+
+  def assert_arrays(exp,act)
+    v= [exp,act].map{|a| a.sort_by(&:to_s) }
+    assert_equal *v
+  end
+
+  def test_subclasses_all
+    assert_arrays [B,C,B1,B2], A.subclasses(true)
+  end
+
+  def test_subclasses_leaf_nodes_only
+    assert_arrays [C,B1,B2], A.subclasses
+  end
+
+  #---------------------------------------------------------------------------------------------------------------------
+
+  def test_superclasses_on_instance
+    assert_equal [B1,B,A,Object,BasicObject], B1.new.superclasses
+  end
+
+  def test_superclasses_on_class
+    assert_equal [B1,B,A,Object,BasicObject], B1.superclasses
+  end
+
+  def test_superclasses_on_ruby_internals
+    assert_equal [NilClass,Object,BasicObject], nil.superclasses
+    assert_equal [TrueClass,Object,BasicObject], true.superclasses
+  end
+
+  class BO < BasicObject; end
+  def test_superclasses_on_basic_object_subclass
+    assert_equal [BO,BasicObject], BO.superclasses
+    #assert_equal [BO,BasicObject], BO.new.superclasses
+  end
+
+  #---------------------------------------------------------------------------------------------------------------------
+
+  def test_validate_type_passes_when_exact_match
+    B.new.validate_type! B
+    B.new.validate_type! A
+  end
+
+  def test_validate_type_passes_with_name
+    B.new.validate_type! 'hehe', B
+    B.new.validate_type! :hehe, A
+  end
+
+  def test_validate_type_passes_when_any_match
+    B.new.validate_type! B, String
+    B.new.validate_type! String, A
+  end
+
+  def test_validate_type_allows_primatives
+    true.validate_type! true
+    false.validate_type! false
+    nil.validate_type! nil
+    nil.validate_type! NilClass
+    nil.validate_type! nil, B
+  end
+
+  def test_validate_type_fail
+    assert_raises(TypeValidationError){ B.new.validate_type! String }
+  end
+
+  def test_validate_type_fail_with_name
+    assert_raises(TypeValidationError){ B.new.validate_type! 'hehe', String }
+    assert_raises(TypeValidationError){ B.new.validate_type! :hehe, String }
+  end
+
+  def test_validate_type_fail_uses_name_in_errmsg
+    3.validate_type! 'hehe', String
+    raise "Error expected."
+  rescue => e
+    assert_match /for hehe/, e.to_s
+  end
+
+  #---------------------------------------------------------------------------------------------------------------------
+
+  def test_validate_lvar_type!
+    hehe= 123
+    :hehe.validate_lvar_type!{ Fixnum }
+    :hehe.validate_lvar_type!{ [nil,Fixnum] }
+    assert_raises(TypeValidationError){ :hehe.validate_lvar_type!{ String }}
+  end
+
+  def test_validate_lvar_type_uses_name_in_errmsg
+    hehe= 'no'
+    :hehe.validate_lvar_type!{ Fixnum }
+    raise "Error expected."
+  rescue => e
+    assert_match /for hehe/, e.to_s
+  end
+end

data/test/unit/ruby_ext/enumerable_test.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+require_relative '../../bootstrap/unit'
+require 'golly-utils/ruby_ext/enumerable'
+
+class EnumerableTest < MiniTest::Unit::TestCase
+
+  def test_frequency_map
+    x= [1, 4, 'a', 4, :b, :b, :b].frequency_map
+    assert_equal({1=>1, 4=>2, 'a'=>1, b:3}, x)
+  end
+
+end

data/test/unit/ruby_ext/options_test.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require_relative '../../bootstrap/unit'
+require 'golly-utils/ruby_ext/options'
+
+class OptionsTest < MiniTest::Unit::TestCase
+
+  def test_nop_when_all_keys_valid
+    {a:1,b:2}.validate_option_keys :a, :b
+    {a:1,b:2}.validate_option_keys :a, :b, :c
+  end
+
+  def test_nop_when_hash_empty
+    {}.validate_option_keys :a, :b
+  end
+
+  def test_error_when_extra_keys
+    assert_raises(RuntimeError){ {a:1,b:2}.validate_option_keys :a }
+  end
+
+  def test_error_msg_contains_all_invalid_key_names
+    {aaa:1,'bbb' => 2, x:5}.validate_option_keys :x
+    flunk 'Error expected.'
+  rescue => e
+    assert_match /:aaa/, e.to_s
+    assert_match /"bbb"/, e.to_s
+    refute_match /x/, e.to_s
+  end
+
+end