thread_variables 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in thread_local_variable_access.gemspec
+gemspec
+
+gem "redgreen", :platform => :ruby_18
+gem "ansi", :platform => :ruby_19
+gem "rake", "~> 0.9.2.2"
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Stefan Kaes
+
+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.

data/README.md

@@ -0,0 +1,38 @@
+# ThreadVariables
+
+This gem provides methods to access thread local variables with a ruby trunk compatible
+API. It also provides an implementation for ruby 1.9, since ruby 1.9.3 made thread locals
+fiber local.
+
+See http://bugs.ruby-lang.org/issues/7097
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'thread_variables'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install thread_variables
+
+## Usage
+
+    require "thread_variables"
+    Thread.current.thread_variable_set :foo, 5
+    Thread.current.thread_variable_get :foo
+    Thread.current.thread_variable? :foo
+    Thread.current.thread_variables
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require "bundler/setup"
+require "rake/testtask"
+include Rake::DSL
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task :default do
+  Rake::Task[:test].invoke
+end

data/lib/thread_variables.rb

@@ -0,0 +1,31 @@
+require "thread_variables/version"
+require "thread"
+
+class Thread
+  if RUBY_VERSION < "1.9"
+
+    alias :thread_variable_get :[]
+    alias :thread_variable_set :[]=
+    alias :thread_variables :keys
+    alias :thread_variable? :key?
+
+  elsif !instance_methods.include?(:thread_variables)
+
+    def thread_variables
+      (locals = @locals) ? locals.keys : []
+    end
+
+    def thread_variable?(k)
+      (locals = @locals) && locals.include?(k.to_sym)
+    end
+
+    def thread_variable_get(k)
+      (locals = @locals) ? locals[k.to_sym] : nil
+    end
+
+    def thread_variable_set(k,v)
+      (@locals ||= {})[k.to_sym] = v
+    end
+
+  end
+end

data/lib/thread_variables/version.rb

@@ -0,0 +1,3 @@
+module ThreadVariables
+  VERSION = "0.1.0"
+end

data/test/colorized_test_output.rb

@@ -0,0 +1,26 @@
+# colorized output for Test::Unit / MiniTest
+begin
+  if RUBY_VERSION < "1.9"
+    require 'redgreen'
+  else
+    require "test/unit/testcase"
+    class MiniTest::Unit::TestCase
+      alias :run_without_colors :run
+      require 'ansi/code'
+      ANSI_COLOR_MAPPING = Hash.new(:white).merge!('.' => :green, 'S' => :magenta, 'F' => :yellow, 'E' => :red )
+      def run(*args)
+        r = run_without_colors *args
+        ANSI.ansi(r, ANSI_COLOR_MAPPING[r])
+      end
+    end
+    class MiniTest::Unit
+      def status(io = @@out)
+        format = "%d tests, %d assertions, %d failures, %d errors, %d skips"
+        color = (errors + failures) > 0 ? :red : :green
+        io.puts ANSI.ansi(format % [test_count, assertion_count, failures, errors, skips], color)
+      end
+    end
+  end
+rescue LoadError => e
+  # do nothing
+end if $stdout.tty?

data/test/thread_variables_test.rb

