kwatable 0.2.0 → 0.3.0

data/lib/kwatable/template/dto-ruby.eruby

@@ -0,0 +1,63 @@
+<%
+
+   ##
+   ## kwatable template file for Ruby DTO class
+   ##
+   ## $Rev: 40 $
+   ## $Release: 0.3.0 $
+   ## copyright(c) 2005 kuwata-lab.com all rights reserved.
+   ##
+   ## <template-desc>generate DTO classes for Ruby</template-desc>
+   ## <template-properties>
+   ##  --module=name    :  module name
+   ##  --parent=name    :  parent class
+   ##  --reqpath=path   :  require path
+   ##  --populate       :  define populate method
+   ##  --symbolkey      :  use symbol as hash key
+   ## </template-properties>
+   ##
+
+   require 'kwatable/template/helper/common'
+   require 'kwatable/template/helper/table'
+   require 'kwatable/template/helper/column'
+   require 'kwatable/template/helper/ruby'
+   extend Kwatable::CommonHelper
+   extend Kwatable::TableHelper
+   extend Kwatable::ColumnHelper
+   extend Kwatable::RubyHelper
+
+   require 'active_support/inflector'
+   #extend Inflector
+
+
+   ## context check
+   context_var_required('@tables')
+
+
+   ## use '_' as escape function
+   alias _ escape_ruby_keyword
+
+
+   ##
+   ## apply template
+   ##
+   basename = File.basename(@template_filename)
+   subtemplate_filename = basename.sub(/\.eruby\z/, '.sub.eruby')
+   subtemplate_filepath = Util.find_file(subtemplate_filename, @template_pathlist)
+   unless subtemplate_filepath
+     raise "#{basename}: subtemplate `#{subtemplate_filename}' not found."
+   end
+   @output_files = []
+   context = self
+   encoding = @properties[:encoding] || @properties[:charset]
+   each_table(@tables) do |table|p
+     @table = table
+     output = Util.eval_template(subtemplate_filepath, context)
+     output = Util.encode(output, encoding) if encoding
+     outfile = @output_filename  # set in subtemplate
+     @output_files << [outfile, output, :create]
+   end
+   @table = nil
+
+
+ %>

data/lib/kwatable/template/dto-ruby.sub.eruby

