methlab 0.0.9 → 0.1.0

data/Rakefile

@@ -1,5 +1,5 @@
 begin
-    require 'rubygems'
+  require 'rubygems'
 rescue LoadError
 end
 
@@ -29,32 +29,32 @@ Rake::GemPackageTask.new(spec) do |s|
 end
 
 Rake::PackageTask.new(spec.name, spec.version) do |p|
-    p.need_tar_gz = true
-    p.need_zip = true
-    p.package_files.include("./bin/**/*")
-    p.package_files.include("./Rakefile")
-    p.package_files.include("./lib/**/*.rb")
-    p.package_files.include("./test/**/*")
-    p.package_files.include("README")
+  p.need_tar_gz = true
+  p.need_zip = true
+  p.package_files.include("./bin/**/*")
+  p.package_files.include("./Rakefile")
+  p.package_files.include("./lib/**/*.rb")
+  p.package_files.include("./test/**/*")
+  p.package_files.include("README")
 end
 
 Rake::TestTask.new do |t|
-    t.libs << 'lib'
-    t.test_files = FileList['test/test*.rb']
-    t.verbose = true 
+  t.libs << 'lib'
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true 
 end
 
 RDoc::Task.new do |rd|
-    rd.rdoc_dir = "rdoc"
-    rd.main = "README"
-    rd.title = "MethLab: A method toolkit for Ruby"
-    rd.rdoc_files.include("./lib/**/*.rb")
-    rd.rdoc_files.include("README")
-    rd.options = %w(-a)
+  rd.rdoc_dir = "rdoc"
+  rd.main = "README"
+  rd.title = "MethLab: A method toolkit for Ruby"
+  rd.rdoc_files.include("./lib/**/*.rb")
+  rd.rdoc_files.include("README")
+  rd.options = %w(-a)
 end
 
 task :fixperms do
-    chmod(0644, Dir['**/*'])  
+  chmod(0644, Dir['**/*'])  
 end
 
 task :default => [:clean, :test, :build]
@@ -65,5 +65,5 @@ desc "Clean the source tree"
 task :clean => [:distclean]
 
 task :to_blog => [:clobber_rdoc, :rdoc] do
-    sh "rm -r $git/blog/content/docs/methlab && mv rdoc $git/blog/content/docs/methlab"
+  sh "rm -fr $git/blog/content/docs/methlab && mv rdoc $git/blog/content/docs/methlab"
 end

data/lib/methlab.rb

@@ -68,7 +68,7 @@
 #
 module MethLab
 
-    VERSION = "0.0.9"
+    VERSION = "0.1.0"
 
     # Integrates MethLab into all namespaces. It does this by patching itself
     # into ::main and Module.
@@ -370,6 +370,37 @@ module MethLab
         end
     end
 
+    #
+    # attr_threaded_accessor creates thread-local accessors via
+    # +Thread.current+. As a result, while these are accessed in your class,
+    # they live in a flat namespace, and must be used with caution.
+    #
+    # Usage:
+    #
+    #   class Foo
+    #     attr_threaded_accessor(:one, :two)
+    #
+    #     def bar
+    #       self.one = 1
+    #       self.two = 2
+    #     end
+    #   end
+    #
+    #   f = Foo.new
+    #   f.one # 1
+    #   f.two # 2
+    #
+    #   Thread.current[:one] # => 1
+    #   Thread.current[:two] # => 2
+    #
+    def attr_threaded_accessor(*method_names)
+        method_names.each do |meth|
+            self.send(:define_method, meth, proc { Thread.current[meth] })
+            meth2 = meth.to_s.gsub(/$/, '=').to_sym
+            self.send(:define_method, meth2, proc { |x| Thread.current[meth] = x })
+        end
+    end
+
     if $METHLAB_AUTOINTEGRATE
         integrate
     end

data/test/test_checks.rb

@@ -1,6 +1,6 @@
 begin
