masterview 0.1.5 → 0.2.0

data/test/unit/file_mio_test.rb

@@ -0,0 +1,368 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+currentPath = File.dirname(__FILE__)
+require File.join( currentPath, '../../lib/masterview/io' )
+
+class TestFileMIO < Test::Unit::TestCase
+  include MasterView
+
+  MVTestDir = File.expand_path( File.join(File.dirname(__FILE__), '..' ) )
+  TemplateDir = "#{MVTestDir}/tmp/template"
+  TemplateErbDir = "#{MVTestDir}/tmp/erb"
+
+  TestFileMIOTemplatePathname = Pathname.new(TemplateDir)
+  ErbPathname = Pathname.new(TemplateErbDir)
+
+  HelloWorldPath = 'hello_world.txt'
+  HelloWorldFullPath = "#{TemplateDir}/hello_world.txt"
+  TestWritePath = 'foo.txt'
+  TestWriteFullPath = "#{TemplateDir}/foo.txt"
+  TestWritePathname = Pathname.new(TestWriteFullPath)
+
+  IOMgr = MIOTrees.new
+
+  def setup
+    IOMgr.template = FileMIOTree.new(TemplateDir, '.html')
+    IOMgr.erb = FileMIOTree.new(TemplateErbDir, '.rhtml' )
+    IOMgr.file = FileMIOTree.new()
+
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+    ErbPathname.rmtree if ErbPathname.exist?
+    TestFileMIOTemplatePathname.mkpath
+    ErbPathname.mkpath
+  end
+
+#------------------------------------------------------------------------------
+# Test Cases
+#------------------------------------------------------------------------------
+
+  # ensure that sandbox limits writing to files outside of root path even if dot dot exists in path
+  def test_sandbox_dotdot 
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( '../bad') }
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( 'bad/../dog/../../foo') }
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( 'bad/../../foo') }
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( 'bad/cat/../../../dog') }
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( '/bad/foo') }
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( '/bad') }
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( '../bad.cat') }
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( 'bad/../dot/../../foo.cat') }
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( 'bad/../../foo.cat') }
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( 'bad/cat/../../../dog.cat') }
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( '/bad/foo.cat') }
+    assert_raise(InvalidPathError){ f = IOMgr.template.path( '/bad.cat') }
+  end
+
+  def test_create_foo
+    verify_mio_handler_paths( 'foo', IOMgr.template, TemplateDir )
+  end
+
+  def test_create_bar
+    verify_mio_handler_paths( 'bar', IOMgr.erb, TemplateErbDir )
+  end
+
+  def test_create_cat
+    verify_mio_handler_paths( 'cat', IOMgr.file, Pathname.getwd.to_str )
+  end
+
+  def test_create_foo_w_ext
+    verify_mio_handler_paths( 'foo.txt', IOMgr.template, TemplateDir )
+  end
+
+  def test_create_parts
+    verify_mio_handler_paths( 'sub/one/two/three/foo.txt', IOMgr.template, TemplateDir )
+  end
+
+  def test_read
+    TestFileMIOTemplatePathname.mkpath unless TestFileMIOTemplatePathname.exist?
+
+    file_content = "hello\nworld"
+    # write to abs pathname, ensure handler resolves rel pathname properly
+    File.open( HelloWorldFullPath, 'w' ){ |file| file.write(file_content) }
+    verify_mio_handler_read( HelloWorldPath, HelloWorldFullPath, file_content, IOMgr.template )
+  end
+
+  def test_read_disable_cache
+    TestFileMIOTemplatePathname.mkpath unless TestFileMIOTemplatePathname.exist?
+
+    file_content = "hello\nworld"
+    # write to abs pathname, ensure handler resolves rel pathname properly
+    File.open( HelloWorldFullPath, 'w' ){ |file| file.write(file_content) }
+    verify_mio_handler_read( HelloWorldPath, HelloWorldFullPath, file_content, IOMgr.template )
+
+    file_content_changed = "foo\nbar"
+    File.open( HelloWorldFullPath, 'w' ){ |file| file.write(file_content_changed) }
+    #verify_mio_handler_read( HelloWorldPath, file_content, IOMgr.template ) # still hitting cache #todo turn this on when caching is ready for testing   
+    verify_mio_handler_read_no_cache( HelloWorldPath, HelloWorldFullPath, file_content_changed, IOMgr.template )    
+  end
+
+  def test_write_string
+    TestWritePathname.delete if TestWritePathname.exist?
+
+    file_content = "foo\nbar"
+    IOMgr.template.path( TestWritePath ).write(file_content)
+    verify_mio_handler_read( TestWritePath, TestWriteFullPath, file_content, IOMgr.template )
+  end
+
+  def test_write_strings
+    TestWritePathname.delete if TestWritePathname.exist?
+
+    file_content = "foo\nbar"
+    IOMgr.template.path( TestWritePath ).write(file_content)
+    verify_mio_handler_read( TestWritePath, TestWriteFullPath, file_content, IOMgr.template )
+  end
+
+  def test_write_block
+    TestWritePathname.delete if TestWritePathname.exist?
+
+    file_content = "hello"
+    IOMgr.template.path( TestWritePath ).write { |f| f.write(file_content) }
+    verify_mio_handler_read( TestWritePath, TestWriteFullPath, file_content, IOMgr.template )
+  end
+
+  def test_write_strings_and_block
+    TestWritePathname.delete if TestWritePathname.exist?
+
+    file_content_strings = [ 'hello', 'world']
+    file_content = file_content_strings.join('')
+    IOMgr.template.path( TestWritePath).write do |f| 
+      file_content_strings.each { |str| f.write(str) }
+    end
+    verify_mio_handler_read( TestWritePath, TestWriteFullPath, file_content, IOMgr.template )
+  end
+
+  def test_write_mkpath
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+
+    file_content = "foo\nbar"
+    IOMgr.template.path( TestWritePath ).write(file_content)
+    verify_mio_handler_read( TestWritePath, TestWriteFullPath, file_content, IOMgr.template )
+  end
+
+  def test_exist
+    file_content = "foo"
+
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+    assert_equal false, IOMgr.template.path( TestWritePath).exist?
+    IOMgr.template.path( TestWritePath).write(file_content)
+    assert_equal true, IOMgr.template.path( TestWritePath).exist?
+
+    TestWritePathname.delete if TestWritePathname.exist?
+    assert_equal false, IOMgr.template.path( TestWritePath).exist?
+    IOMgr.template.path( TestWritePath).write(file_content)
+    assert_equal true, IOMgr.template.path( TestWritePath).exist?
+  end
+
+  def test_identical
+    file_content = "hello\nworld"
+    file_content_foo = "foo"
+
+    TestWritePathname.delete if TestWritePathname.exist?
+    assert_equal false, IOMgr.template.path( TestWritePath ).identical?(file_content)
+    TestFileMIOTemplatePathname.mkpath unless TestFileMIOTemplatePathname.exist?
+    File.open(TestWriteFullPath, 'w'){ |file| file.write(file_content) }
+    assert_equal true, IOMgr.template.path( TestWritePath).identical?(file_content)
+    assert_equal false, IOMgr.template.path( TestWritePath).identical?("foo")
+  end
+
+  def test_mtime
+    file_content = "hello\nworld"
+
+    TestWritePathname.delete if TestWritePathname.exist?
+    TestFileMIOTemplatePathname.mkpath unless TestFileMIOTemplatePathname.exist?
+    File.open(TestWriteFullPath, 'w'){ |file| file.write(file_content) }
+    assert_equal TestWritePathname.mtime, IOMgr.template.path( TestWritePath).mtime
+  end
+
+  def test_findfiles_single_dir
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+    IOMgr.template.path( 'apple.txt').write('foo')
+    IOMgr.template.path( 'bar.txt').write('foo')
+    File.open(TestFileMIOTemplatePathname+'baz.txt', 'w'){ |file| file.write('foo') }
+    found = IOMgr.template.find
+    assert_equal 3, found.length
+    assert_equal FileMIO, found[0].class
+    assert_equal FileMIO, found[1].class
+    assert_equal FileMIO, found[2].class
+    assert_equal (TestFileMIOTemplatePathname+'apple.txt').to_s, found[0].full_pathname.to_s
+    assert_equal 'apple.txt', found[0].pathname.to_s
+    assert_equal 'bar.txt', found[1].pathname.to_s
+    assert_equal 'baz.txt', found[2].pathname.to_s
+  end
+
+  def test_findfiles_single_sub_dir
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+    IOMgr.template.path( 'sub/apple.txt').write('foo')
+    IOMgr.template.path( 'sub/bar.txt').write('foo')
+    File.open(TestFileMIOTemplatePathname+'sub/baz.txt', 'w'){ |file| file.write('foo') }
+    found = IOMgr.template.find(:path => 'sub')
+    assert_equal 3, found.length
+    assert_equal FileMIO, found[0].class
+    assert_equal FileMIO, found[1].class
+    assert_equal FileMIO, found[2].class
+    assert_equal (TestFileMIOTemplatePathname+'sub/apple.txt').to_s, found[0].full_pathname.to_s
+    assert_equal 'sub/apple.txt', found[0].pathname.to_s
+    assert_equal 'sub/bar.txt', found[1].pathname.to_s
+    assert_equal 'sub/baz.txt', found[2].pathname.to_s
+  end
+
+  def test_findfiles_single_sub2_dir_multi_arg
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+    IOMgr.template.path( 'sub/two/apple.txt').write('foo')
+    IOMgr.template.path( 'sub/two/bar.txt').write('foo')
+    File.open(TestFileMIOTemplatePathname+'sub/two/baz.txt', 'w'){ |file| file.write('foo') }
+    found = IOMgr.template.find(:path => 'sub/two')
+    assert_equal 3, found.length
+    assert_equal FileMIO, found[0].class
+    assert_equal FileMIO, found[1].class
+    assert_equal FileMIO, found[2].class
+    assert_equal (TestFileMIOTemplatePathname+'sub/two/apple.txt').to_s, found[0].full_pathname.to_s
+    assert_equal 'sub/two/apple.txt', found[0].pathname.to_s
+    assert_equal 'sub/two/bar.txt', found[1].pathname.to_s
+    assert_equal 'sub/two/baz.txt', found[2].pathname.to_s
+  end
+
+  def test_findfiles_single_sub2_dir_single_arg
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+    IOMgr.template.path( 'sub/two/apple.txt').write('foo')
+    IOMgr.template.path( 'sub/two/bar.txt').write('foo')
+    File.open(TestFileMIOTemplatePathname+'sub/two/baz.txt', 'w'){ |file| file.write('foo') }
+    found = IOMgr.template.find(:path => 'sub/two')
+    assert_equal 3, found.length
+    assert_equal FileMIO, found[0].class
+    assert_equal FileMIO, found[1].class
+    assert_equal FileMIO, found[2].class
+    assert_equal (TestFileMIOTemplatePathname+'sub/two/apple.txt').to_s, found[0].full_pathname.to_s
+    assert_equal 'sub/two/apple.txt', found[0].pathname.to_s
+    assert_equal 'sub/two/bar.txt', found[1].pathname.to_s
+    assert_equal 'sub/two/baz.txt', found[2].pathname.to_s
+  end
+
+  def test_findfiles_single_dir_pattern 
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+    IOMgr.template.path( 'sub/two/apple.txt').write('foo')
+    IOMgr.template.path( 'sub/two/bar.log').write('foo')
+    File.open(TestFileMIOTemplatePathname+'sub/two/baz.txt', 'w'){ |file| file.write('foo') }
+    found = IOMgr.template.find(:path => 'sub/two', :pattern => '*.txt')
+    assert_equal 2, found.length
+    assert_equal FileMIO, found[0].class
+    assert_equal FileMIO, found[1].class
+    assert_equal (TestFileMIOTemplatePathname+'sub/two/apple.txt').to_s, found[0].full_pathname.to_s
+    assert_equal 'sub/two/apple.txt', found[0].pathname.to_s
+    assert_equal 'sub/two/baz.txt', found[1].pathname.to_s
+  end
+
+  def test_findfiles_multi_dir_root 
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+    IOMgr.template.path( 'one/two/three.txt').write('foo')
+    IOMgr.template.path( 'sub/two/apple.txt').write('foo')
+    IOMgr.template.path( 'sub/two/bar.log').write('foo')
+    File.open(TestFileMIOTemplatePathname+'sub/two/baz.txt', 'w'){ |file| file.write('foo') }
+    found = IOMgr.template.find
+    assert_equal 4, found.length
+    assert_equal FileMIO, found[0].class
+    assert_equal FileMIO, found[1].class
+    assert_equal FileMIO, found[2].class
+    assert_equal FileMIO, found[3].class
+    assert_equal (TestFileMIOTemplatePathname+'one/two/three.txt').to_s, found[0].full_pathname.to_s
+    assert_equal 'one/two/three.txt', found[0].pathname.to_s
+    assert_equal 'sub/two/apple.txt', found[1].pathname.to_s
+    assert_equal 'sub/two/bar.log', found[2].pathname.to_s
+    assert_equal 'sub/two/baz.txt', found[3].pathname.to_s
+  end
+
+  def test_findfiles_multi_dir_pattern 
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+    IOMgr.template.path( 'one/two/three.txt').write('foo')
+    IOMgr.template.path( 'sub/two/apple.txt').write('foo')
+    IOMgr.template.path( 'sub/two/bar.log').write('foo')
+    File.open(TestFileMIOTemplatePathname+'sub/two/baz.txt', 'w'){ |file| file.write('foo') }
+    found = IOMgr.template.find(:pattern => '*.txt')
+    assert_equal 3, found.length
+    assert_equal FileMIO, found[0].class
+    assert_equal FileMIO, found[1].class
+    assert_equal FileMIO, found[2].class
+    assert_equal (TestFileMIOTemplatePathname+'one/two/three.txt').to_s, found[0].full_pathname.to_s
+    assert_equal 'one/two/three.txt', found[0].pathname.to_s
+    assert_equal 'sub/two/apple.txt', found[1].pathname.to_s
+    assert_equal 'sub/two/baz.txt', found[2].pathname.to_s
+  end
+
+  def test_findfiles_multi_dir_pattern_deep 
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+    IOMgr.template.path( 'one/two/three.txt').write('foo')
+    IOMgr.template.path( 'sub/two/apple.txt').write('foo')
+    IOMgr.template.path( 'sub/two/bar.log').write('foo')
+    File.open(TestFileMIOTemplatePathname+'sub/two/baz.txt', 'w'){ |file| file.write('foo') }
+    found = IOMgr.template.find(:path => 'sub/two', :pattern => '*.txt')
+    assert_equal 2, found.length
+    assert_equal FileMIO, found[0].class
+    assert_equal FileMIO, found[1].class
+    assert_equal (TestFileMIOTemplatePathname+'sub/two/apple.txt').to_s, found[0].full_pathname.to_s
+    assert_equal 'sub/two/apple.txt', found[0].pathname.to_s
+    assert_equal 'sub/two/baz.txt', found[1].pathname.to_s
+  end
+
+  def test_findfiles_multi_dir_pattern_deep_with_block
+    TestFileMIOTemplatePathname.rmtree if TestFileMIOTemplatePathname.exist?
+    IOMgr.template.path( 'one/two/three.txt').write('foo')
+    IOMgr.template.path( 'sub/two/apple.txt').write('foo')
+    IOMgr.template.path( 'sub/two/bar.log').write('foo')
+    File.open(TestFileMIOTemplatePathname+'sub/two/baz.txt', 'w'){ |file| file.write('foo') }
+    array_of_mio = []
+    found = IOMgr.template.find(:path => 'sub/two', :pattern => '*.txt'){ |mio| array_of_mio << mio }
+    assert_equal 2, found.length
+    assert_equal FileMIO, found[0].class
+    assert_equal FileMIO, found[1].class
+    assert_equal (TestFileMIOTemplatePathname+'sub/two/apple.txt').to_s, found[0].full_pathname.to_s
+    assert_equal 'sub/two/apple.txt', found[0].pathname.to_s
+    assert_equal 'sub/two/baz.txt', found[1].pathname.to_s
+    assert_equal 2, array_of_mio.length
+    assert_kind_of FileMIO, array_of_mio[0]
+    assert_kind_of FileMIO, array_of_mio[1]
+    assert_equal 'sub/two/apple.txt', array_of_mio[0].pathname.to_s
+    assert_equal 'sub/two/baz.txt', array_of_mio[1].pathname.to_s
+  end
+
+#------------------------------------------------------------------------------
+# Test helpers
+#------------------------------------------------------------------------------
+
+  # verify that an mio_handler for files anchored on a particular root_directory
+  # produces the expected file reference paths for a relative path within that space
+  def verify_mio_handler_paths( rel_path, mio_handler, root_directory )
+    assert_equal root_directory, mio_handler.to_str
+
+    file_path = mio_handler.path( rel_path )
+    assert_equal FileMIO, file_path.class
+    assert_equal rel_path, file_path.pathname.to_s
+    assert_equal "#{root_directory}/#{rel_path}", file_path.full_pathname.to_s
+  end
+
+  # verify that the file mio_handler reads the expected file content
+  def verify_mio_handler_read( rel_path, file_abs_path, file_content, mio_handler )
+
+    # verify the actual file contents are as expected
+    assert_equal file_abs_path, "#{mio_handler.to_str}/#{rel_path}"
+    assert_equal file_content, File.read( file_abs_path )
+
+    # verify that the file MIO handler obtains the expected content
+    file_path = mio_handler.path( rel_path )
+    assert_equal file_abs_path, file_path.to_str
+    assert_equal file_content, file_path.read
+  end
+
+  # verify that the file mio_handler reads the expected file content
+  def verify_mio_handler_read_no_cache( rel_path, file_abs_path, file_content, mio_handler )
+
+    # verify the actual file contents are as expected
+    assert_equal file_abs_path, "#{mio_handler.to_str}/#{rel_path}"
+    #???assert_equal file_content, File.read( file_abs_path )
+
+    # verify that the file MIO handler obtains the expected content
+    file_path = mio_handler.path( rel_path )
+    assert_equal file_abs_path, file_path.to_str
+    assert_equal file_content, file_path.read(:disable_cache => true)
+  end
+
+end

