goon_model_gen 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23badabb9901481656de5b91833d0b04452ff998cf18036fbc8c4152963ed7d8
-  data.tar.gz: 25c94a3b11c2411e8d5d68367dc9e5f81d737072be6e69d151597e92232066b8
+  metadata.gz: 4283b78918a93a63233070c2e5d0d1ef100d4b214e672b50640f5b70c6aa08b3
+  data.tar.gz: f0bc7f7a08b1311a4b12d754d1bce760fbe59ac39e6bdbf48e215d63c3b9cf2e
 SHA512:
-  metadata.gz: 2c085ab7ad6374af508b4d2cc57fd750d9d2843d10d05906050aae9f31a4d27739df11118a542a21d9e8e3dd6500809e2bfd52c13f29c610b436adebc5cb0f28
-  data.tar.gz: fc2f17df0f6446a511615215bf7f0937aa8c29639229f007a456385d53eeab3bc95433b2e439bd09ba30b4fac336db22c42f6c86c6453207983bc5fa23751db5
+  metadata.gz: 26af49ba18494c6722cd7421ab53598c70ad86a8ced5269ea1328989713678517f696f4886b6cac1fdad5c378e230d72a34e3c0cc399a0db04f7973a1227fb80
+  data.tar.gz: ad98807c4bfdfbf715b2b528ae5b193b3e205489d505ddca16956c74132113ef50329a8526aef636dff16498b25308a6c02a0f6710a6740488ee0d88b95e576f

data/lib/goon_model_gen/builder/converter_builder.rb

@@ -0,0 +1,76 @@
+require "goon_model_gen"
+
+require "goon_model_gen/builder/abstract_builder"
+
+require "goon_model_gen/source/struct"
+
+require "goon_model_gen/golang/package"
+require "goon_model_gen/golang/datastore_supported"
+
+
+module GoonModelGen
+  module Builder
+    class ConverterBuilder < AbstractBuilder
+      attr_reader :loader
+      attr_reader :packages
+
+      # @param base_package_path [String]
+      # @param loader [Converter::Loader]
+      # @param packages [Golang::Packages]
+      def initialize(base_package_path, loader, packages)
+        super(base_package_path)
+        @package_suffix = "_conv"
+        @loader = loader
+        @packages = packages
+      end
+
+      # @param conv_file_path [Array<String>]
+      def build(conv_file_paths)
+        Golang::Packages.new.tap do |pkgs|
+          build_sentences = []
+          conv_file_paths.each do |conv_file_path|
+            conf_file = loader.process(conv_file_path)
+            procs = build_package(pkgs, conf_file)
+            build_sentences.concat(procs)
+          end
+          resolve_type_names(pkgs)
+          build_sentences.each(&:call)
+        end
+      end
+
+      # @param pkgs [Golang::Packages]
+      # @param conv_file [Converter::ConvFile]
+      # @return [Array<Proc>]
+      def build_package(pkgs, conv_file)
+        procs = []
+        pkgs.new_package(conv_file.converter_package_path).tap do |pkg|
+          {
+            'converter/payload' => conv_file.payload_convs,
+            'converter/result' => conv_file.result_convs,
+          }.each do |template_dir, convs|
+            convs.each do |conv|
+              conv_type = pkg.new_combination_type(conv.name).tap do |t|
+                m = conv.model
+                g = conv.gen_type
+                t.add(:model, m.name, m.package_path, m.package_base_path)
+                t.add(:gen_type, g.name, g.package_path, g.package_base_path)
+                t.memo['mappings'] = conv.mappings
+                unless conv.model.slice_with_ptr.nil?
+                  t.memo['model_slice_with_ptr'] = conv.model.slice_with_ptr
+                end
+              end
+              procs << Proc.new{ build_sentences_with(template_dir, conv_type, nil) }
+            end
+          end
+        end
+        return procs
+      end
+
+      # @param pkgs [Golang::Packages]
+      def resolve_type_names(pkgs)
+        pkgs.resolve_type_names(Golang::DatastoreSupported.packages.dup.add(packages))
+      end
+
+    end
+  end
+end

data/lib/goon_model_gen/cli.rb

@@ -8,7 +8,10 @@ require "goon_model_gen/config"
 require "goon_model_gen/builder/model_builder"
 require "goon_model_gen/builder/store_builder"
 require "goon_model_gen/builder/validation_builder"
+require "goon_model_gen/builder/converter_builder"
+require "goon_model_gen/converter/loader"
 require "goon_model_gen/source/loader"
+require "goon_model_gen/golang/structs_loader"
 require "goon_model_gen/generator"
 
 module GoonModelGen
@@ -58,6 +61,27 @@ module GoonModelGen
       end
     end
 
+    desc "converter FILE1...", "Generate store files from converter YAML files"
+    option :inspect, type: :boolean, desc: "Don't generate any file and show package objects if given"
+    def converter(*paths)
+      loader = Converter::Loader.new(cfg)
+      package_hash = Golang::StructsLoader.new.process(cfg.structs_json_path) # Golang::Packages
+      packages = Golang::Packages.wrap(package_hash.values.flatten)
+      converter_package = packages.find_or_new(cfg.converter_package_path)
+
+      b = Builder::ConverterBuilder.new(cfg.converter_package_path, loader, Golang::Packages.new.add(*packages))
+      conv_packages = b.build(paths)
+
+      if options[:inspect]
+        puts YAML.dump(conv_packages)
+      else
+        conv_packages.map(&:files).flatten.each do |f|
+          new_generator(f, packages).
+            run(converter_package: converter_package)
+        end
+      end
+    end
+
     no_commands do
       def cfg
         @cfg ||= Config.new.load_from(options[:config])

