kwalify 0.5.1 → 0.6.0

data/lib/kwalify/util/assert-text-equal.rb

@@ -0,0 +1,44 @@
+###
+### $Rev: 51 $
+### $Release: 0.6.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+require 'test/unit/testcase'
+require 'tempfile'
+
+
+class Test::Unit::TestCase  # :nodoc:
+
+   def assert_text_equal(expected, actual, message=nil, options={}) # :nodoc:
+      diffopt  = options[:diffopt] || '-u'
+      flag_cut = options.key?(:cut) ? options[:key] : true
+
+      if expected == actual
+         assert(true)
+         return
+      end
+      if expected[-1] != ?\n || actual[-1] != ?\n
+         expected += "\n"
+         actual   += "\n"
+      end
+      begin
+         expfile = Tempfile.new(".expected.")
+         expfile.write(expected); expfile.flush()
+         actfile = Tempfile.new(".actual.")
+         actfile.write(actual);   actfile.flush()
+         diff = `diff #{diffopt} #{expfile.path} #{actfile.path}`
+      ensure
+         expfile.close(true) if expfile
+         actfile.close(true) if actfile
+      end
+      # cut 1st & 2nd lines
+      message = (flag_cut ? diff.gsub(/\A.*\n.*\n/, '') : diff) unless message
+      #raise Test::Unit::AssertionFailedError.new(message)
+      assert_block(message) { false }  # or assert(false, message)
+   end
+
+   alias assert_equal_with_diff assert_text_equal    # for compatibility
+   alias assert_text_equals     assert_text_equal    # for typo
+
+end

data/lib/kwalify/util/hash-interface.rb

@@ -0,0 +1,37 @@
+###
+### $Rev: 51 $$
+### $Release: 0.6.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+module Kwalify
+
+   module HashInterface
+
+      def [](key)
+         instance_variable_get("@{key}")
+      end
+
+      def []=(key, val)
+         instance_variable_set("@{key}", val)
+      end
+
+      def keys()
+         instance_variables.collect { |name| name[1, name.length-1] }
+      end
+
+      def key?(key)
+         instance_variables.include?("@#{key}")
+      end
+
+      def each
+         instance_variables.each do |name|
+            key = name[1, name.length-1]
+            val = instance_varaible_get(name)
+            yield(key, val)
+         end
+      end
+
+   end
+
+end

data/lib/kwalify/util/option-parser.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 41 $
-### $Release: 0.5.1 $
+### $Rev: 51 $
+### $Release: 0.6.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 

data/lib/kwalify/util/testcase-helper.rb