-    require 'rubygems'
-    gem 'test-unit'
+  require 'rubygems'
+  gem 'test-unit'
 rescue LoadError
 end
 
@@ -12,182 +12,182 @@ require 'methlab'
 MethLab.integrate
 
 class CheckedClass
-    def_named(:named, :stuff => String, :stuff2 => [ /pee/, :required ], :stuff3 => :required) do |params| 
-        [:stuff, :stuff2, :stuff3].collect { |x| params[x] }
-    end
+  def_named(:named, :stuff => String, :stuff2 => [ /pee/, :required ], :stuff3 => :required) do |params| 
+    [:stuff, :stuff2, :stuff3].collect { |x| params[x] }
+  end
 
-    def_ordered(:sequential, String, [Integer, :optional]) do |params|
-        params
-    end
+  def_ordered(:sequential, String, [Integer, :optional]) do |params|
+    params
+  end
 
-    def_ordered(:ranged, (0..9)) do |params|
-        params
-    end
+  def_ordered(:ranged, (0..9)) do |params|
+    params
+  end
 
-    def_attr(:set_me, String)
+  def_attr(:set_me, String)
 
-    def_ordered(:proc_nil, proc { |x| x.nil? }) do |params|
-        params
-    end
+  def_ordered(:proc_nil, proc { |x| x.nil? }) do |params|
+    params
+  end
 
-    def_ordered(:proc_raise, proc { |x| ArgumentError.new("foo") }) do |params|
-        params
-    end
+  def_ordered(:proc_raise, proc { |x| ArgumentError.new("foo") }) do |params|
+    params
+  end
 
-    def_named(:has_named_rt, :stuff => {:respond_to => :replace}) do |params|
-        params[:stuff]
-    end
+  def_named(:has_named_rt, :stuff => {:respond_to => :replace}) do |params|
+    params[:stuff]
+  end
 
-    def_ordered(:has_ordered_rt, {:respond_to => :replace}) do |params|
-        params[0]
-    end
+  def_ordered(:has_ordered_rt, {:respond_to => :replace}) do |params|
+    params[0]
+  end
 
-    def_attr :rt, {:respond_to => :replace}
+  def_attr :rt, {:respond_to => :replace}
 end
 
 $named_proc = build_named(:stuff => String) do |params|
-    params
+  params
 end
 
 $ordered_proc = build_ordered((0..9)) do |params|
-    params
+  params
 end
 
 # FIXME module tests
 
 class TestChecks < Test::Unit::TestCase
-    def setup
-        @checked = CheckedClass.new
+  def setup
+    @checked = CheckedClass.new
+  end
+
+  def test_01_named
+    assert(@checked.respond_to?(:named))
+
+    assert_raises(ArgumentError.new("value of argument 'stuff' is an invalid type. Requires 'String'")) do
+      @checked.named(:stuff => 1, :stuff2 => "pee", :stuff3 => 1)
     end
 
-    def test_01_named
-        assert(@checked.respond_to?(:named))
-        
-        assert_raises(ArgumentError.new("value of argument 'stuff' is an invalid type. Requires 'String'")) do
-            @checked.named(:stuff => 1, :stuff2 => "pee", :stuff3 => 1)
-        end
-        
-        assert_raises(ArgumentError.new("value of argument 'stuff2' does not match this regexp: '(?-mix:pee)'")) do
-            @checked.named(:stuff => "foo", :stuff2 => "bar", :stuff3 => 1)
-        end
-
-        assert_raises(ArgumentError.new("argument(s) 'stuff2' were not found but are required by the prototype")) do
-            @checked.named(:stuff => "foo", :stuff3 => 1)
-        end
-
-        assert_raises(ArgumentError.new("argument(s) 'stuff2, stuff3' were not found but are required by the prototype")) do
-            @checked.named(:stuff => "foo")
-        end
-
-        assert_raises(ArgumentError.new("argument(s) 'stuff2' were not found but are required by the prototype")) do
-            @checked.named(:stuff => "foo", :stuff3 => nil)
-        end
-
-        assert_equal(
-            @checked.named(:stuff => "foo", :stuff2 => "poopee", :stuff3 => 1), 
-            ["foo", "poopee", 1]
-        )
-
-        assert_equal($named_proc.call(:stuff => "foo"), { :stuff => "foo" })
+    assert_raises(ArgumentError.new("value of argument 'stuff2' does not match this regexp: '(?-mix:pee)'")) do
+      @checked.named(:stuff => "foo", :stuff2 => "bar", :stuff3 => 1)
     end
 
