tdiary 5.2.3 → 5.3.0

data/vendor/bundle/ruby/3.1.0/gems/tins-1.31.1/tests/concern_test.rb

@@ -1,35 +0,0 @@
-require 'test_helper'
-require 'tins'
-
-class ConcernTest < Test::Unit::TestCase
-  module AC
-    extend Tins::Concern
-
-    included do
-      $included = self
-    end
-
-    def foo
-      :foo
-    end
-
-    module ClassMethods
-      def bar
-        :bar
-      end
-    end
-  end
-
-  $included = nil
-
-  class A
-    include AC
-  end
-
-  def test_concern
-    a = A.new
-    assert_equal A, $included
-    assert_equal :foo, a.foo
-    assert_equal :bar, A.bar
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/tins-1.31.1/tests/count_by_test.rb

@@ -1,17 +0,0 @@
-require 'test_helper'
-require 'tins/xt'
-
-module Tins
-  class CountByTest < Test::Unit::TestCase
-
-    def test_count_by
-      assert_equal 0, [].count_by { |x| x % 2 == 0 }
-      assert_equal 0, [ 1 ].count_by { |x| x % 2 == 0 }
-      assert_equal 1, [ 1 ].count_by { |x| x % 2 == 1 }
-      assert_equal 1, [ 1, 2 ].count_by { |x| x % 2 == 0 }
-      assert_equal 1, [ 1, 2 ].count_by { |x| x % 2 == 1 }
-      assert_equal 2, [ 1, 2, 3, 4, 5 ].count_by { |x| x % 2 == 0 }
-      assert_equal 3, [ 1, 2, 3, 4, 5 ].count_by { |x| x % 2 == 1 }
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/tins-1.31.1/tests/date_dummy_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-require 'tins'
-
-module Tins
-  class DateDummyTest < Test::Unit::TestCase
-    require 'tins/xt/date_dummy'
-    require 'date'
-
-    def test_date_dummy
-      date = Date.parse('2009-09-09')
-      assert_not_equal date, Date.today
-      Date.dummy = date
-      assert_equal date, Date.today
-      Date.dummy = nil
-      assert_not_equal date, Date.today
-    end
-
-    def test_date_dummy_block
-      date = Date.parse('2009-09-09')
-      assert_not_equal date, Date.today
-      Date.dummy date do
-        assert_equal date, Date.today
-        Date.dummy date + 1 do
-          assert_equal date + 1, Date.today
-        end
-        assert_equal date, Date.today
-      end
-      assert_not_equal date, Date.today
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/tins-1.31.1/tests/date_time_dummy_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-require 'tins'
-
-module Tins
-  class DateTimeDummyTest < Test::Unit::TestCase
-    require 'tins/xt/date_time_dummy'
-    require 'date'
-
-    def test_time_dummy
-      date_time = DateTime.parse('2009-09-09 21:09:09')
-      assert_not_equal date_time, DateTime.now
-      DateTime.dummy = date_time
-      assert_equal date_time, DateTime.now
-      DateTime.dummy = nil
-      assert_not_equal date_time, DateTime.now
-    end
-
-    def test_time_dummy_block
-      date_time = DateTime.parse('2009-09-09 21:09:09')
-      assert_not_equal date_time, DateTime.now
-      DateTime.dummy date_time do
-        assert_equal date_time, DateTime.now
-        DateTime.dummy date_time + 1 do
-          assert_equal date_time + 1, DateTime.now
-        end
-        assert_equal date_time, DateTime.now
-      end
-      assert_not_equal date_time, DateTime.now
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/tins-1.31.1/tests/deep_const_get_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-require 'tins/xt/deep_const_get'
-
-module Tins
-  class DeepConstGetTest < Test::Unit::TestCase
-    module A
-      module B
-      end
-    end
-
-    module C
-      module NotB
-      end
-
-      def self.const_missing(c)
-        NotB
-      end
-    end
-
-    def test_deep_const_get_with_start_module
-      assert_raise(ArgumentError) { deep_const_get '::B', A }
-      assert_equal A::B, deep_const_get('B', A)
-    end
-
-    def test_deep_const_get_without_start_module
-      assert_equal Tins::DeepConstGetTest::A::B, deep_const_get('::Tins::DeepConstGetTest::A::B')
-      assert_equal Tins::DeepConstGetTest::A::B, deep_const_get('Tins::DeepConstGetTest::A::B')
-      assert_equal Array, deep_const_get('::Array')
-      assert_equal Array, deep_const_get('Array')
-    end
-
-    def test_deep_const_get_with_const_missing
-      assert_raise(ArgumentError) { deep_const_get '::Tins::DeepConstGetTest::A::D' }
-      assert_equal Tins::DeepConstGetTest::C::NotB, deep_const_get('::Tins::DeepConstGetTest::C::B')
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/tins-1.31.1/tests/deep_dup_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-require 'tins/xt'
-
-module Tins
-  class DeepDupTest < Test::Unit::TestCase
-    def test_deep_dup
-      a = [1,2,3]
-      assert_equal    a, a.deep_dup
-      assert_not_same a, a.deep_dup
-    end
-
-    def test_deep_dup_proc
-      f = lambda { |x| 2 * x }
-      g = f.deep_dup
-      assert_equal f[3], g[3]
-      assert_equal f, g
-      assert_same  f, g
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/tins-1.31.1/tests/delegate_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-require 'tins'
-
-
-class DelegationTestClass
-  class DelegationTestClass2
-    def self.size
-      5
-    end
-  end
-
-  extend Tins::Delegate
-
-  def self.size
-    1
-  end
-
-  @@ary = [ 1, 2 ]
-
-  def initialize
-    @ary = [ 1, 2, 3 ]
-  end
-
-  def ary
-    [ 1, 2, 3, 4 ]
-  end
-
-  delegate :size, to: :class
-
-  delegate :size, to: :@@ary, as: 'cvar_size'
-
-  delegate :size, to: :@ary, as: 'ivar_size'
-
-  delegate :size, to: :ary, as: 'method_size'
-
-  delegate :size, to: 'DelegationTestClass::DelegationTestClass2',
-    as: 'class_size'
-end
-
-class DelegateTest < Test::Unit::TestCase
-  def test_delegate
-    d = DelegationTestClass.new
-    assert_equal 1, d.size
-    assert_equal 2, d.cvar_size
-    assert_equal 3, d.ivar_size
-    assert_equal 4, d.method_size
-    assert_equal 5, d.class_size
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/tins-1.31.1/tests/dslkit_test.rb

