class Kwalify::Main

ex.

command = File.basename($0)
begin
  main = Kwalify::Main.new(command)
  s = main.execute
  print s if s
rescue Kwalify::CommandOptionError => ex
  $stderr.puts "ERROR: #{ex.message}"
  exit 1
rescue Kwalify::KwalifyError => ex
  $stderr.puts "ERROR: #{ex.message}"
  exit 1
end

Public Class Methods

main(command, argv=ARGV) click to toggle source
# File lib/kwalify/main.rb, line 121
def self.main(command, argv=ARGV)
  begin
    main = Kwalify::Main.new(command)
    s = main.execute(argv)
    print s if s
  rescue Kwalify::CommandOptionError => ex
    raise ex if main.debug?
    $stderr.puts ex.message
    exit 1
  rescue Kwalify::KwalifyError => ex
    raise ex if main.debug?
    $stderr.puts "ERROR: #{ex.to_s}"
    exit 1
  #rescue => ex
  #  if main.debug?
  #    raise ex
  #  else
  #    $stderr.puts ex.message
  #    exit 1
  #  end
  end
end
new(command=nil) click to toggle source
# File lib/kwalify/main.rb, line 45
def initialize(command=nil)
  @command = command || File.basename($0)
  @options = {}
  @properties   = {}
  @template_path  = []
  $:.each do |path|
    tpath = "#{path}/kwalify/templates"
    @template_path << tpath if test(?d, tpath)
  end
end

Public Instance Methods

_inspect() click to toggle source
# File lib/kwalify/main.rb, line 62
def _inspect()
  sb = []
  sb <<   "command: #{@command}\n"
  sb <<   "options:\n"
  @options.keys.sort {|k1,k2| k1.to_s<=>k2.to_s }.each do |key|
    sb << "  - #{key}: #{@options[key]}\n"
  end
  sb <<   "properties:\n"
  @properties.keys.sort_by {|k| k.to_s}.each do |key|
    sb << "  - #{key}: #{@properties[key]}\n"
  end
  #sb <<   "template_path:\n"
  #@template_path.each do |path|
  #  sb << "  - #{path}\n"
  #end
  return sb.join
end
debug?() click to toggle source
# File lib/kwalify/main.rb, line 57
def debug?
  @options[:debug]
end
execute(argv=ARGV) click to toggle source
# File lib/kwalify/main.rb, line 81
def execute(argv=ARGV)
  ## parse command-line options
  filenames = _parse_argv(argv)

  ## help or version
  if @options[:help] || @options[:version]
    action = @options[:action]
    s = ''
    s << _version() << "\n"           if @options[:version]
    s << _usage()                     if @options[:help] && !action
    s << _describe_properties(action) if @options[:help] && action
    puts s
    return
  end

  # validation
  if @options[:meta2]
    validate_schemafiles2(filenames)
  elsif @options[:meta]
    validate_schemafiles(filenames)
  elsif @options[:action]
    unless @options[:schema]
      #* key=:command_option_actionnoschema  msg="schema filename is not specified."
      raise option_error(:command_option_actionnoschema, @options[:action])
    end
    perform_action(@options[:action], @options[:schema])
  elsif @options[:schema]
    if @options[:debug]
      inspect_schema(@options[:schema])
    else
      validate_files(filenames, @options[:schema])
    end
  else
    #* key=:command_option_noaction  msg="command-line option '-f' or '-m' required."
    raise option_error(:command_option_noaction, @command)
  end
  return
end

Private Instance Methods

_describe_properties(action) click to toggle source
# File lib/kwalify/main.rb, line 182
def _describe_properties(action)
  template_filename = _find_template(action)
  s = apply_template(template_filename, :describe=>true)
  return s
end
_domain_type?(doc) click to toggle source
# File lib/kwalify/main.rb, line 433
def _domain_type?(doc)
  klass = defined?(YAML::DomainType) ? YAML::DomainType : YAML::Syck::DomainType
  return doc.is_a?(klass)
end
_find_template(action) click to toggle source
# File lib/kwalify/main.rb, line 154
def _find_template(action)
  template_filename = action + '.eruby'
  unless test(?f, template_filename)
    pathlist = []
    pathlist.concat(@options[:tpath].split(/,/)) if @options[:tpath]
    pathlist.concat(@template_path)
    tpath = pathlist.find {|path| test(?f, "#{path}/#{template_filename}") }
    #* key=:command_option_notemplate  msg="%s: invalid action (template not found).\n"
    raise option_error(:command_option_notemplate, action) unless tpath
    template_filename = "#{tpath}/#{action}.eruby"
  end
  return template_filename
