dyna_mo 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85938a7bd6853c94b9e45fb70cf3021d36144027
+  data.tar.gz: 9b5de78332444ee32c20d8222d5a1aa37fa9c485
+SHA512:
+  metadata.gz: 1aec6e1a6b02f58f13962d31191d2f6b755827cb78a64caa67d8093cac80121fdfc2e04567a3c82baa07af31ab41c16687bc09b6549c45a64a02a9ef3bb18a76
+  data.tar.gz: 7ce62a173331ceadeb40ac5c27772e3f6e199167adb23b0e8758586505ffa86ebd19e46ae1b87bec2b026a63f7bb928b7584c0a7e129327d3da78259663a5438

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dyna_mo.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TAGOMORI Satoshi
+
+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,270 @@
+# DynaMo: Testing module to provide dynamic scope method overriding
+
+Dynamic scope implementation for Method Overriding: override methods by specified context, only in current thread.
+
+**DON'T USE THIS GEM IN PRODUCTION CODE.**
+
+## What's this?
+
+To modify methods' behavior with its dynamic contexts, like this:
+
+```ruby
+require 'dyna_mo'
+ 
+module MyModule
+  class MyClass
+    attr_accessor :num
+    def initialize; @num = 0; end
+    def name; "name"; end
+    def sum(numbers); @num + numbers.reduce(:+); end
+  end
+end
+ 
+dynamo_define('MyModule::MyClass', :mytest_case_default) do
+  def_method(:initialize) do
+    @num = 1
+  end
+  
+  def_method(:name) do
+    "dummyname"
+  end
+  
+  def_instance_method(:name, :mytest_case1) do
+    "dummyname1"
+  end
+  
+  def_method(:sum) do |numbers|
+    @num + numbers.reduce(:+) + 1
+  end
+  
+  def_class_method(:create) do |init_num=0|
+    obj = self.new
+    obj.num = init_num
+    obj
+  end
+end
+ 
+class SynopsisTest < Test::Unit::TestCase
+  def test_synopsis
+    assert { MyModule::MyClass.new.name == "name" }
+
+    obj = MyModule::MyClass.new
+    
+    assert { obj.num == 0 }
+    assert { obj.name == "name" }
+    
+    dynamo_context(:mytest_case_default) do
+      assert { obj.num == 0 } # #initialize is not overridden
+      
+      assert { obj.name == "dummyname" }
+      assert { MyModule::MyClass.new.name == "dummyname" }
+      
+      assert { MyModule::MyClass.new.num == 1 }
+      
+      assert { MyModule::MyClass.new.sum([1,2,3]) == (1+(1+2+3)+1) }
+      
+      assert { MyModule::MyClass.create(100).num == 100 }
+    end
+    
+    dynamo_context(:mytest_case1) do
+      assert { obj.name == "dummyname1" }
+    end
+    
+    dynamo_define(MyModule::MyClass, :onetime_context) do
+      def_method(:name) do
+        "onetime"
+      end
+    end
+    
+    dynamo_context(:onetime_context) do
+      assert { obj.name == "onetime" }
+    end
+  end
+end
+ 
+module MyModule; class MyClass2 < MyClass; end; end
+ 
+class Synopsis2Test < Test::Unit::TestCase
+  def test_onece_more
+    dynamo_define(MyModule::MyClass, :onetime_context) do
+      def_method(:name) do
+        "onetime"
+      end
+    end
+    
+    dynamo_context(:onetime_context) do
+      assert { MyModule::MyClass2.new.name == "onetime" }
+    end
+  end
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dyna_mo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dyna_mo
+
+## Usage
+
+Require this module in `helper.rb` or anywhere you want in test code.
+
+```ruby
+require "dyna_mo"
+```
+
+### Kernel.dynamo_define(name_or_module_instance, default_context_name, &block)
+
+Create context to define instance methods and class methods of specified Module/Class.
+
+* `name_or_module_instance` accepts both of String or Module/Class instance. But string specification must be name from top-level, like `Net::HTTP` (or `::Net::HTTP`).
+
+Given block is evaluated with a receiver instance of `DynaMo::Contexts`.
+
+```ruby
+dynamo_define(MyClass, :test_awesome_situation) do
+  # ...
+end
+```
+
+### DynaMo::Contexts#def_instance_method(method_name, context_name = default_context_name, &block)
+
+Define instance method to override existing instance method, only in specified context. Instance variable reference like `@data` is handled correctly for each objects.
+
+`super` cannot be used in this block. Use `dynamo_super()` instead.
+
+Given block is to be method body, and prepended on specified Module/Class, not rewrite method itself. So we can call original method definition by `dynamo_super()`.
+
+```ruby
+ # in dynamo_define
+dynamo_instance_method(:data, :my_test_context) do |num|
+  @data * num
+end
+obj.instance_eval{ @data = "abc" }
+obj.data(3) #=> "abcabcabc"
+```
+
+The most recently called `#def_instance_method` have highest priority. It's for ad-hoc definition in test code.
+
+With `def_instance_method`, given block can have arguments of arbitrary number, not same with original definition. But it brings very confusing behavior (especially for `dynamo_super`), so it is not recommended for many cases.
+
+This method also can add method which does NOT exists in original Module/Class definition.
+
+### DynaMo::Contexts#def_method(...)
+
+Alias of `def_instance_method`.
+
+### DynaMo::Contexts#def_class_method(method_name, context_name = default_context_name, &block)
+
+Define class method. All other things are same with `define_instance_method`.
+
+### Kernel.dynamo_context(context_name, &block)
+
+Create dynamic scope in current thread for specified context name. Given block and lower stack calls run with overridden methods.
+
+```ruby
+require "dyna_mo"
+ 
+class A1; def self.label; "A"; end; end
+class A2 < A1; def self.label; (super) * 2; end; end
+ 
+dynamo_define(A1, :test) do
+  def_class_method(:label) do
+    "AB"
+  end
+end
+ 
+dynamo_context(:test) do
+  A2.label #=> "ABAB"
+  Thread.new { A2.label }.value #=> "AA"
+end
+```
+
+We can apply 2 or more contexts at the same time. If these contexts have definition for same method, the recent defined one is called at first.
+
+```ruby
+dynamo_define(A1, :test1) do
+  def_class_method(:label) do
+    "AB"
+  end
+  def_class_method(:label, :test2) do
+    "AC"
+  end
+  def_class_method(:label, :test3) do
+    "BC"
+  end
+end
+ 
+dynamo_context(:test2) do
+  dynamo_context(:test3) do
+    dynamo_context(:test1) do
+      A2.label #=> "BC"
+    end
+  end
+end
+```
+
+### Kernel.dynamo_super(*args)
+
+Use to call original method definition in overriding method body (block). `dyna_mo` method overriding is implemented with `Module.prepend`, so `dynamo_super()` calls original definition, not parent class's definition.
+
+With `dynamo_super`, all arguments must be specified explicitly.
+
+```ruby
+dynamo_define(A1, :test_default) do
+  def_method(:name) do |prefix|
+    prefix + dynamo_super()
+  end
+end
+```
+
+If you use this method with applying multi contexts, `dynamo_super()` calls each overriding method bodies, like this:
+
+```ruby
+dynamo_define(A1, :test1) do
+  def_class_method(:label) do
+    "1" + dynamo_super()
+  end
+  def_class_method(:label, :test2) do
+    "2" + dynamo_super()
+  end
+  def_class_method(:label, :test3) do
+    "3" + dynamo_super()
+  end
+end
+
+dynamo_context(:test1) do
+  dynamo_context(:test2) do
+    dynamo_context(:test3) do
+      # A1.label/test3 -> A1.label/test2 -> A1.label/test1 -> A1.label/(original)
+      A1.label  #=> "321A"
+    end
+  end
+end
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/dyna_mo/fork )
+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 a new Pull Request
+
+## Copyright
+
+* License
+ * MIT
+* Author
+ * @tagomoris
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/dyna_mo.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dyna_mo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dyna_mo"
+  spec.version       = DynaMo::VERSION
+  spec.authors       = ["TAGOMORI Satoshi"]
+  spec.email         = ["tagomoris@gmail.com"]
+  spec.summary       = %q{Testing module to provide dynamic scope method overriding}
+  spec.description   = %q{Dynamic scope implementation for Method Overriding: override methods by specified context, only in current thread}
+  spec.homepage      = "https://github.com/tagomoris/dyna_mo"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "test-unit", "~> 3.0"
+  spec.add_development_dependency "test-unit-power_assert"
+end

data/example/for_testing.rb

@@ -0,0 +1,84 @@
+require 'dyna_mo'
+
+module MyModule # External module definition (other's gem)
+  class MyClass
+    attr_accessor :num
+
+    def initialize
+      @num = 0
+    end
+
+    def name
+      "name"
+    end
+
+    def sum(numbers)
+      @num + numbers.reduce(:+)
+    end
+  end
+end
+
+## use "dynamo_super()" to call super in dynamo overriding
+
+# in test helper
+dynamo_define('MyModule::MyClass', default_context = :mytest_case_default) do
+  def_method(:initialize) do # == def_instance_method
+    @num = 1
+  end
+
+  def_method(:name) do # arity == 0, default context
+    "dummyname"
+  end
+
+  def_instance_method(:name, :mytest_case1) do
+    "dummyname1"
+  end
+
+  def_method(:sum) do |numbers|
+    @num + numbers.reduce(:+)
+  end
+
+  # define method only in :mytest_case_default context
+  def_singleton_method(:create) do |init_num=0|
+    obj = self.new
+    obj.num = init_num
+    obj
+  end
+end
+
+# test code
+class MyTestCase < Test::Unit::TestCase
+  def test_name
+    assert_equal "name", MyModule::MyClass.new.name
+
+    obj = MyModule::MyClass.new
+
+    assert_equal 0, obj.num
+    assert_equal "name", obj.name
+
+    dynamo_context(:mytest_case_default) do
+      assert_equal 0, obj.num # not overridden
+
+      assert_equal "dummyname", obj.name
+      assert_equal "dummyname", MyModule::MyClass.new.name
+
+      assert_equal 1, MyModule::MyClass.new.num
+
+      assert_equal 100, MyModule::MyClass.create(100).num
+    end
+
+    dynamo_context(:mytest_case1) do
+      assert_equal "dummyname1", obj.name
+    end
+
+    dynamo_define(MyModule::MyClass, :onetime_context) do
+      def_method(:name) do
+        "onetime"
+      end
+    end
+
+    dynamo_context(:onetime_context) do
+      assert_equal "onetime", obj.name
+    end
+  end
+end

data/lib/dyna_mo.rb

@@ -0,0 +1,18 @@
+require "dyna_mo/version"
+
+require "dyna_mo/module"
+
+module DynaMo
+  # constants or ...
+end
+
+require "dyna_mo/contexts"
+# DynaMo::Contexts
+#   #def_instance_method(method_name, context_name=default_context_name, &block)
+#   #def_singleton_method(method_name, context_name=default_context_name, &block)
+#   #def_method -> #def_instance_method
+
+require "dyna_mo/environment"
+# Kernel.dynamo_define(target_name_or_instance, default_context_name_sym, &block)
+# Kernel.dynamo_context(context_name, &block)
+# Kernel.dynamo_super(*args)

data/lib/dyna_mo/contexts.rb

@@ -0,0 +1,42 @@
+require "dyna_mo/override_method"
+
+module DynaMo
+  class Contexts < BasicObject
+    attr_reader :module_name
+    attr_accessor :default_context_name
+
+    def initialize(mod_name, default_context_name)
+      # mod_name MUST be string here to assure target module_name consistency
+      @module_name = (mod_name =~ /^::/ ? mod_name : '::' + mod_name)
+      @default_context_name = default_context_name.to_sym
+
+      @instance_method_mods = []
+      @class_method_mods = []
+    end
+
+    def __apply__
+      target = ::Kernel.eval(@module_name)
+
+      # reverse: Last defined context's method priority is highest
+      target.prepend( *(@instance_method_mods.reverse.map(&:applied_module)) )
+      (class << target; self; end).prepend( *(@class_method_mods.reverse.map(&:applied_module)) )
+
+      # prepending twice has no effects
+    end
+
+    def def_instance_method(method_name, context_name = @default_context_name, &block)
+      raise "block is not given for def_instance_method" unless block # block_given?
+
+      @instance_method_mods.push OverrideMethod.new(context_name.to_sym, method_name, &block)
+      method_name
+    end
+    alias :def_method :def_instance_method
+
+    def def_class_method(method_name, context_name = @default_context_name, &block)
+      raise "block is not given for def_singleton_method" unless block #_given?
+
+      @class_method_mods.push OverrideMethod.new(context_name.to_sym, method_name, &block)
+      method_name
+    end
+  end
+end

data/lib/dyna_mo/environment.rb

@@ -0,0 +1,66 @@
+require "dyna_mo/contexts"
+
+module DynaMo
+  module Environment
+    @@contexts_store = {}
+    @@contexts_mutex = Mutex.new
+
+    def self.synchronize
+      @@contexts_mutex.synchronize do
+        yield
+      end
+    end
+
+    def self.contexts(name, default_context_name)
+      context = ( @@contexts_store[name] ||= DynaMo::Contexts.new(name, default_context_name) )
+      context.default_context_name = default_context_name
+      context
+    end
+
+    def self.apply_environment
+      @@contexts_store.each do |name, contexts|
+        contexts.__apply__
+      end
+      true
+    end
+  end
+end
+
+module Kernel
+  def dynamo_define(target_name_or_instance, default_context_name, &block)
+    raise "block is not given for dynamo_define" unless block_given?
+    # target_name_or_instance accepts module instance, to help programmer to avoid typo
+    target = target_name_or_instance.is_a?(Module) ? target_name_or_instance.name : target_name_or_instance.to_s
+    ::DynaMo::Environment.synchronize do
+      # get/create context object and evaluate block with it
+      context = ::DynaMo::Environment.contexts(target, default_context_name)
+      context.instance_exec(&block)
+    end
+  end
+
+  def dynamo_context(context_name, &block)
+    raise "block is not given for dynamo_context" unless block_given?
+    # get context, apply context and yield block
+    ::DynaMo::Environment.synchronize do
+      ::DynaMo::Environment.apply_environment
+    end
+    Thread.current[:dynamo_contexts] ||= {}
+    Thread.current[:dynamo_contexts][context_name] = true
+    begin
+      yield
+    ensure
+      Thread.current[:dynamo_contexts].delete(context_name)
+    end
+  end
+
+  def dynamo_super(*args)
+    Thread.current[:dynamo_stack].last.call(*args)
+  end
+
+  ## This method is to call `super` just like in original definition,
+  ## without calls of any other contexts' definition and original method definition
+  # def dynamo_ultra_super(*args)
+  #   # But, we need Method#super_method and something to get Method object now running...
+  #   raise NotImplementedError, "We need Kernel.current_method"
+  # end
+end

data/lib/dyna_mo/module.rb

@@ -0,0 +1,5 @@
+class Module
+  def prepend?(mod)
+    self.ancestors.include?(mod) && self.ancestors.index(mod) < self.ancestors.index(self)
+  end
+end

data/lib/dyna_mo/override_method.rb

@@ -0,0 +1,42 @@
+module DynaMo
+  class OverrideMethod
+    attr_reader :context, :name
+
+    def initialize(context, name, &block)
+      @context = context.to_sym
+      @name = name.to_sym
+      @override = block
+
+      @mod = nil
+    end
+
+    def applied_module
+      return @mod if @mod
+
+      mod = Module.new
+      mod.__send__(:define_method, @name, self.to_proc)
+      @mod = mod
+    end
+
+    def to_proc
+      context = @context
+      override = @override
+
+      -> (*args) {
+        Thread.current[:dynamo_contexts] ||= {}
+        Thread.current[:dynamo_stack] ||= []
+
+        if Thread.current[:dynamo_contexts][context]
+          Thread.current[:dynamo_stack].push(-> (*args) { super(*args) })
+          begin
+            instance_exec(*args, &override)
+          ensure
+            Thread.current[:dynamo_stack].pop
+          end
+        else
+          super(*args)
+        end
+      }
+    end
+  end
+end

data/lib/dyna_mo/version.rb

@@ -0,0 +1,3 @@
+module DynaMo
+  VERSION = "0.0.1"
+end

data/test/helper.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'test/unit/power_assert'
+
+def virtual_dynamo_context(name)
+  Thread.current[:dynamo_contexts] ||= {}
+  Thread.current[:dynamo_contexts][name] = true
+  begin
+    yield
+  ensure
+    Thread.current[:dynamo_contexts].delete(name)
+  end
+end
+
+def virtual_dynamo_super(*args)
+  Thread.current[:dynamo_stack].last.call(*args)
+end

data/test/test_basic.rb

@@ -0,0 +1,89 @@
+require 'helper'
+require 'dyna_mo'
+
+module MyModule
+  class MyClass
+    attr_accessor :num
+    def initialize; @num = 0; end
+    def name; "name"; end
+    def sum(numbers); @num + numbers.reduce(:+); end
+  end
+end
+
+dynamo_define('MyModule::MyClass', :mytest_case_default) do
+  def_method(:initialize) do
+    @num = 1
+  end
+
+  def_method(:name) do
+    "dummyname"
+  end
+
+  def_instance_method(:name, :mytest_case1) do
+    "dummyname1"
+  end
+
+  def_method(:sum) do |numbers|
+    @num + numbers.reduce(:+) + 1
+  end
+
+  def_class_method(:create) do |init_num=0|
+    obj = self.new
+    obj.num = init_num
+    obj
+  end
+end
+
+class SynopsisTest < Test::Unit::TestCase
+  def test_synopsis
+    assert { MyModule::MyClass.new.name == "name" }
+
+    obj = MyModule::MyClass.new
+
+    assert { obj.num == 0 }
+    assert { obj.name == "name" }
+
+    dynamo_context(:mytest_case_default) do
+      assert { obj.num == 0 } # #initialize is not overridden
+
+      assert { obj.name == "dummyname" }
+      assert { MyModule::MyClass.new.name == "dummyname" }
+
+      assert { MyModule::MyClass.new.num == 1 }
+
+      assert { MyModule::MyClass.new.sum([1,2,3]) == (1+(1+2+3)+1) }
+
+      assert { MyModule::MyClass.create(100).num == 100 }
+    end
+
+    dynamo_context(:mytest_case1) do
+      assert { obj.name == "dummyname1" }
+    end
+
+    dynamo_define(MyModule::MyClass, :onetime_context) do
+      def_method(:name) do
+        "onetime"
+      end
+    end
+
+    dynamo_context(:onetime_context) do
+      assert { obj.name == "onetime" }
+    end
+  end
+end
+
+module MyModule; class MyClass2 < MyClass; end; end
+
+class Synopsis2Test < Test::Unit::TestCase
+  def test_onece_more
+    dynamo_define(MyModule::MyClass, :onetime_context) do
+      def_method(:name) do
+        "onetime"
+      end
+    end
+
+    dynamo_context(:onetime_context) do
+      assert { MyModule::MyClass2.new.name == "onetime" }
+    end
+  end
+end

data/test/test_contexts.rb

@@ -0,0 +1,136 @@
+require 'helper'
+require 'dyna_mo/contexts'
+
+module Foo
+  class Bar
+    def self.label
+      "baz"
+    end
+    def text
+      "foobar"
+    end
+    def concat(a, b, separator=".")
+      a + separator + b
+    end
+  end
+
+  class Baz < Bar
+    def text
+      (super) + "baz"
+    end
+  end
+end
+
+class ContextsTest < Test::Unit::TestCase
+  def test_instance_method_contexts
+    cxt = DynaMo::Contexts.new('Foo::Bar', :test_i0)
+    cxt.def_instance_method(:text) do # default context name
+      "foobar0"
+    end
+    cxt.def_instance_method(:text, :test_i1) do
+      "foobar1"
+    end
+    cxt.def_instance_method(:text, :test_i2) do |x| # special argument for test
+      "foobar2:" + x
+    end
+
+    cxt.__apply__
+
+    assert { Foo::Bar.new.text == "foobar" }
+    virtual_dynamo_context(:test_i0) do
+      assert { Foo::Bar.new.text == "foobar0" }
+    end
+    virtual_dynamo_context(:test_i1) do
+      assert { Foo::Bar.new.text == "foobar1" }
+    end
+    virtual_dynamo_context(:test_i2) do
+      assert { Foo::Bar.new.text("z") == "foobar2:z" }
+    end
+
+    cxt.def_method(:text, :test_i0) do
+      "foobar_zero"
+    end
+
+    cxt.__apply__
+
+    assert { Foo::Bar.new.text == "foobar" }
+    virtual_dynamo_context(:test_i0) do
+      assert { Foo::Bar.new.text == "foobar_zero" }
+    end
+    virtual_dynamo_context(:test_i1) do
+      assert { Foo::Bar.new.text == "foobar1" }
+    end
+    virtual_dynamo_context(:test_i2) do
+      assert { Foo::Bar.new.text("z") == "foobar2:z" }
+    end
+
+    # 2 or more dynamo contexts work well: last defined method is prior
+    virtual_dynamo_context(:test_i0) do
+      virtual_dynamo_context(:test_i1) do
+        assert { Foo::Bar.new.text == "foobar_zero" }
+      end
+    end
+  end
+
+  def test_for_subclass
+    cxt1 = DynaMo::Contexts.new('Foo::Bar', :test_s0)
+    cxt1.def_instance_method(:text, :test_s1) do
+      "foobar1"
+    end
+    cxt1.def_instance_method(:text) do # default context name
+      "foobar0"
+    end
+    # test_s0 is prior for Foo::Bar
+
+    cxt1.__apply__
+
+    # subclass methods are prior, and prepended methods, original methods
+    assert { Foo::Baz.new.text == "foobarbaz" }
+    virtual_dynamo_context(:test_s0) do
+      assert { Foo::Baz.new.text == "foobar0baz" }
+    end
+    virtual_dynamo_context(:test_s1) do
+      assert { Foo::Baz.new.text == "foobar1baz" }
+    end
+  end
+
+  def test_multi_context_and_threads
+    cxt1 = DynaMo::Contexts.new('Foo::Bar', :test_m0)
+    cxt1.def_instance_method(:text, :test_m1) do
+      "foobar1"
+    end
+    cxt1.def_instance_method(:text) do # default context name
+      "foobar0"
+    end
+    # test_m0 is prior for Foo::Bar
+
+    cxt1.__apply__
+
+    cxt2 = DynaMo::Contexts.new('Foo::Baz', :test_m0)
+    cxt2.def_method(:text) do
+      virtual_dynamo_super() + " baz0"
+    end
+    cxt2.def_method(:text, :test_m1) do
+      virtual_dynamo_super() + " baz1"
+    end
+    # test_m1 is prior for Foo:Baz
+
+    cxt2.__apply__
+
+    virtual_dynamo_context(:test_m0) do
+      virtual_dynamo_context(:test_m1) do
+        # Baz/test_m1 -> Baz/test_m0 -> Baz/origin -> Bar/test_m0
+        assert { Foo::Baz.new.text == "foobar0baz baz0 baz1" }
+
+        # Other thread does NOT accept any effects
+        val1 = Thread.new { Foo::Baz.new.text }.value
+        assert { val1 == "foobarbaz" }
+
+        # Other thread can apply other context
+        # Baz/test_m1 -> Baz/origin -> Bar/test_m1 (without test_m0)
+        val2 = Thread.new { virtual_dynamo_context(:test_m1) { Foo::Baz.new.text } }.value
+        assert { val2 == "foobar1baz baz1" }
+      end
+    end
+  end
+end

data/test/test_override_method.rb

@@ -0,0 +1,106 @@
+require "helper"
+require "dyna_mo/override_method"
+
+class Target1
+  def self.label
+    "target1"
+  end
+
+  def initialize
+    @n = 1
+  end
+
+  def name
+    "target#{@n}"
+  end
+end
+
+class Target2 < Target1
+  def self.label
+    super
+  end
+
+  def initialize
+    @n = 2
+  end
+end
+
+class OverrideMethodTest < Test::Unit::TestCase
+  def test_applied_module_returns_unique_instance
+    m1 = DynaMo::OverrideMethod.new(:test_applied_module, :foo) do
+      "foo"
+    end
+    obj1 = m1.applied_module
+    assert { obj1.object_id == m1.applied_module.object_id }
+  end
+
+  def test_instance_methods
+    t1 = Target1.new
+    assert { t1.name == "target1" }
+
+    m1 = DynaMo::OverrideMethod.new(:test_instance_methods, :name) do
+      "p#{@n}:" + virtual_dynamo_super()
+    end
+
+    Target1.send(:prepend, m1.applied_module)
+
+    assert { t1.name == "target1" }
+    virtual_dynamo_context(:test_instance_methods) do
+      assert { t1.name == "p1:target1" }
+    end
+    assert { t1.name == "target1" }
+
+    m2 = DynaMo::OverrideMethod.new(:test_instance_methods, :initialize) do
+      @n = 1111
+    end
+    Target2.prepend(m2.applied_module)
+    t2 = Target2.new
+
+    assert { t1.name == "target1" }
+    virtual_dynamo_context(:test_instance_methods) do
+      assert { t1.name == "p1:target1" }
+      assert { t2.name == "p2:target2" }
+    end
+    assert { t1.name == "target1" }
+
+    virtual_dynamo_context(:test_instance_methods) do
+      assert { Target1.new.name == "p1:target1" }
+      assert { Target2.new.name == "p1111:target1111" }
+    end
+  end
+
+  def test_class_methods
+    assert { Target1.label == "target1" }
+
+    m1 = DynaMo::OverrideMethod.new(:test_class_methods, :label) do
+      "p1:target1"
+    end
+
+    mod1 = m1.applied_module
+    (class << Target1; self; end).send(:prepend, mod1)
+
+    assert { Target1.label == "target1" }
+    virtual_dynamo_context(:test_class_methods) do
+      assert { Target1.label == "p1:target1" }
+    end
+    assert { Target1.label == "target1" }
+
+    # Target2.label is equal to Target1.self
+    assert { Target2.label == "target1" }
+    virtual_dynamo_context(:test_class_methods) do
+      assert { Target2.label == "p1:target1" }
+    end
+    assert { Target2.label == "target1" }
+
+    m2 = DynaMo::OverrideMethod.new(:test_class_methods, :label) do
+      virtual_dynamo_super().gsub(/1/, '2')
+    end
+    (class << Target2; self; end).send(:prepend, m2.applied_module)
+
+    assert { Target2.label == "target1" }
+    virtual_dynamo_context(:test_class_methods) do
+      assert { Target2.label == "p2:target2" }
+    end
+    assert { Target2.label == "target1" }
+  end
+end

data/test/test_prepend.rb

@@ -0,0 +1,69 @@
+require 'helper'
+require 'dyna_mo/module'
+
+class ModulePrependTest < Test::Unit::TestCase
+  module P1
+    def name
+      val = super
+      "p1:" + val
+    end
+  end
+
+  module P2
+    def name
+      val = super
+      "p2:" + val
+    end
+  end
+
+  class X
+    def name
+      "x"
+    end
+  end
+
+  class Y < X
+    def name
+      "y"
+    end
+  end
+
+  def test_base
+    assert { X.new.name == "x" }
+    assert { Y.new.name == "y" }
+  end
+
+  def test_normal_prepend
+    X.send(:prepend, P1)
+
+    assert { X.new.name == "p1:x" }
+    assert X.include?(P1)
+    assert X.prepend?(P1)
+
+    assert { Y.new.name == "y" } # not prepend
+    assert Y.include?(P1)
+    assert (not Y.prepend?(P1))
+
+    Y.send(:prepend, P2)
+
+    assert { Y.new.name == "p2:y" }
+    assert Y.include?(P2)
+    assert Y.prepend?(P2)
+  end
+
+  def test_prepend_duplicated_module
+    assert X.prepend?(P1)
+    assert (not Y.prepend?(P1))
+    assert Y.prepend?(P2)
+
+    assert { Y.new.name == "p2:y" }
+    dup_mod = P1.dup
+
+    Y.send(:prepend, dup_mod)
+
+    assert Y.prepend?(dup_mod)
+    assert { Y.new.name == "p1:p2:y" }
+  end
+end
+
+

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: dyna_mo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- TAGOMORI Satoshi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit-power_assert
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'Dynamic scope implementation for Method Overriding: override methods
+  by specified context, only in current thread'
+email:
+- tagomoris@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dyna_mo.gemspec
+- example/for_testing.rb
+- lib/dyna_mo.rb
+- lib/dyna_mo/contexts.rb
+- lib/dyna_mo/environment.rb
+- lib/dyna_mo/module.rb
+- lib/dyna_mo/override_method.rb
+- lib/dyna_mo/version.rb
+- test/helper.rb
+- test/test_basic.rb
+- test/test_contexts.rb
+- test/test_override_method.rb
+- test/test_prepend.rb
+homepage: https://github.com/tagomoris/dyna_mo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Testing module to provide dynamic scope method overriding
+test_files:
+- test/helper.rb
+- test/test_basic.rb
+- test/test_contexts.rb
+- test/test_override_method.rb
+- test/test_prepend.rb
+has_rdoc: