kwatable 0.2.0 → 0.3.0

data/lib/kwatable/template/rails-kwartz/show.plogic.eruby

@@ -0,0 +1,9 @@
+<%
+    ###
+    ### $Rev$
+    ### $Release: 0.3.0 $
+    ### copyright(c) 2005 kuwata-lab.com all rights reserved.
+    ###
+ %>
+@import '_link.plogic';
+@import '_attr.plogic';

data/lib/kwatable/template/rails-model.eruby

@@ -0,0 +1,35 @@
+<%
+
+  ##
+  ## kwatable template to generate Rails model class
+  ##
+  ## $Rev$
+  ## $Release: 0.3.0 $
+  ## copyright(c) 2005 kuwata-lab.com all rights reserved.
+  ##
+  ## <template-desc>generate Rails model classes</template-desc>
+  ## <template-properties>
+  ##  --lang=lang              :  language (ex. --lang=ja)
+  ##  --backup[=.bkup]         :  create backup file when updating
+  ##  --encoding=encoding      :  encoding (ex. --encoding=UTF8)
+  ## </template-properties>
+  ##
+
+
+  require 'kwatable/template/helper/common'
+  require 'kwatable/template/helper/table'
+  require 'kwatable/template/helper/column'
+  require 'kwatable/template/helper/label'
+  extend Kwatable::CommonHelper
+  extend Kwatable::TableHelper
+  extend Kwatable::ColumnHelper
+  extend Kwatable::LabelHelper
+
+
+  @output_files = apply_subtemplate_for_each_tables(@tables) { |table|
+    output_filename = table_model(table) + '.rb'
+    output_filename
+  }
+
+
+ %>

data/lib/kwatable/template/rails-model.sub.eruby

