adiwg-mdtranslator 0.10.2 → 0.12.0

data/lib/adiwg/mdtranslator/readers/mdJson/modules_0.9/module_entityForeignKey.rb

@@ -0,0 +1,54 @@
+# unpack an data entity foreign key
+# Reader - ADIwg JSON V1 to internal data structure
+
+# History:
+# 	Stan Smith 2013-12-01 original script
+#   Stan Smith 2014-12-15 refactored to handle namespacing readers and writers
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module EntityForeignKey
+
+                    def self.unpack(hFKey)
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intFKey = intMetadataClass.newEntityForeignKey
+
+                        # entity foreign key - local attribute code name
+                        if hFKey.has_key?('localAttributeCodeName')
+                            aLocalAttributes = hFKey['localAttributeCodeName']
+                            unless aLocalAttributes.empty?
+                                intFKey[:fkLocalAttributes] = aLocalAttributes
+                            end
+                        end
+
+                        # entity foreign key - referenced entity code name
+                        if hFKey.has_key?('referencedEntityCodeName')
+                            s = hFKey['referencedEntityCodeName']
+                            if s != ''
+                                intFKey[:fkReferencedEntity] = s
+                            end
+                        end
+
+                        # entity foreign key - referenced attribute code name
+                        if hFKey.has_key?('referencedAttributeCodeName')
+                            aRefAttributes = hFKey['referencedAttributeCodeName']
+                            unless aRefAttributes.empty?
+                                intFKey[:fkReferencedAttributes] = aRefAttributes
+                            end
+                        end
+
+                        return intFKey
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/mdJson/modules_0.9/module_entityIndex.rb

@@ -0,0 +1,53 @@
+# unpack an data entity index
+# Reader - ADIwg JSON V1 to internal data structure
+
+# History:
+# 	Stan Smith 2013-12-01 original script
+#   Stan Smith 2014-12-15 refactored to handle namespacing readers and writers
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module EntityIndex
+
+                    def self.unpack(hIndex)
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intIndex = intMetadataClass.newEntityIndex
+
+                        # entity index - code name
+                        if hIndex.has_key?('codeName')
+                            s = hIndex['codeName']
+                            if s != ''
+                                intIndex[:indexCode] = s
+                            end
+                        end
+
+                        # entity index - allow duplicates
+                        if hIndex.has_key?('allowDuplicates')
+                            s = hIndex['allowDuplicates']
+                            if s != ''
+                                intIndex[:duplicate] = s
+                            end
+                        end
+
+                        # entity index - attribute list
+                        if hIndex.has_key?('attributeCodeName')
+                            aKeyAttributes = hIndex['attributeCodeName']
+                            unless aKeyAttributes.empty?
+                                intIndex[:attributeNames] = aKeyAttributes
+                            end
+                        end
+
+                        return intIndex
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/mdJson/modules_0.9/module_extent.rb

@@ -0,0 +1,73 @@
+# unpack extent
+# Reader - ADIwg JSON V1 to internal data structure
+
+# History:
+# 	Stan Smith 2013-11-04 original script
+# 	Stan Smith 2013-11-14 add temporal elements
+# 	Stan Smith 2013-11-14 add vertical elements
+# 	Stan Smith 2013-11-27 modified to process a single extent
+# 	Stan Smith 2013-12-05 modified to for new temporalElement schema
+#   Stan Smith 2014-07-07 resolve require statements using Mdtranslator.reader_module
+#   Stan Smith 2014-12-15 refactored to handle namespacing readers and writers
+
+require $ReaderNS.readerModule('module_geographicElement')
+require $ReaderNS.readerModule('module_temporalElement')
+require $ReaderNS.readerModule('module_verticalElement')
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module Extent
+
+                    def self.unpack(hExtent)
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intExtent = intMetadataClass.newExtent
+
+                        # extent - description
+                        if hExtent.has_key?('description')
+                            s = hExtent['description']
+                            if s != ''
+                                intExtent[:extDesc] = s
+                            end
+                        end
+
+                        # extent - geographic elements
+                        if hExtent.has_key?('geographicElement')
+                            aGeoElements = hExtent['geographicElement']
+                            unless aGeoElements.empty?
+                                intExtent[:extGeoElements] = $ReaderNS::GeographicElement.unpack(aGeoElements)
+                            end
+                        end
+
+                        # extent - temporal elements
+                        if hExtent.has_key?('temporalElement')
+                            hTempElement = hExtent['temporalElement']
+                            unless hTempElement.empty?
+                                intExtent[:extTempElements] = $ReaderNS::TemporalElement.unpack(hTempElement)
+                            end
+                        end
+
+                        # extent - vertical elements
+                        if hExtent.has_key?('verticalElement')
+                            aVertElements = hExtent['verticalElement']
+                            unless aVertElements.empty?
+                                aVertElements.each do |hVertElement|
+                                    intExtent[:extVertElements] << $ReaderNS::VerticalElement.unpack(hVertElement)
+                                end
+                            end
+                        end
+
+                        return intExtent
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/mdJson/modules_0.9/module_geoCoordSystem.rb

