narf 0.5.1

data/test/test.action.rb~

@@ -0,0 +1,142 @@
+module Web
+    class Action
+	def Action.clear_actions
+	    @@all_actions = []
+	end
+    end
+end
+
+class TestAction < Test::Unit::TestCase
+    def set_up
+    end
+    
+    def teardown
+	@output = @cgi = @action = @stored_pattern = nil
+	Web::Action.clear_actions
+    end
+
+    def output
+	@output ||= ""
+    end
+
+    def cgi params={}
+	Web::CGI.new( :out => output, :params => params )
+    end
+
+    def stored_pattern pattern={}
+	@stored_pattern ||= pattern
+    end
+
+    def action( pattern=stored_pattern, &function )
+	@action ||= Web::Action.new( pattern, &function )
+    end
+
+    def test_failed_match_on_blank_cgi
+	action( "name" => // )
+	assert_equal( false, action.applies?(cgi) )
+    end
+
+    def test_fails_with_different_params
+	action "name" => //
+	assert_equal( false, action.applies?(cgi( {"not" => "me"} )) )
+    end
+
+    def test_matchs_by_param_present
+	action "name" => //
+	assert action.applies?(cgi( {"name" => "something"}) )
+    end
+    
+    def test_matches_exact_param
+	action "name" => "patrick"
+	assert action.applies?(cgi( {"name" => "patrick" } ))
+	assert_equal( false, action.applies?(cgi( {"name" => "patrick.may"} ) ))
+    end
+
+    def test_matches_pattern
+	action "name" => /patrick|tom/
+	assert action.applies?(cgi( {"name" => "patrick the great" } ))
+	assert action.applies?(cgi( {"name" => "tom the silly" } ))
+    end
+	
+    def test_match_is_not_anal
+	action "name" => //
+	assert action.applies?(cgi( {"name" => "something", "ignore" => "me"} ))
+    end
+
+    def test_runs_block
+	action_ran_flag = false
+	action( "name" => // ) {
+	    action_ran_flag = true
+	}
+
+	action.run
+
+	assert action_ran_flag
+    end
+
+    def test_guards_block
+	Web::Action.new.run
+    end
+
+    def test_passes_cgi_in_with_run
+	action_ran_flag = false
+	action( "name" => // ){ |cgi|
+	    action_ran_flag = cgi.has_key? "flag"
+	}
+
+	action.run cgi( "flag" => "it ran" )
+
+	assert action_ran_flag
+    end
+
+    def test_pick_action_picks_the_most_specific_action
+	one = Web::Action.new( "name" => // )
+	second = Web::Action.new( "name" => "patrick" )
+	third = Web::Action.new( "name" => /patrick|tom/ )
+
+	assert_equal( second, Web::Action.pick( cgi({ "name" => "patrick"}) ) )
+    end
+
+    def test_set_default_action
+	default = Web::Action.new
+	another = Web::Action.new( "this" => "that", "here" => "there" )
+	assert_equal( default, Web::Action.pick( cgi ) )
+    end
+
+# this test causes no initial default action
+#    def test_raises_exception_if_no_action_is_found
+#	assert_raises(Web::Exception){ 
+#	    Web::Action.pick cgi
+#	}
+#    end
+
+    def test_doesnt_raise_exception_if_no_exception_is_found
+	Web::Action.pick(cgi).run
+    end
+
+    def test_blank_action_doesnt_mask_default
+	Web::Action.pick(cgi).run
+
+	default = Web::Action.new
+
+	assert_equal( default, Web::Action.pick(cgi) )
+    end
+
+    def test_run
+	cgi_params = { "name" => "patrick" }
+	test_params = {}
+
+	Web::Action.new { |cgi|
+	    test_params = cgi.multiple_params
+	}
+
+	Web::Action.run :params => cgi_params, :out => ""
+
+	assert_equal( cgi_params, test_params )
+    end
+
+    def todo_test_subclassing_action
+
+    end
+    
+end

data/test/test.assertinclude.rb

@@ -0,0 +1,109 @@
+class TestHashCompare < Test::Unit::TestCase
+    def test_includes_same
+	assert_includes( {"a" => "aa"}  , {"a" => "aa"} )
+    end
+
+    def test_includes_missing
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( { "a" => "aa", "b" => "bb" }  , {"a" => "aa"} )
+	}
+        assert e.to_s.index( "Missing from actual: b => \"bb\"" )
+    end
+
+    def test_includes_different
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => "aa"}   , { "a" => "bb" } )
+	}
+        assert e.to_s.index("Difference: required <a => \"aa\"> was <a => \"bb\">" )
+    end
+
+    def test_includes_multi_level
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => { "a" => "aa", "b" => "bb" }}   , { "a" => { "a" => "aa", "b" => "cc"}} )
+	}
+        assert e.to_s.index("Difference: required <a.b => \"bb\"> was <a.b => \"cc\">")
+    end
+
+    def test_includes_array_with_difference
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => [{ "a" => "aa" }, {"b" => "bb" }]},{ "a" => [ {"a" => "aa"}, {"b" => "cc"}]})
+	}
+        assert e.to_s.index("Difference: required <a[1].b => \"bb\"> was <a[1].b => \"cc\">")
+    end
+
+    def test_includes_array_with_items_missing
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( { "a" => [ {"a" => "aa"}, {"b" => "cc"}]} , {"a" => [{ "a" => "aa" }]} )
+	}
+        assert e.to_s.index("Missing from actual: a[1] => {\"b\"=>\"cc\"}")
+    end
+
+    def test_includes_hash_when_should_not
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => "b"}  , { "a" => { "a" => "aa", "b" => "cc"}} )
+	}
+        assert e.to_s.index("Difference: required <a => \"b\"> was <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}>")
+    end
+
+    def test_does_not_include_hash_when_it_should
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( { "a" => { "a" => "aa" , "b" => "cc"}}, {"a" => "b"}  )
+	}
+        assert e.to_s.index("Difference: required <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}> was <a => \"b\">")
+    end
+
+    def test_includes_array_when_should_not
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => "a"}, { "a" => [ {"a" => "aa"}, {"b" => "cc"}]} )
+	}
+        assert e.to_s.index("Difference: required <a => \"a\"> was <a => [{\"a\"=>\"aa\"}, {\"b\"=>\"cc\"}]>")
+    end
+
+    def test_does_not_include_array_when_it_should
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => "b"}  , { "a" => { "a" => "aa" , "b" => "cc"}} )
+	}
+        assert e.to_s.index("Difference: required <a => \"b\"> was <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}>" )
+    end
+
+    def test_assert_includes
+        assert_includes( {"a" => { "a" => "aa" }}, { "a" => { "a" => "aa" , "b" => "aa"}} )
+    end
+
+    def test_assert_includes2
+        assert_raises (Test::Unit::AssertionFailedError) {
+            assert_includes( { "a" => { "a" => "aa" , "b" => "cc"}}, {"a" => { "c" => "bb" },"b" => { "c" => "bb" }})
+        }
+    end
+
+    def test_assert_includes_array
+        assert_includes( ["a"],[ "a","b"] )
+    end
+    
+    def test_demonstrate_failure
+        assert_raises (Test::Unit::AssertionFailedError) {
+            assert_includes(["a","b"],[ "a"])
+        }
+    end
+
+    class Trivial
+	attr_accessor :name
+	def initialize( name )
+	    @name = name
+	end
+    end
+    
+    def test_compare_object_tree_to_hash
+	assert_includes({"name" => "patrick"}, Trivial.new("patrick"))
+    end
+
+    def test_compare_object_tree_to_hash
+	assert_includes({"name" => { "name" => "patrick" }}, Trivial.new(Trivial.new("patrick")))
+    end
+
+   
+    # TODO:
+    # reports an error if either item is not a hash
+    # improve error reporting when comparing a hash to an array and vice versa
+    # add an enhanced version of assert equals
+end

