go-on-rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bf87cd74390e6eda98fa3fd0f463803699abba3a
+  data.tar.gz: 6e4a785e95fde8e7d0bac8667663642a98a157f3
+SHA512:
+  metadata.gz: 1f9dd6bcc8a2548005c93a18542694f2b9113d28ff8b9010ef3cdc19b9b1fe7fb1cdaeeb51e93e97600f0815d9f77ee95f5441ed5ed35e441c81df950f9df6b8
+  data.tar.gz: 2d0f3af07182f02f4dff820bfe276b8bb0174711badc71aeffc302eb11dc28464d33e7b2a31e1776f6e7f589cd8f1e85118181719d2644bd8bdc97ff9ca7d8a9

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 B1nj0y <idegorepl@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+go-on-rails
+====
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+``ruby
+gem 'go-on-rails'
+``
+
+And then execute:
+``bash
+$ bundle
+``
+
+Or install it yourself as:
+``bash
+$ gem install go-on-rails
+``
+
+## Usage
+
+go-on-rails is a Rails generator used to generate Golang codes from your ever running Rails app or an application that you would create with familiar Rails command tools. One or more examples will be given later on.
+
+So you must have a Rails app or to create one before you can use go-on-rails generator to convert a Rails app to Golang codes.
+
+You can basically run the command to convert the application:
+
+``ruby
+rails g gor [dev(elopment) | pro(duction) | test]
+``
+
+About more command details, you can run:
+
+``ruby
+rails g gor --help
+``
+
+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
+* but the :through keyword not supported yet
+* databases specific functions between mysql, postgres are not covered yet
+* model callbacks in not available
+
+Really a lot...
+
+## Acknowledgement
+
+When I had the idea to convert Rails app or build Golang app with Rails tools, I searched github and found the project: https://github.com/t-k/ar2gostruct. And from ar2gostruct I copied some codes on handling data structure convertion and models association, it make my idea come true faster than I imagined.
+
+## Contributing
+
+- Fork the project.
+- Make your feature addition or bug fix.
+- Add tests for it. This is important so I don't break it in a future version unintentionally.
+- Commit, do not mess with Rakefile or version (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+- Send me a pull request. Bonus points for topic branches.
+

data/lib/generators/gor/USAGE

@@ -0,0 +1,30 @@
+Description:
+    generate Golang app by Rails models: use Rails as a model and migration tool to build a Golang app, or migrate some of existed Rails APIs to Golang to decouple and high-perform your services.
+
+    read more: https://github.com/gingerhot/goonrails
+
+
+Example:
+    rails generate gor development -m user post
+
+    Here are valid ENV_NAME arguments: [dev, development, pro, production, test], the default ENV_NAME is "development" if you omit it.
+
+    So you can also run:
+
+    rails g gor dev -m user post
+
+    This will mainly create:
+        go_app/main.go
+        go_app/db/conn.go
+        go_app/models/user/gor_user.go
+        go_app/models/user/gor_post.go
+
+    Notice: If you omit the -m option, all the models of the Rails app will be generated.
+
+    So if you omit all the options, just run:
+
+    rails g gor
+
+    This will generate all the models and database connection with Rails development env params.
+
+

data/lib/generators/gor/go_on_rails/association.rb

@@ -0,0 +1,41 @@
+module GoOnRails
+    class Association
+        def initialize(klass, models, max_col_size, max_type_size)
+            @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
+
+        def get_schema_info
+            info = {struct_body: "", assoc_info: {has_many: {}, has_one: {}, belongs_to: {}}}
+            self.klass.reflect_on_all_associations.each do |assoc|
+                tags = ["json:\"#{assoc.name.to_s}\" db:\"#{assoc.name.to_s}\""]
+                case assoc.macro
+                when :has_many
+                    col_name = assoc.name.to_s.camelize
+                    class_name = assoc.name.to_s.singularize.camelize
+                    unless assoc.options.empty?
+                        class_name = assoc.options[:class_name] if assoc.options.key? :class_name
+                    end
+                    type_name = "[]#{class_name}"
+                    info[:assoc_info][:has_many][col_name] = {class_name: class_name}
+                    info[:assoc_info][:has_many][col_name].merge!(assoc.options) unless assoc.options.empty?
+
+                when :has_one, :belongs_to
+                    col_name = class_name = assoc.name.to_s.camelize
+                    class_name = assoc.options[:class_name] if assoc.options.key? :class_name unless assoc.options.empty?
+                    type_name = class_name
+                    info[:assoc_info][assoc.macro][col_name] = {class_name: class_name}
+                    info[:assoc_info][assoc.macro][col_name].merge!(assoc.options) unless assoc.options.empty?
+                end
+                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(" "))
+                end
+            end
+            info
+        end
+    end
+end