@@ -0,0 +1,57 @@
+# unpack GeoJSON properties
+# Reader - ADIwg JSON V1 to internal data structure
+
+# History:
+# 	Stan Smith 2014-04-30 original script
+#   Stan Smith 2014-12-15 refactored to handle namespacing readers and writers
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module GeoCoordSystem
+
+                    def self.unpack(hGeoCrs, intElement)
+
+                        intMetadataClass = InternalMetadata.new
+                        intSRS = intMetadataClass.newSRS
+
+                        # get coordinate reference system
+                        # null crs will default to CRS84 in writer
+                        if hGeoCrs.has_key?('properties')
+                            hCRSProp = hGeoCrs['properties']
+
+                            if hCRSProp.has_key?('name')
+                                s = hCRSProp['name']
+                                if s != ''
+                                    intSRS[:srsName] = s
+                                end
+                            end
+
+                            if hCRSProp.has_key?('href')
+                                s = hCRSProp['href']
+                                if s != ''
+                                    intSRS[:srsHref] = s
+                                end
+                            end
+
+                            if hCRSProp.has_key?('type')
+                                s = hCRSProp['type']
+                                if s != ''
+                                    intSRS[:srsType] = s
+                                end
+                            end
+
+                            intElement[:elementSrs] = intSRS
+
+                        end
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/mdJson/modules_0.9/module_geoProperties.rb

@@ -0,0 +1,100 @@
+# unpack GeoJSON properties
+# Reader - ADIwg JSON V1 to internal data structure
+
+# History:
+# 	Stan Smith 2014-04-29 original script
+#   Stan Smith 2014-07-07 resolve require statements using Mdtranslator.reader_module
+#   Stan Smith 2014-08-18 changed assignedId to identifier schema 0.6.0
+#   Stan Smith 2014-12-15 refactored to handle namespacing readers and writers
+
+require $ReaderNS.readerModule('module_temporalElement')
+require $ReaderNS.readerModule('module_verticalElement')
+require $ReaderNS.readerModule('module_resourceIdentifier')
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module GeoProperties
+
+                    def self.unpack(hGeoProps, intElement)
+
+                        # set element extent - (default true)
+                        intElement[:elementIncludeData] = true
+                        if hGeoProps.has_key?('includesData')
+                            if !hGeoProps['includesData']
+                                intElement[:elementIncludeData] = false
+                            end
+                        end
+
+                        # set element feature name
+                        if hGeoProps.has_key?('featureName')
+                            s = hGeoProps['featureName']
+                            if s != ''
+                                intElement[:elementName] = s
+                            end
+                        end
+
+                        # set element description
+                        if hGeoProps.has_key?('description')
+                            s = hGeoProps['description']
+                            if s != ''
+                                intElement[:elementDescription] = s
+                            end
+                        end
+
+                        # set temporal information
+                        if hGeoProps.has_key?('temporalElement')
+                            hTempEle = hGeoProps['temporalElement']
+                            unless hTempEle.empty?
+                                intElement[:temporalElements] = $ReaderNS::TemporalElement.unpack(hTempEle)
+                            end
+                        end
+
+                        # set vertical information
+                        if hGeoProps.has_key?('verticalElement')
+                            aVertEle = hGeoProps['verticalElement']
+                            unless aVertEle.empty?
+                                aVertEle.each do |hVertEle|
+                                    intElement[:verticalElements] << $ReaderNS::VerticalElement.unpack(hVertEle)
+                                end
+                            end
+                        end
+
+                        # set other assigned IDs
+                        if hGeoProps.has_key?('identifier')
+                            aResIds = hGeoProps['identifier']
+                            unless aResIds.empty?
+                                aResIds.each do |hIdentifier|
+                                    intElement[:elementIdentifiers] << $ReaderNS::ResourceIdentifier.unpack(hIdentifier)
+                                end
+                            end
+                        end
+
+                        # set feature scope
+                        if hGeoProps.has_key?('featureScope')
+                            s = hGeoProps['featureScope']
+                            if s != ''
+                                intElement[:elementScope] = s
+                            end
+                        end
+
+                        # set feature acquisition methodology
+                        if hGeoProps.has_key?('featureAcquisitionMethod')
+                            s = hGeoProps['featureAcquisitionMethod']
+                            if s != ''
+                                intElement[:elementAcquisition] = s
+                            end
+                        end
+
+                        return intElement
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/mdJson/modules_0.9/module_geographicElement.rb

