go-on-rails 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98efb6c9f89545a36de83af4b3a972af42dcdab3
-  data.tar.gz: 15f4301f4f7030325d8e9e29140b31308118e75d
+  metadata.gz: 116d71d0238292ffc07cf20ac48510629db81d0a
+  data.tar.gz: 2cc31cd05ad5b3683b1f3f8fbe5c8545c9ebbe25
 SHA512:
-  metadata.gz: f3827a7e075ce518bfc57a595174d8b2d6a68372c5f8b093d45b67fae06ad7ab46b20a8e6aa2f10a2a4879da1d62b2fe4312d20dc507060c2bef5c28807770a7
-  data.tar.gz: 65b16cacd2909f45a721903be8e51676043c365840db2c82c6a1e44dd18ed85a991827c8fcb1fdf9a31810ca99746ff0068c5037e7f8df9e535b15fa0cbef3b4
+  metadata.gz: 831ea5814ff101e6f6db2aad38accb6c63c9cc9177390a77edbc1fb396b8ff6696f975387a8f722d29f4452091dff4de019b3f768e69ee7561bb1556f81135f8
+  data.tar.gz: 11ab127f3ff002f793dd8cb3bc11a96926a36c96bc95c1413ac1e83efafdb561df9f0401236e312774e0b5b19639dd51e7d1181564b0e4bb7b49b50957c1fb68

data/README.md

