kwalify 0.4.1 → 0.5.0

data/test/test.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 31 $
-### $Release: 0.4.1 $
+### $Rev: 42 $
+### $Release: 0.5.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -10,9 +10,11 @@ unless defined?(TESTDIR)
    $LOAD_PATH << libdir << TESTDIR
 end
 
+require 'test-yamlparser.rb'
+require 'test-rule.rb'
 require 'test-validator.rb'
 require 'test-metavalidator.rb'
-require 'test-parser.rb'
+require 'test-main.rb'
 
 #suite = Test::Unit::TestSuite.new()
 #suite << ValidatorTest.suite()

data/todo.txt

@@ -31,3 +31,4 @@
 .- [_] test for kwalify command
 .- [_] error message customizatin
 .- [_] data binding
+.- [_] symbol support

metadata

@@ -1,10 +1,10 @@
-!ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
 specification_version: 1
 name: kwalify
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
-date: 2005-10-26 00:00:00 +09:00
+  version: 0.5.0
+date: 2005-12-18
 summary: a tiny schema validator for YAML document.
 require_paths: 
 - lib
@@ -23,22 +23,20 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
       version: 0.0.0
   version: 
 platform: ruby
-signing_key: 
-cert_chain: 
 authors: 
 - kwatch
 files: 
-- lib/kwalify
 - lib/kwalify.rb
+- lib/kwalify
 - lib/kwalify/errors.rb
-- lib/kwalify/main-program.rb
+- lib/kwalify/main.rb
 - lib/kwalify/messages.rb
 - lib/kwalify/meta-validator.rb
-- lib/kwalify/parser.rb
 - lib/kwalify/rule.rb
 - lib/kwalify/types.rb
-- lib/kwalify/util
 - lib/kwalify/validator.rb
+- lib/kwalify/yaml-parser.rb
+- lib/kwalify/util
 - lib/kwalify/util/assert-diff.rb
 - lib/kwalify/util/option-parser.rb
 - lib/kwalify/util/yaml-helper.rb
@@ -56,9 +54,16 @@ files:
 - examples/tapkit/tapkit.schema.yaml
 - examples/tapkit/tapkit.yaml
 - test/test-metavalidator.rb
-- test/test-parser.rb
 - test/test-validator.rb
 - test/test.rb
+- test/test-main.rb
+- test/test-main.yaml
+- test/test-rule.yaml
+- test/test-validator.yaml
+- test/test-rule.rb
+- test/test-yamlparser.yaml
+- test/test-yamlparser.rb
+- test/test-metavalidator.yaml
 - doc/users-guide.html
 - doc/docstyle.css
 - README.txt

data/lib/kwalify/main-program.rb