data/test/test.assertinclude.rb~

@@ -0,0 +1,109 @@
+class TestHashCompare < Test::Unit::TestCase
+    def test_includes_same
+	assert_includes( {"a" => "aa"}  , {"a" => "aa"} )
+    end
+
+    def test_includes_missing
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( { "a" => "aa", "b" => "bb" }  , {"a" => "aa"} )
+	}
+        assert_equal "Missing from actual: b => \"bb\".", e.to_s
+    end
+
+    def test_includes_different
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => "aa"}   , { "a" => "bb" } )
+	}
+        assert_equal "Difference: required <a => \"aa\"> was <a => \"bb\">.", e.to_s
+    end
+
+    def test_includes_multi_level
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => { "a" => "aa", "b" => "bb" }}   , { "a" => { "a" => "aa", "b" => "cc"}} )
+	}
+        assert_equal "Difference: required <a.b => \"bb\"> was <a.b => \"cc\">.", e.to_s
+    end
+
+    def test_includes_array_with_difference
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => [{ "a" => "aa" }, {"b" => "bb" }]},{ "a" => [ {"a" => "aa"}, {"b" => "cc"}]})
+	}
+        assert_equal "Difference: required <a[1].b => \"bb\"> was <a[1].b => \"cc\">.", e.to_s
+    end
+
+    def test_includes_array_with_items_missing
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( { "a" => [ {"a" => "aa"}, {"b" => "cc"}]} , {"a" => [{ "a" => "aa" }]} )
+	}
+        assert_equal "Missing from actual: a[1] => {\"b\"=>\"cc\"}.", e.to_s
+    end
+
+    def test_includes_hash_when_should_not
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => "b"}  , { "a" => { "a" => "aa", "b" => "cc"}} )
+	}
+        assert_equal "Difference: required <a => \"b\"> was <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}>.", e.to_s
+    end
+
+    def test_does_not_include_hash_when_it_should
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( { "a" => { "a" => "aa" , "b" => "cc"}}, {"a" => "b"}  )
+	}
+        assert_equal "Difference: required <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}> was <a => \"b\">.", e.to_s
+    end
+
+    def test_includes_array_when_should_not
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => "a"}, { "a" => [ {"a" => "aa"}, {"b" => "cc"}]} )
+	}
+        assert_equal "Difference: required <a => \"a\"> was <a => [{\"a\"=>\"aa\"}, {\"b\"=>\"cc\"}]>.", e.to_s
+    end
+
+    def test_does_not_include_array_when_it_should
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => "b"}  , { "a" => { "a" => "aa" , "b" => "cc"}} )
+	}
+        assert_equal "Difference: required <a => \"b\"> was <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}>.", e.to_s
+    end
+
+    def test_assert_includes
+        assert_includes( {"a" => { "a" => "aa" }}, { "a" => { "a" => "aa" , "b" => "aa"}} )
+    end
+
+    def test_assert_includes2
+        assert_raises (Test::Unit::AssertionFailedError) {
+            assert_includes( { "a" => { "a" => "aa" , "b" => "cc"}}, {"a" => { "c" => "bb" },"b" => { "c" => "bb" }})
+        }
+    end
+
+    def test_assert_includes_array
+        assert_includes( ["a"],[ "a","b"] )
+    end
+    
+    def test_demonstrate_failure
+        assert_raises (Test::Unit::AssertionFailedError) {
+            assert_includes(["a","b"],[ "a"])
+        }
+    end
+
+    class Trivial
+	attr_accessor :name
+	def initialize( name )
+	    @name = name
+	end
+    end
+    
+    def test_compare_object_tree_to_hash
+	assert_includes({"name" => "patrick"}, Trivial.new("patrick"))
+    end
+
+    def test_compare_object_tree_to_hash
+	assert_includes({"name" => { "name" => "patrick" }}, Trivial.new(Trivial.new("patrick")))
+    end
+
+   
+    # TODO:
+    # reports an error if either item is not a hash
+    # improve error reporting when comparing a hash to an array and vice versa
+    # add an enhanced version of assert equals
+end

