dataMetaJacksonSer 1.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aaf9ff84148a45b237fedbc3145b843bc1877a38
-  data.tar.gz: b902109105871f7aafc26ac1a29ea6aa48bd3ff8
+  metadata.gz: c280f23ebe6a3da38712640ba619481e38b333cf
+  data.tar.gz: 3739073a2393df9fe1592b25a5669afb4357c274
 SHA512:
-  metadata.gz: fd5412944ff51009a98f019ae3755d9aa8d1d54d2170d66f1ad608d3fabbb6b66c42095a19f271e6ebd3b95eccae72051c5e57a2c6b52b42a96e8b4cf5192141
-  data.tar.gz: 75708f115d9fb0d0b11c37a6151ccd92f85a74bc8b2630ff5b1fea36723298672b0e63af823eec74daad716bdba7f214ca094af1e63baec6aab03d00923c87b1
+  metadata.gz: f03544c1c869c9e20d3cc1abbfa15ff0f4471b9883944ab59bd63585c219be63e5ff71f9d16760e90a59c5043bdceda35541909a892fb6c33e46f70f164300d9
+  data.tar.gz: ca82e225b9d5cd143945da3b6b89d90e40cd99db4e780946577be02d774d80ad1ac7c78c3785941a15e4614bde81e50fa1d50c23fa08f06bc454070dfab70e6a

data/History.md

@@ -1,5 +1,17 @@
 # `dataMetaJacksonSer` Release history:
 
+## `2.0.2` released `2018-05-13 Sun` by [`mub`](https://github.com/mub)
+* 1 update:
+    * Support for Enum serialization
+    
+## `2.0.1` released `2017-04-18 Tue` by [`mub`](https://github.com/mub)
+* 1 update:
+    * Added Java output format for Jsonables.
+
+## `2.0.0` released `2017-04-18 Tue` by [`mub`](https://github.com/mub)
+* 1 major change:
+    * Added the `ignoreUnknown` parameter to the [`Jsonable[T]` trait](https://github.com/eBayDataMeta/DataMeta-domScala/blob/master/ser/jackson/fasterxml/src/main/scala/org/ebay/datameta/ser/jackson/fasterxml/Jsonable.scala), changed the generator to match
+    
 ## `1.0.0` released `2017-04-04 Tue` by [`mub`](https://github.com/mub)
 * 1 major enhancement:
   * Initial release

data/README.md

@@ -18,7 +18,7 @@ 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:
+To generate the JSON (de)serializers in Java, including Hadoop Writables for the DataMeta model, run:
 
     dataMetaJacksonSerGen.rb <DataMeta DOM source> <Target Directory>
 

data/bin/dataMetaJacksonSerGen.rb

@@ -1,17 +1,36 @@
 #!/usr/bin/env ruby
-%w( dataMetaDom dataMetaJacksonSer ).each(&method(:require))
+%w( dataMetaDom dataMetaJacksonSer dataMetaJacksonSer/util ).each(&method(:require))
 
-@source, @target = ARGV
+@source, @target, @formatSpec = 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)
 
+@format = if @formatSpec.nil?
+  DataMetaJacksonSer::JAVA_FMT # default to Java
+else
+  fmt = @formatSpec.to_sym
+  case fmt
+    # this should be verified (asserted) by the API methods too, but they would raise an error
+    # instead of showing help.
+    when DataMetaJacksonSer::JAVA_FMT, DataMetaJacksonSer::SCALA_FMT
+      fmt
+    else
+      DataMetaJacksonSer::helpDataMetaJacksonSerGen(__FILE__,
+          %/Unsupported output format "#{@formatSpec}", use "java" or "scala"/)
+  end
+end
+
+puts "Output format: #{@format}"
+
 @parser = DataMetaDom::Model.new
 begin
     @parser.parse(@source, options={autoVerNs: true})
-    DataMetaJacksonSer::genJacksonables(@parser, @target)
+    DataMetaJacksonSer::genJacksonables(@parser, @target, @format)
     puts "Jackson serialization classes written to #{@target}. Done."
 rescue Exception => e
-   $stderr.puts "ERROR #{e.message}; #{@parser.diagn}"
-   $stderr.puts e.backtrace.inspect
+  indent = ' ' * 4
+  $stderr.puts %/ERROR #{e.message}; #{@parser.diagn}
+#{indent}#{e.backtrace.join("\n#{indent}")}
+/
 end

data/lib/dataMetaJacksonSer.rb