@@ -0,0 +1,213 @@
+<%
+
+   ##
+   ## sub-template of dto-ruby.eruby
+   ##
+   ## $Rev: 38 $
+   ## $Release: 0.3.0 $
+   ## copyright(c) 2005 kuwata-lab.com all rights reserved.
+   ##
+
+
+   #
+   # context check
+   #
+   context_var_required('@tables')
+
+
+   #
+   # output file name
+   #
+   @output_filename = Inflector.underscore(table_class(@table)) + ".rb"
+
+
+   #
+   # class definition
+   #
+   klass = {
+      :name    => table_class(@table),
+      :module  => @table['module'] || @properties[:module],
+      :parent  => @table['parent'] || @properties[:parent],
+      :desc    => @table['desc'],
+   }
+
+
+   #
+   # instance variables
+   #
+   variables = []
+   for column in @table['columns']
+      hash = {
+         :name => column_attr(column),
+         :type => column['class'] || column['type'],
+         :desc => column['desc'],
+      }
+      variables << hash
+   end
+
+
+   #
+   # relations
+   #
+   relations = []
+   for relation in @table['relations']
+      kind = relation['kind']
+      attr = Inflector.underscore(table_class(relation['table']))
+      attr = Inflector.pluralize(attr) unless kind == '1:1'
+      hash = {
+         :kind => kind,
+         :attr => relation['attr'] || attr,
+      }
+      relations << hash
+   end if @table['relations']
+
+
+ %>
+##
+## DTO for Ruby
+##   generated by kwatable with template 'dto-ruby.eruby'
+##   at <%= Time.now.to_s %>
+
+##
+<%
+   #
+   # require other dto file
+   #
+   refclass_table = {}
+   coltypes = {}
+   for column in @table['columns']
+      coltypes[column['type']] = true
+      next unless column['ref']
+      refclass = table_class(column['ref']['table'])
+      reqpath = @properties[:reqpath]
+      next if refclass_table[refclass]
+      refclass_table[refclass] = true
+      libname = Inflector.underscore(refclass)
+%>
+require '<%= reqpath %><%= reqpath ? '/' : '' %><%= libname %>'
+<%
+   end
+ %>
+<% if @properties[:populate] %>
+<%    if coltypes['date'] || coltypes['datetime'] || coltypes['timestamp'] %>
+require 'date'
+<%    end %>
+<%    if coltypes['time'] %>
+require 'time'
+<%    end %>
+<% end %>
+
+<%
+   #
+   # class definition start
+   #
+   mod     = klass[:module] ? "#{klass[:module]}::" : ""
+   extends = klass[:parent] ? " < #{klass[:parent]}" : ""
+
+ %>
+<%= klass[:desc].gsub(/^/, '## ') %>
+
+class <%= mod %><%= klass[:name] %><%= extends %>
+
+
+<%
+   #
+   # accessor
+   #
+ %>
+<% for var in variables %>
+   attr_accessor :<%= '%-14s' % var[:name] %> # <%= var[:desc] %>
+
+<% end %>
+
+<%
+   #
+   # set all values
+   #
+%>
+<% if @properties[:populate] %>
+   def populate(_hash={})
+<%
+      flag_symbol = @properties[:symbolkey]
+      flag_date = flag_datetime = false
+      for var in variables
+         key = flag_symbol ? ":#{var[:name]}" : "'#{var[:name]}'"
+         case var[:type]
+         when 'str', 'string'
+            expr = "_hash[#{key}]"
+         when 'int', 'integer', 'short', 'long'
+            expr = "_hash[#{key}].to_i"
+         when 'float', 'double'
+            expr = "_hash[#{key}].to_f"
+         when 'char'
+            expr = "_hash[#{key}]"
+         when 'bool', 'boolean'
+            expr = "! _hash[#{key}].empty?"
+         when 'date'
+            expr = "Date.parse(_hash[#{key}])"
+         when 'time'
+            expr = "Time.parse(_hash[#{key}])"
+         when 'timestamp', 'datetime'
+            expr = "DateTime.parse(_hash[#{key}])"
+         when 'money'
+            expr = "_hash[#{key}].to_f"
+         else
+           raise "*** internal error: var=#{var.inspect}"
+         end
+ %>
+      <%= "@%-14s = %-25s if _hash.key?(%s)" % [var[:name], expr, key] %>
+
+<%
+      end
+ %>
+   end
+
+<% end %>
+<%
+   #
+   # foreign keys
+   #
+   count = 0
+   for column in @table['columns']
+      if column['ref']
+         count += 1
+         refname = column_refname(column)
+         varname = column_name(column)
+         if refname == varname
+            raise "table #{@table['name']}: column #{column['name']}: proper ref-name is required."
+         end
+         reftype = table_class(column['ref']['table'])
+         argname = Inflector.underscore(reftype)
+ %>
+<%       if count == 1 %>
+   # accessors via foreign keys
+<%       end %>
+   attr_reader :<%= refname %>
+
+   def <%= refname %>=(<%=_ argname %>)
+      @<%= refname %> = <%=_ argname %>
+
+      self.<%= varname %> = <%=_ argname %>.<%= column_name(column['ref']) %>
+
+   end
+
+<%
+      end
+   end
+ %>
+<%
+   #
+   # relations
+   #
+   if !relations.empty?
+%>
+   # relations
+<%    for relation in relations %>
+   attr_accessor :<%= '%-15s' % relation[:attr] %> # <%= relation[:kind] %>
+
+<%    end %>
+
+<%
+   end
+ %>
+end

data/lib/kwatable/template/helper/column.rb