-    def test_02_checked
-        assert(@checked.respond_to?(:sequential))
-
-        assert_raises(ArgumentError.new("value of argument '0' is an invalid type. Requires 'String'")) do
-            @checked.sequential(nil)
-        end
-        
-        assert_raises(ArgumentError.new("value of argument '1' is an invalid type. Requires 'Integer'")) do
-            @checked.sequential("foo", "bar")
-        end
-        
-        assert_raises(ArgumentError.new("value of argument '1' is an invalid type. Requires 'Integer'")) do
-            @checked.sequential("foo", nil)
-        end
-
-        assert_raises(ArgumentError.new("too many arguments (3 for 2)")) do
-            @checked.sequential("foo", 1, nil)
-        end
-
-        assert_raises(ArgumentError.new("not enough arguments (0 for minimum 1)")) do
-            @checked.sequential()
-        end
-
-        assert_equal(@checked.sequential("foo"), ["foo"])
-        assert_equal(@checked.sequential("foo", 1), ["foo", 1])
+    assert_raises(ArgumentError.new("argument(s) 'stuff2' were not found but are required by the prototype")) do
+      @checked.named(:stuff => "foo", :stuff3 => 1)
+    end
+
+    assert_raises(ArgumentError.new("argument(s) 'stuff2, stuff3' were not found but are required by the prototype")) do
+      @checked.named(:stuff => "foo")
+    end
+
+    assert_raises(ArgumentError.new("argument(s) 'stuff2' were not found but are required by the prototype")) do
+      @checked.named(:stuff => "foo", :stuff3 => nil)
+    end
+
+    assert_equal(
+      @checked.named(:stuff => "foo", :stuff2 => "poopee", :stuff3 => 1), 
+      ["foo", "poopee", 1]
+    )
+
+    assert_equal($named_proc.call(:stuff => "foo"), { :stuff => "foo" })
+  end
+
+  def test_02_checked
+    assert(@checked.respond_to?(:sequential))
+
+    assert_raises(ArgumentError.new("value of argument '0' is an invalid type. Requires 'String'")) do
+      @checked.sequential(nil)
+    end
+
+    assert_raises(ArgumentError.new("value of argument '1' is an invalid type. Requires 'Integer'")) do
+      @checked.sequential("foo", "bar")
+    end
+
+    assert_raises(ArgumentError.new("value of argument '1' is an invalid type. Requires 'Integer'")) do
+      @checked.sequential("foo", nil)
+    end
+
+    assert_raises(ArgumentError.new("too many arguments (3 for 2)")) do
+      @checked.sequential("foo", 1, nil)
+  end
+
+  assert_raises(ArgumentError.new("not enough arguments (0 for minimum 1)")) do
+    @checked.sequential()
+end
+
+assert_equal(@checked.sequential("foo"), ["foo"])
+assert_equal(@checked.sequential("foo", 1), ["foo", 1])
     end
 
     def test_03_ranges
-        assert(@checked.respond_to?(:ranged))
+      assert(@checked.respond_to?(:ranged))
 
-        assert_raises(ArgumentError.new("value of argument '0' does not match range '0..9'")) do
-            @checked.ranged(-1)
-        end
+      assert_raises(ArgumentError.new("value of argument '0' does not match range '0..9'")) do
+        @checked.ranged(-1)
+      end
 