end
_load_schemafile(schema_filename, ordered=false) click to toggle source
# File lib/kwalify/main.rb, line 219
def _load_schemafile(schema_filename, ordered=false)
  str = File.read(schema_filename)
  if str.empty?
    #* key=:schema_empty  msg="%s: empty schema.\n"
    msg = Kwalify.msg(:schema_emtpy) % filename
    raise CommandOptionError.new(msg)
  end
  str = Util.untabify(str) if @options[:untabify]
  parser = Kwalify::Yaml::Parser.new()
  parser.preceding_alias = true if @options[:preceding]
  parser.mapping_class = Kwalify::Util::OrderedHash if ordered
  schema = parser.parse(str, :filename=>schema_filename) # or YAML.load(str)
  return schema
end
_parse_argv(argv) click to toggle source
# File lib/kwalify/main.rb, line 361
def _parse_argv(argv)
  option_table = {
    ?h => :help,
    ?v => :version,
    ?q => :quiet,
    ?s => :quiet,
    ?t => :untabify,
    #?z => :meta,
    ?m => :meta,
    ?M => :meta2,
    ?E => :emacs,
    ?l => :linenum,
    ?f => :schema,
    ?D => :debug,
    ?a => :action,
    ?I => :tpath,
    ?P => :preceding,
  }

  errcode_table = {
    #* key=:command_option_schema_required  msg="-%s: schema filename required."
    ?f => :command_option_schema_required,
    #* key=:command_option_action_required  msg="-%s: action required."
    ?a => :command_option_action_required,
    #* key=:command_option_tpath_required  msg="-%s: template path required."
    ?I => :command_option_tpath_required,
  }

  while argv[0] && argv[0][0] == ?-
    optstr = argv.shift
    optstr = optstr[1, optstr.length-1]
    ## property
    if optstr[0] == ?-
      unless optstr =~ /\A\-([-\w]+)(?:=(.*))?\z/
        #* key=:command_property_invalid  msg="%s: invalid property."
        raise option_error(:command_property_invalid, optstr)
      end
      prop_name = $1;  prop_value = $2
      key  = prop_name.gsub(/-/, '_').intern
      value = prop_value.nil? ? true : _to_value(prop_value)
      @properties[key] = value
    ## option
    else
      while optstr && !optstr.empty?
        optchar = optstr[0]
        optstr[0,1] = ""
        unless option_table.key?(optchar)
          #* key=:command_option_invalid  msg="-%s: invalid command option."
          raise option_error(:command_option_invalid, optchar.chr)
        end
        optkey = option_table[optchar]
        case optchar
        when ?f, ?a, ?I
          arg = optstr.empty? ? argv.shift : optstr
          raise option_error(errcode_table[optchar], optchar.chr) unless arg
          @options[optkey] = arg
          optstr = ''
        else
          @options[optkey] = true
        end
      end
    end
  end  # end of while
  #
  @options[:linenum] = true if @options[:emacs]
  @options[:help]    = true if @properties[:help]
  @options[:version] = true if @properties[:version]
  filenames = argv
  return filenames
end
_show_errors(filename, i, ydoc, errors, ok_label="valid.", ng_label="INVALID") click to toggle source
# File lib/kwalify/main.rb, line 309
def _show_errors(filename, i, ydoc, errors, ok_label="valid.", ng_label="INVALID")
  if errors && !errors.empty?
    puts "#{filename}##{i}: #{ng_label}"
    errors.sort!
    for error in errors
      e = error
      if @options[:emacs]
        raise unless @options[:linenum]
        puts "#{filename}:#{e.linenum}:#{e.column} [#{e.path}] #{e.message}\n"
      elsif @options[:linenum]
        puts "  - (line #{e.linenum}) [#{e.path}] #{e.message}\n"
      else
        puts "  - [#{e.path}] #{e.message}\n"
      end
    end
  elsif ydoc.nil?
    #* key=:validation_empty  msg="%s#%d: empty.\n"
    puts Kwalify.msg(:validation_empty) % [filename, i]
  else
    #* key=:validation_valid  msg="%s#%d: valid."
    puts Kwalify.msg(:validation_valid) % [filename, i] unless @options[:quiet]
    #puts "#{filename}##{i} - #{ok_label}" unless @options[:quiet]
  end
end
_to_value(str) click to toggle source
# File lib/kwalify/main.rb, line 347
def _to_value(str)
  case str
  when nil, "null", "nil"     ;  return nil
  when "true", "yes"          ;  return true
  when "false", "no"          ;  return false
  when /\A\d+\z/              ;  return str.to_i
  when /\A\d+\.\d+\z/         ;  return str.to_f
  when /\/(.*)\//             ;  return Regexp.new($1)
  when /\A'.*'\z/, /\A".*"\z/ ;  return eval(str)
  else                        ;  return str
  end