data/test/{filter_helpers_test.rb → unit/filter_helpers_test.rb}

@@ -2,7 +2,7 @@
 
 require 'test/unit'
 currentPath = File.dirname(__FILE__)
-require File.join( currentPath, '../lib/masterview' )
+require File.join( currentPath, '../../lib/masterview' )
 
 class TestDirectiveHelpers < Test::Unit::TestCase
   include MasterView::Directives

data/test/unit/keyword_expander_test.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+currentPath = File.dirname(__FILE__)
+require File.join( currentPath, '../../lib/facets/core/string/starts_with' )
+require File.join( currentPath, '../../lib/masterview/pathname_extensions' )
+require File.join( currentPath, '../../lib/masterview/keyword_expander' )
+
+class TestKeywordExpander < Test::Unit::TestCase
+  include MasterView
+
+  def test_ke
+    ke = KeywordExpander.new 'FOO' => 'bar', 'CAT' => 'dog'
+    ke.set('HELLO', 'world')
+    ke.set('FOO_MAN', 'foo_man')
+    ke.set('FOO_MAN_CHU', 'fmc')
+    ke.set('FOO_HELLO', 'foo_hello')
+    ke.set('ONE_HELLO', 'one_hello')
+    assert_equal 'bar', ke['FOO']
+    assert_equal 'dog', ke['CAT']
+    assert_equal 'nosub', ke.resolveAttrAndDelete( {:a => 'nosub'}, :a)
+    assert_equal 'world', ke.resolveAttrAndDelete( {:a => 'HELLO'}, :a)
+    assert_equal 'world', ke.resolveAttrAndDelete( {'a' => 'HELLO'}, 'a')
+    assert_equal 'bar this', ke.resolveAttrAndDelete( {:a => 'FOO this'}, :a)
+    assert_equal 'bar/this.rhtml', ke.resolveAttrAndDelete( {:a => 'FOO/this.rhtml'}, :a)
+    assert_equal 'foo/bar.rhtml', ke.resolveAttrAndDelete( {:a => 'foo/FOO.rhtml'}, :a)
+    assert_equal 'bar', ke.resolveAttrAndDelete( {:a => 'FOO'}, :a)
+    assert_equal 'dog', ke.resolveAttrAndDelete( {:a => 'CAT'}, :a)
+    assert_equal 'bar/dog.rhtml', ke.resolveAttrAndDelete( {:a => 'FOO/CAT.rhtml'}, :a)
+    assert_equal 'bar/dog/foo_man.rhtml', ke.resolveAttrAndDelete( {:a => 'FOO/CAT/FOO_MAN.rhtml'}, :a)
+    assert_equal 'one_hello/dog/foo_man/world.rhtml', ke.resolveAttrAndDelete( {:a => 'ONE_HELLO/CAT/FOO_MAN/HELLO.rhtml'}, :a)
+    assert_equal 'barbarbar', ke.resolveAttrAndDelete( {:a => 'FOOFOOFOO'}, :a)
+    assert_equal 'bar_bar_bar', ke.resolveAttrAndDelete( {:a => 'FOO_FOO_FOO'}, :a)
+    assert_equal nil, ke.resolveAttrAndDelete( {:a => 'HELLO'}, :not_found)
+  end
+
+  def test_ke_expand_keywords
+    ke = KeywordExpander.new 'FOO' => 'bar', 'CAT' => 'dog'
+    assert_equal nil, ke.expand_keywords(nil)
+    assert_equal 'bar', ke.expand_keywords('FOO')
+    assert_equal 'barbarbar', ke.expand_keywords('FOOFOOFOO')
+    assert_equal 'bardogbar', ke.expand_keywords('FOOCATFOO')
+    assert_equal 'one/bardogbar/dog.html', ke.expand_keywords('one/FOOCATFOO/CAT.html')
+  end
+
+  def test_template_path
+    ke = KeywordExpander.new
+    ke.set_template_pathname('foo/bar/controller/action.html', '.rhtml')
+    assert_equal 'foo/bar/controller/action', ke['{template_path}']
+    assert_equal 'foo/bar/controller', ke['{template_dir_path}']
+    assert_equal 'action', ke['{template_basename}']
+    assert_equal '.html', ke['{extension}']
+    # mv:generate="{template_path}" expands to include default output extension
+    assert_equal 'foo/bar/controller/action.rhtml', ke.expand_keywords('{template_path}')
+    # mv:generate="{template_path}.xxx" expands to respect explicitly-specified output extension
+    assert_equal 'foo/bar/controller/action.xxx', ke.expand_keywords('{template_path}.xxx')
+  end
+
+  def test_template_path_baseonly
+    ke = KeywordExpander.new
+    ke.set_template_pathname('foo_bar', '.rhtml')
+    assert_equal 'foo_bar', ke['{template_path}']
+    assert_equal '', ke['{template_dir_path}']
+    assert_equal 'foo_bar', ke['{template_basename}']
+    assert_equal '', ke['{extension}']
+    # mv:generate="{template_path}" vs. mv:generate="{template_path}.xxx"
+    assert_equal 'foo_bar.rhtml', ke.expand_keywords('{template_path}')
+    assert_equal 'foo_bar.xxx', ke.expand_keywords('{template_path}.xxx')
+  end
+
+  def test_template_path_cont_action
+    ke = KeywordExpander.new
+    ke.set_template_pathname('controller/action', '.rhtml')
+    assert_equal 'controller/action', ke['{template_path}']
+    assert_equal 'controller', ke['{template_dir_path}']
+    assert_equal 'action', ke['{template_basename}']
+    assert_equal '', ke['{extension}']
+    # mv:generate="{template_path}" vs. mv:generate="{template_path}.xxx"
+    assert_equal 'controller/action.rhtml', ke.expand_keywords('{template_path}')
+    assert_equal 'controller/action.xxx', ke.expand_keywords('{template_path}.xxx')
+  end
+
+  def test_template_path_action_only
+    ke = KeywordExpander.new
+    ke.set_template_pathname('action', '.rhtml')
+    assert_equal 'action', ke['{template_path}']
+    assert_equal '', ke['{template_dir_path}']
+    assert_equal 'action', ke['{template_basename}']
+    assert_equal '', ke['{extension}']
+    # mv:generate="{template_path}" vs. mv:generate="{template_path}.xxx"
+    assert_equal 'action.rhtml', ke.expand_keywords('{template_path}')
+    assert_equal 'action.xxx', ke.expand_keywords('{template_path}.xxx')
+  end
+
+end

