kwatable 0.0.1 → 0.1.0

data/lib/kwatable/manipulator.rb

@@ -0,0 +1,222 @@
+###
+### copyright(c) 2005 kuwata-lab.com all rights reserved.
+### $Release: 0.1.0 $
+### $Rev: 15 $
+###
+
+require 'yaml'
+
+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
+      end
+
+      private
+
+      def _error(message_key, *args)
+         msg = Kwatable.msg(:regexp_invalid) % args
+         return ManipulationError.new(msg)
+      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
+            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
+      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
+      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, 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)
+      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
+      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')
+      end
+
+   end
+
+end

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

@@ -4,11 +4,12 @@
    ## kwatable template file for MySQL
    ##
    ## copyright(c) 2005 kuwata-lab.com all rights reserved.
-   ## $Release: 0.0.1 $
-   ## $Rev: 12 $
+   ## $Release: 0.1.0 $
+   ## $Rev: 15 $
    ##
    ## template properties:
    ##   (none)
+   ##
 
 
    #
@@ -62,15 +63,15 @@
       year_month
       zerofill
    END
-   KEYWORDS = {}
-   keywords.split(/\s+/).each { |word| KEYWORDS[word] = true }
+   @keywords = {}
+   keywords.split(/\s+/).each { |word| @keywords[word] = true }
 
 
    #
    # escape keyword
    #
-   def _(word)
-      return KEYWORDS[word.downcase] ? "`#{word}`" : word
+   def self._(word)
+      return @keywords[word.downcase] ? "`#{word}`" : word
    end
 
 