data/lib/generators/gor/go_on_rails/converter.rb

@@ -0,0 +1,97 @@
+module GoOnRails
+    class Convertor
+        TYPE_MAP = {
+            "string"     => "string",
+            "text"       => "string",
+            "boolean"    => "bool",
+            "integer(1)" => "int8",
+            "integer(2)" => "int16",
+            "integer(3)" => "int32",
+            "integer(4)" => "int64",
+            "integer(8)" => "int64",
+            "float"      => "float64",
+            "datetime"   => "time.Time",
+            "date"       => "time.Time"
+        }
+
+        def initialize(klass, models, option = {})
+            @klass = klass
+            @models = models
+            @max_col_size = 0
+            @max_type_size = 0
+        end
+        attr_accessor :klass, :models, :max_col_size, :max_type_size
+
+        def convert
+            get_schema_info
+        end
+
+        private
+
+        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
+
+            self.klass.columns.each_with_index do |col, index|
+                tags = []
+
+                # add struct tag
+                tags << struct_tag(col)
+
+                col_type = col.type.to_s
+                struct_info[:has_datetime_type] = true if %w(datetime time).include? col_type
+                if col_type == "datetime" and %w(created_at updated_at).include? col.name
+                    struct_info[:timestamp_cols] << col.name
+                end
+
+                case col_type
+                when "integer"
+                    type = TYPE_MAP["integer(#{col.limit})"] || "int64"
+                    type = "u#{type}" if col.sql_type.match("unsigned").present?
+                else
+                    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(" "))
+            end
+
+            assoc = get_associations
+            struct_info[:struct_body] << assoc[:struct_body]
+            struct_info[:assoc_info] = assoc[:assoc_info]
+            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.get_schema_info
+        end
+
+        def struct_tag(col)
+            "json:\"#{col.name}\" db:\"#{col.name}\""
+        end
+
+    end
+end
+
+require_relative 'association'

data/lib/generators/gor/gor_generator.rb

