charta 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 94a236f9258dcbbbaa9a215a5af25e1ddeb904bb
-  data.tar.gz: 8251595d5fc8c7a70881108b37b43507b694f034
+SHA256:
+  metadata.gz: a9634870840f818207264c46799dc53cf3e37bf3f3d119e85dc470405ebcb8d1
+  data.tar.gz: 6453c04a73201f197c869b37d18a6ff0c262c8545ced384a13ecee48568279e1
 SHA512:
-  metadata.gz: 2440f9a26b7cd4d3d14c5f8b3840f3be1ba51ac7e11269c4ef2d5e615956d87f652b210b70861d803f11a1748533e67166c33732c946eac46f31e57470bf1496
-  data.tar.gz: a426cc2d10067261ad61666d63373cb7e28be1ac6c5b4887926b44d1ae7efe8e3d089e4092d19e791d6b5dc9df9ee6bbd96faa687568ae8253c3e367b7bfc6a2
+  metadata.gz: 658472714de5dbe3a618839ddf36858884b6d28ab520bab2c5140514d0a287931b52aa1278110dc3979a3ed40b2bc0c7cb7e11a9450bff9767ae32180ebe24f8
+  data.tar.gz: 675ea3982c1d1bb3465f68e272fb995dde17cc61f5af81837346a7431fc79d1fc82dc0661eb2528aab2903808d6e0941d20923fa62142db25eafa95eb32a00f6

data/charta.gemspec

@@ -1,30 +1,30 @@
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'charta/version'
+require_relative 'lib/charta/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'charta'
-  spec.version       = Charta::VERSION
-  spec.authors       = ['Brice TEXIER']
-  spec.email         = ['brice@ekylibre.com']
+  spec.name = 'charta'
+  spec.version = Charta::VERSION
+  spec.authors = ['Ekylibre developers']
+  spec.email = ['dev@ekylibre.com']
 
-  spec.summary       = 'Simple tool over geos and co'
-  spec.homepage      = 'https://github.com/ekylibre/charta'
-  spec.license       = 'MIT'
+  spec.summary = 'Simple tool over geos and co'
+  spec.required_ruby_version = '>= 2.6.0'
+  spec.homepage = 'https://gitlab.com/ekylibre'
+  spec.license = 'AGPL-3.0-only'
+
+  spec.files = Dir.glob(%w[lib/**/*.rb *.gemspec])
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'nokogiri', '>= 1.7.0'
-  spec.add_dependency 'rgeo', '~> 1.0.0'
+  spec.add_dependency 'activesupport', '~> 5.0'
   spec.add_dependency 'json', '>= 1.8.0'
-  spec.add_dependency 'rgeo-geojson', '~> 1.0.0'
-  spec.add_dependency 'rgeo-proj4', '~> 1.0.0'
-  spec.add_dependency 'activesupport', '>= 5.1'
-  spec.add_development_dependency 'bundler', '~> 1.14'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_dependency 'nokogiri', '>= 1.7.0'
+  spec.add_dependency 'rgeo', '~> 2.0'
+  spec.add_dependency 'rgeo-geojson', '~> 2.0'
+  spec.add_dependency 'rgeo-proj4', '~> 2.0'
+  spec.add_dependency 'zeitwerk', '~> 2.4.0'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'minitest', '~> 5.0'
-  spec.add_development_dependency 'byebug'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rubocop', '1.3.1'
 end

data/lib/charta.rb

@@ -1,17 +1,18 @@
 # Gathers geomatic calculations
 # Completes RGeo
+require 'bigdecimal'
+require 'bigdecimal/util'
 require 'rgeo'
 require 'rgeo/proj4'
-require 'charta/geometry'
-require 'charta/geometry_collection'
-require 'charta/point'
-require 'charta/line_string'
-require 'charta/polygon'
-require 'charta/multi_polygon'
-require 'charta/bounding_box'
-require 'charta/geo_json'
-require 'charta/gml'
-require 'charta/kml'
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  'geo_json' => 'GeoJSON',
+  'gml' => 'GML',
+  'kml' => 'KML'
+)
+loader.setup
 
 unless RGeo::CoordSys::Proj4.supported?
   puts "Proj4 is not supported. Some actions won't work"
@@ -26,75 +27,27 @@ module Charta
   }.freeze
 
   class << self