-        assert_raises(ArgumentError.new("value of argument '0' does not match range '0..9'")) do
-            @checked.ranged("foo")
-        end
+      assert_raises(ArgumentError.new("value of argument '0' does not match range '0..9'")) do
+        @checked.ranged("foo")
+      end
 
-        assert_raises(ArgumentError.new("value of argument '0' does not match range '0..9'")) do
-            @checked.ranged(10)
-        end
+      assert_raises(ArgumentError.new("value of argument '0' does not match range '0..9'")) do
+        @checked.ranged(10)
+      end
 
-        assert_equal(@checked.ranged(5), [5])
-        assert_equal($ordered_proc.call(5), [5])
+      assert_equal(@checked.ranged(5), [5])
+      assert_equal($ordered_proc.call(5), [5])
     end
 
     def test_04_procs
-        assert(@checked.respond_to?(:proc_nil))
+      assert(@checked.respond_to?(:proc_nil))
 
-        assert_raises(ArgumentError.new("value of argument '0' does not pass custom validation.")) do
-            @checked.proc_nil(true)
-        end
+      assert_raises(ArgumentError.new("value of argument '0' does not pass custom validation.")) do
+        @checked.proc_nil(true)
+      end
 
-        assert_equal(@checked.proc_nil(nil), [nil])
-        
-        assert(@checked.respond_to?(:proc_nil))
+      assert_equal(@checked.proc_nil(nil), [nil])
 
-        assert_raises(ArgumentError.new("foo")) do
-            @checked.proc_raise(true)
-        end
+      assert(@checked.respond_to?(:proc_nil))
 
-        assert_equal(@checked.proc_nil(nil), [nil])
+      assert_raises(ArgumentError.new("foo")) do
+        @checked.proc_raise(true)
+      end
+
+      assert_equal(@checked.proc_nil(nil), [nil])
     end
 
     def test_05_attr
-        assert(@checked.respond_to?(:set_me))
+      assert(@checked.respond_to?(:set_me))
 
-        assert_raises(ArgumentError.new("value of argument '0' is an invalid type. Requires 'String'")) do
-            @checked.set_me = 0
-        end
+      assert_raises(ArgumentError.new("value of argument '0' is an invalid type. Requires 'String'")) do
+        @checked.set_me = 0
+      end
 
-        @checked.set_me = "Foo"
+      @checked.set_me = "Foo"
 
-        assert_equal(@checked.set_me, "Foo")
+      assert_equal(@checked.set_me, "Foo")
     end
 
     def test_06_respond_to
-        assert(@checked.respond_to?(:has_named_rt))
-        assert(@checked.respond_to?(:has_ordered_rt))
-        assert(@checked.respond_to?(:rt))
-
-        assert_raises(ArgumentError.new("value of argument '0' does not respond to 'replace'")) do
-            @checked.rt = nil
-        end
-
-        assert_raises(ArgumentError.new("value of argument '0' does not respond to 'replace'")) do
-            @checked.has_ordered_rt(nil)
-        end
-        
-        assert_raises(ArgumentError.new("value of argument 'stuff' does not respond to 'replace'")) do
-            @checked.has_named_rt(:stuff => nil)
-        end
-
-        @checked.rt = "foo"
-
-        assert(@checked.rt, "foo")
-        assert(@checked.has_ordered_rt("foo"), "foo")
-        assert(@checked.has_named_rt(:stuff => "foo"), "foo")
+      assert(@checked.respond_to?(:has_named_rt))
+      assert(@checked.respond_to?(:has_ordered_rt))
+      assert(@checked.respond_to?(:rt))
+
+      assert_raises(ArgumentError.new("value of argument '0' does not respond to 'replace'")) do
+        @checked.rt = nil
+      end
+
+      assert_raises(ArgumentError.new("value of argument '0' does not respond to 'replace'")) do
+        @checked.has_ordered_rt(nil)
+      end
+
+      assert_raises(ArgumentError.new("value of argument 'stuff' does not respond to 'replace'")) do
+        @checked.has_named_rt(:stuff => nil)
+      end
+
+      @checked.rt = "foo"
+
+      assert(@checked.rt, "foo")
+      assert(@checked.has_ordered_rt("foo"), "foo")
+      assert(@checked.has_named_rt(:stuff => "foo"), "foo")
     end
 end

