dc-kwalify 0.7.2

data/test/test-rule.rb

@@ -0,0 +1,26 @@
+###
+### $Rev$
+### $Release: 0.7.2 $
+### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+###
+
+require File.dirname(__FILE__) + '/test.rb'
+
+
+class RuleTest < Test::Unit::TestCase
+
+  ## define test methods
+  filename = __FILE__.sub(/\.rb$/, '.yaml')
+  load_yaml_testdata(filename, :lang=>'ruby')
+
+
+  ## execute test
+  def _test()
+    assert_nothing_raised do
+      return if $target && $target != @name
+      schema = @schema
+      rule = Kwalify::Rule.new(schema)
+    end
+  end
+
+end

data/test/test-rule.yaml

@@ -0,0 +1,317 @@
+##
+## $Rev$
+## $Release: 0.7.2 $
+## copyright(c) 2005-2010 kuwata-lab all rights reserved.
+##
+---
+name:   sequence1
+desc:   basic sequence
+input: |
+  type: seq
+  sequence:
+    - type: str
+#
+---
+name:   mapping1
+desc:   basic mapping
+input: |
+  type:       map
+  mapping:
+   "name":
+      type:      str
+      required:  yes
+   "email":
+      type:      str
+      pattern:   /@/
+   "age":
+      type:      int
+   "birth":
+      type:      date
+#
+---
+name:   seqmap1
+desc:   mapping of sequence
+input: |
+  type:      seq
+  sequence:
+    - type:      map
+      mapping:
+       "name":
+          type:      str
+          required:  true
+       "email":
+          type:      str
+#
+---
+name:  mapseq1
+desc:  mapping of sequence
+input: |
+  type:      map
+  mapping:
+   "company":
+      type:      str
+      required:  yes
+   "email":
+      type:      str
+   "employees":
+      type:      seq
+      sequence:
+        - type:    map
+          mapping:
+           "code":
+              type:      int
+              required:  yes
+           "name":
+              type:      str
+              required:  yes
+           "email":
+              type:      str
+#
+---
+name: unique1
+desc: unique constraint
+input: |
+  type: seq
+  sequence:
+    - type:     map
+      required: yes
+      mapping:
+       "name":
+          type:     str
+          required: yes
+          unique:   yes
+       "email":
+          type:     str
+       "groups":
+          type:     seq
+          sequence:
+            - type: str
+              unique:   yes
+---
+name:  constraints1
+desc:  some constraints
+input: |
+  name:      address-book
+  desc:      Address book
+  type:      seq
+  sequence:
+    - type:      map
+      mapping:
+       "name":
+          type:       str
+          required:   yes
+       "email":
+          type:       str
+          required:   yes
+          pattern:    /@/
+       "password":
+          type:       str
+          length:     { max: 16, min: 8 }
+       "age":
+          type:       int
+          range:      { max: 30, min: 18 }
+          # or assert: 18 <= val && val <= 30
+       "blood":
+          type:       str
+          enum:
+            - A
+            - B
+            - O
+            - AB
+       "birth":
+          type:       date
+       "memo":
+          type:       any
+       "deleted"
+          type:       bool
+          default:    false  
+#
+---
+name:  default1
+desc:  default rule
+input: |
+  type: map
+  mapping:
+   "properties":
+      type: map
+      mapping:
+       =:
+          type: any
+#
+---
+name:  default2
+desc:  default rule #2
+input: |
+  type: seq
+  sequence:
+    - type: map
+      mapping:
+       "name":
+          type: str
+          required: yes
+       "email":
+          type: str
+       "birth":
+          type: date
+       =:
+          type: any
+#
+---
+name:  merge1
+desc:  merge rule
+input: |
+  type: map
+  mapping:
+   "group":
+      type: map
+      mapping:
+       "name": &name
+          type: str
+          required: yes
+       "email": &email
+          type: str
+          pattern: /@/
+          required: no
+   "user":
+      type: map
+      mapping:
+       "name":
+          <<: *name             # merge
+          length: { max: 16 }   # append
+       "email":
+          <<: *email            # merge
+          required: yes         # overwrite
+#
+---
+name:  anchor1
+desc:  sharing rule with anchor and alias
+input: |
+  desc:   Bookshelf
+  type:   seq
+  sequence:
+    - type:   map
+      mapping:
+       "title":
+          type:   str
+          required: yes
+       "author":  &persons       # anchor
+          type:   seq
+          sequence:
+            - type: str
+       "translator": *persons     # alias
+       "publisher":
+          type:   str
+       "year":
+          type:   int
+#
+---
+name:  anchor2
+desc:  recursive definition of rule
+input: |
+  &task                  # anchor
+  desc:   WBS
+  type:   map
+  mapping:
+   "name":      { type: str, required: yes }
+   "assigned":  { type: str }
+   "deadline":  { type: date }
+   "subtasks":
+      type:  seq
+      sequence:
+        - *task          # alias
+---
+name: meta_schema
+desc: schema for meta-validator
+#
+input: |
+  name:      MAIN
+  type:      map
+  required:  yes
+  mapping:   &main-rule
+   "name":
+      type:      str
+   "desc":
+      type:      str
+   "type":
+      type:      str
+      #required:  yes
+      enum:
+        - seq
+        #- sequence
+        #- list
+        - map
+        #- mapping
+        #- hash
+        - str
+        #- string
+        - int
+        #- integer
+        - float
+        - number
+        #- numeric
+        - bool
+        #- boolean
+        - text
+        - date
+        - time
+        - timestamp
+        #- object
+        - any
+        - scalar
+        #- collection
+   "required":
+      type:      bool
+   "enum":
+      type:      seq
+      sequence:
+        - type:     scalar
+          unique:   yes
+   "pattern":
+      type:      str
+   "assert":
+      type:      str
+      pattern:   /\bval\b/
+   "range":
+      type:      map
+      mapping:
+       "max":
+          type:     scalar
+       "min":
+          type:     scalar
+       "max-ex":
+          type:     scalar
+       "min-ex":
+          type:     scalar
+   "length":
+      type:      map
+      mapping:
+       "max":
+          type:     int
+       "min":
+          type:     int
+       "max-ex":
+          type:     int
+       "min-ex":
+          type:     int
+   "ident":
+      type:      bool
+   "unique":
+      type:      bool
+   "sequence":
+      name:      SEQUENCE
+      type:      seq
+      sequence:
+        - type:      map
+          mapping:   *main-rule
+          name:      MAIN
+          #required:  yes
+   "mapping":
+      name:      MAPPING
+      type:      map
+      mapping:
+        =:
+          type:      map
+          mapping:   *main-rule
+          name:      MAIN
+          #required:  yes
+