end
_usage() click to toggle source
# File lib/kwalify/main.rb, line 335
def _usage()
  #msg = Kwalify.msg(:command_help) % [@command, @command, @command]
  msg = Kwalify.msg(:command_help)
  return msg
end
_validate_files(validator, filenames) click to toggle source
# File lib/kwalify/main.rb, line 255
def _validate_files(validator, filenames)
  ## parser
  if @options[:linenum] || @options[:preceding]
    parser = Kwalify::Yaml::Parser.new(validator)
    parser.preceding_alias = true if @options[:preceding]
  else
    parser = nil
  end
  ## filenames
  if filenames.empty?
    filenames = [ $stdin ]
  end
  for filename in filenames
    ## read input
    if filename.is_a?(IO)
      input = filename.read()
      filename = '(stdin)'
    else
      input = File.read(filename)
    end
    if input.empty?
      #* key=:validation_empty  msg="%s#%d: empty."
      puts kwalify.msg(:validation_empty) % [filename, i]
      #puts "#{filename}##{i}: empty."
      next
    end
    input = Util.untabify(input) if @options[:untabify]
    ## parse input
    if parser
      #i = 0
      #ydoc = parser.parse(input, :filename=>filename)
      #_show_errors(filename, i, ydoc, parser.errors)
      #while parser.has_next?
      #  i += 1
      #  ydoc = parser.parse_next()
      #  _show_errors(filename, i, ydoc, parser.errors)
      #end
      i = 0
      parser.parse_stream(input, :filename=>filename) do |ydoc|
        _show_errors(filename, i, ydoc, parser.errors)
        i += 1
      end
    else
      i = 0
      YAML.load_documents(input) do |ydoc|
        errors = validator.validate(ydoc)
        _show_errors(filename, i, ydoc, errors)
        i += 1
      end
    end
  end
end
_version() click to toggle source
# File lib/kwalify/main.rb, line 342
def _version()
  return RELEASE
end
apply_template(template_filename, hash) click to toggle source
# File lib/kwalify/main.rb, line 169
def apply_template(template_filename, hash)
  template = File.read(template_filename)
  trim_mode = 1
  erb = ERB.new(template, nil, trim_mode)
  context = Object.new
  hash.each do |key, val|
    context.instance_variable_set("@#{key}", val)
  end
  s = context.instance_eval(erb.src, template_filename)
  return s
end
inspect_schema(schema_filename) click to toggle source
# File lib/kwalify/main.rb, line 200
def inspect_schema(schema_filename)
  schema = _load_schemafile(schema_filename)
  if schema.nil?
    puts "nil"
  else
    validator = Kwalify::Validator.new(schema)  # error raised when schema is wrong
    puts validator._inspect()
  end
end
option_error(error_symbol, arg) click to toggle source
# File lib/kwalify/main.rb, line 148
def option_error(error_symbol, arg)
  msg = Kwalify.msg(error_symbol) % arg
  return CommandOptionError.new(msg, arg, error_symbol)
end
perform_action(action, schema_filename, describe=false) click to toggle source
# File lib/kwalify/main.rb, line 189
def perform_action(action, schema_filename, describe=false)
  template_filename = _find_template(action)
  schema = _load_schemafile(schema_filename, ordered=true)
  validator = Kwalify::Validator.new(schema)
  @properties[:schema_filename] = schema_filename
  hash = { :validator=>validator, :schema=>schema, :properties=>@properties }
  s = apply_template(template_filename, hash)
  puts s if s && !s.empty?
end
validate_files(filenames, schema_filename) click to toggle source

-f schemafile datafile

# File lib/kwalify/main.rb, line 212
def validate_files(filenames, schema_filename)
  schema = _load_schemafile(schema_filename)
  validator = Kwalify::Validator.new(schema)
  _validate_files(validator, filenames)
end
validate_schemafiles(schema_filenames) click to toggle source

-m schemafile

# File lib/kwalify/main.rb, line 236
def validate_schemafiles(schema_filenames)
  meta_validator = Kwalify::MetaValidator.instance()
  _validate_files(meta_validator, schema_filenames)
end
validate_schemafiles2(schema_filenames) click to toggle source

-M schemafile

# File lib/kwalify/main.rb, line 243
def validate_schemafiles2(schema_filenames)
  parser = Kwalify::Yaml::Parser.new()
  parser.preceding_alias = true if @options[:preceding]
  for schema_filename in schema_filenames
    str = File.read(schema_filename)
    str = Util.untabify(str) if @options[:untabify]
    schema = parser.parse(str, :filename=>schema_filename)
    Kwalify::Validator.new(schema)   # exception raised when schema has errors
  end
end