go-on-rails 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43f78729f6b807de4949b5bfff9f06dde9854808
-  data.tar.gz: 40b116bfcb24d9e7a3d378827adc6734ce3fa673
+  metadata.gz: 70e8dc6ab9f83a091e415e3024b7b23aebe413eb
+  data.tar.gz: a489ffa6df65afdbff314b2c61429007fcb2c886
 SHA512:
-  metadata.gz: 5ab347d8b5206dbd0ddd711dbe696ce39f56bf61b5ff8d3d37b31d48edc93931beecc10587f73754a69219008078fb804016adddf6f584e746f658185207311d
-  data.tar.gz: c095725253a77157d9e19b4327d55ea72f3874243a703fec2ac88b42e5e7225bcf06821dfe9ecd79fbb9983e39b404928157d4f1bc560d725d05585baf066f9f
+  metadata.gz: f3112295d0c589078b792d7938786a5c2b25a02965d525821e53072ef42849222c88f49cff51b3afa9fa1928c6907ed369d10d94367fee72253b11b64bcba51c
+  data.tar.gz: 2b5b01368af6cb2aa0f37191865e9325e3a36407fbc2e7ffe1645cdff0c1bd9e58e5affc7a4af1503280e8614cc89274a81dd648f71686ee792dd13cb370a45e

data/README.md

@@ -5,6 +5,8 @@
 go-on-rails
 ====
 
+[中文文档](./README_zh.md)
+
 go-on-rails is a Rails generator created for three scenarios:
 
 1. Integrate some APIs written in Golang to existed Rails app for high performance
@@ -107,12 +109,12 @@ And the gem is still under development, so there're a lot of known issues.
 
 ## Golang dependencies by default
 