@@ -21,7 +21,7 @@ Here's a simple [example(tutorial)](https://github.com/goonr/example_simple) sho
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'go-on-rails', '~> 0.1.0'
+gem 'go-on-rails', '~> 0.1.1'
 ```
 
 And then execute:
@@ -76,15 +76,22 @@ And the gem is still under development, so there're a lot of known issues.
 
 ## Known issues and TODOs
 
-* the generated Golang codes includes the association between models, basic relations like has_many, has_one, belongs_to have been supported
-* so some association functions is available
-* and the :dependent action is triggered when destroying some related model
-* some validation like presense, length restriction and format are supported
-* databases specific functions between mysql, postgres are not covered yet
-* model callbacks are not available
+* databases specific functions between MySQL, Postgres are not covered yet
 * sql.NullType not supported yet, so you'd better in the migrations set those columns "not null" with a default value that's consistent with Golang's zero value specification, such as "" default for string and text typed column, and 0 default for int, etc.
 
-Really a lot...
+- [x] Associations
+  - [x] has_many
+  - [x] has_one
+  - [x] belongs_to
+  - [x] dependent
+- [x] Validations
+  - [x] length
+  - [x] presence
+  - [x] format(string only)
+  - [x] numericality(partially)
+  - [ ] other validations
+- [ ] Callbacks
+- [ ] Transactions
 
 ## Golang dependencies by default
 

data/lib/generators/gor/go-on-rails/association.rb

@@ -1,12 +1,10 @@
 module GoOnRails
   class Association
-    def initialize(klass, models, max_col_size, max_type_size)
+    def initialize(klass, models)
       @klass = klass
       @models = models
-      @max_col_size = max_col_size
-      @max_type_size = max_type_size
     end
-    attr_reader :klass, :models, :max_col_size, :max_type_size
+    attr_reader :klass, :models
 
     def get_schema_info
       info = {struct_body: "", has_assoc_dependent: false, assoc_info: {has_many: {}, has_one: {}, belongs_to: {}}}
@@ -32,8 +30,7 @@ module GoOnRails
         end
         info[:has_assoc_dependent] = true if assoc.options.key? :dependent
         if col_name && type_name && (self.models.include? class_name)
-          format = "\t%-#{max_col_size}.#{max_col_size+2}s%-#{max_type_size}.#{max_type_size}s`%s`\n"
-          info[:struct_body] << sprintf(format, col_name, type_name, tags.join(" "))
+          info[:struct_body] << sprintf("%s %s `%s`\n", col_name, type_name, tags.join(" "))
         end
       end
       info

data/lib/generators/gor/go-on-rails/converter.rb

@@ -14,13 +14,11 @@ module GoOnRails
       "date"       => "time.Time"
     }
 
-    def initialize(klass, models, option = {})
+    def initialize(klass, models)
       @klass = klass
       @models = models
-      @max_col_size = 0
-      @max_type_size = 0
     end
-    attr_accessor :klass, :models, :max_col_size, :max_type_size
+    attr_accessor :klass, :models
 
     def convert
       get_schema_info
@@ -31,8 +29,6 @@ module GoOnRails
     def get_schema_info
       struct_info = {col_names: [], timestamp_cols: [], has_datetime_type: false, struct_body: ""}
 
-      self.max_col_size = get_max_col_size
-      self.max_type_size = get_max_type_size
       validation = GoOnRails::Validator.new(self.klass)
 
       self.klass.columns.each_with_index do |col, index|
@@ -55,9 +51,8 @@ module GoOnRails
           type = TYPE_MAP[col_type] || "string"
         end
 
-        format = (index == 0 ? "" : "\t") + "%-#{self.max_col_size}.#{self.max_col_size}s%-#{self.max_type_size}.#{self.max_type_size}s`%s`\n"
         struct_info[:col_names] << col.name unless col.name == "id"
-        struct_info[:struct_body] << sprintf(format, col.name.camelize, type, tags.join(" "))
+        struct_info[:struct_body] << sprintf("%s %s `%s`\n", col.name.camelize, type, tags.join(" "))
       end
 
       assoc = get_associations
@@ -67,25 +62,12 @@ module GoOnRails
       return struct_info
     end
 
-    def get_max_col_size
-      col_name_max_size = self.klass.column_names.collect{|name| name.size}.max || 0
-      assoc_max_size = self.klass.reflect_on_all_associations.collect{|assoc| assoc.name.to_s.size}.max || 0
-      type_max_size = TYPE_MAP.collect{|key, value| key.size}.max || 0
-      [col_name_max_size + 1, assoc_max_size, type_max_size].max
-    end
-
-    def get_max_type_size
-      assoc_max_size = self.klass.reflect_on_all_associations.collect{|assoc| assoc.name.to_s.size + 2}.max || 0
-      type_max_size = TYPE_MAP.collect{|key, value| key.size}.max || 0
-      [assoc_max_size, type_max_size].max
-    end
-
     def get_struct_name
       self.klass.table_name.camelize
     end
 
     def get_associations
-      builder = GoOnRails::Association.new(self.klass, self.models, self.max_col_size, self.max_type_size)
+      builder = GoOnRails::Association.new(self.klass, self.models)
       builder.get_schema_info
     end
 

data/lib/generators/gor/templates/db.go.erb

@@ -1,4 +1,4 @@
-package model
+package models
 
 import (
 	"log"

data/lib/generators/gor/templates/gor_model.go.erb

@@ -2,11 +2,11 @@
 <%- model_name_underscore = @model_name.underscore -%>
 <%- col_names = @struct_info[:col_names] -%>
 <%- has_assoc = !@struct_info[:assoc_info][:has_many].empty? || !@struct_info[:assoc_info][:has_one].empty? -%>
-// The file is generated by go-on-rails, a Rails generator gem:
+// Package models is generated by go-on-rails, a Rails generator gem:
 // https://rubygems.org/gems/go-on-rails
 // Or on Github: https://github.com/goonr/go-on-rails
 // By B1nj0y <idegorepl@gmail.com>
-package model
+package models
 
 import (
 	"errors"
@@ -29,59 +29,59 @@ func Find<%= @model_name %>(id int64) (*<%= @model_name %>, error) {
 	if id == 0 {
 		return nil, errors.New("Invalid id: it can't be zero")
 	}
-	var_<%= model_name_underscore %> := <%= @model_name %>{}
-	err := db.Get(&var_<%= model_name_underscore %>, db.Rebind(`SELECT * FROM <%= table_name %> WHERE id = ? LIMIT 1`), id)
+	_<%= model_name_underscore %> := <%= @model_name %>{}
+	err := db.Get(&_<%= model_name_underscore %>, db.Rebind(`SELECT * FROM <%= table_name %> WHERE id = ? LIMIT 1`), id)
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return &var_<%= model_name_underscore %>, nil
+	return &_<%= model_name_underscore %>, nil
 }
 
 // First<%= @model_name %> find the first one <%= model_name_underscore %> by id ASC order
 func First<%= @model_name %>() (*<%= @model_name %>, error) {
-	var_<%= model_name_underscore %> := <%= @model_name %>{}
-	err := db.Get(&var_<%= model_name_underscore %>, db.Rebind(`SELECT * FROM <%= table_name %> ORDER BY id ASC LIMIT 1`))
+	_<%= model_name_underscore %> := <%= @model_name %>{}
+	err := db.Get(&_<%= model_name_underscore %>, db.Rebind(`SELECT * FROM <%= table_name %> ORDER BY id ASC LIMIT 1`))
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return &var_<%= model_name_underscore %>, nil
+	return &_<%= model_name_underscore %>, nil
 }
 
 // First<%= @model_name.pluralize %> find the first N <%= model_name_underscore.pluralize %> by id ASC order
 func First<%= @model_name.pluralize %>(n uint32) ([]<%= @model_name %>, error) {
-	var_<%= param_name_plural %> := []<%= @model_name %>{}
+	_<%= param_name_plural %> := []<%= @model_name %>{}
 	sql := fmt.Sprintf("SELECT * FROM <%= table_name %> ORDER BY id ASC LIMIT %v", n)
-	err := db.Select(&var_<%= param_name_plural %>, db.Rebind(sql))
+	err := db.Select(&_<%= param_name_plural %>, db.Rebind(sql))
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return var_<%= param_name_plural %>, nil
+	return _<%= param_name_plural %>, nil
 }
 
 // Last<%= @model_name %> find the last one <%= model_name_underscore %> by id DESC order
 func Last<%= @model_name %>() (*<%= @model_name %>, error) {
-	var_<%= model_name_underscore %> := <%= @model_name %>{}
-	err := db.Get(&var_<%= model_name_underscore %>, db.Rebind(`SELECT * FROM <%= table_name %> ORDER BY id DESC LIMIT 1`))
+	_<%= model_name_underscore %> := <%= @model_name %>{}
+	err := db.Get(&_<%= model_name_underscore %>, db.Rebind(`SELECT * FROM <%= table_name %> ORDER BY id DESC LIMIT 1`))
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return &var_<%= model_name_underscore %>, nil
+	return &_<%= model_name_underscore %>, nil
 }
 
 // Last<%= @model_name.pluralize %> find the last N <%= model_name_underscore.pluralize %> by id DESC order
 func Last<%= @model_name.pluralize %>(n uint32) ([]<%= @model_name %>, error) {
-	var_<%= param_name_plural %> := []<%= @model_name %>{}
+	_<%= param_name_plural %> := []<%= @model_name %>{}
 	sql := fmt.Sprintf("SELECT * FROM <%= table_name %> ORDER BY id DESC LIMIT %v", n)
-	err := db.Select(&var_<%= param_name_plural %>, db.Rebind(sql))
+	err := db.Select(&_<%= param_name_plural %>, db.Rebind(sql))
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return var_<%= param_name_plural %>, nil
+	return _<%= param_name_plural %>, nil
 }
 
 // Find<%= @model_name.pluralize %> find one or more <%= model_name_underscore.pluralize %> by one or more ids
@@ -91,44 +91,44 @@ func Find<%= @model_name.pluralize %>(ids ...int64) ([]<%= @model_name %>, error
 		log.Println(msg)
 		return nil, errors.New(msg)
 	}
-	var_<%= param_name_plural %> := []<%= @model_name %>{}
+	_<%= param_name_plural %> := []<%= @model_name %>{}
 	idsHolder := strings.Repeat(",?", len(ids)-1)
 	sql := db.Rebind(fmt.Sprintf(`SELECT * FROM <%= table_name %> WHERE id IN (?%s)`, idsHolder))
 	idsT := []interface{}{}
 	for _,id := range ids {
 		idsT = append(idsT, interface{}(id))
 	}
-	err := db.Select(&var_<%= param_name_plural %>, sql, idsT...)
+	err := db.Select(&_<%= param_name_plural %>, sql, idsT...)
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return var_<%= param_name_plural %>, nil
+	return _<%= param_name_plural %>, nil
 }
 
 // Find<%= @model_name %>By find a single <%= model_name_underscore %> by a field name and a value
 func Find<%= @model_name %>By(field string, val interface{}) (*<%= @model_name %>, error) {
-	var_<%= model_name_underscore %> := <%= @model_name %>{}
+	_<%= model_name_underscore %> := <%= @model_name %>{}
 	sqlFmt := `SELECT * FROM <%= table_name %> WHERE %s = ? LIMIT 1`
 	sqlStr := fmt.Sprintf(sqlFmt, field)
-	err := db.Get(&var_<%= model_name_underscore %>, db.Rebind(sqlStr), val)
+	err := db.Get(&_<%= model_name_underscore %>, db.Rebind(sqlStr), val)
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return &var_<%= model_name_underscore %>, nil
+	return &_<%= model_name_underscore %>, nil
 }
 
 // Find<%= @model_name.pluralize %>By find all <%= param_name_plural %> by a field name and a value
-func Find<%= @model_name.pluralize %>By(field string, val interface{}) (var_<%= param_name_plural %> []<%= @model_name %>, err error) {
+func Find<%= @model_name.pluralize %>By(field string, val interface{}) (_<%= param_name_plural %> []<%= @model_name %>, err error) {
 	sqlFmt := `SELECT * FROM <%= table_name %> WHERE %s = ?`
 	sqlStr := fmt.Sprintf(sqlFmt, field)
-	err = db.Select(&var_<%= param_name_plural %>, db.Rebind(sqlStr), val)
+	err = db.Select(&_<%= param_name_plural %>, db.Rebind(sqlStr), val)
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return var_<%= param_name_plural %>, nil
+	return _<%= param_name_plural %>, nil
 }
 
 // All<%= @model_name.pluralize %> get all the <%= @model_name %> records
@@ -171,21 +171,21 @@ func <%= @model_name %>CountWhere(where string, args ...interface{}) (c int64, e
 }
 
 // <%= @model_name %>IncludesWhere get the <%= @model_name %> associated models records, it's just the eager_load function
-func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interface{}) (var_<%= param_name_plural %> []<%= @model_name %>, err error) {
-	var_<%= param_name_plural %>, err = Find<%= @model_name.pluralize %>Where(sql, args...)
+func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interface{}) (_<%= param_name_plural %> []<%= @model_name %>, err error) {
+	_<%= param_name_plural %>, err = Find<%= @model_name.pluralize %>Where(sql, args...)
 	if err != nil {
 		log.Println(err)
 		return nil, err
 	}
 	if len(assocs) == 0 {
 		log.Println("No associated fields ard specified")
-		return var_<%= param_name_plural %>, err
+		return _<%= param_name_plural %>, err
 	}
-	if len(var_<%= param_name_plural %>) <= 0 {
+	if len(_<%= param_name_plural %>) <= 0 {
 		return nil, errors.New("No results available")
 	}
-	ids := make([]interface{}, len(var_<%= param_name_plural %>))
-	for _, v := range var_<%= param_name_plural %> {
+	ids := make([]interface{}, len(_<%= param_name_plural %>))
+	for _, v := range _<%= param_name_plural %> {
 		ids = append(ids, interface{}(v.Id))
 	}
 	<%- if has_assoc -%>
@@ -196,15 +196,15 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 				<%- has_many = @struct_info[:assoc_info][:has_many] -%>
 				<%- has_many.each do |k, v| -%>
 				case "<%= k.underscore.pluralize %>":
-				    <%- if v[:through] -%>
+				    <%- if v[:through] || v[:as] -%>
 						// FIXME: optimize the query
-						for i, vvv := range  var_<%= param_name_plural %> {
-							var_<%= v[:class_name].underscore.pluralize %>, err := <%= @model_name %>Get<%= v[:class_name].pluralize %>(vvv.Id)
+						for i, vvv := range  _<%= param_name_plural %> {
+							_<%= v[:class_name].underscore.pluralize %>, err := <%= @model_name %>Get<%= v[:class_name].pluralize %>(vvv.Id)
 							if err != nil {
 								continue
 							}
-							vvv.<%= k %> = var_<%= v[:class_name].underscore.pluralize %>
-						    var_<%= param_name_plural %>[i] = vvv
+							vvv.<%= k %> = _<%= v[:class_name].underscore.pluralize %>
+						    _<%= param_name_plural %>[i] = vvv
 						}
 					<%- else -%>
 						<%- if v[:foreign_key] -%>
@@ -212,13 +212,13 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 						<%- else -%>
 							where := fmt.Sprintf("<%= model_name_underscore %>_id IN (?%s)", idsHolder)
 						<%- end -%>
-						var_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>Where(where, ids...)
+						_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>Where(where, ids...)
 						if err != nil {
 							log.Printf("Error when query associated objects: %v\n", assoc)
 							continue
 						}
-						for _, vv := range var_<%= v[:class_name].underscore.pluralize %> {
-							for i, vvv := range  var_<%= param_name_plural %> {
+						for _, vv := range _<%= v[:class_name].underscore.pluralize %> {
+							for i, vvv := range  _<%= param_name_plural %> {
 								<%- if v[:foreign_key] -%>
 									if vv.<%= v[:foreign_key].camelize %> == vvv.Id {
 										vvv.<%= k %> = append(vvv.<%= k %>, vv)
@@ -228,7 +228,7 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 										vvv.<%= k %> = append(vvv.<%= k %>, vv)
 									}
 								<%- end -%>
-								var_<%= param_name_plural %>[i].<%= k %> = vvv.<%= k %>
+								_<%= param_name_plural %>[i].<%= k %> = vvv.<%= k %>
 						    }
 					    }
 				    <%- end -%>
@@ -243,13 +243,13 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 					<%- else -%>
 						where := fmt.Sprintf("<%= model_name_underscore %>_id IN (?%s)", idsHolder)
 					<%- end -%>
-					var_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>Where(where, ids...)
+					_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>Where(where, ids...)
 					if err != nil {
 						log.Printf("Error when query associated objects: %v\n", assoc)
 						continue
 					}
-					for _, vv := range var_<%= v[:class_name].underscore.pluralize %> {
-						for i, vvv := range  var_<%= param_name_plural %> {
+					for _, vv := range _<%= v[:class_name].underscore.pluralize %> {
+						for i, vvv := range  _<%= param_name_plural %> {
 							<%- if v[:foreign_key] -%>
 								if vv.<%= v[:foreign_key].camelize %> == vvv.Id {
 									vvv.<%= k %> = vv
@@ -259,7 +259,7 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 									vvv.<%= k %> = vv
 								}
 							<%- end -%>
-							var_<%= param_name_plural %>[i].<%= k %> = vvv.<%= k %>
+							_<%= param_name_plural %>[i].<%= k %> = vvv.<%= k %>
 						}
 					}
 				<%- end -%>
@@ -267,7 +267,7 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 		}
 	}
 	<%- end -%>
-	return var_<%= param_name_plural %>, nil
+	return _<%= param_name_plural %>, nil
 }
 
 // <%= @model_name %>Ids get all the Ids of <%= @model_name %> records
@@ -280,7 +280,7 @@ func <%= @model_name %>Ids() (ids []int64, err error) {
 	return ids, nil
 }
 
-// <%= @model_name %>Ids get all the Ids of <%= @model_name %> records by where restriction
+// <%= @model_name %>IdsWhere get all the Ids of <%= @model_name %> records by where restriction
 func <%= @model_name %>IdsWhere(where string, args ...interface{}) ([]int64, error) {
 	ids, err := <%= @model_name %>IntCol("id", where, args...)
 	return ids, err
@@ -345,10 +345,10 @@ func Find<%= @model_name.pluralize %>Where(where string, args ...interface{}) (<
 	return <%= param_name_plural %>, nil
 }
 
-// Find<%= @model_name.pluralize %>BySql query use a complete SQL clause
-// with placeholders, eg: FindUsersBySql("SELECT * FROM users WHERE first_name = ? AND age > ?", "John", 18)
+// Find<%= @model_name.pluralize %>BySQL query use a complete SQL clause
+// with placeholders, eg: FindUsersBySQL("SELECT * FROM users WHERE first_name = ? AND age > ?", "John", 18)
 // will return those records in the table "users" whose first_name is "John" and age elder than 18
-func Find<%= @model_name.pluralize %>BySql(sql string, args ...interface{}) (<%= param_name_plural %> []<%= @model_name %>, err error) {
+func Find<%= @model_name.pluralize %>BySQL(sql string, args ...interface{}) (<%= param_name_plural %> []<%= @model_name %>, err error) {
 	stmt, err := db.Preparex(db.Rebind(sql))
 	if err != nil {
 		log.Println(err)
@@ -395,8 +395,8 @@ func Create<%= @model_name %>(am map[string]interface{}) (int64, error) {
 	return lastId, nil
 }
 
-func (var_<%= model_name_underscore %> *<%= @model_name %>) Create() (int64, error) {
-	ok, err := govalidator.ValidateStruct(var_<%= model_name_underscore %>)
+func (_<%= model_name_underscore %> *<%= @model_name %>) Create() (int64, error) {
+	ok, err := govalidator.ValidateStruct(_<%= model_name_underscore %>)
 	if !ok {
 		errMsg := "Validate <%= @model_name %> struct error: Unknown error"
 		if err != nil {
@@ -408,11 +408,11 @@ func (var_<%= model_name_underscore %> *<%= @model_name %>) Create() (int64, err
 <%- unless @struct_info[:timestamp_cols].empty? -%>
 	t := time.Now()
 	<%- @struct_info[:timestamp_cols].each do |c| -%>
-	var_<%= model_name_underscore %>.<%= c.camelize %> = t
+	_<%= model_name_underscore %>.<%= c.camelize %> = t
     <%- end -%>
 <%- end -%>
     sql := `INSERT INTO <%= table_name %> (<%= col_names.join(",") %>) VALUES (:<%= col_names.join(",:") %>)`
-    result, err := db.NamedExec(sql, var_<%= model_name_underscore %>)
+    result, err := db.NamedExec(sql, _<%= model_name_underscore %>)
 	if err != nil {
 		log.Println(err)
 		return 0, err
@@ -428,48 +428,62 @@ func (var_<%= model_name_underscore %> *<%= @model_name %>) Create() (int64, err
 <%- unless @struct_info[:assoc_info][:has_many].empty? -%>
 	<%- has_many = @struct_info[:assoc_info][:has_many] -%>
 	<%- has_many.each do |k, v| -%>
-func (var_<%= model_name_underscore %> *<%= @model_name %>) <%= v[:class_name].pluralize %>Create(am map[string]interface{}) error {
+// <%= v[:class_name].pluralize %>Create used to create the associated objects
+func (_<%= model_name_underscore %> *<%= @model_name %>) <%= v[:class_name].pluralize %>Create(am map[string]interface{}) error {
 	<%- if v[:through] -%>
 		// FIXME: use transaction to create these associated objects
-		<%= v[:class_name].underscore %>_id, err := Create<%= v[:class_name] %>(am)
+		<%= v[:class_name].underscore %>Id, err := Create<%= v[:class_name] %>(am)
 		if err != nil {
 			return err
 		}
-		_, err = Create<%= v[:through].to_s.singularize.camelize %>(map[string]interface{}{"<%= model_name_underscore %>_id": var_<%= model_name_underscore %>.Id, "<%= v[:class_name].underscore %>_id": <%= v[:class_name].underscore %>_id})
+		_, err = Create<%= v[:through].to_s.singularize.camelize %>(map[string]interface{}{"<%= model_name_underscore %>_id": _<%= model_name_underscore %>.Id, "<%= v[:class_name].underscore %>_id": <%= v[:class_name].underscore %>Id})
+	<%- elsif v[:as] -%>
+		am["<%= v[:as] %>_id"] = _<%= model_name_underscore %>.Id
+		am["<%= v[:as] %>_type"] = "<%= @model_name %>"
+		_, err := Create<%= v[:class_name] %>(am)
 	<%- else -%>
 		<%- if v[:foreign_key] -%>
-			am["<%= v[:foreign_key] %>"] = var_<%= model_name_underscore %>.Id
+			am["<%= v[:foreign_key] %>"] = _<%= model_name_underscore %>.Id
 		<%- else -%>
-			am["<%= model_name_underscore %>_id"] = var_<%= model_name_underscore %>.Id
+			am["<%= model_name_underscore %>_id"] = _<%= model_name_underscore %>.Id
 		<%- end -%>
 		_, err := Create<%= v[:class_name] %>(am)
 	<%- end -%>
 	return err
 }
 
-func (var_<%= model_name_underscore %> *<%= @model_name %>) Get<%= v[:class_name].pluralize %>() error {
-	var_<%= v[:class_name].underscore.pluralize %>, err := <%= @model_name %>Get<%= v[:class_name].pluralize %>(var_<%= model_name_underscore %>.Id)
+// Get<%= v[:class_name].pluralize %> used to get associated objects
+func (_<%= model_name_underscore %> *<%= @model_name %>) Get<%= v[:class_name].pluralize %>() error {
+	_<%= v[:class_name].underscore.pluralize %>, err := <%= @model_name %>Get<%= v[:class_name].pluralize %>(_<%= model_name_underscore %>.Id)
 	if err == nil {
-		var_<%= model_name_underscore %>.<%= k %> = var_<%= v[:class_name].underscore.pluralize %>
+		_<%= model_name_underscore %>.<%= k %> = _<%= v[:class_name].underscore.pluralize %>
     }
     return err
 }
 
+// <%= @model_name %>Get<%= v[:class_name].pluralize %> a helper fuction used to get associated objects for <%= @model_name %>IncludesWhere()
 func <%= @model_name %>Get<%= v[:class_name].pluralize %>(id int64) ([]<%= v[:class_name] %>, error) {
 	<%- if v[:through] -%>
 		// FIXME: use transaction to create these associated objects
 		<%- target_table = v[:class_name].underscore.pluralize -%>
 		<%- through_table = v[:through].to_s.pluralize -%>
-		sql := "SELECT `<%= target_table %>`.* FROM `<%= target_table %>` INNER JOIN `<%= through_table %>` ON `<%= target_table %>`.`id` = `<%= through_table %>`.`<%= v[:class_name].underscore %>_id` WHERE `<%= through_table %>`.`<%= model_name_underscore %>_id` = ?"
-		var_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>BySql(sql, id)
+		sql := `SELECT <%= target_table %>.*
+		        FROM   <%= target_table %>
+		               INNER JOIN <%= through_table %>
+		                       ON <%= target_table %>.id = <%= through_table %>.<%= v[:class_name].underscore %>_id
+		        WHERE <%= through_table %>.<%= model_name_underscore %>_id = ?`
+		_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>BySQL(sql, id)
+	<%- elsif v[:as] -%>
+		where := `<%= v[:as] %>_type = "<%= @model_name %>" AND <%= v[:as] %>_id = ?`
+		_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>Where(where, id)
 	<%- else -%>
 		<%- if v[:foreign_key] -%>
-			var_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>By("<%= v[:foreign_key] %>", id)
+			_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>By("<%= v[:foreign_key] %>", id)
 		<%- else -%>
-			var_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>By("<%= model_name_underscore %>_id", id)
+			_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>By("<%= model_name_underscore %>_id", id)
 		<%- end -%>
 	<%- end -%>
-	return var_<%= v[:class_name].underscore.pluralize %>, err
+	return _<%= v[:class_name].underscore.pluralize %>, err
 }
 
 	<%- end -%>
@@ -478,11 +492,11 @@ func <%= @model_name %>Get<%= v[:class_name].pluralize %>(id int64) ([]<%= v[:cl
 <%- unless @struct_info[:assoc_info][:has_one].empty? -%>
 	<%- has_one = @struct_info[:assoc_info][:has_one] -%>
 	<%- has_one.each do |k, v| -%>
-func (var_<%= model_name_underscore %> *<%= @model_name %>) Create<%= v[:class_name] %>(am map[string]interface{}) error {
+func (_<%= model_name_underscore %> *<%= @model_name %>) Create<%= v[:class_name] %>(am map[string]interface{}) error {
 	<%- if v[:foreign_key] -%>
-	am["<%= v[:foreign_key] %>"] = var_<%= model_name_underscore %>.Id
+	am["<%= v[:foreign_key] %>"] = _<%= model_name_underscore %>.Id
     <%- else -%>
-	am["<%= model_name_underscore %>_id"] = var_<%= model_name_underscore %>.Id
+	am["<%= model_name_underscore %>_id"] = _<%= model_name_underscore %>.Id
 	<%- end -%>
 	_, err := Create<%= v[:class_name] %>(am)
 	return err
@@ -493,11 +507,13 @@ func (var_<%= model_name_underscore %> *<%= @model_name %>) Create<%= v[:class_n
 <%- unless @struct_info[:assoc_info][:belongs_to].empty? -%>
 	<%- belongs_to = @struct_info[:assoc_info][:belongs_to] -%>
 	<%- belongs_to.each do |k, v| -%>
-func (var_<%= model_name_underscore %> *<%= @model_name %>) Create<%= v[:class_name] %>(am map[string]interface{}) error {
+    <%-# don't create virtual table for polymorphic model -%>
+	<%- next if v[:polymorphic] -%>
+func (_<%= model_name_underscore %> *<%= @model_name %>) Create<%= v[:class_name] %>(am map[string]interface{}) error {
 	<%- if v[:foreign_key] -%>
-	am["<%= v[:foreign_key] %>"] = var_<%= model_name_underscore %>.Id
+	am["<%= v[:foreign_key] %>"] = _<%= model_name_underscore %>.Id
     <%- else -%>
-	am["<%= model_name_underscore %>_id"] = var_<%= model_name_underscore %>.Id
+	am["<%= model_name_underscore %>_id"] = _<%= model_name_underscore %>.Id
 	<%- end -%>
 	_, err := Create<%= v[:class_name] %>(am)
 	return err
@@ -505,11 +521,11 @@ func (var_<%= model_name_underscore %> *<%= @model_name %>) Create<%= v[:class_n
 	<%- end -%>
 <%- end -%>
 
-func (var_<%= model_name_underscore %> *<%= @model_name %>) Destroy() error {
-	if var_<%= model_name_underscore %>.Id == 0 {
+func (_<%= model_name_underscore %> *<%= @model_name %>) Destroy() error {
+	if _<%= model_name_underscore %>.Id == 0 {
 		return errors.New("Invalid Id field: it can't be a zero value")
 	}
-	err := Destroy<%= @model_name %>(var_<%= model_name_underscore %>.Id)
+	err := Destroy<%= @model_name %>(_<%= model_name_underscore %>.Id)
 	return err
 }
 
@@ -608,23 +624,29 @@ func destroy<%= @model_name %>Associations(ids ...int64) {
 					<%- case opts[:dependent] -%>
 					<%- when :destroy, :delete_all -%>
 						<%- if opts[:through] -%>
-							sql := fmt.Sprintf("id IN (SELECT id FROM <%= opts[:through].to_s %> WHERE <%= model_name_underscore %>_id IN (?%s))", idsHolder)
-							_, err = Destroy<%= opts[:class_name].pluralize %>Where(sql, idsT...)
+							where := fmt.Sprintf("id IN (SELECT id FROM <%= opts[:through].to_s %> WHERE <%= model_name_underscore %>_id IN (?%s))", idsHolder)
+							_, err = Destroy<%= opts[:class_name].pluralize %>Where(where, idsT...)
 							if err != nil {
 								log.Printf("Destroy associated object %s error: %v\n", "<%= opts[:class_name].pluralize %>", err)
 							}
-							sql = fmt.Sprintf("<%= model_name_underscore %>_id IN (?%s)", idsHolder)
-							_, err = Destroy<%= opts[:through].to_s.pluralize.camelize %>Where(sql, idsT...)
+							where = fmt.Sprintf("<%= model_name_underscore %>_id IN (?%s)", idsHolder)
+							_, err = Destroy<%= opts[:through].to_s.pluralize.camelize %>Where(where, idsT...)
 							if err != nil {
 								log.Printf("Destroy associated object %s error: %v\n", "<%= opts[:through].to_s.singularize.camelize %>", err)
 							}
+						<%- elsif opts[:as] -%>
+							where := fmt.Sprintf(`<%= opts[:as] %>_type = "<%= @model_name %>" AND <%= opts[:as] %>_id IN (?%s)`, idsHolder)
+							_, err = Destroy<%= opts[:class_name].pluralize %>Where(where, idsT...)
+							if err != nil {
+								log.Printf("Destroy associated object %s error: %v\n", "<%= opts[:class_name].pluralize %>", err)
+							}
 						<%- else -%>
 							<%- if opts.key? :foreign_key -%>
-								sql := fmt.Sprintf("<%= opts[:foreign_key] %> IN (?%s)", idsHolder)
+								where := fmt.Sprintf("<%= opts[:foreign_key] %> IN (?%s)", idsHolder)
 							<%- else -%>
-								sql := fmt.Sprintf("<%= model_name_underscore %>_id IN (?%s)", idsHolder)
+								where := fmt.Sprintf("<%= model_name_underscore %>_id IN (?%s)", idsHolder)
 							<%- end -%>
-							_, err = Destroy<%= opts[:class_name].pluralize %>Where(sql, idsT...)
+							_, err = Destroy<%= opts[:class_name].pluralize %>Where(where, idsT...)
 							if err != nil {
 								log.Printf("Destroy associated object %s error: %v\n", "<%= opts[:class_name].pluralize %>", err)
 							}
@@ -633,7 +655,7 @@ func destroy<%= @model_name %>Associations(ids ...int64) {
 						// no sql.NULLType supported, just set the associated field to zero value of int64
 						<%- if opts[:through] -%>
 							sql := fmt.Sprintf("UPDATE <%= opts[:through].to_s %> SET <%= opts[:class_name].underscore %>_id = 0 WHERE <%= opts[:class_name].underscore %>_id IN (?%s)", idsHolder)
-							_, err = Update<%= opts[:through].to_s.camelize %>BySql(sql, idsT...)
+							_, err = Update<%= opts[:through].to_s.camelize %>BySQL(sql, idsT...)
 							if err != nil {
 								log.Printf("Delete associated object %s error: %v\n", "<%= opts[:class_name].pluralize %>", err)
 							}
@@ -643,7 +665,7 @@ func destroy<%= @model_name %>Associations(ids ...int64) {
 							<%- else -%>
 								sql := fmt.Sprintf("UPDATE <%= opts[:class_name].underscore.pluralize %> SET <%= model_name_underscore %>_id = 0 WHERE <%= model_name_underscore %>_id IN (?%s)", idsHolder)
 							<%- end -%>
-							_, err = Update<%= opts[:class_name].pluralize %>BySql(sql, idsT...)
+							_, err = Update<%= opts[:class_name].pluralize %>BySQL(sql, idsT...)
 							if err != nil {
 								log.Printf("Delete associated object %s error: %v\n", "<%= opts[:class_name].pluralize %>", err)
 							}
@@ -656,8 +678,8 @@ func destroy<%= @model_name %>Associations(ids ...int64) {
 }
 <%- end -%>
 
-func (var_<%= model_name_underscore %> *<%= @model_name %>) Save() error {
-	ok, err := govalidator.ValidateStruct(var_<%= model_name_underscore %>)
+func (_<%= model_name_underscore %> *<%= @model_name %>) Save() error {
+	ok, err := govalidator.ValidateStruct(_<%= model_name_underscore %>)
 	if !ok {
 		errMsg := "Validate <%= @model_name %> struct error: Unknown error"
 		if err != nil {
@@ -666,16 +688,16 @@ func (var_<%= model_name_underscore %> *<%= @model_name %>) Save() error {
 		log.Println(errMsg)
 		return errors.New(errMsg)
 	}
-	if var_<%= model_name_underscore %>.Id == 0 {
+	if _<%= model_name_underscore %>.Id == 0 {
 		return errors.New("Invalid Id field: it can't be a zero value")
 	}
 <%- if @struct_info[:timestamp_cols].include? "updated_at" -%>
-	var_<%= model_name_underscore %>.UpdatedAt = time.Now()
+	_<%= model_name_underscore %>.UpdatedAt = time.Now()
 <%- end -%>
 	sqlFmt := `UPDATE <%= table_name %> SET %s WHERE id = %v`
 	<%- save_col_names = col_names - ["created_at"] -%>
-	sqlStr := fmt.Sprintf(sqlFmt, "<%= save_col_names.zip(save_col_names).map{|c| c.join(" = :")}.join(", ") %>", var_<%= model_name_underscore %>.Id)
-    _, err = db.NamedExec(sqlStr, var_<%= model_name_underscore %>)
+	sqlStr := fmt.Sprintf(sqlFmt, "<%= save_col_names.zip(save_col_names).map{|c| c.join(" = :")}.join(", ") %>", _<%= model_name_underscore %>.Id)
+    _, err = db.NamedExec(sqlStr, _<%= model_name_underscore %>)
     return err
 }
 
@@ -707,31 +729,31 @@ func Update<%= @model_name %>(id int64, am map[string]interface{}) error {
 	return nil
 }
 
-func (var_<%= model_name_underscore %> *<%= @model_name %>) Update(am map[string]interface{}) error {
-	if var_<%= model_name_underscore %>.Id == 0 {
+func (_<%= model_name_underscore %> *<%= @model_name %>) Update(am map[string]interface{}) error {
+	if _<%= model_name_underscore %>.Id == 0 {
 		return errors.New("Invalid Id field: it can't be a zero value")
 	}
-	err := Update<%= @model_name %>(var_<%= model_name_underscore %>.Id, am)
+	err := Update<%= @model_name %>(_<%= model_name_underscore %>.Id, am)
 	return err
 }
 
-func (var_<%= model_name_underscore %> *<%= @model_name %>) UpdateAttributes(am map[string]interface{}) error {
-	if var_<%= model_name_underscore %>.Id == 0 {
+func (_<%= model_name_underscore %> *<%= @model_name %>) UpdateAttributes(am map[string]interface{}) error {
+	if _<%= model_name_underscore %>.Id == 0 {
 		return errors.New("Invalid Id field: it can't be a zero value")
 	}
-	err := Update<%= @model_name %>(var_<%= model_name_underscore %>.Id, am)
+	err := Update<%= @model_name %>(_<%= model_name_underscore %>.Id, am)
 	return err
 }
 
-func (var_<%= model_name_underscore %> *<%= @model_name %>) UpdateColumns(am map[string]interface{}) error {
-	if var_<%= model_name_underscore %>.Id == 0 {
+func (_<%= model_name_underscore %> *<%= @model_name %>) UpdateColumns(am map[string]interface{}) error {
+	if _<%= model_name_underscore %>.Id == 0 {
 		return errors.New("Invalid Id field: it can't be a zero value")
 	}
-	err := Update<%= @model_name %>(var_<%= model_name_underscore %>.Id, am)
+	err := Update<%= @model_name %>(_<%= model_name_underscore %>.Id, am)
 	return err
 }
 
-func Update<%= @model_name.pluralize %>BySql(sql string, args ...interface{}) (int64, error) {
+func Update<%= @model_name.pluralize %>BySQL(sql string, args ...interface{}) (int64, error) {
 	if sql == "" {
 		return 0, errors.New("A blank SQL clause")
 	}

data/lib/tasks/gor.rake

@@ -11,4 +11,9 @@ namespace :gor do
     github.com/asaskevich/govalidator"
     puts 'Installation completed!'
   end
+
+  task :fmt do
+    go_files = Rails.root.join('go_app', 'models/*.go').to_s
+    system "gofmt -w #{go_files} > /dev/null 2>&1"
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: go-on-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - B1nj0y
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-21 00:00:00.000000000 Z
+date: 2017-06-02 00:00:00.000000000 Z
 dependencies: []
 description: Modeling, developing and testing your Golang app with your familiar Rails
   tools like rails generate, db migration, console etc. It is more meant to help integrating