go-on-rails 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d2c69a6ebce31c2804821e2984af576d8a45212
-  data.tar.gz: fcd5211c4a7eb06c15f8fb82ee37cb71f36ade55
+  metadata.gz: 4885ebf7ebb9df3a3c2941dd88966f28384975a1
+  data.tar.gz: 71d6fca3d339378f36105063de928ed2f3620d0a
 SHA512:
-  metadata.gz: 7706dd9487899a009c937f4cc114c197e839ffc8a3f89b115de3f59b3301013030b6950207c796b6c236870f9fdfa13a2ae4360663a6db33d27f0c73c533b93a
-  data.tar.gz: 0b60b8ded7ee6f87c8533c0cae640dcc07cb1724ee24ec98caed7c2f85e8407ed71a35eedbe3db02170598a729b472e2d4a1b8cef12116e830b4b1578fa24662
+  metadata.gz: 86055cbc92c586e8c1764f392f2bc1ca895faee9b3b0933a3c88c87ea58199bdabfd2b24853a55a9b6b46b51f7bb316e470c9d3004cac3d29b344b4f46390154
+  data.tar.gz: a835298ceea075195217320032977be3530b1dad25aa1233f72ba34d33553e64ed581bdaa248f4c692b3d69b2c325730bd6edd81af92339d9afe930f79b8ae27

data/README.md

