masterview 0.2.5 → 0.3.0

data/test/unit/mio_test.rb

@@ -6,6 +6,13 @@ require File.join( currentPath, '../../lib/masterview/io' )
 
 class TestMIO < Test::Unit::TestCase
 
+  # bring test subjects into the local name space
+  MIOTrees = MasterView::MIO::MIOTrees
+  FileMIOTree = MasterView::MIO::FileMIOTree
+  StringHashMIOTree = MasterView::MIO::StringHashMIOTree
+  MTimeStringHashMIOTree = MasterView::MIO::MTimeStringHashMIOTree
+  RailsErbCacheMIOTree = MasterView::MIO::RailsErbCacheMIOTree
+
   MVTestDir = File.expand_path( File.join(File.dirname(__FILE__), '..' ) )
   TemplateDir = "#{MVTestDir}/tmp/template"
   TemplateErbDir = "#{MVTestDir}/tmp/erb"
@@ -23,20 +30,20 @@ class TestMIO < Test::Unit::TestCase
 #  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
+    @mio = MIOTrees.new
+    @mio.foo = FileMIOTree.new(FileMIOTemplatePathname, ErbDefaultExtension) #??just use TemplateDir??
+    @mio.bar = FileMIOTree.new(ErbPathname, ErbDefaultExtension)  #??just use TemplateErbDir??
+    @mio.baz = StringHashMIOTree.new
+    @mio.msh = MTimeStringHashMIOTree.new
+    @mio.rec = 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_kind_of(FileMIOTree, @mio.foo)
+    assert_kind_of(FileMIOTree, @mio.bar)
+    assert_kind_of(StringHashMIOTree, @mio.baz)
+    assert_kind_of(MTimeStringHashMIOTree, @mio.msh)
+    assert_kind_of(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)

data/test/unit/mtime_string_hash_mio_tree_test.rb

@@ -5,7 +5,11 @@ currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview/io' )
 
 class TestMTimeStringHashMIO < Test::Unit::TestCase
-  include MasterView
+
+  # bring test subjects into the local name space
+  MIOTrees = MasterView::MIO::MIOTrees
+  MTimeStringHashMIOTree = MasterView::MIO::MTimeStringHashMIOTree
+  MTimeStringMIO = MasterView::MIO::MTimeStringMIO
 
   TestStringMIOTemplatePathname = Pathname.new('../tmp/template')
   ErbPathname = Pathname.new('../tmp/erb')

data/test/unit/parser_test.rb

@@ -5,36 +5,48 @@ currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview' )
 
 class TestParser < Test::Unit::TestCase
-  include MasterView::Directives
+
+  # map references to internal parser implementation classes inot the local name space
+  RenderLevel = MasterView::TemplateProcessing::RenderLevel
+  RenderMode = MasterView::TemplateProcessing::RenderMode
+  DirectiveSet = MasterView::TemplateProcessing::DirectiveSet
+  DirectiveCallStack = MasterView::TemplateProcessing::DirectiveCallStack
+  SimpleRenderHandler = MasterView::TemplateProcessing::SimpleRenderHandler
+  Renderer = MasterView::TemplateProcessing::Renderer
+  Tag = MasterView::TemplateProcessing::Tag
+
+  def setup
+    @renderer = Renderer.new(:output_mio_tree => MasterView::MIO::StringHashMIOTree.new({}, '.rhtml', :logging => true))
+  end
 
   def test_render_level
-    rl = MasterView::RenderLevel.new
+    rl = RenderLevel.new
     assert_equal [], rl.render_modes
 
-    a = MasterView::RenderMode.new
-    b = MasterView::RenderMode.new
-    rl = MasterView::RenderLevel.new [a,b]
+    a = RenderMode.new
+    b = RenderMode.new
+    rl = RenderLevel.new [a,b]
     assert_equal [a,b], rl.render_modes
 
-    c = MasterView::RenderMode.new
+    c = RenderMode.new
     rl.push c
     assert_equal [a,b,c], rl.render_modes
   end
 
   def test_render_mode
-    rm = MasterView::RenderMode.new
-    assert_equal nil, rm.output 
+    rm = RenderMode.new
+    assert_equal nil, rm.output
     assert_equal :normal, rm.mode_type
     assert_equal [], rm.tags
 
     a = '/foo/bar'