@@ -0,0 +1,179 @@
+# unpack geographic element
+# Reader - ADIwg JSON V1 to internal data structure
+# determine element type
+
+# History:
+# 	Stan Smith 2013-11-04 original script
+# 	Stan Smith 2013-11-13 added line string
+# 	Stan Smith 2013-11-13 added multi line string
+# 	Stan Smith 2013-11-18 added polygon
+#   Stan Smith 2014-04-30 complete redesign for json schema 0.3.0
+#   Stan Smith 2014-05-22 added multi polygon
+#   Stan Smith 2014-05-23 cleaned up hash copy problem by using Marshal
+#   Stan Smith 2014-05-23 added direct geometry support for Point, Line, Polygon
+#   Stan Smith 2014-05-23 added direct geometry support for MultiPoint, MultiLine, MultiPolygon
+#   Stan Smith 2014-05-23 added direct support for geometryCollection
+#   Stan Smith 2014-07-07 resolve require statements using Mdtranslator.reader_module
+#   Stan Smith 2014-12-15 refactored to handle namespacing readers and writers
+
+require $ReaderNS.readerModule('module_geoCoordSystem')
+require $ReaderNS.readerModule('module_geoProperties')
+require $ReaderNS.readerModule('module_boundingBox')
+require $ReaderNS.readerModule('module_point')
+require $ReaderNS.readerModule('module_lineString')
+require $ReaderNS.readerModule('module_polygon')
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module GeographicElement
+
+                    def self.unpack(aGeoElements)
+
+                        # only one geometry is allowed per geographic element.
+                        # ... in GeoJSON each geometry is allowed a bounding box;
+                        # ... This code splits bounding boxes to separate elements
+
+                        # instance classes needed in script
+                        aIntGeoEle = Array.new
+
+                        aGeoElements.each do |hGeoJsonElement|
+
+                            # instance classes needed in script
+                            intMetadataClass = InternalMetadata.new
+                            hGeoElement = intMetadataClass.newGeoElement
+
+                            # find geographic element type
+                            if hGeoJsonElement.has_key?('type')
+                                elementType = hGeoJsonElement['type']
+                            else
+                                # invalid geographic element
+                                return nil
+                            end
+
+                            # set geographic element id
+                            if hGeoJsonElement.has_key?('id')
+                                s = hGeoJsonElement['id']
+                                if s != ''
+                                    hGeoElement[:elementId] = s
+                                end
+                            end
+
+                            # set geographic element coordinate reference system - CRS
+                            if hGeoJsonElement.has_key?('crs')
+                                hGeoCrs = hGeoJsonElement['crs']
+                                $ReaderNS::GeoCoordSystem.unpack(hGeoCrs, hGeoElement)
+                            end
+
+                            # set geographic element properties
+                            if hGeoJsonElement.has_key?('properties')
+                                hGeoProps = hGeoJsonElement['properties']
+                                $ReaderNS::GeoProperties.unpack(hGeoProps, hGeoElement)
+                            end
+
+                            # process geographic element bounding box
+                            # the bounding box must be represented as a separate geographic element for ISO
+                            # need to make a deep copy of current state of geographic element for bounding box
+                            if hGeoJsonElement.has_key?('bbox')
+                                if hGeoJsonElement['bbox'].length == 4
+                                    aBBox = hGeoJsonElement['bbox']
+
+                                    boxElement = Marshal.load(Marshal.dump(hGeoElement))
+                                    boxElement[:elementGeometry] = $ReaderNS::BoundingBox.unpack(aBBox)
+
+                                    aIntGeoEle << boxElement
+                                end
+                            end
+
+                            # unpack geographic element
+                            case elementType
+
+                                # GeoJSON Features
+                                when 'Feature'
+                                    if hGeoJsonElement.has_key?('geometry')
+                                        hGeometry = hGeoJsonElement['geometry']
+
+                                        # geoJSON requires geometry to be 'null' when geometry is bounding box only
+                                        # JSON null converts in parsing to ruby nil
+                                        unless hGeometry.nil?
+                                            unless hGeometry.empty?
+                                                if hGeometry.has_key?('type')
+                                                    geometryType = hGeometry['type']
+                                                    aCoordinates = hGeometry['coordinates']
+                                                    unless aCoordinates.empty?
+                                                        case geometryType
+                                                            when 'Point', 'MultiPoint'
+                                                                hGeoElement[:elementGeometry] = $ReaderNS::Point.unpack(aCoordinates, geometryType)
+                                                            when 'LineString', 'MultiLineString'
+                                                                hGeoElement[:elementGeometry] = $ReaderNS::LineString.unpack(aCoordinates, geometryType)
+                                                            when 'Polygon', 'MultiPolygon'
+                                                                hGeoElement[:elementGeometry] = $ReaderNS::Polygon.unpack(aCoordinates, geometryType)
+                                                            else
+                                                                # log - the GeoJSON geometry type is not supported
+                                                        end
+                                                        aIntGeoEle << hGeoElement
+                                                    end
+                                                end
+                                            end
+                                        end
+
+                                    end
+
+                                # GeoJSON Feature Collection
+                                when 'FeatureCollection'
+                                    if hGeoJsonElement.has_key?('features')
+                                        aFeatures = hGeoJsonElement['features']
+                                        unless aFeatures.empty?
+                                            intGeometry = intMetadataClass.newGeometry
+                                            intGeometry[:geoType] = 'MultiGeometry'
+                                            intGeometry[:geometry] = $ReaderNS::GeographicElement.unpack(aFeatures)
+                                            hGeoElement[:elementGeometry] = intGeometry
+                                            aIntGeoEle << hGeoElement
+                                        end
+                                    end
+
+                                # GeoJSON Geometries
+                                when 'Point', 'MultiPoint'
+                                    aCoordinates = hGeoJsonElement['coordinates']
+                                    hGeoElement[:elementGeometry] = $ReaderNS::Point.unpack(aCoordinates, elementType)
+                                    aIntGeoEle << hGeoElement
+
+                                when 'LineString', 'MultiLineString'
+                                    aCoordinates = hGeoJsonElement['coordinates']
+                                    hGeoElement[:elementGeometry] = $ReaderNS::LineString.unpack(aCoordinates, elementType)
+                                    aIntGeoEle << hGeoElement
+
+                                when 'Polygon', 'MultiPolygon'
+                                    aCoordinates = hGeoJsonElement['coordinates']
+                                    hGeoElement[:elementGeometry] = $ReaderNS::Polygon.unpack(aCoordinates, elementType)
+                                    aIntGeoEle << hGeoElement
+
+                                # GeoJSON Geometry Collection
+                                when 'GeometryCollection'
+                                    if hGeoJsonElement.has_key?('geometries')
+                                        aGeometries = hGeoJsonElement['geometries']
+                                        unless aGeometries.empty?
+                                            intGeometry = intMetadataClass.newGeometry
+                                            intGeometry[:geoType] = 'MultiGeometry'
+                                            intGeometry[:geometry] = $ReaderNS::GeographicElement.unpack(aGeometries)
+                                            hGeoElement[:elementGeometry] = intGeometry
+                                            aIntGeoEle << hGeoElement
+                                        end
+                                    end
+
+                            end
+
+                        end
+
+                        return aIntGeoEle
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end