data/lib/goon_model_gen/config.rb

@@ -20,7 +20,10 @@ module GoonModelGen
       store_package_path
       converter_dir
       converter_package_path
+      goa_gen_dir
+      goa_gen_package_path
       structs_gen_dir
+      structs_json_path
       validator_package_path
       version_comment
     ].freeze
@@ -41,6 +44,7 @@ module GoonModelGen
       @converter_package_path ||= join_paths(@base_package_path, @converter_dir)
       @goa_gen_package_path   ||= join_paths(@base_package_path, @goa_gen_dir)
       @structs_gen_dir ||= "./cmd/structs"
+      @structs_json_path ||= "./structs.json"
       @version_comment ||= false
       self
     end

data/lib/goon_model_gen/converter/abstract_conv.rb

@@ -0,0 +1,20 @@
+require "goon_model_gen"
+
+module GoonModelGen
+  module Converter
+    class AbstractConv
+      attr_accessor :file # ConvFile
+      attr_reader :name
+      attr_reader :model    # TypeRef
+      attr_reader :gen_type # TypeRef Payload/Result
+      attr_reader :mappings
+
+      def initialize(name, model, gen_type, mappings)
+        @name = name
+        @model = model
+        @gen_type = gen_type
+        @mappings = mappings
+      end
+    end
+  end
+end

data/lib/goon_model_gen/converter/conv_file.rb

@@ -0,0 +1,20 @@
+require "goon_model_gen"
+
+module GoonModelGen
+  module Converter
+    class ConvFile
+      attr_reader :path
+      attr_reader :converter_package_path # String
+      attr_accessor :payload_convs, :result_convs # [XxxxConv]
+
+      def initialize(path, converter_package_path)
+        @path = path
+        @converter_package_path = converter_package_path
+      end
+
+      def basename
+        ::File.basename(path, '.*')
+      end
+    end
+  end
+end

data/lib/goon_model_gen/converter/loader.rb

@@ -0,0 +1,85 @@
+require "goon_model_gen"
+
+require "erb"
+require "yaml"
+
+require "goon_model_gen/converter/conv_file"
+require "goon_model_gen/converter/payload_conv"
+require "goon_model_gen/converter/result_conv"
+require "goon_model_gen/converter/type_ref"
+require "goon_model_gen/converter/mapping"
+
+require "active_support/core_ext/string"
+
+module GoonModelGen
+  module Converter
+    class Loader
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      def process(path)
+        erb = ERB.new(::File.read(path), nil, "-")
+        erb.filename = path
+        txt = erb.result
+        raw = YAML.load(txt)
+
+        converter_dir = raw['converter_dir'] || ::File.basename(path, '.*')
+        converter_package_path = raw['converter_package_path'] || File.join(config.converter_package_path, converter_dir)
+        ConvFile.new(path, converter_package_path).tap do |f|
+          f.payload_convs = load_conv_defs(f, PayloadConv, raw['payloads'] || {})
+          f.result_convs = load_conv_defs(f, ResultConv, raw['results'] || {})
+        end
+      end
+
+      def load_conv_defs(f, conv_class, hash)
+        hash.map do |(name, definition)|
+          model = load_model_for_conv(definition['model'])
+          gen_type = TypeRef.new(name, File.join(config.goa_gen_package_path, f.basename))
+          mappings = load_mappings(definition['mappings'], conv_class)
+          conv_class.new(name, model, gen_type, mappings).tap do |conv|
+            conv.file = f
+          end
+        end
+      end
+
+      def load_model_for_conv(obj)
+        pkg_name, pkg_path, pkg_base_path = nil, nil, nil
+        slice_with_ptr = nil
+        case obj
+        when Hash
+          pkg_name, pkg_path = obj['name'], obj['package_path']
+          slice_with_ptr = obj['slice_with_ptr']
+        when String
+          pkg_name = obj
+          pkg_base_path = config.model_package_path
+        else
+          raise "Unsupported model type for converter definition: #{obj.inspect}"
+        end
+        TypeRef.new(pkg_name, pkg_path).tap do |t|
+          t.package_base_path = pkg_base_path
+          t.slice_with_ptr = slice_with_ptr
+        end
+      end
+
+      def load_mappings(hash, conv_class)
+        hash.map do |(name, props)|
+          props ||= {}
+          props = {'arg' => props} if props.is_a?(String)
+          args = props['args'] || [props['arg'] || name]
+          func, requires_context, returns_error = *conv_class.load_func(props)
+          if func.nil? && (args.length > 1)
+            raise "Invalid argument length: #{args.length} for #{name}: #{args.inspect}"
+          end
+          Mapping.new(name, args, func, requires_context, returns_error).tap do |m|
+            m.allow_zero = props['allow_zero']
+            m.resolve_package_path(config)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/goon_model_gen/converter/mapping.rb