@@ -1,98 +1,98 @@
 $:.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))
+%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].
+JSON Serialization artifacts generation.
 
 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'
+    VERSION = '2.0.2'
     include DataMetaDom, DataMetaDom::PojoLexer
 
 =begin rdoc
-HDFS Reader and Writer for textual Java types such as String.
+JSON 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)')
+                ctx.fld.aggr ? ctx.rw.call("JU.read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}String(in)") : ctx.rw.call('JU.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})"
+                 ctx.fld.aggr ? ctx.rw.call("JU.write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}String(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter}#{ctx.|})") : "out.writeStringField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}#{ctx.|})"
             }
     )
 
 =begin rdoc
-HDFS Reader and Writer for integral Java types such as Integer or Long.
+JSON 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 <= 4; ctx.fld.aggr ? ctx.rw.call("JU.read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Integer(in)") :
+                                ctx.rw.call("in.getIntValue#{ctx.|}")
 
-                        when ctx.fType.length <= 8; ; ctx.fld.aggr ? ctx.rw.call("read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Long(in)") : ctx.rw.call('in.getLongValue')
+                        when ctx.fType.length <= 8; ; ctx.fld.aggr ? ctx.rw.call("JU.read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Long(in)") : ctx.rw.call("in.getLongValue#{ctx.|}")
 
                         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 <= 4; ctx.fld.aggr ? "JU.write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))
+                        }Integer(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter}#{ctx.|})" :
+                        "out.writeNumberField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}#{ctx.|})"
 
-                      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})"
+                      when ctx.fType.length <= 8;  ctx.fld.aggr ? "JU.write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))
+                        }Long(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter}#{ctx.|})" :
+                        "out.writeNumberField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}#{ctx.|})"
 
                       else; raise "Invalid integer field #{ctx.fld}"
                   end
                 })
 
 =begin rdoc
-HDFS Reader and Writer for floating point Java types such as Float or Double.
+JSON 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()')
+                      when ctx.fType.length <= 4; ctx.fld.aggr ? ctx.rw.call("JU.read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Float(in)") : ctx.rw.call('in.getFloatValue()')
+                      when ctx.fType.length <= 8; ctx.fld.aggr ? ctx.rw.call("JU.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})"
+                      when ctx.fType.length <= 4; ctx.fld.aggr ? "JU.write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Float(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter}#{ctx.|})" : "out.writeNumberField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}#{ctx.|})"
+                      when ctx.fType.length <= 8; ctx.fld.aggr ? "JU.write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Double(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter}#{ctx.|})" : "out.writeNumberField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}#{ctx.|})"
                       else; raise "Invalid float field #{ctx.fld}"
                     end
               })
 
 =begin rdoc
-HDFS Reader and Writer for the temporal type, the DateTime
+JSON 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)')
+                ctx.fld.aggr ? ctx.rw.call("JU.read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}ZonedDateTime(in)") : ctx.rw.call('JU.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})"
+                 ctx.fld.aggr ? %<JU.write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}ZonedDateTime("#{
+                    ctx.fld.name}", out, value.#{ctx.valGetter}#{ctx.|})> : "JU.writeDttmFld(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter}#{ctx.|})"
             }
     )
 
 =begin rdoc
-HDFS Reader and Writer for boolean Java type.
+JSON Reader and Writer for boolean Java type.
 =end
     BOOL_RW_METHODS = RwHolder.new(
             lambda { |ctx|
@@ -101,45 +101,43 @@ HDFS Reader and Writer for boolean Java type.
             },
             lambda { |ctx|
                 aggrNotSupported(ctx.fld, 'Booleans') if ctx.fld.aggr
-                "out.writeBooleanField(\"#{ctx.fld.name}\", value.#{ctx.valGetter})"
+                "out.writeBooleanField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}#{ctx.|})"
             }
     )
 
 =begin rdoc
-HDFS Reader and Writer the raw data type, the byte array.
+JSON 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)')
+                ctx.rw.call('JU.readByteArrayPrim(in)')
             },
             lambda { |ctx|
                 aggrNotSupported(ctx.fld, 'Raw Data') if ctx.fld.aggr
-                "writeByteArrayFld(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter})" }
+                "JU.writeByteArrayFld(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter}#{ctx.|})" }
     )
 
 =begin rdoc