@@ -0,0 +1,130 @@
+require 'thread_variables'
+require 'test/unit'
+require File.expand_path('../colorized_test_output', __FILE__)
+
+class ThreadVariablesTest < Test::Unit::TestCase
+
+  def test_symbol_setter_and_getter
+    t = Thread.new { Thread.current.thread_variable_set :foo, 42 }
+    t.join
+    assert_equal 42, t.thread_variable_get(:foo)
+  end
+
+  def test_string_setter_and_getter
+    t = Thread.new { Thread.current.thread_variable_set "foo", 42 }
+    t.join
+    assert_equal 42, t.thread_variable_get("foo")
+  end
+
+  def test_string_setter_and_smybol_getter
+    t = Thread.new { Thread.current.thread_variable_set "foo", 42 }
+    t.join
+    assert_equal 42, t.thread_variable_get(:foo)
+  end
+
+  def test_symbol_setter_and_string_getter
+    t = Thread.new { Thread.current.thread_variable_set :foo, 42 }
+    t.join
+    assert_equal 42, t.thread_variable_get("foo")
+  end
+
+  def test_listing_keys
+    t = Thread.new do
+      Thread.current.thread_variable_set :foo, 42
+      Thread.current.thread_variable_set "bar", 815
+    end
+    t.join
+    vs = t.thread_variables
+    assert_equal 2, vs.size
+    assert vs.include?(:foo)
+    assert vs.include?(:bar)
+  end
+
+  def test_ckecking_keys
+    t = Thread.new do
+      Thread.current.thread_variable_set :foo, 42
+      Thread.current.thread_variable_set "bar", 815
+    end
+    t.join
+    assert t.thread_variable?(:foo)
+    assert t.thread_variable?(:bar)
+  end
+
+  # official tests
+  # see http://bugs.ruby-lang.org/attachments/3149/thread_variables.patch
+
+  def test_main_thread_variable_in_enumerator
+    assert_equal Thread.main, Thread.current
+
+    Thread.current.thread_variable_set :foo, "bar"
+
+    thread, value = Fiber.new {
+      Fiber.yield [Thread.current, Thread.current.thread_variable_get(:foo)]
+    }.resume
+
+    assert_equal Thread.current, thread
+    assert_equal Thread.current.thread_variable_get(:foo), value
+  end if RUBY_VERSION >= "1.9"
+
+  def test_thread_variable_in_enumerator
+    Thread.new {
+      Thread.current.thread_variable_set :foo, "bar"
+
+      thread, value = Fiber.new {
+        Fiber.yield [Thread.current, Thread.current.thread_variable_get(:foo)]
+      }.resume
+
+      assert_equal Thread.current, thread
+      assert_equal Thread.current.thread_variable_get(:foo), value
+    }.join
+  end if RUBY_VERSION >= "1.9"
+
+  def test_thread_variables
+    assert_equal [], Thread.new { Thread.current.thread_variables }.join.value
+
+    t = Thread.new {
+      Thread.current.thread_variable_set(:foo, "bar")
+      Thread.current.thread_variables
+    }
+    assert_equal [:foo], t.join.value
+  end
+
+  def test_thread_variable?
+    assert !Thread.new { Thread.current.thread_variable?("foo") }.join.value
+    t = Thread.new {
+      Thread.current.thread_variable_set("foo", "bar")
+    }.join
+
+    assert t.thread_variable?("foo")
+    assert t.thread_variable?(:foo)
+    assert !t.thread_variable?(:bar)
+  end
+
+  def test_thread_variable_strings_and_symbols_are_the_same_key
+    t = Thread.new {}.join
+    t.thread_variable_set("foo", "bar")
+    assert_equal "bar", t.thread_variable_get(:foo)
+  end
+
+  def test_thread_variable_frozen
+    t = Thread.new { }.join
+    t.freeze
+    exception_class = RUBY_VERSION < "1.9" ? TypeError : RuntimeError
+    assert_raises(exception_class) do
+      t.thread_variable_set(:foo, "bar")
+    end
+  end
+
+  def test_thread_variable_security
+    t = Thread.new { sleep }
+
+    assert_raises(SecurityError) do
+      Thread.new { $SAFE = 4; t.thread_variable_get(:foo) }.join
+    end
+
+    assert_raises(SecurityError) do
+      Thread.new { $SAFE = 4; t.thread_variable_set(:foo, :baz) }.join
+    end
+  end if RUBY_VERSION > "1.9.3"
+
+end

data/thread_variables.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'thread_variables/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "thread_variables"
+  gem.version       = ThreadVariables::VERSION
+  gem.authors       = ["Stefan Kaes"]
+  gem.email         = ["stefan.kaes@xing.com"]
+  gem.description   = %q{Provide thread local variables for ruby 1.9 and API for all ruby versions}
+  gem.summary       = %q{Provide functionality compatible to latest trunk commit for all ruby version above 1.8}
+  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.require_paths = ["lib"]
+end

data/thread_variables.patch