@@ -0,0 +1,93 @@
+class GorGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+  argument :env_name, type: :string, default: "development"
+  class_option :models, type: :array, default: [], aliases: '-m'
+  class_option :only_models, type: :boolean, default: false, aliases: '-o', description: "only generate models"
+
+  def generate_gor
+      env_names = %W(dev development pro production test)
+      unless env_names.include? env_name
+          printf("Invalid env argument: Not any of %p\n\n", env_names)
+          exit
+      end
+
+      rails_env = case env_name
+      when "dev"
+          "development"
+      when "pro"
+          "production"
+      else
+          env_name
+      end
+
+      models = options[:models]
+      if models.empty?
+          models = get_all_models "app/models"
+      else
+          models.map!(&:camelize)
+      end
+      puts "The models: #{models} and Rails env [#{rails_env}] will be used to generate Golang App!"
+
+      models.each do |m|
+          begin
+              klass = m.split('::').inject(Object) { |kls, part| kls.const_get(part) }
+              if klass < ActiveRecord::Base && !klass.abstract_class?
+                  @model_name = klass.to_s
+                  convertor = GoOnRails::Convertor.new(klass, models)
+                  @struct_info = convertor.convert
+                  template "gor_model.go.erb", "go_app/models/gor_#{@model_name.underscore}.go"
+              end
+          rescue Exception => e
+              puts "Failed to convert the model [#{m}]: #{e.message}"
+          end
+      end
+
+      unless options[:only_models]
+          # generate the main.go
+          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
+          copy_file "home_controller.go", "go_app/controllers/home_controller.go"
+          copy_file "index.tmpl", "go_app/views/index.tmpl"
+          copy_file "favicon.ico", "go_app/public/favicon.ico"
+      end
+  end
+
+  private
+
+  def get_all_models model_dir
+      Dir.chdir(model_dir) do
+          Dir["**/*.rb"]
+      end.map { |m| m.sub(/\.rb$/,'').camelize }
+  end
+
+  def create_database_config rails_env
+      db_conf = Rails.configuration.database_configuration[rails_env]
+      case db_conf["adapter"]
+      when "sqlite3"
+          @db_config[:driver_name] = "sqlite3"
+          @db_config[:dsn] = "../" + db_conf["database"]
+          @db_config[:driver_package] = "_ \"github.com/mattn/go-sqlite3\""
+      when "mysql2"
+          @db_config[:driver_name] = "mysql"
+          # 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"))
+          @db_config[:driver_package] = "_ \"github.com/go-sql-driver/mysql\""
+      when "postgresql"
+          @db_config[:driver_name] = "postgres"
+          format = "host=%s user=%s dbname=%s sslmode=disable password=%s"
+          @db_config[:dsn] = sprintf(format, *db_conf.values_at("host", "username", "database", "password"))
+          @db_config[:driver_package] = "_ \"github.com/lib/pq\""
+      end
+  end
+
+end
+
+require_relative 'go_on_rails/converter'

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

@@ -0,0 +1,26 @@
+package model
+
+import (
+	"log"
+
+	<%= @db_config[:driver_package] %>
+	"github.com/jmoiron/sqlx"
+)
+
+var db *sqlx.DB
+
+func init() {
+	var err error
+	driver_name := "<%= @db_config[:driver_name] %>"
+	if driver_name == "" {
+		log.Fatal("Invalid driver name")
+	}
+	dsn := "<%= @db_config[:dsn] %>"
+	if dsn == "" {
+		log.Fatal("Invalid DSN")
+	}
+	db, err = sqlx.Connect(driver_name, dsn)
+	if err != nil {
+		log.Fatal(err)
+	}
+}

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

