dataMetaByteSer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d5201ed98a82b4da2ca29379d7318cb3607e920
+  data.tar.gz: edb71acaf79c4111d1a703c9a7044c9a78019fb8
+SHA512:
+  metadata.gz: 4d9edb7888e536f006becb9ce5612ef7573798afb5f136e0b36745021caaebc8c1cfad455815e6c1269a25763f45590a0133200ffc3121ababe839791e7cae7d
+  data.tar.gz: a5358415079756f869e417d783f069ebdf60aafe46c8fb449dd9014af7ef269ff1f683723f9784f3759b83d79c848aa1ab0ff6303675c1b8fa55f647d2c99639

data/.yardopts

@@ -0,0 +1 @@
+--title "DataMeta Bytes (de)serialization" -r README.md --charset UTF-8 lib/**/* - README.md

data/History.md

@@ -0,0 +1,5 @@
+# `dataMetaByteSer` Release history:
+
+## `1.0.0` released `2012-12-17`
+* 1 major enhancement:
+  * Initial release

data/PostInstall.txt

@@ -0,0 +1 @@
+No special steps

data/README.md

@@ -0,0 +1,35 @@
+# `dataMetaByteSer` gem
+
+Byte array (de)serialization generation from [DataMeta DOM](https://github.com/eBayDataMeta/DataMeta-gems) sources.
+
+References to this gem's:
+
+* [Source](https://github.com/eBayDataMeta/DataMeta-gems)
+
+
+## DESCRIPTION:
+
+See the [DataMeta Project](https://github.com/eBayDataMeta/DataMeta)
+
+## FEATURES:
+
+Generates (de)serializers to/from byte arrays with matching Hadoop writables, performance maximized by storage size
+first and runtime performance second, both aspects are clocked to perform around best in the class.
+
+## SYNOPSIS:
+
+To generate Byte Array serializers in Java, including Hadoop Writables for the DataMeta model, run:
+
+    dataMetaByteSerGen.rb <DataMeta DOM source> <Target Directory>
+
+## REQUIREMENTS:
+
+* No special requirements
+
+## INSTALL:
+
+    gem install dataMetaByteSer
+
+## LICENSE:
+
+[Apache v 2.0](https://github.com/eBayDataMeta/DataMeta/blob/master/LICENSE.md)

data/Rakefile

@@ -0,0 +1,13 @@
+%w(yard rdoc/task rake/testtask fileutils ./lib/dataMetaByteSer).each{ |r| require r}
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc 'Regen RDocs'
+task :default => :docs
+
+YARD::Rake::YardocTask.new('docs') {|r|
+    r.stats_options = ['--list-undoc']
+}
+

data/bin/dataMetaByteSerGen.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+%w( dataMetaDom dataMetaByteSer ).each(&method(:require))
+
+@source, @target = ARGV
+DataMetaByteSer::helpDataMetaBytesSerGen __FILE__ unless @source && @target
+DataMetaByteSer::helpDataMetaBytesSerGen(__FILE__, "DataMeta DOM source #{@source} is not a file") unless File.file?(@source)
+DataMetaByteSer::helpDataMetaBytesSerGen(__FILE__, "Writables destination directory #{@target} is not a dir") unless File.directory?(@target)
+
+@parser = DataMetaDom::Model.new
+begin
+    @parser.parse(@source)
+    DataMetaByteSer::genWritables(@parser, @target)
+rescue Exception => e
+   $stderr.puts "ERROR #{e.message}; #{@parser.diagn}"
+   $stderr.puts e.backtrace.inspect
+end

data/lib/dataMetaByteSer/python.rb

@@ -0,0 +1,387 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'fileutils'
+require 'dataMetaDom'
+require 'dataMetaDom/util'
+require 'dataMetaDom/python'
+require 'dataMetaByteSer/util'
+
+module DataMetaByteSer
+# (De)Serialization for Python
+module Py
+    include DataMetaDom, DataMetaDom::PythonLexer, DataMetaByteSer
+=begin rdoc
+Builds a class name for a Writable.
+=end
+    def writableClassName(baseName); "#{baseName}_Writable" end
+=begin rdoc
+Builds a class name for a InOutable.
+=end
+    def inOutablePy(arg)
+        klassName = case
+                        when arg.kind_of?(String)
+                            arg
+                        else
+                            _, s = DataMetaDom.splitNameSpace(arg.fType.type)
+                            s
+                    end
+        "#{klassName}_InOutable"
+    end
+
+    def mapsNotSupported(fld)
+        raise ArgumentError, "Field #{fld.name}: maps are not currently supported on Hadoop layer"
+    end
+
+    def aggrNotSupported(fld, forWhat)
+        raise ArgumentError, "Field #{fld.name}: aggregate types are not supported for #{forWhat} on Hadoop layer"
+    end
+
+=begin rdoc
+HDFS Reader and Writer for textual Python types such as str.
+=end
+    TEXT_RW_METHODS = DataMetaByteSer::RwHolder.new(
+            lambda{|ctx|
+                ctx.fld.aggr ? ctx.rw.call("DataMetaHadoopUtil.read#{aggrPyFull(ctx.fld.aggr)}String(di)") : ctx.rw.call('DataMetaHadoopUtil.readText(di)')
+            },
+            lambda{|ctx|
+                ctx.fld.aggr ? "DataMetaHadoopUtil.write#{aggrPyFull(ctx.fld.aggr)}String(do, val.#{ctx.valGetter})" : "DataMetaHadoopUtil.writeTextIfAny(do, val.#{ctx.valGetter})"
+            }
+    )
+
+=begin rdoc
+HDFS Reader and Writer for integral Python type.
+=end
+        INTEGRAL_RW_METHODS = RwHolder.new(
+                lambda{ |ctx|
+                    mapsNotSupported(ctx.fld) if ctx.fld.trgType # map
+                    case
+                        when ctx.fType.length <= 4; ctx.fld.aggr ? ctx.rw.call("DataMetaHadoopUtil.read#{aggrPyFull(ctx.fld.aggr)}Integer(di)") :
+                                ctx.rw.call('WritableUtils.readVInt(di)')
+
+                        when ctx.fType.length <= 8; ; ctx.fld.aggr ? ctx.rw.call("DataMetaHadoopUtil.read#{aggrPyFull(ctx.fld.aggr)}Long(di)") : ctx.rw.call('WritableUtils.readVLong(di)')
+
+                        else; raise "Invalid integer field #{ctx.fld}"
+                    end
+                },
+                lambda{ |ctx|
+                    case
+                        when ctx.fType.length <= 4; ctx.fld.aggr ? "DataMetaHadoopUtil.write#{aggrPyFull(ctx.fld.aggr)}Integer(do, val.#{ctx.valGetter})" :
+                                "WritableUtils.writeVInt(do, val.#{ctx.valGetter})"
+
+                        when ctx.fType.length <= 8;  ctx.fld.aggr ? "DataMetaHadoopUtil.write#{aggrPyFull(ctx.fld.aggr)}Long(do, val.#{ctx.valGetter})" : "WritableUtils.writeVLong(do, val.#{ctx.valGetter})"
+
+                        else; raise "Invalid integer field #{ctx.fld}"
+                    end
+                })
+
+=begin rdoc
+HDFS Reader and Writer for Booleans.
+=end
+    BOOLEAN_RW_METHODS = RwHolder.new(
+            lambda{|ctx|
+                mapsNotSupported(ctx.fld) if ctx.fld.trgType # map
+                ctx.fld.aggr ? ctx.rw.call("DataMetaHadoopUtil.read#{aggrPyFull(ctx.fld.aggr)}Boolean(di)") : ctx.rw.call('di.readBoolean()')
+            },
+            lambda{|ctx|
+                mapsNotSupported(ctx.fld) if ctx.fld.trgType # map
+                ctx.fld.aggr ? "DataMetaHadoopUtil.write#{aggrPyFull(ctx.fld.aggr)}Boolean(do, val.#{ctx.valGetter})" : "do.writeBoolean(val.#{ctx.valGetter})"
+            })
+
+    # Python has no primitivable types
+    PRIMITIVABLE_TYPES = Set.new
+
+=begin rdoc
+HDFS Reader and Writer for floating point types.
+=end
+        FLOAT_RW_METHODS = RwHolder.new(
+                lambda{|ctx|
+                    mapsNotSupported(ctx.fld) if ctx.fld.trgType # map
+                    case
+                        when ctx.fType.length <= 4; ctx.fld.aggr ? ctx.rw.call("DataMetaHadoopUtil.read#{aggrPyFull(ctx.fld.aggr)}Float(di)") : ctx.rw.call('di.readFloat()')
+                        when ctx.fType.length <= 8; ctx.fld.aggr ? ctx.rw.call("DataMetaHadoopUtil.read#{aggrPyFull(ctx.fld.aggr)}Double(di)") : ctx.rw.call('di.readDouble()')
+                        else; raise "Invalid float field #{ctx.fld}"
+                    end
+                },
+                lambda{|ctx|
+                    mapsNotSupported(ctx.fld) if ctx.fld.trgType # map
+                    case
+                        when ctx.fType.length <= 4; ctx.fld.aggr ? "DataMetaHadoopUtil.write#{aggrPyFull(ctx.fld.aggr)}Float(do, val.#{ctx.valGetter})" : "do.writeFloat(val.#{ctx.valGetter})"
+                        when ctx.fType.length <= 8; ctx.fld.aggr ? "DataMetaHadoopUtil.write#{aggrPyFull(ctx.fld.aggr)}Double(do, val.#{ctx.valGetter})" : "do.writeDouble(val.#{ctx.valGetter})"
+                        else; raise "Invalid float field #{ctx.fld}"
+                    end
+                })
+
+=begin rdoc
+HDFS Reader and Writer for the temporal type, the DateTime
+=end
+        DTTM_RW_METHODS = RwHolder.new(
+                lambda { |ctx|
+                    ctx.fld.aggr ? ctx.rw.call("DataMetaHadoopUtil.read#{aggrPyFull(ctx.fld.aggr)}DateTime(di)") : ctx.rw.call('DataMetaHadoopUtil.readDttm(di)')
+                },
+                lambda { |ctx|
+                    ctx.fld.aggr ? "DataMetaHadoopUtil.write#{aggrPyFull(ctx.fld.aggr)}DateTime(do, val.#{ctx.valGetter})" : "DataMetaHadoopUtil.writeDttm(do, val.#{ctx.valGetter})"
+                }
+        )
+=begin rdoc
+HDFS Reader and Writer the variable size Decimal data type.
+=end
+        NUMERIC_RW_METHODS = RwHolder.new(lambda{|ctx| ctx.fld.aggr ? ctx.rw.call("DataMetaHadoopUtil.read#{aggrPyFull(ctx.fld.aggr)}BigDecimal(di)") : ctx.rw.call('DataMetaHadoopUtil.readBigDecimal(di)')},
+                                          lambda{|ctx| "DataMetaHadoopUtil.writeBigDecimal(do, val.#{ctx.valGetter})"})
+
+# Full name of a Py aggregate for the given DataMeta DOM aggregate
+    def aggrPyFull(aggr)
+        case aggr
+            when DataMetaDom::Field::LIST
+                'List'
+            when DataMetaDom::Field::SET
+                'Set'
+            when DataMetaDom::Field::DEQUE
+                'Deque' # note this is different from Java
+            else
+                raise ArgumentError, "Aggregate type #{aggr} not supported for Python serialization"
+        end
+    end
+
+=begin rdoc
+HDFS Reader and Writer the Java Enums.
+=end
+        ENUM_RW_METHODS = RwHolder.new(
+                lambda{|ctx|
+                    aggrNotSupported(ctx.fld, 'Enums') if ctx.fld.aggr
+                    _, s = DataMetaDom.splitNameSpace(ctx.fType.type)
+                    "#{s}(WritableUtils.readVInt(di) + 1)" # Python starts their enums from 1 - we save it starting from 0
+                    # as Java and Scala does
+                },
+                lambda { |ctx|
+                    aggrNotSupported(ctx.fld, 'Enums') if ctx.fld.aggr
+                    # Python starts their enums from 1 - we save it starting from 0 as Java and Scala
+                    "WritableUtils.writeVInt(do, val.#{ctx.valGetter}.value - 1)"
+                }
+        )
+=begin rdoc
+HDFS Reader and Writer the URL.
+=end
+        URL_RW_METHODS = RwHolder.new(
+                lambda { |ctx|
+                    aggrNotSupported(ctx.fld, 'URLs') if ctx.fld.aggr
+                    'DataMetaHadoopUtil.readText(di)'
+                },
+                lambda { |ctx|
+                    aggrNotSupported(ctx.fld, 'URLs') if ctx.fld.aggr
+                    "DataMetaHadoopUtil.writeTextIfAny(do, val.#{ctx.valGetter})"
+                }
+        )
+# Pseudo-implementers that just raise an error
+    NOT_IMPLEMENTED_METHODS = RwHolder.new(
+            lambda { |ctx|
+                aggrNotSupported(ctx.fld, 'Serialization')
+            },
+            lambda { |ctx|
+                aggrNotSupported(ctx.fld, 'Serialization')
+            }
+    )
+=begin rdoc
+Read/write methods for the standard data types.
+=end
+        STD_RW_METHODS = {
+                DataMetaDom::INT => INTEGRAL_RW_METHODS,
+                DataMetaDom::STRING => TEXT_RW_METHODS,
+                DataMetaDom::DATETIME => DTTM_RW_METHODS,
+                DataMetaDom::BOOL => BOOLEAN_RW_METHODS,
+                DataMetaDom::CHAR => TEXT_RW_METHODS,
+                DataMetaDom::FLOAT => FLOAT_RW_METHODS,
+                DataMetaDom::RAW => NOT_IMPLEMENTED_METHODS,
+                DataMetaDom::NUMERIC => NUMERIC_RW_METHODS,
+                DataMetaDom::URL => URL_RW_METHODS
+        }
+# DataMeta DOM object renderer
+        RECORD_RW_METHODS = RwHolder.new(
+                lambda { |ctx|
+                    if ctx.fld.aggr
+                        if ctx.fld.trgType # map
+                            mapsNotSupported(ctx.fld)
+                        else  # list, set or deque
+                            "DataMetaHadoopUtil.read#{aggrPyFull(ctx.fld.aggr)}(di, #{
+                            inOutablePy(ctx)}())"
+                        end
+                    else # scalar
+                        "#{inOutablePy(ctx)}().read(di)"
+                    end
+                },
+                lambda { |ctx|
+                    if ctx.fld.aggr && !ctx.fld.trgType
+                        if ctx.fld.trgType # map
+                            mapsNotSupported(ctx.fld)
+                        else  # list, set or deque
+                            "DataMetaHadoopUtil.writeCollection(val.#{ctx.valGetter}, do, #{inOutablePy(ctx)}())"
+                        end
+                    else # scalar
+                        "#{inOutablePy(ctx)}().write(do, val.#{ctx.valGetter})"
+                    end
+                }
+        )
+=begin rdoc
+Read/write methods for the DataMeta DOM Maps, accidentally all the same as for the standard data types.
+=end
+        MAP_RW_METHODS = STD_RW_METHODS
+
+# Build the Read/Write operation renderer for the given context:
+        def getRwRenderer(ctx)
+            dt = ctx.fld.dataType
+            ctx.refType = nil # reset to avoid misrendering primitives
+            rwRenderer = STD_RW_METHODS[dt.type]
+            return rwRenderer if rwRenderer
+            refKey = dt.type
+            ctx.refType = ctx.model.enums[refKey] || ctx.model.records[refKey]
+            case
+                when ctx.refType.kind_of?(DataMetaDom::Record)
+                    RECORD_RW_METHODS
+                when ctx.refType.kind_of?(DataMetaDom::Enum)
+                    ENUM_RW_METHODS
+                when ctx.refType.kind_of?(DataMetaDom::BitSet)
+                    NOT_IMPLEMENTED_METHODS
+                when ctx.refType.kind_of?(DataMetaDom::Mapping)
+                    MAP_RW_METHODS[ctx.fType.type] || (raise ArgumentError, "No renderer found for the key type #{
+                    ctx.fType.type}, record #{ctx.rec}, field #{ctx.fld}")
+                else
+                    raise "No renderer defined for field #{ctx.fld}"
+            end
+        end
+
+# Generates one InOutable, Writables here currently are not generated
+        def genWritable(model, wriOut, ioOut, record, pyPackage, baseName)
+            enumCount = model.enums.values.select{|e| e.kind_of?(DataMetaDom::Enum)}.size
+            recImports = model.records.values.map{|r| # import all records
+                p, b, pp = DataMetaDom::PojoLexer::assertNamespace(r.name)
+                %|from #{DataMetaXtra::Str.downCaseFirst(b)} import #{b}|
+            }.join("\n")
+#             ioImports = model.records.values.reject{|r| r.name == record.name}.map{|r| # import all InOutables except of this one
+#                 p, b, pp = DataMetaDom::PojoLexer::assertNamespace(r.name)
+#                 # since one InOutable may import another which may import another, and Python can't handle this,
+#                 # catch the error. It's harmless because if it really failed to import, we'll know
+#                 %|
+# try:
+#     from #{inOutablePy(DataMetaXtra::Str.downCaseFirst(b))} import #{inOutablePy(b)}
+# except ImportError:
+#     pass|
+#             }.join("\n")
+            ctx = RendCtx.new.init(model, record, pyPackage, baseName)
+            fields = record.fields
+            wriName = nil # writableClassName(baseName)
+            ioName = inOutablePy(baseName)
+            hasOptional = fields.values.map{|f|
+#      !model.records[f.dataType.type] &&
+                !f.isRequired
+            }.reduce(:|) # true if there is at least one optional field which isn't a record
+            keysInOrder = fields.each_key.map{|k| k.to_s}.sort.map{|k| k.to_sym}
+            reads = ''
+            writes = ''
+            writeNullMaskHead = hasOptional ? "nullFlags = bitarray(#{fields.keys.size}); nullFlags.setall(False); fldIndex = -1" : ''
+            readNullMaskHead = hasOptional ? 'nullFlags = DataMetaHadoopUtil.readBitArray(di); fldIndex = -1' : ''
+            indent = "\n#{' ' * 8}"
+            # sorting provides predictable read/write order
+            keysInOrder.each { |k|
+                f = fields[k]
+                ctx.fld = f
+                rwRenderer = getRwRenderer(ctx)
+                reads <<  ( indent + (f.isRequired ? '' : "fldIndex += 1#{indent}") + "val.#{DataMetaDom.setterName(ctx.fld)}(" +
+                        (f.isRequired ? '' : ' None if nullFlags[fldIndex] else ')+ "#{rwRenderer.r.call(ctx)})"
+                )
+                # noinspection RubyNestedTernaryOperatorsInspection
+                writes << (indent + (f.isRequired ?
+                        (PRIMITIVABLE_TYPES.member?(f.dataType.type) ? '' : ''):
+#%Q<if(val.#{DataMetaDom::PojoLexer::getterName(ctx.fld)}() == null) throw noReqFld("#{f.name}"); >) :
+                        "if(val.#{DataMetaDom.getterName(ctx.fld)}() is not None): ") + "#{rwRenderer.w.call(ctx)}")
+                unless f.isRequired
+                    writeNullMaskHead << (indent + "fldIndex += 1#{indent}if(val.#{DataMetaDom.getterName(ctx.fld)}() is None): nullFlags[fldIndex] = True")
+                end
+            }
+            writeNullMaskHead << ( indent + 'DataMetaHadoopUtil.writeBitArray(do, nullFlags)') if hasOptional
+
+            ioOut.puts <<IN_OUTABLE_CLASS
+
+class #{ioName}(InOutable):
+
+    def write(self, do, val):
+        val.verify()
+        #{writeNullMaskHead}
+        #{writes}
+
+    def readVal(self, di, val):
+        #{readNullMaskHead}
+        #{reads}
+        return val
+
+    def read(self, di):
+        return self.readVal(di, #{baseName}())
+
+IN_OUTABLE_CLASS
+        end
+
+=begin rdoc
+Generates all the writables for the given model.
+Parameters:
+* +model+ - the model to generate Writables from.
+* +outRoot+ - destination directory name.
+=end
+        def genWritables(model, outRoot)
+            firstRecord = model.records.values.first
+            pyPackage, base, packagePath = DataMetaDom::PojoLexer::assertNamespace(firstRecord.name)
+            # Next: replace dots with underscores.The path also adjusted accordingly.
+            #
+            # Rationale for this, quoting PEP 8:
+            #
+            #    Package and Module Names
+            #
+            #    Modules should have short, all-lowercase names. Underscores can be used in the module name if it improves
+            #    readability. Python packages should also have short, all-lowercase names, although the use of underscores
+            #    is discouraged.
+            #
+            # Short and all-lowercase names, and improving readability if you have complex system and need long package names,
+            # is "discouraged". Can't do this here, our system is more complicated for strictly religous, "pythonic" Python.
+            # A tool must be enabling, and in this case, this irrational ruling gets in the way.
+            # And dots are a no-no, Python can't find packages with complicated package structures and imports.
+            #
+            # Hence, we opt for long package names with underscores for distinctiveness and readability:
+            pyPackage = pyPackage.gsub('.', '_')
+            packagePath = packagePath.gsub('/', '_')
+            destDir = File.join(outRoot, packagePath)
+            FileUtils.mkdir_p destDir
+            wriOut = nil # File.open(File.join(destDir, "#{writableClassName(base)}.py"), 'wb')
+            serFile = File.join(destDir, 'serial.py')
+            FileUtils.rm serFile if File.file?(serFile)
+            ioOut = File.open(serFile, 'wb') # one huge serialization file
+            ioOut.puts %|# This file is generated by DataMeta DOM. Do not edit manually!
+#package #{pyPackage}
+
+from hadoop.io import WritableUtils, InputStream, OutputStream, Text
+from ebay_datameta_core.base import DateTime
+from decimal import *
+from collections import *
+from bitarray import bitarray
+from ebay_datameta_hadoop.base import *
+from model import *
+
+|
+            begin
+                model.records.values.each { |e|
+                        _, base, _ = DataMetaDom::PojoLexer::assertNamespace(e.name)
+                        case
+                            when e.kind_of?(DataMetaDom::Record)
+                                genWritable model, wriOut, ioOut, e, pyPackage, base
+                            else
+                                raise "Unsupported Entity: #{e.inspect}"
+                        end
+                }
+            ensure
+                begin
+                    ioOut.close
+                ensure
+                    #wriOut.close
+                end
+            end
+        end
+        module_function :genWritables, :genWritable, :inOutablePy, :writableClassName, :mapsNotSupported,
+            :aggrNotSupported, :getRwRenderer, :aggrPyFull
+end
+end

data/lib/dataMetaByteSer/util.rb

@@ -0,0 +1,138 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'set'
+require 'logger'
+
+module DataMetaByteSer
+
+=begin rdoc
+A holder for a read renderer and a write renderer, those come in pairs that have to be consistent so the
+data is read and written uniformly.
+=end
+    class RwHolder
+=begin rdoc
+Read renderer.
+=end
+        attr_reader :r
+=begin rdoc
+Write renderer.
+=end
+        attr_reader :w
+=begin rdoc
+Creates a new HDFS Reade and Write renderers pair.
+=end
+        def initialize(readRenderer, writeRenderer); @r = readRenderer; @w = writeRenderer end
+    end
+
+=begin rdoc
+Rendering context with rendering-related properties and settings.
+=end
+    class RendCtx
+
+=begin rdoc
+DataMeta DOM Model on the context.
+=end
+        attr_accessor :model
+=begin rdoc
+Record currently worked on.
+=end
+        attr_accessor :rec
+
+=begin rdoc
+Set of imports if any, each as symbol.
+=end
+        attr_accessor :imps
+
+=begin rdoc
+Java package.
+=end
+        attr_accessor :pckg
+=begin rdoc
+Base name of the type, without a namespace.
+=end
+        attr_accessor :baseName
+=begin rdoc
+The data type of the entity on the context.
+=end
+        attr_accessor :refType
+=begin rdoc
+Field currently on the context.
+=end
+        attr_reader :fld
+
+=begin rdoc
+Creates a new context.
+=end
+        def initialize; @imps = Set.new end
+
+=begin rdoc
+Setter for the field on the context, the field currently worked on.
+=end
+        def fld=(val); @fld = val end
+
+=begin rdoc
+Initialize the context with the model, the record, the package and the basename.
+Returns self for call chaining.
+=end
+        def init(model, rec, pckg, baseName); @model = model; @rec = rec; @pckg = pckg; @baseName = baseName; self end
+
+=begin rdoc
+Add an import to the context, returns self for call chaining.
+=end
+        def <<(import)
+            @imps << import.to_sym if import
+            self
+        end
+
+=begin rdoc
+Formats imports into Java source, sorted.
+=end
+        def importsText
+            @imps.to_a.map{|k| "import #{k};"}.sort.join("\n")
+        end
+
+=begin rdoc
+Determines if the refType is a DataMetaDom::Mapping.
+=end
+        def isMapping
+            @refType.kind_of?(DataMetaDom::Mapping) && !@refType.kind_of?(DataMetaDom::BitSet)
+        end
+
+# Effective field type
+        def fType
+            isMapping ? @refType.fromT : @fld.dataType
+        end
+
+# Readwrap
+        def rw
+            isMapping ? lambda{|t| "new #{condenseType(@fld.dataType.type, self)}(#{t})"} : lambda{|t| t}
+        end
+
+=begin rdoc
+Getter name for the current field, if the type is Mapping, includes <tt>.getKey()</tt> too.
+=end
+        def valGetter
+            "#{DataMetaDom.getterName(@fld)}()" + ( isMapping ? '.getKey()' : '')
+        end
+    end # RendCtx
+
+=begin rdoc
+Builds a class name for a Writable.
+=end
+    def writableClassName(baseName); "#{baseName}_Writable" end
+
+=begin rdoc
+Builds a class name for a InOutable.
+=end
+    def inOutableClassName(baseName); "#{baseName}_InOutable" end
+
+    def mapsNotSupported(fld)
+        raise ArgumentError, "Field #{fld.name}: maps are not currently supported on Hadoop layer"
+    end
+
+    def aggrNotSupported(fld, forWhat)
+        raise ArgumentError, "Field #{fld.name}: aggregate types are not supported for #{forWhat} on Hadoop layer"
+    end
+
+    module_function :writableClassName, :inOutableClassName, :mapsNotSupported, :aggrNotSupported
+end

data/lib/dataMetaByteSer/ver_reads.rb

@@ -0,0 +1,49 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'dataMetaDom/field'
+require 'dataMetaDom/pojo'
+
+module DataMetaByteSer
+=begin rdoc
+Migration tooling.
+
+=end
+module VerReads
+    include DataMetaDom, DataMetaDom::PojoLexer
+=begin
+Generates Versioned Read switch that channels the read to the proper migration scenario.
+=end
+    def genVerReadSwitch(v1, v2, modelForVer, vers, outRoot)
+#        v1 = mo1.records.values.first.ver.full
+#        v2 = mo2.records.values.first.ver.full
+        mo1 = modelForVer.call(v1)
+        mo2 = modelForVer.call(v2)
+        destDir = outRoot
+        javaPackage = '' # set the scope for the var
+        vars = OpenStruct.new # for template's local variables. ERB does not make them visible to the binding
+        # sort the models by versions out, 2nd to be the latest:
+        raise ArgumentError, "Versions on the model are the same: #{v1}" if v1 == v2
+        if v1 > v2
+            model2 = mo1
+            model1 = mo2
+            ver1 = v2
+            ver2 = v1
+        else
+            model2 = mo2
+            model1 = mo1
+            ver1 = v1
+            ver2 = v2
+        end
+        puts "Going from ver #{ver1} to #{ver2}"
+        trgE = model2.records.values.first
+        javaPackage, baseName, packagePath = assertNamespace(trgE.name)
+        javaClassName = "Read__Switch_v#{ver1.toVarName}_to_v#{ver2.toVarName}"
+        destDir = File.join(outRoot, packagePath)
+        FileUtils.mkdir_p destDir
+        IO::write(File.join(destDir, "#{javaClassName}.java"),
+                  ERB.new(IO.read(File.join(File.dirname(__FILE__), '../../tmpl/readSwitch.erb')),
+                          $SAFE, '%<>').result(binding), mode: 'wb')
+    end
+    module_function :genVerReadSwitch
+end
+end

data/lib/dataMetaByteSer.rb

@@ -0,0 +1,391 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+# Definition for generating Plain Old Java Objects (POJOs)
+%w(fileutils dataMetaDom dataMetaDom/pojo dataMetaDom/enum dataMetaDom/record dataMetaDom/help).each(&method(:require))
+require 'set'
+require 'dataMetaByteSer/util'
+
+=begin rdoc
+Serialization artifacts generation such as Hadoop Writables etc.
+
+TODO this isn't a bad way, but beter use templating next time such as {ERB}[http://ruby-doc.org/stdlib-1.9.3/libdoc/erb/rdoc/ERB.html].
+
+For command line details either check the new method's source or the README.rdoc file, the usage section.
+=end
+module DataMetaByteSer
+    # Current version
+    VERSION = '1.0.0'
+    include DataMetaDom, DataMetaDom::PojoLexer
+
+=begin rdoc
+HDFS Reader and Writer for textual Java types such as String.
+=end
+    TEXT_RW_METHODS = RwHolder.new(
+            lambda{|ctx|
+                ctx.fld.aggr ? ctx.rw.call("read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}String(in)") : ctx.rw.call('readText(in)')
+            },
+            lambda{|ctx|
+                 ctx.fld.aggr ? "write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}String(out, val.#{ctx.valGetter})" : "writeTextIfAny(out, val.#{ctx.valGetter})"
+            }
+    )
+
+=begin rdoc
+HDFS Reader and Writer for integral Java types such as Integer or Long.
+=end
+    INTEGRAL_RW_METHODS = RwHolder.new(
+                lambda{ |ctx|
+                    mapsNotSupported(ctx.fld) if ctx.fld.trgType # map
+                    case
+                        when ctx.fType.length <= 4; ctx.fld.aggr ? ctx.rw.call("read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Integer(in)") :
+                                ctx.rw.call('readVInt(in)')
+
+                        when ctx.fType.length <= 8; ; ctx.fld.aggr ? ctx.rw.call("read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Long(in)") : ctx.rw.call('readVLong(in)')
+
+                        else; raise "Invalid integer field #{ctx.fld}"
+                    end
+                  },
+                lambda{ |ctx|
+                  case
+                      when ctx.fType.length <= 4; ctx.fld.aggr ? "write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Integer(out, val.#{ctx.valGetter})" :
+                              "writeVInt(out, val.#{ctx.valGetter})"
+
+                      when ctx.fType.length <= 8;  ctx.fld.aggr ? "write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Long(out, val.#{ctx.valGetter})" : "writeVLong(out, val.#{ctx.valGetter})"
+
+                      else; raise "Invalid integer field #{ctx.fld}"
+                  end
+                })
+
+=begin rdoc
+HDFS Reader and Writer for floating point Java types such as Float or Double.
+=end
+    FLOAT_RW_METHODS = RwHolder.new(
+                lambda{|ctx|
+                    mapsNotSupported(ctx.fld) if ctx.fld.trgType # map
+                    case
+                      when ctx.fType.length <= 4; ctx.fld.aggr ? ctx.rw.call("read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Float(in)") : ctx.rw.call('in.readFloat()')
+                      when ctx.fType.length <= 8; ctx.fld.aggr ? ctx.rw.call("read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Double(in)") : ctx.rw.call('in.readDouble()')
+                      else; raise "Invalid float field #{ctx.fld}"
+                    end
+                  },
+                lambda{|ctx|
+                    case
+                      when ctx.fType.length <= 4; ctx.fld.aggr ? "write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Float(out, val.#{ctx.valGetter})" : "out.writeFloat(val.#{ctx.valGetter})"
+                      when ctx.fType.length <= 8; ctx.fld.aggr ? "write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Double(out, val.#{ctx.valGetter})" : "out.writeDouble(val.#{ctx.valGetter})"
+                      else; raise "Invalid float field #{ctx.fld}"
+                    end
+              })
+
+=begin rdoc
+HDFS Reader and Writer for the temporal type, the DateTime
+=end
+    DTTM_RW_METHODS = RwHolder.new(
+            lambda { |ctx|
+                ctx.fld.aggr ? ctx.rw.call("read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}ZonedDateTime(in)") : ctx.rw.call('readDttm(in)')
+            },
+            lambda { |ctx|
+                 ctx.fld.aggr ? "write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}ZonedDateTime(out, val.#{ctx.valGetter})" : "writeDttm(out, val.#{ctx.valGetter})"
+            }
+    )
+
+=begin rdoc
+HDFS Reader and Writer for boolean Java type.
+=end
+    BOOL_RW_METHODS = RwHolder.new(
+            lambda { |ctx|
+                aggrNotSupported(ctx.fld, 'Booleans') if ctx.fld.aggr
+                ctx.rw.call('in.readBoolean()')
+            },
+            lambda { |ctx|
+                aggrNotSupported(ctx.fld, 'Booleans') if ctx.fld.aggr
+                "out.writeBoolean(val.#{ctx.valGetter})"
+            }
+    )
+
+=begin rdoc
+HDFS Reader and Writer the raw data type, the byte array.
+=end
+    RAW_RW_METHODS = RwHolder.new(
+            lambda { |ctx|
+                aggrNotSupported(ctx.fld, 'Raw Data') if ctx.fld.aggr
+                ctx.rw.call('readByteArray(in)')
+            },
+            lambda { |ctx|
+                aggrNotSupported(ctx.fld, 'Raw Data') if ctx.fld.aggr
+                "writeByteArray(out, val.#{ctx.valGetter})" }
+    )
+
+=begin rdoc
+HDFS Reader and Writer the variable size Decimal data type.
+=end
+    NUMERIC_RW_METHODS = RwHolder.new(lambda{|ctx| ctx.fld.aggr ? ctx.rw.call("read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}BigDecimal(in)") : ctx.rw.call('readBigDecimal(in)')},
+                                      lambda{|ctx| "writeBigDecimal(out, val.#{ctx.valGetter})"})
+
+=begin rdoc
+HDFS Reader and Writer the Java Enums.
+=end
+    ENUM_RW_METHODS = RwHolder.new(
+          lambda{|ctx|
+            aggrNotSupported(ctx.fld, 'Enums') if ctx.fld.aggr
+            "#{condenseType(ctx.fType.type, ctx.pckg)}.forOrd(readVInt(in))"
+          },
+          lambda { |ctx|
+            aggrNotSupported(ctx.fld, 'Enums') if ctx.fld.aggr
+            "writeVInt(out, val.#{ctx.valGetter}.ordinal())"
+          }
+    )
+
+=begin rdoc
+HDFS Reader and Writer the BitSet.
+=end
+    BITSET_RW_METHODS = RwHolder.new(
+          lambda { |ctx|
+            aggrNotSupported(ctx.fld, 'BitSets') if ctx.fld.aggr
+            "new #{condenseType(ctx.fld.dataType, ctx.pckg)}(readLongArray(in))"
+          },
+          lambda { |ctx|
+            aggrNotSupported(ctx.fld, 'BitSets') if ctx.fld.aggr
+            "writeBitSet(out, val.#{ctx.valGetter})"
+          }
+    )
+
+=begin rdoc
+HDFS Reader and Writer the URL.
+=end
+    URL_RW_METHODS = RwHolder.new(
+            lambda { |ctx|
+                aggrNotSupported(ctx.fld, 'URLs') if ctx.fld.aggr
+                'new java.net.URL(readText(in))'
+            },
+            lambda { |ctx|
+                aggrNotSupported(ctx.fld, 'URLs') if ctx.fld.aggr
+                "writeTextIfAny(out, val.#{ctx.valGetter}.toExternalForm())"
+            }
+    )
+=begin rdoc
+Read/write methods for the standard data types.
+=end
+    STD_RW_METHODS = {
+          INT => INTEGRAL_RW_METHODS,
+          STRING => TEXT_RW_METHODS,
+          DATETIME => DTTM_RW_METHODS,
+          BOOL => BOOL_RW_METHODS,
+          CHAR => TEXT_RW_METHODS,
+          FLOAT => FLOAT_RW_METHODS,
+          RAW => RAW_RW_METHODS,
+          NUMERIC => NUMERIC_RW_METHODS,
+          URL => URL_RW_METHODS
+    }
+# DataMeta DOM object renderer
+    RECORD_RW_METHODS = RwHolder.new(
+        lambda { |ctx|
+            if ctx.fld.aggr
+                if ctx.fld.trgType # map
+                    mapsNotSupported(ctx.fld)
+                else  # list, set or deque
+                    "read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}(in, #{
+                        inOutableClassName(condenseType(ctx.fType.type, ctx.pckg))}.getInstance())"
+                end
+            else # scalar
+                "#{inOutableClassName(condenseType(ctx.fType.type, ctx.pckg))}.getInstance().read(in)"
+            end
+        },
+        lambda { |ctx|
+            if ctx.fld.aggr && !ctx.fld.trgType
+                if ctx.fld.trgType # map
+                    mapsNotSupported(ctx.fld)
+                else  # list, set or deque
+                    "writeCollection(val.#{ctx.valGetter}, out, #{inOutableClassName(condenseType(ctx.fType.type, ctx.pckg))}.getInstance())"
+                end
+            else # scalar
+                "#{inOutableClassName(condenseType(ctx.fType.type, ctx.pckg))}.getInstance().write(out, val.#{ctx.valGetter})"
+            end
+        }
+    )
+
+# Transforms the given DataMeta DOM aggregate type to full pathed Java class name
+    def aggrJavaFull(aggr)
+        PojoLexer::AGGR_CLASSES[aggr] || (raise ArgumentError, "No Aggregate classes for type #{aggr}" )
+    end
+
+# Transforms the given full Java name for the aggregate class into base name to interpolate into methods
+    def aggrBaseName(aggr)
+        /^(\w+\.)+(\w+)$/.match(aggr)[2]
+    end
+=begin rdoc
+Read/write methods for the DataMeta DOM Maps, accidentally all the same as for the standard data types.
+=end
+    MAP_RW_METHODS = STD_RW_METHODS
+
+    # Build the Read/Write operation renderer for the given context:
+    def getRwRenderer(ctx)
+        dt = ctx.fld.dataType
+        ctx.refType = nil # reset to avoid misrendering primitives
+        rwRenderer = STD_RW_METHODS[dt.type]
+        return rwRenderer if rwRenderer
+        refKey = dt.type
+        ctx.refType = ctx.model.enums[refKey] || ctx.model.records[refKey]
+        case
+            when ctx.refType.kind_of?(DataMetaDom::Record)
+                RECORD_RW_METHODS
+            when ctx.refType.kind_of?(DataMetaDom::Enum)
+                ENUM_RW_METHODS
+            when ctx.refType.kind_of?(DataMetaDom::BitSet)
+                BITSET_RW_METHODS
+            when ctx.refType.kind_of?(DataMetaDom::Mapping)
+                MAP_RW_METHODS[ctx.fType.type] || (raise ArgumentError, "No renderer found for the key type #{
+                ctx.fType.type}, record #{ctx.rec}, field #{ctx.fld}")
+            else
+                raise "No renderer defined for field #{ctx.fld}"
+        end
+    end
+
+# Temporary/scratch var -- avoiding collisions at all costs
+    def tmpVar(name); "#{'_'*3}#{name}#{'_'*3}" end
+
+  # generates writable via delegation
+  def genWritable(model, wriOut, ioOut, record, javaPackage, baseName)
+    ctx = RendCtx.new.init(model, record, javaPackage, baseName)
+    fields = record.fields
+    wriName = writableClassName(baseName)
+    ioName = inOutableClassName(baseName)
+    # scan for imports needed
+    hasOptional = fields.values.map{|f|
+#      !model.records[f.dataType.type] &&
+              !f.isRequired
+    }.reduce(:|) # true if there is at least one optional field which isn't a record
+    #fields.values.each { |f|
+    #      ctx << DataMetaDom::PojoLexer::JAVA_IMPORTS[f.dataType.type]
+    #}
+
+    # field keys (names) in the order of reading/writing to the in/out record
+    keysInOrder = fields.each_key.map{|k| k.to_s}.sort.map{|k| k.to_sym}
+    reads = ''
+    writes = ''
+    writeNullMaskHead = hasOptional ? 'final BitSet nullFlags = new BitSet(); int fldIndex = -1;' : ''
+    readNullMaskHead = hasOptional ? 'final BitSet nullFlags = new BitSet(readLongArray(in), false); int fldIndex = -1;' : ''
+    indent = "\n#{' ' * 8}"
+    # sorting provides predictable read/write order
+    keysInOrder.each { |k|
+      f = fields[k]
+      ctx.fld = f
+      rwRenderer = getRwRenderer(ctx)
+#      unless ctx.refType.kind_of?(DataMetaDom::Record)
+        reads <<  (
+            indent + (f.isRequired ? '' : 'fldIndex++;') + "val.#{DataMetaDom.setterName(ctx.fld)}(" +
+                (f.isRequired ? '' : 'nullFlags.get(fldIndex) ? null : ')+
+            "#{rwRenderer.r.call(ctx)});"
+        )
+# rendering of noReqFld - using the Veryfiable interface instead
+#=begin
+        writes << (indent + (f.isRequired ?
+                (PRIMITIVABLE_TYPES.member?(f.dataType.type) ? '' : ''):
+#%Q<if(val.#{DataMetaDom::PojoLexer::getterName(ctx.fld)}() == null) throw noReqFld("#{f.name}"); >) :
+                "if(val.#{DataMetaDom.getterName(ctx.fld)}() != null) ") + "#{rwRenderer.w.call(ctx)};")
+        unless f.isRequired
+          writeNullMaskHead << (indent + "fldIndex++; if(val.#{DataMetaDom.getterName(ctx.fld)}() == null) nullFlags.set(fldIndex);")
+        end
+#=end
+#      end
+    }
+    writeNullMaskHead << ( indent + 'writeBitSet(out, nullFlags);') if hasOptional
+    ioOut.puts <<IN_OUTABLE_CLASS
+package #{javaPackage};
+import org.ebay.datameta.dom.*;
+import java.io.*;
+import static org.ebay.datameta.ser.bytes.DataMetaHadoopUtil.*;
+import static org.apache.hadoop.io.WritableUtils.*;
+import org.ebay.datameta.ser.bytes.InOutable;
+#{ctx.importsText}
+#{DataMetaDom::PojoLexer.classJavaDoc({})}public class #{ioName} extends InOutable<#{baseName}> {
+
+    private static final #{ioName} INSTANCE = new #{ioName}();
+    public static #{ioName} getInstance() { return INSTANCE; }
+    private #{ioName}() {}
+
+    @Override public void write(final DataOutput out, final #{baseName} val) throws IOException {
+        val.verify();
+        #{writeNullMaskHead}
+#{writes}
+    }
+
+    @Override public #{baseName} read(final DataInput in, final #{baseName} val) throws IOException {
+        #{readNullMaskHead}
+#{reads}
+        return val;
+    }
+    @Override public #{baseName} read(final DataInput in) throws IOException {
+        return read(in, new #{baseName}());
+    }
+}
+IN_OUTABLE_CLASS
+      wriOut.puts <<WRITABLE_CLASS
+package #{javaPackage};
+import org.apache.hadoop.io.Writable;
+import org.ebay.datameta.dom.*;
+import java.io.*;
+import static org.ebay.datameta.ser.bytes.DataMetaHadoopUtil.*;
+import static org.apache.hadoop.io.WritableUtils.*;
+import org.ebay.datameta.ser.bytes.HdfsReadWrite;
+#{ctx.importsText}
+#{DataMetaDom::PojoLexer.classJavaDoc({})}public class #{wriName} extends HdfsReadWrite<#{baseName}> {
+
+    public #{wriName}(final #{baseName} value) {
+        super(value);
+    }
+
+    public #{wriName}() {
+        super(new #{baseName}()); // the value must be on the instance at all times,
+// for example, when used with hadoop fs -text, this class will be used with default constructor
+    }
+
+    @Override public void write(final DataOutput out) throws IOException {
+        #{ioName}.getInstance().write(out, getVal());
+    }
+
+    @Override public void readFields(final DataInput in) throws IOException {
+        #{ioName}.getInstance().read(in, getVal());
+    }
+}
+WRITABLE_CLASS
+
+      ########assertValue();
+  end
+
+=begin rdoc
+Generates all the writables for the given model.
+Parameters:
+* +model+ - the model to generate Writables from.
+* +outRoot+ - destination directory name.
+=end
+    def genWritables(model, outRoot)
+      model.records.values.each { |e|
+        javaPackage, base, packagePath = DataMetaDom::PojoLexer::assertNamespace(e.name)
+        destDir = File.join(outRoot, packagePath)
+        FileUtils.mkdir_p destDir
+        wriOut = File.open(File.join(destDir, "#{writableClassName(base)}.java"), 'wb')
+        ioOut = File.open(File.join(destDir, "#{inOutableClassName(base)}.java"), 'wb')
+        begin
+          case
+            when e.kind_of?(DataMetaDom::Record)
+              genWritable model, wriOut, ioOut, e, javaPackage, base
+            else
+              raise "Unsupported Entity: #{e.inspect}"
+          end
+        ensure
+            begin
+               ioOut.close
+            ensure
+               wriOut.close
+            end
+        end
+      }
+    end
+
+    # Shortcut to help for the Hadoop Writables generator.
+    def helpDataMetaBytesSerGen(file, errorText=nil)
+        DataMetaDom::help(file, 'DataMeta Serialization to/from Bytes', '<DataMeta DOM source> <Target Directory>', errorText)
+    end
+
+module_function :helpDataMetaBytesSerGen, :genWritables, :genWritable, :getRwRenderer,
+            :aggrBaseName, :aggrJavaFull
+end

