kwatable 0.0.1

data/lib/kwatable/main-program.rb

@@ -0,0 +1,197 @@
+###
+### copyright(c) 2005 kuwata-lab.com all rights reserved.
+### $Release: 0.0.1 $
+### $Rev: 12 $
+###
+
+require 'erb'
+
+module Kwatable
+
+   class CommandOptionError < KwatableError
+   end
+
+   class MainProgram
+      def initialize(argv=ARGV)
+         @argv = argv
+      end
+
+      def execute()
+         options, properties = parse_options(@argv)
+
+         ## help or version
+         if options[?h] || options[?v]
+            puts version() if options[?v]
+            puts usage()   if options[?h]
+            return
+         end
+
+         ## load data file
+         s = ''
+         filenames = @argv
+         filenames.each do |filename|
+            File.open(filename) do |f|
+               f.each_line do |line|
+                  s << line.gsub(/([^\t]{8})|([^\t]*)\t/n){[$+].pack("A8")}  ## expand tab
+               end
+            end
+         end
+         yaml = YAML.load(s)
+
+         ## manufacture
+         manufactory = Manufactory.new()
+         manufactory.manufacture(yaml)
+         $stderr.print yaml.to_yaml if options[?D]
+
+         ## template filename
+         template = options[?f]
+         unless template
+            return nil if options[?D]
+            #* key=:template_required  msg="template is not specified."
+            raise CommandOptionError.new(Kwatable.msg(:template_required))
+         end
+
+         ## template filepath
+         template_filepath = nil
+         if test(?f, template)
+            template_filepath = template
+         elsif options[?I] && t = find_template(template, options[?I])
+            template_filepath = t
+         else
+            template_filepath = find_template(template, Kwatable.template_path)
+         end
+         unless template_filepath
+            #* key=:template_notfound  msg="`%s': template file not found."
+            raise CommandOptionError.new(Kwatable.msg(:template_notfound) % template)
+         end
+
+         ## apply template
+         if !options[?m]
+            context = { 'tables' => yaml['tables'], 'properties' => properties, }
+            output = apply_template(template_filepath, context)
+            return output
+         else
+            yaml['tables'].each do |table|
+               context = { 'table' => table, 'properties' => properties, }
+               output = apply_template(template_filepath, context)
+               output_filename = context[:output_filename]
+               output_filename = "#{options[?d]}/#{output_filename}" if options[?d]
+               File.open(output_filename, 'w') { |f| f.write(output) }
+               unless options[?s]
+                  #* key=:file_generated  msg="generated: %s"
+                  $stderr.puts(Kwatable.msg(:file_generated) % output_filename)
+               end
+            end
+            return nil
+         end
+      end
+
+      private
+
+      def parse_options(argv)
+         options = {}
+         properties = {}
+         while argv[0] && argv[0][0] == ?-
+            optstr = argv.shift
+            if optstr =~ /\A--([-\w]+)(=.*)?/		## properties
+               key, value = $1, $2
+               key = key.gsub(/-/, '_')
+               if value
+                   value.sub!(/\A=/, '')
+               else
+                   value = true
+               end
+               case value
+               when "true", "yes"    ;  value = true
+               when "false", "no"    ;  value = false
+               when "null", "nil"    ;  value = nil
+               when /\A\d+\z/        ;  value = value.to_i
+               when /\A\d+\.\d+\z/   ;  value = value.to_f
+               when /\A'.*'\z/       ;  value = eval(value)
+               when /\A".*"\z/       ;  value = eval(value)
+               end
+               properties[key.intern] = value
+            else
+               optstr = optstr[1, optstr.length-1]
+               while optstr && !optstr.empty?
+                  optchar = optstr[0]
+                  optstr  = optstr[1, optstr.length-1]
+                  case optchar
+                  when ?h, ?v, ?m, ?s, ?D
+                     options[optchar] = true
+                  when ?f, ?t
+                     arg = optstr.empty? ? argv.shift : optstr
+                     optstr = nil
+                     unless arg
+                        #* key=:template_required  msg="-%s: template filename required."
+                        raise CommandOptionError.new(Kwatable.msg(:template_required) % optchar.chr)
+                     end
+                     options[?f] = arg
+                     #options[optchar] = arg
+                  when ?d
+                     arg = optstr.empty? ? argv.shift : optstr
+                     optstr = nil
+                     unless arg
+                        #* key=:outdir_required  msg="-%s: output directory required."
+                        raise CommandOptionError.new(Kwatable.msg(:outdir_required) % optchar.chr)
+                     end
+                     options[optchar] = arg
+                  when ?I
+                     arg = optstr.empty? ? argv.shift : optstr
+                     optstr = nil
+                     unless arg
+                        #* key=:directory_required  msg="-%s: directory required."
+                        raise CommandOptionError.new(Kwatable.msg(:directory_required) % optchar.chr)
+                     end
+                     (options[optchar] ||= []).concat(arg.split(/,/))
+                  else
+                     #* key=:option_invalid  msg="-%s: invalid option."
+                     raise CommandOptionError.new(Kwatable.msg(:option_invalid) % optchar.chr)
+                  end
+               end   # end while
+            end   # end if
+         end   # end while
+         return options, properties
+      end
+
+      def find_template(template, path_list)
+         path_list.each do |path|
+            t = "#{path}/#{template}"
+            return t if test(?f, t)
+         end
+         return nil
+      end
+
+      def apply_template(filename, context)
+         str = File.open(filename) { |f| f.read() }
+         trim_mode = '>'  # or '%'
+         erb = ERB.new(str, $SAFE, trim_mode)
+         result = eval_erb(erb, context)
+         return result
+      end
+
+      def eval_erb(__erb, context)
+         return __erb.result(binding())
+      end
+
+      def usage()
+         command = File::basename($0)
+         s = ""
+         s << "Usage: #{command} [-hvm] [-I path] [-d dir] -f template datafile [datafile2 ...]\n"
+         s << "  -h           : help\n"
+         s << "  -v           : version\n"
+         s << "  -I path      : template directory path\n"
+         s << "  -f template  : template filename\n"
+         s << "  -m           : multiple output file\n"
+         s << "  -d dir       : output file directory (with '-m')\n"
+         s << "  -s           : silent mode\n"
+         return s
+      end
+
+      def version()
+         return ("$Release: 0.0.1 $" =~ /[\.\d]+/ && $&)
+      end
+
+   end
+
+end

