charta 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fbd9a97d2afc3f7fac4856628353c24a686fad2a416c0d12dbb00b448f6d9a4
-  data.tar.gz: '0267836321e3643033bcd873e7672144a37bf0f0b293cd9440a7f01de84a02dc'
+  metadata.gz: 8f153424d966d80706e24233539f19c1efa2f7f5d013ac299046e51bd98e3ad8
+  data.tar.gz: '09fcff41f2a1f3d4a3cda3786c4a882f16b79cd551bda14c4083ebc351561956'
 SHA512:
-  metadata.gz: 76960df71f7e14223da5c28b93dfad64f6ffd563609408cf04eea019afb23c1f7fbeaf3a49775a251152581ac6650a8d9688e7d96230d3aed687cdcb90390eda
-  data.tar.gz: a987c577129ff328b5b8ae574b28dc83ea0a54a308c6e02c0986db53837f06d62429545c48dac75bd5a96b241f98beaaf6d63a5eab3d51ad56abfc31ffac3de3
+  metadata.gz: 2a366f56215565b6183f990e5cdd10a829871f0280bf923aaad2e7ab3afca35432196b24d5b921a41de5a763efda7b2672be2b8c3f93003f78583829ab8222a5
+  data.tar.gz: b19fece238165742bf01a44d2f7b500801629f2325737b1a36c9997d4a5e42ed12555299454ca4ae03db477a4ef69e84fec85dd3e66970865bfe60a8771c09a9

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'
-  spec.add_dependency 'json', '>= 1.8.0'
-  spec.add_dependency 'rgeo-geojson', '~> 1.0'
-  spec.add_dependency 'rgeo-proj4', '~> 1.0'
   spec.add_dependency 'activesupport', '~> 5.0'
+  spec.add_dependency 'json', '>= 1.8.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 'rake', '~> 10.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

@@ -4,19 +4,15 @@ require 'bigdecimal'
 require 'bigdecimal/util'
 require 'rgeo'
 require 'rgeo/proj4'
+require 'zeitwerk'
 
-require 'charta/coordinates'
-require 'charta/ewkt_serializer'
-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'
+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"
@@ -31,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)
@@ -111,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)
@@ -143,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/coordinates.rb

@@ -9,12 +9,12 @@ module Charta
 
       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
+        when 'FeatureCollection'
+          map_feature_collection_coordinates hash, &block
+        when 'Feature'
+          map_feature_coordinates hash, &block
+        else
+          map_geometry_coordinates hash, &block
         end
       end
 
@@ -41,16 +41,16 @@ module Charta
             coordinates = hash['coordinates']
             mapped =
               case hash['type']
-                when 'Point' then
-                  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, "Cannot handle: #{hash['type'].inspect}. In #{hash.inspect}"
+              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
@@ -62,4 +62,4 @@ module Charta
         end
     end
   end
-end
+end

data/lib/charta/ewkt_serializer.rb

@@ -11,6 +11,7 @@ module Charta
 
         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(', ') + ')'
@@ -18,6 +19,7 @@ module Charta
 
         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(', ') + ')'
@@ -29,11 +31,13 @@ module Charta
 
         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(', ') + ')'
@@ -41,6 +45,7 @@ module Charta
 
         def polygon_to_ewkt(hash)
           return 'POLYGON EMPTY' if hash['coordinates'].nil?
+
           'POLYGON(' + hash['coordinates'].collect do |hole|
             '(' + hole.collect do |point|
               point.join(' ')
@@ -50,6 +55,7 @@ module Charta
 
         def multi_point_to_ewkt(hash)
           return 'MULTIPOINT EMPTY' if hash['coordinates'].nil?
+
           'MULTIPOINT(' + hash['coordinates'].collect do |point|
             '(' + point.join(' ') + ')'
           end.join(', ') + ')'
@@ -57,6 +63,7 @@ module Charta
 
         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(' ')
@@ -66,6 +73,7 @@ module Charta
 
         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|
@@ -78,6 +86,7 @@ module Charta
         # 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|
@@ -89,4 +98,4 @@ module Charta
     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

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)
+          Geometry.feature(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