@@ -1,258 +0,0 @@
-###
-### $Rev: 39 $
-### $Release: 0.4.1 $
-### copyright(c) 2005 kuwata-lab all rights reserved.
-###
-
-require 'yaml'
-require 'kwalify'
-require 'kwalify/util/yaml-helper'
-require 'kwalify/util/option-parser'
-
-
-module Kwalify
-
-   ##
-   ## ex.
-   ##   command = File.basename($0)
-   ##   begin
-   ##      main = Kwalify::MainProgram.new(ARGV, command)
-   ##      s = main.execute
-   ##      print s if s
-   ##   rescue CommandOptionError => ex
-   ##      $stderr.puts "ERROR: #{ex.message}"
-   ##      exit 1
-   ##   rescue Kwalify::KwalifyError => ex
-   ##      $stderr.puts "ERROR: #{ex.message}"
-   ##      exit 1
-   ##   end
-   ##
-   class MainProgram
-
-      def initialize(argv=ARGV, command=nil)
-         @command = command || File.basename($0)
-         @options, @proerties = _parse_argv(argv)
-         @filenames = argv
-      end
-
-
-      def execute(filenames=@filenames)
-         if @options[:help] || @options[:version]
-            s = ''
-            s << _version() if @options[:version]
-            s << _usage()   if @options[:help]
-            return s
-         end
-         if @options[:meta] || @options[:meta2]
-            s = _meta_validate(filenames)
-         elsif @options[:schema]
-            if @options[:debug]
-               s = _inspect_schema(@options[:schema])
-            else
-               s = _validate(filenames)
-            end
-         else
-            #* key=:action_required  msg="command-line option '-f' or '-m' required."
-            raise CommandOptionError.new(nil, nil, Kwalify.msg(:action_required))
-         end
-         return s   # or return (s == nil || s.empty?) ? nil : s
-      end
-
-
-      private
-
-
-      def _load_yaml(str)
-         str = YamlHelper.untabify(tr) if @options[:untabify]
-         if @options[:linenum]
-            @parser = Kwalify::Parser.new(str)
-            doc = @parser.parse()
-         else
-            doc = YAML.load(str)
-            doc = doc.value if _domain_type?(doc)
-         end
-         return doc
-      end
-
-
-      def _meta_validate(filenames)
-         filenames = [ nil ] if filenames.empty?
-         meta_validator = @options[:meta2] ? nil : Kwalify.meta_validator()
-         flag_no_validate = @options[:meta2] == true
-         s = ''
-         filenames.each do |filename|
-            s << __meta_validate(meta_validator, filename)
-         end
-         return s
-      end
-
-
-      def __meta_validate(meta_validator, filename=nil)
-         str = filename ? File.open(filename) { |f| f.read() } : $stdin.read()
-         schema = _load_yaml(str)
-         filename ||= "(stdin)"
-         if !schema || schema.empty?
-            #* key=:meta_schema_empty  msg="%s: empty.\n"
-            return Kwalify.msg(:meta_schema_emtpy) % filename
-         end
-         errors = nil
-         if meta_validator
-            errors = meta_validator.validate(schema)
-         else
-            begin
-               validator = Kwalify::Validator.new(schema)  # error raised when schema is wrong
-            rescue Kwalify::SchemaError => ex
-               errors = [ ex ]
-            end
-         end
-         s = ''
-         if !errors || errors.empty?
-            #* key=:meta_validation_valid  msg="%s: ok.\n"
-            s << (Kwalify.msg(:meta_validation_valid) % filename) unless @options[:silent]
-         else
-            #* key=:meta_validation_invalid  msg="%s: NG!\n"
-            s << (Kwalify.msg(:meta_validation_invalid) % filename)
-            s << _errors_to_str(errors)
-         end
-         return s
-      end
-
-
-      def _errors_to_str(errors)
-         s = ''
-         flag_linenum = @options[:linenum]
-         if flag_linenum
-            @parser.set_error_linenums(errors)
-            errors = errors.sort { |e1, e2| e1.linenum <=> e2.linenum }
-         end
-         errors.each do |error|
-            if flag_linenum
-               s << "  - (line #{error.linenum}) [#{error.path}] #{error.message}\n"
-            else
-               s << "  - [#{error.path}] #{error.message}\n"
-            end
-         end
-         return s
-      end
-
-
-      def _validate(filenames)
-         schema_filename = @options[:schema]
-         str = File.open(schema_filename) { |f| f.read() }
-         schema = _load_yaml(str)
-         validator = Kwalify::Validator.new(schema)
-         #
-         filenames = [ nil ] if filenames.empty?
-         s = ''
-         filenames.each do |filename|
-            s << __validate(validator, filename)
-         end
-         return s
-      end
-
-
-      def __validate(validator, filename=nil)
-         str = filename ? File.open(filename) { |f| f.read() } : $stdin.read()
-         filename ||= "(stdin)"
-         s = ''
-         i = -1
-         _each_yaml_documents(str) do |document|
-            i += 1
-            if !document || document.empty?
-               #* key=:schema_empty  msg="%s#%d: empty.\n"
-               s << (Kwalify.msg(:schema_empty) % i)
-               next
-            end
-            errors = validator.validate(document)
-            if errors.empty?
-               #* key=:validation_valid  msg="%s#%d: valid.\n"
-               s << (Kwalify.msg(:validation_valid) % [filename, i]) unless @options[:silent]
-            else
-               #* key=:validation_invalid  msg="%s#%d: INVALID\n"
-               s << (Kwalify.msg(:validation_invalid) % [filename, i])
-               s << _errors_to_str(errors)
-            end
-         end
-         return s
-      end
-
-
-      def _each_yaml_documents(str, &block)
-         str = YamlHelper.untabify(str) if @options[:untabify]
-         if @options[:linenum]
-            @parser = Kwalify::Parser.new(str)
-            doc = @parser.parse()
-            yield(doc)
-         else
-            YAML::load_documents(str) do |doc|
-               doc = doc.value if _domain_type?(doc)
-               yield(doc)
-            end
-         end
-      end
-
-
-      def _inspect_schema(schema_filename)
-         filename = schema_filename
-         str = filename ? File.open(filename) { |f| f.read() } : $stdin.read()
-         schema = _load_yaml(str)
-         return nil if !schema || schema.empty?
-         validator = Kwalify::Validator.new(schema)  # error raised when schema is wrong
-         s = validator._inspect()
-         s << "\n" unless s[-1] == ?\n
-         return s
-      end
-
-
-      def _usage()
-         s = ''
-         s <<  "Usage1: #{@command} [-hvstl] -f schema.yaml document.yaml [document2.yaml ...]\n"
-         s <<  "Usage2: #{@command} [-hvstl] -m schema.yaml [schema2.yaml ...]\n"
-         s <<  "  -h, --help      :  help\n"
-         s <<  "  -v              :  version\n"
-         s <<  "  -s              :  silent\n"
-         s <<  "  -f schema.yaml  :  schema definition file\n"
-         s <<  "  -m              :  meta-validation mode\n"
-         s <<  "  -t              :  expand tab character automatically\n"
-         s <<  "  -l              :  show linenumber when errored (experimental)\n"
-         return s
-      end
-
-
-      def _version()
-         return "Kwalify: #{RELEASE}\n"
-      end
-
-
-      def _parse_argv(argv)
-         opt_parser = CommandOptionParser.new("hvstlmMD", "f")
-         #opts, props = opt_parser.parse(argv)
-         #properties = {}
-         #props.each do |pname, pvalue|
-         #   key   = pname.gsub(/-/, '_').intern
-         #   value = value == nil ? true: CommandOptionParser.to_value(pvalue)
-         #   properties[key] = value
-         #end
-         auto_convert = true
-         opts, properties = opt_parser.parse(argv, auto_convert)
-         options = {}
-         options[:help]     = opts[?h] || properties[:help]
-         options[:version]  = opts[?v] || properties[:version]
-         options[:silent]   = opts[?s]
-         options[:schema]   = opts[?f]
-         options[:linenum]  = opts[?l]
-         options[:meta]     = opts[?m]
-         options[:meta2]    = opts[?M]
-         options[:untabify] = opts[?t]
-         options[:debug]    = opts[?D]
-         return options, properties
-      end
-      
-      def _domain_type?(doc)
-         klass = defined?(YAML::DomainType) ? YAML::DomainType : YAML::Syck::DomainType
-         return doc.is_a?(klass)
-      end
-
-   end
-
-end