go-on-rails 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf87cd74390e6eda98fa3fd0f463803699abba3a
-  data.tar.gz: 6e4a785e95fde8e7d0bac8667663642a98a157f3
+  metadata.gz: 2839e5d56004e5a3974cb77427e5c3438ef3c5df
+  data.tar.gz: 24a489fcc1fac898832b6d1269a287d0c88d7a89
 SHA512:
-  metadata.gz: 1f9dd6bcc8a2548005c93a18542694f2b9113d28ff8b9010ef3cdc19b9b1fe7fb1cdaeeb51e93e97600f0815d9f77ee95f5441ed5ed35e441c81df950f9df6b8
-  data.tar.gz: 2d0f3af07182f02f4dff820bfe276b8bb0174711badc71aeffc302eb11dc28464d33e7b2a31e1776f6e7f589cd8f1e85118181719d2644bd8bdc97ff9ca7d8a9
+  metadata.gz: 6107aa404f72156d23e5191b0414c5d5c6d391eaca61e68cf48031f17d55c627fe4c30e8f46a2aeb6939c850835e2c83504354155ad369ffd03f7a64f443a7c5
+  data.tar.gz: 3a3a53bc94bbc3d8ce3b9d48b8d6140b8e1e2b19699843d13ed97206cdc9345b809330092b350cbf66c5afa97de2bba5ee99b5b582cd2cfde5c456f3edbe9032

data/README.md

@@ -1,41 +1,67 @@
 go-on-rails
 ====
 
+## Prerequisites
+
+* Rails development environment
+* Golang development environment
+
 ## Installation
 
 Add this line to your application's Gemfile:
 
-``ruby
+```ruby
 gem 'go-on-rails'
-``
+```
 
 And then execute:
-``bash
+```bash
 $ bundle
-``
+```
 
 Or install it yourself as:
-``bash
+```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.
+go-on-rails aims at three scenarios:
+
+1. Integrate some api written in Golang to existed Rails app for high performance
+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
+
+One or more examples will be given later on.
+
+So you must have a Rails app or to create one before you can try go-on-rails generator to convert a Rails app to Golang codes.
+
+You can just run the command to convert the application:
+
+```bash
+rails g gor [dev(elopment) | pro(duction) | test] [-m model_a model_b model_c ...]
+```
+
+Then a directory named "go_app" with Golang codes will be generated under your Rails app root path.
+
+Install the dependent Golang packages:
+
+```bash
+rails gor:deps
+```
 
-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.
+Then change to the "go_app" directory and run:
 
-You can basically run the command to convert the application:
+```bash
+go run main.go
+```
 
-``ruby
-rails g gor [dev(elopment) | pro(duction) | test]
-``
+You can visit the page in http://localhost:3000 by default.
 
-About more command details, you can run:
+More command details about go-on-rails generator:
 
-``ruby
+```bash
 rails g gor --help
