charta 0.2.0 → 0.3.1

data/lib/charta/factory/simple_feature_factory.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    class SimpleFeatureFactory < FeatureFactoryBase
+      class << self
+        def build
+          new(
+            ewkt_builder: EwktFeatureBuilder.new,
+            srid_provider: SridProvider.build,
+            transformer: Transformers::EwktTransformerChain.build
+          )
+        end
+      end
+
+      # @return [EwktFeatureBuilder]
+      attr_reader :ewkt_builder
+      # @return [SridProvider]
+      attr_reader :srid_provider
+      # @return [Transformers::EwktTransformer]
+      attr_reader :transformer
+
+      def initialize(ewkt_builder:, srid_provider:, transformer:)
+        @ewkt_builder = ewkt_builder
+        @srid_provider = srid_provider
+        @transformer = transformer
+      end
+
+      def new_feature(coordinates, srs: nil, format: nil)
+        if coordinates.is_a?(Charta::Geometry)
+          coordinates
+        elsif coordinates.is_a?(RGeo::Feature::Instance)
+          new_feature(Charta.generate_ewkt(coordinates))
+        elsif coordinates.to_s =~ /\A[[:space:]]*\z/
+          empty_feature(srs)
+        else
+          convert_feature(coordinates, srs: srs, format: format)
+        end
+      end
+
+      private
+
+        def convert_feature(coordinates, srs: nil, format: nil)
+          srid = srs.nil? ? nil : srid_provider.find(srs)
+
+          ewkt_builder.from_ewkt(transformer.transform(coordinates, srid: srid, format: format))
+        end
+    end
+  end
+end

data/lib/charta/factory/simple_geometry_factory.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    class SimpleGeometryFactory
+      # @return [SimpleFeatureFactory]
+      attr_reader :feature_factory
+
+      # @param [SimpleFeatureFactory] feature_factory
+      def initialize(feature_factory:)
+        @feature_factory = feature_factory
+      end
+
+      def new_geometry(coordinates, srs: nil, format: nil)
+        if coordinates.is_a?(::Charta::Geometry)
+          coordinates
+        else
+          wrap(feature_factory.new_feature(coordinates, srs: srs, format: format))
+        end
+      end
+
+      def empty_geometry(srs)
+        wrap(feature_factory.empty_feature(srs))
+      end
+
+      protected
+
+        def wrap(feature)
+          case feature.geometry_type
+          when RGeo::Feature::Point
+            Point.new(feature)
+          when RGeo::Feature::LineString
+            LineString.new(feature)
+          when RGeo::Feature::Polygon
+            Polygon.new(feature)
+          when RGeo::Feature::MultiPolygon
+            MultiPolygon.new(feature)
+          when RGeo::Feature::GeometryCollection
+            GeometryCollection.new(feature)
+          else
+            Geometry.new(feature)
+          end
+        end
+    end
+  end
+end

data/lib/charta/factory/srid_provider.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    class SridProvider
+      SRS = {
+        WGS84: 4326,
+        CRS84: 4326,
+        RGF93: 2143
+      }.freeze
+
+      class << self
+        def build
+          new(SRS)
+        end
+      end
+
+      def initialize(srs)
+        @srs = srs
+      end
+
+      def find(srname_or_srid)
+        if srname_or_srid.to_s =~ /\Aurn:ogc:def:crs:.*\z/
+          x = srname_or_srid.split(':').last.upcase.to_sym
+          @srs[x] || x
+        elsif srname_or_srid.to_s =~ /\AEPSG::?(\d{4,5})\z/
+          srname_or_srid.split(':').last
+        elsif srname_or_srid.to_s =~ /\A\d+\z/
+          srname_or_srid.to_i
+        else
+          @srs[srname_or_srid] || srname_or_srid
+        end
+      end
+    end
+  end
+end

data/lib/charta/factory/transformers/ewkt_passthrough.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    module Transformers
+      class EwktPassthrough < EwktTransformer
+        # @return [Boolean]
+        def handles?(value, format:)
+          value.is_a?(String) && format.nil?
+        end
+
+        # @param [String, Hash] value
+        # @return [String] ewkt representation of value
+        def transform(value, srid: nil, format: nil)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/charta/factory/transformers/ewkt_transformer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    module Transformers
+      class EwktTransformer
+        # @return [Boolean]
+        def handles?(value, format:)
+          false
+        end
+
+        # @param [String, Hash] value
+        # @return [String] ewkt representation of value
+        def transform(value, srid: nil, format: nil)
+          raise StandardError.new('Not implemented')
+        end
+      end
+    end
+  end
+end