@@ -0,0 +1,136 @@
+<%
+
+  ##
+  ## $Rev$
+  ## $Release: 0.3.0 $
+  ## copyright(c) 2005 kuwata-lab.com all rights reserved.
+  ##
+
+  ##
+  def relation_options(hash)
+    list = hash.collect { |key, val|
+      k = Inflector.underscore(key)
+      v = val.inspect
+      case k
+      when 'kind'    ;  nil
+      when 'desc'    ;  nil
+      when 'table'   ;  nil
+      when 'columns' ;  nil
+      when 'where'   ;  ":conditions=>#{v}"
+      when 'orderby' ;  ":order=>#{v}"
+      #when 'as'      ; ":#{k}=>#{v}"
+      #when 'through' ; ":#{k}=>#{v}"
+      #when 'source'  ; ":#{k}=>#{v}"
+      else           ;  ":#{k}=>#{v}"
+      end
+    }.compact()
+    return list
+  end
+
+
+  ## generate model class
+  def generate_model_rb(table, user_code=nil)
+    controller_name = table['name']
+    class_name = table_class(table)
+    desc = (table['desc'] || '').gsub(/^/, '## ').chomp
+    # class start
+    s = ''
+    s <<     "#{desc}\n"
+    s <<     "class #{class_name} < ActiveRecord::Base\n"
+    # table name
+    if Inflector.pluralize(table_model(table)) != table['name']
+      s <<   "  set_table_name '#{table['name']}'\n"
+    end
+    # primary key
+    ident_column = table['ident-columns'].first
+    if ident_column['name'] != 'id'
+      s <<   "  set_primary_key '#{ident_column['name']}'\n"
+    end
+    # has_many, has_one
+    relmethods = { '1:1'=>'has_one', '1:n'=>'has_many', 'n:n'=>'has_and_belongs_to_many' }
+    for relation in table['relations']
+      relmethod = relmethods[relation['kind']]
+      relmodel  = table_model(relation['table'])
+      relcolname = column_name(relation['columns'].first)
+      relopts = ''
+      relopts << ", :foreign_key=>'#{relcolname}'" if relcolname != "#{table_model(table)}_id"
+      relopts << ", :join_table=>'#{relation['join-table']['name']}'" if relation['join-table']
+      relopts << ", :conditions=>#{relation['where'].inspect}" if relation['where']
+      relopts << ", :order=>'#{relation['order-by']}'" if relation['order-by']
+      relopts << ", :group=>'#{relation['group-by']}'" if relation['group-by']
+      for key in ['as', 'through', 'source']
+        relopts << ", :#{key}=>#{relation[key].inspect}" if relation[key]
+      end
+      if relation['vendor'] && relation['vendor']['rails-model']
+        for param in relation['vendor']['rails-model']
+          key, value = param
+          key.gsub!(/-/, '_')
+          relopts << ", :#{key}=>#{value.inspect}"
+        end
+      end
+      s <<   "  #{relmethod} :#{relmodel}#{relopts}\n"
+    end if table['relations']
+    # belongs_to
+    columns = table['columns']
+    for column in columns
+      if column['ref']
+        ref_name = column_refname(column)
+        s << "  belongs_to :#{ref_name}"
+        ref_model_name = table_model(column['ref']['table'])
+        ref_class_name = table_class(column['ref']['table'])
+        s << ", :class_name=>'#{ref_class_name}'" if ref_name != ref_model_name
+        ref_attr = column_attr(column['ref'])
+        foreign_key = "#{ref_model_name}_#{ref_attr}"
+        s << ", :foreign_key=>'#{column_attr(column)}'" if column['name'] != foreign_key
+        s << "\n"
+      end
+    end if columns
+    # alias
+    for column in columns
+      if column_attr(column) != column['name']
+        #s << "  alias #{column_attr(column)} #{column['name']}\n"
+        s << "  def #{column_attr(column)}; #{column['name']}; end\n"
+        s << "  def #{column_attr(column)}=(_val); #{column['name']}=(_val); end\n"
+      end
+    end if columns
+    # validator
+    for column in columns
+      next if !column_editable?(column)
+      colname = column_name(column)
+      if column['required']
+        s << "  validates_presence_of :#{colname}\n"
+      end
+      if %w[int integer float double money].include?(column['type'])
+        s << "  validates_numericality_of :#{colname}\n" unless column['ref']
+      end
+      if column['unique'] || (column['ident'] && colname != 'id')
+        s << "  validates_uniqueness_of :#{colname}\n"
+      end
+      if column['pattern']
+        s << "  validates_format_of :#{colname}, :with=>#{column['pattern']}\n"
+      end
+      if column['length']
+        h = column['length']
+        s << "  validates_length_of :#{colname}"
+        s << ", :maximum=>#{h['max']}" if h['max']
+        s << ", :minimum=>#{h['min']}" if h['min']
+        s << "\n"
+      end
+    end if columns
+    s << "\n"
+    # user-code
+    if user_code
+      s << user_code
+    else
+      s <<   "  ## <user-custom-code>\n"
+      s <<   "  ## ... put user custom code here\n"
+      s <<   "  ## </user-custom-code>\n"
+    end
+    s << "\n"
+    #
+    s <<     "end\n"
+    return s
+  end
+
+ %>
+<%= generate_model_rb(@table, @user_custom_code) %>

data/lib/kwatable/{templates → template}/validator-ruby.eruby

@@ -3,20 +3,27 @@
    ##
    ## kwatable template file for Ruby Validator
    ##
+   ## $Rev: 32 $
+   ## $Release: 0.3.0 $
    ## copyright(c) 2005 kuwata-lab.com all rights reserved.
-   ## $Release: 0.2.0 $
-   ## $Rev$
    ##
-   ## template properties:
-   ##   module  - module/class name
+   ## <template-desc>generate validator class for Ruby</template-desc>
+   ## <template-properties>
+   ##  --module=name    :  module/class name
+   ## </template-properties>
    ##
 
+   require 'kwatable/template/helper/common'
+   extend Kwatable::CommonHelper
+
+
    #
-   # context variables
+   # context check
    #
-   tables     = context['tables']
-   properties = context['properties']
-   
+   context_var_required('@tables')
+   #@tables or raise "don't use '-m' option with '%'." % File.basename(@template_filename)
+
+
    #
    # constraint keys
    #