+    def default_feature_factory=(factory)
+      @default_feature_factory = factory
+      @geometry_factory = nil
+    end
+
+    # @deprecated This is deprecated and will be removed in 0.4
+    def default_feature_factory
+      @default_feature_factory || (self.default_feature_factory = Factory::SimpleFeatureFactory.build)
+    end
+
+    def geometry_factory
+      @geometry_factory ||= Factory::SimpleGeometryFactory.new(feature_factory: default_feature_factory)
+    end
+
+    # @deprecated This is deprecated and will be removed in 0.4
     def new_feature(coordinates, srs = nil, format = nil, _flatten_collection = true, _options = {})
-      geom_ewkt = nil
-      if coordinates.is_a?(RGeo::Feature::Instance)
-        return Geometry.feature(coordinates)
-      elsif coordinates.is_a?(::Charta::Geometry)
-        return coordinates
-      elsif coordinates.to_s =~ /\A[[:space:]]*\z/
-        geom_ewkt = empty_geometry(srs).to_ewkt
-      elsif coordinates.is_a?(Hash) || (coordinates.is_a?(String) && ::Charta::GeoJSON.valid?(coordinates)) # GeoJSON
-        srid = srs ? find_srid(srs) : :WGS84
-        geom_ewkt = ::Charta::GeoJSON.new(coordinates, srid).to_ewkt
-      elsif coordinates.is_a?(String)
-        geom_ewkt = if coordinates =~ /\A[A-F0-9]+\z/ # WKB
-                      if srs && srid = find_srid(srs)
-                        generate_ewkt RGeo::Geos.factory(srid: srid).parse_wkb(coordinates)
-                      else
-                        generate_ewkt Geometry.factory.parse_wkb(coordinates)
-                      end
-                    elsif format == 'gml' && ::Charta::GML.valid?(coordinates)
-                      # required format 'cause kml geometries return empty instead of failing
-                      ::Charta::GML.new(coordinates, srid).to_ewkt
-                    elsif format == 'kml' && ::Charta::KML.valid?(coordinates)
-                      ::Charta::KML.new(coordinates).to_ewkt
-                    elsif coordinates =~ /^SRID\=\d+\;/i
-                      if feature = Geometry.feature(coordinates)
-                        generate_ewkt feature
-                      else
-                        Charta::GeometryCollection.empty.feature
-                      end
-                    else # WKT expected
-                      if srs && srid = find_srid(srs)
-                        begin
-                          f = RGeo::Geos.factory(srid: srid).parse_wkt(coordinates)
-                        rescue RGeo::Error::ParseError => e
-                          raise "Invalid EWKT (#{e.message}): #{coordinates}"
-                        end
-                        generate_ewkt f
-                      else
-                        generate_ewkt Geometry.feature(coordinates)
-                      end
-                    end
-      else # Default for RGeo
-        geom_ewkt = generate_ewkt coordinates
-      end
-      if geom_ewkt.to_s =~ /\A[[:space:]]*\z/
-        raise ArgumentError, "Invalid data: coordinates=#{coordinates.inspect}, srid=#{srid.inspect}"
-      end
-      Geometry.feature(geom_ewkt)
+      default_feature_factory.new_feature(coordinates, srs: srs, format: format)
     end
 
     def new_geometry(coordinates, srs = nil, format = nil, _flatten_collection = true, _options = {})
-      return coordinates if coordinates.is_a?(::Charta::Geometry)
-      feature = Charta.new_feature(coordinates, srs, format, _flatten_collection, _options)
-      type = feature.geometry_type
-      geom = case type
-             when RGeo::Feature::Point then
-               Point.new(feature)
-             when RGeo::Feature::LineString then
-               LineString.new(feature)
-             when RGeo::Feature::Polygon then
-               Polygon.new(feature)
-             when RGeo::Feature::MultiPolygon then
-               MultiPolygon.new(feature)
-             when RGeo::Feature::GeometryCollection then
-               GeometryCollection.new(feature)
-             else
-               Geometry.new(feature)
-             end
-      geom
+      geometry_factory.new_geometry(coordinates, srs: srs, format: format)
     end
 
     def new_point(lat, lon, srid = 4326)
@@ -106,12 +59,18 @@ module Charta
       options[:srid] ||= new_geometry(points.first).srid if points.any?
       options[:srid] ||= 4326
 
-      ewkt = "SRID=#{options[:srid]};LINESTRING(" + points.map { |wkt| p = new_geometry(wkt); "#{p.x} #{p.y}" }.join(', ') + ')'
+      points_coordinates = points.map do |wkt|
+        p = new_geometry(wkt)
+
+        "#{p.x} #{p.y}"
+      end
+
+      ewkt = "SRID=#{options[:srid]};LINESTRING(#{points_coordinates.join(', ')})"
       new_geometry(ewkt)
     end
 
     def empty_geometry(srid = :WGS84)
