goon_model_gen 0.1.0

data/lib/goon_model_gen/golang/packages.rb

@@ -0,0 +1,64 @@
+require "goon_model_gen"
+
+require "goon_model_gen/golang/modifier"
+
+require "active_support/core_ext/string"
+
+module GoonModelGen
+  module Golang
+    class Packages < Array
+
+      def name_to_type_map
+        each_with_object({}) do |pkg, d|
+          d.update(pkg.name_to_type_map)
+        end
+      end
+
+      def dup
+        Packages.new.add(*self)
+      end
+
+      def add(*packages)
+        packages.each do |i|
+          self << i
+        end
+        self
+      end
+
+      def detect_by(basename)
+        detect{|pkg| pkg.basename == basename}
+      end
+
+      def resolve_type_names(extra_packages = [])
+        candidates = dup.add(*extra_packages)
+        map(&:types).flatten.each do |t|
+          t.resolve(candidates)
+        end
+        return self
+      end
+
+      # @param type_name [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
+        end
+      end
+
+      def type_for(expression)
+        return nil if expression.blank?
+        Modifier.parse(expression) do |name|
+          lookup(name)
+        end
+      end
+    end
+  end
+end

data/lib/goon_model_gen/golang/predeclared_type.rb

@@ -0,0 +1,16 @@
+require "goon_model_gen"
+
+require "goon_model_gen/golang/type"
+
+module GoonModelGen
+  module Golang
+    class PredeclaredType < Type
+
+      # @param pkgs [Packages]
+      def resolve(pkgs)
+        # Do nothing
+      end
+
+    end
+  end
+end

data/lib/goon_model_gen/golang/sentence.rb

@@ -0,0 +1,17 @@
+require "goon_model_gen"
+
+module GoonModelGen
+  module Golang
+    class Sentence
+      attr_reader :template_path
+      attr_reader :type
+
+      # @param template_path [string]
+      # @param type [Type]
+      def initialize(template_path, type)
+        @template_path = template_path
+        @type = type
+      end
+    end
+  end
+end

data/lib/goon_model_gen/golang/struct.rb

@@ -0,0 +1,38 @@
+require "goon_model_gen"
+
+require "goon_model_gen/golang/type"
+require "goon_model_gen/golang/field"
+
+module GoonModelGen
+  module Golang
+    class Struct < Type
+      attr_accessor :ref_name
+
+      def fields
+        @fields ||= []
+      end
+
+      # @param name [string]
+      # @param t [Type]
+      # @param tags [Hash<String,Array<String>>]
+      def new_field(name, t, tags, options = {})
+        Field.new(name, t, tags, options).tap do |f|
+          f.struct = self
+          fields.push(f)
+        end
+      end
+
+      def id_field
+        fields.detect(&:goon_id)
+      end
+
+      # @param pkgs [Packages]
+      def resolve(pkgs)
+        fields.each do |f|
+          f.resolve(pkgs)
+        end
+      end
+
+    end
+  end
+end

data/lib/goon_model_gen/golang/type.rb

@@ -0,0 +1,29 @@
+require "goon_model_gen"
+
+module GoonModelGen
+  module Golang
+    class Type
+      attr_reader :name
+      attr_accessor :package
+
+      # @param name [string]
+      def initialize(name)
+        @name = name
+      end
+
+      # @param pkgs [Packages]
+      def resolve(pkgs)
+        raise NotImplementedError, "#{self.type.name} doesn't implement resolve method"
+      end
+
+      # @return [string]
+      def qualified_name
+        if package && package.name
+          "#{package.name}.#{name}"
+        else
+          name
+        end
+      end
+    end
+  end
+end

data/lib/goon_model_gen/model_builder.rb

