kwatable 0.2.0 → 0.3.0

data/lib/kwatable/main.rb

@@ -0,0 +1,331 @@
+###
+### copyright(c) 2005 kuwata-lab.com all rights reserved.
+### $Release: 0.3.0 $
+### $Rev: 43 $
+###
+
+require 'yaml'
+require 'erb'
+require 'fileutils'
+
+begin
+  require 'rubygems'
+  require_gem 'activesupport'
+rescue LoadError => ex
+  # ignore
+end
+
+require 'kwatable'
+require 'kwatable/util'
+require 'kwatable/util/assertion'
+require 'kwatable/validator'
+
+
+module Kwatable
+
+  class CommandOptionError < KwatableError
+  end
+
+  class Main
+    include Assertion
+
+    def initialize(argv=ARGV)
+      @argv = argv
+    end
+
+    def execute()
+      options, properties, filenames = _parse_options(@argv)
+
+      ## help or version
+      if options[?h] || options[?v]
+        puts _version() if options[?v]
+        return unless options[?h]
+        puts _template_info(options)       if  options[?t]
+        puts _usage()                      if !options[?t]
+        puts _available_template(options)  if !options[?t]
+        return
+      end
+
+      ## option check
+      if dir = options[?d]
+        #* key=:dir_notfound  msg="-d %s: directory not found."
+        _option_error(:dir_notfound, dir) unless test(?e, dir)
+        #* key=:dir_notadir  msg="-d %s: not a directory."
+        _option_error(:dir_notadir, dir) unless test(?d, dir)
+      end
+
+      ## load and validate datafile
+      tabledefs = []
+      check_only = options[?c]
+      s = '' if check_only
+      filenames.each do |filename|
+        tabledef, content = _load_yaml(filename, options[?T])
+        tabledefs << tabledef
+        unless options[?u]
+          errors = Kwatable.validate(tabledef, content)
+          if !errors || errors.empty?
+            s << "#{filename}: valid.\n" if check_only
+          else
+            s << "#{filename}: INVALID!\n" if check_only
+            s2 = errors.sort.collect { |err|
+              "%s:%d: %s: %s" % [filename, err.linenum, err.path, err.message]
+            }.join("\n")
+            if check_only
+              s << s2 << "\n"
+            else
+              #* key=:tabledef_validation_error  msg="schema validation error.\n%s"
+              _option_error(:tabledef_validation_error, s2)
+            end
+          end
+        end
+      end
+      return s if check_only
+
+      ## merge tabledefs
+      tabledef = tabledefs.shift
+      tabledefs.each do |tdef|
+        tabledef = _merge_tabledefs(tabledef, tdef)
+      end
+
+      ## manipulation
+      manipulator = Manipulator.new()
+      manipulator.manipulate(tabledef)
+      $stderr.puts tabledef.to_yaml if options[?D]
+
+      ## template filename
+      filename = options[?t]
+      unless filename
+        return nil if options[?D]
+        #* key=:template_notspecified  msg="template is not specified."
+        _option_error(:template_notspecified)
+      end
+      template_pathlist = _template_pathlist(options[?I])
+      template_filename = _find_template(filename, template_pathlist)
+
+      ## apply template
+      hash = { :options=>options, :properties=>properties,
+               :template_filename=>template_filename,
+               :template_pathlist=>template_pathlist,
+             }
+      hash[:tables] = tabledef['tables']
+      context = _create_context(hash)
+      output = Util.eval_template(template_filename, context)
+      output_files = context.instance_variable_get("@output_files")
+      if output_files
+        output_files.each do |filename, content, message_key|
+          _write_file(filename, content, message_key, options)
+        end
+        output = nil
+      end
+      return output
+    end
+
+    def self.main(argv=ARGV)
+      begin
+        main = Main.new(ARGV)
+        output = main.execute()
+        print output if output
+      rescue KwatableError => ex
+        $stderr.puts "[ERROR] #{ex.message()}"
+      end
+    end
+
+    private
+
+    def _write_file(filepath, content, message_key, options)
+      flag_quiet = options[?q]
+      #dir        = options[?d]
+      #filepath = "#{dir}/#{filepath}" if dir
+      unless message_key == :identical
+        path = File.dirname(filepath)
+        FileUtils.mkdir_p(path) unless test(?d, path)
+        File.open(filepath, 'w') { |f| f.write(content) }
+      end
+      unless flag_quiet
+        message = _output_message(message_key)
+        $stderr.puts(message % filepath)
+      end
+    end
+
+    def _output_message(message_key)
+      unless @msg_table
+        table = {}
+        #* key=:file_create  msg="create:    %s"
+        table[:create] = Kwatable.msg(:file_create)
+        #* key=:file_update  msg="update:    %s"
+        table[:update] = Kwatable.msg(:file_update)
+        #* key=:file_delete  msg="delete:    %s"
+        table[:delete] = Kwatable.msg(:file_delete)
+        #* key=:file_identical  msg="identical: %s"
+        table[:identical] = Kwatable.msg(:file_identical)
+        table[nil] = table[:create]
+        @msg_table = table
+      end
+      message = @msg_table[message_key]
+      assert! "message_key=#{message_key.inspect}"unless message
+      return message
+    end
+
+    def _load_yaml(filename, not_untabify)
+      #* key=:datafile_notfound  msg="%s: datafile notfound."
+      _option_error(:datafile_notfound, filename) unless test(?e, filename)
+      #* key=:datafile_notafile  msg="%s: not a file."
+      _option_error(:datafile_notafile, filename) unless test(?f, filename)
+      content = File.read(filename)
+      content = Util.untabify(content) unless not_untabify
+      ydoc = YAML.load(content)
+      #* key=:tabledef_empty  msg="table definition file is empty."
+      _option_error(:tabledef_empty) unless ydoc
+      #* key=:tabledef_notmap  msg="table definition is not a mapping."
+      _option_error(:tabledef_notmap) unless ydoc.is_a?(Hash)
+      return ydoc, content
+    end
+
+    def _merge_tabledefs(base_tabledef, other_tabledef)
+      base, other = base_tabledef, other_tabledef
+      return other unless base
+      other.each do |key, value|
+        if base.key?(key)
+          case v = base[key]
+          when Array  ;  v.concat(value)
+          when Hash   ;  v.update(value)
+          else        ;  base[key] = v
+          end
+        else
+          base[key] = value
+        end
+      end
+      return base
+    end
+
+    def _create_context(vars={})
+      context = Object.new
+      vars.each do |key, val|
+        context.instance_variable_set("@#{key.to_s}", val)
+      end
+      context.extend Assertion
+      return context
+    end
+
+    def _find_template(filename, pathlist)
+      filename += '.eruby' unless filename =~ /\.eruby$/
+      filepath = Util.find_file(filename, pathlist)
+      unless filepath
+        #* key=:template_notfound  msg="`%s': template file not found."
+        _option_error(:template_notfound, filename)
+      end
+      return filepath
+    end
+
+    def _template_info(options)
+      filename = options[?t]
+      template_pathlist = _template_pathlist(options[?I])
+      template_filename = _find_template(filename, template_pathlist)
+      s = ''
+      s <<   "Filename:     #{template_filename}\n"
+      content = File.read(template_filename)
+      if content =~ /<template-desc>(.*?)<\/template-desc>/m
+        s << "Description:  #{$1}\n"
+      end
+      if content =~ /<template-properties>(.*?)<\/template-properties>/m
+        lines = $1.to_a
+        lines.shift; lines.pop
+        s << "Properties:\n"
+        s << lines.collect { |line| line.sub(/^[ \t]*\#+/, '') }.join
+      end
+      if content =~ /<template-details>(.*?)<\/template-details>/m
+        lines = $1.to_a
+        lines.shift; lines.pop
+        s << "Details:\n"
+        s << lines.collect { |line| line.sub(/^[ \t]*\#+/, '') }.join
+      end
+      return s
+    end
+
+    def _available_template(options)
+      path_list = _template_pathlist(options[?I])
+      filenames = path_list.collect { |path| Dir.glob("#{path}/*.eruby") }.flatten
+      filenames.delete_if { |filename| filename =~ /\.sub\.eruby$/ }
+      s = "Templates:\n"
+      filenames.each do |filename|
+        content = File.read(filename)
+        desc = (content =~ /<template-desc>(.*?)<\/template-desc>/) ? $1 : ''
+        name = File.basename(filename).sub(/\.eruby$/, '')
+        s << "  %-18s: %s\n" % [name, desc]
+      end
+      return s
+    end
+
+    def _template_pathlist(option_I)
+      path_list = []
+      path_list.concat(option_I.split(/,/)) if option_I
+      path_list.concat(Kwatable.template_path)
+      return path_list
+    end
+
+    def _option_error(message_key, *args)
+      msg = Kwatable.msg(message_key)
+      assert! "massage not found. (message_key=#{message_key.inspect})" unless msg
+      err = CommandOptionError.new(msg % args)
+      err.set_backtrace(caller())
+      raise err
+    end
+
+    def _parse_options(argv)
+      begin
+        options, properties, filenames = Util.parse_argv(argv, "hvqcuD", "Iftd")
+        options[?h] = true if properties[:help]
+        options[?t] ||= options[?f] if options[?f]
+        return options, properties, filenames
+      rescue => ex
+        msg = ex.message
+        if msg =~ /\A-(.+?): unknown option.\z/
+          optchar = $1
+          #* key=:option_unknown  msg="-%s: unknown option."
+          _option_error(:option_unknown, optchar)
+        elsif msg =~ /\A-(.+?): argument required.\z/
+          case optchar = $1
+          when 'f', 't'
+            #* key=:template_required  msg="-%s: template filename required."
+            _option_error(:template_required, optchar)
+          when 'd'
+            #* key=:outdir_required  msg="-%s: output directory required."
+            _option_error(:outdir_required, optchar)
+          when 'I'
+            #* key=:directory_required  msg="-%s: directory required."
+            _option_error(:directory_required, optchar)
+          else
+            raise "*** internal error: optchar=#{optchar.inspect}"
+          end
+        else
+          raise "*** internal error: msg=#{msg.inspect}"
+        end
+      end
+    end
+
+    def _usage(command=nil)
+      command ||= File::basename($0)
+      s = ""
+      s << "Usage: #{command} [-hvmqcuT] [-I path] [-d dir] -t template datafile [datafile2 ...]\n"
+      s << "  -h, --help   : show help\n"
+      s << "  -v           : show version\n"
+      s << "  -I path      : template directory path\n"
+      s << "  -t template  : template filename\n"
+      #s << "  -f template  : template filename\n"
+      s << "  -ht template : show template info(filename, desc, and properties)\n"
+      s << "  -d dir       : output file directory\n"
+      #s << "  -m           : multiple output file mode\n"
+      s << "  -q           : quiet mode\n"
+      s << "  -c           : validation only\n"
+      s << "  -u           : skip validation of datafile\n"
+      s << "  -T           : not expand tab characters in datafile\n"
+      return s
+    end
+
+    def _version()
+      return RELEASE
+    end
+
+  end
+
+end

data/lib/kwatable/manipulator.rb

@@ -1,222 +1,350 @@
 ###
 ### copyright(c) 2005 kuwata-lab.com all rights reserved.
-### $Release: 0.2.0 $
-### $Rev: 18 $
+### $Release: 0.3.0 $
+### $Rev: 44 $
 ###
 
 require 'yaml'
+require 'kwatable/util/assertion'
 
 module Kwatable
 
-   class ManipulationError < KwatableError
-   end
-
-
-   ##
-   ## ex.
-   ##  tabledef = YAML.load_file('tabledef.yaml')
-   ##  manipulator = Kwatable::Manipulator.new
-   ##  tabledef = manipulator.manipulate(tabledef)
-   ##  p tabledef[:columns]
-   ##  p tabledef[:tables]
-   ##
-   class Manipulator
-
-      #def parse(input)
-      #   str = ''
-      #   input.each_line do |line|
-      #      str << line.gsub(/([^\t]{8})|([^\t]*)\t/n){[$+].pack("A8")}    ## expand tab
-      #   end
-      #   tabledef = YAML.load(str)
-      #   manipulate(tabledef)
-      #   return tabledef
-      #end
-
-      def manipulate(tabledef)
-         #assert unless tabledef.is_a?(Hash)
-         return tabledef unless tabledef.is_a?(Hash)
-
-         column_map, patterned_columns = _manipulate_columns(tabledef['columns'])
-         #assert unless column_map.is_a?(Hash)
-         #assert unless patterned_columns.is_a?(Array)
-
-         table_map = _manipulate_tables(tabledef['tables'], column_map, patterned_columns)
-         #assert unless table_map.is_a?(Hash)
-
-         tabledef['column_map'] = column_map         # Hash
-         tabledef['table_map'] = table_map           # Hash
-         return tabledef
+  class ManipulationError < KwatableError
+  end
+
+
+  ##
+  ## ex.
+  ##  tabledef = YAML.load_file('tabledef.yaml')
+  ##  manipulator = Kwatable::Manipulator.new
+  ##  tabledef = manipulator.manipulate(tabledef)
+  ##  p tabledef[:columns]
+  ##  p tabledef[:tables]
+  ##
+  class Manipulator
+    include Assertion
+
+    def initialize(options={})
+      @overridable = options[:overridable]
+    end
+
+    #def parse(input)
+    #   str = ''
+    #   input.each_line do |line|
+    #      str << line.gsub(/([^\t]{8})|([^\t]*)\t/n){[$+].pack("A8")}    ## expand tab
+    #   end
+    #   tabledef = YAML.load(str)
+    #   manipulate(tabledef)
+    #   return tabledef
+    #end
+
+    def manipulate(tabledef)
+      #assert unless tabledef.is_a?(Hash)
+      return tabledef unless tabledef.is_a?(Hash)
+
+      column_map, patterned_columns = _manipulate_columns(tabledef['columns'])
+      #assert unless column_map.is_a?(Hash)
+      #assert unless patterned_columns.is_a?(Array)
+
+      table_map = _manipulate_tables(tabledef['tables'], column_map, patterned_columns)
+      #assert unless table_map.is_a?(Hash)
+
+      tabledef['column_map'] = column_map         # Hash
+      tabledef['table_map'] = table_map           # Hash
+      return tabledef
+    end
+
+    private
+
+    def _error(message_key, *args)
+      msg = Kwatable.msg(message_key)
+      assert! "message_key=#{message_key}" unless msg
+      return ManipulationError.new(msg % args)
+    end
+
+    def _manipulate_columns(columns)
+      column_map  = {}
+      patterned_columns = []
+      columns.each_with_index do |column, i|
+        name = column['name']
+        unless name
+          #* key=:colname_required  msg="column name required (index=%d)."
+          raise _error(:colname_required, i)
+        end
+        if name =~ /\A\/(.*)\/\z/
+          pattern = $1
+          begin
+            #namepatetrn = eval(name)
+            namepattern = Regexp.compile(pattern)
+          rescue RegexpError => ex
+            #* key=:regexp_invalid  msg="column '%s': pattern %s: %s"
+            raise _error(:regexp_invalid, column['name'], column['pattern'], ex.message)
+          end
+          column['namepattern'] = namepatntern
+          patterned_columns << column
+        else
+          if column_map.key?(name)
+            #* key=:coldef_duplicated  msg="column '%s': column name is duplicated."
+            raise _error(:coldef_duplicated, column['name']) unless @overridable
+          end
+          column_map[name] = column
+        end
+        #name = column['name'].strip
+        #namepattern = column['namepattern']
+        #unless name || namepattern
+        #   #* key=:colname_required  msg="column definition doesn't have a name nor namepattern."
+        #   raise ManipulationError.new(Kwatable.msg(:colname_required))
+        #end
+        #if name
+        #   if column_map.key?(name)
+        #      #* key=:coldef_duplicated  msg="column definition `%s' is duplicated."
+        #      raise ManipulationError.new(Kwatable.msg(:coldef_duplicated) % [name]) unless @overridable
+        #   end
+        #   column_map[name] = column
+        #end
+        #if namepattern
+        #   pattern = namepattern.strip
+        #   pattern = $1 if pattern =~ /^\/(.*)\/$/
+        #   column['namepattern'] = Regexp.compile(pattern)
+        #   patterned_columns << column
+        #end
+      end if columns
+      return column_map, patterned_columns
+    end
+
+    def _manipulate_tables(tables, column_map, patterned_columns)
+      #assert unless tables.is_a?(Array)
+      #assert unless column_map.is_a?(Hash)
+      #assert unless patterned_columns.is_a?(Array)
+
+      ## create table_map
+      table_map  = {}
+      tables.each_with_index do |table, i|
+        name = table['name']
+        unless name
+          #* key=:tablename_required  msg="table definition doesn't have a name (index=%d)."
+          raise _error(:tablename_required, i)
+        end
+        if table_map.key?(name)
+          #* key=:tabledef_duplicated  msg="table '%s': table name is duplicated."
+          raise _error(:tabledef_duplicated, name) unless @overridable
+        end
+        unless table['columns']
+          #* key=:tablecolumns_required  msg="table '%s': columns requried."
+          raise _error(:tablecolumns_required, table['name'])
+        end
+        table_map[name] = table
       end
 
-      private
+      ## manipulate table columns
+      tables.each do |table|
+        _alias_table_key(table, 'ident-columns', 'primary-keys')
+        _manipulate_table_columns(table, table_map, column_map, patterned_columns)
+      end
 
-      def _error(message_key, *args)
-         msg = Kwatable.msg(message_key) % args
-         return ManipulationError.new(msg)
+      ## manipulate table column ref
+      tables.each do |table|
+        _manipulate_table_column_ref(table, table_map)
       end
 
-      def _manipulate_columns(columns)
-         column_map  = {}
-         patterned_columns = []
-         columns.each_with_index do |column, i|
-            name = column['name']
-            unless name
-               #* key=:colname_required  msg="table '%s': column name required (index=%d)."
-               raise _error(:colname_required, table['name'], i)
-            end
-            if name =~ /\A\/(.*)\/\z/
-               pattern = $1
-               begin
-                  namepattern = Regexp.compile(pattern)
-               rescue RegexpError => ex
-                  #* key=:regexp_invalid  msg="table '%s': column '%s': pattern %s: %s"
-                  raise _error(:regexp_invalid, table['name'], column['name'], column['pattern'], ex.message)
-               end
-               column['namepattern'] = namepattern
-               patterned_columns << column
-            else
-               if column_map.key?(name)
-                  #* key=:coldef_duplicated  msg="table '%s': column '%s': column name is duplicated."
-                  raise _error(:coldef_duplicated, table['name'], column['name'])
-               end
-               column_map[name] = column
+      ## ident-columns (primary-keys)
+      tables.each do |table|
+        if table['ident-columns']
+          ident_columns = table['ident-columns'].collect do |colname|
+            column = table['columns'].find { |col| col['name'] == colname }
+            unless column
+              #* key=:table_identcol_missing msg="table '%s': ident-column '%s': no such column."
+              raise _error(:table_identcol_missing, table['name'], colname)
             end
-            #name = column['name'].strip
-            #namepattern = column['namepattern']
-            #unless name || namepattern
-            #   #* key=:colname_required  msg="column definition doesn't have a name nor namepattern."
-            #   raise ManipulationError.new(Kwatable.msg(:colname_required))
-            #end
-            #if name
-            #   if column_map.key?(name)
-            #      #* key=:coldef_duplicated  msg="column definition `%s' is duplicated."
-            #      raise ManipulationError.new(Kwatable.msg(:coldef_duplicated) % [name])
-            #   end
-            #   column_map[name] = column
-            #end
-            #if namepattern
-            #   pattern = namepattern.strip
-            #   pattern = $1 if pattern =~ /^\/(.*)\/$/
-            #   column['namepattern'] = Regexp.compile(pattern)
-            #   patterned_columns << column
-            #end
-         end if columns
-         return column_map, patterned_columns
+            column
+          end
+          table['ident-columns'] = table['primary-keys'] = ident_columns
+        end
+        ## detect ident-column, and column type checking
+        ident_columns = []
+        table['columns'].each do |column|
+          ident_columns << column if column['ident']
+          unless column['type']
+            #* key=:tabletype_required msg="table '%s': column '%s': type is not determined.."
+            raise _error(:tabletype_required, table['name'], column['name'])
+          end
+        end
+        table['ident-columns'] ||= ident_columns
+        table['primary-keys'] ||= ident_columns
+        ## check modeling
+        #if table['ident-columns'].length != 1 && table['modeling'] != false
+        #  warn("table `%s': may be `modeling: no' ? " % [table['name']])
+        #end
       end
 
-      def _manipulate_tables(tables, column_map, patterned_columns)
-         #assert unless tables.is_a?(Array)
-         #assert unless column_map.is_a?(Hash)
-         #assert unless patterned_columns.is_a?(Array)
-
-         ## create table_map
-         table_map  = {}
-         tables.each_with_index do |table, i|
-            name = table['name']
-            unless name
-               #* key=:tablename_required  msg="table definition doesn't have a name (index=%d)."
-               raise _error(:tablename_required, i)
-            end
-            if table_map.key?(name)
-               #* key=:tabledef_duplicated  msg="table '%s': table name is duplicated."
-               raise _error(:tabledef_duplicated, name)
-            end
-            table_map[name] = table
-         end
-
-         ## manipulate table columns
-         tables.each do |table|
-            colname_map = {}
-            table['columns'].each_with_index do |column, i|
-               column['table'] = table
-               colname = column['name']
-               unless colname
-                  #* key=:tablecolumn_required  msg="table '%s': column name requried (index=%d)."
-                  raise _error(:tablecolumn_required, table['name'], i)
-               end
-               if colname_map[colname]
-                  #* key=:tablecolumn_duplicated msg="table '%s': column '%s': column name is duplicated."
-                  raise _error(:tablecolumn_duplicated, table['name'], colname)
-               end
-               colname_map[colname] = true
-               _set_defaults(column, column_map, patterned_columns)
-               #_alias_keys(column, "primary-key", "primarykey", "identifier")
-               #_alias_keys(column, "not-null",    "notnull",    "required")
-               _alias_key(column, table, "ident", "primary-key")
-               _alias_key(column, table, "required", "not-null")
-               _handle_ref(column, table, table_map) if column['ref']
-               _handle_enum(column) if column['enum']
-               unless column['type']
-                  #* key=:tabletype_required  msg="table `%s': column `%s': type is not determined."
-                  raise _error(:tabletype_required, table['name'], column['name'])
-               end
-            end if table['columns']
-         end if tables
-
-         return table_map
+      ## manipulate table relations
+      tables.each do |table|
+        _manipulate_table_relations(table, table_map) if table['relations']
       end
 
-      def _set_defaults(column, column_map, patterned_columns)
-         colname = column['name']
-         defaults = column_map[colname]
-         defaults ||= patterned_columns.find { |col| colname =~ col['namepattern'] }
-         defaults.each do |key, val|
-            column[key] = val if !column.key?(key) && key != 'namepattern'
-         end if defaults
+      return table_map
+    end
+
+    def _manipulate_table_columns(table, table_map, column_map, patterned_columns)
+      colname_map = {}
+      table['columns'].each_with_index do |column, i|
+        column['table'] = table
+        colname = column['name']
+        unless colname
+          #* key=:tablecolumn_required  msg="table '%s': column name requried (index=%d)."
+          raise _error(:tablecolumn_required, table['name'], i)
+        end
+        if colname_map[colname]
+          #* key=:tablecolumn_duplicated msg="table '%s': column '%s': column name is duplicated."
+          raise _error(:tablecolumn_duplicated, table['name'], colname)
+        end
+        colname_map[colname] = true
+        _set_defaults(column, column_map, patterned_columns)
+        _alias_column_key(column, table, "ident", "primary-key")
+        _alias_column_key(column, table, "required", "not-null")
+        _manipulate_column_enum(column) if column['enum']
       end
+    end
 
-      def _alias_keys(column, key, *old_keys)  # not used
-         old_keys.each do |old_key|
-            column[key] = column[old_key] if !column.key?(key) && column.key?(old_key)
-         end if old_keys
+    def _manipulate_table_column_ref(table, table_map)
+      table['columns'].each do |column|
+        _manipulate_column_ref(column, table, table_map) if column['ref']
       end
+    end
+
+    def _set_defaults(column, column_map, patterned_columns)
+      colname = column['name']
+      defaults = column_map[colname]
+      defaults ||= patterned_columns.find { |col| colname =~ col['namepattern'] }
+      defaults.each do |key, val|
+        column[key] = val if !column.key?(key) && key != 'namepattern'
+      end if defaults
+    end
 
-      def _alias_key(column, table, key1, key2)
-         if column.key?(key1) && column.key?(key2)
-            #* key=:alias_conflict  msg="table '%s', column '%s': alias key '%1:' and '%2:' are not allowed to use in the same time."
-            raise _error(:alias_conflict, table['name'], column['name'], key1, key2)
-         end
-         column[key2] = column[key1] if column.key?(key1)
-         column[key1] = column[key2] if column.key?(key2)
+    def _alias_table_key(table, key1, key2)
+      if table.key?(key1) && table.key?(key2)
+        #* key=:alias_tablekey_conflict  msg="table '%s': alias key '%1:' and '%2:' are not allowed to use in the same time."
+        raise _error(:alias_tablekey_conflict, table['name'], nil, key1, key2)
       end
+      table[key2] = table[key1] if table.key?(key1)
+      table[key1] = table[key2] if table.key?(key2)
+    end
 
-      def _handle_enum(column)
-         return unless column['enum']
-         width = 0
-         column['enum'].each do |value|
-            len = value.to_s.length
-            width = len if len > width
-         end
-         column['type']  ||= 'str'
-         column['width'] ||= width
+    def _alias_column_key(column, table, key1, key2)
+      if column.key?(key1) && column.key?(key2)
+        #* key=:alias_columnkey_conflict  msg="table '%s', column '%s': alias key '%1:' and '%2:' are not allowed to use in the same time."
+        raise _error(:alias_columnkey_conflict, table['name'], column['name'], key1, key2)
       end
+      column[key2] = column[key1] if column.key?(key1)
+      column[key1] = column[key2] if column.key?(key2)
+    end
 
-      def _handle_ref(column, table, table_map)
-         ref = column['ref']
-         return unless ref
-         ref = ref.strip
-         return unless ref =~ /\A(\w+)\.(\w+)\z/ || ref =~ /\A(\w+)\((\w+)\)\z/
-         ref_table_name  = $1
-         ref_column_name = $2
-         ref_table = table_map[ref_table_name]
-         unless ref_table
-            #* key=:reftable_notfound  msg="`table '%s': column '%s': 'ref: %s': reference table not found."
-            raise _error(:reftable_notfound, table['name'], column['name'], column['ref'])
-         end
-         cols = ref_table['columns']
-         ref_column = cols ? cols.find { |col| col['name'] == ref_column_name } : nil
-         unless ref_column
-            #* key=:refcolumn_notfound  msg="`table '%s': column '%s': ref: %s': reference column not found in the table."
-            raise _error(:refcolumn_notfound, table['name'], column['name'], column['ref'])
-         end
-         #column['ref-table']  = ref_table
-         #column['ref-column'] = ref_column
-         column['ref']        = ref_column
-         column['ref-name'] ||= column['name'].sub(/_#{ref_column['name']}$/, '')
-         column['type']       = ref_column['type']
-         column['width']    ||= ref_column['width']  if ref_column.key?('width')
+    def _manipulate_column_enum(column)
+      return unless column['enum']
+      width = 0
+      column['enum'].each do |value|
+        len = value.to_s.length
+        width = len if len > width
       end
+      column['type']  ||= 'str'
+      column['width'] ||= width
+    end
+
+    def _manipulate_column_ref(column, table, table_map)
+      ref = column['ref']
+      return unless ref
+      ref = ref.strip
+      return unless ref =~ /\A(\w+)\.(\w+)\z/ || ref =~ /\A(\w+)\((\w+)\)\z/
+      ref_table_name  = $1
+      ref_column_name = $2
+      ref_table = table_map[ref_table_name]
+      unless ref_table
+        #* key=:reftable_notfound  msg="`table '%s': column '%s': 'ref: %s': reference table not found."
+        raise _error(:reftable_notfound, table['name'], column['name'], column['ref'])
+      end
+      cols = ref_table['columns']
+      ref_column = cols ? cols.find { |col| col['name'] == ref_column_name } : nil
+      unless ref_column
+        #* key=:refcolumn_notfound  msg="`table '%s': column '%s': ref: %s': reference column not found in the table."
+        raise _error(:refcolumn_notfound, table['name'], column['name'], column['ref'])
+      end
+      #column['ref-table']  = ref_table
+      #column['ref-column'] = ref_column
+      column['_ref']       = column['ref']
+      column['ref']        = ref_column
+      #column['ref-name'] ||= column['name'].sub(/_#{ref_column['name']}$/, '')
+      column['type']       = ref_column['type']
+      column['width']    ||= ref_column['width']  if ref_column.key?('width')
+    end
+
+    def _manipulate_table_relations(table, table_map)
+      return unless table['relations']
+      table['relations'].each do |relation|
+        unless relation['kind']
+          #* key=:relation_kind_required  msg="table `%s': relation kind required."
+          raise _error(:relation_kind_required, table['name'])
+        end
+        unless relation['referrer']
+          #* key=:relation_referrer_required  msg="table `%s': relation referrer required."
+          raise _error(:relation_referrer_required, table['name'])
+        end
+        referrer = relation['referrer']
+        unless referrer =~ /\A(\w+)\.(\w+)\z/ || referrer =~ /\A(\w+)\((\w+(?:,\s*\w+)*)\)\z/
+          #* key=:referrer_invalid  msg="table `%s': referrer `%s': invalid pattern."
+          raise _error(:referrer_invalid, table['name'], referrer)
+        end
+        reftable_name, refcolumn_names = $1, $2
+        unless table_map[reftable_name]
+          #* key=:referrer_table_notfound  msg="table `%s': referrer `%s': table not found."
+          raise _error(:referrer_table_notfound, table['name'], referrer)
+        end
+        reftable = table_map[reftable_name]
+        refcolumns = refcolumn_names.split(/,\s*/).collect do |refcolumn_name|
+          refcolumn = reftable['columns'].find { |col| col['name'] == refcolumn_name }
+          unless refcolumn
+            #* key=:referrer_column_notfound  msg="table `%s': referrer `%s': column not found."
+            raise _error(:referrer_column_notfound, table['name'], referrer)
+          end
+          refcolumn
+        end
+        relation['table']   = reftable
+        relation['columns'] = refcolumns
+        #
+        if relation['kind'] == 'n:n'
+          unless relation['join-table']
+            #* key=:referrer_jointable_required  msg="table `%s': referrer `%s': `join-table:' is required when n:n relationship."
+            raise _error(:referrer_jointable_required, table['name'], referrer)
+          end
+          join_table_name = relation['join-table']
+          join_table = table_map[join_table_name]
+          unless join_table
+            #* key=:referrer_jointable_notfound  msg="table `%s': referrer `%s': join-table '%s' not found."
+            raise _error(:referrer_jointable_notfound, table['name'], referrer, join_table_name)
+          end
+          relation['join-table'] = join_table
+          ident_column = table['columns'].find { |col| col['ident'] }
+          unless ident_column
+            #* key=:referrer_identcolumn_notfound  msg="table `%s': referrer `%s': table `%s' does not have ident column (it is required for have n:n relationship)."
+            raise _error(:referrer_identcolumn_notfound, table['name'], referrer, table['name'])
+          end
+          unless _find_ref_column(join_table, ident_column)
+            #* key=:referrer_joincolumn_notfound  msg="table `%s': referrer `%s': join-table '%s' does not have column to link to %s table."
+            raise _error(:referrer_joincolumn_notfound, table['name'], referrer, join_table['name'], table['name'])
+          end
+          refcolumns.each do |refcolumn|
+            unless _find_ref_column(join_table, refcolumn)
+              #* key=:referrer_joincolumn2_notfound  msg="table `%s': referrer `%s': join-table '%s' does not have column to link to table '%s'."
+              raise _error(:referrer_joincolumn2_notfound, table['name'], referrer, join_table['name'], reftable['name'])
+            end
+          end
+        end
+      end
+    end
+
+    def _find_ref_column(table, refcolumn)
+      return table['columns'].find { |col| col['ref'] && col['ref'].__id__ == refcolumn.__id__ }
+    end
 
-   end
+  end
 
 end