@@ -0,0 +1,451 @@
+<%- param_name_plural = table_name = @model_name.underscore.pluralize -%>
+<%- model_name_underscore = @model_name.underscore -%>
+<%- col_names = @struct_info[:col_names] -%>
+// The file is generated by go_on_rails, a Rails generator gem:
+// https://rubygems.org/gems/go_on_rails
+// By B1nj0y <idegorepl@gmail.com>
+package model
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"strings"
+	<%- if @struct_info[:has_datetime_type] -%>
+	"time"
+    <%- end -%>
+)
+
+type <%= @model_name %> struct {
+	<%= @struct_info[:struct_body] -%>
+}
+
+// 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")
+	}
+	var_<%= model_name_underscore %> := <%= @model_name %>{}
+	err := db.Get(&var_<%= model_name_underscore %>, "SELECT * FROM <%= table_name %> WHERE id = $1 LIMIT 1", id)
+	if err != nil {
+		log.Printf("Error: %v\n", err)
+		return nil, err
+	}
+	return &var_<%= model_name_underscore %>, nil
+}
+
+// Find<%= @model_name.pluralize %> find one or more <%= model_name_underscore.pluralize %> by one or more ids
+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)
+	}
+	var_<%= param_name_plural %> := []<%= @model_name %>{}
+	idsStr := strings.Trim(strings.Replace(fmt.Sprint(ids), " ", ",", -1), "[]")
+	sql := fmt.Sprintf(`SELECT * FROM <%= table_name %> WHERE id IN (%s)`, idsStr)
+	err := db.Select(&var_<%= param_name_plural %>, sql)
+	if err != nil {
+		log.Printf("Error: %v\n", err)
+		return nil, err
+	}
+	return var_<%= 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 %>{}
+	sqlFmt := `SELECT * FROM <%= table_name %> WHERE %s = $1 LIMIT 1`
+	sqlStr := fmt.Sprintf(sqlFmt, field)
+	err := db.Get(&var_<%= model_name_underscore %>, sqlStr, val)
+	if err != nil {
+		log.Printf("Error: %v\n", err)
+		return nil, err
+	}
+	return &var_<%= 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) {
+	sqlFmt := `SELECT * FROM <%= table_name %> WHERE %s = $1`
+	sqlStr := fmt.Sprintf(sqlFmt, field)
+	err = db.Select(&var_<%= param_name_plural %>, sqlStr, val)
+	if err != nil {
+		log.Printf("Error: %v\n", err)
+		return nil, err
+	}
+	return var_<%= param_name_plural %>, 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(&<%= table_name %>, "SELECT * FROM <%= table_name %>")
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	return <%= param_name_plural %>, nil
+}
+
+// <%= @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 %>")
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	return ids, nil
+}
+
+// <%= @model_name %>Ids 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
+}
+
+// <%= @model_name %>IntCol get some int64 typed column of <%= @model_name %> by where restriction
+func <%= @model_name %>IntCol(col, where string, args ...interface{}) (intColRecs []int64, err error) {
+	sql := "SELECT " + col + " FROM <%= table_name %>"
+	if len(where) > 0 {
+		sql = sql + " WHERE " + where
+	}
+	stmt, err := db.Preparex(sql)
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	err = stmt.Select(&intColRecs, args...)
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	return intColRecs, nil
+}
+
+// <%= @model_name %>StrCol get some string typed column of <%= @model_name %> by where restriction
+func <%= @model_name %>StrCol(col, where string, args ...interface{}) (strColRecs []string, err error) {
+	sql := "SELECT " + col + " FROM <%= table_name %>"
+	if len(where) > 0 {
+		sql = sql + " WHERE " + where
+	}
+	stmt, err := db.Preparex(sql)
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	err = stmt.Select(&strColRecs, args...)
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	return strColRecs, nil
+}
+
+// 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) {
+	sql := "SELECT * FROM <%= table_name %>"
+	if len(where) > 0 {
+		sql = sql + " WHERE " + where
+	}
+	stmt, err := db.Preparex(sql)
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	err = stmt.Select(&<%= param_name_plural %>, args...)
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	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)
+// 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(sql)
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	err = stmt.Select(&<%= param_name_plural %>, args...)
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+	return <%= param_name_plural %>, nil
+}
+
+func Create<%= @model_name %>(am map[string]interface{}) error {
+	if len(am) == 0 {
+		return fmt.Errorf("Zero key in the attributes map!")
+	}
+<%- unless @struct_info[:timestamp_cols].empty? -%>
+	t := time.Now()
+	for _, v := range []string{<%= @struct_info[:timestamp_cols].map(&:inspect).join(", ") %>} {
+		if am[v] == nil {
+			am[v] = t
+		}
+	}
+<%- end -%>
+	keys := make([]string, len(am))
+	i := 0
+	for k := range am {
+		keys[i] = k
+		i++
+	}
+	sqlFmt := `INSERT INTO <%= table_name %> (%s) VALUES (%s)`
+	sqlStr := fmt.Sprintf(sqlFmt, strings.Join(keys, ","), ":"+strings.Join(keys, ",:"))
+	_, err := db.NamedExec(sqlStr, am)
+	if err != nil {
+		log.Print(err)
+		return err
+	}
+	return nil
+}
+
+func (var_<%= model_name_underscore %> *<%= @model_name %>) Create() error {
+<%- unless @struct_info[:timestamp_cols].empty? -%>
+	t := time.Now()
+	<%- @struct_info[:timestamp_cols].each do |c| -%>
+	var_<%= model_name_underscore %>.<%= c.camelize %> = t
+    <%- end -%>
+<%- end -%>
+    sql := `INSERT INTO <%= table_name %> (<%= col_names.join(",") %>) VALUES (:<%= col_names.join(",:") %>)`
+    _, err := db.NamedExec(sql, var_<%= model_name_underscore %>)
+    return 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 {
+	<%- if v[:foreign_key] -%>
+	am["<%= v[:foreign_key] %>"] = var_<%= model_name_underscore %>.Id
+    <%- else -%>
+	am["<%= model_name_underscore %>_id"] = var_<%= model_name_underscore %>.Id
+	<%- end -%>
+	err := Create<%= v[:class_name] %>(am)
+	return err
+}
+
+func (var_<%= model_name_underscore %> *<%= @model_name %>) Get<%= v[:class_name].pluralize %>() error {
+	<%- if v[:foreign_key] -%>
+	var_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>By("<%= v[:foreign_key] %>", var_<%= model_name_underscore %>.Id)
+    <%- else -%>
+	var_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>By("<%= model_name_underscore %>_id", var_<%= model_name_underscore %>.Id)
+	<%- end -%>
+	if err == nil {
+		var_<%= model_name_underscore %>.<%= k %> = var_<%= v[:class_name].underscore.pluralize %>
+	}
+	return err
+}
+	<%- end -%>
+<%- end -%>
+
+<%- 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 {
+	<%- if v[:foreign_key] -%>
+	am["<%= v[:foreign_key] %>"] = var_<%= model_name_underscore %>.Id
+    <%- else -%>
+	am["<%= model_name_underscore %>_id"] = var_<%= model_name_underscore %>.Id
+	<%- end -%>
+	err := Create<%= v[:class_name] %>(am)
+	return err
+}
+	<%- end -%>
+<%- end -%>
+
+<%- 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 {
+	<%- if v[:foreign_key] -%>
+	am["<%= v[:foreign_key] %>"] = var_<%= model_name_underscore %>.Id
+    <%- else -%>
+	am["<%= model_name_underscore %>_id"] = var_<%= model_name_underscore %>.Id
+	<%- end -%>
+	err := Create<%= v[:class_name] %>(am)
+	return err
+}
+	<%- end -%>
+<%- end -%>
+
+func (var_<%= model_name_underscore %> *<%= @model_name %>) Destroy() error {
+	if var_<%= 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)
+	return err
+}
+
+func Destroy<%= @model_name %>(id int64) error {
+	stmt, err := db.Preparex(`DELETE FROM <%= table_name %> WHERE id = ?`)
+	_, err = stmt.Exec(id)
+	if err != nil {
+		return err
+	}
+	<%- [:has_many, :has_one].each do |ass| -%>
+		<%- ass_cols = @struct_info[:assoc_info][ass] -%>
+		<%- unless ass_cols.empty? -%>
+			<%- ass_cols.each_value do |opts| -%>
+				<%- if opts.key? :dependent -%>
+					<%- if opts.key? :foreign_key -%>
+    Destroy<%= opts[:class_name].pluralize %>Where("<%= opts[:foreign_key] %> = ?", id)
+					<%- else -%>
+    Destroy<%= opts[:class_name].pluralize %>Where("<%= model_name_underscore %>_id = ?", id)
+					<%- end -%>
+				<%- end -%>
+			<%- end -%>
+		<%- end -%>
+	<%- end -%>
+	return nil
+}
+
+func Destroy<%= @model_name.pluralize %>(ids ...int64) (int64, error) {
+	if len(ids) == 0 {
+		msg := "At least one or more ids needed"
+		log.Println(msg)
+		return 0, errors.New(msg)
+	}
+	idsStr := strings.Trim(strings.Replace(fmt.Sprint(ids), " ", ",", -1), "[]")
+	sql := fmt.Sprintf(`DELETE FROM <%= table_name %> WHERE id IN (%s)`, idsStr)
+	stmt, err := db.Preparex(sql)
+	result, err := stmt.Exec()
+	if err != nil {
+		return 0, err
+	}
+	cnt, err := result.RowsAffected()
+	if err != nil {
+		return 0, err
+	}
+	<%- [:has_many, :has_one].each do |ass| -%>
+		<%- ass_cols = @struct_info[:assoc_info][ass] -%>
+		<%- unless ass_cols.empty? -%>
+			<%- ass_cols.each_value do |opts| -%>
+				<%- if opts.key? :dependent -%>
+					<%- if opts.key? :foreign_key -%>
+    where := fmt.Sprintf("<%= opts[:foreign_key] %> IN (%s)", idsStr)
+    Destroy<%= opts[:class_name].pluralize %>Where(where)
+					<%- else -%>
+	where := fmt.Sprintf("<%= model_name_underscore %>_id IN (%s)", idsStr)
+    Destroy<%= opts[:class_name].pluralize %>Where(where)
+					<%- end -%>
+				<%- end -%>
+			<%- end -%>
+		<%- end -%>
+	<%- end -%>
+	return cnt, nil
+}
+
+// Destroy<%= @model_name.pluralize %>Where delete records by a where clause
+// like: 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 `
+	if len(where) > 0 {
+		sql = sql + where
+	} else {
+		return 0, errors.New("No WHERE conditions provided")
+	}
+	stmt, err := db.Preparex(sql)
+	result, err := stmt.Exec(args...)
+	if err != nil {
+		return 0, err
+	}
+	cnt, err := result.RowsAffected()
+	if err != nil {
+		return 0, err
+	}
+	return cnt, nil
+}
+
+func (var_<%= model_name_underscore %> *<%= @model_name %>) Save() error {
+	if var_<%= 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()
+<%- end -%>
+	sqlFmt := `UPDATE <%= table_name %> SET %s WHERE id = %v`
+	sqlStr := fmt.Sprintf(sqlFmt, "<%= col_names.zip(col_names).map{|c| c.join(" = :")}.join(", ") %>", var_<%= model_name_underscore %>.Id)
+    _, err := db.NamedExec(sqlStr, var_<%= model_name_underscore %>)
+    return err
+}
+
+func Update<%= @model_name %>(id int64, am map[string]interface{}) error {
+	if len(am) == 0 {
+		return errors.New("Zero key in the attributes map!")
+	}
+<%- if @struct_info[:timestamp_cols].include? "updated_at" -%>
+	am["updated_at"] = time.Now()
+<%- end -%>
+	keys := make([]string, len(am))
+	i := 0
+	for k := range am {
+		keys[i] = k
+		i++
+	}
+	sqlFmt := `UPDATE <%= table_name %> SET %s WHERE id = %v`
+	setKeysArr := []string{}
+	for _,v := range keys {
+		s := fmt.Sprintf(" %s = :%s", v, v)
+		setKeysArr = append(setKeysArr, s)
+	}
+	sqlStr := fmt.Sprintf(sqlFmt, strings.Join(setKeysArr, ", "), id)
+	_, err := db.NamedExec(sqlStr, am)
+	if err != nil {
+		log.Print(err)
+		return err
+	}
+	return nil
+}
+
+func (var_<%= model_name_underscore %> *<%= @model_name %>) Update(am map[string]interface{}) error {
+	if var_<%= 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)
+	return err
+}
+
+func (var_<%= model_name_underscore %> *<%= @model_name %>) UpdateAttributes(am map[string]interface{}) error {
+	if var_<%= 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)
+	return err
+}
+
+func (var_<%= model_name_underscore %> *<%= @model_name %>) UpdateColumns(am map[string]interface{}) error {
+	if var_<%= 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)
+	return err
+}
+
+func Update<%= @model_name.pluralize %>BySql(sql string, args ...interface{}) (int64, error) {
+	if sql == "" {
+		return 0, errors.New("A blank SQL clause")
+	}
+<%- if @struct_info[:timestamp_cols].include? "updated_at" -%>
+	sql = strings.Replace(strings.ToLower(sql), "set", "set updated_at = ?, ", 1)
+	args = append([]interface{}{time.Now()}, args...)
+<%- end -%>
+	stmt, err := db.Preparex(sql)
+	result, err := stmt.Exec(args...)
+	if err != nil {
+		return 0, err
+	}
+	cnt, err := result.RowsAffected()
+	if err != nil {
+		return 0, err
+	}
+	return cnt, nil
+}

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