@@ -0,0 +1,21 @@
+require "goon_model_gen"
+
+module GoonModelGen
+  module Converter
+    class Mapping
+      attr_reader :name, :args, :func, :requires_context, :returns_error
+      attr_accessor :package_base_path, :package_name
+      attr_accessor :allow_zero # for int or uint only
+      def initialize(name, args, func, requires_context, returns_error)
+        @name, @args, @func, @requires_context, @returns_error = name, args, func, requires_context, returns_error
+      end
+
+      def resolve_package_path(config)
+        if func.present? && func.include?('.')
+          self.package_base_path = requires_context ? config.store_package_path : config.model_package_path
+          self.package_name = func.split('.', 2).first
+        end
+      end
+    end
+  end
+end

data/lib/goon_model_gen/converter/payload_conv.rb

@@ -0,0 +1,25 @@
+require "goon_model_gen"
+
+require "goon_model_gen/converter/abstract_conv"
+
+module GoonModelGen
+  module Converter
+    class PayloadConv < AbstractConv
+      class << self
+        # @return [String, boolean, boolean] func, requires_context, returns_error
+        def load_func(props)
+          if f = props['filter']
+            return f, false, false
+          elsif f = props['reader']
+            return f, false, true
+          elsif f = props['loader']
+            return f, true, true
+          else
+            return nil, nil, nil
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/goon_model_gen/converter/result_conv.rb

@@ -0,0 +1,24 @@
+require "goon_model_gen"
+
+require "goon_model_gen/converter/abstract_conv"
+
+module GoonModelGen
+  module Converter
+    class ResultConv < AbstractConv
+
+      class << self
+        # @return [String, boolean, boolean] func, requires_context, returns_error
+        def load_func(props)
+          if f = props['filter']
+            return f, false, false
+          elsif f = props['writer']
+            return f, false, true
+          else
+            return nil, nil, nil
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/goon_model_gen/converter/type_ref.rb

@@ -0,0 +1,14 @@
+require "goon_model_gen"
+
+module GoonModelGen
+  module Converter
+    class TypeRef
+      attr_reader :name, :package_path
+      attr_accessor :package_base_path
+      attr_accessor :slice_with_ptr
+      def initialize(name, package_path)
+        @name, @package_path = name, package_path
+      end
+    end
+  end
+end

data/lib/goon_model_gen/golang/builtin.rb

@@ -9,7 +9,8 @@ module GoonModelGen
       TYPE_NAMES =
         %w[bool byte complex128 complex64
            error float32 float64 int int16 int32 int64 int8
-           rune string uint uint16 uint32 uint64 uint8 uintptr]
+           rune string uint uint16 uint32 uint64 uint8 uintptr
+           interface] # interface is not a type but is added to ease to treat any type
 
       class << self
         def package

data/lib/goon_model_gen/golang/combination_type.rb

@@ -0,0 +1,45 @@
+require "goon_model_gen"
+
+require "goon_model_gen/golang/type"
+
+module GoonModelGen
+  module Golang
+    class CombinationType < Type
+      class ItemType
+        attr_reader :name, :package_path, :package_base_path
+        attr_reader :type
+        def initialize(name, package_path, package_base_path = nil)
+          @name, @package_path, @package_base_path = name, package_path, package_base_path
+        end
+
+        def to_hash
+          {name: name, package_path: package_path, package_base_path: package_base_path}
+        end
+
+        # @param pkgs [Packages]
+        def resolve(pkgs)
+          @type = pkgs.type_by(**to_hash) || raise("Type not found by #{to_hash.inspect}")
+        end
+      end
+
+      attr_reader :map
+
+      # @param name [String]
+      def initialize(name)
+        super(name)
+        @map = {}
+      end
+
+      def add(key, name, package_path, package_base_path = nil)
+        map[key] = ItemType.new(name, package_path, package_base_path)
+      end
+
+      # @param pkgs [Packages]
+      def resolve(pkgs)
+        map.each do |_, item|
+          item.resolve(pkgs)
+        end
+      end
+    end
+  end
+end

data/lib/goon_model_gen/golang/enum.rb

@@ -19,7 +19,7 @@ module GoonModelGen
 
       # @param pkgs [Packages]
       def resolve(pkgs)
-        @base_type = pkgs.type_for(base_type_name) || raise("#{base_type_name.inspect} not found")
+        @base_type = pkgs.type_for(base_type_name) || raise("#{base_type_name.inspect} not found for #{name}")
       end
     end
   end

data/lib/goon_model_gen/golang/field.rb

@@ -1,5 +1,11 @@
 require "goon_model_gen"
 
+require "goon_model_gen/golang/type"
+require "goon_model_gen/golang/struct"
+require "goon_model_gen/golang/named_slice"
+require "goon_model_gen/golang/builtin"
+require "goon_model_gen/golang/modifier"
+
 module GoonModelGen
   module Golang
     class Field
@@ -37,6 +43,51 @@ module GoonModelGen
           (type.package.path == pkg.path) ? type.name : type.qualified_name
         "#{ name } #{ type_exp } `#{ tags_string }`"
       end