-    rm = MasterView::RenderMode.new(a)
-    assert_equal a, rm.output 
+    rm = RenderMode.new(a)
+    assert_equal a, rm.output
     assert_equal :normal, rm.mode_type
     assert_equal [], rm.tags
 
-    rm = MasterView::RenderMode.new(a, :wide)
-    assert_equal a, rm.output 
+    rm = RenderMode.new(a, :wide)
+    assert_equal a, rm.output
     assert_equal :wide, rm.mode_type
     assert_equal [], rm.tags
 
@@ -44,7 +56,7 @@ class TestParser < Test::Unit::TestCase
     attributes = { 'bar' => 'baz', 'can' => 'dog' }
     mode_type = :wide
     parent = :parent
-    t2 = MasterView::Tag.new(directives, tag_name, attributes, mode_type, parent)
+    t2 = Tag.new(directives, tag_name, attributes, mode_type, parent, nil, @renderer)
     rm.tags << t1 << t2
     assert_equal [t1,t2], rm.tags
     assert_equal t2, rm.tag
@@ -58,30 +70,30 @@ class TestParser < Test::Unit::TestCase
   end
 
   def test_dcs
-    dcs = MasterView::DirectiveCallStack.new
+    dcs = DirectiveCallStack.new
     dcs << :a
     dcs << :b
     dcs << [:c,:d]
     assert_equal [:a,:b,:c,:d], dcs.directives_to_call
-    dcs2 = MasterView::DirectiveCallStack.new
+    dcs2 = DirectiveCallStack.new
     dcs2 << :e
     dcs2 << :f
     assert_equal [:e,:f], dcs2.directives_to_call
     dcs << dcs2
     assert_equal [:a,:b,:c,:d,:e,:f], dcs.directives_to_call
 
-    assert_equal [], MasterView::DirectiveCallStack.new.render
+    assert_equal [], DirectiveCallStack.new.render
 
     proc1 = lambda { |f| "1" }
     proc2 = lambda { |f| "2" }
-    dcs3 = MasterView::DirectiveCallStack.new
+    dcs3 = DirectiveCallStack.new
     dcs3 << proc1
     dcs3 << proc2
-    assert_equal '1', dcs3.render 
+    assert_equal '1', dcs3.render
   end
 
   def test_directives
-    fs = MasterView::DirectiveSet.new
+    fs = DirectiveSet.new
     fs << :a
     fs << :b
     fs << [:c, :d]
@@ -97,21 +109,21 @@ class TestParser < Test::Unit::TestCase
   end
 
   def test_simple_render_handler
-    s = MasterView::SimpleRenderHandler.new
-    dcs = MasterView::DirectiveCallStack.new
+    s = SimpleRenderHandler.new
+    dcs = DirectiveCallStack.new
     directives = [:f1, :f2]
     tag_name = 'foo'
     attributes = { 'bar' => 'baz', 'can' => 'dog' }
     mode_type = :wide
     parent = :parent
-    t2 = MasterView::Tag.new(directives, tag_name, attributes, mode_type, parent)
+    t2 = Tag.new(directives, tag_name, attributes, mode_type, parent, nil, @renderer)
     dcs.context = { :tag => t2 }
     ret = s.stag(dcs)
     assert_equal "<foo", ret[0]
     assert_equal " bar=\"baz\"", ret[1]
     assert_equal " can=\"dog\"", ret[2]
     assert_equal '>', ret[3]
-    
+
     dcs.context[:content_part] = 'hello'
     assert_equal ['hello'], s.characters(dcs)
     assert_equal ['<!-- ', 'hello', ' -->'], s.comment(dcs)
@@ -120,7 +132,7 @@ class TestParser < Test::Unit::TestCase
 
     attributes = { :can => 'dog', :bar => 'baz' } # test that we can use symbols for keys
     tag_name = :foo
-    t3 = MasterView::Tag.new(directives, tag_name, attributes, mode_type, parent)
+    t3 = Tag.new(directives, tag_name, attributes, mode_type, parent, nil, @renderer)
     dcs.context = { :tag => t3 }
     ret = s.stag(dcs)
     assert_equal "<foo", ret[0]
