dataMetaDom 1.0.0

data/lib/dataMetaDom.rb

@@ -0,0 +1,141 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'set'
+require 'dataMetaDom/util'
+require 'dataMetaDom/recAttr'
+require 'dataMetaDom/dataType'
+require 'dataMetaDom/field'
+require 'dataMetaDom/docs'
+require 'dataMetaDom/enum'
+require 'dataMetaDom/record'
+require 'dataMetaDom/ref'
+require 'dataMetaDom/sourceFile'
+require 'date'
+require 'dataMetaXtra'
+require 'dataMetaDom/sources'
+require 'dataMetaDom/model'
+
+=begin rdoc
+
+DataMeta DOM infrastructure root.
+
+For command line details either check the new method's source or the README.rdoc file, the usage section.
+
+=end
+module DataMetaDom
+
+# Current version
+VERSION = '1.0.0'
+
+=begin rdoc
+Quick and dirty turning a Windows path into a path of the platform on which this script is running.
+Assumes that backslash is never used as a part of a directory name, pretty safe assumption.
+=end
+def uniPath(source)
+    source.gsub(/\\/, File::SEPARATOR)
+end
+
+=begin rdoc
+Returns an array of the namespace and the base, first element nil if no namespace
+both elements nil if not a proper namespace.
+@param [String] source source text to split
+@return [Array] array of +String+, the namespace and the base
+=end
+def splitNameSpace(source)
+    #noinspection RubyNestedTernaryOperatorsInspection
+    source =~ /(\w[\w\.]*)\.(#{TYPE_START}\w*)/ ? [($1.empty? ? nil : $1), $2] :
+            (source =~ /(#{TYPE_START}\w*)/ ? [nil, source] : [nil, nil])
+end
+
+# adjust the namespace if required
+def nsAdjustment(namespace, options, src)
+    src && options[:autoNsVer] ? "#{namespace}.v#{src.ver.full.toVarName}" : namespace
+end
+
+=begin rdoc
+Combines the namespace with the base name: if the namespace is empty or +nil+, returns the base name as a symbol,
+otherwise returns namespace.base
+@param [String] namespace the namespace part
+@param [String] base the base name of the entity
+@return [String] base and namespace properly combined into full name specification
+=end
+def combineNsBase(namespace, base)
+    namespace && !namespace.empty? ? "#{namespace}.#{base}".to_sym : base.to_sym
+end
+
+=begin rdoc
+Given the namespace and the base, returns true if the namespace is a valid one.
+@param [String] namespace the namespace part
+@param [String] base the base name of the entity
+@return [Boolean] true if the given namespace passes simple smell check with the given base
+=end
+def validNs?(namespace, base)
+    namespace && !namespace.empty? && namespace.to_sym != base
+end
+
+=begin rdoc
+if name is a standard type, return it.
+if name is a fully qualified namespaced name, return it
+otherwise, combine the namespace provided with the base to return the full name
+=end
+def fullTypeName(namespace, name)
+    #noinspection RubyUnusedLocalVariable
+    ns, _ = splitNameSpace(name.to_s) # if it is already a full namespaced name or a standard type, return original
+    validNs?(ns, name) || STANDARD_TYPES.member?(name) ? name.to_sym : "#{combineNsBase(namespace, name)}".to_sym
+end
+
+# Returns qualified name for the given namespace: strips the namespace if the namespace is the same, or keep it
+def qualName(namespace, name)
+    ns, b = splitNameSpace(name.to_s)
+    !STANDARD_TYPES.member?(name.to_sym) && (!validNs?(ns, b) || ns == namespace) ? b : name
+end
+
+=begin rdoc
+Simplest diminfo to be reused wherever no other aspect of a datatype is needed
+
+@!attribute [r] len
+    @return [Fixnum] the Length part of the dimension info
+@!attribute [r] scale
+    @return [Fixnum] the Scale part of the dimension info
+
+=end
+class DimInfo
+
+    attr_reader :len, :scale
+
+# Creates an instance with the given parameters
+    def initialize(len, scale); @len = len; @scale = scale end
+
+# Textual representation of this instance, length.scale
+    def to_s; "#{@len}.#{@scale}" end
+
+# Convenience constant - NIL dimension to use in the types that are not dimensioned.
+    NIL=DimInfo.new(nil, nil)
+end
+
+=begin rdoc
+# Parses parenthesized dimension info such as (18, 2) or just (18)
+
+Returns DimInfo::NIL if the dimSpec is +nil+ or the DimInfo instance as specified
+=end
+def getParenDimInfo(dimSpec)
+    return DimInfo::NIL unless dimSpec
+    result = dimSpec =~ /^\s*\(\s*(\d+)\s*(?:,\s*(\d+))?\s*\)\s*$/
+    raise "Invalid dimension specification: '#{dimSpec}'" unless result
+    DimInfo.new($1.to_i, $2.to_i)
+end
+
+=begin rdoc
+Adds options to help and version from the first argument
+And shortcuts to showing the help screen if the ARGV is empty.
+The options for help are either <tt>--help</tt> or </tt>-h</tt>.
+The option for show version and exit is either <tt>--version</tt> or <tt>-v</tt>.
+=end
+def helpAndVerFirstArg
+    raise Trollop::HelpNeeded if ARGV.empty? || ARGV[0] == '--help' || ARGV[0] == '-h' # show help screen
+    raise Trollop::VersionNeeded if ARGV[0] == '--version' || ARGV[0].downcase == '-v' # show version screen
+end
+
+module_function :combineNsBase, :splitNameSpace, :uniPath, :validNs?, :getParenDimInfo,
+                :helpAndVerFirstArg, :fullTypeName, :nsAdjustment
+end

data/test/test_dataMetaDom.rb

@@ -0,0 +1,130 @@
+# keep this underscore naming in the test subdir, it's easier to append files names to test
+require './test/test_helper.rb'
+
+# Unit test cases for the DataMetaDom
+#  See for instance:
+#  - test_full
+class TestNewGem < Test::Unit::TestCase
+
+    # an empty stub for now
+    def setup
+        DataMetaDom::L.level = Logger::DEBUG
+    end
+
+=begin rdoc
+Tests splitting full name without namespace, the base class name only.
+=end
+    def test_splitNameSpaceClassOnly
+        orig = 'ZeeKlass'
+        ns, base = DataMetaDom.splitNameSpace('ZeeKlass')
+        assert_nil(ns, "for the original #{orig}, namespace must be nil")
+        assert_equal(orig, base)
+    end
+
+=begin rdoc
+Helper method to test the given combination of the NS and the Base,
+to vary the parameters and make sure they all work
+=end
+    def splitNameSpaceFullLevelN(origNs, origBase)
+        origFull = DataMetaDom.combineNsBase(origNs, origBase)
+        ns, base = DataMetaDom.splitNameSpace(origFull)
+        assert_equal(origBase, base)
+        assert_equal(origNs, ns)
+        DataMetaDom::L.info "original: #{origNs}.#{origBase}, orig ver=#{origFull}, ns=#{ns}, base=#{base}"
+    end
+
+=begin rdoc
+Uses splitNameSpaceFullLevelN to test 3 levels of namespace nesting.
+=end
+    def test_splitNameSpaceFull
+        %w(Klass ZeeKlass).each { |c|
+            splitNameSpaceFullLevelN('one', c)
+            splitNameSpaceFullLevelN('one.two', c)
+            splitNameSpaceFullLevelN('one.two.three', c)
+        }
+    end
+
+    # Semantic Version Parsing scenarios
+    def test_semVerParsing
+        assert_raise(ArgumentError) { DataMetaDom::SemVer.new('.2.3') }
+        assert_raise(ArgumentError) { DataMetaDom::SemVer.new('1.2.') }
+        assert_raise(ArgumentError) { DataMetaDom::SemVer.new('1a.2.3') }
+        assert_raise(ArgumentError) { DataMetaDom::SemVer.new('1.2a.3') }
+        assert_raise(ArgumentError) { DataMetaDom::SemVer.new('1.2.a3') }
+        assert_raise(ArgumentError) { DataMetaDom::SemVer.new('') }
+        assert_raise(ArgumentError) { DataMetaDom::SemVer.new(nil) }
+        assert_raise(ArgumentError) { DataMetaDom::SemVer.new('-1.2.3') }
+        assert_raise(ArgumentError) { DataMetaDom::SemVer.new('1.-2.3') }
+        assert_raise(ArgumentError) { DataMetaDom::SemVer.new('1.2.-3') }
+
+        assert_true(DataMetaDom::SemVer.new('12.234.456').toVarName == '12_234_456')
+        assert_true(DataMetaDom::SemVer.new('12.234.456.7890').toVarName == '12_234_456_7890')
+        assert_true(DataMetaDom::SemVer.new('12.234.456.7890.blah.yada.meh').toVarName == '12_234_456_7890')
+        
+        v = DataMetaDom::SemVer.new('12.345.6.7')
+        DataMetaDom::L.debug("Parsed: #{fullSemVerInfo(v)}")
+        assertSemVer(v, 12, 345, 6, 7)
+
+        v = DataMetaDom::SemVer.new('12.345.6.7.blah-blah-yada.yada')
+        DataMetaDom::L.debug("Parsed: #{fullSemVerInfo(v)}")
+        assertSemVer(v, 12, 345, 6, 7)
+
+        v = DataMetaDom::SemVer.new('12.345.6')
+        DataMetaDom::L.debug("Parsed: #{fullSemVerInfo(v)}")
+        assertSemVer(v, 12, 345, 6, nil)
+
+        v = DataMetaDom::SemVer.new('12.345.6.blah-blah-yada.yada')
+        DataMetaDom::L.debug("Parsed: #{fullSemVerInfo(v)}")
+        assertSemVer(v, 12, 345, 6, nil)
+
+    end
+
+    # Semantic Version Comparison
+    def test_semVerCmp
+        v1, v2 = DataMetaDom::SemVer.new('5.6.7'), DataMetaDom::SemVer.new('12.15.16')
+        assert_true( (v1.source <=> v2.source) > 0) # stringwise, v1 > v2
+        assert_true( (v1 <=> v2) < 0) # versionwise, v1 < v2
+
+        v1, v2 = DataMetaDom::SemVer.new('5.6.7.8'), DataMetaDom::SemVer.new('5.6.7')
+        assert_true( (v1.source <=> v2.source) > 0)
+        DataMetaDom::L.debug("v1.items=#{v1.items.inspect}, v2.items=#{v2.items.inspect}")
+        assert_true( (v1 <=> v2) > 0)
+
+        v1, v2 = DataMetaDom::SemVer.new('5.6.7'), DataMetaDom::SemVer.new('5.6.7.8')
+        assert_true( (v1.source <=> v2.source) < 0)
+        assert_true( (v1 <=> v2) < 0)
+
+        v1, v2 = DataMetaDom::SemVer.new('5.6.7.3'), DataMetaDom::SemVer.new('5.6.7.12')
+        assert_true( (v1.source <=> v2.source) > 0)
+        assert_true( (v1 <=> v2) < 0)
+
+        v1, v2 = DataMetaDom::SemVer.new('5.6.7.8'), DataMetaDom::SemVer.new('5.6.7.8')
+        assert_true( (v1.source <=> v2.source) == 0)
+        assert_true( (v1 <=> v2) == 0)
+    end
+
+    def test_diffLevel
+        assert_equal(DataMetaDom::SemVer.new('1.2.3').diffLevel(DataMetaDom::SemVer.new('1.2.3.blah')), DataMetaDom::SemVer::DiffLevel::NONE)
+        assert_equal(DataMetaDom::SemVer.new('1.2.3.4').diffLevel(DataMetaDom::SemVer.new('1.2.3.4.blah')), DataMetaDom::SemVer::DiffLevel::NONE)
+        assert_equal(DataMetaDom::SemVer.new('1.2.3').diffLevel(DataMetaDom::SemVer.new('2.2.3.blah')), DataMetaDom::SemVer::DiffLevel::MAJOR)
+        assert_equal(DataMetaDom::SemVer.new('1.2.3').diffLevel(DataMetaDom::SemVer.new('1.4.3.blah')), DataMetaDom::SemVer::DiffLevel::MINOR)
+        assert_equal(DataMetaDom::SemVer.new('1.2.3').diffLevel(DataMetaDom::SemVer.new('1.2.4.blah')), DataMetaDom::SemVer::DiffLevel::UPDATE)
+        assert_equal(DataMetaDom::SemVer.new('1.2.3.4').diffLevel(DataMetaDom::SemVer.new('1.2.3.blah')), DataMetaDom::SemVer::DiffLevel::BUILD)
+        assert_equal(DataMetaDom::SemVer.new('1.2.3').diffLevel(DataMetaDom::SemVer.new('1.2.3.4.blah')), DataMetaDom::SemVer::DiffLevel::BUILD)
+        assert_equal(DataMetaDom::SemVer.new('1.2.3.4').diffLevel(DataMetaDom::SemVer.new('1.2.3.5.blah')), DataMetaDom::SemVer::DiffLevel::BUILD)
+    end
+
+    # Helper method
+    def fullSemVerInfo(semVer)
+       %<#{semVer.to_long_s}: maj=#{semVer.major}, min=#{semVer.minor}, upd=#{semVer.update}, bld=#{semVer.build}>
+    end
+
+    # Helper method
+    def assertSemVer(semVer, maj, min, upd, bld)
+        assert_equal(semVer.major, maj)
+        assert_equal(semVer.minor, min)
+        assert_equal(semVer.update, upd)
+        assert_equal(semVer.build, bld)
+    end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+## keep this underscore naming in the test subdir, it's easier to append files names to test
+%w(stringio test/unit).each { |r| require r }
+# this is expected to run from the project root, normally by the rake file
+require './lib/dataMetaDom'
+require './lib/dataMetaDom/util'
+require './lib/dataMetaDom/ver'

data/tmpl/java/migrationEntityEnums.erb

@@ -0,0 +1,172 @@
+<%#
+    Template for Java POJO migration scenario, includes full migration support for enums too.
+%>
+package <%=javaPackage%>;
+
+/*
+           This class is generated by DataMeta DOM. Do not edit manually!
+*/
+import java.time.ZonedDateTime;
+import org.ebay.datameta.dom.Migrator;
+import java.util.stream.Collectors;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toSet;
+
+<%
+  srcPackage = javaPackage.gsub(".v#{ver2.toVarName}", ".v#{ver1.toVarName}")
+%>
+public class <%=javaClassName%> implements Migrator<<%=srcPackage%>.<%=baseName%>, <%=baseName%>> {
+
+    private static final <%=javaClassName%> INSTANCE = new <%=javaClassName%>();
+
+    public static <%=javaClassName%> getInstance() { return INSTANCE; }
+
+    public <%=baseName%> migrate(<%=srcPackage%>.<%=baseName%> src, Object... xtras) {
+        final <%=baseName%> result = new <%=baseName%>();
+<%
+  srcFldKeys = Set.new srcE.fields.keys
+  trgFldKeys = Set.new trgE.fields.keys
+  added = trgFldKeys - srcFldKeys
+  addedReq = added.select{|k| trgE[k].isRequired}
+  addedOpt = added.reject{|k| trgE[k].isRequired}
+  if addedReq.size > 0
+     migrCtx.canAuto = false%>
+        !!>/* !!> The following <%=addedReq.size%> required field(s) added to this record:
+            !!> <%= addedReq.map{|k| k.to_s}.sort.join(', ') %>
+            !!> you must add some value for those here */
+<%end
+
+  if addedOpt.size > 0%>
+  /*
+    The following <%=addedOpt.size%> optional field(s) added to this record:
+        <%= addedOpt.map{|k| k.to_s}.sort.join(', ') %>
+    no action taken on this.
+  */
+<%  end
+
+  removed = srcFldKeys - trgFldKeys
+  if removed.size > 0%>
+    /*
+    The following <%=removed.size%> field(s) removed from this record:
+    <%= removed.map{|k| k.to_s}.sort.join(', ') %>
+    no action taken on this.
+    */
+<%end
+#  _erbout << "/*\ntrgE.fields.keys: #{trgE.fields.keys.inspect}\n*/\n"
+  trgE.fields.keys.sort.each { |trgK|
+     vars.trgFld = trgE.fields[trgK]
+     vars.trgDType = vars.trgFld.dataType
+     vars.trgType = vars.trgDType.type
+     if vars.trgFld.trgType
+         migrCtx.canAuto = false%>
+        !!> // field "<%=vars.trgFld.name%>" is a map. Maps currently are not supported on serialization level!!<%
+     end
+     vars.srcFld = srcE.fields[trgK]
+#     _erbout << "//trgFld=#{vars.trgFld}, srcFld=#{vars.srcFld}\n"
+     next unless vars.srcFld
+     vars.srcType = flipVer(vars.srcFld.dataType.type, ver2, ver1)
+     if model1.records[vars.srcType] # DataMeta DOM record type
+         fNs, vars.fBase = DataMetaDom.splitNameSpace(vars.trgFld.dataType.type)
+         if vars.trgFld.aggr
+             case vars.trgFld.aggr
+                 when Field::SET
+%>        result.<%=setterName(vars.trgFld)%>(src.<%=getterName(vars.trgFld)%>().stream().map(e -> <%=migrClass(vars.fBase, ver1, ver2)%>.getInstance().migrate(e)).collect(toSet()));
+<%                 when Field::DEQUE
+%>        result.<%=setterName(vars.trgFld)%>(new LinkedList<>(src.<%=getterName(vars.trgFld)%>().stream().map(e -> <%=migrClass(vars.fBase, ver1, ver2)%>.getInstance().migrate(e)).collect(toList())));
+<%               when Field::LIST
+%>        result.<%=setterName(vars.trgFld)%>(new ArrayList<>(src.<%=getterName(vars.trgFld)%>().stream().map(e -> <%=migrClass(vars.fBase, ver1, ver2)%>.getInstance().migrate(e)).collect(toList())));
+<%                 else
+                 raise ArgumentError, %<Unsupported aggregation type "#{vars.trgFld.aggr}" on the field "#{trgK}" of the record>
+             end
+             #result.setEmbeds(new ArrayList<>(src.getEmbeds().stream().map(e -> Migrate_EmbeddedType_v6_to_v7.getInstance().migrate(e)).collect(toList())));
+             #result.setIdLessNess(src.getIdLessNess().stream().map(e -> Migrate_IdLess_v6_to_v7.getInstance().migrate(e)).collect(toSet()));
+         else
+             if vars.srcFld.aggr
+                migrCtx.canAuto = false%>
+              !!> // field "<%=vars.trgFld.name%>" changed from aggregate to scalar, you need to write up custom code for this.
+<%           else%>
+        result.<%=setterName(vars.trgFld)%>(<%=migrClass(vars.fBase, ver1, ver2)%>.getInstance().migrate(src.<%=getterName(vars.trgFld)%>()));
+<%           end
+
+         end
+
+     elsif model1.enums[vars.srcType] # DataMeta enum type
+        unless model2.enums[vars.trgType]
+            migrCtx.canAuto = false%>
+            !!> // field "<%=vars.trgFld.name%>" turned from an enumerable type to a non-enumerable type. Please handle this manually.!!
+<%      end
+        fNs, vars.fBase = DataMetaDom.splitNameSpace(vars.trgFld.dataType.type)
+        e1 = model1.enums[vars.srcType]
+        e2 = model2.enums[vars.trgType]
+        if e2.kind_of?(DataMetaDom::Mappings)
+            migrCtx.canAuto = false%>
+            !! Field "<%=vars.trgFld.name%>" is a mapping. Mappings are not supported on serialization level!!
+<%      elsif e2.kind_of?(DataMetaDom::BitSet)
+            migrCtx.canAuto = false%>
+            !! Field "<%=vars.trgFld.name%>" is a Bit Set. Bit Sets are not supported on serialization level!!
+<%        else
+          if e2.isEqOrXtOf(e1) == :ne
+              migrCtx.canAuto = false%>
+              !!> // Irreconcilable changes in the enum field "<%=vars.trgFld.name%>": list of [<%= e1.rawVals * ', ' %>] to [<%=e2.rawVals * ', '%>]. Please handle this manually.!!
+<%        else%>
+        result.<%=setterName(vars.trgFld)%>(<%=vars.fBase%>.forOrd(src.<%=getterName(vars.trgFld)%>().ordinal()));
+<%        end
+        end
+
+     else # DataMeta DOM standard type
+         vars.srcDType = vars.srcFld.dataType # can go easy on namespaces and such, they don't apply to std types
+         vars.srcType = vars.srcDType.type
+         case vars.trgType
+             when DATETIME
+                 if vars.srcType == DATETIME%>
+        result.<%=setterName(vars.trgFld)%>(src.<%=getterName(vars.trgFld)%>());
+<%               else
+                migrCtx.canAuto = false%>
+                !!> // Field "<%=vars.trgFld.name%>" changed from <%=vars.srcType%> to <%=vars.trgType%> -- please handle this manually!
+<%                end
+             when URL%>
+        result.<%=setterName(vars.trgFld)%>(src.<%=getterName(vars.trgFld)%>());
+<%
+             when BOOL%>
+        result.<%=setterName(vars.trgFld)%>(src.<%=getterName(vars.trgFld)%>());
+<%           when INT
+                 if vars.trgFld.aggr%>
+        //noinspection Convert2MethodRef
+        result.<%=setterName(vars.trgFld)%>(<%=setAggrPrims(vars.trgFld)%>);
+<%               else
+                     if vars.trgDType.length == vars.srcDType.length%>
+        result.<%=setterName(vars.trgFld)%>(src.<%=getterName(vars.trgFld)%>());
+<%                   else%>
+        result.<%=setterName(vars.trgFld)%>(src.<%=getterName(vars.trgFld)%>().<%=primValMethod(vars.trgDType)%>());
+<%                   end
+                end
+             when FLOAT
+                 if vars.trgFld.aggr%>
+        //noinspection Convert2MethodRef
+        result.<%=setterName(vars.trgFld)%>(<%=setAggrPrims(vars.trgFld)%>);
+<%                 else
+                       if vars.trgDType.length == vars.srcDType.length%>
+        result.<%=setterName(vars.trgFld)%>(src.<%=getterName(vars.trgFld)%>());
+<%                     else%>
+        result.<%=setterName(vars.trgFld)%>(src.<%=getterName(vars.trgFld)%>().<%=primValMethod(vars.trgDType)%>());
+<%                     end
+                 end
+             when NUMERIC%>
+        result.<%=setterName(vars.trgFld)%>(src.<%=getterName(vars.trgFld)%>());
+<%           when STRING, CHAR%>
+        result.<%=setterName(vars.trgFld)%>(src.<%=getterName(vars.trgFld)%>());
+<%             else
+                migrCtx.canAuto = false%>
+              !!> // Unsupported data type "<%=vars.trgType%>" on the field "<%=vars.trgFld.name%>". !!
+<%       end
+     end
+  }
+%>
+        return result;
+    }
+}

data/tmpl/python/entity.erb

@@ -0,0 +1,50 @@
+# package <%=@pyPackage%>
+
+
+# ****************** <%=pyClassName%> ***************
+class <%=pyClassName%>(Verifiable):
+    VERSION = SemVer("<%=srcE.ver.full%>")
+    <%=rxRoster.to_patterns%>
+
+    def __init__(self):
+<%	srcE.fields.keys.each { |fieldName|%>
+        self.__<%=fieldName%> = None
+<%}
+%>
+    def getVersion(self):
+        return self.__class__.VERSION
+
+<%	srcE.fields.keys.each { |fieldName|
+    field = srcE.fields[fieldName]%>
+    def <%=getterName(field)%>(self):
+        return self.__<%=fieldName%>
+
+    def <%=setterName(field)%>(self, val):<%    if field.isRequired%>
+        if val is None: raise AttributeError("The \"None\" argument passed to the setter of the required field \"<%=fieldName%>\" on the class <%=srcE.name%>.")<%    end%>
+        self.__<%=fieldName%> = val
+<%}
+%>
+
+    def __eq__(self, other):
+        if not isinstance(other, type(self)): raise AttributeError("Attempt to compare an instance of %s to an instance of %s" % (self.__class__, other.__class__))
+        return (<%=eqHashFields.map{|f| "self.__#{f}"}.join(', ')%>) == (<%=eqHashFields.map{|f| "other._#{pyClassName}__#{f}"}.join(', ')%>)
+<%# the reference to the self.__x vars as instance._ClassName__x has been tested with classes in packages, it works %>
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return (<%=eqHashFields.map{|f| "hash(self.__#{f})"}.join(' ^ ')%> ^ hash((<%=eqHashFields.map{|f| "self.__#{f}"}.join(', ')%>)))
+
+    def verify(self):<%unless verCalls.empty?%>
+        missingFields = []
+        <%=verCalls%>
+        if(len(missingFields) != 0): raise AttributeError("<%=baseName%>: required fields not set: %s" % ", ".join(missingFields))
+<%end%>
+        <%=rxRoster.to_verifications(baseName)%>
+<%=fieldVerifications%>
+
+        return
+
+# -------------- END of <%=pyClassName%> --------------
+

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: dataMetaDom
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Michael Bergens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dataMetaXtra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: typesafe_enum
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.7
+description: DataMeta DOM classes and runnables
+email: michael.bergens@gmail.com
+executables:
+- dataMetaPojo.rb
+- dataMetaMySqlDdl.rb
+- dataMetaSameFullJ.rb
+- dataMetaSameIdJ.rb
+- dataMetaGvExport.rb
+- dataMetaOracleDdl.rb
+- dataMetaReVersion.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- History.md
+- PostInstall.txt
+- README.md
+- Rakefile
+- bin/dataMetaGvExport.rb
+- bin/dataMetaMySqlDdl.rb
+- bin/dataMetaOracleDdl.rb
+- bin/dataMetaPojo.rb
+- bin/dataMetaReVersion.rb
+- bin/dataMetaSameFullJ.rb
+- bin/dataMetaSameIdJ.rb
+- lib/dataMetaDom.rb
+- lib/dataMetaDom/converter.rb
+- lib/dataMetaDom/dataType.rb
+- lib/dataMetaDom/docs.rb
+- lib/dataMetaDom/enum.rb
+- lib/dataMetaDom/field.rb
+- lib/dataMetaDom/help.rb
+- lib/dataMetaDom/model.rb
+- lib/dataMetaDom/mySql.rb
+- lib/dataMetaDom/ora.rb
+- lib/dataMetaDom/pojo.rb
+- lib/dataMetaDom/python.rb
+- lib/dataMetaDom/recAttr.rb
+- lib/dataMetaDom/record.rb
+- lib/dataMetaDom/ref.rb
+- lib/dataMetaDom/sourceFile.rb
+- lib/dataMetaDom/sources.rb
+- lib/dataMetaDom/util.rb
+- lib/dataMetaDom/ver.rb
+- test/test_dataMetaDom.rb
+- test/test_helper.rb
+- tmpl/java/migrationEntityEnums.erb
+- tmpl/python/entity.erb
+homepage: https://github.com/eBayDataMeta
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: DataMeta DOM
+test_files:
+- test/test_dataMetaDom.rb