@@ -1,314 +0,0 @@
-require 'test_helper'
-require 'tins'
-
-class TL
-  def initialize
-    make_baz
-  end
-
-  extend Tins::ThreadLocal
-  thread_local :foo
-
-  extend Tins::ThreadLocal
-  thread_local :foo2 do {} end
-
-  include Tins::ThreadLocal
-  def make_baz
-    instance_thread_local :baz
-  end
-
-  extend Tins::ThreadGlobal
-  thread_global :bar
-
-  thread_global :bar2 do {} end
-end
-
-class IE
-
-  def initialize(&block)
-    @block = block
-  end
-
-  def exec
-    instance_exec(&@block)
-  end
-
-  def foo
-    :foo
-  end
-end
-
-class C
-  extend Tins::Constant
-
-  constant :foo
-
-  constant :bar, :baz
-end
-
-class DA
-  extend Tins::DSLAccessor
-
-  dsl_accessor :foo
-
-  dsl_accessor :bar, :bar
-
-  dsl_accessor :baz do :baz end
-
-  dsl_accessor :quux, :qu, :ux
-
-  dsl_reader :on, true
-
-  dsl_reader :off, false
-
-  dsl_reader :states do
-    [ on, off ]
-  end
-
-  dsl_reader :abc, *%w[a b c]
-end
-
-class I
-  include Tins::Interpreter
-
-  def foo
-    :foo
-  end
-
-  def y
-    2
-  end
-end
-
-class S
-  include Tins::SymbolMaker
-end
-
-module K
-  extend Tins::ConstantMaker
-end
-
-module D
-  extend Tins::Deflect
-end
-
-class D3 < Tins::MethodMissingDelegator::DelegatorClass
-end
-
-require 'test/unit'
-require 'tempfile'
-
-class PoliteTest < Test::Unit::TestCase
-  def setup
-    @tl = TL.new
-    @tl2 = TL.new
-    @ie = IE.new { foo }
-    @c  = C.new
-    @da = DA.new
-    @i  = I.new
-  end
-
-  def test_version
-    assert_equal Tins::VERSION_ARRAY * '.', Tins::VERSION
-  end
-
-  def test_thread_local
-    assert_nil @tl.foo
-    @tl.foo = 1
-    assert_equal 1, @tl.foo
-    new_foo = nil
-    thread = Thread.new do
-      @tl.foo = 2
-      new_foo = @tl.foo
-    end
-    thread.join
-    assert_equal 2, new_foo
-    assert_equal 1, @tl.foo
-    assert_equal @tl.baz, @tl2.baz
-  end
-
-  def test_thread_local_with_default
-    assert_kind_of Hash, @tl.foo2
-    @tl.foo2[:hi] = 1
-    assert_equal 1, @tl.foo2[:hi]
-    thread = Thread.new do
-      assert_kind_of Hash, @tl.foo2
-      assert_nil @tl.foo2[:hi]
-      @tl.foo2[:hi] = 2
-    end
-    thread.join
-    assert_equal 1, @tl.foo2[:hi]
-  end
-
-  def test_instance_thread_local
-    assert_nil @tl.baz
-    @tl.baz = 1
-    assert_equal 1, @tl.baz
-    new_foo = nil
-    thread = Thread.new do
-      @tl.baz = 2
-      new_foo = @tl.baz
-    end
-    thread.join
-    assert_equal 2, new_foo
-    assert_equal 1, @tl.baz
-    assert_not_equal @tl.baz, @tl2.baz
-  end
-
-  def test_thread_global
-    assert_nil @tl.bar
-    @tl.bar = 1
-    assert_equal 1, @tl.bar
-    new_bar = nil
-    thread = Thread.new do
-      @tl.bar = 2
-      new_bar = @tl.bar
-    end
-    thread.join
-    assert_equal 2, new_bar
-    assert_equal 2, @tl.bar
-  end
-
-  def test_thread_global_with_default
-    assert_kind_of Hash, @tl.bar2
-    @tl.bar2[:hi] = 1
-    assert_equal 1, @tl.bar2[:hi]
-    thread = Thread.new do
-      assert_kind_of Hash, @tl.bar2
-      assert_equal 1, @tl.bar2[:hi]
-    end
-    thread.join
-    assert_equal 1, @tl.bar2[:hi]
-  end
-
-  def test_instance_exec
-    assert_equal :foo, @ie.foo
-    assert_equal :foo, @ie.exec
-    @ie.freeze
-    assert_equal :foo, @ie.foo
-    assert_equal :foo, @ie.exec
-  end
-
-  def test_constant
-    assert_equal :foo, @c.foo
-    assert_equal :baz, @c.bar
-  end
-
-  def test_dsl_accessor
-    assert_nil @da.foo
-    assert_equal :bar, @da.bar
-    assert_equal :baz, @da.baz
-    assert_equal [:qu, :ux], @da.quux
-    @da.foo 1
-    @da.bar 2
-    @da.baz 3
-    assert_equal 1, @da.foo
-    assert_equal 2, @da.bar
-    assert_equal 3, @da.baz
-  end
-
-  def test_dsl_reader
-    assert_equal true, @da.on
-    assert_equal false, @da.off
-    assert_raise(ArgumentError) do
-      @da.on false
-    end
-    assert_equal [ @da.on, @da.off ], @da.states
-    assert_equal %w[a b c], @da.abc
-    @da.abc << 'd'
-    assert_equal %w[a b c d], @da.abc
-    @da.instance_variable_set :@abc, %w[a b c]
-    assert_equal %w[a b c], @da.abc
-  end
-
-  def test_dsl_accessor_multiple
-    assert_nil @da.foo
-    assert_equal :bar, @da.bar
-    @da.foo 1, 2
-    @da.bar [1, 2]
-    assert_equal [1, 2], @da.foo
-    assert_equal [1, 2], @da.bar
-    @da.bar [1, 2, *@da.bar]
-    assert_equal [1, 2] * 2, @da.bar
-  end
-
-  def test_interpreter
-    assert_equal :foo, @i.interpret('foo')
-    temp = Tempfile.new('foo')
-    temp.write 'foo'
-    temp.rewind
-    assert_equal :foo, @i.interpret(temp)
-  end
-
-  def test_interpreter_with_args
-    assert_equal 3, @i.interpret('|x| x + y', 1)
-    temp = Tempfile.new('foo')
-    temp.write '|x| x + y'
-    temp.rewind
-    assert_equal 3, @i.interpret(temp, 1)
-  end
-
-  def test_symbol_maker
-    s = S.new
-    assert_equal(:foo, s.instance_exec { foo })
-    assert_raise(NoMethodError) { s.instance_exec { foo 1 }}
-  end
-
-  def test_constant_maker
-    assert_equal(:FOO, K::FOO)
-  end
-
-  def test_deflect_block
-    assert_raise(NoMethodError) { 1.foo }
-    assert !D.deflect?(Integer, :foo)
-    D.deflect(Integer, :foo, Tins::Deflect::Deflector.new { :foo }) do
-      assert_equal :foo, 1.foo
-      assert D.deflect?(Integer, :foo)
-    end
-    assert !D.deflect?(Integer, :foo)
-    assert_raise(NoMethodError) { 1.foo }
-  end
-
-  def test_deflect
-    assert_raise(NoMethodError) { 1.foo }
-    assert !D.deflect?(Integer, :foo)
-    D.deflect_start(Integer, :foo, Tins::Deflect::Deflector.new { :foo })
-    assert_equal :foo, 1.foo
-    assert D.deflect?(Integer, :foo)
-    t = Thread.new do
-      assert !D.deflect?(Integer, :foo)
-      assert_raise(NoMethodError) { 1.foo }
-    end
-    t.join
-    D.deflect_stop(Integer, :foo)
-    assert !D.deflect?(Integer, :foo)
-    assert_raise(NoMethodError) { 1.foo }
-  end
-
-  def test_deflect_method_missing
-    assert_raise(NoMethodError) { 1.foo }
-    assert !D.deflect?(Integer, :method_missing)
-    D.deflect_start(Integer, :method_missing, Tins::Deflect::Deflector.new { :foo })
-    assert_equal :foo, 1.foo
-    assert D.deflect?(Integer, :method_missing)
-    t = Thread.new do
-      assert !D.deflect?(Integer, :method_missing)
-      assert_raise(NoMethodError) { 1.foo }
-    end
-    t.join
-    D.deflect_stop(Integer, :method_missing)
-    assert !D.deflect?(Integer, :method_missing)
-    assert_raise(NoMethodError) { 1.foo }
-  end
-
-  def test_delegate_d3
-    d = D3.new []
-    assert_equal 0, d.size
-    d.push 1
-    assert_equal [1], d.map { |x| x }
-    d.push 2
-    assert_equal [1, 2], d.map { |x| x }
-    d.push 3
-    assert_equal [1, 2, 3], d.map { |x| x }
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/tins-1.31.1/tests/duration_test.rb