@@ -0,0 +1,319 @@
+diff --git a/NEWS b/NEWS
+index 0e4508e..b20cebb 100644
+--- a/NEWS
++++ b/NEWS
+@@ -81,6 +81,16 @@ with all sufficient information, see the ChangeLog file.
+       * added Struct#to_h returning values with keys corresponding to the
+         instance variable names.
+ 
++  * Thread
++    * added method:
++      * added Thread#thread_variable_get for getting thread local variables
++        (these are different than Fiber local variables).
++      * added Thread#thread_variable_set for setting thread local variables.
++      * added Thread#thread_variables for getting a list of the thread local
++        variable keys.
++      * added Thread#thread_variable? for testing to see if a particular thread
++        variable has been set.
++
+   * Time
+     * change return value:
+       * Time#to_s returned encoding defaults to US-ASCII but automatically
+diff --git a/test/ruby/test_thread.rb b/test/ruby/test_thread.rb
+index c8081b4..145e021 100644
+--- a/test/ruby/test_thread.rb
++++ b/test/ruby/test_thread.rb
+@@ -27,6 +27,79 @@ class TestThread < Test::Unit::TestCase
+     end
+   end
+ 
++  def test_main_thread_variable_in_enumerator
++    assert_equal Thread.main, Thread.current
++
++    Thread.current.thread_variable_set :foo, "bar"
++
++    thread, value = Fiber.new {
++      Fiber.yield [Thread.current, Thread.current.thread_variable_get(:foo)]
++    }.resume
++
++    assert_equal Thread.current, thread
++    assert_equal Thread.current.thread_variable_get(:foo), value
++  end
++
++  def test_thread_variable_in_enumerator
++    Thread.new {
++      Thread.current.thread_variable_set :foo, "bar"
++
++      thread, value = Fiber.new {
++        Fiber.yield [Thread.current, Thread.current.thread_variable_get(:foo)]
++      }.resume
++
++      assert_equal Thread.current, thread
++      assert_equal Thread.current.thread_variable_get(:foo), value
++    }.join
++  end
++
++  def test_thread_variables
++    assert_equal [], Thread.new { Thread.current.thread_variables }.join.value
++
++    t = Thread.new {
++      Thread.current.thread_variable_set(:foo, "bar")
++      Thread.current.thread_variables
++    }
++    assert_equal [:foo], t.join.value
++  end
++
++  def test_thread_variable?
++    refute Thread.new { Thread.current.thread_variable?("foo") }.join.value
++    t = Thread.new {
++      Thread.current.thread_variable_set("foo", "bar")
++    }.join
++
++    assert t.thread_variable?("foo")
++    assert t.thread_variable?(:foo)
++    refute t.thread_variable?(:bar)
++  end
++
++  def test_thread_variable_strings_and_symbols_are_the_same_key
++    t = Thread.new {}.join
++    t.thread_variable_set("foo", "bar")
++    assert_equal "bar", t.thread_variable_get(:foo)
++  end
++
++  def test_thread_variable_frozen
++    t = Thread.new { }.join
++    t.freeze
++    assert_raises(RuntimeError) do
++      t.thread_variable_set(:foo, "bar")
++    end
++  end
++
++  def test_thread_variable_security
++    t = Thread.new { sleep }
++
++    assert_raises(SecurityError) do
++      Thread.new { $SAFE = 4; t.thread_variable_get(:foo) }.join
++    end
++
++    assert_raises(SecurityError) do
++      Thread.new { $SAFE = 4; t.thread_variable_set(:foo, :baz) }.join
++    end
++  end
++
+   def test_mutex_synchronize
+     m = Mutex.new
+     r = 0
+diff --git a/thread.c b/thread.c
+index b512566..b21a088 100644
+--- a/thread.c
++++ b/thread.c
+@@ -2525,6 +2525,9 @@ rb_thread_local_aref(VALUE thread, ID id)
+  *    #=> nil if fiber-local
+  *    #=> 2 if thread-local (The value 2 is leaked to outside of meth method.)
+  *
++ *  For thread-local variables, please see <code>Thread#thread_local_get</code>
++ *  and <code>Thread#thread_local_set</code>.
++ *
+  */
+ 
+ static VALUE
+@@ -2561,7 +2564,9 @@ rb_thread_local_aset(VALUE thread, ID id, VALUE val)
+  *      thr[sym] = obj   -> obj
+  *
+  *  Attribute Assignment---Sets or creates the value of a fiber-local variable,
+- *  using either a symbol or a string. See also <code>Thread#[]</code>.
++ *  using either a symbol or a string. See also <code>Thread#[]</code>.  For
++ *  thread-local variables, please see <code>Thread#thread_variable_set</code>
++ *  and <code>Thread#thread_variable_get</code>.
+  */
+ 
+ static VALUE
+@@ -2572,6 +2577,80 @@ rb_thread_aset(VALUE self, VALUE id, VALUE val)
+ 
+ /*
+  *  call-seq:
++ *      thr.thread_variable_get(key)  -> obj or nil
++ *
++ *  Returns the value of a thread local variable that has been set.  Note that
++ *  these are different than fiber local values.  For fiber local values,
++ *  please see Thread#[] and Thread#[]=.
++ *
++ *  Thread local values are carried along with threads, and do not respect
++ *  fibers.  For example:
++ *
++ *    Thread.new {
++ *      Thread.current.thread_variable_set("foo", "bar") # set a thread local
++ *      Thread.current["foo"] = "bar"                    # set a fiber local
++ *
++ *      Fiber.new {
++ *        Fiber.yield [
++ *          Thread.current.thread_variable_get("foo"), # get the thread local
++ *          Thread.current["foo"],                     # get the fiber local
++ *        ]
++ *      }.resume
++ *    }.join.value # => ['bar', nil]
++ *
++ *  The value "bar" is returned for the thread local, where nil is returned
++ *  for the fiber local.  The fiber is executed in the same thread, so the
++ *  thread local values are available.
++ *
++ *  See also Thread#[]
++ */
++
++static VALUE
++rb_thread_variable_get(VALUE thread, VALUE id)
++{
++    VALUE locals;
++    rb_thread_t *th;
++
++    GetThreadPtr(thread, th);
++
++    if (rb_safe_level() >= 4 && th != GET_THREAD()) {
++	rb_raise(rb_eSecurityError, "Insecure: can't modify thread locals");
++    }
++
++    locals = rb_iv_get(thread, "locals");
++    return rb_hash_aref(locals, ID2SYM(rb_to_id(id)));
++}
++
++/*
++ *  call-seq:
++ *      thr.thread_variable_set(key, value)
++ *
++ *  Sets a thread local with +key+ to +value+.  Note that these are local to
++ *  threads, and not to fibers.  Please see Thread#thread_variable_get and
++ *  Thread#[] for more information.
++ */
++
++static VALUE
++rb_thread_variable_set(VALUE thread, VALUE id, VALUE val)
++{
++    VALUE locals;
++    rb_thread_t *th;
++
++    GetThreadPtr(thread, th);
++
++    if (rb_safe_level() >= 4 && th != GET_THREAD()) {
++	rb_raise(rb_eSecurityError, "Insecure: can't modify thread locals");
++    }
++    if (OBJ_FROZEN(thread)) {
++	rb_error_frozen("thread locals");
++    }
++
++    locals = rb_iv_get(thread, "locals");
++    return rb_hash_aset(locals, ID2SYM(rb_to_id(id)), val);
++}
++
++/*
++ *  call-seq:
+  *     thr.key?(sym)   -> true or false
+  *
+  *  Returns <code>true</code> if the given string (or symbol) exists as a
+@@ -2651,6 +2730,76 @@ rb_thread_keys(VALUE self)
+     return ary;
+ }
+ 
++static int
++keys_i(VALUE key, VALUE value, VALUE ary)
++{
++    rb_ary_push(ary, key);
++    return ST_CONTINUE;
++}
++
++/*
++ *  call-seq:
++ *     thr.thread_variables   -> array
++ *
++ *  Returns an an array of the names of the thread-local variables (as Symbols).
++ *
++ *     thr = Thread.new do
++ *       Thread.current.thread_variable_set(:cat, 'meow')
++ *       Thread.current.thread_variable_set("dog", 'woof')
++ *     end
++ *     thr.join               #=> #<Thread:0x401b3f10 dead>
++ *     thr.thread_variables   #=> [:dog, :cat]
++ *
++ *  Note that these are not fiber local variables.  Please see Thread#[] and
++ *  Thread#thread_variable_get for more details.
++ */
++
++static VALUE
++rb_thread_variables(VALUE thread)
++{
++    VALUE locals;
++    VALUE ary;
++
++    locals = rb_iv_get(thread, "locals");
++    ary = rb_ary_new();
++    rb_hash_foreach(locals, keys_i, ary);
++
++    return ary;
++}
++
++/*
++ *  call-seq:
++ *     thr.thread_variable?(key)   -> true or false
++ *
++ *  Returns <code>true</code> if the given string (or symbol) exists as a
++ *  thread-local variable.
++ *
++ *     me = Thread.current
++ *     me.thread_variable_set(:oliver, "a")
++ *     me.thread_variable?(:oliver)    #=> true
++ *     me.thread_variable?(:stanley)   #=> false
++ *
++ *  Note that these are not fiber local variables.  Please see Thread#[] and
++ *  Thread#thread_variable_get for more details.
++ */
++
++static VALUE
++rb_thread_variable_p(VALUE thread, VALUE key)
++{
++    VALUE locals;
++
++    locals = rb_iv_get(thread, "locals");
++
++    if (!RHASH(locals)->ntbl)
++        return Qfalse;
++
++    if (st_lookup(RHASH(locals)->ntbl, ID2SYM(rb_to_id(key)), 0)) {
++	return Qtrue;
++    }
++
++    return Qfalse;
++}
++
+ /*
+  *  call-seq:
+  *     thr.priority   -> integer
+@@ -4541,6 +4690,10 @@ Init_Thread(void)
+     rb_define_method(rb_cThread, "priority", rb_thread_priority, 0);
+     rb_define_method(rb_cThread, "priority=", rb_thread_priority_set, 1);
+     rb_define_method(rb_cThread, "status", rb_thread_status, 0);
++    rb_define_method(rb_cThread, "thread_variable_get", rb_thread_variable_get, 1);
++    rb_define_method(rb_cThread, "thread_variable_set", rb_thread_variable_set, 2);
++    rb_define_method(rb_cThread, "thread_variables", rb_thread_variables, 0);
++    rb_define_method(rb_cThread, "thread_variable?", rb_thread_variable_p, 1);
+     rb_define_method(rb_cThread, "alive?", rb_thread_alive_p, 0);
+     rb_define_method(rb_cThread, "stop?", rb_thread_stop_p, 0);
+     rb_define_method(rb_cThread, "abort_on_exception", rb_thread_abort_exc, 0);
+diff --git a/vm.c b/vm.c
+index c47b592..5269a50 100644
+--- a/vm.c
++++ b/vm.c
+@@ -1838,6 +1838,7 @@ ruby_thread_init(VALUE self)
+     GetThreadPtr(self, th);
+ 
+     th_init(th, self);
++    rb_iv_set(self, "locals", rb_hash_new());
+     th->vm = vm;
+ 
+     th->top_wrapper = 0;
+@@ -2185,6 +2186,7 @@ Init_VM(void)
+ 
+ 	/* create main thread */
+ 	th_self = th->self = TypedData_Wrap_Struct(rb_cThread, &thread_data_type, th);
++	rb_iv_set(th_self, "locals", rb_hash_new());
+ 	vm->main_thread = th;
+ 	vm->running_thread = th;
+ 	th->vm = vm;

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: thread_variables
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Stefan Kaes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-02 00:00:00 Z
+dependencies: []
+
+description: Provide thread local variables for ruby 1.9 and API for all ruby versions
+email: 
+- stefan.kaes@xing.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/thread_variables.rb
+- lib/thread_variables/version.rb
+- test/colorized_test_output.rb
+- test/thread_variables_test.rb
+- thread_variables.gemspec
+- thread_variables.patch
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Provide functionality compatible to latest trunk commit for all ruby version above 1.8
+test_files: 
+- test/colorized_test_output.rb
+- test/thread_variables_test.rb