data/lib/charta/factory/transformers/ewkt_transformer_chain.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    module Transformers
+      class EwktTransformerChain < EwktTransformer
+        class << self
+          def build
+            new(
+              Transformers::FromGeoJsonTransformer.new,
+              Transformers::FromWkbTransformer.new,
+              Transformers::FromGmlTransformer.new,
+              Transformers::FromKmlTransformer.new,
+              Transformers::EwktPassthrough.new
+            )
+          end
+        end
+
+        # @return [Array<EwktTransformer>]
+        attr_reader :transformers
+
+        def initialize(*transformers)
+          @transformers = transformers
+        end
+
+        # @return [Boolean]
+        def handles?(value, format:)
+          transformers.any? { |t| t.handles?(value, format: format) }
+        end
+
+        # @param [String, Hash] value
+        # @return [String] ewkt representation of value
+        def transform(value, srid: nil, format: nil)
+          transformer = transformers.detect { |t| t.handles?(value, format: format) }
+          raise TransformationError.new('Not handled') if transformer.nil?
+
+          transformer.transform(value, srid: srid, format: format)
+        end
+      end
+    end
+  end
+end

data/lib/charta/factory/transformers/from_geo_json_transformer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    module Transformers
+      class FromGeoJsonTransformer < EwktTransformer
+        # @return [Boolean]
+        def handles?(value, format:)
+          value.is_a?(Hash) || (value.is_a?(String) && Charta::GeoJSON.valid?(value)) # GeoJSON
+        end
+
+        # @param [String, Hash] value
+        # @return [String] ewkt representation of value
+        def transform(value, srid: nil, format: nil)
+          Charta::GeoJSON.new(value, srid).to_ewkt
+        end
+      end
+    end
+  end
+end

data/lib/charta/factory/transformers/from_gml_transformer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    module Transformers
+      class FromGmlTransformer < EwktTransformer
+        # @return [Boolean]
+        def handles?(value, format:)
+          value.is_a?(String) && format == 'gml' && Charta::GML.valid?(value)
+        end
+
+        # @param [String, Hash] value
+        # @return [String] ewkt representation of value
+        def transform(value, srid: nil, format: nil)
+          Charta::GML.new(value, srid).to_ewkt
+        end
+      end
+    end
+  end
+end

data/lib/charta/factory/transformers/from_kml_transformer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    module Transformers
+      class FromKmlTransformer < EwktTransformer
+        # @return [Boolean]
+        def handles?(value, format:)
+          value.is_a?(String) && format == 'kml' && Charta::KML.valid?(value)
+        end
+
+        # @param [String, Hash] value
+        # @return [String] ewkt representation of value
+        def transform(value, srid: nil, format: nil)
+          Charta::KML.new(value, srid).to_ewkt
+        end
+      end
+    end
+  end
+end