@@ -29,12 +36,12 @@
 ##   at <%= Time.now.to_s %>
 
 ##
-<% if properties[:module] %>
+<% if @properties[:module] %>
 
-module <%= properties[:module] %>
+module <%= @properties[:module] %>
 
 <% end %>
-<% for table in tables %>
+<% for table in @tables %>
 
   ## <%= table['name'] %> - <%= table['desc'] %>
 

data/lib/kwatable/util.rb

@@ -0,0 +1,133 @@
+###
+### $Rev: 43 $
+### $Release: 0.3.0 $
+### copyright(c) 2005 kuwata-lab.com all rights reserved.
+###
+
+module Kwatable
+
+
+  module Util
+
+
+    module_function
+
+
+    ##
+    ## expand tab characters into spaces
+    ##
+    def untabify(str, width=8)
+      list = str.split(/\t/)
+      last = list.pop
+      sb = ''
+      list.each do |s|
+        column = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
+        n = width - (column % width)
+        sb << s << (" " * n)
+      end
+      sb << last
+      return sb
+    end
+
+
+    ##
+    ## find file from path_list
+    ##
+    def find_file(filename, path_list, find_in_currdir=true, test_char=?f)
+      ch = test_char
+      return filename if find_in_currdir && test(ch, filename)
+      #return nil if filename[0] == ?/         # absolute path
+      fname = nil
+      found = path_list.find { |path| test(ch, fname = "#{path}/#{filename}") }
+      return found ? fname : nil
+    end
+
+
+    ##
+    ## evaluate template with context object
+    ##
+    def eval_template(template_filename, context, template=nil)
+      template ||= File.read(template_filename)
+      trim_mode = 1
+      erb = ERB.new(template, nil, trim_mode)
+      return context.instance_eval(erb.src, template_filename)
+    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
+
+
+    ##
+    ## parse command-line options
+    ##
+    ## ex.
+    ##  argv = %w[-hqu user -p passwd --help --name=val file1 file2]
+    ##  options, properties, filenames = Util.parse_argv(argv, "hvq", "upl")
+    ##  p options    #=> { ?h=>true, ?q=>true, ?u=>"user", ?p=>"passwd" }
+    ##  p properties #=> { :help=>true, :name=>"val" }
+    ##  p filenames  #=> [ "file1", "file2" ]
+    ##
+    def parse_argv(argv, single_opts='', arged_opts='', optional_opts='')
+      options = {}
+      properties = {}
+      while argv[0] && argv[0][0] == ?-
+        optstr = argv.shift
+        if optstr == '-'
+          break
+        elsif optstr =~ /\A--([-\w]+)(?:=(.*))?/	# properties
+          key, value = $1, $2
+          case value
+          when nil              ;  value = true
+          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.gsub(/-/, '_').intern] = value
+        else						# options
+          optstr = optstr.slice(1..-1)
+          while optstr && !optstr.empty?
+            optchar = optstr[0]
+            optstr  = optstr.slice(1..-1)
+            if single_opts && single_opts.include?(optchar)
+              options[optchar] = true
+            elsif arged_opts && arged_opts.include?(optchar)
+              arg = optstr.empty? ? argv.shift : optstr
+              optstr = nil
+              raise "-#{optchar.chr}: argument required." unless arg
+              options[optchar] = arg
+            elsif optional_opts && optional_opts.include?(optchar)
+              arg = optstr.empty? ? true : optstr
+              optstr = nil
+              options[optchar] = arg
+            else
+              raise "-#{optchar.chr}: unknown option."
+            end
+          end  #while
+        end  #if
+      end  #while
+      filenames = argv
+      return options, properties, filenames
+    end
+
+
+  end
+
+end

data/lib/kwatable/util/assert-text-equal.rb