@@ -1,3 +1,5 @@
+[![Gem Version](https://badge.fury.io/rb/go-on-rails.svg)](https://badge.fury.io/rb/go-on-rails)
+
 <img align="right" width="260" height="260" src="./go-on-rails.png">
 
 go-on-rails
@@ -9,7 +11,7 @@ go-on-rails is a Rails generator created for three scenarios:
 2. Use your farmiliar Rails tools to develope and manage a Golang app project
 3. Convert a *not very complicated* Rails app to Golang equivalent
 
-Here's a simple [example(tutorial)](https://github.com/goonr/example_simple) shows the basic usage of go-on-rails generator, and some real-world examples are coming soon.
+Here's a simple [example(tutorial)](https://github.com/goonr/example_simple) shows the basic usage of go-on-rails generator, and [another example](https://github.com/goonr/example_with_admin) shows how to integrate Go APIs in a Rails project. Some real-world examples are coming soon.
 
 ## Prerequisites
 
@@ -21,7 +23,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.3'
+gem 'go-on-rails', '~> 0.1.4'
 ```
 
 And then execute:

data/lib/generators/gor/gor_generator.rb

@@ -29,6 +29,10 @@ class GorGenerator < Rails::Generators::Base
     puts "Rails env: [#{rails_env}]"
     puts "The models: #{@models} will be converted to a Golang App!"
 
+    # read the database configuration
+    @db_config = {}
+    create_database_config(rails_env)
+
     @models.each do |m|
       begin
         klass = m.split('::').inject(Object) { |kls, part| kls.const_get(part) }
@@ -48,8 +52,6 @@ class GorGenerator < Rails::Generators::Base
       copy_file "main.go", "go_app/main.go"
 
       # generate program for database connection
-      @db_config = {}
-      create_database_config(rails_env)
       template "db.go.erb", "go_app/models/db.go"
 
       # generate the controllers and views dir
@@ -75,6 +77,7 @@ class GorGenerator < Rails::Generators::Base
 
   def create_database_config rails_env
     db_conf = Rails.configuration.database_configuration[rails_env]
+    db_conf["host"] = "localhost" unless db_conf["host"]
     case db_conf["adapter"]
     when "sqlite3"
       @db_config[:driver_name] = "sqlite3"
@@ -82,10 +85,11 @@ class GorGenerator < Rails::Generators::Base
       @db_config[:driver_package] = "_ \"github.com/mattn/go-sqlite3\""
     when "mysql2"
       @db_config[:driver_name] = "mysql"
+      db_conf["port"] = 3306 unless db_conf["port"]
       # MySQL DSN format: username:password@protocol(address)/dbname?param=value
       # See more: https://github.com/go-sql-driver/mysql
-      format = "%s:%s@%s/%s?charset=%s&parseTime=True&loc=Local"
-      @db_config[:dsn] = sprintf(format, *db_conf.values_at("username", "password", "host", "database", "encoding"))
+      format = "%s:%s@tcp(%s:%s)/%s?charset=%s&parseTime=True&loc=Local"
+      @db_config[:dsn] = sprintf(format, *db_conf.values_at("username", "password", "host", "port", "database", "encoding"))
       @db_config[:driver_package] = "_ \"github.com/go-sql-driver/mysql\""
     when "postgresql"
       @db_config[:driver_name] = "postgres"

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

@@ -7,7 +7,7 @@ import (
 	"github.com/jmoiron/sqlx"
 )
 
-var db *sqlx.DB
+var DB *sqlx.DB
 
 func init() {
 	var err error
@@ -19,7 +19,7 @@ func init() {
 	if dsn == "" {
 		log.Fatal("Invalid DSN")
 	}
-	db, err = sqlx.Connect(driver_name, dsn)
+	DB, err = sqlx.Connect(driver_name, dsn)
 	if err != nil {
 		log.Fatal(err)
 	}

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

@@ -9,6 +9,7 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"math"
 	"strings"
 	<%- if @struct_info[:has_datetime_type] -%>
 	"time"
@@ -26,13 +27,187 @@ type <%= @model_name %> struct {
 	<%= @struct_info[:struct_body] -%>
 }
 
-// Find<%= @model_name %> find a single <%= model_name_underscore %> by an id
+// DataStruct for the pagination
+type <%= @model_name %>Page struct {
+	WhereString string
+	WhereParams []interface{}
+	Order       map[string]string
+	FirstId     int64
+	LastId      int64
+	PageNum     int
+	PerPage     int
+	TotalPages  int
+	TotalItems  int64
+	orderStr    string
+}
+
+// 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")
+	}
+	err := _p.buildPageCount()
+	if err != nil {
+		return nil, fmt.Errorf("Calculate page count error: %v", err)
+	}
+	if _p.orderStr == "" {
+		_p.buildOrder()
+	}
+	idStr, idParams := _p.buildIdRestrict("current")
+<% if @db_config[:driver_name] == "postgres" %>
+	whereStr := fmt.Sprintf("%s %s %s FETCH NEXT %v ROWS ONLY", _p.WhereString, idStr, _p.orderStr, _p.PerPage)
+<% else %>
+	whereStr := fmt.Sprintf("%s %s %s LIMIT %v", _p.WhereString, idStr, _p.orderStr, _p.PerPage)
+<% end %>
+	whereParams := []interface{}{}
+	whereParams = append(append(whereParams, _p.WhereParams...), idParams...)
+	<%= param_name_plural %>, 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
+	}
+	return <%= param_name_plural %>, nil
+}
+
+// Current 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")
+	}
+	if _, exist := _p.Order["id"]; !exist {
+		return nil, errors.New("No id order specified in Order map")
+	}
+	err := _p.buildPageCount()
+	if err != nil {
+		return nil, fmt.Errorf("Calculate page count error: %v", err)
+	}
+	if _p.orderStr == "" {
+		_p.buildOrder()
+	}
+	idStr, idParams := _p.buildIdRestrict("previous")
+<% if @db_config[:driver_name] == "postgres" %>
+	whereStr := fmt.Sprintf("%s %s %s FETCH NEXT %v ROWS ONLY", _p.WhereString, idStr, _p.orderStr, _p.PerPage)
+<% else %>
+	whereStr := fmt.Sprintf("%s %s %s LIMIT %v", _p.WhereString, idStr, _p.orderStr, _p.PerPage)
+<% end %>
+	whereParams := []interface{}{}
+	whereParams = append(append(whereParams, _p.WhereParams...), idParams...)
+	<%= param_name_plural %>, 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
+	}
+	_p.PageNum -= 1
+	return <%= param_name_plural %>, nil
+}
+
+// Current 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")
+	}
+	if _, exist := _p.Order["id"]; !exist {
+		return nil, errors.New("No id order specified in Order map")
+	}
+	err := _p.buildPageCount()
+	if err != nil {
+		return nil, fmt.Errorf("Calculate page count error: %v", err)
+	}
+	if _p.orderStr == "" {
+		_p.buildOrder()
+	}
+	idStr, idParams := _p.buildIdRestrict("next")
+<% if @db_config[:driver_name] == "postgres" %>
+	whereStr := fmt.Sprintf("%s %s %s FETCH NEXT %v ROWS ONLY", _p.WhereString, idStr, _p.orderStr, _p.PerPage)
+<% else %>
+	whereStr := fmt.Sprintf("%s %s %s LIMIT %v", _p.WhereString, idStr, _p.orderStr, _p.PerPage)
+<% end %>
+	whereParams := []interface{}{}
+	whereParams = append(append(whereParams, _p.WhereParams...), idParams...)
+	<%= param_name_plural %>, 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
+	}
+	_p.PageNum += 1
+	return <%= param_name_plural %>, nil
+}
+
+// buildOrder is for <%= @model_name %>Page object to build SQL ORDER clause
+func (_p *<%= @model_name %>Page) buildOrder() {
+	tempList := []string{}
+	for k, v := range _p.Order {
+		tempList = append(tempList, fmt.Sprintf("%v %v", k, v))
+	}
+	_p.orderStr = " ORDER BY " + strings.Join(tempList, ", ")
+}
+
+// buildIdRestrict is for <%= @model_name %>Page object to build a SQL clause for ID restriction,
+// implementing a simple keyset style pagination
+func (_p *<%= @model_name %>Page) buildIdRestrict(direction string) (idStr string, idParams []interface{}) {
+	switch direction {
+	case "previous":
+		if strings.ToLower(_p.Order["id"]) == "desc" {
+			idStr += "id > ? "
+			idParams = append(_p.WhereParams, _p.FirstId)
+		} else {
+			idStr += "id < ? "
+			idParams = append(_p.WhereParams, _p.FirstId)
+		}
+	case "current":
+		// trick to make Where function work
+		if _p.PageNum == 0 && _p.FirstId == 0 && _p.LastId == 0 {
+			idStr += "id > ? "
+			idParams = append(_p.WhereParams, 0)
+		} else {
+			if strings.ToLower(_p.Order["id"]) == "desc" {
+				idStr += "id <= ? AND id >= ? "
+				idParams = append(_p.WhereParams, _p.FirstId, _p.LastId)
+			} else {
+				idStr += "id >= ? AND id <= ? "
+				idParams = append(_p.WhereParams, _p.FirstId, _p.LastId)
+			}
+		}
+	case "next":
+		if strings.ToLower(_p.Order["id"]) == "desc" {
+			idStr += "id < ? "
+			idParams = append(_p.WhereParams, _p.LastId)
+		} else {
+			idStr += "id > ? "
+			idParams = append(_p.WhereParams, _p.LastId)
+		}
+	}
+	return
+}
+
+// buildPageCount calculate the TotalItems/TotalPages for the <%= @model_name %>Page object
+func (_p *<%= @model_name %>Page) buildPageCount() error {
+	count, err := <%= @model_name %>CountWhere(_p.WhereString, _p.WhereParams...)
+	if err != nil {
+		return err
+	}
+	_p.TotalItems = count
+	if _p.PerPage == 0 {
+		_p.PerPage = 10
+	}
+	_p.TotalPages = int(math.Ceil(float64(_p.TotalItems) / float64(_p.PerPage)))
+	return nil
+}
+
+
+// Find<%= @model_name %> find a single <%= model_name_underscore %> 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")
+		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)
+	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
@@ -40,10 +215,10 @@ func Find<%= @model_name %>(id int64) (*<%= @model_name %>, error) {
 	return &_<%= model_name_underscore %>, nil
 }
 
-// First<%= @model_name %> find the first one <%= model_name_underscore %> by id ASC order
+// First<%= @model_name %> find the first one <%= model_name_underscore %> 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`))
+	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
@@ -51,11 +226,11 @@ func First<%= @model_name %>() (*<%= @model_name %>, error) {
 	return &_<%= model_name_underscore %>, 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 <%= model_name_underscore.pluralize %> by ID ASC order
 func First<%= @model_name.pluralize %>(n uint32) ([]<%= @model_name %>, error) {
 	_<%= param_name_plural %> := []<%= @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(&_<%= param_name_plural %>, DB.Rebind(sql))
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
@@ -63,10 +238,10 @@ func First<%= @model_name.pluralize %>(n uint32) ([]<%= @model_name %>, error) {
 	return _<%= param_name_plural %>, nil
 }
 
-// Last<%= @model_name %> find the last one <%= model_name_underscore %> by id DESC order
+// Last<%= @model_name %> find the last one <%= model_name_underscore %> 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`))
+	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
@@ -74,11 +249,11 @@ func Last<%= @model_name %>() (*<%= @model_name %>, error) {
 	return &_<%= model_name_underscore %>, 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 <%= model_name_underscore.pluralize %> by ID DESC order
 func Last<%= @model_name.pluralize %>(n uint32) ([]<%= @model_name %>, error) {
 	_<%= param_name_plural %> := []<%= @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(&_<%= param_name_plural %>, DB.Rebind(sql))
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
@@ -86,7 +261,7 @@ func Last<%= @model_name.pluralize %>(n uint32) ([]<%= @model_name %>, error) {
 	return _<%= param_name_plural %>, nil
 }
 
-// Find<%= @model_name.pluralize %> find one or more <%= model_name_underscore.pluralize %> by one or more ids
+// Find<%= @model_name.pluralize %> find one or more <%= model_name_underscore.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"
@@ -95,12 +270,12 @@ func Find<%= @model_name.pluralize %>(ids ...int64) ([]<%= @model_name %>, error
 	}
 	_<%= 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))
+	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(&_<%= param_name_plural %>, sql, idsT...)
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
@@ -113,7 +288,7 @@ func Find<%= @model_name %>By(field string, val interface{}) (*<%= @model_name %
 	_<%= model_name_underscore %> := <%= @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(&_<%= model_name_underscore %>, DB.Rebind(sqlStr), val)
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
@@ -125,7 +300,7 @@ func Find<%= @model_name %>By(field string, val interface{}) (*<%= @model_name %
 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(&_<%= 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
@@ -135,7 +310,7 @@ func Find<%= @model_name.pluralize %>By(field string, val interface{}) (_<%= par
 
 // 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 %>")
+	err = DB.Select(&<%= param_name_plural %>, "SELECT * FROM <%= table_name %>")
 	if err != nil {
 		log.Println(err)
 		return nil, err
@@ -145,7 +320,7 @@ func All<%= @model_name.pluralize %>() (<%= param_name_plural %> []<%= @model_na
 
 // <%= @model_name %>Count get the count of all the <%= @model_name %> records
 func <%= @model_name %>Count() (c int64, err error) {
-	err = db.Get(&c, "SELECT count(*) FROM <%= table_name %>")
+	err = DB.Get(&c, "SELECT count(*) FROM <%= table_name %>")
 	if err != nil {
 		log.Println(err)
 		return 0, err
@@ -159,7 +334,7 @@ func <%= @model_name %>CountWhere(where string, args ...interface{}) (c int64, e
 	if len(where) > 0 {
 		sql = sql + " WHERE " + where
 	}
-	stmt, err := db.Preparex(db.Rebind(sql))
+	stmt, err := DB.Preparex(DB.Rebind(sql))
 	if err != nil {
 		log.Println(err)
 		return 0, err
@@ -272,9 +447,9 @@ func <%= @model_name %>IncludesWhere(assocs []string, sql string, args ...interf
 	return _<%= param_name_plural %>, nil
 }
 
-// <%= @model_name %>Ids get all the Ids of <%= @model_name %> records
+// <%= @model_name %>Ids get all the IDs of <%= @model_name %> records
 func <%= @model_name %>Ids() (ids []int64, err error) {
-	err = db.Select(&ids, "SELECT id FROM <%= table_name %>")
+	err = DB.Select(&ids, "SELECT id FROM <%= table_name %>")
 	if err != nil {
 		log.Println(err)
 		return nil, err
@@ -282,7 +457,7 @@ func <%= @model_name %>Ids() (ids []int64, err error) {
 	return ids, nil
 }
 
-// <%= @model_name %>IdsWhere 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
@@ -294,7 +469,7 @@ func <%= @model_name %>IntCol(col, where string, args ...interface{}) (intColRec
 	if len(where) > 0 {
 		sql = sql + " WHERE " + where
 	}
-	stmt, err := db.Preparex(db.Rebind(sql))
+	stmt, err := DB.Preparex(DB.Rebind(sql))
 	if err != nil {
 		log.Println(err)
 		return nil, err
@@ -313,7 +488,7 @@ func <%= @model_name %>StrCol(col, where string, args ...interface{}) (strColRec
 	if len(where) > 0 {
 		sql = sql + " WHERE " + where
 	}
-	stmt, err := db.Preparex(db.Rebind(sql))
+	stmt, err := DB.Preparex(DB.Rebind(sql))
 	if err != nil {
 		log.Println(err)
 		return nil, err
@@ -334,7 +509,7 @@ func Find<%= @model_name.pluralize %>Where(where string, args ...interface{}) (<
 	if len(where) > 0 {
 		sql = sql + " WHERE " + where
 	}
-	stmt, err := db.Preparex(db.Rebind(sql))
+	stmt, err := DB.Preparex(DB.Rebind(sql))
 	if err != nil {
 		log.Println(err)
 		return nil, err
@@ -351,7 +526,7 @@ func Find<%= @model_name.pluralize %>Where(where string, args ...interface{}) (<
 // with placeholders, eg: FindUserBySql("SELECT * FROM users WHERE first_name = ? AND age > ? ORDER BY DESC LIMIT 1", "John", 18)
 // will return only One record in the table "users" whose first_name is "John" and age elder than 18
 func Find<%= @model_name %>BySql(sql string, args ...interface{}) (*<%= @model_name %>, error) {
-	stmt, err := db.Preparex(db.Rebind(sql))
+	stmt, err := DB.Preparex(DB.Rebind(sql))
 	if err != nil {
 		log.Println(err)
 		return nil, err
@@ -369,7 +544,7 @@ func Find<%= @model_name %>BySql(sql string, args ...interface{}) (*<%= @model_n
 // 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) {
-	stmt, err := db.Preparex(db.Rebind(sql))
+	stmt, err := DB.Preparex(DB.Rebind(sql))
 	if err != nil {
 		log.Println(err)
 		return nil, err
@@ -404,7 +579,7 @@ func Create<%= @model_name %>(am map[string]interface{}) (int64, error) {
 	}
 	sqlFmt := `INSERT INTO <%= table_name %> (%s) VALUES (%s)`
 	sqlStr := fmt.Sprintf(sqlFmt, strings.Join(keys, ","), ":"+strings.Join(keys, ",:"))
-	result, err := db.NamedExec(sqlStr, am)
+	result, err := DB.NamedExec(sqlStr, am)
 	if err != nil {
 		log.Println(err)
 		return 0, err
@@ -435,7 +610,7 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) Create() (int64, error)
     <%- 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, _<%= model_name_underscore %>)
 	if err != nil {
 		log.Println(err)
 		return 0, err
@@ -517,7 +692,7 @@ func <%= @model_name %>Get<%= k.pluralize %>(id int64) ([]<%= v[:class_name] %>,
 <%- unless @struct_info[:assoc_info][:has_one].empty? -%>
 	<%- has_one = @struct_info[:assoc_info][:has_one] -%>
 	<%- has_one.each do |k, v| -%>
-// Create<%= k %> is a method used for <%= @model_name %> model
+// 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 {
 	<%- if v[:foreign_key] -%>
 	am["<%= v[:foreign_key] %>"] = _<%= model_name_underscore %>.Id
@@ -557,14 +732,14 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) Destroy() error {
 	return err
 }
 
-// Destroy<%= @model_name %> will destroy a <%= @model_name %> record specified by id parameter.
+// Destroy<%= @model_name %> will destroy a <%= @model_name %> record specified by the id parameter.
 func Destroy<%= @model_name %>(id int64) error {
 	<%- if @struct_info[:has_assoc_dependent] -%>
 	// Destroy association objects at first
 	// Not care if exec properly temporarily
 	destroy<%= @model_name %>Associations(id)
     <%- end -%>
-	stmt, err := db.Preparex(db.Rebind(`DELETE FROM <%= table_name %> WHERE id = ?`))
+	stmt, err := DB.Preparex(DB.Rebind(`DELETE FROM <%= table_name %> WHERE id = ?`))
 	_, err = stmt.Exec(id)
 	if err != nil {
 		return err
@@ -590,7 +765,7 @@ func Destroy<%= @model_name.pluralize %>(ids ...int64) (int64, error) {
 	for _,id := range ids {
 		idsT = append(idsT, interface{}(id))
 	}
-	stmt, err := db.Preparex(db.Rebind(sql))
+	stmt, err := DB.Preparex(DB.Rebind(sql))
 	result, err := stmt.Exec(idsT...)
 	if err != nil {
 		return 0, err
@@ -602,8 +777,8 @@ func Destroy<%= @model_name.pluralize %>(ids ...int64) (int64, error) {
 	return cnt, nil
 }
 
-// Destroy<%= @model_name.pluralize %>Where delete records by a where clause
-// like: Destroy<%= @model_name.pluralize %>Where("name = ?", "John")
+// Destroy<%= @model_name.pluralize %>Where delete records by a where clause restriction.
+// e.g. Destroy<%= @model_name.pluralize %>Where("name = ?", "John")
 // And this func will not call the association dependent action
 func Destroy<%= @model_name.pluralize %>Where(where string, args ...interface{}) (int64, error) {
 	sql := `DELETE FROM <%= table_name %> WHERE `
@@ -620,7 +795,7 @@ func Destroy<%= @model_name.pluralize %>Where(where string, args ...interface{})
 		destroy<%= @model_name %>Associations(ids...)
 	}
 	<%- end -%>
-	stmt, err := db.Preparex(db.Rebind(sql))
+	stmt, err := DB.Preparex(DB.Rebind(sql))
 	result, err := stmt.Exec(args...)
 	if err != nil {
 		return 0, err
@@ -731,7 +906,7 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) Save() error {
 	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 %>)
+    _, err = DB.NamedExec(sqlStr, _<%= model_name_underscore %>)
     return err
 }
 
@@ -756,7 +931,7 @@ func Update<%= @model_name %>(id int64, am map[string]interface{}) error {
 		setKeysArr = append(setKeysArr, s)
 	}
 	sqlStr := fmt.Sprintf(sqlFmt, strings.Join(setKeysArr, ", "), id)
-	_, err := db.NamedExec(sqlStr, am)
+	_, err := DB.NamedExec(sqlStr, am)
 	if err != nil {
 		log.Println(err)
 		return err
@@ -773,6 +948,7 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) Update(am map[string]in
 	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 {
 		return errors.New("Invalid Id field: it can't be a zero value")
@@ -781,7 +957,7 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) UpdateAttributes(am map
 	return err
 }
 
-// UpdateColumns method is supposed to be used to update <%= @model_name %> records as corresponding update_columns in Rails
+// 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 {
 		return errors.New("Invalid Id field: it can't be a zero value")
@@ -791,7 +967,7 @@ func (_<%= model_name_underscore %> *<%= @model_name %>) UpdateColumns(am map[st
 }
 
 // Update<%= @model_name.pluralize %>BySql is used to update <%= @model_name %> records by a SQL clause
-// that use '?' binding syntax
+// using the '?' binding syntax.
 func Update<%= @model_name.pluralize %>BySql(sql string, args ...interface{}) (int64, error) {
 	if sql == "" {
 		return 0, errors.New("A blank SQL clause")
@@ -800,7 +976,7 @@ func Update<%= @model_name.pluralize %>BySql(sql string, args ...interface{}) (i
 	sql = strings.Replace(strings.ToLower(sql), "set", "set updated_at = ?, ", 1)
 	args = append([]interface{}{time.Now()}, args...)
 <%- end -%>
-	stmt, err := db.Preparex(db.Rebind(sql))
+	stmt, err := DB.Preparex(DB.Rebind(sql))
 	result, err := stmt.Exec(args...)
 	if err != nil {
 		return 0, err

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: go-on-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - B1nj0y
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-07 00:00:00.000000000 Z
+date: 2017-09-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