data/test/test_dataMetaByteSer.rb

@@ -0,0 +1,17 @@
+# 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 DataMetaByteSer
+#  See for instance:
+#  - test_full
+class TestNewGem < Test::Unit::TestCase
+
+    # an empty stub for now
+    def setup;
+    end
+
+    # stub
+    def test_true
+        assert_equal('a', "a")
+    end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+## 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/dataMetaByteSer'

data/tmpl/readSwitch.erb

@@ -0,0 +1,63 @@
+<%#
+    Template for Java migration guides
+%>
+package <%=javaPackage%>;
+/*
+           This class is generated by DataMeta DOM. Do not edit manually!
+*/
+import org.ebay.datameta.ser.bytes.InOutable;
+import org.ebay.datameta.util.jdk.SemanticVersion;
+
+import java.io.DataInput;
+import java.io.IOException;
+
+public class <%=javaClassName%> {
+
+    private static final <%=javaClassName%> INSTANCE = new <%=javaClassName%>();
+
+    public static <%=javaClassName%> getInstance() { return INSTANCE; }
+
+<% model2.records.values.each { |trgE|
+    vars.versCases = vers.clone.select{|v| v < ver2}.sort{|x, y| y<=>x}
+    vars.javaPackage, vars.baseName, vars.packagePath = assertNamespace(trgE.name)
+    srcRecName = flipVer(trgE.name, ver2.toVarName, ver1.toVarName)
+    srcE = model1.records[srcRecName]
+    if srcE
+%>
+    public <%= vars.baseName %> read_<%= vars.baseName %>_versioned(final DataInput in) throws IOException {
+        final SemanticVersion ver = InOutable.readVersion(in);
+        if(ver.equals(<%=vars.baseName%>.VERSION)) {
+                return <%=vars.baseName%>_InOutable.getInstance().read(in);
+<%
+  while vars.versCases.length > 1 # loop through the case statement - a version per each
+  vars.switchTargVer = vars.versCases.shift
+  vars.brackets = ''
+  caseObjName = flipVer(trgE.name, ver2.toVarName, vars.switchTargVer.toVarName)
+  caseMod = modelForVer.call(vars.switchTargVer)
+  next unless caseMod.records.keys.member?(caseObjName.to_sym) # skip cases for the versions where this object's target version does not exist
+%>
+       }
+       else if(ver.equals(<%=caseObjName%>.VERSION)){<% vars.versMigr =  vers.clone.select{|v| v <= ver2}.sort{|x, y| y<=>x}%>
+                return <%  while vars.versMigr.length > 1 # migration steps loop nested in the case statement loop
+      vars.brackets << ')'
+      vars.migrTargVer = vars.versMigr.shift # target version for migration loop
+      vars.srcVer = vars.versMigr[0]
+      vars.srcType = flipVer(trgE.name, ver2.toVarName, vars.srcVer.toVarName)
+      migrMod = modelForVer.call(vars.srcVer)
+      break unless migrMod.records.keys.member?(vars.srcType.to_sym) # enough if there is no record in the target version
+      vars.jpMigr = vars.javaPackage.gsub(".v#{ver2.toVarName}", ".v#{vars.migrTargVer.toVarName}")
+%>
+                // substituting in <%=vars.javaPackage%>: ".v<%=ver2.toVarName%>" with ".v<%=vars.migrTargVer.toVarName%>"
+            <%=vars.jpMigr%>.<%=migrClass(vars.baseName, vars.srcVer, vars.migrTargVer)%>.getInstance().migrate(<% break if vars.srcVer <= vars.switchTargVer
+   end # migration steps loop %>
+
+                <%=vars.srcType%>_InOutable.getInstance().read(in)
+            <%= vars.brackets %>;
+<% end %>
+        }
+        else throw new IllegalArgumentException("Unsupported version for the record <%=vars.baseName%>: " + ver);
+    }
+<%  end
+  } # records loop %>
+}
+

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: dataMetaByteSer
+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: dataMetaDom
+  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
+description: Generates serializers of DataMeta objects to/from byte arrays, which
+  can be used with Hadoop, BigTable and beyond.
+email: michael.bergens@gmail.com
+executables:
+- dataMetaByteSerGen.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- History.md
+- PostInstall.txt
+- README.md
+- Rakefile
+- bin/dataMetaByteSerGen.rb
+- lib/dataMetaByteSer.rb
+- lib/dataMetaByteSer/python.rb
+- lib/dataMetaByteSer/util.rb
+- lib/dataMetaByteSer/ver_reads.rb
+- test/test_dataMetaByteSer.rb
+- test/test_helper.rb
+- tmpl/readSwitch.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:
+- Hadoop libraries
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: DataMeta Byte Array Serializers Gen
+test_files:
+- test/test_dataMetaByteSer.rb