data/test/unit/mio_test.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+currentPath = File.dirname(__FILE__)
+require File.join( currentPath, '../../lib/masterview/io' )
+
+class TestMIO < Test::Unit::TestCase
+
+  MVTestDir = File.expand_path( File.join(File.dirname(__FILE__), '..' ) )
+  TemplateDir = "#{MVTestDir}/tmp/template"
+  TemplateErbDir = "#{MVTestDir}/tmp/erb"
+
+  FileMIOTemplatePathname = Pathname.new(TemplateDir)
+  FileMIOTemplateDefaultExtension = '.html'
+  ErbPathname = Pathname.new(TemplateErbDir)
+  ErbDefaultExtension = '.rhtml'
+
+  CatDogPath = 'cat/dog.html'
+#  HelloWorldFullPath = "#{TemplateDir}/hello_world.txt"
+  HelloWorldPath = 'hello_world.txt'
+#  TestWritePath = 'foo.txt'
+#  TestWriteFullPath = "#{TemplateDir}/foo.txt"
+#  TestWritePathname = Pathname.new(TestWriteFullPath)
+
+  def setup
+    @mio = MasterView::MIOTrees.new
+    @mio.foo = MasterView::FileMIOTree.new(FileMIOTemplatePathname, ErbDefaultExtension) #??just use TemplateDir??
+    @mio.bar = MasterView::FileMIOTree.new(ErbPathname, ErbDefaultExtension)  #??just use TemplateErbDir??
+    @mio.baz = MasterView::StringHashMIOTree.new
+    @mio.msh = MasterView::MTimeStringHashMIOTree.new
+    @mio.rec = MasterView::RailsErbCacheMIOTree.new
+  end
+
+  def test_mio_setup
+    assert_kind_of(MasterView::FileMIOTree, @mio.foo)
+    assert_kind_of(MasterView::FileMIOTree, @mio.bar)
+    assert_kind_of(MasterView::StringHashMIOTree, @mio.baz)
+    assert_kind_of(MasterView::MTimeStringHashMIOTree, @mio.msh)
+    assert_kind_of(MasterView::RailsErbCacheMIOTree, @mio.rec)
+    assert_nil(@mio.not_there)
+    assert_equal(FileMIOTemplatePathname.to_s, @mio.foo.to_s)
+    assert_equal(ErbPathname.to_s, @mio.bar.to_s)
+  end
+  
+  def test_mio_filemiotree_interface
+    assert(@mio.foo.respond_to?(:path))
+    assert(@mio.foo.respond_to?(:find))
+    assert(@mio.foo.respond_to?(:cleanup_path_get_relative_pathname))
+  end
+
+  def test_mio_stringmiotree_interface
+    assert(@mio.baz.respond_to?(:path))
+    assert(@mio.baz.respond_to?(:find))
+    assert(@mio.baz.respond_to?(:cleanup_path_get_relative_pathname))
+  end
+
+  def test_mio_mtime_stringmiotree_interface
+    assert(@mio.msh.respond_to?(:path))
+    assert(@mio.msh.respond_to?(:find))
+    assert(@mio.msh.respond_to?(:cleanup_path_get_relative_pathname))
+  end
+
+  def test_mio_rec_miotree_interface
+    assert(@mio.rec.respond_to?(:path))
+    assert(@mio.rec.respond_to?(:find))
+    assert(@mio.rec.respond_to?(:cleanup_path_get_relative_pathname))
+  end
+
+  def test_mio_filemio_interface
+    assert(@mio.foo.path(CatDogPath).respond_to?(:pathname))
+    assert(@mio.foo.path(CatDogPath).respond_to?(:full_pathname))
+    assert(@mio.foo.path(CatDogPath).respond_to?(:read))
+    assert(@mio.foo.path(CatDogPath).respond_to?(:write))
+    assert(@mio.foo.path(CatDogPath).respond_to?(:exist?))
+    assert(@mio.foo.path(CatDogPath).respond_to?(:identical?))
+    assert(@mio.foo.path(CatDogPath).respond_to?(:mtime))
+  end
+
+  def test_mio_stringmio_interface
+    assert(@mio.baz.path(CatDogPath).respond_to?(:pathname))
+    assert(@mio.baz.path(CatDogPath).respond_to?(:full_pathname))
+    assert(@mio.baz.path(CatDogPath).respond_to?(:read))
+    assert(@mio.baz.path(CatDogPath).respond_to?(:write))
+    assert(@mio.baz.path(CatDogPath).respond_to?(:exist?))
+    assert(@mio.baz.path(CatDogPath).respond_to?(:identical?))
+    assert(@mio.baz.path(CatDogPath).respond_to?(:mtime))
+  end
+
+  def test_mio_mtime_stringmio_interface
+    assert(@mio.msh.path(CatDogPath).respond_to?(:pathname))
+    assert(@mio.msh.path(CatDogPath).respond_to?(:full_pathname))
+    assert(@mio.msh.path(CatDogPath).respond_to?(:read))
+    assert(@mio.msh.path(CatDogPath).respond_to?(:write))
+    assert(@mio.msh.path(CatDogPath).respond_to?(:exist?))
+    assert(@mio.msh.path(CatDogPath).respond_to?(:identical?))
+    assert(@mio.msh.path(CatDogPath).respond_to?(:mtime))
+  end
+
+  def test_mio_rec_mio_interface
+    assert(@mio.rec.path(CatDogPath).respond_to?(:pathname))
+    assert(@mio.rec.path(CatDogPath).respond_to?(:full_pathname))
+    assert(@mio.rec.path(CatDogPath).respond_to?(:read))
+    assert(@mio.rec.path(CatDogPath).respond_to?(:write))
+    assert(@mio.rec.path(CatDogPath).respond_to?(:exist?))
+    assert(@mio.rec.path(CatDogPath).respond_to?(:identical?))
+    assert(@mio.rec.path(CatDogPath).respond_to?(:mtime))
+  end
+
+end
+