@@ -135,7 +147,7 @@ class TestParser < Test::Unit::TestCase
     attributes = { 'bar' => 'baz', 'can' => 'dog' }
     mode_type = :wide
     parent = :parent
-    t = MasterView::Tag.new(directives, tag_name, attributes, mode_type, parent)
+    t = Tag.new(directives, tag_name, attributes, mode_type, parent, nil, @renderer)
     assert_equal [:f1, :f2], t.directives
     assert_equal tag_name, t.tag_name
     assert_equal attributes, t.attributes
@@ -161,9 +173,9 @@ class TestParser < Test::Unit::TestCase
     assert_equal [[:a,:b], [:c,:d], [:e,:f]], t.data
   end
 
-  # base, meta, link, hr, br, param, img, area, input, col 
+  # base, meta, link, hr, br, param, img, area, input, col
   def test_simplify_element_names
-    r = MasterView::Renderer.new(:output_mio_tree => MasterView::StringHashMIOTree.new )
+    r = Renderer.new(:output_mio_tree => MasterView::MIO::StringHashMIOTree.new )
     assert_equal ['<base', ' />'], r.simplify_empty_elements( ['<base', '>', '</', 'base>'] )
     assert_equal ['<meta', ' />'], r.simplify_empty_elements( ['<meta', '>', '</', 'meta>'] )
     assert_equal ['<link', ' />'], r.simplify_empty_elements( ['<link', '>', '</', 'link>'] )
@@ -173,7 +185,7 @@ class TestParser < Test::Unit::TestCase
     assert_equal ['<img', ' />'], r.simplify_empty_elements( ['<img', '>', '</', 'img>'] )
     assert_equal ['<area', ' />'], r.simplify_empty_elements( ['<area', '>', '</', 'area>'] )
     assert_equal ['<input', ' />'], r.simplify_empty_elements( ['<input', '>', '</', 'input>'] )
-    assert_equal ['<col', ' />'], r.simplify_empty_elements( ['<col', '>', '</', 'col>'] ) 
+    assert_equal ['<col', ' />'], r.simplify_empty_elements( ['<col', '>', '</', 'col>'] )
 
     assert_equal ['<script', '>', '</', 'script>'], r.simplify_empty_elements( ['<script', '>', '</', 'script>'] )
     assert_equal ['<title', '>', '</', 'title>'], r.simplify_empty_elements( ['<title', '>', '</', 'title>'] )
@@ -187,5 +199,5 @@ class TestParser < Test::Unit::TestCase
     #todo
   end
 
-  
+
 end

data/test/unit/pathname_extensions_test.rb

@@ -2,7 +2,7 @@
 
 require 'test/unit'
 require 'pathname'
-require File.join( File.dirname(__FILE__), '../../lib/masterview/pathname_extensions' )
+require File.join( File.dirname(__FILE__), '../../lib/masterview/core_ext/pathname' )
 
 class TestPathnameExtensions < Test::Unit::TestCase
   def test_for_path

data/test/unit/run_parser_test.rb

@@ -15,9 +15,9 @@ class TestParser < Test::Unit::TestCase
   end
 
   def test_parser_run
-    @template_mio_tree = MasterView::FileMIOTree.new(TestFixturesDir, '.html')
+    @template_mio_tree = MasterView::MIO::FileMIOTree.new(TestFixturesDir, '.html')
     @template_mio = @template_mio_tree.path(MasterViewHTMLFile)
-    @erb_mio_tree = MasterView::FileMIOTree.new(TmpOutputDir, '.rhtml')
+    @erb_mio_tree = MasterView::MIO::FileMIOTree.new(TmpOutputDir, '.rhtml')
     MasterView::Parser.parse_mio( @template_mio, @erb_mio_tree)
     assert File.exist?(TmpOutputDir+'/layouts/product.rhtml')
     assert File.exist?(TmpOutputDir+'/product/_form.rhtml')

data/test/unit/simplified_directive_base_test.rb

