dataMetaJacksonSer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aaf9ff84148a45b237fedbc3145b843bc1877a38
+  data.tar.gz: b902109105871f7aafc26ac1a29ea6aa48bd3ff8
+SHA512:
+  metadata.gz: fd5412944ff51009a98f019ae3755d9aa8d1d54d2170d66f1ad608d3fabbb6b66c42095a19f271e6ebd3b95eccae72051c5e57a2c6b52b42a96e8b4cf5192141
+  data.tar.gz: 75708f115d9fb0d0b11c37a6151ccd92f85a74bc8b2630ff5b1fea36723298672b0e63af823eec74daad716bdba7f214ca094af1e63baec6aab03d00923c87b1

data/.yardopts

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

data/History.md

@@ -0,0 +1,5 @@
+# `dataMetaJacksonSer` Release history:
+
+## `1.0.0` released `2017-04-04 Tue` by [`mub`](https://github.com/mub)
+* 1 major enhancement:
+  * Initial release

data/PostInstall.txt

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

data/README.md

@@ -0,0 +1,35 @@
+# `dataMetaJacksonSer` gem
+
+JSON (de)serialization generation from [DataMeta DOM](https://github.com/eBayDataMeta/DataMeta-gems/tree/master/meta/core/dom) sources
+using FasterXML Jackson.
+
+References to this gem's:
+
+* [Source](https://github.com/eBayDataMeta/DataMeta-gems/tree/master/meta/ser/jackson/fasterxml)
+
+
+## DESCRIPTION:
+
+See the [DataMeta Project Documentation Repository](https://github.com/eBayDataMeta/DataMeta)
+
+## FEATURES:
+
+Generates (de)serializers to/from JSON using FasterXML Jackson.
+
+## SYNOPSIS:
+
+To generate Byte Array serializers in Java, including Hadoop Writables for the DataMeta model, run:
+
+    dataMetaJacksonSerGen.rb <DataMeta DOM source> <Target Directory>
+
+## REQUIREMENTS:
+
+* No special requirements
+
+## INSTALL:
+
+    gem install dataMetaJacksonSer
+
+## 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 ./lib/dataMetaJacksonSer ./lib/dataMetaJacksonSer/util).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/dataMetaJacksonSerGen.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+%w( dataMetaDom dataMetaJacksonSer ).each(&method(:require))
+
+@source, @target = ARGV
+DataMetaJacksonSer::helpDataMetaJacksonSerGen __FILE__ unless @source && @target
+DataMetaJacksonSer::helpDataMetaJacksonSerGen(__FILE__, "DataMeta DOM source #{@source} is not a file") unless File.file?(@source)
+DataMetaJacksonSer::helpDataMetaJacksonSerGen(__FILE__, "Jacksonables destination directory #{@target} is not a dir") unless File.directory?(@target)
+
+@parser = DataMetaDom::Model.new
+begin
+    @parser.parse(@source, options={autoVerNs: true})
+    DataMetaJacksonSer::genJacksonables(@parser, @target)
+    puts "Jackson serialization classes written to #{@target}. Done."
+rescue Exception => e
+   $stderr.puts "ERROR #{e.message}; #{@parser.diagn}"
+   $stderr.puts e.backtrace.inspect
+end

data/lib/dataMetaJacksonSer/util.rb

@@ -0,0 +1,133 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'set'
+require 'logger'
+
+module DataMetaJacksonSer
+
+=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 InOutable.
+=end
+    def jsonableClassName(baseName); "#{baseName}_JSONable" end
+
+    def mapsNotSupported(fld)
+        raise ArgumentError, "Field #{fld.name}: maps are not currently supported on JSON serialization layer"
+    end
+
+    def aggrNotSupported(fld, forWhat)
+        raise ArgumentError, "Field #{fld.name}: aggregate types are not supported for #{forWhat} on JSON serialization layer"
+    end
+
+    module_function :jsonableClassName, :mapsNotSupported, :aggrNotSupported
+end

data/lib/dataMetaJacksonSer.rb

@@ -0,0 +1,356 @@
+$:.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 dataMetaDom/util).each(&method(:require))
+require 'set'
+require 'dataMetaJacksonSer/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 DataMetaJacksonSer
+    # 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(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter})" : "out.writeStringField(\"#{ctx.fld.name}\", value.#{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('in.getIntValue')
+
+                        when ctx.fType.length <= 8; ; ctx.fld.aggr ? ctx.rw.call("read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Long(in)") : ctx.rw.call('in.getLongValue')
+
+                        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(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter})" :
+                        "out.writeNumberField(\"#{ctx.fld.name}\", value.#{ctx.valGetter})"
+
+                      when ctx.fType.length <= 8;  ctx.fld.aggr ? "write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))
+                        }Long(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter})" :
+                        "out.writeNumberField(\"#{ctx.fld.name}\", value.#{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.getFloatValue()')
+                      when ctx.fType.length <= 8; ctx.fld.aggr ? ctx.rw.call("read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Double(in)") : ctx.rw.call('in.getDoubleValue()')
+                      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, value.#{ctx.valGetter})" : "out.writeNumberField(\"#{ctx.fld.name}\", value.#{ctx.valGetter})"
+                      when ctx.fType.length <= 8; ctx.fld.aggr ? "write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Double(out, value.#{ctx.valGetter})" : "out.writeNumberField(\"#{ctx.fld.name}\", value.#{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("#{
+                    ctx.fld.name}", out, value.#{ctx.valGetter})> : "writeDttmFld(\"#{ctx.fld.name}\", out, value.#{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.getBooleanValue()')
+            },
+            lambda { |ctx|
+                aggrNotSupported(ctx.fld, 'Booleans') if ctx.fld.aggr
+                "out.writeBooleanField(\"#{ctx.fld.name}\", value.#{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
+                "writeByteArrayFld(\"#{ctx.fld.name}\", out, value.#{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| "out.writeNumberField(\"#{ctx.fld.name}\", value.#{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
+            "#{DataMetaDom.condenseType(ctx.fType.type, ctx.pckg)}.forName(readText(in))"
+          },
+          lambda { |ctx|
+            aggrNotSupported(ctx.fld, 'Enums') if ctx.fld.aggr
+            "out.writeStringField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}.name())"
+          }
+    )
+
+=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 #{DataMetaDom.condenseType(ctx.fld.dataType, ctx.pckg)}(readLongArray(in))"
+          },
+          lambda { |ctx|
+            aggrNotSupported(ctx.fld, 'BitSets') if ctx.fld.aggr
+            "writeBitSetFld(\"#{ctx.fld.name}\", out, value.#{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
+                "out.writeStringField(\"#{ctx.fld.name}\", value.#{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, #{
+                        jsonableClassName(DataMetaDom.condenseType(ctx.fType.type, ctx.pckg))})"
+                end
+            else # scalar
+                "#{jsonableClassName(DataMetaDom.condenseType(ctx.fType.type, ctx.pckg))}.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
+                    "writeCollectionFld(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter}, #{jsonableClassName(DataMetaDom.condenseType(ctx.fType.type, ctx.pckg))})"
+                end
+            else # scalar
+                "#{jsonableClassName(DataMetaDom.condenseType(ctx.fType.type, ctx.pckg))}.writeField(\"#{ctx.fld.name}\", out, value.#{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 genJacksonable(model, ioOut, record, javaPackage, baseName)
+    ctx = RendCtx.new.init(model, record, javaPackage, baseName)
+    fields = record.fields
+    ioName = jsonableClassName(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 = ''
+    indent = "#{' ' * 2}"
+    # 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*5}case "#{f.name}" =>
+#{indent*6}value.#{DataMetaDom.setterName(ctx.fld)}(#{rwRenderer.r.call(ctx)})
+/
+# rendering of noReqFld - using the Veryfiable interface instead
+#=begin
+      writes << ( "\n" + (indent*2) + (f.isRequired ?
+                (PRIMITIVABLE_TYPES.member?(f.dataType.type) ? '' : ''):
+#%Q<if(value.#{DataMetaDom::PojoLexer::getterName(ctx.fld)}() == null) throw noReqFld("#{f.name}"); >) :
+                "if(value.#{DataMetaDom.getterName(ctx.fld)} != null) ") + "#{rwRenderer.w.call(ctx)}")
+#=end
+#      end
+    }
+    ioOut.puts <<JSONABLE_CLASS
+package #{javaPackage}
+
+import org.ebay.datameta.ser.jackson.fasterxml.JacksonUtil._
+import org.ebay.datameta.ser.jackson.fasterxml.Jsonable
+import com.fasterxml.jackson.core.{JsonFactory, JsonGenerator, JsonParser, JsonToken}
+import com.fasterxml.jackson.core.JsonToken.{END_ARRAY, END_OBJECT}
+
+#{DataMetaDom::PojoLexer.classJavaDoc({})}object #{ioName} extends Jsonable[#{baseName}] {
+
+  override def write(out: JsonGenerator, value: #{baseName}) {
+    value.verify()
+#{writes}
+  }
+
+  override def read(in: JsonParser, value: #{baseName}): #{baseName} = {
+    while(in.nextToken() != END_OBJECT) {
+      val fldName = in.getCurrentName
+      if(fldName != null) {
+        in.nextToken()
+        fldName match {
+#{reads}
+          case _ => throw new IllegalArgumentException(s"""Unhandled field "$fldName" """)
+        }
+      }
+    }
+    value
+  }
+
+  override def read(in: JsonParser): #{baseName} = {
+    read(in, new #{baseName}())
+  }
+}
+JSONABLE_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 genJacksonables(model, outRoot)
+      model.records.values.each { |e|
+        javaPackage, base, packagePath = DataMetaDom::PojoLexer::assertNamespace(e.name)
+        destDir = File.join(outRoot, packagePath)
+        FileUtils.mkdir_p destDir
+        ioOut = File.open(File.join(destDir, "#{jsonableClassName(base)}.scala"), 'wb')
+        begin
+          case
+            when e.kind_of?(DataMetaDom::Record)
+              genJacksonable model, ioOut, e, javaPackage, base
+            else
+              raise "Unsupported Entity: #{e.inspect}"
+          end
+        ensure
+            ioOut.close
+        end
+      }
+    end
+
+    # Shortcut to help for the Hadoop Writables generator.
+    def helpDataMetaJacksonSerGen(file, errorText=nil)
+        DataMetaDom::help(file, 'DataMeta Serialization to/from Jackson', '<DataMeta DOM source> <Target Directory>', errorText)
+    end
+
+module_function :helpDataMetaJacksonSerGen, :genJacksonables, :genJacksonable, :getRwRenderer,
+            :aggrBaseName, :aggrJavaFull
+end

data/test/test_dataMetaJacksonSer.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/dataMetaJacksonSer'

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: dataMetaJacksonSer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Michael Bergens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-31 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.4
+  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.4
+description: Generates serializers of DataMeta objects to/from JSON using Fast XML
+  Jackson
+email: michael.bergens@gmail.com
+executables:
+- dataMetaJacksonSerGen.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- History.md
+- PostInstall.txt
+- README.md
+- Rakefile
+- bin/dataMetaJacksonSerGen.rb
+- lib/dataMetaJacksonSer.rb
+- lib/dataMetaJacksonSer/util.rb
+- test/test_dataMetaJacksonSer.rb
+- test/test_helper.rb
+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 JSON Serializers Gen using Fast XML Jackson
+test_files:
+- test/test_dataMetaJacksonSer.rb