@@ -127,10 +128,10 @@ create table <%= _(table['name']) %> (
          type += "(#{width})" if width
 
          #
-         # set type with 'enum(...)' if column has values
+         # set type with 'enum(...)' if column has enum
          #
-         if column['values']
-            type  = "enum(" + column['values'].collect{|v| "'#{v}'"}.join(", ") + ")"
+         if column['enum']
+            type  = "enum(" + column['enum'].collect{|v| "'#{v}'"}.join(", ") + ")"
             width = nil
          end
 
@@ -139,8 +140,8 @@ create table <%= _(table['name']) %> (
          #
          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 << 'not null'       if column['required'] && !column['serial'] && !column['ident']
+         constraints << 'primary key'    if column['ident']
          constraints << 'unique'         if column['unique']
 
          #
@@ -150,7 +151,9 @@ create table <%= _(table['name']) %> (
          type_part  = '%-20s' % type
          const_part = constraints.join(' ')
          comma   = flag_last_loop ? '' : ','
-         comment = column['ref'] ? "  -- references #{column['ref']}" : ""
+         #comment = column['ref'] ? "  -- references #{column['ref']}" : ""
+         ref = column['ref']
+         comment = ref ? "  -- references #{ref['table']['name']}(#{ref['name']})" : ""
  %>
    <%= name_part %> <%= type_part %> <%= const_part %><%= comma %><%= comment %>
 

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

@@ -4,11 +4,12 @@
    ## kwatable template file for PostgreSQL
    ##
    ## copyright(c) 2005 kuwata-lab.com all rights reserved.
-   ## $Release: 0.0.1 $
-   ## $Rev: 12 $
+   ## $Release: 0.1.0 $
+   ## $Rev: 15 $
    ##
    ## template properties:
    ##   (none)
+   ##
 
 
    #
@@ -47,15 +48,15 @@
       vacuum varchar verbose
       when where
    END
-   KEYWORDS = {}
-   keywords.split(/\s+/).each { |word| KEYWORDS[word] = true }
+   @keywords = {}
+   keywords.split(/\s+/).each { |word| @keywords[word] = true }
 
 
    #
    # escape keyword
    #
-   def _(word)
-      return KEYWORDS[word.downcase] ? "\"#{word}\"" : word
+   def self._(word)
+      return @keywords[word.downcase] ? "\"#{word}\"" : word
    end
 
 
@@ -122,10 +123,13 @@ create table <%= _(table['name']) %> (
          # constraints
          #
          constraints = []
-         constraints << 'not null'    if column['not-null'] && !column['serial'] && !column['primary-key']
-         constraints << 'primary key' if column['primary-key']
+         constraints << 'not null'    if column['required'] && !column['serial'] && !column['ident']
+         constraints << 'primary key' if column['ident']
          constraints << 'unique'      if column['unique']
-         constraints << "references #{column['ref-table']['name']}(#{column['ref-column']['name']})" if column['ref-table']
+         #constraints << "references #{column['ref-table']['name']}(#{column['ref-column']['name']})" if column['ref-table']
+         ref = column['ref']
+         constraints << "references #{ref['table']['name']}(#{ref['name']})" if ref
+
 
          #
          # column definition
@@ -134,7 +138,7 @@ create table <%= _(table['name']) %> (
          type_part  = '%-20s' % type
          const_part = constraints.join(' ')
          comma   = flag_last_loop ? '' : ','
-         comment = column['values'] ? "  -- #{column['values'].join(',')}" : ""
+         comment = column['enum'] ? "  -- #{column['enum'].join(',')}" : ""
  %>
    <%= name_part %> <%= type_part %> <%= const_part %><%= comma %><%= comment %>
 

data/lib/kwatable/templates/defaults.yaml

@@ -3,8 +3,8 @@
 ##
 ## copyright(c) 2005 kuwata-lab all rights reserverd
 ## 
-## $Id: defaults.yaml 11 2005-09-11 13:15:45Z kwatch $
-## $Release: 0.0.1 $
+## $Id: defaults.yaml 13 2005-09-15 00:21:25Z kwatch $
+## $Release: 0.1.0 $
 ##
 
 columns:
@@ -63,14 +63,14 @@ columns:
   - name:	gender
     type:	char
     width:	1
-    values:
+    enum:
       - M
       - F
       
   - name:	blood
     type:	char
     width:	2
-    values:
+    enum:
       - A
       - B
       - O

data/lib/kwatable/templates/dto-java.eruby

@@ -4,12 +4,13 @@
    ## kwatable template file for Java DTO class
    ##
    ## copyright(c) 2005 kuwata-lab.com all rights reserved.
-   ## $Release: 0.0.1 $
-   ## $Rev: 12 $
+   ## $Release: 0.1.0 $
+   ## $Rev: 15 $
    ##
    ## template properties:
    ##   package   -  package name
    ##   parent    -  parent class
+   ##
 
 
    #
@@ -20,46 +21,43 @@
    raise "option '-m' is required when using 'dto-java.eruby'." unless table
 
 
-   unless defined?(KEYWORDS)
-      #
-      # java keywords
-      #
-      keywords = <<-END
-        abstract boolean break byte case catch char class const
-        continue default do double else extends final finally float
-        for goto if implements import instanceof int interface long
-        native new package private protected public return short
-        static strictfp super switch synchronized this throw throws
-        transient try void volatile while
-      END
-      KEYWORDS = {}
-      keywords.split(/\s+/).each { |word| KEYWORDS[word] = true }
-
-
-      #
-      # escape java keywords
-      #
-      def _(word)
-         return KEYWORDS[word] ? "_#{word}" : word
-      end
+   #
+   # java keywords
+   #
+   keywords = <<-END
+     abstract assert boolean break byte case catch char class const
+     continue default do double else enum extends final finally float
+     for goto if implements import instanceof int interface long
+     native new package private protected public return short
+     static strictfp super switch synchronized this throw throws
+     transient try void volatile while
+   END
+   @keywords = {}
+   keywords.split(/\s+/).each { |word| @keywords[word] = true }
 
 
-      #
-      # convert 'aaa_bbb_ccc' into 'AaaBbbCcc'
-      #
-      def camel_case(name, flag_all=true)
-         s = ''
-         name.split('_').each_with_index do |word, i|
-            s << (!flag_all && i == 0 ? word.downcase : word.capitalize)
-         end
-         return s
-         #s = name.split('_').collect { |w| w.capitalize }.join()
-         #s[0] = s[0].to_s.upcase.chr unless flag_all
-      end
+   #
+   # escape java keywords
+   #
+   def self._(word)
+      return @keywords[word] ? "_#{word}" : word
+   end
+
 
+   #
+   # convert 'aaa_bbb_ccc' into 'AaaBbbCcc'
+   #
+   def self.camel_case(name, flag_all=true)
+      s = ''
+      name.split('_').each_with_index do |word, i|
+         s << (!flag_all && i == 0 ? word.downcase : word.capitalize)
+      end
+      return s
+      #s = name.split('_').collect { |w| w.capitalize }.join()
+      #s[0] = s[0].to_s.upcase.chr unless flag_all
    end
-   
-   
+
+
    #
    # class definition
    #
@@ -69,7 +67,7 @@
       :parent  => table['parent']  || properties[:parent],
       :desc    => table['desc'],
    }
-   
+
 
    #
    # output file name
@@ -135,24 +133,20 @@ public class <%= klass[:name] %><%= extends %> implements java.io.Serializable {
    #
    # instance variables
    #
-   for var in variables
-      vartype = '%-12s' % var[:type]
-      varname = '%-12s' % (var[:name]+';')
- %>
-    private  <%= vartype %> <%= _(varname) %>  /* <%= var[:desc] %> */
-<%
-  end
  %>
+<% for var in variables %>
+<%    varname = '%-12s' % ( _(var[:name]) + ';') %>
+    private  <%= '%-12s' % var[:type] %> <%= varname %>  /* <%= var[:desc] %> */
+<% end %>
 
 <%
    #
-   # constructor
+   # populator with java.sql.ResultSet
    #
-   argstr = variables.collect { |var| "#{var[:type]} #{_(var[:name])}" }.join(', ')
  %>
-    public <%= klass[:name] %>(<%= argstr %>) {
+    public void populate(java.sql.ResultSet resultset) {
 <% for var in variables %>
-        this.<%= _(var[:name]) %> = <%= _(var[:name]) %>;
+        set<%= camel_case(var[:name]) %>(resultset.get<%= var[:type].capitalize %>("<%= var[:name] %>"));
 <% end %>
     }
 
@@ -169,19 +163,15 @@ public class <%= klass[:name] %><%= extends %> implements java.io.Serializable {
     public <%= vartype %> <%= getter %>() { return <%= _(varname) %> }
     public void <%= setter %>(<%= vartype %> <%= _(varname) %>) { this.<%= _(varname) %> = <%= _(varname) %>; }
 
-<%
-   end
- %>
-    // -----------
-
+<% end %>
 <%
    #
    # foreign keys
    #
    for column in table['columns']
-      if column['ref-table']
-         reftype = column['ref-table']['class']
-         refcol  = column['ref-column']['name']
+      if column['ref']
+         reftype = column['ref']['table']['class']
+         refcolname = column['ref']['name']
          refname = column['ref-name']
          varname = column['name']
          if refname == varname
@@ -194,7 +184,7 @@ public class <%= klass[:name] %><%= extends %> implements java.io.Serializable {
     public <%= reftype %> <%= getter %>() { return <%= _(refname) %>; }
     public void <%= setter %>(<%= reftype %> <%= _(refname) %>) {
         this.<%= _(refname) %> = <%= _(refname) %>;
-        this.<%= _(varname) %> = <%= _(refname) %>.get<%= camel_case(refcol) %>();
+        this.<%= _(varname) %> = <%= _(refname) %>.get<%= camel_case(refcolname) %>();
     }
 
 <%