data/test/test_defaults.rb

@@ -1,6 +1,6 @@
 begin
-    require 'rubygems'
-    gem 'test-unit'
+  require 'rubygems'
+  gem 'test-unit'
 rescue LoadError
 end
 
@@ -12,49 +12,49 @@ require 'methlab'
 MethLab.integrate
 
 class DefaultClass
-    def_named(:named, 
-              :foo => [String, {:default => "foo"}, :required], 
-              :bar => [String, {:default => "bar"}] 
-             ) do |params|
-                 params
-             end
-    
-    def_ordered(:ordered, 
-                [String, {:default => "foo"}, :required], 
-                [String, {:default => "bar"}]
-               ) do |params|
-                   params
-               end
-
-    def_attr :ml_attr, [String, {:default => "foo"}]
+  def_named(:named, 
+            :foo => [String, {:default => "foo"}, :required], 
+            :bar => [String, {:default => "bar"}] 
+           ) do |params|
+             params
+           end
+
+           def_ordered(:ordered, 
+                       [String, {:default => "foo"}, :required], 
+                       [String, {:default => "bar"}]
+                      ) do |params|
+                        params
+                      end
+
+                      def_attr :ml_attr, [String, {:default => "foo"}]
 end
 
 class TestDefaults < Test::Unit::TestCase
-    def setup
-        @default = DefaultClass.new
-    end
+  def setup
+    @default = DefaultClass.new
+  end
 
-    def test_01_named
-        assert(@default.respond_to?(:named))
+  def test_01_named
+    assert(@default.respond_to?(:named))
 
-        assert_equal(@default.named, {:foo => "foo", :bar => "bar"})
-        assert_equal(@default.named(:foo => "fixme"), {:foo => "fixme", :bar => "bar"})
-        assert_equal(@default.named(:foo => "fixme", :bar => "woot"), {:foo => "fixme", :bar => "woot"})
-    end
+    assert_equal(@default.named, {:foo => "foo", :bar => "bar"})
+    assert_equal(@default.named(:foo => "fixme"), {:foo => "fixme", :bar => "bar"})
+    assert_equal(@default.named(:foo => "fixme", :bar => "woot"), {:foo => "fixme", :bar => "woot"})
+  end
 
-    def test_02_ordered
-        assert(@default.respond_to?(:ordered))
+  def test_02_ordered
+    assert(@default.respond_to?(:ordered))
 
-        assert_equal(@default.ordered, ["foo", "bar"])
-        assert_equal(@default.ordered("fixme"), ["fixme", "bar"])
-        assert_equal(@default.ordered("fixme", "woot"), ["fixme", "woot"])
-    end
+    assert_equal(@default.ordered, ["foo", "bar"])
+    assert_equal(@default.ordered("fixme"), ["fixme", "bar"])
+    assert_equal(@default.ordered("fixme", "woot"), ["fixme", "woot"])
+  end
 
-    def test_03_attr
-        assert(@default.respond_to?(:ml_attr))
+  def test_03_attr
+    assert(@default.respond_to?(:ml_attr))
 
-        assert_equal(@default.ml_attr, "foo")
-        @default.ml_attr = "bar"
-        assert_equal(@default.ml_attr, "bar")
-    end
+    assert_equal(@default.ml_attr, "foo")
+    @default.ml_attr = "bar"
+    assert_equal(@default.ml_attr, "bar")
+  end
 end

data/test/test_inline.rb

@@ -1,6 +1,6 @@
 begin
-    require 'rubygems'
-    gem 'test-unit'
+  require 'rubygems'
+  gem 'test-unit'
 rescue LoadError
 end
 