@@ -0,0 +1,256 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+currentPath = File.dirname(__FILE__)
+require File.join( currentPath, '../../lib/masterview' )
+require File.join( currentPath, '../test_helper' )
+
+class TestSimplifiedDirectiveBase < Test::Unit::TestCase
+  def test_nothing_yet
+  end
+end
+
+=begin comment out for now
+
+class SimplifiedDirectiveExample < MasterView::SimplifiedDirectiveBase
+end
+
+class TestSimplifiedDirectiveBase < Test::Unit::TestCase
+
+  def setup
+    @sde = SimplifiedDirectiveExample.new('product, desc, {:foo => :bar}, :readonly => false')
+    @sde.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+  end
+
+  def test_args
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options
+    @sde.arg :html_options
+    @sde.arg :not_there
+    assert @sde.instance_variables.include?('@obj')
+    assert @sde.instance_variables.include?('@method')
+    assert @sde.instance_variables.include?('@options')
+    assert @sde.instance_variables.include?('@html_options')
+    assert @sde.instance_variables.include?('@not_there')
+    assert_equal 'product', @sde.instance_variable_get('@obj')
+    assert_equal 'desc', @sde.instance_variable_get('@method')
+    assert_equal '{:foo => :bar}', @sde.instance_variable_get('@options')
+    assert_equal ':readonly => false', @sde.instance_variable_get('@html_options')
+    assert_equal nil, @sde.instance_variable_get('@not_there')
+  end
+
+  def test_arg_quote
+    @sde.arg :obj, :quote => true
+    @sde.arg :method, :quote => false
+    assert_equal '\'product\'', @sde.instance_variable_get('@obj')
+    assert_equal 'desc', @sde.instance_variable_get('@method')
+  end
+
+  def test_prepare_output
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options
+    @sde.arg :html_options
+    assert_equal 'test', @sde.prepare_output('test')
+    assert_equal 'test product', @sde.prepare_output('test', :obj)
+    assert_equal 'test product, desc', @sde.prepare_output('test', :obj, :method)
+    assert_equal 'test product, desc, {:foo => :bar}', @sde.prepare_output('test', :obj, :method, :options)
+    assert_equal 'test product, desc, {:foo => :bar}, :readonly => false', @sde.prepare_output('test', :obj, :method, :options, :html_options)
+  end
+
+  def test_prepare_output_mixed
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options
+    @sde.arg :html_options
+    assert_equal 'test product, :foo', @sde.prepare_output('test', :obj, :foo)
+    assert_equal 'test product, :foo, :bar', @sde.prepare_output('test', :obj, :foo, :bar)
+    assert_equal 'test product, desc, {:foo => :bar}, :hello', @sde.prepare_output('test', :obj, :method, :options, :hello)
+    assert_equal 'test product, desc, {:foo => :bar}, :hello, 1', @sde.prepare_output('test', :obj, :method, :options, :hello, 1)
+    assert_equal 'test product, desc, {:foo => :bar}, :hello, 1, [:a, :b]', @sde.prepare_output('test', :obj, :method, :options, :hello, 1, [:a, :b])
+  end
+
+  def test_prepare_output_quote
+    @sde.arg :obj, :quote => true
+    @sde.arg :method, :quote => true
+    @sde.arg :options
+    @sde.arg :html_options
+    assert_equal 'test', @sde.prepare_output('test')
+    assert_equal 'test \'product\'', @sde.prepare_output('test', :obj)
+    assert_equal 'test \'product\', \'desc\'', @sde.prepare_output('test', :obj, :method)
+    assert_equal 'test \'product\', \'desc\', {:foo => :bar}', @sde.prepare_output('test', :obj, :method, :options)
+    assert_equal 'test \'product\', \'desc\', {:foo => :bar}, :readonly => false', @sde.prepare_output('test', :obj, :method, :options, :html_options)
+  end
+
+  def test_prepare_output_middle_nil
+    @sde = SimplifiedDirectiveExample.new('product, desc, {:foo => :bar}, :readonly => false')
+    @sde.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options
+    @sde.arg :html_options
+    @sde.instance_variable_set("@options", nil)
+    assert_equal 'test product, desc', @sde.prepare_output('test', :obj, :method, :options)
+    assert_equal 'test product, desc, nil, :readonly => false', @sde.prepare_output('test', :obj, :method, :options, :html_options)
+  end
+
+  def test_prepare_output_middle_needs_brackets
+    @sde = SimplifiedDirectiveExample.new('product, desc, :foo => :bar')
+    @sde.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options
+    @sde.arg :html_options
+    @sde.instance_variable_set("@html_options", ':hello => :world')
+    assert_equal 'test product, desc, :foo => :bar', @sde.prepare_output('test', :obj, :method, :options)
+    assert_equal 'test product, desc, { :foo => :bar }, :hello => :world', @sde.prepare_output('test', :obj, :method, :options, :html_options)
+  end
+
+  def test_prepare_output_middle_empty_string
+    @sde = SimplifiedDirectiveExample.new('product, desc, :foo => :bar')
+    @sde.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options
+    @sde.arg :html_options
+    @sde.instance_variable_set("@options", '')
+    @sde.instance_variable_set("@html_options", ':hello => :world')
+    assert_equal 'test product, desc', @sde.prepare_output('test', :obj, :method, :options)
+    assert_equal 'test product, desc, nil, :hello => :world', @sde.prepare_output('test', :obj, :method, :options, :html_options)
+  end
+
+  def test_prepare_output_middle_nil_opt_default_string
+    @sde = SimplifiedDirectiveExample.new('product, desc')
+    @sde.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options, :default => '{}'
+    @sde.arg :html_options
+    @sde.instance_variable_set("@html_options", ':readonly => true')
+    assert_equal 'test product, desc', @sde.prepare_output('test', :obj, :method, :options)
+    assert_equal 'test product, desc, {}, :readonly => true', @sde.prepare_output('test', :obj, :method, :options, :html_options)
+  end
+
+  def test_prepare_output_middle_nil_opt_default_hash
+    @sde = SimplifiedDirectiveExample.new('product, desc')
+    @sde.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options, :default => {}
+    @sde.arg :html_options
+    @sde.instance_variable_set("@html_options", ':readonly => true')
+    assert_equal 'test product, desc', @sde.prepare_output('test', :obj, :method, :options)
+    assert_equal 'test product, desc, {}, :readonly => true', @sde.prepare_output('test', :obj, :method, :options, :html_options)
+  end
+
+  def test_prepare_output_middle_nil_opt_default_array
+    @sde = SimplifiedDirectiveExample.new('product, desc')
+    @sde.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options, :default => []
+    @sde.arg :html_options
+    @sde.instance_variable_set("@html_options", ':readonly => true')
+    assert_equal 'test product, desc', @sde.prepare_output('test', :obj, :method, :options)
+    assert_equal 'test product, desc, [], :readonly => true', @sde.prepare_output('test', :obj, :method, :options, :html_options)
+  end
+
+  def test_prepare_output_middle_nil_opt_default_symbol
+    @sde = SimplifiedDirectiveExample.new('product, desc')
+    @sde.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options, :default => :foo
+    @sde.arg :html_options
+    @sde.instance_variable_set("@html_options", ':readonly => true')
+    assert_equal 'test product, desc', @sde.prepare_output('test', :obj, :method, :options)
+    assert_equal 'test product, desc, :foo, :readonly => true', @sde.prepare_output('test', :obj, :method, :options, :html_options)
+  end
+
+  def test_prepare_output_middle_nil_opt_default_fixnum
+    @sde = SimplifiedDirectiveExample.new('product, desc')
+    @sde.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options, :default => 123
+    @sde.arg :html_options
+    @sde.instance_variable_set("@html_options", ':readonly => true')
+    assert_equal 'test product, desc', @sde.prepare_output('test', :obj, :method, :options)
+    assert_equal 'test product, desc, 123, :readonly => true', @sde.prepare_output('test', :obj, :method, :options, :html_options)
+  end
+
+  def test_prepare_output_middle_nil_opt_default_hash_mixed
+    @sde = SimplifiedDirectiveExample.new('product, desc')
+    @sde.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options, :default => {}
+    assert_equal 'test product, desc', @sde.prepare_output('test', :obj, :method, :options)
+    assert_equal 'test product, desc, {}, 123', @sde.prepare_output('test', :obj, :method, :options, 123)
+  end
+
+  def test_merge_common_str
+    @sde.element_attrs['class'] = 'red'
+    @sde.element_attrs['id'] = 'id1'
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options, :default => {}
+    @sde.arg :html_options, :append_element_attrs => [:common_html]
+    assert_equal ':readonly => false, :class => "red", :id => "id1"', @sde.instance_variable_get('@html_options')
+  end
+
+  def test_merge_common_array
+    @sde.element_attrs['class'] = 'red'
+    @sde.element_attrs['id'] = 'id1'
+    @sde.arg :obj
+    @sde.arg :method
+    @sde.arg :options, :default => {}
+    @sde.arg :html_options, :append_element_attrs => [:common_html]
+    assert_equal ':readonly => false, :class => "red", :id => "id1"', @sde.instance_variable_get('@html_options')
+  end
+
+  def test_render_nothing
+    @sde.arg :obj
+    assert_equal nil, @sde.render_nothing
+  end
+
+  def test_render
+    @sde.arg :obj
+
+    result = @sde.render @sde.prepare_output 'test', :obj
+    assert_equal ['test product'], result
+
+    result = @sde.render @sde.prepare_output 'hello', :obj
+    assert_equal ['test product', 'hello product'], result
+  end
+
+  def test_render_erb_content
+    @sde.arg :obj
+
+    result = @sde.render @sde.erb_content 'test', :obj
+    assert_equal ['<%= test product %>'], result
+
+    result = @sde.render @sde.erb_content 'hello', :obj
+    assert_equal ['<%= test product %>', '<%= hello product %>'], result
+  end
+
+  def test_merge_hash_into_str
+    assert_equal '', @sde.merge_hash_into_str({}, '')
+    assert_equal ':foo => :bar', @sde.merge_hash_into_str({}, ':foo => :bar')
+    assert_equal ':foo => :bar', @sde.merge_hash_into_str({:foo => :bar}, '')
+    assert_equal ':foo => :baz, :foo => :bar', @sde.merge_hash_into_str({:foo => :bar}, ':foo => :baz')
+    assert_equal ':foo => :baz, :foo => :bar, :goo => :hello', @sde.merge_hash_into_str({:goo => :hello, :foo => :bar}, ':foo => :baz')
+    assert_equal '"class" => "red"', @sde.merge_hash_into_str({'class' => 'red'}, '')
+
+    assert_equal '{}', @sde.merge_hash_into_str({}, '{}')
+    assert_equal '{:foo => :bar}', @sde.merge_hash_into_str({}, '{:foo => :bar}')
+    assert_equal '{:foo => :bar}', @sde.merge_hash_into_str({:foo => :bar}, '{ }')
+    assert_equal '{:foo => :baz, :foo => :bar}', @sde.merge_hash_into_str({:foo => :bar}, ' {:foo => :baz} ')
+    assert_equal '{:foo => :baz, :foo => :bar, :goo => :hello}', @sde.merge_hash_into_str({:goo => :hello, :foo => :bar}, '{:foo => :baz}')
+    assert_equal '{"class" => "red"}', @sde.merge_hash_into_str({'class' => 'red'}, '{}')
+  end
+
+end
+
+=end