@@ -1,81 +0,0 @@
-require 'test_helper'
-require 'tins'
-
-module Tins
-  class DurationTest < Test::Unit::TestCase
-    def test_short_to_s
-      assert_equal '00:11:06', Tins::Duration.new(666).to_s
-    end
-
-    def test_to_s_with_days
-      assert_equal '7+17:11:06', Tins::Duration.new(666666).to_s
-    end
-
-    def test_to_s_with_fractional_seconds
-      assert_equal '00:11:06.123', Tins::Duration.new(666.123456).to_s
-    end
-
-    def test_to_s_with_days_and_fractional_seconds
-      assert_equal '7+17:11:06.123', Tins::Duration.new(666666.123456).to_s
-    end
-
-    def test_format_without_precision
-      assert_equal '0+00:11:06.123456', Tins::Duration.new(666.123456).format
-    end
-
-    def test_smart_format
-      assert_equal '00:11:06.123', Tins::Duration.new(666.123456).format('%D')
-      assert_equal '7+17:11:06.123', Tins::Duration.new(666666.123456).format('%D')
-    end
-
-    def test_predicate_days
-      s = 0
-      assert_false Tins::Duration.new(s).days?
-      s += 86_400
-      assert_true Tins::Duration.new(s).days?
-    end
-
-    def test_predicate_hours
-      s = 0
-      assert_false Tins::Duration.new(s).hours?
-      s += 3600
-      assert_true Tins::Duration.new(s).hours?
-    end
-
-    def test_predicate_minutes
-      s = 0
-      assert_false Tins::Duration.new(s).minutes?
-      s += 60
-      assert_true Tins::Duration.new(s).minutes?
-    end
-
-    def test_predicate_seconds
-      s = 0
-      assert_false Tins::Duration.new(s).seconds?
-      s += 1
-      assert_true Tins::Duration.new(s).seconds?
-    end
-
-    def test_predicate_fractional_seconds
-      s = 0
-      assert_false Tins::Duration.new(s).fractional_seconds?
-      s += 0.1
-      assert_true Tins::Duration.new(s).fractional_seconds?
-    end
-
-    def test_comparison
-      t1 = Tins::Duration.new(666.23456)
-      t2 = Tins::Duration.new(666.12345)
-      assert_operator t1, :>, t2
-    end
-
-    def test_negative_durations
-      duration = Tins::Duration.new(-42)
-      assert_equal '-0+00:00:42.000000', duration.format
-      assert_equal '-00:00:42', duration.to_s
-      assert_true duration.negative?
-      assert_false Tins::Duration.new(42).negative?
-    end
-  end
-end
-