-HDFS Reader and Writer the variable size Decimal data type.
+JSON 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})"})
+    NUMERIC_RW_METHODS = RwHolder.new(lambda{|ctx| ctx.fld.aggr ? ctx.rw.call("JU.read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}BigDecimal(in)") : ctx.rw.call('JU.readBigDecimal(in)')},
+                                      lambda{|ctx| "out.writeNumberField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}#{ctx.|})"})
 
 =begin rdoc
-HDFS Reader and Writer the Java Enums.
+JSON 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))"
+            ctx.fld.aggr ? "JU.read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Enum(in, #{ctx.fType.type}.class)" : "Enum.valueOf(#{DataMetaDom.condenseType(ctx.fType.type, ctx.pckg)}.class, JU.readText(in))"
           },
           lambda { |ctx|
-            aggrNotSupported(ctx.fld, 'Enums') if ctx.fld.aggr
-            "out.writeStringField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}.name())"
+            ctx.fld.aggr ? %<JU.write#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}Enum("#{ctx.fld.name}", out, value.#{ctx.valGetter}#{ctx.|})> : "out.writeStringField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}#{ctx.|}.name())"
           }
     )
 
 =begin rdoc
-HDFS Reader and Writer the BitSet.
+JSON Reader and Writer the BitSet.
 =end
     BITSET_RW_METHODS = RwHolder.new(
           lambda { |ctx|
@@ -148,21 +146,21 @@ HDFS Reader and Writer the BitSet.
           },
           lambda { |ctx|
             aggrNotSupported(ctx.fld, 'BitSets') if ctx.fld.aggr
-            "writeBitSetFld(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter})"
+            "writeBitSetFld(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter}#{ctx.|})"
           }
     )
 
 =begin rdoc
-HDFS Reader and Writer the URL.
+JSON 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))'
+                'new java.net.URL(in.getText())'
             },
             lambda { |ctx|
                 aggrNotSupported(ctx.fld, 'URLs') if ctx.fld.aggr
-                "out.writeStringField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}.toExternalForm)"
+                "out.writeStringField(\"#{ctx.fld.name}\", value.#{ctx.valGetter}#{ctx.|}.toExternalForm())"
             }
     )
 =begin rdoc
@@ -186,11 +184,11 @@ Read/write methods for the standard data types.
                 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))})"
+                    "JU.read#{aggrBaseName(aggrJavaFull(ctx.fld.aggr))}(in, #{
+                        jsonableClassName(DataMetaDom.condenseType(ctx.fType.type, ctx.pckg))}.getInstance())"
                 end
             else # scalar
-                "#{jsonableClassName(DataMetaDom.condenseType(ctx.fType.type, ctx.pckg))}.read(in)"
+                "#{jsonableClassName(DataMetaDom.condenseType(ctx.fType.type, ctx.pckg))}.getInstance().read(in)"
             end
         },
         lambda { |ctx|
@@ -198,10 +196,10 @@ Read/write methods for the standard data types.
                 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))})"
+                    "JU.writeCollectionFld(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter}#{ctx.|}, #{jsonableClassName(DataMetaDom.condenseType(ctx.fType.type, ctx.pckg))}.getInstance())"
                 end
             else # scalar
-                "#{jsonableClassName(DataMetaDom.condenseType(ctx.fType.type, ctx.pckg))}.writeField(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter})"
+                "#{jsonableClassName(DataMetaDom.condenseType(ctx.fType.type, ctx.pckg))}.getInstance().writeField(\"#{ctx.fld.name}\", out, value.#{ctx.valGetter}#{ctx.|})"
             end
         }
     )
@@ -246,8 +244,9 @@ Read/write methods for the DataMeta DOM Maps, accidentally all the same as for t
 # 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)
+  # generates Scala JSONable via delegation
+  def genJacksonable(model, ioOut, record, javaPackage, baseName, fmt = :scala)
+    assertOutFmt fmt
     ctx = RendCtx.new.init(model, record, javaPackage, baseName)
     fields = record.fields
     ioName = jsonableClassName(baseName)
@@ -271,20 +270,44 @@ Read/write methods for the DataMeta DOM Maps, accidentally all the same as for t
       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)})
+
+      reads << case fmt
+        when SCALA_FMT
+          %/
+          #{indent*5}case "#{f.name}" =>
+#{indent*6}target.#{DataMetaDom.setterName(ctx.fld)}(#{rwRenderer.r.call(ctx)})
 /