+
+      def ptr?
+        case type
+        when Modifier then (type.prefix == "*")
+        when Type then false
+        else raise "Unsupported type class #{type.inspect}"
+        end
+      end
+
+      def slice?
+        case type
+        when Modifier then (type.prefix == "[]")
+        when NamedSlice then true
+        when Type then false
+        else raise "Unsupported type class #{type.inspect}"
+        end
+      end
+
+      def struct?
+        case type
+        when Modifier then false
+        when Struct then true
+        when Type then false
+        else raise "Unsupported type class #{type.inspect}"
+        end
+      end
+
+      def value_ptr?
+        case type
+        when Modifier then
+          return false unless type.prefix == '*'
+          case type.target
+          when Builtin then type.target.name != 'interface'
+          else false
+          end
+        when Type then false
+        else raise "Unsupported type class #{type.inspect}"
+        end
+      end
+
+      # @param pkg2alias [Hash<String,String>]
+      # @return [string]
+      def short_desc(pkg2alias = nil)
+        "#{name}: #{type.qualified_name(pkg2alias)}"
+      end
     end
   end
 end

data/lib/goon_model_gen/golang/file.rb

@@ -5,14 +5,13 @@ require "goon_model_gen/golang/sentence"
 module GoonModelGen
   module Golang
     class File
-      attr_reader :package, :name
+      attr_reader :name
       attr_reader :sentences
+      attr_accessor :package
       attr_accessor :custom_suffix # false/true
 
-      # @param package [Package]
       # @param name [string]
-      def initialize(package, name)
-        @package = package
+      def initialize(name)
         @name = name
         @sentences = []
       end

data/lib/goon_model_gen/golang/modifier.rb

@@ -27,8 +27,10 @@ module GoonModelGen
         prefix + target.name
       end
 
-      def qualified_name
-        prefix + target.qualified_name
+      # @param pkg2alias [Hash<String,String>]
+      # @return [string]
+      def qualified_name(pkg2alias = nil)
+        prefix + target.qualified_name(pkg2alias)
       end
 
       # @param pkgs [Packages]

data/lib/goon_model_gen/golang/named_slice.rb

@@ -6,18 +6,28 @@ module GoonModelGen
   module Golang
     class NamedSlice < Type
       attr_reader :base_type_name
+      attr_reader :base_type_package_path
       attr_reader :base_type
 
       # @param name [String]
       # @param base_type_name [String]
-      def initialize(name, base_type_name)
+      # @param base_type_package_path [String]
+      def initialize(name, base_type_name, base_type_package_path = nil)
         super(name)
         @base_type_name = base_type_name
+        @base_type_package_path = base_type_package_path
       end
 
       # @param pkgs [Packages]
       def resolve(pkgs)
-        @base_type = pkgs.type_for(base_type_name) || raise("#{base_type_name.inspect} not found")
+        @base_type =
+          base_type_package_path.present? ?
+            pkgs.type_for(base_type_name, base_type_package_path) :
+            pkgs.type_for(base_type_name) || raise("#{base_type_name.inspect} not found")
+      end
+
+      def ptr_slice?
+        base_type.is_a?(GoonModelGen::Golang::Modifier) && (base_type.prefix == '*')
       end
     end
   end

data/lib/goon_model_gen/golang/package.rb

@@ -3,6 +3,7 @@ require "goon_model_gen"
 require "goon_model_gen/golang/struct"
 require "goon_model_gen/golang/enum"
 require "goon_model_gen/golang/named_slice"
+require "goon_model_gen/golang/combination_type"
 require "goon_model_gen/golang/file"
 
 module GoonModelGen
@@ -20,13 +21,25 @@ module GoonModelGen
       end
 
       def basename
-        @basename ||= path ? ::File.basename(path, '.*') : nil
+        @basename ||= (path ? ::File.basename(path, '.*') : nil)
       end
 
       def name
         @name ||= basename ? basename.gsub(/[\-\_]/, '').downcase : nil
       end
 
+      def merge!(other)
+        other.types.each{|t| add(t) unless types.any?{|oldt| oldt.name == t.name }  }
+        other.files.each{|f| add_file(f)  unless files.any?{|oldf| oldf.name == f.name } }
+      end
+
+      # @param file [File]
+      def add_file(file)
+        files.push(file)
+        file.package = self
+      end
+
+      # @param type [Type]
       def add(type)
         types.push(type)
         type.package = self
@@ -45,10 +58,17 @@ module GoonModelGen
       end
 
       # @param name [string]
+      # @param base_type_package_path [String]
       # @param base_type_name [String]
       # @return [Slice]
-      def new_named_slice(name, base_type_name)
-        NamedSlice.new(name, "[]#{base_type_name}").tap{|s| add(s) }
+      def new_named_slice(name, base_type_name, base_type_package_path = nil)
+        NamedSlice.new(name, base_type_name, base_type_package_path).tap{|s| add(s) }
+      end
+
+      # @param name [string]
+      # @return [CombinationType]
+      def new_combination_type(name)
+        CombinationType.new(name).tap{|s| add(s) }
       end
 
       # @param name [string]
@@ -60,8 +80,8 @@ module GoonModelGen
       # @param name [string]
       # @return [File]
       def new_file(name)
-        File.new(self, name).tap do |f|
-          files.push(f)
+        File.new(name).tap do |f|
+          add_file(f)
         end
       end
 

data/lib/goon_model_gen/golang/packages.rb