data/test/test.formreader-2.0.rb

@@ -0,0 +1,352 @@
+
+class TestFormReader2 < Test::Unit::TestCase
+  # for each kind of html element
+  #   * test the parsed html element handles "assert_include" properly
+  #   * test submit the html element
+  # a few important bits:
+  #   * handle multiple elements in a form properly.
+  #     i.e. just because a field isn't name="field[]"
+  #          doesn't mean that multiple params on a field are lost.
+  #     also, you should be able to have multiple elements with the
+  #          same name, but different types
+  # this should work exactly the same for simple text elements.
+  # this will work very differently for select elements,
+  # testing of which IMHO is broken
+  #
+  # More notes from patrick:
+  # There are two dimensions of "multiples" on a form
+  #    * single or multiple elements in the html
+  #    * a request by the programmer that elements be returned as a array or as a string
+  #
+  # I have some simple templating constructs in here to help write the tests.
+  # I'm not using Narflates b/c this templating is only to support these tests;
+  # the FormReader code works on just html
+  #
+
+  include Web::Testing
+
+  def setup
+    @parser = nil
+  end
+
+  def make_form( content )
+    @parser = FormReader.new( "<form name='aForm'>" + content + "</form>" )
+  end
+
+  def get_fields
+    @parser.get_fields( "aForm" )
+  end
+
+  def merge_fields( edited_fields={} )
+    @parser.merge_fields( "aForm", edited_fields )
+  end
+
+  def get_options
+    @parser.get_options( "aForm" )
+  end
+
+  def test_blank_form
+    make_form ""
+    assert_equal( {}, get_fields )
+    assert_equal( {}, merge_fields )
+    assert_raises( Web::Testing::FieldNotFoundException ) {
+      merge_fields( "missing" => "element" )
+    }
+  end
+
+
+  # -----------------------------------------
+  # the text elements should behave similarly
+  # -----------------------------------------
+  
+  def test_plain_input
+    do_text_tests <<-HTML
+    <input name="{name}" value="{value}">
+    HTML
+  end
+
+  def test_text
+    do_text_tests <<-HTML
+    <input type="text" name="{name}" value="{value}">
+    HTML
+  end
+
+  def test_password
+    do_text_tests <<-HTML
+    <input type="password" name="{name}" value="{value}">
+    HTML
+  end
+
+  def test_textarea
+    do_text_tests <<-HTML
+    <textarea name="{name}">
+    {value}
+    </textarea>
+    HTML
+  end
+
+  def test_hidden
+    do_text_tests <<-HTML
+    <input type="hidden" name="{name}" value="{value}">
+    HTML
+  end
+
+  def make_text_field( pattern, name, value )
+    pattern.gsub( /\{name\}/i, name ).gsub( /\{value\}/i, value )
+  end
+
+  def do_text_tests( field_pattern )
+    make_form( make_text_field( field_pattern, "atextfield", "avalue" ) )
+
+    assert_includes( { "atextfield" => "avalue" }, get_fields )
+    assert_equal( { "atextfield" => ["avalue"] }, merge_fields )
+
+    assert_equal( { "atextfield" => ["other"] },
+                   merge_fields( "atextfield" => "other" ) )
+    assert_equal( { "atextfield" => ["other"] },
+                   merge_fields( :atextfield  => "other" ) )
+
+    assert_raises( FormMergeError ) {
+      merge_fields( "atextfield" => [ "one", "two" ] )
+    }
+
+    # multiple elements.  Note that it doesn't matters
+    # how the programmer wants the cgi to return results,
+    # s/he still tests multiple elements the same
+    # i.e. "field" and "field[]" behave the same
+    # when asserting content on a form or merging elements
+    make_form( make_text_field( field_pattern, "atextfield[]", "two" ) + 
+               make_text_field( field_pattern, "atextfield[]", "one" ) )
+
+    assert_includes( { "atextfield[]" => ["two", "one"] }, get_fields )
+    assert_equal(   { "atextfield[]" => ["two", "one"] }, merge_fields )
+
+    make_form( make_text_field( field_pattern, "atextfield", "two" ) + 
+               make_text_field( field_pattern, "atextfield", "one" ) )
+
+    assert_includes( { "atextfield" =>["two", "one"] }, get_fields )
+    assert_equal(   { "atextfield" => ["two", "one"] }, merge_fields )
+
+    # if you merge a multiple with a string,
+    # the string replaces the first element
+    # in the multiple
+    assert_equal( { "atextfield" => ["first", "one"] },
+                   merge_fields( :atextfield => "first" ) )
+    assert_equal( { "atextfield" => ["first", "second"] },
+                   merge_fields( :atextfield => ["first", "second"] ) )
+    assert_raises( FormMergeError ) {
+      merge_fields( :atextfield => ["first", "second", "third"] )
+    }
+
+  end
+
+  # -----------------------------------------
+  # file uploads may be odd
+  # -----------------------------------------
+  
+  def test_file
+    make_form( make_file_field( "file" ) )
+    assert_includes( { "file" => "" }, get_fields )
+    ### do browsers send the file field when
+    ### nothing was entered?
+    assert_equal( {"file" => [""] }, merge_fields )
+    
+    upload = Web::Upload.new( File.new( "test/testfiles/text" ),
+                              "content-type",
+                              "original-filename" ) 
+    assert_equal( { "file" => [upload] },
+                  merge_fields( :file => upload ) )
+  end
+  
+  def make_file_field( name )
+    "<input type=\"file\" name=\"#{name}\">"
+  end
+  
+  # -----------------------------------------
+  # use the same api for:
+  #    single selects and radio buttons
+  #    multi selects and checkboxes
+  # since they more or less are used
+  # to say same thing on a form
+  # -----------------------------------------
+  
+  def test_select
+    do_select_tests <<-HTML
+    <select name="{name}">
+    {option}<option {checked}selected{endchecked}>{value}</option>{endoption}
+    </select>
+    HTML
+
+    do_select_tests <<-HTML
+    <select name="{name}">
+    {option}<option value="{value}" {checked}selected{endchecked}></option>{endoption}
+    </select>
+    HTML
+    do_multiselect_tests <<-HTML
+    <select name="{name}" multiple>
+    {option}<option {checked}selected{endchecked}>{value}</option>{endoption}
+    </select>
+    HTML
+    
+    # select field + select field = two different select fields
+
+  end
+
+  def test_radio_and_checkbox
+    do_select_tests <<-HTML
+    {option}<input type="radio" name="{name}" value="{value}" {checked}checked{endchecked}>{endoption}
+    HTML
+
+    do_select_tests <<-HTML
+    <select name="{name}">
+    {option}<option value="{value}" {checked}selected{endchecked}></option>{endoption}
+    </select>
+    HTML
+    
+    do_multiselect_tests <<-HTML
+    <select name="{name}" multiple>
+    {option}<option {checked}selected{endchecked}>{value}</option>{endoption}
+    </select>
+    HTML
+    
+    # select field + select field = two different select fields
+
+    # checkboxes + checkboxes = one big group of checkboxes
+    # that can return multiple values
+    
+    # radio buttons + radio buttons = one big group of radio buttons
+    # that can return one value
+
+    # checkboxes + radio buttons = ?????
+  end
+
+  def make_select_field( pattern, name, values )
+    pattern.gsub!( /\{NAME\}/i, name )
+    pattern =~ /\{OPTION\}(.*)\{ENDOPTION\}/si
+    option_pattern = $1
+    options = ""
+    values.each{ |k,v|
+      options += option_pattern.gsub( /\{VALUE\}/i, k ). \
+                 gsub( if v
+                         /\{CHECKED\}|\{ENDCHECKED\}/i
+                       else
+                         /\{CHECKED\}.*\{ENDCHECKED\}/i
+                       end, "" )
+    }
+    pattern.gsub( /\{OPTION\}.*\{ENDOPTION\}/i, options )
+  end
+  
+
+  def do_select_tests( pattern )
+    make_form( make_select_field( pattern,
+                                  "field",
+                                  {"first" => true,
+                                   "second" => false } ) )
+    
+    assert_includes( { "field" => "first" }, get_fields )
+    assert_equal(   { "field" => ["first"] }, merge_fields )
+    assert_equal(   { "field" => ["second"] },
+                    merge_fields( "field" => select("second") ) )
+    assert_raises( FormMergeError ) {
+      merge_fields( "field" => select("missing value") )
+    }
+
+    assert_raises( FormMergeError ) {
+      merge_fields( "field" => select("first", "second") )
+    }
+   
+  end
+
+  def do_multiselect_tests( pattern )
+    make_form( make_select_field( pattern,
+                                  "field",
+                                  {"first"  => true,
+                                   "second" => false,
+                                   "third"  => true } ) )
+    assert_includes( { "field" => ["first", "third"] }, get_fields )
+    assert_includes( { "field" => ["first", "second", "third"] }, get_options )
+    assert_equal(   { "field" => ["first", "third"] }, merge_fields )
+
+    # three cases for merge_fields with selects:
+    # using the select function:
+    # * a single text value adds to the selected values
+    assert_equal(   { "field" => ["first", "second", "third" ] },
+                    merge_fields( "field" => select("second") ) )
+    # * an multiples add to the selected values
+    assert_equal(   { "field" => ["first", "second", "third" ] },
+                    merge_fields( "field" => select("second","third") ) )
+    
+    # * a hash turns values on and off
+    assert_equal(   { "field" => ["second", "third"] },
+                    merge_fields( "field" => {"first" => false,
+                                              "second" => true } ) )
+    assert_equal(   { "field" => ["second", "third"] },
+                    merge_fields( "field" => select("first" => false,
+                                                     "second" => true ) ) )
+
+
+    assert_raises( FormMergeError ) {
+      merge_fields( "field" => "not using select method" )
+    }
+
+    assert_raises( FormMergeError ) {
+      merge_fields( "field" => select("missing value") )
+    }
+
+    #assert_raises( FormMergeError ) {
+    #  merge_fields( "field" => ["first", "second"] )
+    #}
+
+  end
+  
+  # -----------------------------------------
+  # test checkboxes as booleans
+  # -----------------------------------------
+
+  def test_boolean_checkbox
+    html = ""
+    
+    {"first"  => true,
+     "second" => false,
+     "third"  => true }.each{ |k, v|
+
+      html += "<input type=\"checkbox\" name=\"#{k}\"";
+      html += " checked" if (v)
+      html += ">";
+
+    }
+
+    make_form( html )
+
+    assert_includes( {"first"  => [true ],
+                      "second" => [false],
+                      "third"  => [true ]  }, get_fields   )
+    assert_equal(    {"first"  => [true ],
+                      "third"  => [true ]  }, merge_fields )
+    
+    # how to check a checkbox...
+    assert_equal( {"first"  => [true ],
+                   "second" => [true],
+                   "third"  => [true ]  },
+                  merge_fields( "second" => true ) )
+
+    # how to uncheck a check box
+    assert_equal( {"second" => [true],
+                   "third"  => [true ]  },
+                  merge_fields( "first"  => false,
+                                "second" => true   ) )
+
+  end
+
+  # -----------------------------------------
+  # test blending different kinds
+  # of elements into the same
+  # "field" or "field[]"
+  # -----------------------------------------
+
+  # -----------------------------------------
+  # test fields with narflate style names,
+  # i.e. "field[1].name" / etc
+  # -----------------------------------------
+
+end