@@ -0,0 +1,47 @@
+###
+### $Rev: 36 $
+### $Release: 0.3.0 $
+### copyright(c) 2005 kuwata-lab.com all rights reserved.
+###
+
+require 'test/unit/testcase'
+require 'tempfile'
+
+
+class Test::Unit::TestCase  # :nodoc:
+
+
+  def assert_text_equal(expected, actual, message=nil, options={}) # :nodoc:
+    diffopt  = options[:diffopt] || '-u'
+    flag_cut = options.key?(:cut) ? options[:key] : true
+    prefix   = options[:prefix] || ''
+    #prefix   = prefix + "\n" if !prefix.empty? && prefix[-1] != ?\n
+
+    if expected == actual
+      assert(true)
+      return
+    end
+    if expected[-1] != ?\n || actual[-1] != ?\n
+      expected += "\n"
+      actual   += "\n"
+    end
+    begin
+      expfile = Tempfile.new(".expected.")
+      expfile.write(expected); expfile.flush()
+      actfile = Tempfile.new(".actual.")
+      actfile.write(actual);   actfile.flush()
+      diff = `diff #{diffopt} #{expfile.path} #{actfile.path}`
+    ensure
+      expfile.close(true) if expfile
+      actfile.close(true) if actfile
+    end
+    diff.sub!(/\A.*\n.*\n/, '') if flag_cut  # cut 1st & 2nd lines
+    msg = prefix + (message || diff)
+    assert_block(msg) { false }  # or assert(false, msg)
+  end
+
+  alias assert_equal_with_diff assert_text_equal    # for compatibility
+  alias assert_text_equals     assert_text_equal    # for typo
+
+
+end

data/lib/kwatable/util/assertion.rb

@@ -0,0 +1,115 @@
+###
+### $Rev: 33 $
+### $Release: 0.3.0 $
+### copyright(c) 2005 kuwata-lab.com all rights reserved.
+###
+
+##
+## utility module for assertion
+##
+## ex.
+##   require 'assertion'
+##   include Assertion   # or extend Assertion
+##   assert s && !s.empty?
+##   assert! unless s && !s.empty?
+##
+module Assertion
+
+
+  ##
+  ## assertion error class
+  ##
+  class AssertionError < StandardError
+
+    def initialize(message='')
+      super
+    end
+
+    alias _to_s to_s
+
+    def to_s
+      #s = super
+      s = _to_s()
+      return "*** assertion error: #{s}"
+    end
+
+  end
+
+
+  ##
+  ## assertion error class
+  ##
+  class UnreachableError < AssertionError
+
+    def to_s
+      s = _to_s()
+      return "*** unreachable error: #{s}"
+    end
+
+  end
+
+
+  module_function
+
+
+  ##
+  ## raise AssertionError if condition is false
+  ##
+  ## ex.
+  ##   assert s && !s.empty?, "s=#{s.inspect}"
+  ##
+  def assert(condition, message='')
+    _raise_error(AssertionError, message, caller()) unless condition
+  end
+
+
+  ##
+  ## raise AssertionError
+  ##
+  ## ex.
+  ##   assert! "s=#{s.inspect}" unless s && !s.empty?
+  ##
+  def assert! (message='')
+    _raise_error(AssertionError, message, caller())
+  end
+
+
+  ##
+  ## raise UnreachableError
+  ##
+  ## ex.
+  ##   case value
+  ##   when true
+  ##     ...
+  ##   when false
+  ##     ...
+  ##   else
+  ##     unreachable
+  ##   end
+  ##
+  def unreachable(message='')
+    _raise_error(UnreachableError, message, caller())
+  end
+
+
+  private
+
+
+  def _raise_error(error_class, message, caller_obj)
+    error = error_class.new(message)
+    error.set_backtrace(caller_obj)
+    raise error
+  end
+
+
+end
+
+
+if $0 == __FILE__
+  include Assertion
+  case ARGV.shift
+  when 'assert'      ;  assert false, ARGV.join(' ')
+  when 'unreachable' ;  unreachable ARGV.join(' ')
+  else               ;  assert! ARGV.join(' ')
+  end
+end