@@ -9,6 +9,17 @@ module GoonModelGen
   module Golang
     class Packages < Array
 
+      class << self
+        def wrap(obj)
+          case obj
+          when Packages then obj
+          when Package then Packages.new.add(obj)
+          when Array then Packages.new.add(*obj)
+          else raise "Unsupported obj for #{self.name}.wrap #{obj.inspect}"
+          end
+        end
+      end
+
       def name_to_type_map
         each_with_object({}) do |pkg, d|
           d.update(pkg.name_to_type_map)
@@ -20,8 +31,12 @@ module GoonModelGen
       end
 
       def add(*packages)
-        packages.each do |i|
-          self << i
+        packages.flatten.each do |i|
+          if pkg = find_by_path(i.path)
+            pkg.merge!(i)
+          else
+            self << i
+          end
         end
         self
       end
@@ -30,8 +45,20 @@ module GoonModelGen
         Package.new(path).tap{|pkg| add(pkg)}
       end
 
-      def detect_by(basename)
-        detect{|pkg| pkg.basename == basename}
+      def detect_by(name)
+        detect{|pkg| pkg.name == name}
+      end
+
+      def find_by_path(path)
+        detect{|pkg| pkg.path == path}
+      end
+
+      def find_or_new(path)
+        find_by_path(path) || new_package(path)
+      end
+
+      def select_by(name)
+        select{|pkg| pkg.name == name}
       end
 
       def resolve_type_names(extra_packages = [])
@@ -43,25 +70,50 @@ module GoonModelGen
       end
 
       # @param type_name [string]
+      # @param package_path [string]
       # @param [Type]
-      def lookup(type_name)
-        if type_name.include?('.')
-          pkg_name, name = type_name.split('.', 2)
-          pkg = detect_by(pkg_name)
-          return pkg ? pkg.lookup(name) : nil
-        else
-          each do |pkg|
-            t = pkg.lookup(type_name)
-            return t if t
-          end
-          return nil
+      def lookup(type_name, package_path = nil)
+        lookup_by(name: type_name, package_path: package_path)
+      end
+
+      # @param name [String]
+      # @param package_path [String]
+      # @param package_base_path [String]
+      # @param [Type]
+      def lookup_by(name: nil, package_path: nil, package_base_path: nil)
+        pkg_name, type_name = name.include?('.') ? name.split('.', 2) : [nil, name]
+        if package_path.present?
+          pkg = find_by_path(package_path) || raise("Package not found #{package_path.inspect} for type #{name.inspect}")
+          return pkg.lookup(type_name)
+        end
+
+        pkgs =
+          package_base_path.blank? ? self :
+            self.class.wrap(select{|pkg| pkg.path ? pkg.path.include?(package_base_path) : false})
+        if pkg_name.present?
+          pkgs = pkgs.select_by(pkg_name)
+          raise("Package not found #{pkg_name.inspect} for type #{name.inspect}") if pkgs.empty?
+          return self.class.wrap(pkgs).lookup(type_name)
         end
+
+        each do |pkg|
+          t = pkg.lookup(type_name)
+          return t if t
+        end
+        return nil
       end
 
-      def type_for(expression)
+      def type_for(expression, package_path = nil)
         return nil if expression.blank?
         Modifier.parse(expression) do |name|
-          lookup(name)
+          lookup(name, package_path)
+        end
+      end
+
+      def type_by(name: nil, package_path: nil, package_base_path: nil)
+        return nil if name.blank?
+        Modifier.parse(name) do |type_name|
+          lookup_by(name: type_name, package_path: package_path, package_base_path: package_base_path)
         end
       end
     end

data/lib/goon_model_gen/golang/structs_loader.rb

@@ -0,0 +1,67 @@
+require "goon_model_gen"
+
+require "erb"
+require "yaml"
+
+require "goon_model_gen/golang/packages"
+require "goon_model_gen/golang/datastore_supported"
+
+require "active_support/core_ext/string"
+
+module GoonModelGen
+  module Golang
+    class StructsLoader
+
+      # @param path [String]
+      # @return [Hash<String,Packages>]
+      def process(path)
+        erb = ERB.new(::File.read(path), nil, "-")
+        erb.filename = path
+        txt = erb.result
+        raw = YAML.load(txt)
+
+        r = raw.each_with_object({}) do |(key, types), d|
+          d[key] = build_packages(types)
+        end
+
+        whole_packages = Golang::DatastoreSupported.packages.dup
+        r.values.each do |pkgs|
+          whole_packages.add(*pkgs)
+        end
+
+        r.values.each do |pkgs|
+          pkgs.resolve_type_names(whole_packages)
+        end
+        return r
+      end
+
+      def build_packages(types)
+        Packages.new.tap do |pkgs|
+          types.each do |type_hash|
+            next if type_hash['PkgPath'].blank? || type_hash['Name'].blank?
+            pkg = pkgs.find_or_new(type_hash['PkgPath'])
+            if type_hash['Fields']
+              pkg.new_struct(type_hash['Name']).tap do |s|
+                type_hash['Fields'].each do |f|
+                  t = f['Type']
+                  tags = (f['Tag'] || {}).each_with_object({}){|(k,v), d| d[k] = v.split(',')}
+                  s.new_field(f['Name'], t['Representation'], tags)
+                end
+              end
+            elsif type_hash['Kind'] == 'slice'
+              base_type_hash = base_type_hash_from(type_hash['Elem'])
+              pkg.new_named_slice(type_hash['Name'], base_type_hash['Name'], base_type_hash['PkgPath'])
+            else
+              pkg.new_enum(type_hash['Name'], type_hash['Kind'], {})
+            end
+          end
+        end
+      end
+
+      def base_type_hash_from(type_hash)
+        type_hash['Elem'].nil? ? type_hash : base_type_name_from(type_hash['Elem'])
+      end
+
+    end
+  end
+end

