tins 0.13.2 → 1.0.0

data/lib/tins/thread_local.rb

@@ -0,0 +1,52 @@
+module Tins
+  module ThreadLocal
+    @@mutex = Mutex.new
+
+    @@cleanup = lambda do |my_object_id|
+      my_id = "__thread_local_#{my_object_id}__"
+      @@mutex.synchronize do
+        for t in Thread.list
+          t[my_id] = nil if t[my_id]
+        end
+      end
+    end
+
+    # Define a thread local variable named _name_ in this module/class. If the
+    # value _value_ is given, it is used to initialize the variable.
+    def thread_local(name, default_value = nil)
+      is_a?(Module) or raise TypeError, "receiver has to be a Module"
+
+      name = name.to_s
+      my_id = "__thread_local_#{__id__}__"
+
+      ObjectSpace.define_finalizer(self, @@cleanup)
+
+      define_method(name) do
+        Thread.current[my_id] ||= {}
+        Thread.current[my_id][name]
+      end
+
+      define_method("#{name}=") do |value|
+        Thread.current[my_id] ||= {}
+        Thread.current[my_id][name] = value
+      end
+
+      if default_value
+        Thread.current[my_id] = {}
+        Thread.current[my_id][name] = default_value
+      end
+      self
+    end
+
+    # Define a thread local variable for the current instance with name _name_.
+    # If the value _value_ is given, it is used to initialize the variable.
+    def instance_thread_local(name, value = nil)
+      sc = class << self
+        extend Tins::ThreadLocal
+        self
+      end
+      sc.thread_local name, value
+      self
+    end
+  end
+end

data/lib/tins/version.rb

@@ -1,6 +1,6 @@
 module Tins
   # Tins version
-  VERSION         = '0.13.2'
+  VERSION         = '1.0.0'
   VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/lib/tins/xt.rb

@@ -39,4 +39,5 @@ module Tins
   require 'tins/xt/method_description'
   require 'tins/xt/annotate'
   require 'tins/xt/concern'
+  require 'tins/xt/dslkit'
 end

data/lib/tins/xt/dslkit.rb

@@ -0,0 +1,23 @@
+require 'tins'
+
+module Tins
+  class ::Module
+    include Tins::Constant
+    include Tins::DSLAccessor
+    include Tins::ClassMethod
+    include Tins::Delegate
+    include Tins::ParameterizedModule
+    include Tins::FromModule
+  end
+
+  class ::Object
+    include Tins::ThreadLocal
+    include Tins::ThreadGlobal
+    include Tins::InstanceExec
+    include Tins::Interpreter
+    include Tins::Deflect
+    include Tins::ThreadLocal
+    include Tins::Eigenclass
+    include Tins::BlockSelf
+  end
+end

data/tests/concern_test.rb

@@ -1,36 +1,35 @@
 require 'test_helper'
-require 'tins/concern'
+require 'tins'
 
-module Tins
-  class ConcernTest < Test::Unit::TestCase
-    module ConcernTroll
-      extend ::Tins::Concern[:complain => true]
+class ConcernTest < Test::Unit::TestCase
+  module AC
+    extend Tins::Concern
 
-      included do
-        @included = :included
-        @options  = tins_concern_args.first
-      end
+    included do
+      $included = self
+    end
 
-      module ClassMethods
-        def class_foo
-          :class_foo
-        end
-      end
+    def foo
+      :foo
+    end
 
-      def foo
-        :foo
+    module ClassMethods
+      def bar
+        :bar
       end
     end
+  end
 
-    class Troll
-      include ConcernTroll
-    end
+  $included = nil
 
-    def test_concern
-      assert_equal :class_foo, Troll.class_foo
-      assert_equal :foo, Troll.new.foo
-      assert_equal :included, Troll.instance_variable_get(:@included)
-      assert_equal true, Troll.instance_variable_get(:@options)[:complain]
-    end
+  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/tests/dslkit_test.rb

@@ -0,0 +1,308 @@
+require 'test_helper'
+require 'tins'
+
+class TL
+  def initialize
+    make_baz
+  end
+
+  extend Tins::ThreadLocal
+  thread_local :foo
+
+  include Tins::ThreadLocal
+  def make_baz
+    instance_thread_local :baz
+  end
+
+  extend Tins::ThreadGlobal
+  thread_global :bar
+end
+
+class IE
+  include Tins::InstanceExec
+
+  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::InstanceExec
+  include Tins::SymbolMaker
+end
+
+module K
+  extend Tins::ConstantMaker
+end
+
+module D
+  extend Tins::Deflect
+end
+
+class D2
+  extend Tins::Delegate
+
+  def initialize
+    @ary = [ 1, 2, 3 ]
+  end
+  attr_reader :ary
+
+  delegate :my_size1, :@ary, :size
+  delegate :my_size2, :ary, :size
+  delegate :size, :ary
+  delegate :length, :ary
+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_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_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_raises(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_raises(NoMethodError) { s.instance_exec { foo 1 }}
+  end
+
+  def test_constant_maker
+    assert_equal(:FOO, K::FOO)
+  end
+
+  def test_deflect_block
+    assert_raises(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_raises(NoMethodError) { 1.foo }
+  end
+
+  def test_deflect
+    assert_raises(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_raises(NoMethodError) { 1.foo }
+    end
+    t.join
+    D.deflect_stop(Integer, :foo)
+    assert !D.deflect?(Integer, :foo)
+    assert_raises(NoMethodError) { 1.foo }
+  end
+
+  def test_deflect_method_missing
+    assert_raises(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_raises(NoMethodError) { 1.foo }
+    end
+    t.join
+    D.deflect_stop(Integer, :method_missing)
+    assert !D.deflect?(Integer, :method_missing)
+    assert_raises(NoMethodError) { 1.foo }
+  end
+
+  def test_delegate
+    d = D2.new
+    assert_equal 3, d.my_size1
+    assert_equal 3, d.my_size2
+    assert_equal 3, d.size
+    assert_equal 3, d.length
+  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