@@ -0,0 +1,70 @@
+###
+### $Rev: 39 $
+### $Release: 0.3.0 $
+### copyright(c) 2005 kuwata-lab.com all rights reserved.
+###
+
+module Kwatable
+
+  module ColumnHelper
+
+    module_function
+
+    ##
+    def column_attr(column)
+      return column['attr'] || column['name']
+    end
+
+    alias column_name column_attr
+
+    ##
+    def column_refname(column)
+      attr = column_attr(column)
+      return column['ref-name'] || \
+             (column['ref'] ? attr.sub(/_#{column['ref']['name']}\z/, '') : attr)
+    end
+
+    ##
+    def column_label(column)
+      return column['label'] || column_refname(column)
+    end
+
+
+    ##
+    def column_showable?(column)
+      #return column_control_type(column) ? true : false
+      name = column['name']
+      return false if name == 'id'
+      return false if name == 'password' || name == 'passwd'
+      return true
+    end
+
+    ##
+    def column_editable?(column)
+      name = column['name']
+      return false if name == 'id'
+      return false if name =~ /\A(created|updated)_(on|at)\z/
+      return true
+    end
+
+    ##
+    def column_control_type(column)
+      type = column['type']
+      name = column['name']
+      if    name == 'id'                                 ;  return nil
+      elsif column['ref']                                ;  return 'select'
+      elsif column['enum']                               ;  return 'radio'
+      elsif %w[created_on created_at].include?(name)     ;  return nil
+      elsif %w[modified_on modified_at].include?(name)   ;  return nil
+      elsif %w[date timestamp datetime].include?(type)   ;  return 'select'
+      elsif %w[boolean bool].include?(type)              ;  return 'checkbox'
+      elsif %w[text].include?(type)                      ;  return 'text_area'
+      elsif %w[password passwd].include?(name)           ;  return 'password_field'
+      else                                               ;  return 'text_field'
+      end
+    end
+
+
+  end
+
+end

data/lib/kwatable/template/helper/common.rb

@@ -0,0 +1,151 @@
+##
+## $Rev: 43 $
+## $Release: 0.3.0 $
+## copyright(c) 2005 kuwata-lab.com all rights reserved.
+##
+
+require 'kwatable/util'
+
+module Kwatable
+
+
+  module CommonHelper
+
+
+    ##
+    def context_var_required(var_name)
+      value = instance_variable_get(var_name)
+      return if value
+      template_name = File.basename(@template_filename).sub(/\.\w+$/, '')
+      msg = case var_name
+            when '@tables' ; "don't use '-m' option with '%s'."         % template_name
+            when '@table'  ; "option '-m' is required when using '%s'." % template_name
+            else           ; "context value '%s' required but not found." % var_name
+            end
+      err = StandardError.new(msg)
+      err.set_backtrace(caller())
+      raise err
+    end
+
+
+    ## convert 'foo_bar_baz' into 'FooBarBaz'
+    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
+      #s = name.split('_').collect { |w| w.capitalize }.join()
+      #s[0] = s[0].to_s.upcase.chr unless flag_all
+      return s
+    end
+
+
+    ## quote by single-quoation
+    def q(obj)
+      return "'#{obj.to_s.gsub(/['\\]/, '\\\\\1')}'"
+    end
+
+
+    ## find file from path_list
+    def find_file(filename, path_list, find_in_currdir=true)
+      return Util.find_file(filename, path_list, find_in_currdir)
+    end
+
+
+    ## find subtemplate
+    def find_subtemplate(template_filename=@template_filename, template_pathlist=@template_pathlist)
+      basename = File.basename(template_filename)
+      subtemplate_filename = basename.sub(/\.eruby\z/, '.sub.eruby')
+      subtemplate_filepath = Util.find_file(subtemplate_filename, template_pathlist)
+      unless subtemplate_filepath
+        raise "#{basename}: subtemplate `#{subtemplate_filepath}' not found."
+      end
+      return subtemplate_filepath
+    end
+
+
+    ## read user custom code from output filename and apply template with it.
+    ## return output string and action symbol(:create, :update, or :identical).
+    def eval_template_with_custom_code(template_filename, context, output_filename, options={})
+      # options
+      encoding = options[:encoding]
+      template = options[:template]
+      # get user custom code
+      if test(?f, output_filename)
+        content = File.read(output_filename)
+        custom_code = user_custom_code(content)
+      else
+        content = custom_code = nil
+      end
+      # eval template and get output
+      context.instance_variable_set("@user_custom_code", custom_code)
+      output = Util.eval_template(template_filename, context, template)
+      output = encode(output, encoding) if encoding
+      context.instance_variable_set("@user_custom_code", nil)
+      # detect action
+      action = content.nil? ? :create : (content == output ? :identical : :update)
+      return output, action
+    end
+
+
+    ## get user custom code
+    def user_custom_code(content)
+      pattern = /^.*<user-custom-code>(?:.|\n)*<\/user-custom-code>.*\n/
+      return content =~ pattern ? $& : nil
+    end
+
+
+    ## encode string
+    def encode(str, encoding)
+      require 'kconv'
+      out_code = case encoding
+                 when /\Aeuc-jp\z/i          ;  Kconv::EUC
+                 when /\As(hift[-_])?jis\z/i ;  Kconv::SJIS
+                 when /\Autf8\z/i            ;  Kconv::UTF8
+                 when /\Autf16\z/i           ;  Kconv::UTF16
+                 when /\Aiso-2022-jp\z/i     ;  Kconv::JIS
+                 else                        ;  nil
+                 end
+      return Kconv.kconv(str, out_code)
+    end
+
+
+    ##
+    def each_table(tables, &block)
+      tables.each do |table|
+        reason = table_check_modeling(table)
+        if reason
+          msg = "*** table '#{table['name']}' skipped. (reason: #{reason})"
+          $stderr.puts msg unless @options[?q]
+        else
+          yield(table)
+        end
+      end
+    end
+
+
+    ## apply subtemplate for each tables
+    def apply_subtemplate_for_each_tables(tables, opthash={}, &block)
+      subtemplate_filepath = find_subtemplate()
+      subtemplate = File.read(subtemplate_filepath)
+      encoding = @properties[:encoding] || @properties[:charset]
+      context = self
+      output_files = []
+      opts = { :encoding=>encoding, :template=>subtemplate }
+      each_table(@tables) do |table|
+        output_filename = yield(table)
+        dir = @options[?d]
+        output_filename = "#{dir}/#{output_filename}" if dir
+        @table = table
+        output, action = eval_template_with_custom_code(subtemplate_filepath, context, output_filename, opts)
+        @table = nil
+        output_files << [output_filename, output, action]
+      end
+      return output_files
+    end
+
+
+  end
+
+
+end