data/lib/goon_model_gen/golang/type.rb

@@ -16,10 +16,12 @@ module GoonModelGen
         raise NotImplementedError, "#{self.type.name} doesn't implement resolve method"
       end
 
+      # @param pkg2alias [Hash<String,String>]
       # @return [string]
-      def qualified_name
+      def qualified_name(pkg2alias = nil)
         if package && package.name
-          "#{package.name}.#{name}"
+          pkg_name = (pkg2alias && package.path ? pkg2alias[package.path] : nil) || package.name
+          "#{pkg_name}.#{name}"
         else
           name
         end

data/lib/goon_model_gen/templates/converter/payload/01_base_imports.go.erb

@@ -0,0 +1,11 @@
+<%-
+model = type.map[:model].type
+gen_type = type.map[:gen_type].type
+
+import model.package
+import :gen, gen_type.package
+
+mappings = type.memo['mappings'] || []
+requires_context = mappings.any?(&:requires_context)
+import 'context' if requires_context
+-%>

data/lib/goon_model_gen/templates/converter/payload/02_SliceToModelSlice.go.erb

@@ -0,0 +1,45 @@
+<%-
+import converter_package
+
+model = type.map[:model].type
+gen_type = type.map[:gen_type].type
+mappings = type.memo['mappings'] || []
+requires_context = mappings.any?(&:requires_context)
+arg_def_prefix = requires_context ? 'ctx context.Context, ' : nil
+arg_prefix = requires_context ? 'ctx, ' : nil
+
+model_slice = model.package.types.detect do |t|
+  t.is_a?(GoonModelGen::Golang::NamedSlice) &&
+  (
+    (t.base_type == model) ||
+    (t.ptr_slice? && (t.base_type.target == model))
+  )
+end
+
+if model_slice
+  element_is_ptr = model_slice.ptr_slice?
+  plural_model_type_name = model_slice.qualified_name
+else
+  element_is_ptr =
+    !type.memo['model_slice_with_ptr'].nil? ? type.memo['model_slice_with_ptr'] :
+    model.fields.any?{|f| !f.tags['goon'].nil? }
+  plural_model_type_name = (element_is_ptr ? '[]*' : '[]') + model.qualified_name
+end
+-%>
+
+func <%= gen_type.name %>SliceToModelSlice(<%= arg_def_prefix %>payloads *[]*<%= gen_type.qualified_name(dependencies) %>) (*<%= plural_model_type_name %>, error) {
+	if payloads == nil {
+		return nil, <%= converter_package.name %>.NoPayloadGiven
+	}
+
+  s := <%= plural_model_type_name %>{}
+	for _, payload := range *payloads {
+		m, err := <%= gen_type.name %>ToModel(<%= arg_prefix %>payload)
+		if err != nil {
+			return nil, err
+		}
+		s = append(s, <%= element_is_ptr ? '' : '*' %>m)
+	}
+
+	return &s, nil
+}

data/lib/goon_model_gen/templates/converter/payload/03_ToModel.go.erb

@@ -0,0 +1,21 @@
+<%-
+import converter_package
+
+model = type.map[:model].type
+gen_type = type.map[:gen_type].type
+mappings = type.memo['mappings'] || []
+requires_context = mappings.any?(&:requires_context)
+arg_def_prefix = requires_context ? 'ctx context.Context, ' : nil
+arg_prefix = requires_context ? 'ctx, ' : nil
+-%>
+
+func <%= gen_type.name %>ToModel(<%= arg_def_prefix %>payload *<%= gen_type.qualified_name(dependencies) %>) (*<%= model.qualified_name %>, error) {
+	if payload == nil {
+		return nil, <%= converter_package.name %>.NoPayloadGiven
+	}
+  var m <%= model.qualified_name %>
+  if err := <%= gen_type.name %>AssignModel(<%= arg_prefix %>payload, &m); err != nil {
+    return nil, err
+  }
+  return &m, nil
+}

data/lib/goon_model_gen/templates/converter/payload/04_AssignModel.go.erb