data/test/test-users-guide.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test/test.rb')
+
+class UsersGuideTest < Test::Unit::TestCase
+
+  DATA_DIR = 'data/users-guide'
+  CURR_DIR = Dir.pwd
+  for item in Dir.glob("#{DATA_DIR}/*.result").sort()
+    filename = File.basename(item)
+    name = (filename =~ /(.*)\.\w+$/) && $1.gsub(/[^\w]/, '_')
+    s = <<-END
+      def test_#{name}
+        @name = #{name.inspect}
+        @filename = #{filename.inspect}
+        _test()
+      end
+    END
+    eval s
+  end
+
+### BEGIN
+  def test_address_book_ruby
+    @command = 'kwalify -a genclass-ruby -tf address_book.schema.yaml'
+    @result = File.read('address_book.rb')
+    _test()
+  end
+  def test_example_address_book_ruby
+    @command = 'ruby example_address_book.rb'
+    @result = File.read('example_address_book_ruby.result')
+    @testopts = { 'delete_object_id' => true }
+    _test()
+  end
+### END
+
+  def setup
+    Dir.chdir DATA_DIR
+  end
+
+  def teardown
+    Dir.chdir CURR_DIR
+  end
+
+  def _test
+    #@name ||= (caller()[0] =~ /in `test_(.*?)'/) && $1
+    @name = (self.name =~ /\Atest_(.*)\(.*\)\z/) && $1
+    return if @name =~ /\_java$/
+    @filename ||= @name + '.result'
+
+    result = @result || File.read(@filename)
+    tuples = result.split(/^(?=\$ )/).collect do |s|
+      if s.sub!(/\A\$ (.*)\n/, '')
+        command = $1
+        while command =~ /\\\z/
+          command.chop!
+          s.sub!(/\A(.*)\n/, '')
+          command << $1
+        end
+        [@command || command, @expected || s]
+      else
+        [@command, @expected || s]
+      end
+    end
+
+    tuples.each do |command, expected|
+      actual = @actual || `#{command}`
+      #if @testopts && @testops['delete_object_id']
+        rexp = /(\#<\w+(::\w+)*:)0x[0-9a-f]+/
+        actual.gsub!(rexp, '\1')
+        expected.gsub!(rexp, '\1')
+      #end
+      assert_text_equal(expected, actual)
+    end
+
+  end
+
+end

data/test/test-util.rb

@@ -0,0 +1,125 @@
+###
+### $Rev$
+### $Release: 0.7.2 $
+### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+###
+
+require File.dirname(__FILE__) + '/test.rb'
+
+require 'kwalify/util'
+
+
+class UtilTest < Test::Unit::TestCase
+
+  def spec(detail)
+    yield
+  end
+
+  def test_untabify
+    spec "converts tab characters to spaces" do
+      input    = "123\t999"
+      expected = "123     999"
+      assert_text_equal expected, Kwalify::Util.untabify(input)
+    end
+    spec "able to specify column width" do
+      input    = "12\t999"
+      expected = "12  999"
+      assert_text_equal expected, Kwalify::Util.untabify(input, 4)
+    end
+    spec "able to handle multiline string" do
+      input    = "123\n\t456\n789\t0"
+      expected = "123\n        456\n789     0"
+      assert_text_equal expected, Kwalify::Util.untabify(input)
+    end
+    spec "returns nil if argument is nil" do
+      assert_nil Kwalify::Util.untabify(nil)
+    end
+    spec "don't remove tailing spaces" do   # bugfix
+      input    = "abc\t\t"
+      expected = "abc             "
+      assert_text_equal expected, Kwalify::Util.untabify(input)
+    end
+  end
+
+  SCHEMA1 = <<END
+type: seq
+sequence:
+  - type: map
+    class: Member
+    mapping:
+     "name": { type: str, required: true }
+     "age":  { type: int, required: false }
+END
+
+  def test_traverse
+    spec "traverse schema structure" do
+      schema = YAML.load(SCHEMA1)
+      assert_equal "Member", schema["sequence"][0]["class"]
+      Kwalify::Util.traverse_schema(schema) do |rulehash|
+        ## add module prefix to class name
+        if rulehash['class']
+          rulehash['class'] = 'MyModule::' + rulehash['class']
+        end
+      end
+      assert_equal "MyModule::Member", schema["sequence"][0]["class"]
+    end
+  end
+
+  def test_traverse_rule
+    spec "traverse rule" do
+      schema = YAML.load(SCHEMA1)
+      validator = Kwalify::Validator.new(schema)
+      rules = []
+      Kwalify::Util.traverse_rule(validator) do |rule|
+        rules << rule
+      end
+      assert_equal 4, rules.length
+      assert_text_equal <<'END', rules[0].send(:_inspect)
+type:    seq
+klass:    Array
+  - 
+    type:    map
+    klass:    Hash
+      "name":
+        type:    str
+        klass:    String
+        required:  true
+      "age":
+        type:    int
+        klass:    Integer
+        required:  false
+END
+      assert_text_equal <<'END', rules[1].send(:_inspect)
+type:    map
+klass:    Hash
+  "name":
+    type:    str
+    klass:    String
+    required:  true
+  "age":
+    type:    int
+    klass:    Integer
+    required:  false
+END
+      assert_text_equal <<'END', rules[2].send(:_inspect)
+type:    str
+klass:    String
+required:  true
+END
+      assert_text_equal <<'END', rules[3].send(:_inspect)
+type:    int
+klass:    Integer
+required:  false
+END
+    end
+  end
+
+  def test_get_value
+    schema = YAML.load(SCHEMA1)
+    path = ['sequence', 0, 'mapping', 'name', 'type']
+    assert_equal 'str', Kwalify::Util.get_value(schema, path)
+    path = ['sequence', 1, 'mapping', 'name', 'type']
+    assert_equal nil,   Kwalify::Util.get_value(schema, path)
+  end
+
+end

data/test/test-validator.rb

@@ -0,0 +1,95 @@
+###
+### $Rev$
+### $Release: 0.7.2 $
+### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+###
+
+require File.dirname(__FILE__) + '/test.rb'
+
+
+class ValidatorTest < Test::Unit::TestCase
+
+
+  ## define test methods
+  filename = __FILE__.sub(/\.rb$/, '.yaml')
+  load_yaml_testdata(filename, :lang=>'ruby')
+
+
+  ## execute test
+  def _test()
+    return if $target && $target != @name
+    ## Syck parser
+    schema = YAML.load(@schema)
+    validator = Kwalify::Validator.new(schema)
+    error2 = @error.gsub(/\(line \d+\)/, '')
+    _test_by_syck_parser(validator, @valid,   ''    )
+    _test_by_syck_parser(validator, @invalid, error2)
+    ## Kwalify::YamlParser
+    schema = Kwalify::YamlParser.new(@schema).parse()
+    validator = Kwalify::Validator.new(schema)
+    _test_by_kwalify_yamlparser(validator, @valid,   ''    )
+    _test_by_kwalify_yamlparser(validator, @invalid, @error)
+    ## Kwalify::Yaml::Parser
+    schema = Kwalify::Yaml::Parser.new().parse(@schema)
+    validator = Kwalify::Validator.new(schema)
+    _test_by_kwalify_yaml_parser(validator, @valid,   ''    )
+    _test_by_kwalify_yaml_parser(validator, @invalid, @error2 || @error)
+  end
+
+
+  def _test_by_kwalify_yamlparser(validator, input, expected)
+    parser = Kwalify::YamlParser.new(input)
+    document = parser.parse()
+    error_list  = validator.validate(document)
+    parser.set_errors_linenum(error_list)
+    error_list.sort!
+    actual = ''
+    error_list.each do |error|
+      e = error
+      args = [e.error_symbol.inspect, e.linenum, e.path, e.message]
+      actual << "%-20s: (line %d)[%s] %s\n" % args
+    end
+    if $print
+      print actual
+    else
+      assert_text_equal(expected, actual)
+    end
+  end
+
+
+  def _test_by_kwalify_yaml_parser(validator, input, expected)
+    parser = Kwalify::Yaml::Parser.new(validator)
+    document = parser.parse(input)
+    error_list  = parser.errors()
+    error_list.sort!
+    actual = ''
+    error_list.each do |error|
+      e = error
+      args = [e.error_symbol.inspect, e.linenum, e.column, e.path, e.message]
+      #actual << "%-20s: (line %d)[%s] %s\n" % args
+      actual << "%-20s: %d:%d:[%s] %s\n" % args
+    end
+    if $print
+      print actual
+    else
+      assert_text_equal(expected, actual)
+    end
+  end
+
+
+  def _test_by_syck_parser(validator, input, expected)
+    document = YAML.load(input)
+    error_list  = validator.validate(document)
+    expected = expected.to_a.sort.join()
+    actual = error_list.collect { |e|
+      "%-20s: [%s] %s\n" % [e.error_symbol.inspect, e.path, e.message]
+    }.sort.join()
+    if $print
+      print actual
+    else
+      assert_text_equal(expected, actual)
+    end
+  end
+
+
+end