@@ -0,0 +1,137 @@
+require "goon_model_gen"
+
+require "goon_model_gen/source/context"
+require "goon_model_gen/source/struct"
+require "goon_model_gen/source/enum"
+require "goon_model_gen/source/named_slice"
+
+
+require "goon_model_gen/golang/package"
+require "goon_model_gen/golang/packages"
+require "goon_model_gen/golang/datastore_supported"
+
+require "active_support/core_ext/string"
+
+module GoonModelGen
+  class ModelBuilder
+    attr_reader :base_package_path
+
+    def initialize(base_package_path)
+      @base_package_path = base_package_path
+    end
+
+
+    # @param context [Source::Context]
+    # @return [Golang::Packages]
+    def build(context)
+      Golang::Packages.new.tap do |r|
+        build_sentences = []
+        context.files.each do |f|
+          package_path = File.join(base_package_path, f.basename)
+          pkg, procs = build_package(package_path, f.types)
+          r << pkg
+          build_sentences.concat(procs)
+        end
+        r.resolve_type_names(Golang::DatastoreSupported.packages)
+        build_sentences.each(&:call)
+      end
+    end
+
+    # @param package_path [String]
+    # @param types [Array<Source::Type>]
+    # @return [Golang::Package, Array<Proc>]
+    def build_package(package_path, types)
+      procs = []
+      pkg = Golang::Package.new(package_path).tap do |pkg|
+        types.each do |t|
+          case t
+          when Source::Struct then
+            go_type = build_struct(t, pkg)
+            template = (t.id_name && t.id_type) ? "model/goon" : "model/struct"
+            procs << Proc.new{ build_sentences(template, t, go_type) }
+          when Source::Enum then
+            go_type = pkg.new_enum(t.name, t.base_type, t.map)
+            procs << Proc.new{ build_sentences("model/enum", t, go_type) }
+          when Source::NamedSlice then
+            go_type = pkg.new_named_slice(t.name, t.base_type_name)
+            procs << Proc.new{ build_sentences("model/slice", t, go_type) }
+          else
+            raise "Unsupported type #{t.class.name} #{t.inspect}"
+          end
+        end
+      end
+      return pkg, procs
+    end
+
+    # @param t [Source::Struct]
+    # @param pkg [Golang::Package]
+    # @return [Golang::Struct]
+    def build_struct(t, pkg)
+      pkg.new_struct(t.name).tap do |s|
+        s.ref_name = t.ref_name
+        if t.id_name && t.id_type
+          tags = {
+            'goon' => ['id'],
+            'datastore' => ['-'],
+            'json' => [t.id_name.underscore],
+          }
+          s.new_field(t.id_name, t.id_type, tags, goon_id: true)
+        end
+        t.fields.each do |f|
+          s.new_field(f.name, f.type_name, f.build_tags)
+        end
+      end
+    end
+
+
+    # @param template_base [string]
+    # @param t [Source::Struct]
+    # @param go_type [Golang::Type]
+    def build_sentences(template_base, t, go_type)
+      m2t = method_to_template_for(template_base)
+      t.generators ||= default_generators_for(template_base)
+      t.generators.each do |name, suffix|
+        next if !suffix
+        template = m2t[name]
+        parts = [t.name.underscore]
+        custom_suffix = false
+        if suffix.is_a?(String)
+          parts << suffix
+          custom_suffix = true
+        end
+        filename = parts.join('_') << '.go'
+        go_type.package.find_or_new_file(filename).tap do |file|
+          file.custom_suffix = custom_suffix
+          file.new_sentence(File.join(template_base, template), go_type)
+        end
+      end
+    end
+
+    def default_generators_for(template_base)
+      method_to_template_for(template_base).keys.
+        each_with_object({}){|name, d| d[name] = true }
+    end
+
+    def method_to_template_map
+      @method_to_template_map ||= {}
+    end
+
+    def method_to_template_for(template_base)
+      method_to_template_map[template_base] ||=
+        begin
+          templates_for(template_base).each_with_object({}) do |filename, d|
+            m = filename.sub(/\A\d+\_/, '').sub(/\.go\.erb\z/, '')
+            d[m] = filename
+          end
+        end
+    end
+
+    def templates_for(template_base)
+      base_dir = File.join(File.expand_path('../templates', __FILE__), template_base)
+      Dir.chdir(base_dir) do
+        Dir.glob('*.go.erb')
+      end
+    end
+
+  end
+end