data/lib/charta/factory/transformers/from_wkb_transformer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    module Transformers
+      class FromWkbTransformer < EwktTransformer
+        # @return [Boolean]
+        def handles?(value, format:)
+          value.is_a?(String) && !!(value =~ /\A[A-F0-9]+\z/)
+        end
+
+        # @param [String, Hash] value
+        # @return [String] ewkt representation of value
+        def transform(value, srid: nil, format: nil)
+          if srid.nil?
+            Geometry.factory.parse_wkb(value)
+          else
+            RGeo::Geos.factory(srid: srid).parse_wkb(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/charta/factory/transformers/transformation_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    module Transformers
+      class TransformationError < StandardError
+      end
+    end
+  end
+end

data/lib/charta/geo_json.rb

@@ -7,12 +7,14 @@ module Charta
 
     def initialize(data, srid = :WGS84)
       srid ||= :WGS84
-      @json = self.class.flatten(data.is_a?(Hash) ? data : JSON.parse(data))
+      @json = Coordinates.flatten(data.is_a?(Hash) ? data : JSON.parse(data))
       lsrid = @json['crs']['properties']['name'] if @json.is_a?(Hash) &&
                                                     @json['crs'].is_a?(Hash) &&
                                                     @json['crs']['properties'].is_a?(Hash)
       lsrid ||= srid
       @srid = ::Charta.find_srid(lsrid)
+
+      @json = Coordinates.normalize_4326_geometry(@json) if @srid.to_i == 4326
     end
 
     def geom
@@ -24,7 +26,7 @@ module Charta
     end
 
     def to_ewkt
-      "SRID=#{@srid};" + self.class.object_to_ewkt(@json)
+      "SRID=#{srid};" + EwktSerializer.object_to_ewkt(@json)
     end
 
     def valid?
@@ -42,131 +44,17 @@ module Charta
         false
       end
 
-      # Force coordinates to 2D
       def flatten(hash)
-        if hash['type'] == 'FeatureCollection'
-          flatten_feature_collection(hash)
-        elsif hash['type'] == 'Feature'
-          flatten_feature(hash)
-        else
-          flatten_geometry(hash)
-        end
-      end
-
-      def flatten_feature_collection(hash)
-        hash.merge('features' => hash['features'].map { |f| flatten_feature(f) })
-      end
-
-      def flatten_feature(hash)
-        hash.merge('geometry' => flatten_geometry(hash['geometry']))
-      end
-
-      def flatten_geometry(hash)
-        coordinates = hash['coordinates']
-        flattened =
-          case hash['type']
-          when 'Point' then
-            flatten_position(coordinates)
-          when 'MultiPoint', 'LineString'
-            coordinates.map { |p| flatten_position(p) }
-          when 'MultiLineString', 'Polygon'
-            coordinates.map { |l| l.map { |p| flatten_position(p) } }
-          when 'MultiPolygon'
-            coordinates.map { |m| m.map { |l| l.map { |p| flatten_position(p) } } }
-          when 'GeometryCollection' then
-            return hash.merge('geometries' => hash['geometries'].map { |g| flatten_geometry(g) })
-          else
-            raise StandardError, "Cannot handle: #{hash['type'].inspect}. In #{hash.inspect}"
-          end
-
-        hash.merge('coordinates' => flattened)
-      end
-
-      def flatten_position(position)
-        position[0..1]
-      end
-
-      def object_to_ewkt(hash)
-        type = hash[:type] || hash['type']
-        send("#{type.gsub(/(.)([A-Z])/, '\1_\2').downcase}_to_ewkt", hash)
-      end
-
-      def feature_collection_to_ewkt(hash)
-        return 'GEOMETRYCOLLECTION EMPTY' if hash['features'].nil?
-        'GEOMETRYCOLLECTION(' + hash['features'].collect do |feature|
-          object_to_ewkt(feature)
-        end.join(', ') + ')'
-      end
-
-      def geometry_collection_to_ewkt(hash)
-        return 'GEOMETRYCOLLECTION EMPTY' if hash['geometries'].nil?
-        'GEOMETRYCOLLECTION(' + hash['geometries'].collect do |feature|
-          object_to_ewkt(feature)
-        end.join(', ') + ')'
-      end
-
-      def feature_to_ewkt(hash)
-        object_to_ewkt(hash['geometry'])
-      end
-
-      def point_to_ewkt(hash)
-        return 'POINT EMPTY' if hash['coordinates'].nil?
-        'POINT(' + hash['coordinates'].join(' ') + ')'
-      end
-
-      def line_string_to_ewkt(hash)
-        return 'LINESTRING EMPTY' if hash['coordinates'].nil?
-        'LINESTRING(' + hash['coordinates'].collect do |point|
-          point.join(' ')
-        end.join(', ') + ')'
-      end
-
-      def polygon_to_ewkt(hash)
-        return 'POLYGON EMPTY' if hash['coordinates'].nil?
-        'POLYGON(' + hash['coordinates'].collect do |hole|
-          '(' + hole.collect do |point|
-            point.join(' ')
-          end.join(', ') + ')'
-        end.join(', ') + ')'
-      end
-
-      def multi_point_to_ewkt(hash)
-        return 'MULTIPOINT EMPTY' if hash['coordinates'].nil?
-        'MULTIPOINT(' + hash['coordinates'].collect do |point|
-          '(' + point.join(' ') + ')'
-        end.join(', ') + ')'
-      end
-
-      def multi_line_string_to_ewkt(hash)
-        return 'MULTILINESTRING EMPTY' if hash['coordinates'].nil?
-        'MULTILINESTRING(' + hash['coordinates'].collect do |line|
-          '(' + line.collect do |point|
-            point.join(' ')
-          end.join(', ') + ')'
-        end.join(', ') + ')'
-      end
-
-      def multipolygon_to_ewkt(hash)
-        return 'MULTIPOLYGON EMPTY' if hash['coordinates'].nil?
-        'MULTIPOLYGON(' + hash['coordinates'].collect do |polygon|
-          '(' + polygon.collect do |hole|
-            '(' + hole.collect do |point|
-              point.join(' ')
-            end.join(', ') + ')'
-          end.join(', ') + ')'
-        end.join(', ') + ')'
+        Coordinates.flatten hash
       end
 
-      # for PostGIS ST_ASGeoJSON compatibility
-      def multi_polygon_to_ewkt(hash)
-        return 'MULTIPOLYGON EMPTY' if hash['coordinates'].nil?
-        'MULTIPOLYGON(' + hash['coordinates'].collect do |polygon|
-          '(' + polygon.collect do |hole|
-            '(' + hole.collect do |point|
-              point.join(' ')
-            end.join(', ') + ')'
-          end.join(', ') + ')'
-        end.join(', ') + ')'
+      %i[
+        object_to_ewkt feature_collection_to_ewkt geometry_collection_to_ewkt feature_to_ewkt point_to_ewkt line_string_to_ewkt
+        polygon_to_ewkt multi_point_to_ewkt multi_line_string_to_ewkt multipolygon_to_ewkt multi_polygon_to_ewkt
+      ].each do |m|
+        define_method m do |*args|
+          EwktSerializer.send m, *args
+        end
       end
     end
   end