-# rendering of noReqFld - using the Veryfiable interface instead
+        when JAVA_FMT
+          %/
+#{indent*6}case "#{f.name}":
+#{indent*7}target.#{DataMetaDom.setterName(ctx.fld)}(#{rwRenderer.r.call(ctx)});
+#{indent*7}break;
+/
+        else
+          badFmt fmt
+      end
+
+# rendering of noReqFld - using the Verifiable interface instead
 #=begin
-      writes << ( "\n" + (indent*2) + (f.isRequired ?
+      writes  << case fmt
+        when SCALA_FMT
+           "\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)}")
+                "if(value.#{DataMetaDom.getterName(ctx.fld)} != null) ") + "#{rwRenderer.w.call(ctx)}"
 #=end
-#      end
+        when JAVA_FMT
+          "\n" + (indent*2) + (f.isRequired ?
+              (PRIMITIVABLE_TYPES.member?(f.dataType.type) ? '' : ''):
+              "if(value.#{DataMetaDom.getterName(ctx.fld)}#{ctx.|} != null) ") + "#{rwRenderer.w.call(ctx)};"
+        else
+          badFmt fmt
+      end
     }
-    ioOut.puts <<JSONABLE_CLASS
+
+    ioOut.puts case fmt
+      when SCALA_FMT
+          %^
 package #{javaPackage}
 
 import org.ebay.datameta.ser.jackson.fasterxml.JacksonUtil._
@@ -299,25 +322,95 @@ import com.fasterxml.jackson.core.JsonToken.{END_ARRAY, END_OBJECT}
 #{writes}
   }
 
-  override def read(in: JsonParser, value: #{baseName}): #{baseName} = {
+  override def readInto(in: JsonParser, target: #{baseName}, ignoreUnknown: Boolean = true): #{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" """)
+          case _ => if(!ignoreUnknown) throw new IllegalArgumentException(s"""Unhandled field "$fldName" """)
+        }
+      }
+    }
+    target
+  }
+
+  override def read(in: JsonParser, ignoreUnknown: Boolean = true): #{baseName} = {
+    readInto(in, new #{baseName}(), ignoreUnknown)
+  }
+}
+^
+      when JAVA_FMT
+                          %^
+package #{javaPackage};
+
+import static org.ebay.datameta.ser.jackson.fasterxml.JacksonUtil.*;
+import org.ebay.datameta.ser.jackson.fasterxml.JacksonUtil;
+import org.ebay.datameta.ser.jackson.fasterxml.Jsonable;
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonToken;
+
+import java.io.IOException;
+
+import static com.fasterxml.jackson.core.JsonToken.END_ARRAY;
+import static com.fasterxml.jackson.core.JsonToken.END_OBJECT;
+
+/**
+ * Json Serializer/Deserializer for the type {@link #{baseName}}.
+ * This class is completely immutable, state-free and therefore thread-safe, implemented and used as a singleton.
+ */
+#{DataMetaDom::PojoLexer.classJavaDoc({})}public class #{ioName} extends Jsonable<#{baseName}> {
+
+  /** An instance of the {@link JacksonUtil} - can use it anywhere because {@link JacksonUtil} is a singleton,
+   * immutable and state-free.
+   */
+  public final static JacksonUtil JU = JacksonUtil.getInstance();
+
+  public static #{ioName} getInstance() { return INSTANCE; }
+
+  private final static #{ioName} INSTANCE = new #{ioName}();
+
+  /**
+   * Constructor is private - use {@link #getInstance()} to get an instance.
+   */
+  private #{ioName}() {}
+
+  public void write(final JsonGenerator out, final #{baseName} value) throws IOException {
+    value.verify();
+#{writes}
+  }
+
+  public #{baseName} readInto(final JsonParser in, final #{baseName} target, final boolean ignoreUnknown) throws IOException {
+    JsonToken t = null;
+    while ( (t = in.nextToken()) != END_OBJECT) {
+      if(t == null) throw new IllegalArgumentException("NULL token at " + in.getParsingContext());
+      final String fldName = in.getCurrentName();
+      if(fldName != null) {
+        in.nextToken();
+        switch(fldName){
+            case "#{VER_KEY}": break; // skip the version field
+            case "#{DT_KEY}": break;  // skip the data type field
+#{reads}
+          default:
+            if(!ignoreUnknown) throw new IllegalArgumentException("Unhandled field \\"" + fldName + '\\"');
         }
       }
     }
-    value
+    return target;
   }
 