@@ -0,0 +1,90 @@
+<%-
+model = type.map[:model].type
+gen_type = type.map[:gen_type].type
+mappings = type.memo['mappings'] || []
+requires_context = mappings.any?(&:requires_context)
+arg_def_prefix = requires_context ? 'ctx context.Context, ' : nil
+arg_prefix = requires_context ? 'ctx, ' : nil
+-%>
+
+func <%= gen_type.name %>AssignModel(<%= arg_def_prefix %>payload *<%= gen_type.qualified_name(dependencies) %>, m *<%= model.qualified_name %>) error {
+	if payload == nil {
+		return converters.NoPayloadGiven
+	}
+	if m == nil {
+		return converters.NoModelGiven
+	}
+
+<%-
+mappings.each do |mapping|
+  import GoonModelGen::Golang::Packages.wrap(packages).detect_by(mapping.package_name) if mapping.package_name.present?
+
+  mfield = model.fields.detect{|f| f.name == mapping.name} || raise("Field not found #{mapping.name} of #{model.package.path}.#{model.name}")
+  argFields = mapping.args.map do |arg|
+    gen_type.fields.detect{|f| f.name == arg} ||
+      raise("Field not found #{arg.inspect} of #{gen_type.package.path}.#{gen_type.name}")
+  end
+-%>
+  // <%= mfield.short_desc(dependencies) %> <== <%= argFields.map{|f| f.short_desc(dependencies) }.join(', ') %>
+<%- if mapping.args.length == 1 -%>
+<%-
+      pfield = argFields.first
+
+      assignable_condition = nil
+      if pfield.ptr?
+        assignable_condition = "payload.#{ pfield.name } != nil"
+        if !mapping.allow_zero &&  pfield.value_ptr? && pfield.type.target.name =~ /\Aint\z|\Aint8\z|\Aint16\z|\Aint32\z|\Aint64\z|\Auint\z|\Auint8\z|\Auint16\z|\Auint32\z|\Auint64\z/
+          assignable_condition << " && *payload.#{ pfield.name } != 0"
+        end
+      end
+      if mapping.func.nil? || !mapping.returns_error
+        arg = '%spayload.%s' % [pfield.ptr? ? '*' : '', pfield.name]
+        right_side = mapping.func.blank? ? arg :
+          '%s(%s%s)' % [mapping.func, mapping.requires_context ? 'ctx, ' : '', arg]
+-%>
+<%-     if assignable_condition -%>
+  if <%= assignable_condition %> {
+    m.<%= mfield.name %> = <%= right_side %>
+  }
+<%-     else -%>
+  m.<%= mfield.name %> = <%= right_side %>
+<%-     end -%>
+<%-
+      else
+        arg = '%spayload.%s' % [pfield.ptr? ? '*' : pfield.slice? ? '&' :'', pfield.name]
+        right_side = '%s(%s%s)' % [mapping.func, mapping.requires_context ? 'ctx, ' : '', arg]
+-%>
+<%-     if assignable_condition -%>
+  if <%= assignable_condition %> {
+<%-     end -%>
+  if v, err := <%= right_side %>; err != nil {
+    return err
+  } else {
+    m.<%= mfield.name %> = <%= (pfield.slice? || mapping.requires_context)  ? '*' : '' %>v
+  }
+<%-     if assignable_condition -%>
+  }
+<%-     end -%>
+<%-   end -%>
+
+<%- else -%>
+<%-   arg_str = argFields.map{|f| "payload.#{f.name}"}.join(", ") %>
+<%-   if !mapping.returns_error # => requries_context is false -%>
+  m.<%= mfield.name %> = <%= mapping.func %>(<%= arg_str %>)
+<%-   else
+        arg_str = (mapping.requries_context ? 'ctx, ' : '') + arg_str
+-%>
+  if v, err := <%= mapping.func %>(<%= arg_str %>); err != nil {
+    return err
+  } else {
+    m.<%= mfield.name %> = v
+  }
+<%-   end -%>
+
+<%- end -%>
+
+<%-
+end
+-%>
+  return nil
+}

data/lib/goon_model_gen/templates/converter/result/01_base_imports.go.erb

@@ -0,0 +1,18 @@
+<%-
+model = type.map[:model].type
+gen_type = type.map[:gen_type].type
+mappings = type.memo['mappings'] || []
+
+import model.package
+import :gen, gen_type.package
+
+if mappings.any?{|m| m.args.length > 1}
+  raise "Multiple arguments for result type mapping is not supported now"
+end
+if mappings.any?(&:returns_error)
+  raise "returns_error (by writer) for result type mapping is not supported now"
+end
+if mappings.any?(&:requires_context)
+  raise "requires_context (by saver) for result type mapping is not supported now"
+end
+-%>

data/lib/goon_model_gen/templates/converter/result/02_SliceToResultSlice.go.erb

@@ -0,0 +1,33 @@
+<%-
+model = type.map[:model].type
+gen_type = type.map[:gen_type].type
+
+model_slice = model.package.types.detect do |t|
+  t.is_a?(GoonModelGen::Golang::NamedSlice) &&
+  (
+    (t.base_type == model) ||
+    (t.ptr_slice? && (t.base_type.target == model))
+  )
+end
+
+if model_slice
+  element_is_ptr = model_slice.ptr_slice?
+  plural_model_type_name = model_slice.qualified_name
+else
+  element_is_ptr =
+    !type.memo['model_slice_with_ptr'].nil? ? type.memo['model_slice_with_ptr'] :
+    model.fields.any?{|f| !f.tags['goon'].nil? }
+  plural_model_type_name = (element_is_ptr ? '[]*' : '[]') + model.qualified_name
+end
+-%>
+
+func <%= model.name %>SliceToResultSlice(s *<%= plural_model_type_name %>) *[]*<%= gen_type.qualified_name(dependencies) %> {
+  if s == nil {
+    return nil
+  }
+  r := []*<%= gen_type.qualified_name(dependencies) %>{}
+  for _, m := range *s {
+    r = append(r, <%= model.name %>ToResult(<%= element_is_ptr ? '' : '&' %>m))
+  }
+  return &r
+}