-      GeometryCollection.empty(srid)
+      geometry_factory.empty_geometry(srid)
     end
 
     def generate_ewkt(feature)
@@ -138,23 +97,16 @@ module Charta
     end
 
     # Check and returns the SRID matching with srname or SRID.
+    # @deprecated
     def find_srid(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
+      Factory::SridProvider.build.find(srname_or_srid)
     end
 
     def from(format, data)
       unless respond_to?("from_#{format}")
         raise "Unknown format: #{format.inspect}"
       end
+
       send("from_#{format}", data)
     end
 

data/lib/charta/bounding_box.rb

@@ -24,5 +24,9 @@ module Charta
     def to_a
       [[@y_min, @x_min], [@y_max, @x_max]]
     end
+
+    def to_bbox_string
+      "#{@x_min}, #{@y_min}, #{x_max}, #{y_max}"
+    end
   end
 end

data/lib/charta/coordinates.rb

@@ -0,0 +1,65 @@
+module Charta
+  module Coordinates
+    class << self
+
+      # Force coordinates to 2D
+      def flatten(hash)
+        map_coordinates(hash) { |position| position[0..1] }
+      end
+
+      def map_coordinates(hash, &block)
+        case hash['type']
+        when 'FeatureCollection'
+          map_feature_collection_coordinates hash, &block
+        when 'Feature'
+          map_feature_coordinates hash, &block
+        else
+          map_geometry_coordinates hash, &block
+        end
+      end
+
+      def normalize_4326_geometry(json)
+        map_coordinates json do |(x, y)|
+          [((x + 180.to_d) % 360.to_d) - 180.to_d, ((y + 90.to_d) % 180.to_d) - 90.to_d]
+        end
+      end
+
+      private
+
+        def map_feature_collection_coordinates(hash, &block)
+          hash.merge 'features' => hash['features'].map { |feature| map_feature_coordinates feature, &block }
+        end
+
+        def map_feature_coordinates(hash, &block)
+          hash.merge 'geometry' => map_geometry_coordinates(hash['geometry'], &block)
+        end
+
+        def map_geometry_coordinates(hash, &block)
+          if hash['type'] == 'GeometryCollection'
+            map_geometry_collection_coordinates hash, &block
+          else
+            coordinates = hash['coordinates']
+            mapped =
+              case hash['type']
+              when 'Point'
+                block.call coordinates
+              when 'MultiPoint', 'LineString'
+                coordinates.map(&block)
+              when 'MultiLineString', 'Polygon'
+                coordinates.map { |line| line.map(&block) }
+              when 'MultiPolygon'
+                coordinates.map { |poly| poly.map { |line| line.map(&block) } }
+              else
+                raise StandardError.new("Cannot handle: #{hash['type'].inspect}. In #{hash.inspect}")
+              end
+
+            hash.merge 'coordinates' => mapped
+          end
+        end
+
+        def map_geometry_collection_coordinates(hash, &block)
+          hash.merge 'geometries' => hash['geometries'].map { |geometry| map_geometry_coordinates(geometry, &block) }
+        end
+    end
+  end
+end

data/lib/charta/ewkt_serializer.rb

@@ -0,0 +1,101 @@
+module Charta
+  module EwktSerializer
+
+    class << self
+      def object_to_ewkt(hash)
+        type = hash[:type] || hash['type']
+        send("#{type.gsub(/(.)([A-Z])/, '\1_\2').downcase}_to_ewkt", hash)
+      end
+
+      private
+
+        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(', ') + ')'
+        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(', ') + ')'
+        end
+    end
+
+  end
+end

data/lib/charta/factory/ewkt_feature_builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    class EwktFeatureBuilder
+      # @param [String] ewkt EWKT representation of a feature
+      # @return [RGeo::Feature::Instance]
+      def from_ewkt(ewkt)
+        if ewkt.to_s =~ /\A[[:space:]]*\z/
+          raise ArgumentError.new("Invalid data: #{ewkt.inspect}")
+        end
+
+        Geometry.feature(ewkt)
+      end
+    end
+  end
+end

data/lib/charta/factory/feature_factory_base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Charta
+  module Factory
+    class FeatureFactoryBase
+      def new_feature(coordinates, srs: nil, format: nil)
+        raise StandardError.new('Not implemented')
+      end
+
+      def empty_feature(srs = :WGS84)
+        new_feature('GEOMETRYCOLLECTION EMPTY', srs: srs)
+      end
+    end
+  end
+end