data/test/unit/string_hash_mio_test.rb

@@ -5,7 +5,11 @@ currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview/io' )
 
 class TestStringHashMIO < Test::Unit::TestCase
-  include MasterView
+
+  # bring test subjects into the local name space
+  MIOTrees = MasterView::MIO::MIOTrees
+  StringHashMIOTree = MasterView::MIO::StringHashMIOTree
+  StringMIO = MasterView::MIO::StringMIO
 
   MVTestDir = File.expand_path( File.join(File.dirname(__FILE__), '..' ) )
   TemplateDir = "#{MVTestDir}/tmp/template"

data/test/unit/template_file_watcher_test.rb

@@ -38,8 +38,8 @@ class TestTemplateWatcher < Test::Unit::TestCase
       STDOUT.puts "...installed test fixture #{TestFixtureFile}" if DEBUG_TRACE
       STDOUT.puts "...#{TestSubjectFileShortName} template timestamp=#{File.mtime(TestSubjectFile)}" if DEBUG_TRACE
     end
-    @template_mio_tree = MasterView::FileMIOTree.new(TemplateSrcDir, '.html')
-    @output_mio_tree = MasterView::FileMIOTree.new(TemplateDstDir, '.rhtml')
+    @template_mio_tree = MasterView::MIO::FileMIOTree.new(TemplateSrcDir, '.html')
+    @output_mio_tree = MasterView::MIO::FileMIOTree.new(TemplateDstDir, '.rhtml')
   end
 
   def test_a_parse_template_on_startup