data/vendor/bundle/ruby/3.1.0/gems/tins-1.31.1/tests/dynamic_scope_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-require 'tins'
-
-class DynamicScopeTest < Test::Unit::TestCase
-  include Tins::DynamicScope
-
-  def test_dynamic_scoping
-    assert_raise(NameError) { foo }
-    assert_equal false, dynamic_defined?(:foo)
-    dynamic_scope do
-      assert_raise(NameError) { foo }
-      assert_equal false, dynamic_defined?(:foo)
-      self.foo = 1
-      assert_equal 1, foo
-      assert_equal true, dynamic_defined?(:foo)
-      dynamic_scope do
-        assert_equal 1, foo
-        assert_equal true, dynamic_defined?(:foo)
-        self.foo = 2
-        assert_equal 2, foo
-        dynamic_scope do
-          assert_equal 2, foo
-        end
-        assert_equal 2, foo
-      end
-      assert_equal 1, foo
-    end
-    assert_equal false, dynamic_defined?(:foo)
-    assert_raise(NameError) { foo }
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/tins-1.31.1/tests/expose_test.rb

@@ -1,43 +0,0 @@
-require 'test_helper'
-require 'tins/xt/expose'
-
-module Tins
-  class ExposeTest < Test::Unit::TestCase
-    class A
-      def priv
-        :priv
-      end
-      private :priv
-
-      def prot(x)
-        :prot
-      end
-      protected :prot
-    end
-
-    def setup
-      @a = A.new
-    end
-
-    def test_raises_exception_unless_exposed
-      assert_raise(NoMethodError) { @a.priv }
-      assert_raise(NoMethodError) { @a.prot(:any) }
-    end
-
-    def test_exposes_all_methods
-      @a = @a.expose
-      assert_equal :priv, @a.priv
-      assert_equal :prot, @a.prot(:any)
-    end
-
-    def test_exposes_all_methods_in_block
-      assert_equal :priv, @a.expose { priv }
-      assert_equal :prot, @a.expose { prot(:any) }
-    end
-
-    def test_exposes_specified_method_call
-      assert_equal :priv, @a.expose(:priv)
-      assert_equal :prot, @a.expose(:prot, :any)
-    end
-  end
-end