data/lib/kwatable/manufactory.rb

@@ -0,0 +1,213 @@
+###
+### copyright(c) 2005 kuwata-lab.com all rights reserved.
+### $Release: 0.0.1 $
+### $Rev: 11 $
+###
+
+require 'yaml'
+
+module Kwatable
+
+   class ManufactureError < KwatableError
+   end
+
+
+   ##
+   ## ex.
+   ##  manufactory = Kwatable::Manufactory.new
+   ##  tabledef = manufactory.parse(input)    # input is String or File
+   ##  p tabledef[:columns]
+   ##  p tabledef[:tables]
+   ##
+   class Manufactory
+
+      def parse(input)
+         str = ''
+         input.each_line do |line|
+            str << line.gsub(/([^\t]{8})|([^\t]*)\t/n){[$+].pack("A8")}    ## expand tab
+         end
+         ingredient = YAML.load(str)
+         manufacture(ingredient)
+         return ingredient
+      end
+
+      def manufacture(ingredient)
+         #assert unless ingredient.is_a?(Hash)
+      
+         column_map, patterned_columns = manufacture_columns(ingredient['columns'])
+         #assert unless column_map.is_a?(Hash)
+         #assert unless patterned_columns.is_a?(Array)
+
+         table_map = manufacture_tables(ingredient['tables'], column_map, patterned_columns)
+         #assert unless table_map.is_a?(Hash)
+
+         ingredient['column_map'] = column_map         # Hash
+         ingredient['table_map'] = table_map           # Hash
+         return ingredient
+      end
+
+      private
+
+      def manufacture_columns(columns)
+         column_map  = {}
+         patterned_columns = []
+         columns.each do |column|
+            name = column['name']
+            unless name
+               #* key=:colname_required  msg="column definition doesn't have a name."
+               raise ManufactureError.new(Kwatable.msg(:colname_required))
+            end
+            if name =~ /\A\/(.*)\/\z/
+               pattern = $1
+               begin
+                  name = Regexp.compile(pattern)
+               rescue RegexpError => ex
+                  #* key=:regexp_invalid  msg="column %s: %s"
+                  raise ManufactureError.new(Kwatable.msg(:regexp_invalid) % [name, ex.message])
+               end
+               column['namepattern'] = name
+               #column.delete('name')
+               patterned_columns << column
+            else
+               if column_map.key?(name)
+                  #* key=:coldef_duplicated  msg="column definition `%s' is duplicated."
+                  raise ManufactureError.new(Kwatable.msg(:coldef_duplicated) % name)
+               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 ManufactureError.new(Kwatable.msg(:colname_required))
+            #end
+            #if name
+            #   if column_map.key?(name)
+            #      #* key=:coldef_duplicated  msg="column definition `%s' is duplicated."
+            #      raise ManufactureError.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
+      end
+
+      def manufacture_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 do |table|
+            name = table['name']
+            unless name
+               #* key=:tablename_required  msg="table definition doesn't have a name."
+               raise ManufactureError.new(Kwatable.msg(:tablename_required))
+            end
+            if table_map.key?(name)
+               #* key=:tabledef_duplicated  msg="table definition `%s' is duplicated."
+               raise ManufactureError.new(Kwatable.msg(:tabledef_duplicated) % [name])
+            end
+            table_map[name] = table
+         end
+
+         ## manufacture table columns
+         tables.each do |table|
+            name_map = {}
+            table['columns'].each do |column|
+               name = column['name']
+               unless name
+                  #* key=:tablecolumn_required  msg="table '%s': column name requried."
+                  raise ManufactureError.new(Kwatable.msg(:tablecolumn_required % [table['name']]))
+               end
+               if name_map[name]
+                  #* key=:tablecolumn_duplicated msg="table '%s': column '%s' is duplicated."
+                  raise ManufactureError.new(Kwatable.msg(:tablecolumn_duplicated % [table['name'], name]))
+               end
+               name_map[name] = 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, "primary-key", "identifier")
+               alias_key(column, "not-null",    "required")
+               handle_ref(column, table_map) if column['ref']
+               handle_values(column) if column['values']
+               unless column['type']
+                  #* key=:tabletype_required  msg="table `%s': type of column `%s' is not determined."
+                  raise ManufactureError.new(Kwatable.msg(:tabletype_required) % [table['name'], column['name']])
+               end
+            end if table['columns']
+         end if tables
+
+         return table_map
+      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_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
+      end
+
+      def alias_key(column, key1, key2)
+         if column[key1] && !column.key?(key2)
+            column[key2] = column[key1]
+         elsif column[key2] && !column.key?(key1)
+            column[key1] = column[key2]
+         end
+      end
+
+      def handle_values(column)
+         return unless column['values']
+         width = 0
+         column['values'].each do |value|
+            len = value.to_s.length
+            width = len if len > width
+         end
+         column['type']  ||= 'string'
+         column['width'] ||= width
+      end
+
+      def handle_ref(column, 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="`ref: %s': table not found."
+            raise ManufactureError.new(Kwatable.msg(:reftable_notfound) % 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="`ref: %s': column not found in the table."
+            raise ManufactureError.new(Kwatable.msg(:refcolumn_notfound) % column['ref'])
+         end
+         column['ref-table']  = ref_table
+         column['ref-column'] = 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
+
+   end
+
+end

data/lib/kwatable/templates/ddl-mysql.eruby

@@ -0,0 +1,169 @@
+<%
+
+   ##
+   ## kwatable template file for MySQL
+   ##
+   ## copyright(c) 2005 kuwata-lab.com all rights reserved.
+   ## $Release: 0.0.1 $
+   ## $Rev: 12 $
+   ##
+   ## template properties:
+   ##   (none)
+
+
+   #
+   # context variables
+   #
+   tables     = context['tables']
+   properties = context['properties']
+   raise "don't use '-m' option with 'ddl-mysql.eruby'." unless tables
+
+
+   #
+   # MySQL keywords
+   #
+   keywords = <<-END
+      add all alter analyze and as asc asensitive
+      before between bigint binary blob both by
+      call cascade case change char character check collate column
+      condition connection constraint continue convert create cross
+      current_date current_time current_timestamp current_user cursor
+      database databases day_hour day_microsecond day_minute day_second
+      dec decimal declare default delayed delete desc describe
+      deterministic distinct distinctrow div double drop dual
+      each else elseif enclosed escaped exists exit explain
+      false fetch float for force foreign from fulltext
+      goto grant group
+      having high_priority hour_microsecond hour_minute hour_second
+      if ignore in index infile inner inout insensitive insert
+      int integer interval into is iterate
+      join
+      key keys kill
+      leading leave left like limit lines load localtime
+      localtimestamp lock long longblob longtext loop low_priority
+      match mediumblob mediumint mediumtext middleint
+      minute_microsecond minute_second mod modifies
+      natural not no_write_to_binlog null numeric
+      on optimize option optionally or order out outer outfile
+      precision primary procedure purge
+      read reads real references regexp release rename repeat
+      replace require restrict return revoke right rlike
+      schema schemas second_microsecond select sensitive
+      separator set show smallint soname spatial specific sql
+      sqlexception sqlstate sqlwarning sql_big_result
+      sql_calc_found_rows sql_small_result ssl starting straight_join
+      table terminated then tinyblob tinyint tinytext to
+      trailing trigger true
+      undo union unique unlock unsigned update usage use using
+      utc_date utc_time utc_timestamp
+      values varbinary varchar varcharacter varying
+      when where while with write
+      xor
+      year_month
+      zerofill
+   END
+   KEYWORDS = {}
+   keywords.split(/\s+/).each { |word| KEYWORDS[word] = true }
+
+
+   #
+   # escape keyword
+   #
+   def _(word)
+      return KEYWORDS[word.downcase] ? "`#{word}`" : word
+   end
+
+
+   #
+   # start output
+   #
+%>
+----------------------------------------------------------------------
+-- DDL for MySQL
+--   generated by kwatable with template 'ddl-mysql.eruby'
+--   at <%= Time.now.to_s %>
+
+----------------------------------------------------------------------
+<%
+   #
+   # create table statement
+   #
+ %>
+<% for table in tables %>
+
+-- <%= table['desc'] %>
+
+create table <%= _(table['name']) %> (
+<%
+      n = table['columns'].length
+      i = 0
+      for column in table['columns']
+         i += 1
+         flag_last_loop = (i == n)
+
+         name  = column['name']
+         type  = column['type']
+         width = column['width']
+
+         #
+         # column type
+         #
+         case type
+         when 'char'      ;  type = 'tinyint'
+         when 'short'     ;  type = 'mediumint'
+         when 'int'       ;  type = 'integer'
+         when 'inteter'   ;
+         when 'str'       ;  type = 'varchar' ; width ||= 255
+         when 'string'    ;  type = 'varchar' ; width ||= 255
+         when 'text'      ;
+         when 'float'     ;
+         when 'double'    ;
+         when 'bool'      ;  type = 'boolean'
+         when 'boolean'   ;
+         when 'date'      ;
+         when 'timestamp' ;
+         when 'money'     ;  type = 'decimal'
+         end
+         type += "(#{width})" if width
+
+         #
+         # set type with 'enum(...)' if column has values
+         #
+         if column['values']
+            type  = "enum(" + column['values'].collect{|v| "'#{v}'"}.join(", ") + ")"
+            width = nil
+         end
+
+         #
+         # constraints
+         #
+         constraints = []
+         constraints << 'auto_increment' if column['serial']
+         constraints << 'not null'       if column['not-null'] && !column['serial'] && !column['primary-key']
+         constraints << 'primary key'    if column['primary-key']
+         constraints << 'unique'         if column['unique']
+
+         #
+         # column definition
+         #
+         name_part  = '%-20s' % _(name)
+         type_part  = '%-20s' % type
+         const_part = constraints.join(' ')
+         comma   = flag_last_loop ? '' : ','
+         comment = column['ref'] ? "  -- references #{column['ref']}" : ""
+ %>
+   <%= name_part %> <%= type_part %> <%= const_part %><%= comma %><%= comment %>
+
+<%
+      end
+
+      #
+      # composite primary key
+      #
+ %>
+<%    if table['primary-keys'] %>
+<%       pkeystr = table['primary-keys'].collect { |pkey| _(pkey) }.join(', ') %>
+   , primary key (<%= pkeystr %>)
+<%    end %>
+);
+<% end %>