@@ -0,0 +1,27 @@
+package controller
+
+import (
+	"html/template"
+	"net/http"
+	// you can import models
+	//m "../models"
+)
+
+func HomeHandler(w http.ResponseWriter, r *http.Request) {
+	// you can use model functions to do CRUD
+	//
+	// user, _ := m.FindUser(1)
+	// u, err := json.Marshal(user)
+	// if err != nil {
+	// 	log.Printf("JSON encoding error: %v\n", err)
+	// 	u = []byte("Get data error!")
+	// }
+
+	type Greeting struct {
+		Name  string
+		Words string
+	}
+	greeting := Greeting{Name: "Rubyist", Words: "Welcome to GoOnRails!"}
+	t, _ := template.ParseFiles("views/index.tmpl")
+	t.Execute(w, greeting)
+}

data/lib/generators/gor/templates/index.tmpl

@@ -0,0 +1,8 @@
+<html>
+    <title>GoOnRails Framework</title>
+    <body>
+        <h1>
+            Hello {{ .Name }}, {{ .Words }}
+        </h1>
+    </body>
+</html>

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

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"flag"
+	"log"
+	"net/http"
+	"os"
+
+	c "./controllers"
+	"github.com/gorilla/handlers"
+	"github.com/gorilla/mux"
+)
+
+func main() {
+	// The app will run on port 3000 by default, you can custom it with the flag -port
+	servePort := flag.String("port", "3000", "Http Server Port")
+	flag.Parse()
+	log.Printf("The application starting on the port: [%v]\n", *servePort)
+
+	// Here we are instantiating the gorilla/mux router
+	r := mux.NewRouter()
+	// Then we bind some route to some handler(controller action)
+	r.HandleFunc("/", c.HomeHandler)
+	// Create a static assets router
+	r.PathPrefix("/public/").Handler(http.StripPrefix("/public/", http.FileServer(http.Dir("./public/"))))
+
+	// Let's start the server
+	http.ListenAndServe(":"+*servePort, handlers.LoggingHandler(os.Stdout, r))
+}

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: go-on-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- B1nj0y
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-03 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. And you can convert your ever
+  running Rails app to Golang app partially or completely(not now or your Rails app
+  not so complicated)
+email: idegorepl@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/generators/gor/USAGE
+- lib/generators/gor/go_on_rails/association.rb
+- lib/generators/gor/go_on_rails/converter.rb
+- lib/generators/gor/gor_generator.rb
+- lib/generators/gor/templates/db.go.erb
+- lib/generators/gor/templates/favicon.ico
+- lib/generators/gor/templates/gor_model.go.erb
+- lib/generators/gor/templates/home_controller.go
+- lib/generators/gor/templates/index.tmpl
+- lib/generators/gor/templates/main.go
+homepage: https://github.com/goonr/go-on-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Use Rails generator to Generate a Golang application
+test_files: []