data/lib/goon_model_gen/source/context.rb

@@ -0,0 +1,17 @@
+require "goon_model_gen"
+
+module GoonModelGen
+  module Source
+    class Context
+      attr_reader :files
+
+      def initialize
+        @files = []
+      end
+
+      # @return [nil|Type]
+      def lookup(type_name)
+      end
+    end
+  end
+end

data/lib/goon_model_gen/source/contextual.rb

@@ -0,0 +1,9 @@
+require "goon_model_gen"
+
+module GoonModelGen
+  module Source
+    module Contextual
+      attr_accessor :context
+    end
+  end
+end

data/lib/goon_model_gen/source/enum.rb

@@ -0,0 +1,20 @@
+require "goon_model_gen"
+
+require "goon_model_gen/source/type"
+
+module GoonModelGen
+  module Source
+    class Enum < Type
+      attr_reader :base_type, :map
+
+      # @param name [String]
+      # @param base_type [String]
+      # @param map [Hash<Object,String>]
+      def initialize(name, base_type, map)
+        super(name)
+        @base_type = base_type
+        @map = map
+      end
+    end
+  end
+end

data/lib/goon_model_gen/source/field.rb

@@ -0,0 +1,41 @@
+require "goon_model_gen"
+
+require "goon_model_gen/source/contextual"
+
+module GoonModelGen
+  module Source
+    class Field
+      include Contextual
+
+      attr_reader :name, :type_name
+      attr_reader :required
+      attr_reader :unique
+      attr_reader :tags # Hash<string,Array[string]> ex. for datastore, validate, json, etc...
+
+      # @param name [String]
+      # @param attrs [Hash<string,Object>]
+      def initialize(name, attrs)
+        @name = name
+        @type_name = attrs['type']
+        @required = attrs['required']
+        @unique = attrs['unique']
+        @tags = attrs['tags']
+      end
+
+      def build_tags
+        r = {}
+        (tags || {}).each do |key, val|
+          r[key] = val.is_a?(Array) ? val.dup : [val]
+        end
+        r['json'] ||= [name.underscore]
+        if required
+          r['validate'] ||= []
+          r['validate'] << 'required'
+        else
+          r['json'] << 'omitempty'
+        end
+        return r
+      end
+    end
+  end
+end

data/lib/goon_model_gen/source/file.rb

@@ -0,0 +1,58 @@
+require "goon_model_gen"
+
+require "goon_model_gen/source/contextual"
+require "goon_model_gen/source/struct"
+require "goon_model_gen/source/enum"
+require "goon_model_gen/source/named_slice"
+
+module GoonModelGen
+  module Source
+    class File
+      include Contextual
+
+      attr_reader :path
+      attr_reader :types
+
+      # @param path [string]
+      def initialize(path)
+        @path = path
+        @types = []
+      end
+
+      def basename
+        ::File.basename(path, '.*')
+      end
+
+      # @param name [string]
+      # @return [Struct]
+      def new_struct(name)
+        Struct.new(name).tap do |s|
+          s.context = self.context
+          types.push(s)
+        end
+      end
+
+      # @param name [string]
+      # @param base_type [String]
+      # @param map [Hash<Object,Hash>] elements of enum from YAML
+      # @return [Enum]
+      def new_enum(name, base_type, map)
+        Enum.new(name, base_type, map).tap do |t|
+          t.context = self.context
+          types.push(t)
+        end
+      end
+
+      # @param name [string]
+      # @param base_type_name [string]
+      # @return [Slice]
+      def new_named_slice(name, base_type_name)
+        NamedSlice.new(name, base_type_name).tap do |s|
+          s.context = self.context
+          types.push(s)
+        end
+      end
+
+    end
+  end
+end