data/lib/goon_model_gen/templates/converter/result/03_ToResult.go.erb

@@ -0,0 +1,50 @@
+<%-
+model = type.map[:model].type
+gen_type = type.map[:gen_type].type
+mappings = type.memo['mappings'] || []
+-%>
+
+
+func <%= model.name %>ToResult(m *<%= model.qualified_name %>) *<%= gen_type.qualified_name(dependencies) %> {
+  if m == nil {
+    return nil
+  }
+  r := &<%= gen_type.qualified_name(dependencies) %>{}
+
+<%-
+mappings.each do |mapping|
+  import GoonModelGen::Golang::Packages.wrap(packages).detect_by(mapping.package_name) if mapping.package_name.present?
+
+  rfield = gen_type.fields.detect{|f| f.name == mapping.name} || raise("Field not found #{mapping.name} of #{gen_type.package.path}.#{gen_type.name}")
+  arg_fields = mapping.args.map do |arg|
+    model.fields.detect{|f| f.name == arg} ||
+      raise("Field not found #{arg.inspect} of #{model.package.path}.#{model.name}")
+  end
+-%>
+  // <%= rfield.short_desc(dependencies) %> <== <%= arg_fields.map{|f| f.short_desc(dependencies) }.join(', ') %>
+<%-
+  mfield = arg_fields.first
+  arg = "m.#{mfield.name}"
+  if mfield.struct? || mfield.slice?
+    arg = "&#{arg}"
+    raise "Struct field or Slice field requires func for mapping" if mapping.func.blank?
+  end
+  right_side_main = mapping.func ? "#{mapping.func}(#{arg})" : arg
+  right_side = (rfield.slice? ? '*' : '') + right_side_main
+-%>
+<%- if rfield.value_ptr? -%>
+  {
+    v := <%= right_side_main %>
+    r.<%= rfield.name %> = &v
+  }
+
+<%- else -%>
+  r.<%= rfield.name %> = <%= right_side %>
+
+<%- end -%>
+<%-
+end
+-%>
+
+  return r
+}

data/lib/goon_model_gen/version.rb

@@ -1,3 +1,3 @@
 module GoonModelGen
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goon_model_gen
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - akm
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-08 00:00:00.000000000 Z
+date: 2019-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -144,14 +144,23 @@ files:
 - goon_model_gen.gemspec
 - lib/goon_model_gen.rb
 - lib/goon_model_gen/builder/abstract_builder.rb
+- lib/goon_model_gen/builder/converter_builder.rb
 - lib/goon_model_gen/builder/model_builder.rb
 - lib/goon_model_gen/builder/store_builder.rb
 - lib/goon_model_gen/builder/validation_builder.rb
 - lib/goon_model_gen/cli.rb
 - lib/goon_model_gen/config.rb
+- lib/goon_model_gen/converter/abstract_conv.rb
+- lib/goon_model_gen/converter/conv_file.rb
+- lib/goon_model_gen/converter/loader.rb
+- lib/goon_model_gen/converter/mapping.rb
+- lib/goon_model_gen/converter/payload_conv.rb
+- lib/goon_model_gen/converter/result_conv.rb
+- lib/goon_model_gen/converter/type_ref.rb
 - lib/goon_model_gen/generator.rb
 - lib/goon_model_gen/golang.rb
 - lib/goon_model_gen/golang/builtin.rb
+- lib/goon_model_gen/golang/combination_type.rb
 - lib/goon_model_gen/golang/datastore_supported.rb
 - lib/goon_model_gen/golang/enum.rb
 - lib/goon_model_gen/golang/field.rb
@@ -163,6 +172,7 @@ files:
 - lib/goon_model_gen/golang/predeclared_type.rb
 - lib/goon_model_gen/golang/sentence.rb
 - lib/goon_model_gen/golang/struct.rb
+- lib/goon_model_gen/golang/structs_loader.rb
 - lib/goon_model_gen/golang/type.rb
 - lib/goon_model_gen/source/context.rb
 - lib/goon_model_gen/source/contextual.rb
@@ -173,6 +183,13 @@ files:
 - lib/goon_model_gen/source/named_slice.rb
 - lib/goon_model_gen/source/struct.rb
 - lib/goon_model_gen/source/type.rb
+- lib/goon_model_gen/templates/converter/payload/01_base_imports.go.erb
+- lib/goon_model_gen/templates/converter/payload/02_SliceToModelSlice.go.erb
+- lib/goon_model_gen/templates/converter/payload/03_ToModel.go.erb
+- lib/goon_model_gen/templates/converter/payload/04_AssignModel.go.erb
+- lib/goon_model_gen/templates/converter/result/01_base_imports.go.erb
+- lib/goon_model_gen/templates/converter/result/02_SliceToResultSlice.go.erb
+- lib/goon_model_gen/templates/converter/result/03_ToResult.go.erb
 - lib/goon_model_gen/templates/dsl.rb
 - lib/goon_model_gen/templates/model/enum/01_base.go.erb
 - lib/goon_model_gen/templates/model/enum/02_All.go.erb