@@ -10,18 +10,34 @@ require 'test/unit'
 require 'methlab'
 
 class InlineTest
-    inline(:foo) { nil }
-    inline(:bar, :baz, :quux) { 1 }
+  extend MethLab
+
+  inline(:foo) { nil }
+  inline(:bar, :baz, :quux) { 1 }
+
+  attr_threaded_accessor(:one, :two)
 end
 
 class TestInline < Test::Unit::TestCase
-    def test_01_inline_works
-        it = InlineTest.new
+  def test_01_inline_works
+    it = InlineTest.new
 
-        assert_equal(nil, it.foo)
+    assert_equal(nil, it.foo)
 
-        [:bar, :baz, :quux].each do |meth|
-            assert_equal(1, it.send(meth))
-        end
+    [:bar, :baz, :quux].each do |meth|
+      assert_equal(1, it.send(meth))
     end
+  end
+
+  def test_02_attr_threaded_accessor
+    it = InlineTest.new
+
+    it.one = 1
+    it.two = 2
+
+    assert_equal(it.one, 1)
+    assert_equal(it.two, 2)
+    assert_equal(Thread.current[:one], 1)
+    assert_equal(Thread.current[:two], 2)
+  end
 end

data/test/test_integrate.rb

@@ -1,6 +1,6 @@
 begin
-    require 'rubygems'
-    gem 'test-unit'
+  require 'rubygems'
+  gem 'test-unit'
 rescue LoadError
 end
 
@@ -10,23 +10,23 @@ require 'test/unit'
 require 'methlab'
 
 class TestIntegrate < Test::Unit::TestCase
-    def test_01_integration
-        main = eval("self", TOPLEVEL_BINDING)
-        MethLab.integrate
+  def test_01_integration
+    main = eval("self", TOPLEVEL_BINDING)
+    MethLab.integrate
 
-        module_methods = Module.instance_methods
-        main_methods   = main.methods
+    module_methods = Module.instance_methods
+    main_methods   = main.methods
 
-        assert(module_methods.include?(:def_named)     || module_methods.include?("def_named"))
-        assert(module_methods.include?(:def_ordered)   || module_methods.include?("def_ordered"))
-        assert(module_methods.include?(:build_named)   || module_methods.include?("build_named"))
-        assert(module_methods.include?(:build_ordered) || module_methods.include?("build_ordered"))
-        assert(module_methods.include?(:inline)        || module_methods.include?("inline"))
+    assert(module_methods.include?(:def_named)     || module_methods.include?("def_named"))
+    assert(module_methods.include?(:def_ordered)   || module_methods.include?("def_ordered"))
+    assert(module_methods.include?(:build_named)   || module_methods.include?("build_named"))
+    assert(module_methods.include?(:build_ordered) || module_methods.include?("build_ordered"))
+    assert(module_methods.include?(:inline)        || module_methods.include?("inline"))
 
-        assert(main_methods.include?(:def_named)     || main_methods.include?("def_named"))
-        assert(main_methods.include?(:def_ordered)   || main_methods.include?("def_ordered"))
-        assert(main_methods.include?(:build_named)   || main_methods.include?("build_named"))
-        assert(main_methods.include?(:build_ordered) || main_methods.include?("build_ordered"))
-        assert(main_methods.include?(:inline)        || main_methods.include?("inline"))
-    end
+    assert(main_methods.include?(:def_named)     || main_methods.include?("def_named"))
+    assert(main_methods.include?(:def_ordered)   || main_methods.include?("def_ordered"))
+    assert(main_methods.include?(:build_named)   || main_methods.include?("build_named"))
+    assert(main_methods.include?(:build_ordered) || main_methods.include?("build_ordered"))
+    assert(main_methods.include?(:inline)        || main_methods.include?("inline"))
+  end
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: methlab
 version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 9
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors: 
 - Erik Hollensbe
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-26 00:00:00 -04:00
+date: 2010-06-16 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -44,23 +45,27 @@ 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.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A method construction and validation toolkit.