-``
+```
 
 And the gem is still under development, so there're a lot of known issues.
 
@@ -44,9 +70,9 @@ And the gem is still under development, so there're a lot of known issues.
 * 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
+* model callbacks is not available
+* sql.NullType not supported yet, so you'd better set all columns "not null" with a default value in the migration, such as "" default for string and text typed column, and 0 default for int, etc, that's consistent with Golang's zero value specification.
 
 Really a lot...
 

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

@@ -1,41 +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
+  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?
+    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},omitempty\" 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
+        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

@@ -1,97 +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: ""}
+  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
 
-            self.max_col_size = get_max_col_size
-            self.max_type_size = get_max_type_size
+    def convert
+      get_schema_info
+    end
 
-            self.klass.columns.each_with_index do |col, index|
-                tags = []
+    private
 
-                # add struct tag
-                tags << struct_tag(col)
+    def get_schema_info
+      struct_info = {col_names: [], timestamp_cols: [], has_datetime_type: false, struct_body: ""}
 
-                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
+      self.max_col_size = get_max_col_size
+      self.max_type_size = get_max_type_size
 
-                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
+      self.klass.columns.each_with_index do |col, index|
+        tags = []
 
-                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
+        # add struct tag
+        tags << struct_tag(col)
 
-            assoc = get_associations
-            struct_info[:struct_body] << assoc[:struct_body]
-            struct_info[:assoc_info] = assoc[:assoc_info]
-            return struct_info
+        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
 
-        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
+        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
 
-        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
+        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
 
-        def get_struct_name
-            self.klass.table_name.camelize
-        end
+      assoc = get_associations
+      struct_info[:struct_body] << assoc[:struct_body]
+      struct_info[:assoc_info] = assoc[:assoc_info]
+      return struct_info
+    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 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 struct_tag(col)
-            "json:\"#{col.name}\" db:\"#{col.name}\""
-        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},omitempty\" db:\"#{col.name}\""
+    end
+
+  end
 end
 
 require_relative 'association'

data/lib/generators/gor/gor_generator.rb

@@ -5,89 +5,96 @@ class GorGenerator < Rails::Generators::Base
   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
+    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
+    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 = 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
+    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"
+    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 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
+      # 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
+
+    # use gofmt to prettify the generated Golang files
+    gofmt_go_files
   end
 
   private
 
   def get_all_models model_dir
-      Dir.chdir(model_dir) do
-          Dir["**/*.rb"]
-      end.map { |m| m.sub(/\.rb$/,'').camelize }
+    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
+    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
 
+  def gofmt_go_files
+    go_files = Rails.root.join('go_app', 'models/*.go').to_s
+    system "gofmt -w #{go_files} > /dev/null 2>&1"
+  end
 end
 
 require_relative 'go_on_rails/converter'

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

@@ -1,8 +1,9 @@
 <%- 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
+// The file is generated by go-on-rails, a Rails generator gem:
+// https://rubygems.org/gems/go-on-rails
+// Or on Github: https://github.com/goonr/go-on-rails
 // By B1nj0y <idegorepl@gmail.com>
 package model
 
@@ -42,9 +43,13 @@ func Find<%= @model_name.pluralize %>(ids ...int64) ([]<%= @model_name %>, error
 		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)
+	idsHolder := strings.Repeat(",?", len(ids)-1)
+	sql := fmt.Sprintf(`SELECT * FROM <%= table_name %> WHERE id IN (?%s)`, idsHolder)
+	idsT := []interface{}{}
+	for _,id := range ids {
+		idsT = append(idsT, interface{}(id))
+	}
+	err := db.Select(&var_<%= param_name_plural %>, sql, idsT...)
 	if err != nil {
 		log.Printf("Error: %v\n", err)
 		return nil, err
@@ -179,9 +184,9 @@ func Find<%= @model_name.pluralize %>BySql(sql string, args ...interface{}) (<%=
 	return <%= param_name_plural %>, nil
 }
 
-func Create<%= @model_name %>(am map[string]interface{}) error {
+func Create<%= @model_name %>(am map[string]interface{}) (int64, error) {
 	if len(am) == 0 {
-		return fmt.Errorf("Zero key in the attributes map!")
+		return 0, fmt.Errorf("Zero key in the attributes map!")
 	}
 <%- unless @struct_info[:timestamp_cols].empty? -%>
 	t := time.Now()
@@ -199,12 +204,17 @@ func Create<%= @model_name %>(am map[string]interface{}) error {
 	}
 	sqlFmt := `INSERT INTO <%= table_name %> (%s) VALUES (%s)`
 	sqlStr := fmt.Sprintf(sqlFmt, strings.Join(keys, ","), ":"+strings.Join(keys, ",:"))
-	_, err := db.NamedExec(sqlStr, am)
+	result, err := db.NamedExec(sqlStr, am)
 	if err != nil {
 		log.Print(err)
-		return err
+		return 0, err
 	}
-	return nil
+	lastId, err := result.LastInsertId()
+	if err != nil {
+		log.Print(err)
+		return 0, err
+	}
+	return lastId, nil
 }
 
 func (var_<%= model_name_underscore %> *<%= @model_name %>) Create() error {
@@ -223,25 +233,43 @@ func (var_<%= model_name_underscore %> *<%= @model_name %>) Create() error {
 	<%- 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
+	<%- 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": var_<%= model_name_underscore %>.Id, "<%= v[:class_name].underscore %>_id": <%= v[:class_name].underscore %>_id})
+	<%- else -%>
+		<%- 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)
 	<%- 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)
+	<%- if v[:through] -%>
+		// FIXME: use transaction to create these associated objects
+		<%= v[:class_name].underscore %>_ids, err := <%= v[:through].to_s.singularize.camelize %>IntCol("<%= v[:class_name].underscore %>_id", "<%= model_name_underscore %>_id = ?", var_<%= model_name_underscore %>.Id)
+		if err != nil {
+			return err
+		}
+		var_<%= v[:class_name].underscore.pluralize %>, err := Find<%= v[:class_name].pluralize %>(<%= v[:class_name].underscore %>_ids...)
+	<%- else -%>
+		<%- 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 -%>
 	<%- end -%>
 	if err == nil {
 		var_<%= model_name_underscore %>.<%= k %> = var_<%= v[:class_name].underscore.pluralize %>
-	}
-	return err
+    }
+    return err
 }
 	<%- end -%>
 <%- end -%>
@@ -255,7 +283,7 @@ func (var_<%= model_name_underscore %> *<%= @model_name %>) Create<%= v[:class_n
     <%- else -%>
 	am["<%= model_name_underscore %>_id"] = var_<%= model_name_underscore %>.Id
 	<%- end -%>
-	err := Create<%= v[:class_name] %>(am)
+	_, err := Create<%= v[:class_name] %>(am)
 	return err
 }
 	<%- end -%>
@@ -270,7 +298,7 @@ func (var_<%= model_name_underscore %> *<%= @model_name %>) Create<%= v[:class_n
     <%- else -%>
 	am["<%= model_name_underscore %>_id"] = var_<%= model_name_underscore %>.Id
 	<%- end -%>
-	err := Create<%= v[:class_name] %>(am)
+	_, err := Create<%= v[:class_name] %>(am)
 	return err
 }
 	<%- end -%>
@@ -295,10 +323,25 @@ func Destroy<%= @model_name %>(id int64) error {
 		<%- 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)
+					<%- if opts[:through] -%>
+						<%= opts[:class_name].underscore %>_ids, err := <%= opts[:through].to_s.singularize.camelize %>IntCol("<%= opts[:class_name].underscore %>_id", "<%= model_name_underscore %>_id = ?", var_<%= model_name_underscore %>.Id)
+						if err != nil {
+							return err
+						}
+						_, err = Destroy<%= opts[:class_name].pluralize %>(<%= opts[:class_name].underscore %>_ids...)
+						if err != nil {
+							return err
+						}
+						_, err = Destroy<%= opts[:through].to_s.pluralize.camelize %>Where("<%= model_name_underscore %>_id = ?", var_<%= model_name_underscore %>.Id)
+						if err != nil {
+							return err
+						}
 					<%- else -%>
-    Destroy<%= opts[:class_name].pluralize %>Where("<%= model_name_underscore %>_id = ?", id)
+						<%- 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 -%>
@@ -313,10 +356,14 @@ func Destroy<%= @model_name.pluralize %>(ids ...int64) (int64, error) {
 		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)
+	idsHolder := strings.Repeat(",?", len(ids)-1)
+	sql := fmt.Sprintf(`DELETE FROM <%= table_name %> WHERE id IN (?%s)`, idsHolder)
+	idsT := []interface{}{}
+	for _,id := range ids {
+		idsT = append(idsT, interface{}(id))
+	}
 	stmt, err := db.Preparex(sql)
-	result, err := stmt.Exec()
+	result, err := stmt.Exec(idsT...)
 	if err != nil {
 		return 0, err
 	}
@@ -330,11 +377,11 @@ func Destroy<%= @model_name.pluralize %>(ids ...int64) (int64, error) {
 			<%- 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)
+    where := fmt.Sprintf("<%= opts[:foreign_key] %> IN (?%s)", idsHolder)
+    Destroy<%= opts[:class_name].pluralize %>Where(where, idsT)
 					<%- else -%>
-	where := fmt.Sprintf("<%= model_name_underscore %>_id IN (%s)", idsStr)
-    Destroy<%= opts[:class_name].pluralize %>Where(where)
+	where := fmt.Sprintf("<%= model_name_underscore %>_id IN (?%s)", idsHolder)
+    Destroy<%= opts[:class_name].pluralize %>Where(where, idsT)
 					<%- end -%>
 				<%- end -%>
 			<%- end -%>
@@ -373,7 +420,8 @@ func (var_<%= model_name_underscore %> *<%= @model_name %>) Save() error {
 	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)
+	<%- save_col_names = col_names - ["created_at"] -%>
+	sqlStr := fmt.Sprintf(sqlFmt, "<%= save_col_names.zip(save_col_names).map{|c| c.join(" = :")}.join(", ") %>", var_<%= model_name_underscore %>.Id)
     _, err := db.NamedExec(sqlStr, var_<%= model_name_underscore %>)
     return err
 }

data/lib/tasks/gor.rake

@@ -0,0 +1,14 @@
+namespace :gor do
+  desc 'Install dependent Golang packages'
+  task :deps do
+    puts 'Beginning to install Go deps...'
+    system "go get \
+    github.com/jmoiron/sqlx \
+    github.com/gorilla/handlers \
+    github.com/gorilla/mux \
+    github.com/mattn/go-sqlite3 \
+    github.com/go-sql-driver/mysql \
+    github.com/lib/pq"
+    puts 'Installation completed!'
+  end
+end

metadata

@@ -1,19 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: go-on-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - B1nj0y
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-03 00:00:00.000000000 Z
+date: 2017-04-14 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)
+  tools like rails generate, db migration, console etc. It also help integrating some
+  api written in Golang to existed Rails app for high performance.
 email: idegorepl@gmail.com
 executables: []
 extensions: []
@@ -31,6 +30,7 @@ files:
 - lib/generators/gor/templates/home_controller.go
 - lib/generators/gor/templates/index.tmpl
 - lib/generators/gor/templates/main.go
+- lib/tasks/gor.rake
 homepage: https://github.com/goonr/go-on-rails
 licenses:
 - MIT