dataMetaDom 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a5a34ddc40e94ae5a9075a76cd8896a3b3781b76
+  data.tar.gz: 80d035936a0991579930f19b6bf4f8262f81c7fe
+SHA512:
+  metadata.gz: 529782409a1e9957fba291b94318f96c7bea71f11415340039900be2a7d22d7e80761d4bfef5b5166e1b987d6dde4c5b9ea17e5e1579a9fc8194126b4508e53b
+  data.tar.gz: 571cb5dddc02d545731ef0ada7ea573ee033682816a13dc3122dd117229c7ba2b44a357a0e918a8c30c7661b3e71afbdcf487c904d086964c60130e33daef5c2

data/.yardopts

@@ -0,0 +1 @@
+--title "DataMeta DOM" -r README.md --charset UTF-8 lib/**/* - README.md

data/History.md

@@ -0,0 +1,6 @@
+
+# `dataMetaDom` Release history:
+
+## `1.0.0` - `2017-01-15`
+* 1 major enhancement:
+    * Initial release

data/PostInstall.txt

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

data/README.md

@@ -0,0 +1,137 @@
+# dataMetaDom
+
+The Core of the DataMeta platform, see the Features section below.
+
+## Description
+
+See the [DataMeta home page](https://github.com/eBayDataMeta) and
+
+References to this gem's:
+
+* [Source](https://github.com/eBayDataMeta/DataMeta-gems)
+
+## Features
+
+The following components are included into this gem:
+
+* DataMetaDOM DDL parser - parses the DataMetaDOM [DDL](http://en.wikipedia.org/wiki/Data_definition_language) into
+  the model in memory.
+* export the DataMetaDOM DDL to [POJO](http://en.wikipedia.org/wiki/Plain_Old_Java_Object) including implementors
+  of the `DataMetaSame` Java interface, to provide equality either by the class `identity` or by all of the
+  fields.
+* export the DataMetaDOM DDL to MySQL DDL
+
+## Problems
+
+None known.
+
+## Synopsis
+
+Beside the API, there are the following runnables in this gem:
+
+### DataMetaDOM POJO generator.
+
+Use this runnable to parse a DataMetaDOM source and generate Java objects
+([POJOs](http://en.wikipedia.org/wiki/Plain_Old_Java_Object)) matching the DataMeta model.
+
+Usage:
+
+    dataMetaDomPojo.rb <DataMetaDOM source> <target directory>
+
+Example:
+
+    dataMetaDomPojo.rb /gitrepos/projects/data/schema/showCase.dmDom ./pojos
+
+### DataMetaDOM MySQL DDL generator
+
+Use this runnable to parse a DataMetaDOM DDL source and generate matching
+[MySQL DDL](http://dev.mysql.com/doc/refman/5.5/en/sql-syntax-data-definition.html) statements, including
+creates, drops, creating referential integrity links and dropping those.
+
+Usage:
+
+    dataMetaDomMySqlDdl.rb <DataMetaDOM source> <target directory>
+
+Example:
+
+    dataMetaDomMySqlDdl.rb /gitrepos/projects/data/schema/showCase.dmDom ./sql
+
+### DataMetaDOM Full compare DataMetaSame generator for POJOs
+
+Use this to generate implementors of the DataMetaSame interface from DataMetaDOM sources performing full compare.
+
+Usage:
+
+    dataMetaDomSameFullJ.rb <DataMetaDOM source> <target directory>
+
+### DataMetaDOM compare by identity DataMetaSame generator for POJOs
+
+Use this to generate implementors of the DataMetaSame interface from DataMetaDOM sources performing compare only
+by the `identity` for the class, see DataMetaDom::Record for details.
+
+Usage:
+
+    dataMetaDomSameIdJ.rb <DataMetaDOM source> <target directory>
+
+### Exporting DataMetaDOM source into graphical file showing entity relationships
+
+This script generates [GraphViz](http://www.graphviz.org) source for the given DataMetaDOM module
+and attempts to display the resulting jpeg file in the current OS.
+
+Usage:
+
+    dataMetaDomGvExport.rb <DataMetaDOM source> <target base path>
+
+The script will append the suffix `.gv` to the `target base path` for the GraphViz source and the suffix `.jpeg`
+to the name of the genrated image file.
+
+Example:
+
+    dataMetaDomGvExport.rb src/main/schema/Model.dmDom target/Model
+
+this will generate `target/Model.gv` and `target/Model.jpeg`
+
+This requires [GraphViz](http://www.graphviz.org) installation with the `dot` command in the path
+and some kind of a graphic environment. On Windows, [Irfanview](http://www.irfanview.com) is very useful, otherwise
+the script will use default Windows viewers that oftentimes are much slower.
+
+### Reversion all files in path
+
+Usage:
+
+    dataMetaReVersion.rb <Path> <NS> <CSV-globs> <Ver-From> <Ver-To>
+
+Where:
+
+* Path - starting path to look for the files to re-version
+* NS - Namespace, such as Java/Scala package
+* CVS-globs - comma-separated file patterns, in regular filesystem globbing format
+* Ver-From - Source version or an asterisk for any version. Example: `11.2.1`
+* Ver-To - Target version. Example: `11.2.2`
+
+Examples of arguments to this command:
+
+* `src/main/com/acme com.acme.svc.obj.dom '*.java,*.scala' '*' 1.2.3` -- starting from the `src/main/com/acme`
+    directory, replace on all Scala and Java files, any DataMeta version with `1.2.3`
+* `. com.acme.svc.obj.dom '*.conf,*.scala' 1.2.1 1.2.3` -- starting from the current directory,
+    replace on all Scala and config files, DataMeta version `1.2.1` with `1.2.3`.
+
+Note the single quotes for the file glob patterns and the "star" specification of the source version: this is to
+prevent the shell to glob before passing the result to the program.
+
+Note that there is no relation between the path and the namespace; only Java still enforces such relation therefore
+we do not want to be dependent on it.
+
+
+## Requirements
+
+* No special requirements
+
+## Install
+
+    gem install dataMetaDom
+
+## 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/dataMetaDom ./lib/dataMetaDom/dataType).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/dataMetaGvExport.rb

@@ -0,0 +1,97 @@
+#!/bin/env ruby
+%w( dataMetaDom dataMetaXtra ).each(&method(:require))
+include DataMetaDom
+
+ENTITY_FILL_COLOR='#CCEEFF'
+ENUM_FILL_COLOR='#CCFFCC'
+ENUM_LINE_COLOR='#00CC00'
+ENTITY_LINE_COLOR='#000066'
+
+def genGv(parser, outFileName)
+  out = File.open(outFileName, 'wb')
+out.puts <<GV_HEADER
+digraph Model {
+    ranksep=1.6;
+    node [shape=box, fontcolor="black" style="rounded,filled" fontname="Consolas" fillcolor="#AAFFCC" pad=1.5 decorate=true fontsize=15 ];
+    edge [arrowhead=vee] ;
+GV_HEADER
+  parser.records.each_value.each { |rec|
+    ns, base = DataMetaDom::splitNameSpace(rec.name)
+    out.puts %{  #{base} [fillcolor = "#{ENTITY_FILL_COLOR}" color="#{ENTITY_LINE_COLOR}"]}
+  }
+  parser.enums.values.each { |e|
+    ns, base = DataMetaDom::splitNameSpace(e.name)
+    out.puts %{  #{base} [fillcolor = "#{ENUM_FILL_COLOR}" color="#{ENUM_LINE_COLOR}"]}
+  }
+
+  parser.records.each_value.each { |rec|
+    rec.refs.each { |ref|
+      # can not use the dotted package notation, GraphViz interprets it differently
+      # besides, with full names the graph becomes unreadable.
+      ns, fromEntityBareName = splitNameSpace ref.fromEntity.name
+      ns, toEntityBareName = splitNameSpace ref.toEntity.name
+      case ref.type
+        when Reference::RECORD
+           out.puts %{  #{fromEntityBareName} -> #{toEntityBareName} } + \
+              %{[ label="#{ref.fromField.name}" color="#{ENTITY_LINE_COLOR}"]}
+        when Reference::ENUM_REF
+          out.puts %{  #{fromEntityBareName} -> #{toEntityBareName} } +\
+              %{[ label="#{ref.fromField.name}" color="#{ENUM_LINE_COLOR}"]}
+      else
+          # skip it
+      end
+    }
+  }
+  out.puts '}'
+  out.close
+end
+
+def viewGv
+  puts `dot -o#{@imageFile} -Tjpeg #{@gvFile}`
+  if DataMetaXtra::Sys::WINDOWS
+      @imageFile.gsub!('/','\\')
+      irfanViewExe = %<#{ENV['PROGRAMFILES']}\\IrfanView\\i_view32.exe>
+      shimgvwDll = %<#{ENV['SystemRoot']}\\System32\\shimgvw.dll>
+      if File.file?(irfanViewExe) # if Irfanview is installed, use it because it works always faster than PhotoViewer
+          system(%<start "#{File.basename(@domFile)}" "#{irfanViewExe}" #{@imageFile} /title=#{File.basename(@domFile)}>)
+      elsif File.file?(shimgvwDll)
+=begin
+use the standard issue Windows PhotoViewer
+if this runs too slow, run Color Calibration, or move the PhotoViewer window from one monitor to another:
+if the PhotoViewer still is slow, install and use IrfanView 32 bit instead:
+=end
+          system(%<start "#{File.basename(@domFile)}" rundll32.exe #{shimgvwDll}, ImageView_Fullscreen #{@imageFile}>)
+      else  # use default Windows viewer for jpeg if any
+          system(%<start "#{File.basename(@domFile)}" #{@imageFile}>)
+      end
+  elsif DataMetaXtra::Sys::LINUX
+      # on Linux, ise ImageMagick, can install it with: sudo yum install php-pecl-imagick
+      system("display #{@imageFile} &")
+      # can also use "gnome-open" under GDM
+  else
+      $stderr.puts %|Don't know how to run image view on "#{RUBY_PLATFORM}"|
+  end
+
+end
+
+@domFile, @outPath = $*
+raise %|DataMetaDOM source "#{@domFile}" is not a file| unless @domFile && File.file?(@domFile)
+raise 'Output path is missing' unless @outPath
+@outDir = File.dirname(@outPath)
+raise %|Output directory "#{@outDir}" is not a directory| unless @outDir && File.directory?(@outDir)
+# absolute path works best with viewer utilities and exporters too
+@domBase = File.basename(@domFile, '.dmDom')
+@gvFile = File.absolute_path(File.join(@outPath, @domBase + '.gv'))
+@imageFile = File.absolute_path(File.join(@outPath, @domBase + '.jpeg'))
+
+
+@parser = Model.new
+begin
+  @parser.parse @domFile
+  genGv @parser, @gvFile
+  viewGv
+rescue Exception => e
+   puts "ERROR #{e.message}#{@parser.diagn}"
+   puts e.backtrace.inspect
+end
+

data/bin/dataMetaMySqlDdl.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# this script generates the SQL DDL for the DataMeta DOM model
+# Example, from gem root:
+#    dataMetaMySqlDdl.rb ../../../dataMeta/showCase.dmDom ../../../../../target/sql
+
+%w(dataMetaDom dataMetaDom/mySql dataMetaDom/help).each(&method(:require))
+
+include DataMetaDom, DataMetaDom::MySqlLexer
+
+@source, @target = ARGV
+
+DataMetaDom::helpMySqlDdl __FILE__ unless @source && @target
+DataMetaDom::helpMySqlDdl(__FILE__, "DataMeta DOM source #{@source} is not a file") unless File.file?(@source)
+DataMetaDom::helpMySqlDdl(__FILE__, "MySQL DDL destination directory #{@target} is not a dir") unless File.directory?(@target)
+
+@parser = Model.new
+begin
+  @parser.parse(@source)
+  puts @parser.enums.values.join("\n") if $DEBUG
+  puts @parser.records.values.join("\n") if $DEBUG
+  genDdl(@parser, @target)
+  puts "MySQL DDL generated into #{@target}"
+rescue Exception => e
+   $stderr.puts "ERROR #{e.message}; #{@parser.diagn}"
+   $stderr.puts e.backtrace.inspect
+   exit 1
+end

data/bin/dataMetaOracleDdl.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# this script generates the SQL DDL for the DataMeta DOM core model
+# Example, from gem root:
+#    dataMetaOracleDdl.rb ../../../dataMeta/showCase.dmDom ../../../../../target/sql
+
+%w(dataMetaDom dataMetaDom/ora dataMetaDom/help).each(&method(:require))
+
+include DataMetaDom, DataMetaDom::OraLexer
+
+@source, @target = ARGV
+DataMetaDom::helpOracleDdl __FILE__ unless @source && @target
+DataMetaDom::helpOracleDdl(__FILE__, "DataMeta DOM source #{@source} is not a file") unless File.file?(@source)
+DataMetaDom::helpOracleDdl(__FILE__, "Oracle DDL destination directory #{@target} is not a dir") unless File.directory?(@target)
+
+@parser = Model.new
+begin
+  @parser.parse(@source)
+  puts @parser.enums.values.join("\n") if $DEBUG
+  puts @parser.records.values.join("\n") if $DEBUG
+  genDdl(@parser, @target)
+  puts "Oracle DDL generated into #{@target}"
+rescue Exception => e
+   $stderr.puts "ERROR #{e.message}; #{@parser.diagn}"
+   $stderr.puts e.backtrace.inspect
+    exit 1
+end

data/bin/dataMetaPojo.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# this script generates Java POJOs and the SQL DDL for the DataMeta DOM model
+# Sample:
+# mkdir ../../../../../target/pojo
+# dataMetaPojo.rb ../../../dataMeta/showCase.dmDom ../../../../../target/pojo
+
+%w(dataMetaDom dataMetaDom/pojo dataMetaDom/help).each(&method(:require))
+
+include DataMetaDom, DataMetaDom::PojoLexer
+
+@source, @target = ARGV
+DataMetaDom::helpPojoGen __FILE__ unless @source && @target
+DataMetaDom::helpPojoGen(__FILE__, "DataMeta DOM source #{@source} is not a file") unless File.file?(@source)
+DataMetaDom::helpPojoGen(__FILE__, "POJO destination directory #{@target} is not a dir") unless File.directory?(@target)
+
+@parser = Model.new
+begin
+  @parser.parse(@source, options={autoVerNs: true})
+  puts @parser.enums.values.join("\n") if $DEBUG
+  puts @parser.records.values.join("\n") if $DEBUG
+  genPojos(@parser, @target)
+  puts "POJOs written to #{@target}. Done."
+rescue Exception => e
+   $stderr.puts "ERROR #{e.message}; #{@parser.diagn}"
+   $stderr.puts e.backtrace.inspect
+   exit 1
+end

data/bin/dataMetaReVersion.rb

@@ -0,0 +1,66 @@
+#!/bin/env ruby
+
+# This script replaces references to DataMetaDOM version with a new version
+# In the source files as well as config files.
+
+require 'dataMetaDom'
+require 'dataMetaDom/ver'
+require 'dataMetaDom/help'
+
+@path, @ns, @globs_def, @ver_from_spec, @ver_to_spec = $*
+
+def help(errorText = nil)
+    DataMetaDom.help(__FILE__, 'Source reversioner', %q~<Path> <NS> <CSV-globs> <Ver-From> <Ver-To>
+
+Where:
+    * Path - starting path to look for the files to re-version
+    * NS - Namespace, such as Java/Scala package
+    * CVS-globs - comma-separated file patterns, in regular filesystem globbing format
+    * Ver-From - Source version or an asterisk for any version. Example: 1.2.1
+    * Ver-To - Target version. Example: 1.2.2
+
+Examples of arguments:
+    Replace on all Java and Scala files starting from the src/main/com/acme, any prior DataMeta version with 1.2.3:
+        src/main/com/acme com.acme.svc.schema.dom '*.java,*.scala' '*' 1.2.3
+
+    Starting from the current directory, replace on all Scala and config files, DataMeta version 1.2.1 with 1.2.3:
+        . com.acme.svc.schema.dom '*.conf,*.scala' 1.2.1 1.2.3
+
+Note the single quotes for the file glob patterns and the "star" specification of the source version: this is to
+prevent the shell to glob before passing the result to the program.
+
+Note that there is no relation between the path and the namespace; only Java still enforces such relation therefore
+we do not want to be dependent on it.
+
+~, errorText)
+end
+
+help 'Target path is missing' unless @path && !@path.empty?
+help %<"#{@path}" is not a valid path!> unless File.directory?(@path)
+help %<"#{@ns}" is not a valid namespace!> unless @ns.is_a?(String) && @ns =~ /^[\w_\.]+$/
+help 'No file globs specified' unless @globs_def && !@globs_def.empty?
+if @ver_from_spec == '*'
+    @ver_from = nil
+else
+    begin
+        @ver_from = DataMetaDom::SemVer.new(@ver_from_spec)
+    rescue Exception => x
+        help "Source version: #{x.message}"
+    end
+end
+
+begin
+    @ver_to = DataMetaDom::SemVer.new(@ver_to_spec)
+rescue Exception => x
+    help "Target version: #{x.message}"
+end
+
+begin
+    puts "Reversioning #{@globs_def} files starting from #{@path} to #{@ver_to}"
+    DataMetaDom::Ver.reVersion(@path, @ns, @globs_def.split(','), @ver_from, @ver_to)
+    puts 'Done.'
+rescue Exception => x
+    $stderr.puts %<ERROR #{x.message}
+    #{x.backtrace.join("\n\t")}>
+    exit 1
+end

data/bin/dataMetaSameFullJ.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# this script generates Full Compare DataMetaSame implementors
+# Sample:
+# mkdir ../../../../../target/pojo
+# dataMetaSameFullJ.rb ../../../dataMeta/showCase.dmDom ../../../../../target/pojo
+
+%w(dataMetaDom dataMetaDom/pojo dataMetaDom/help).each(&method(:require))
+
+source, target = ARGV
+raise ArgumentError, 'Usage: source DataMeta DOM, target directory' unless source && target
+DataMetaDom::PojoLexer.dataMetaSameRun DataMetaDom::PojoLexer::FULL_COMPARE, __FILE__, source, target
+
+puts "All-fields DataMeta-Sames written to #{target}. Done."

data/bin/dataMetaSameIdJ.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# this script generates Full Compare DataMetaSame implementors
+# Sample:
+# mkdir ../../../../../target/pojo
+# dataMetaSameIdJ.rb ../../../schema/showCase.dmDom ../../../../../target/pojo
+
+%w(dataMetaDom dataMetaDom/pojo dataMetaDom/help).each(&method(:require))
+
+source, target = ARGV
+raise ArgumentError, 'Usage: source DataMeta DOM, target directory' unless source && target
+DataMetaDom::PojoLexer.dataMetaSameRun DataMetaDom::PojoLexer::ID_ONLY_COMPARE, __FILE__, source, target
+puts "ID level DataMetaSames written to #{target}. Done."

data/lib/dataMetaDom/converter.rb

@@ -0,0 +1,70 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+%w(fileutils set).each { |r| require r }
+
+module DataMetaDom
+
+=begin
+Converter (ser/deser) code common to the DataMeta DOM.
+
+For command line details either check the new method's source or the README.rdoc file, the usage section.
+=end
+
+=begin rdoc
+Converter class definition, see implementations:
+* INTEGRAL_CONV
+* FRACT_CONV
+* BOOL_CONV
+* DTTM_CONV
+* TEXT_CONV
+=end
+class Converter
+
+=begin rdoc
+Lambda converting from a data type to matching textual.
+=end
+    attr_reader :ser
+
+=begin rdoc
+Lambda converting from a textual to matching data type.
+=end
+    attr_reader :deser
+
+=begin rdoc
+Creates an instance with the given parameters, two lambdas, see ser and deser properties for details.
+=end
+    def initialize(serialize, deserialize); @ser = serialize; @deser = deserialize end
+end
+
+=begin rdoc
+Converter for the integral types, meaning no fraction.
+=end
+INTEGRAL_CONV=Converter.new(lambda { |i| i ? i.to_s : nil }, lambda { |s| s ? s.to_i : nil })
+
+=begin rdoc
+Numbers with fraction, such as real numbers, aka floating point.
+=end
+FRACT_CONV=Converter.new(lambda { |f| f ? f.to_s : nil }, lambda { |s| s ? s.to_f : nil })
+
+=begin rdoc
+Converter for boolean.
+=end
+BOOL_CONV=Converter.new(lambda { |b| b ? b.to_s : nil },
+                        lambda { |s| s && !s.empty? ? ("TY1ty1".index(s[0]) ? true : false) : nil })
+=begin rdoc
+Converter for datetime.
+=end
+DTTM_CONV=Converter.new(lambda { |d| d ? "DateTime.parse('#{d}')" : nil }, lambda { |s| s ? DateTime.parse(s) : nil })
+# DateTime.to_s does exactly what we need, no more no less
+
+=begin rdoc
+Conterter for textual types, such as string or char.
+=end
+TEXT_CONV=Converter.new(lambda { |src| src.inspect }, lambda { |src| eval(src) })
+
+# All Converters hash keyed by the type, referencing an instance of the Converter class.
+CONVS={INT => INTEGRAL_CONV, STRING => TEXT_CONV, CHAR => TEXT_CONV, FLOAT => FRACT_CONV, NUMERIC => FRACT_CONV,
+       BOOL => BOOL_CONV, DATETIME => DTTM_CONV, URL => TEXT_CONV}
+
+
+end

data/lib/dataMetaDom/dataType.rb

@@ -0,0 +1,112 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+%w(fileutils set dataMetaDom/util).each { |r| require r }
+
+module DataMetaDom
+
+=begin rdoc
+DataMeta DOM Data Type, including the base type, length if any and scale if any.
+
+For command line details either check the new method's source or the README.rdoc file, the usage section.
+=end
+class DataType
+
+=begin rdoc
+Base type; either one of the standard types, see STANDARD_TYPES on the util.rb or fully named custom type
+such as a Record, an Enum, a Map, a BitSet.
+
+Use case of changing the type: multiple versions in one VM process.
+=end
+    attr_accessor :type
+
+=begin rdoc
+For those data types that have a dimension, such as length. See DIMMED_TYPES on the util.rb.
+=end
+    attr_reader :length
+
+=begin rdoc
+For those data types that have a scale. See SCALE_TYPES on the util.rb.
+=end
+    attr_reader :scale
+
+    class << self
+# The type must not feature a length
+        def mustNotDim(type)
+            !DIMMED_TYPES.member?(type) && !OPT_DIMMABLE.member?(type)
+        end
+
+# The type must feature a length > 0
+        def mustDim(type)
+            DIMMED_TYPES.member?(type)
+        end
+
+# The type may or may not feature a length
+        def canDim(type)
+            DIMMED_TYPES.member?(type) || OPT_DIMMABLE.member?(type)
+        end
+
+=begin rdoc
+Parses type definition from DataMeta DOM source, raising errors if anything is wrong.
+Returns a new instance of the DataType.
+=end
+        def parse(src, textual)
+            r = textual.scan(/([\w\.]+)(\[[\d\.]+\])?/)
+            raise "Invalid data type spec #{textual}" unless r
+            typeSpec, dimSpec = r[0]
+            type = typeSpec.to_sym
+            raise "The type #{type} can not be dimensioned" if DataType.mustNotDim(type) && dimSpec && !dimSpec.empty?
+            raise "The type #{type} must be dimensioned" if DataType.mustDim(type) && (!dimSpec || dimSpec.empty?)
+            length = nil; scale = nil
+            unless !dimSpec || dimSpec.empty?
+                raise "Invalid dimension format '#{dimSpec}'" unless dimSpec.scan(/^\[(\d+)\.?(\d+)?\]$/)
+                length = $1.to_i
+                scale = $2 ? $2.to_i : nil
+            end
+            @type = DataMetaDom.fullTypeName(src.namespace, type)
+            DataType.new @type, length, scale
+        end
+
+    end
+
+=begin rdoc
+Creates the instance with the given base type, the length and the scale
+=end
+    def initialize(t, len=nil, scale=nil)
+        raise ArgumentError, "The type #{t} can not have length" if DataType.mustNotDim(t) && len
+
+        raise ArgumentError, "The type #{type} must have length > 0, but \"#{len}\" specified" \
+          if DataType.mustDim(t) && (!len || len < 1)
+
+        @type = t.to_sym
+        @length = len
+        @scale = scale
+    end
+
+=begin rdoc
+Builds a length (dimension) and scale specification for this type according to the DataMeta DOM syntax.
+If the type does not have a dimension (no length, no scale), returns empty string.
+=end
+    def length_spec; @length && @length != 0 ? "[#{@length}" + (@scale ? '.' + @scale.to_s : '') + ']' : '' end
+
+# Textual representation of this isntance, includes the type spec with the length spec.
+    def to_s; "#{@type}#{length_spec}" end
+end
+
+# Reusable type - Integer of the length 1, aka Java's +byte+.
+INT1 = DataType.new(INT, 1)
+# Reusable type - Integer of the length 2, aka Java's +short+.
+INT2 = DataType.new(INT, 2)
+# Reusable type - Integer of the length 4, aka Java's +int+.
+INT4 = DataType.new(INT, 4)
+# Reusable type - Integer of the length 8, aka Java's +long+.
+INT8 = DataType.new(INT, 8)
+# Reusable type - Float (Real number) of the length 4, aka Java's +float+.
+FLOAT4 = DataType.new(FLOAT, 4)
+# Reusable type - Float (Real number) of the length 8, aka Java's +double+.
+FLOAT8 = DataType.new(FLOAT, 8)
+# Reusable type - DATETIME, in Java projected into <tt>java.time.ZonedDateTime</tt>.
+DTTM_TYPE = DataType.new(DATETIME)
+# Reusable type - URL, in Java projected into <tt>java.net.URL</tt>.
+URL_TYPE = DataType.new(URL)
+
+end