@@ -0,0 +1,112 @@
+###
+### $Rev: 51 $
+### $Release: 0.6.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+require 'yaml'
+require 'test/unit/testcase'
+
+
+class Test::Unit::TestCase   # :nodoc:
+
+
+  def self._untabify(str, width=8)         # :nodoc:
+    sb = []
+    str.scan(/(.*?)\t/m) do |s, |
+      len = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
+      sb << s << (" " * (width - len % width))
+    end
+    str = (sb << $').join if $'
+    return str
+  end
+
+
+  def self.load_yaml_documents(filename, options={})   # :nodoc:
+    str = File.read(filename)
+    if filename =~ /\.rb$/
+      str =~ /^__END__$/   or raise "*** error: __END__ is not found in '#{filename}'."
+      str = $'
+    end
+    str = _untabify(str) unless options[:tabify] == false
+    #
+    identkey = options[:identkey] || 'name'
+    list = []
+    table = {}
+    YAML.load_documents(str) do |ydoc|
+      if ydoc.is_a?(Hash)
+        list << ydoc
+      elsif ydoc.is_a?(Array)
+        list += ydoc
+      else
+        raise "*** invalid ydoc: #{ydoc.inspect}"
+      end
+    end
+    #
+    list.each do |ydoc|
+      ident = ydoc[identkey]
+      ident         or  raise "*** #{identkey} is not found."
+      table[ident]  and raise "*** #{identkey} '#{ident}' is duplicated."
+      table[ident] = ydoc
+      yield(ydoc) if block_given?
+    end
+    #
+    return list
+  end
+
+
+  def self.load_yaml_testdata(filename, options={})   # :nodoc:
+    identkey   = options[:identkey]   || 'name'
+    testmethod = options[:testmethod] || '_test'
+    lang       = options[:lang]
+    load_yaml_documents(filename, options) do |ydoc|
+      ident = ydoc[identkey]
+      s  =   "def test_#{ident}\n"
+      ydoc.each do |key, val|
+        if key[-1] == ?*
+          key = key[0, key.length-1]
+          val = val[lang]
+        end
+        s << "  @#{key} = #{val.inspect}\n"
+      end
+      s  <<  "  #{testmethod}\n"
+      s  <<  "end\n"
+      #$stderr.puts "*** #{method_name()}(): eval_str=<<'END'\n#{s}END" if $DEBUG
+      module_eval s   # not eval!
+    end
+  end
+
+
+  def self.method_name   # :nodoc:
+    return (caller[0] =~ /in `(.*?)'/) && $1
+  end
+
+
+  def self.load_yaml_testdata_with_each_lang(filename, options={})   # :nodoc:
+    identkey   = options[:identkey]   || 'name'
+    testmethod = options[:testmethod] || '_test'
+    langs = defined?($lang) && $lang ? [ $lang ] : options[:langs]
+    langs or raise "*** #{method_name()}(): option ':langs' is required."
+    #
+    load_yaml_documents(filename, options) do |ydoc|
+      ident = ydoc[identkey]
+      langs.each do |lang|
+        s  =   "def test_#{ident}_#{lang}\n"
+        s  <<  "  @lang = #{lang.inspect}\n"
+        ydoc.each do |key, val|
+          if key[-1] == ?*
+            key = key[0, key.length-1]
+            val = val[lang]
+          end
+          s << "  @#{key} = #{val.inspect}\n"
+        end
+        s  <<  "  #{testmethod}\n"
+        s  <<  "end\n"
+        #$stderr.puts "*** #{method_name()}(): eval_str=<<'END'\n#{s}END" if $DEBUG
+        module_eval s   # not eval!
+      end
+    end
+  end
+
+
+end

data/lib/kwalify/util/yaml-helper.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 41 $
-### $Release: 0.5.1 $
+### $Rev: 51 $
+### $Release: 0.6.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 

data/lib/kwalify/validator.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 42 $
-### $Release: 0.5.1 $
+### $Rev: 48 $
+### $Release: 0.6.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 

data/lib/kwalify/yaml-parser.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 44 $
-### $Release: 0.5.1 $
+### $Rev: 51 $
+### $Release: 0.6.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -193,7 +193,7 @@ module Kwalify
          case value
          when /^-( |$)/
             data = parse_sequence(value_start_column, value)
-         when /^(:?[-.\w]+|'.*?'|".*?"|=|<<) *:( |$)/
+         when /^(:?:?[-.\w]+\*?|'.*?'|".*?"|=|<<) *:( |$)/
          #when /^:?["']?[-.\w]+["']? *:( |$)/			#'
             data = parse_mapping(value_start_column, value)
          when /^\[/, /^\{/
@@ -471,12 +471,13 @@ module Kwalify
 
       def parse_block_text(column, value)
          assert value =~ /^[>|\|]/
-         value =~ /^([>|\|])([-+]?)\s*(.*)$/
+         value =~ /^([>|\|])([-+]?)(\d+)?\s*(.*)$/
          char = $1
          indicator = $2
          sep = char == "|" ? "\n" : " "
-         #text = $3.empty? ? '' :  $3 + sep
-         text = $3
+         margin = $3 && !$3.empty? ? $3.to_i : nil
+         #text = $4.empty? ? '' :  $4 + sep
+         text = $4
          s = ''
          empty = ''
          min_indent = -1
@@ -493,8 +494,9 @@ module Kwalify
                empty = ''
             end
          end
-         s << empty if indicator == '+'
+         s << empty if indicator == '+' && char != '>'
          s[-1] = "" if indicator == '-'
+         min_indent = column + margin - 1 if margin
          if min_indent > 0
             sp = ' ' * min_indent
             s.gsub!(/^#{sp}/, '')
@@ -502,6 +504,7 @@ module Kwalify
          if char == '>'
             s.gsub!(/([^\n])\n([^\n])/, '\1 \2')
             s.gsub!(/\n(\n+)/, '\1')
+            s << empty if indicator == '+'
          end
          getline() if current_line() =~ /^\s*\#/
          return create_scalar(text + s)
@@ -547,11 +550,11 @@ module Kwalify
 
       def parse_mapping(column, value)
          #assert value =~ /^(:?["']?[-.\w]+["']? *):(( +)(.*))?$/         #'
-         assert value =~ /^((?::?[-.\w]+|'.*?'|".*?"|=|<<) *):(( +)(.*))?$/
+         assert value =~ /^((?::?[-.\w]+\*?|'.*?'|".*?"|=|<<) *):(( +)(.*))?$/
          map = create_mapping()  # {}
          while true
             #unless value =~ /^(:?["']?[-.\w]+["']? *):(( +)(.*))?$/      #'
-            unless value =~ /^((?::?[-.\w]+|'.*?'|".*?"|=|<<) *):(( +)(.*))?$/
+            unless value =~ /^((?::?[-.\w]+\*?|'.*?'|".*?"|=|<<) *):(( +)(.*))?$/
                #* key=:mapping_noitem  msg="mapping item is expected."
                raise syntax_error(:mapping_noitem)
             end

data/test/test-main.rb

@@ -1,21 +1,13 @@
 ###
-### $Rev: 42 $
-### $Release: 0.5.1 $
+### $Rev: 51 $
+### $Release: 0.6.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
-unless defined?(TESTDIR)
-   TESTDIR = File.dirname(__FILE__)
-   libdir  = File.dirname(TESTDIR) + "/lib"
-   $LOAD_PATH << libdir << TESTDIR
-end
+require File.dirname(__FILE__) + '/test.rb'
+
+require 'kwalify/main'
 
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-require 'kwalify'
-require 'kwalify/util/assert-diff'
-require 'kwalify/main.rb'
-require 'yaml'
 
 module Kwalify
    class Main
@@ -23,64 +15,19 @@ module Kwalify
    end
 end
 
+
 class File
    def self.move(filename, dirname)
-      File.rename(filename, "#{dirname}/filename")
+      File.rename(filename, "#{dirname}/#{filename}")
    end
 end
 
+
 class MainTest < Test::Unit::TestCase
 
    ## define test methods
    filename = __FILE__.sub(/\.rb$/, ".yaml")
-   str = File.read(filename)
-   @@docs = {}
-   YAML.load_documents(str) do |doc|
-      name = doc['name']
-      !@@docs.key?(name) or raise "*** test name '#{name}' is duplicated."
-      @@docs[name] = doc
-      doc.each do |key, val|
-         doc[$1] ||= val['ruby'] if key =~ /\A(.*)\*\z/
-      end
-      s = <<-END
-         def test_#{name}
-            doc = @@docs['#{name}']
-            @name      = doc['name']
-            @desc      = doc['desc']
-            @args      = doc['args']
-            @inspect   = doc['inspect']
-            @exception = #{doc['exception'] ? "Kwalify::" + doc['exception'] : 'nil'}
-            @error_symbol = doc['error_symbol']
-            @expected  = doc['expected']
-            @schema    = doc['schema']
-            @document  = doc['document']
-            @valid     = doc['valid']
-            @invalid   = doc['invalid']
-            @valid_out = doc['valid-out']
-            @invalid_out = doc['invalid-out']
-            @method    = doc['method']
-            # @options   = doc['options']
-
-            case @method
-            when 'parseOptions'
-               _test_parse_options()
-            when 'execute'
-               raise "*** #{doc['name']}: args is not defined."    unless doc['args']
-               raise "*** #{doc['name']}: expected is not defined."  unless doc['expected']
-               _test_execute()
-            when 'validation'
-               _test_validation()
-               raise "*** #{doc['name']}: schema is not defined."  unless doc['schema']
-               raise "*** #{doc['name']}: valid is not defined."   unless doc['valid']
-               raise "*** #{doc['name']}: invalid is not defined." unless doc['invalid']
-
-            else
-               raise "*** #{@method}: invalid method name."
-            end
-         end
-      END
-      eval s
-   end
+   load_yaml_testdata(filename, :lang=>'ruby')
 
 
    ## temporary directory
@@ -88,6 +35,28 @@ class MainTest < Test::Unit::TestCase
    Dir.mkdir(@@tmpdir) unless test(?d, @@tmpdir)
 
 
+   def _test
+      if @exception
+         @exception_class = Kwalify.const_get(@exception)
+      end
+      case @method
+      when 'parseOptions'
+         _test_parse_options()
+      when 'execute'
+         _test_execute()
+      when 'validation'
+         raise "*** #{@name}: schema is not defined."  unless @schema
+         raise "*** #{@name}: valid is not defined."   unless @valid
+         raise "*** #{@name}: invalid is not defined." unless @invalid
+         _test_validation()
+      when 'action'
+         _test_action()
+      else
+         raise "*** #{@method}: invalid method name."
+      end
+   end
+
+
    ## validation test
    def _test_validation()
       return if $target && $target != @name
@@ -108,12 +77,12 @@ class MainTest < Test::Unit::TestCase
          main = Kwalify::Main.new('kwalify')
          args = [ "-lf", schema_filename, valid_filename ]
          output = main.execute(args)
-         assert_equal_with_diff(@valid_out, output)
+         assert_text_equal(@valid_out, output)
          #
          main = Kwalify::Main.new('kwalify')
          args = [ "-lf", schema_filename, invalid_filename ]
          output = main.execute(args)
-         assert_equal_with_diff(@invalid_out, output)
+         assert_text_equal(@invalid_out, output)
          #
       ensure
          File.move(schema_filename,  @@tmpdir)
@@ -122,31 +91,33 @@ class MainTest < Test::Unit::TestCase
       end
    end
 
+
    ## execute test
    def _test_execute()
       return if $target && $target != @name
-      raise "*** args is required when method is 'execute'." unless @args
-      raise "*** expected is required when method is 'execute'." unless @expected
+      raise "*** #{@name}: args is required."    unless @args
+      raise "*** #{@name}: expected is require." unless @expected
       #
       File.open("#{@name}.schema", 'w')   { |f| f.write(@schema)   } if @schema
       File.open("#{@name}.document", 'w') { |f| f.write(@document) } if @document
       #
       begin
          main = Kwalify::Main.new("kwalify")
-         if (! @exception)
-            actual = main.execute(@args)
-            assert_equal_with_diff(@expected, actual)
-         else
-            assert_raise(@exception) do
+         if @exception_class
+            assert_raise(@exception_class) do
                main.execute(@args)
             end
+         else
+            actual = main.execute(@args)
+            assert_text_equal(@expected, actual)
          end
       ensure
          File.move("#{@name}.schema",   @@tmpdir) if @schema
          File.move("#{@name}.document", @@tmpdir) if @document
       end
    end
-   
+
+
    ## command option test
    def _test_parse_options()
       return if $target && $target != @name
@@ -159,10 +130,10 @@ class MainTest < Test::Unit::TestCase
             s << "  - #{filename}\n"
          end
          actual = s
-         assert_equal_with_diff(@inspect, actual)
+         assert_text_equal(@expected, actual)
       rescue => ex
          #klass = @exception
-         if @exception && ex.class == @exception
+         if @exception_class && ex.class == @exception_class
             # OK
             assert_equal(@error_symbol, ex.error_symbol) if ex.respond_to?(:error_symbol)
          else
@@ -172,8 +143,36 @@ class MainTest < Test::Unit::TestCase
       end
    end
 
-end
 
-#if $0 == __FILE__
-#   Test::Unit::UI::Console::TestRunner.run(ValidatorTest)
-#end
+   ## execute test
+   def _test_action()
+      return if $target && $target != @name
+      raise "*** #{@name}: args is required."    unless @args
+      raise "*** #{@name}: expected is require." unless @expected
+      #
+      File.open("#{@name}.schema", 'w')   { |f| f.write(@schema)   } if @schema
+      File.open("#{@name}.document", 'w') { |f| f.write(@document) } if @document
+      #
+      begin
+         main = Kwalify::Main.new("kwalify")
+         actual = main.execute(@args)
+         if @output_files
+            assert(actual.nil? || actual=='')
+	    @output_files.each do |filename|
+               actual = File.read(filename)
+	       assert_text_equal(@expected[filename], actual)
+	    end
+         else
+	    assert_text_equal(@expected, actual)
+	 end
+      ensure
+         File.move("#{@name}.schema",   @@tmpdir) if @schema
+         File.move("#{@name}.document", @@tmpdir) if @document
+	 @output_files.each do |filename|
+            File.move(filename, @@tmpdir) if @document
+	 end if @output_files
+      end
+   end
+
+
+end