-* `github.com/jmoiron/sqlx`: an extension on the standard `database/sql` database API library
-* `github.com/mattn/go-sqlite3`: a SQLite driver
-* `github.com/go-sql-driver/mysql`: a MySQL driver
-* `github.com/lib/pq`: a PostgreSQL driver
-* `github.com/asaskevich/govalidator`: for the struct validation
-* `gopkg.in/gin-gonic/gin.v1`: a HTTP web framework
+* [github.com/jmoiron/sqlx](https://github.com/jmoiron/sqlx): an extension on the standard `database/sql` database API library
+* [github.com/mattn/go-sqlite3](https://github.com/mattn/go-sqlite3): a SQLite driver
+* [github.com/go-sql-driver/mysql](https://github.com/go-sql-driver/mysql): a MySQL driver
+* [github.com/lib/pq](https://github.com/lib/pq): a PostgreSQL driver
+* [github.com/asaskevich/govalidator](https://github.com/asaskevich/govalidator): for the struct validation
+* [github.com/gin-gonic/gin](https://github.com/gin-gonic/gin): a HTTP web framework
 
 ## Acknowledgement
 

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

@@ -1,5 +1,7 @@
-<%- param_name_plural = table_name = @model_name.underscore.pluralize -%>
-<%- model_name_underscore = @model_name.underscore -%>
+<%#- var_pmn stands for pluralized model name, its format is same as the table name -#%>
+<%- var_pmn = table_name = @model_name.underscore.pluralize -%>
+<%#- var_umn stands for underscored model name -#%>
+<%- var_umn = @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? -%>
 // Package models includes the functions on the model <%= @model_name %>.
@@ -41,7 +43,7 @@ type <%= @model_name %>Page struct {
 	orderStr    string
 }
 
-// Current get the current page of <%= @model_name %>Page object for pagination
+// Current() get the current page of <%= @model_name %>Page object for pagination
 func (_p *<%= @model_name %>Page) Current() ([]<%= @model_name %>, error) {
 	if _, exist := _p.Order["id"]; !exist {
 		return nil, errors.New("No id order specified in Order map")
@@ -61,17 +63,17 @@ func (_p *<%= @model_name %>Page) Current() ([]<%= @model_name %>, error) {
 <% end %>
 	whereParams := []interface{}{}
 	whereParams = append(append(whereParams, _p.WhereParams...), idParams...)
-	<%= param_name_plural %>, err := Find<%= @model_name.pluralize %>Where(whereStr, whereParams...)
+	<%= var_pmn %>, err := Find<%= @model_name.pluralize %>Where(whereStr, whereParams...)
 	if err != nil {
 		return nil, err
 	}
-	if len(<%= param_name_plural %>) != 0 {
-		_p.FirstId, _p.LastId = <%= param_name_plural %>[0].Id, <%= param_name_plural %>[len(<%= param_name_plural %>)-1].Id
+	if len(<%= var_pmn %>) != 0 {
+		_p.FirstId, _p.LastId = <%= var_pmn %>[0].Id, <%= var_pmn %>[len(<%= var_pmn %>)-1].Id
 	}
-	return <%= param_name_plural %>, nil
+	return <%= var_pmn %>, nil
 }
 
-// Current get the previous page of <%= @model_name %>Page object for pagination
+// Previous() get the previous page of <%= @model_name %>Page object for pagination
 func (_p *<%= @model_name %>Page) Previous() ([]<%= @model_name %>, error) {
 	if _p.PageNum == 0 {
 		return nil, errors.New("This's the first page, no previous page yet")
@@ -94,18 +96,18 @@ func (_p *<%= @model_name %>Page) Previous() ([]<%= @model_name %>, error) {
 <% end %>
 	whereParams := []interface{}{}
 	whereParams = append(append(whereParams, _p.WhereParams...), idParams...)
-	<%= param_name_plural %>, err := Find<%= @model_name.pluralize %>Where(whereStr, whereParams...)
+	<%= var_pmn %>, err := Find<%= @model_name.pluralize %>Where(whereStr, whereParams...)
 	if err != nil {
 		return nil, err
 	}
-	if len(<%= param_name_plural %>) != 0 {
-		_p.FirstId, _p.LastId = <%= param_name_plural %>[0].Id, <%= param_name_plural %>[len(<%= param_name_plural %>)-1].Id
+	if len(<%= var_pmn %>) != 0 {
+		_p.FirstId, _p.LastId = <%= var_pmn %>[0].Id, <%= var_pmn %>[len(<%= var_pmn %>)-1].Id
 	}
 	_p.PageNum -= 1
-	return <%= param_name_plural %>, nil
+	return <%= var_pmn %>, nil
 }
 
-// Current get the next page of <%= @model_name %>Page object for pagination
+// Next() get the next page of <%= @model_name %>Page object for pagination
 func (_p *<%= @model_name %>Page) Next() ([]<%= @model_name %>, error) {
 	if _p.PageNum == _p.TotalPages-1 {
 		return nil, errors.New("This's the last page, no next page yet")
@@ -128,15 +130,31 @@ func (_p *<%= @model_name %>Page) Next() ([]<%= @model_name %>, error) {
 <% end %>
 	whereParams := []interface{}{}
 	whereParams = append(append(whereParams, _p.WhereParams...), idParams...)
-	<%= param_name_plural %>, err := Find<%= @model_name.pluralize %>Where(whereStr, whereParams...)
+	<%= var_pmn %>, err := Find<%= @model_name.pluralize %>Where(whereStr, whereParams...)
 	if err != nil {
 		return nil, err
 	}
-	if len(<%= param_name_plural %>) != 0 {
-		_p.FirstId, _p.LastId = <%= param_name_plural %>[0].Id, <%= param_name_plural %>[len(<%= param_name_plural %>)-1].Id
+	if len(<%= var_pmn %>) != 0 {
+		_p.FirstId, _p.LastId = <%= var_pmn %>[0].Id, <%= var_pmn %>[len(<%= var_pmn %>)-1].Id
 	}
 	_p.PageNum += 1
-	return <%= param_name_plural %>, nil
+	return <%= var_pmn %>, nil
+}
+
+// GetPage() is a helper function for the <%= @model_name %>Page object to return a corresponding page due to
+// the parameter passed in, one of "previous, current or next"
+func (_p *<%= @model_name %>Page) GetPage(direction string) (ps []<%= @model_name %>, err error) {
+	switch direction {
+	case "previous":
+		ps, _ = _p.Previous()
+	case "next":
+		ps, _ = _p.Next()
+	case "current":
+		ps, _ = _p.Current()
+	default:
+		return nil, errors.New("Error: wrong dircetion! None of previous, current or next!")
+	}
+	return
 }
 
 // buildOrder is for <%= @model_name %>Page object to build SQL ORDER clause
@@ -204,121 +222,121 @@ func (_p *<%= @model_name %>Page) buildPageCount() error {
 }
 
 
-// Find<%= @model_name %> find a single <%= model_name_underscore %> by an ID
+// Find<%= @model_name %> find a single <%= var_umn %> by an ID
 func Find<%= @model_name %>(id int64) (*<%= @model_name %>, error) {
 	if id == 0 {
 		return nil, errors.New("Invalid ID: it can't be zero")
 	}
-	_<%= model_name_underscore %> := <%= @model_name %>{}
-	err := DB.Get(&_<%= model_name_underscore %>, DB.Rebind(`SELECT * FROM <%= table_name %> WHERE id = ? LIMIT 1`), id)
+	_<%= var_umn %> := <%= @model_name %>{}
+	err := DB.Get(&_<%= var_umn %>, DB.Rebind(`SELECT * FROM <%= table_name %> WHERE id = ? LIMIT 1`), id)
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return &_<%= model_name_underscore %>, nil
+	return &_<%= var_umn %>, nil
 }
 
-// First<%= @model_name %> find the first one <%= model_name_underscore %> by ID ASC order
+// First<%= @model_name %> find the first one <%= var_umn %> by ID ASC order
 func First<%= @model_name %>() (*<%= @model_name %>, error) {
-	_<%= model_name_underscore %> := <%= @model_name %>{}
-	err := DB.Get(&_<%= model_name_underscore %>, DB.Rebind(`SELECT * FROM <%= table_name %> ORDER BY id ASC LIMIT 1`))
+	_<%= var_umn %> := <%= @model_name %>{}
+	err := DB.Get(&_<%= var_umn %>, 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 &_<%= model_name_underscore %>, nil
+	return &_<%= var_umn %>, nil
 }
 
-// First<%= @model_name.pluralize %> find the first N <%= model_name_underscore.pluralize %> by ID ASC order
+// First<%= @model_name.pluralize %> find the first N <%= var_umn.pluralize %> by ID ASC order
 func First<%= @model_name.pluralize %>(n uint32) ([]<%= @model_name %>, error) {
-	_<%= param_name_plural %> := []<%= @model_name %>{}
+	_<%= var_pmn %> := []<%= @model_name %>{}
 	sql := fmt.Sprintf("SELECT * FROM <%= table_name %> ORDER BY id ASC LIMIT %v", n)
-	err := DB.Select(&_<%= param_name_plural %>, DB.Rebind(sql))
+	err := DB.Select(&_<%= var_pmn %>, DB.Rebind(sql))
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return _<%= param_name_plural %>, nil
+	return _<%= var_pmn %>, nil
 }
 
-// Last<%= @model_name %> find the last one <%= model_name_underscore %> by ID DESC order
+// Last<%= @model_name %> find the last one <%= var_umn %> by ID DESC order
 func Last<%= @model_name %>() (*<%= @model_name %>, error) {
-	_<%= model_name_underscore %> := <%= @model_name %>{}
-	err := DB.Get(&_<%= model_name_underscore %>, DB.Rebind(`SELECT * FROM <%= table_name %> ORDER BY id DESC LIMIT 1`))
+	_<%= var_umn %> := <%= @model_name %>{}
+	err := DB.Get(&_<%= var_umn %>, 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 &_<%= model_name_underscore %>, nil
+	return &_<%= var_umn %>, nil
 }
 
-// Last<%= @model_name.pluralize %> find the last N <%= model_name_underscore.pluralize %> by ID DESC order
+// Last<%= @model_name.pluralize %> find the last N <%= var_umn.pluralize %> by ID DESC order
 func Last<%= @model_name.pluralize %>(n uint32) ([]<%= @model_name %>, error) {
-	_<%= param_name_plural %> := []<%= @model_name %>{}
+	_<%= var_pmn %> := []<%= @model_name %>{}
 	sql := fmt.Sprintf("SELECT * FROM <%= table_name %> ORDER BY id DESC LIMIT %v", n)
-	err := DB.Select(&_<%= param_name_plural %>, DB.Rebind(sql))
+	err := DB.Select(&_<%= var_pmn %>, DB.Rebind(sql))
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return _<%= param_name_plural %>, nil
+	return _<%= var_pmn %>, nil
 }
 
-// Find<%= @model_name.pluralize %> find one or more <%= model_name_underscore.pluralize %> by the given ID(s)
+// Find<%= @model_name.pluralize %> find one or more <%= var_umn.pluralize %> by the given ID(s)
 func Find<%= @model_name.pluralize %>(ids ...int64) ([]<%= @model_name %>, error) {
 	if len(ids) == 0 {
 		msg := "At least one or more ids needed"
 		log.Println(msg)
 		return nil, errors.New(msg)
 	}
-	_<%= param_name_plural %> := []<%= @model_name %>{}
+	_<%= var_pmn %> := []<%= @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(&_<%= param_name_plural %>, sql, idsT...)
+	err := DB.Select(&_<%= var_pmn %>, sql, idsT...)
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return _<%= param_name_plural %>, nil
+	return _<%= var_pmn %>, nil
 }
 
-// Find<%= @model_name %>By find a single <%= model_name_underscore %> by a field name and a value
+// Find<%= @model_name %>By find a single <%= var_umn %> by a field name and a value
 func Find<%= @model_name %>By(field string, val interface{}) (*<%= @model_name %>, error) {
-	_<%= model_name_underscore %> := <%= @model_name %>{}
+	_<%= var_umn %> := <%= @model_name %>{}
 	sqlFmt := `SELECT * FROM <%= table_name %> WHERE %s = ? LIMIT 1`
 	sqlStr := fmt.Sprintf(sqlFmt, field)
-	err := DB.Get(&_<%= model_name_underscore %>, DB.Rebind(sqlStr), val)
+	err := DB.Get(&_<%= var_umn %>, DB.Rebind(sqlStr), val)
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return &_<%= model_name_underscore %>, nil
+	return &_<%= var_umn %>, 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{}) (_<%= param_name_plural %> []<%= @model_name %>, err error) {
+// Find<%= @model_name.pluralize %>By find all <%= var_pmn %> by a field name and a value
+func Find<%= @model_name.pluralize %>By(field string, val interface{}) (_<%= var_pmn %> []<%= @model_name %>, err error) {
 	sqlFmt := `SELECT * FROM <%= table_name %> WHERE %s = ?`
 	sqlStr := fmt.Sprintf(sqlFmt, field)
-	err = DB.Select(&_<%= param_name_plural %>, DB.Rebind(sqlStr), val)
+	err = DB.Select(&_<%= var_pmn %>, DB.Rebind(sqlStr), val)
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
 	}
-	return _<%= param_name_plural %>, nil
+	return _<%= var_pmn %>, nil
 }
 
 // All<%= @model_name.pluralize %> get all the <%= @model_name %> records
-func All<%= @model_name.pluralize %>() (<%= param_name_plural %> []<%= @model_name %>, err error) {
-	err = DB.Select(&<%= param_name_plural %>, "SELECT * FROM <%= table_name %>")
+func All<%= @model_name.pluralize %>() (<%= var_pmn %> []<%= @model_name %>, err error) {
+	err = DB.Select(&<%= var_pmn %>, "SELECT * FROM <%= table_name %>")
 	if err != nil {
 		log.Println(err)
 		return nil, err
 	}
-	return <%= param_name_plural %>, nil
+	return <%= var_pmn %>, nil
 }
 
 // <%= @model_name %>Count get the count of all the <%= @model_name %> records
@@ -351,21 +369,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{}) (_<%= param_name_plural %> []<%= @model_name %>, err error) {
-	_<%= param_name_plural %>, err = Find<%= @model_name.pluralize %>Where(sql, args...)
+func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interface{}) (_<%= var_pmn %> []<%= @model_name %>, err error) {
+	_<%= var_pmn %>, 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 _<%= param_name_plural %>, err
+		return _<%= var_pmn %>, err
 	}
-	if len(_<%= param_name_plural %>) <= 0 {
+	if len(_<%= var_pmn %>) <= 0 {
 		return nil, errors.New("No results available")
 	}
-	ids := make([]interface{}, len(_<%= param_name_plural %>))
-	for _, v := range _<%= param_name_plural %> {
+	ids := make([]interface{}, len(_<%= var_pmn %>))
+	for _, v := range _<%= var_pmn %> {
 		ids = append(ids, interface{}(v.Id))
 	}
 	<%- if has_assoc -%>
@@ -378,19 +396,19 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 				case "<%= k.underscore.pluralize %>":
 				    <%- if v[:through] || v[:as] -%>
 						// FIXME: optimize the query
-						for i, vvv := range  _<%= param_name_plural %> {
+						for i, vvv := range  _<%= var_pmn %> {
 							_<%= k.underscore.pluralize %>, err := <%= @model_name %>Get<%= k.pluralize %>(vvv.Id)
 							if err != nil {
 								continue
 							}
 							vvv.<%= k %> = _<%= k.underscore.pluralize %>
-						    _<%= param_name_plural %>[i] = vvv
+						    _<%= var_pmn %>[i] = vvv
 						}
 					<%- else -%>
 						<%- if v[:foreign_key] -%>
 							where := fmt.Sprintf("<%= v[:foreign_key] %> IN (?%s)", idsHolder)
 						<%- else -%>
-							where := fmt.Sprintf("<%= model_name_underscore %>_id IN (?%s)", idsHolder)
+							where := fmt.Sprintf("<%= var_umn %>_id IN (?%s)", idsHolder)
 						<%- end -%>
 						_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>Where(where, ids...)
 						if err != nil {
@@ -398,7 +416,7 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 							continue
 						}
 						for _, vv := range _<%= v[:class_name].underscore.pluralize %> {
-							for i, vvv := range  _<%= param_name_plural %> {
+							for i, vvv := range  _<%= var_pmn %> {
 								<%- if v[:foreign_key] -%>
 									if vv.<%= v[:foreign_key].to_s.camelize %> == vvv.Id {
 										vvv.<%= k %> = append(vvv.<%= k %>, vv)
@@ -408,7 +426,7 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 										vvv.<%= k %> = append(vvv.<%= k %>, vv)
 									}
 								<%- end -%>
-								_<%= param_name_plural %>[i].<%= k %> = vvv.<%= k %>
+								_<%= var_pmn %>[i].<%= k %> = vvv.<%= k %>
 						    }
 					    }
 				    <%- end -%>
@@ -421,7 +439,7 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 					<%- if v[:foreign_key] -%>
 						where := fmt.Sprintf("<%= v[:foreign_key] %> IN (?%s)", idsHolder)
 					<%- else -%>
-						where := fmt.Sprintf("<%= model_name_underscore %>_id IN (?%s)", idsHolder)
+						where := fmt.Sprintf("<%= var_umn %>_id IN (?%s)", idsHolder)
 					<%- end -%>
 					_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>Where(where, ids...)
 					if err != nil {
@@ -429,7 +447,7 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 						continue
 					}
 					for _, vv := range _<%= v[:class_name].underscore.pluralize %> {
-						for i, vvv := range  _<%= param_name_plural %> {
+						for i, vvv := range  _<%= var_pmn %> {
 							<%- if v[:foreign_key] -%>
 								if vv.<%= v[:foreign_key].to_s.camelize %> == vvv.Id {
 									vvv.<%= k %> = vv
@@ -439,7 +457,7 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 									vvv.<%= k %> = vv
 								}
 							<%- end -%>
-							_<%= param_name_plural %>[i].<%= k %> = vvv.<%= k %>
+							_<%= var_pmn %>[i].<%= k %> = vvv.<%= k %>
 						}
 					}
 				<%- end -%>
@@ -447,7 +465,7 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 		}
 	}
 	<%- end -%>
-	return _<%= param_name_plural %>, nil
+	return _<%= var_pmn %>, nil
 }
 
 // <%= @model_name %>Ids get all the IDs of <%= @model_name %> records
@@ -507,7 +525,7 @@ func <%= @model_name %>StrCol(col, where string, args ...interface{}) (strColRec
 // Find<%= @model_name.pluralize %>Where query use a partial SQL clause that usually following after WHERE
 // with placeholders, eg: FindUsersWhere("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 %>Where(where string, args ...interface{}) (<%= param_name_plural %> []<%= @model_name %>, err error) {
+func Find<%= @model_name.pluralize %>Where(where string, args ...interface{}) (<%= var_pmn %> []<%= @model_name %>, err error) {
 	sql := "SELECT * FROM <%= table_name %>"
 	if len(where) > 0 {
 		sql = sql + " WHERE " + where
@@ -517,12 +535,12 @@ func Find<%= @model_name.pluralize %>Where(where string, args ...interface{}) (<
 		log.Println(err)
 		return nil, err
 	}
-	err = stmt.Select(&<%= param_name_plural %>, args...)
+	err = stmt.Select(&<%= var_pmn %>, args...)
 	if err != nil {
 		log.Println(err)
 		return nil, err
 	}
-	return <%= param_name_plural %>, nil
+	return <%= var_pmn %>, nil
 }
 
 // Find<%= @model_name %>BySql query use a complete SQL clause
@@ -534,30 +552,30 @@ func Find<%= @model_name %>BySql(sql string, args ...interface{}) (*<%= @model_n
 		log.Println(err)
 		return nil, err
 	}
-	_<%= model_name_underscore %> := &<%= @model_name %>{}
-	err = stmt.Get(_<%= model_name_underscore %>, args...)
+	_<%= var_umn %> := &<%= @model_name %>{}
+	err = stmt.Get(_<%= var_umn %>, args...)
 	if err != nil {
 		log.Println(err)
 		return nil, err
 	}
-	return _<%= model_name_underscore %>, nil
+	return _<%= var_umn %>, 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)
 // 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{}) (<%= var_pmn %> []<%= @model_name %>, err error) {
 	stmt, err := DB.Preparex(DB.Rebind(sql))
 	if err != nil {
 		log.Println(err)
 		return nil, err
 	}
-	err = stmt.Select(&<%= param_name_plural %>, args...)
+	err = stmt.Select(&<%= var_pmn %>, args...)
 	if err != nil {
 		log.Println(err)
 		return nil, err
 	}
-	return <%= param_name_plural %>, nil
+	return <%= var_pmn %>, nil
 }
 
 // Create<%= @model_name %> use a named params to create a single <%= @model_name %> record.
@@ -596,8 +614,8 @@ func Create<%= @model_name %>(am map[string]interface{}) (int64, error) {
 }
 
 // Create is a method for <%= @model_name %> to create a record
-func (_<%= model_name_underscore %> *<%= @model_name %>) Create() (int64, error) {
-	ok, err := govalidator.ValidateStruct(_<%= model_name_underscore %>)
+func (_<%= var_umn %> *<%= @model_name %>) Create() (int64, error) {
+	ok, err := govalidator.ValidateStruct(_<%= var_umn %>)
 	if !ok {
 		errMsg := "Validate <%= @model_name %> struct error: Unknown error"
 		if err != nil {
@@ -609,11 +627,11 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) Create() (int64, error)
 <%- unless @struct_info[:timestamp_cols].empty? -%>
 	t := time.Now()
 	<%- @struct_info[:timestamp_cols].each do |c| -%>
-	_<%= model_name_underscore %>.<%= c.camelize %> = t
+	_<%= var_umn %>.<%= c.camelize %> = t
     <%- end -%>
 <%- end -%>
     sql := `INSERT INTO <%= table_name %> (<%= col_names.join(",") %>) VALUES (:<%= col_names.join(",:") %>)`
-    result, err := DB.NamedExec(sql, _<%= model_name_underscore %>)
+    result, err := DB.NamedExec(sql, _<%= var_umn %>)
 	if err != nil {
 		log.Println(err)
 		return 0, err
@@ -630,23 +648,23 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) Create() (int64, error)
 	<%- has_many = @struct_info[:assoc_info][:has_many] -%>
 	<%- has_many.each do |k, v| -%>
 // <%= k.pluralize %>Create is used for <%= @model_name %> to create the associated objects <%= k.pluralize %>
-func (_<%= model_name_underscore %> *<%= @model_name %>) <%= k.pluralize %>Create(am map[string]interface{}) error {
+func (_<%= var_umn %> *<%= @model_name %>) <%= k.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)
 		if err != nil {
 			return err
 		}
-		_, 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})
+		_, err = Create<%= v[:through].to_s.singularize.camelize %>(map[string]interface{}{"<%= var_umn %>_id": _<%= var_umn %>.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] %>_id"] = _<%= var_umn %>.Id
 		am["<%= v[:as] %>_type"] = "<%= @model_name %>"
 		_, err := Create<%= v[:class_name] %>(am)
 	<%- else -%>
 		<%- if v[:foreign_key] -%>
-			am["<%= v[:foreign_key] %>"] = _<%= model_name_underscore %>.Id
+			am["<%= v[:foreign_key] %>"] = _<%= var_umn %>.Id
 		<%- else -%>
-			am["<%= model_name_underscore %>_id"] = _<%= model_name_underscore %>.Id
+			am["<%= var_umn %>_id"] = _<%= var_umn %>.Id
 		<%- end -%>
 		_, err := Create<%= v[:class_name] %>(am)
 	<%- end -%>
@@ -654,12 +672,12 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) <%= k.pluralize %>Creat
 }
 
 // Get<%= k.pluralize %> is used for <%= @model_name %> to get associated objects <%= k.pluralize %>
-// Say you have a <%= @model_name %> object named <%= model_name_underscore %>, when you call <%= model_name_underscore %>.Get<%= k.pluralize %>(),
+// Say you have a <%= @model_name %> object named <%= var_umn %>, when you call <%= var_umn %>.Get<%= k.pluralize %>(),
 // the object will get the associated <%= k.pluralize %> attributes evaluated in the struct
-func (_<%= model_name_underscore %> *<%= @model_name %>) Get<%= k.pluralize %>() error {
-	_<%= k.underscore.pluralize %>, err := <%= @model_name %>Get<%= k.pluralize %>(_<%= model_name_underscore %>.Id)
+func (_<%= var_umn %> *<%= @model_name %>) Get<%= k.pluralize %>() error {
+	_<%= k.underscore.pluralize %>, err := <%= @model_name %>Get<%= k.pluralize %>(_<%= var_umn %>.Id)
 	if err == nil {
-		_<%= model_name_underscore %>.<%= k %> = _<%= k.underscore.pluralize %>
+		_<%= var_umn %>.<%= k %> = _<%= k.underscore.pluralize %>
     }
     return err
 }
@@ -674,7 +692,7 @@ func <%= @model_name %>Get<%= k.pluralize %>(id int64) ([]<%= v[:class_name] %>,
 		        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 = ?`
+		        WHERE <%= through_table %>.<%= var_umn %>_id = ?`
 		_<%= k.underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>BySql(sql, id)
 	<%- elsif v[:as] -%>
 		where := `<%= v[:as] %>_type = "<%= @model_name %>" AND <%= v[:as] %>_id = ?`
@@ -683,7 +701,7 @@ func <%= @model_name %>Get<%= k.pluralize %>(id int64) ([]<%= v[:class_name] %>,
 		<%- if v[:foreign_key] -%>
 			_<%= k.underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>By("<%= v[:foreign_key] %>", id)
 		<%- else -%>
-			_<%= k.underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>By("<%= model_name_underscore %>_id", id)
+			_<%= k.underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>By("<%= var_umn %>_id", id)
 		<%- end -%>
 	<%- end -%>
 	return _<%= k.underscore.pluralize %>, err
@@ -696,11 +714,11 @@ func <%= @model_name %>Get<%= k.pluralize %>(id int64) ([]<%= v[:class_name] %>,
 	<%- has_one = @struct_info[:assoc_info][:has_one] -%>
 	<%- has_one.each do |k, v| -%>
 // Create<%= k %> is a method for the <%= @model_name %> model object to create an associated <%= k %> record
-func (_<%= model_name_underscore %> *<%= @model_name %>) Create<%= k %>(am map[string]interface{}) error {
+func (_<%= var_umn %> *<%= @model_name %>) Create<%= k %>(am map[string]interface{}) error {
 	<%- if v[:foreign_key] -%>
-	am["<%= v[:foreign_key] %>"] = _<%= model_name_underscore %>.Id
+	am["<%= v[:foreign_key] %>"] = _<%= var_umn %>.Id
     <%- else -%>
-	am["<%= model_name_underscore %>_id"] = _<%= model_name_underscore %>.Id
+	am["<%= var_umn %>_id"] = _<%= var_umn %>.Id
 	<%- end -%>
 	_, err := Create<%= v[:class_name] %>(am)
 	return err
@@ -714,11 +732,11 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) Create<%= k %>(am map[s
     <%-# don't create virtual table for polymorphic model -%>
 	<%- next if v[:polymorphic] -%>
 // Create<%= k %> is a method for a <%= @model_name %> object to create an associated <%= k %> record
-func (_<%= model_name_underscore %> *<%= @model_name %>) Create<%= k %>(am map[string]interface{}) error {
+func (_<%= var_umn %> *<%= @model_name %>) Create<%= k %>(am map[string]interface{}) error {
 	<%- if v[:foreign_key] -%>
-	am["<%= v[:foreign_key] %>"] = _<%= model_name_underscore %>.Id
+	am["<%= v[:foreign_key] %>"] = _<%= var_umn %>.Id
     <%- else -%>
-	am["<%= model_name_underscore %>_id"] = _<%= model_name_underscore %>.Id
+	am["<%= var_umn %>_id"] = _<%= var_umn %>.Id
 	<%- end -%>
 	_, err := Create<%= v[:class_name] %>(am)
 	return err
@@ -727,11 +745,11 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) Create<%= k %>(am map[s
 <%- end -%>
 
 // Destroy is method used for a <%= @model_name %> object to be destroyed.
-func (_<%= model_name_underscore %> *<%= @model_name %>) Destroy() error {
-	if _<%= model_name_underscore %>.Id == 0 {
+func (_<%= var_umn %> *<%= @model_name %>) Destroy() error {
+	if _<%= var_umn %>.Id == 0 {
 		return errors.New("Invalid Id field: it can't be a zero value")
 	}
-	err := Destroy<%= @model_name %>(_<%= model_name_underscore %>.Id)
+	err := Destroy<%= @model_name %>(_<%= var_umn %>.Id)
 	return err
 }
 
@@ -833,12 +851,12 @@ func destroy<%= @model_name %>Associations(ids ...int64) {
 					<%- case opts[:dependent] -%>
 					<%- when :destroy, :delete_all -%>
 						<%- if opts[:through] -%>
-							where := fmt.Sprintf("id IN (SELECT id FROM <%= opts[:through].to_s %> WHERE <%= model_name_underscore %>_id IN (?%s))", idsHolder)
+							where := fmt.Sprintf("id IN (SELECT id FROM <%= opts[:through].to_s %> WHERE <%= var_umn %>_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)
 							}
-							where = fmt.Sprintf("<%= model_name_underscore %>_id IN (?%s)", idsHolder)
+							where = fmt.Sprintf("<%= var_umn %>_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)
@@ -853,7 +871,7 @@ func destroy<%= @model_name %>Associations(ids ...int64) {
 							<%- if opts.key? :foreign_key -%>
 								where := fmt.Sprintf("<%= opts[:foreign_key] %> IN (?%s)", idsHolder)
 							<%- else -%>
-								where := fmt.Sprintf("<%= model_name_underscore %>_id IN (?%s)", idsHolder)
+								where := fmt.Sprintf("<%= var_umn %>_id IN (?%s)", idsHolder)
 							<%- end -%>
 							_, err = Destroy<%= opts[:class_name].pluralize %>Where(where, idsT...)
 							if err != nil {
@@ -872,7 +890,7 @@ func destroy<%= @model_name %>Associations(ids ...int64) {
 							<%- if opts.key? :foreign_key -%>
 								sql := fmt.Sprintf("UPDATE <%= opts[:class_name].underscore.pluralize %> SET <%= opts[:foreign_key] %> = 0 WHERE <%= opts[:foreign_key] %> IN (?%s)", idsHolder)
 							<%- else -%>
-								sql := fmt.Sprintf("UPDATE <%= opts[:class_name].underscore.pluralize %> SET <%= model_name_underscore %>_id = 0 WHERE <%= model_name_underscore %>_id IN (?%s)", idsHolder)
+								sql := fmt.Sprintf("UPDATE <%= opts[:class_name].underscore.pluralize %> SET <%= var_umn %>_id = 0 WHERE <%= var_umn %>_id IN (?%s)", idsHolder)
 							<%- end -%>
 							_, err = Update<%= opts[:class_name].pluralize %>BySql(sql, idsT...)
 							if err != nil {
@@ -889,8 +907,8 @@ func destroy<%= @model_name %>Associations(ids ...int64) {
 
 // Save method is used for a <%= @model_name %> object to update an existed record mainly.
 // If no id provided a new record will be created. A UPSERT action will be implemented further.
-func (_<%= model_name_underscore %> *<%= @model_name %>) Save() error {
-	ok, err := govalidator.ValidateStruct(_<%= model_name_underscore %>)
+func (_<%= var_umn %> *<%= @model_name %>) Save() error {
+	ok, err := govalidator.ValidateStruct(_<%= var_umn %>)
 	if !ok {
 		errMsg := "Validate <%= @model_name %> struct error: Unknown error"
 		if err != nil {
@@ -899,17 +917,17 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) Save() error {
 		log.Println(errMsg)
 		return errors.New(errMsg)
 	}
-	if _<%= model_name_underscore %>.Id == 0 {
-		_, err = _<%= model_name_underscore %>.Create()
+	if _<%= var_umn %>.Id == 0 {
+		_, err = _<%= var_umn %>.Create()
 		return err
 	}
 <%- if @struct_info[:timestamp_cols].include? "updated_at" -%>
-	_<%= model_name_underscore %>.UpdatedAt = time.Now()
+	_<%= var_umn %>.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(", ") %>", _<%= model_name_underscore %>.Id)
-    _, err = DB.NamedExec(sqlStr, _<%= model_name_underscore %>)
+	sqlStr := fmt.Sprintf(sqlFmt, "<%= save_col_names.zip(save_col_names).map{|c| c.join(" = :")}.join(", ") %>", _<%= var_umn %>.Id)
+    _, err = DB.NamedExec(sqlStr, _<%= var_umn %>)
     return err
 }
 
@@ -943,29 +961,29 @@ func Update<%= @model_name %>(id int64, am map[string]interface{}) error {
 }
 
 // Update is a method used to update a <%= @model_name %> record with the map[string]interface{} typed key-value parameters.
-func (_<%= model_name_underscore %> *<%= @model_name %>) Update(am map[string]interface{}) error {
-	if _<%= model_name_underscore %>.Id == 0 {
+func (_<%= var_umn %> *<%= @model_name %>) Update(am map[string]interface{}) error {
+	if _<%= var_umn %>.Id == 0 {
 		return errors.New("Invalid Id field: it can't be a zero value")
 	}
-	err := Update<%= @model_name %>(_<%= model_name_underscore %>.Id, am)
+	err := Update<%= @model_name %>(_<%= var_umn %>.Id, am)
 	return err
 }
 
 // UpdateAttributes method is supposed to be used to update <%= @model_name %> records as corresponding update_attributes in Ruby on Rails.
-func (_<%= model_name_underscore %> *<%= @model_name %>) UpdateAttributes(am map[string]interface{}) error {
-	if _<%= model_name_underscore %>.Id == 0 {
+func (_<%= var_umn %> *<%= @model_name %>) UpdateAttributes(am map[string]interface{}) error {
+	if _<%= var_umn %>.Id == 0 {
 		return errors.New("Invalid Id field: it can't be a zero value")
 	}
-	err := Update<%= @model_name %>(_<%= model_name_underscore %>.Id, am)
+	err := Update<%= @model_name %>(_<%= var_umn %>.Id, am)
 	return err
 }
 
 // UpdateColumns method is supposed to be used to update <%= @model_name %> records as corresponding update_columns in Ruby on Rails.
-func (_<%= model_name_underscore %> *<%= @model_name %>) UpdateColumns(am map[string]interface{}) error {
-	if _<%= model_name_underscore %>.Id == 0 {
+func (_<%= var_umn %> *<%= @model_name %>) UpdateColumns(am map[string]interface{}) error {
+	if _<%= var_umn %>.Id == 0 {
 		return errors.New("Invalid Id field: it can't be a zero value")
 	}
-	err := Update<%= @model_name %>(_<%= model_name_underscore %>.Id, am)
+	err := Update<%= @model_name %>(_<%= var_umn %>.Id, am)
 	return err
 }
 

data/lib/generators/gor/templates/main.go

@@ -4,7 +4,7 @@ import (
 	"flag"
 
 	c "./controllers"
-	"gopkg.in/gin-gonic/gin.v1"
+	"github.com/gin-gonic/gin"
 )
 
 func main() {

data/lib/tasks/gor.rake

@@ -4,7 +4,7 @@ namespace :gor do
     puts 'Beginning to install Go deps...'
     system "go get \
     github.com/jmoiron/sqlx \
-    gopkg.in/gin-gonic/gin.v1 \
+    github.com/gin-gonic/gin \
     github.com/mattn/go-sqlite3 \
     github.com/go-sql-driver/mysql \
     github.com/lib/pq \

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: go-on-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - B1nj0y
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-18 00:00:00.000000000 Z
+date: 2017-10-05 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
@@ -57,5 +57,5 @@ rubyforge_project:
 rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: Use Rails generator to Generate a Golang application
+summary: Use Rails to Develop or Generate a Golang application
 test_files: []