-  override def read(in: JsonParser): #{baseName} = {
-    read(in, new #{baseName}())
+  public #{baseName} read(final JsonParser in, boolean ignoreUnknown) throws IOException {
+    return readInto(in, new #{baseName}(), ignoreUnknown);
   }
 }
-JSONABLE_CLASS
+^
+                      else
+                          badFmt fmt
+
+end
 
   end
 
@@ -327,16 +420,17 @@ Parameters:
 * +model+ - the model to generate Writables from.
 * +outRoot+ - destination directory name.
 =end
-    def genJacksonables(model, outRoot)
+    def genJacksonables(model, outRoot, fmt = :scala)
+      assertOutFmt fmt
       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')
+        ioOut = File.open(File.join(destDir, "#{jsonableClassName(base)}.#{fmt}"), 'wb')
         begin
           case
             when e.kind_of?(DataMetaDom::Record)
-              genJacksonable model, ioOut, e, javaPackage, base
+              genJacksonable model, ioOut, e, javaPackage, base, fmt
             else
               raise "Unsupported Entity: #{e.inspect}"
           end
@@ -348,7 +442,7 @@ Parameters:
 
     # 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)
+        DataMetaDom::help(file, 'DataMeta Serialization to/from Jackson', '<DataMeta DOM source> <Target Directory> [java | scala]', errorText)
     end
 
 module_function :helpDataMetaJacksonSerGen, :genJacksonables, :genJacksonable, :getRwRenderer,

data/lib/dataMetaJacksonSer/util.rb

@@ -5,6 +5,28 @@ require 'logger'
 
 module DataMetaJacksonSer
 
+=begin rdoc
+Output format: Scala.
+=end
+  SCALA_FMT = :scala
+
+=begin rdoc
+Output format: Java.
+=end
+  JAVA_FMT = :java
+
+=begin rdoc
+The key for the Version field in the generated JSON.
+The "=" symbol is used to avoid any collision with fields/variables.
+=end
+  VER_KEY = '*v*'
+
+=begin rdoc
+The key for the DataType field in the generated JSON.
+The "=" symbol is used to avoid any collision with fields/variables.
+=end
+  DT_KEY = '*dt*'
+
 =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.
@@ -55,6 +77,11 @@ Base name of the type, without a namespace.
 The data type of the entity on the context.
 =end
         attr_accessor :refType
+
+=begin rdoc
+Rendering format: either JAVA_FMT or SCALA_FMT
+=end
+        attr_accessor :fmt
 =begin rdoc
 Field currently on the context.
 =end
@@ -63,7 +90,7 @@ Field currently on the context.
 =begin rdoc
 Creates a new context.
 =end
-        def initialize; @imps = Set.new end
+        def initialize; @imps = Set.new; @fmt = JAVA_FMT end
 
 =begin rdoc
 Setter for the field on the context, the field currently worked on.
@@ -74,7 +101,37 @@ Setter for the field on the context, the field currently worked on.
 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
+        def init(model, rec, pckg, baseName, fmt = JAVA_FMT)
+          @model = model; @rec = rec; @pckg = pckg; @baseName = baseName
+          @fmt = DataMetaJacksonSer::assertOutFmt(fmt)
+          self
+        end
+
+=begin rdoc
+End of line for the given format - for Java, it's a semicolon, for Scala - empty string
+=end
+       def /
+         case fmt
+           when JAVA_FMT
+             ';'
+           when SCALA_FMT
+             ''
+             # all the other options are weeded out in init(...) by calling assertOutFmt
+         end
+       end
+
+=begin rdoc
+Method call Parentheses for the given format - for Java, it's (), for Scala - empty string
+=end
+    def |
+      case fmt
+        when JAVA_FMT
+          '()'
+        when SCALA_FMT
+          ''
+        # all the other options are weeded out in init(...) by calling assertOutFmt
+      end
+    end
 
 =begin rdoc
 Add an import to the context, returns self for call chaining.
