dc-kwalify 0.7.2 → 1.0.0

data/test/test-rule.rb

@@ -1,26 +0,0 @@
-###
-### $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

@@ -1,317 +0,0 @@
-##
-## $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

@@ -1,75 +0,0 @@
-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

@@ -1,125 +0,0 @@
-###
-### $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

@@ -1,95 +0,0 @@
-###
-### $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