@@ -116,6 +173,21 @@ Getter name for the current field, if the type is Mapping, includes <tt>.getKey(
         end
     end # RendCtx
 
+# Helper error raiser for an unsupported JSONable format
+  def badFmt(fmt)
+    raise ArgumentError, %<Unsupported JSONable format "#{fmt}, use "java" or "scala"">
+  end
+
+# Verifies the validity of the output format, raises an error if it's wrong.
+  def assertOutFmt(fmt)
+    case fmt
+      when JAVA_FMT, SCALA_FMT
+        fmt
+      else
+        badFmt fmt
+    end
+  end
+
 =begin rdoc
 Builds a class name for a InOutable.
 =end
@@ -129,5 +201,5 @@ Builds a class name for a InOutable.
         raise ArgumentError, "Field #{fld.name}: aggregate types are not supported for #{forWhat} on JSON serialization layer"
     end
 
-    module_function :jsonableClassName, :mapsNotSupported, :aggrNotSupported
+    module_function :jsonableClassName, :mapsNotSupported, :aggrNotSupported, :assertOutFmt, :badFmt
 end

data/lib/dataMetaJacksonSer/ver_reads.rb

@@ -0,0 +1,60 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'dataMetaDom/field'
+require 'dataMetaDom/pojo'
+
+
+module DataMetaJacksonSer
+=begin rdoc
+Migration tooling.
+
+=end
+module VerReadsJson
+    include DataMetaDom, DataMetaDom::PojoLexer
+=begin
+Generates Versioned Read switch that channels the read to the proper migration scenario.
+=end
+    def genVerReadSwitchJson(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__SwitchJson_v#{ver1.toVarName}_to_v#{ver2.toVarName}"
+        destDir = File.join(outRoot, packagePath)
+        FileUtils.mkdir_p destDir
+        javaDestFile = File.join(destDir, "#{javaClassName}.java")
+
+        skippedCount = 0
+        if File.file?(javaDestFile)
+            skippedCount += 1
+            $stderr.puts %<Read switch target "#{javaDestFile} present, therefore skipped">
+        else
+            IO::write(javaDestFile,
+                      ERB.new(IO.read(File.join(File.dirname(__FILE__), '../../tmpl/readSwitch.erb')),
+                              $SAFE, '%<>').result(binding), mode: 'wb')
+        end
+
+        $stderr.puts %<Read Switch targets skipped: #{skippedCount}> if skippedCount > 0
+    end
+    module_function :genVerReadSwitchJson
+end
+end

data/tmpl/readSwitch.erb

@@ -0,0 +1,67 @@
+<%#
+    Template for Java migration guides
+%>
+package <%=javaPackage%>;
+/*
+           This class is generated by DataMeta DOM. Do not edit manually!
+*/
+import com.fasterxml.jackson.core.JsonFactory;
+import org.ebay.datameta.ser.jackson.fasterxml.JacksonUtil;
+import org.ebay.datameta.ser.jackson.fasterxml.VerAndDataType;
+import org.ebay.datameta.util.jdk.SemanticVersion;
+
+import java.io.IOException;
+
+public class <%=javaClassName%> {
+
+    private static final <%=javaClassName%> INSTANCE = new <%=javaClassName%>();
+
+    public static <%=javaClassName%> getInstance() { return INSTANCE; }
+
+    public static final JsonFactory JF = JacksonUtil.getInstance().getJf();
+
+<% 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 String json) throws IOException {
+        final VerAndDataType vdt = VerAndDataType.fromJson(json);
+        final SemanticVersion ver = vdt.getVersion();
+        if(ver.equals(<%=vars.baseName%>.VERSION)) {
+                return <%=vars.baseName%>_JSONable.getInstance().read(JF.createParser(json));
+<%
+  while vars.versCases.length > 0 # 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 > 0 # 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%>_JSONable.getInstance().read(JF.createParser(json))
+            <%= vars.brackets %>;
+<% end %>
+        }
+        else throw new IllegalArgumentException("Unsupported version for the record <%=vars.baseName%>: " + ver);
+    }
+<%  end
+  } # records loop %>
+}
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dataMetaJacksonSer
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Michael Bergens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-31 00:00:00.000000000 Z
+date: 2018-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dataMetaDom
@@ -46,8 +46,10 @@ files:
 - bin/dataMetaJacksonSerGen.rb
 - lib/dataMetaJacksonSer.rb
 - lib/dataMetaJacksonSer/util.rb
+- lib/dataMetaJacksonSer/ver_reads.rb
 - test/test_dataMetaJacksonSer.rb
 - test/test_helper.rb
+- tmpl/readSwitch.erb
 homepage: https://github.com/eBayDataMeta
 licenses:
 - Apache-2.0
@@ -69,9 +71,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - Hadoop libraries
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
-summary: DataMeta JSON Serializers Gen using Fast XML Jackson
+summary: DataMeta JSON Serializers Gem using Fast XML Jackson
 test_files:
 - test/test_dataMetaJacksonSer.rb