geosparql_to_geojson 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8745dbc21bfac65f5e4ff1e9a195d561d9f15d5c
-  data.tar.gz: 3f52ce971cf31c957258a911506ff2c76f714ef8
+  metadata.gz: ade4cd28437367ccc541abe72a5e55b689768a47
+  data.tar.gz: 15ea869f499f0e99191d615c5187716705fc3861
 SHA512:
-  metadata.gz: 4614f07cac499f359243bc66a76c952914995a51ca834ffd0fc5f02f5f2ea2c23c298bd18e1a52b12b2dc192572fbeec4563e763f74bf177e122d08915e8909a
-  data.tar.gz: 5c64b4b1db9f453052e9ed53b80bcb034df71d7097cdcf7950e9c405c113a424caff02a71bfe0b0bce66af27110fc2c2fa8e0683541ada4f6cdeb5f1e04aeb9c
+  metadata.gz: b2dc79686b00b5e1868be0fe1a0972459901675a1cf66d248f18672eaad5e548c782a3f945f28054e516a91410836d59a59f6971ca8ac6e73cade017dd7e3376
+  data.tar.gz: 791611cb8d76ad9b7971dfc6947735e70283537c80c48be7857fdbd2bf81a953a14b1390356fcec98da6f134f27525e4bb3538404d3d32077742a17f448ba127

data/gocd/web1live.yaml

@@ -0,0 +1,30 @@
+pipelines:
+  GEM-geosparql-to-geojson:
+    group: Dependencies
+    label_template: "${COUNT}"
+    materials:
+      GEM-geosparql-to-geojson-git:
+        git: https://github.com/ukparliament/geosparql_to_geojson.git
+        branch: master
+        auto_update: true
+    stages:
+      - deploy:
+          approval: manual
+          jobs:
+            deploy:
+              tasks:
+                - exec:
+                    run_if: passed
+                    command: make
+                    arguments:
+                      - checkout_to_release
+                - exec:
+                    run_if: passed
+                    command: make
+                    arguments:
+                      - deploy_to_release
+
+environments:
+  Web.LIVE:
+    pipelines:
+      - GEM-geosparql-to-geojson

data/lib/geosparql_to_geojson.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'geosparql_to_geojson/version'
 require 'geosparql_to_geojson/converter'
 require 'geosparql_to_geojson/geojson'
@@ -14,6 +16,6 @@ module GeosparqlToGeojson
   #
   # @return [GeosparqlToGeojson::GeoJson]
   def self.convert_to_geojson(geosparql_values: '', geosparql_properties: {}, reverse: false)
-    GeosparqlToGeojson::Converter.new(geosparql_values, geosparql_properties, reverse).convert
+    GeosparqlToGeojson::Converter::BaseConverter.new(geosparql_values, geosparql_properties, reverse).convert
   end
 end

data/lib/geosparql_to_geojson/converter.rb

@@ -1,148 +1,16 @@
+# frozen_string_literal: true
+
 require 'json'
 
+# Namespace for classes and modules that deal with converting GeoSparql to GeoJSON
+#
+# @since 0.1.0
 module GeosparqlToGeojson
-  # Class to convert GeoSparql to GeoJSON data.
+  # Namespace for classes that convert GeoSparql to GeoJSON data.
   #
-  # @since 0.1.0
-  class Converter
-    # Constant containing hash of GeoSparql types and the correctly formatted version.
-    GEOSPARQL_TYPES = {
-      polygon:            :Polygon,
-      point:              :Point,
-      multipoint:         :MultiPoint,
-      linestring:         :LineString,
-      multipolygon:       :MultiPolygon,
-      geometrycollection: :GeometryCollection,
-      multiline:          :Multiline
-    }.freeze
-
-    # Constant regex containing every GeoSparql data type that finds the type and the type's values.
-    GEOMETRY_REGEX = /(#{GEOSPARQL_TYPES.values.join('|')})\(+(.*?)\)+/i
-
-    # Creates a new instance of GeosparqlToGeojson::Converter
-    #
-    # @param [String] geosparql_data the GeoSparql data to be converted into GeoJSON.
-    def initialize(geosparql_values, geosparql_properties, reverse)
-      @geosparql_values     = geosparql_values
-      @geosparql_properties = geosparql_properties
-      @reverse              = reverse
-    end
-
-    # Method calls GeosparqlToGeojson::Converter#collect_geosparql_data to start converting data.
-    #
-    # @example Converting GeoSparql string into GeoJSON
-    #   GeosparqlToGeojson::Converter.new('Point(1.23 9.87)').convert
-    #   #=> '{
-    #          "type": "FeatureCollection",
-    #          "features": [
-    #            {
-    #              "type": "Feature",
-    #              "geometry": {
-    #                "type": "Point",
-    #                "coordinates": [
-    #                  1.23,
-    #                  9.87
-    #                ]
-    #              },
-    #              "properties": {}
-    #        }'
-    def convert
-      GeosparqlToGeojson::GeoJson.new(collect_geosparql_data)
-    end
-
-    private
-
-    # Creates a hash of each GeoSparql type present and it's values.
-    def collect_geosparql_data
-      @data_store = {}
-
-      if @geosparql_values.is_a?(Array)
-        @geosparql_values.each do |value|
-          scanned_data = value.scan(GEOMETRY_REGEX)
-          populate_data_hash(scanned_data)
-        end
-      else
-        scanned_data = @geosparql_values.scan(GEOMETRY_REGEX)
-        populate_data_hash(scanned_data)
-      end
-
-      format_geosparql_data
-    end
-
-    # Sets the hash key to the GeoSparql type if it isn't already set and adds the GeoSparql values
-    def populate_data_hash(scanned_geosparql_data)
-      scanned_geosparql_data.each do |data|
-        key = convert_key_to_correct_format(data[0])
-        @data_store[key] = [] unless @data_store[key]
-        @data_store[key] << data[1]
-      end
-    end
-
-    # Converts the key that's captured by the regex into the correct format
-    def convert_key_to_correct_format(key)
-      key = key.downcase
-      GEOSPARQL_TYPES[key.to_sym]
-    end
-
-    # Splits values into arrays and converts them into floats.
-    def format_geosparql_data
-      @data_store.keys.each do |key|
-        @data_store[key.to_sym].map! do |values|
-          format_data(values, key)
-        end
-      end
-
-      generate_hash_from_values
-    end
-
-    # Formats GeoSparql data.
-    # Will reverse the values if @reverse is set to true.
-    #
-    # @param [String] values the GeoSparql data to be converted into GeoJSON.
-    # @param [Symbol] key the type of GeoSparql data
-    #
-    # @return [Array]
-    def format_data(values, key)
-      values = values.first if values.is_a?(Array)
-      values = values.split(/[\s]|[,]/).map!(&:to_f)
-      values.reverse! if @reverse
-
-      values = values.each_slice(2).to_a if key != :Point
-      values = [values] if key != :Point && key != :LineString
-      values
-    end
-
-    # Created a hash from the GeoSparql values in the GeoJSON 'Feature' format.
-    def generate_hash_from_values
-      @data_hash_array = []
-      @data_store.keys.each do |key|
-        @data_store[key.to_sym].each do |data|
-          @data_hash_array << generate_feature_hash(type: key.to_s, coordinates: data)
-        end
-      end
-
-      generate_feature_collection
-    end
-
-    # Adds converted GeoSparql data to a GeoJSON 'feature' type.
-    #
-    # @return [Hash] a hash containing GeoSparql data
-    def generate_feature_hash(data_hash)
-      {
-        type: 'Feature',
-        geometry: data_hash,
-        properties: @geosparql_properties
-      }
-    end
-
-    # Adds GeoJSON 'feature' hash to a GeoJSON 'FeatureCollections' type.
-    #
-    # @return [String] a string of GeoJSON
-    def generate_feature_collection
-      {
-        type: 'FeatureCollection',
-        features: @data_hash_array
-      }.to_json
-    end
+  # @since 0.2.0
+  module Converter
+    require 'geosparql_to_geojson/converter/base_converter'
+    require 'geosparql_to_geojson/converter/polygon_converter'
   end
 end

data/lib/geosparql_to_geojson/converter/base_converter.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+# Namespace for classes and modules that deal with converting GeoSparql to GeoJSON
+#
+# @since 0.1.0
+module GeosparqlToGeojson
+  # Namespace for classes that convert GeoSparql to GeoJSON data.
+  #
+  # @since 0.2.0
+  module Converter
+    # Class to convert GeoSparql to GeoJSON data.
+    #
+    # @since 0.1.0
+    # @attr_reader [String] geosparql_values the GeoSPARQL values to be converted.
+    # @attr_reader [Hash] geosparql_properties the GeoJSON properties to be added to the converted GeoSPARQL.
+    # @attr_reader [Boolean] reverse whether the polygon data needs to be reversed.
+    class BaseConverter
+      attr_reader :geosparql_values, :geosparql_properties, :reverse
+
+      # Constant containing hash of GeoSparql types and the correctly formatted version.
+      GEOSPARQL_TYPES = {
+        polygon:            :Polygon,
+        point:              :Point,
+        multipoint:         :MultiPoint,
+        linestring:         :LineString,
+        multipolygon:       :MultiPolygon,
+        geometrycollection: :GeometryCollection,
+        multiline:          :Multiline
+      }.freeze
+
+      # Constant regex containing every GeoSparql data type that finds the type and the type's values.
+      GEOMETRY_REGEX = /(#{GEOSPARQL_TYPES.values.join('|')})?\(+(.*?)\)+/i
+
+      # Creates a new instance of GeosparqlToGeojson::Converter::BaseConverter
+      #
+      # @param [String] geosparql_values the GeoSparql data to be converted into GeoJSON.
+      # @param [Hash] geosparql_properties the properties to be added to the formatted GeoJSON.
+      # @param [Boolean] reverse the geosparql_values data.
+      def initialize(geosparql_values, geosparql_properties, reverse)
+        @geosparql_values     = geosparql_values
+        @geosparql_properties = geosparql_properties
+        @reverse              = reverse
+      end
+
+      # Method calls GeosparqlToGeojson::Converter#collect_geosparql_data to start converting data.
+      #
+      # @example Converting GeoSparql string into GeoJSON
+      #   GeosparqlToGeojson::Converter.new('Point(1.23 9.87)').convert
+      #   #=> '{
+      #          "type": "FeatureCollection",
+      #          "features": [
+      #            {
+      #              "type": "Feature",
+      #              "geometry": {
+      #                "type": "Point",
+      #                "coordinates": [
+      #                  1.23,
+      #                  9.87
+      #                ]
+      #              },
+      #              "properties": {}
+      #        }'
+      def convert
+        GeosparqlToGeojson::GeoJson.new(collect_geosparql_data)
+      end
+
+      private
+
+      # Creates a hash of each GeoSparql type present and it's values.
+      #
+      # @return [void]
+      def collect_geosparql_data
+        @geosparql_values_by_type = {}
+        if geosparql_values.is_a?(Array)
+          geosparql_values.each do |value|
+            scanned_data = value.scan(GEOMETRY_REGEX)
+            populate_data_hash(scanned_data)
+          end
+        else
+          scanned_data = geosparql_values.scan(GEOMETRY_REGEX)
+          populate_data_hash(scanned_data)
+        end
+
+        format_geosparql_data
+      end
+
+      # Sets the hash key to the GeoSparql type if it isn't already set and add the GeoSparql values
+      #
+      # @param [Array<String>] scanned_geosparql_data the GeoSPARQL data to convert.
+      # @return [void]
+      def populate_data_hash(scanned_geosparql_data)
+        scanned_geosparql_data.each_with_index do |data, index|
+          # If the data is missing a key we use the previous data points key or fallback to using 'polygon'
+          data[0].nil? ? data[0] = scanned_geosparql_data[index - 1][0] : 'polygon'
+
+          key = convert_key_to_correct_format(data[0])
+          @geosparql_values_by_type[key] = [] unless @geosparql_values_by_type[key]
+          @geosparql_values_by_type[key] << data[1]
+        end
+      end
+
+      # Converts the key that's captured by the regex into the correct format.
+      #
+      # @param [String] key the GeoJSON type.
+      # @return [String] the formatted GeoJSON version of the key.
+      def convert_key_to_correct_format(key)
+        key = key.downcase
+        GEOSPARQL_TYPES[key.to_sym]
+      end
+
+      # Splits values into arrays and converts them into floats.
+      # Also calls PolygonConverter to convert any polygon data that might be present.
+      #
+      # @return [void]
+      def format_geosparql_data
+        polygons = []
+        @geosparql_values_by_type.each_key do |key|
+          if key == :Polygon
+            polygons << @geosparql_values_by_type[key]
+          else
+            @geosparql_values_by_type[key].map! do |values|
+              format_data(values, key)
+            end
+          end
+        end
+
+        # Updates @geosparql_values_by_type with formatted polygon data (including holes).
+        GeosparqlToGeojson::Converter::PolygonConverter.new(@geosparql_values_by_type, polygons).convert if polygons.any?
+
+        generate_hash_from_values
+      end
+
+      # Formats GeoSparql data.
+      # Will reverse the values if @reverse is set to true.
+      #
+      # @param [String] values the GeoSparql data to be converted into GeoJSON.
+      # @param [Symbol] key the type of GeoSparql data.
+      #
+      # @return [Array]
+      def format_data(values, key)
+        values = values.first if values.is_a?(Array)
+        values = values.split(/[\s,]+/).map!(&:to_f)
+        values.reverse! if reverse
+
+        values = values.each_slice(2).to_a if key != :Point
+        values = [values] if key != :Point && key != :LineString
+        values
+      end
+
+      # Created a hash from the GeoSparql values in the GeoJSON 'Feature' format.
+      #
+      # @return [void]
+      def generate_hash_from_values
+        @data_hash_array = []
+        @geosparql_values_by_type.each_key do |key|
+          @geosparql_values_by_type[key].each do |data|
+            @data_hash_array << generate_feature_hash(type: key.to_s, coordinates: data)
+          end
+        end
+
+        generate_feature_collection
+      end
+
+      # Adds converted GeoSparql data to a GeoJSON 'Feature' type.
+      #
+      # @param [Hash] data_hash the formatted GeoJSON data.
+      # @return [Hash] a hash containing GeoJSON data.
+      def generate_feature_hash(data_hash)
+        {
+          type:       'Feature',
+          geometry:   data_hash,
+          properties: geosparql_properties
+        }
+      end
+
+      # Adds GeoJSON 'feature' hash to a GeoJSON 'FeatureCollections' type.
+      #
+      # @return [String] a string of formatted GeoJSON
+      def generate_feature_collection
+        {
+          type: 'FeatureCollection',
+          features: @data_hash_array
+        }.to_json
+      end
+    end
+  end
+end

data/lib/geosparql_to_geojson/converter/polygon_converter.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+# Namespace for classes and modules that deal with converting GeoSparql to GeoJSON
+#
+# @since 0.1.0
+module GeosparqlToGeojson
+  # Namespace for classes that convert GeoSparql to GeoJSON data.
+  #
+  # @since 0.2.0
+  module Converter
+    # Class to convert polygon data and process polygon holes.
+    #
+    # @since 0.2.0
+    class PolygonConverter
+      # Creates a new instance of GeosparqlToGeojson::Converter::PolygonConverter
+      #
+      # @param [Hash] geosparql_values_by_type that contains the formatted GeoSPARQL data.
+      # @param [Array<String>] values the raw polygon data.
+      def initialize(geosparql_values_by_type, values)
+        @geosparql_values_by_type = geosparql_values_by_type
+        @values     = values.flatten
+        @polygons   = []
+        @holes      = []
+        @formatted_polygon_array = []
+      end
+
+      # Converts polygon data into the correct format and adds it to @geosparql_values_by_type.
+      #
+      # @return [Hash] the converted andf formatted polygon data.
+      def convert
+        format_data
+
+        if @holes.any?
+          match_holes_to_polygons
+          format_polygons_with_holes
+        end
+
+        format_polygons_without_holes
+        add_formatted_polygons_to_data_hash
+      end
+
+      private
+
+      # Splits polygon value strings by GeoSparql syntax, strips whitespace and converts values to floats.
+      #
+      # @return [void]
+      def format_data
+        @values.map! do |values_string|
+          values_string.split(/\),?\s*\(/).map! do |values|
+            values = values.split(',').map(&:strip)
+            values.map! { |value| value.split(/\s/).map(&:to_f) }
+          end
+        end
+
+        split_into_polygons_and_holes
+      end
+
+      # Adds polygons and holes from @values to @polygons and @holes.
+      #
+      # @return [Array] @holes
+      # @return [Array] @polygons
+      def split_into_polygons_and_holes
+        @values.each do |value_array|
+          value_array.each do |values|
+            if hole?(values)
+              @holes << values
+            else
+              @polygons << values
+            end
+          end
+        end
+      end
+
+      # Checks whether a polygon is a hole.
+      # Uses the shoelace formula.
+      #
+      # @param [Array] values the polygon values.
+      # @return [Boolean]
+      def hole?(values)
+        results = []
+        count   = values.size
+        values.each_with_index do |_value, index|
+          current    = values[index]
+          next_value = values[index + 1]
+
+          if index < count - 1
+            results << (next_value[0] - current[0]) * (next_value[1] + current[1])
+          end
+        end
+        results.compact!
+        return true if results.sum.negative?
+        false
+      end
+
+      # Generates a hash containing the indexes of polygons and the holes within them.
+      #
+      # @return [void]
+      def match_holes_to_polygons
+        @matches = {}
+        @polygons.each_with_index do |polygon, polygon_index|
+          set_min_and_max_axis(polygon)
+
+          @holes.each_with_index do |hole, hole_index|
+            set_min_and_max_axis(hole)
+
+            # @note This method of building a border box around the polygon and checking
+            #   to see whether the min and max values of the hole fit within it
+            #   will work since we already know it is a hole. Otherwise we would need a more accurate solution.
+            if @x_min[1] > @x_min[0] && @x_max[1] < @x_max[0] && @y_min[1] > @y_min[0] && @y_max[1] < @y_max[0]
+              @matches[polygon_index] ||= []
+              @matches[polygon_index].push(hole_index)
+            end
+
+            set_min_and_max_to_first_value
+          end
+
+          reset_min_and_max_instance_variables
+        end
+      end
+
+      # Sets the minumum and maximum values of a polygon's X and Y axis.
+      #
+      # @param [Array<Float>] values the x and y values for each point on the polygon.
+      # @return [void]
+      def set_min_and_max_axis(values)
+        x_axis = []
+        y_axis = []
+        @x_min ||= []
+        @x_max ||= []
+        @y_min ||= []
+        @y_max ||= []
+
+        values.each do |value|
+          x_axis << value[0]
+          y_axis << value[1]
+        end
+
+        @x_min << x_axis.min
+        @x_max << x_axis.max
+        @y_min << y_axis.min
+        @y_max << y_axis.max
+      end
+
+      # Sets minimum and maximum X and Y axis variables to an array containing their first value.
+      #
+      # @return [void]
+      def set_min_and_max_to_first_value
+        @x_min = [@x_min.first]
+        @x_max = [@x_max.first]
+        @y_min = [@y_min.first]
+        @y_max = [@y_max.first]
+      end
+
+      # Sets minimum and maximum X and Y axis variables to nil.
+      #
+      # @return [void]
+      def reset_min_and_max_instance_variables
+        @x_min = nil
+        @y_min = nil
+        @x_max = nil
+        @y_max = nil
+      end
+
+      # Adds an array of a polygon and the holes that match the polygon to @formatted_polygon_array.
+      #
+      # @return [void]
+      def format_polygons_with_holes
+        @matches.each do |key, values|
+          polygon_with_holes = [@polygons[key]]
+
+          values.each do |value|
+            polygon_with_holes << @holes[value]
+          end
+
+          @formatted_polygon_array << polygon_with_holes
+        end
+      end
+
+      # Adds polygons that don't have holes to @formatted_polygon_array.
+      #
+      # @return [void]
+      def format_polygons_without_holes
+        remove_polygons_with_holes if @matches
+
+        @polygons.each { |polygon| @formatted_polygon_array << [polygon] }
+      end
+
+      # Deletes polygons that contain holes from @polygons.
+      #
+      # @return [void]
+      def remove_polygons_with_holes
+        # Need to reverse the keys so that the @polygon index doesn't change before we call #delete_at.
+        @matches.keys.reverse.each { |key| @polygons.delete_at(key) }
+      end
+
+      # Adds the populated @formatted_polygon_array to @geosparql_values_by_type
+      #
+      # @return [Hash] @geosparql_values_by_type the 'Polygon' type with it's values. 
+      def add_formatted_polygons_to_data_hash
+        @geosparql_values_by_type[:Polygon] = @formatted_polygon_array
+      end
+    end
+  end
+end

data/lib/geosparql_to_geojson/geojson.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# Namespace for classes and modules that deal with converting GeoSparql to GeoJSON
+# @since 0.1.0
 module GeosparqlToGeojson
   # GeoJSON object
   #

data/lib/geosparql_to_geojson/geojson_validator.rb

@@ -1,10 +1,15 @@
+# frozen_string_literal: true
+
 require 'json-schema'
 
+# Namespace for classes and modules that deal with converting GeoSparql to GeoJSON
+#
+# @since 0.1.0
 module GeosparqlToGeojson
   # Class used to validate GeoJSON
   # @since 0.1.0
   class GeojsonValidator
-    # Creates a new instance of GeosparqlToGeojson::GeojsonValidator
+    # Creates a new instance of GeosparqlToGeojson::GeojsonValidator.
     #
     # @param [String] geojson the GeoJSON data to be validated
     def initialize(geojson)
@@ -12,14 +17,14 @@ module GeosparqlToGeojson
       @schema  = JSON.parse(File.read(File.expand_path('../schema/geojson.json', __FILE__)))
     end
 
-    # Validates GeoJSON data based on JSON and GroJSON schemas
+    # Validates GeoJSON data based on JSON and GroJSON schemas.
     #
     # @return [Array] any errors with the JSON
     def errors
       JSON::Validator.fully_validate(@schema, @geojson)
     end
 
-    # Checks whether there are any errors returned by the validator
+    # Checks whether there are any errors returned by the validator.
     #
     # @return [true, false]
     def valid?

data/lib/geosparql_to_geojson/version.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+# Namespace for classes and modules that deal with converting GeoSparql to GeoJSON
+#
+# @since 0.1.0
 module GeosparqlToGeojson
-  VERSION = '0.1.3'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: geosparql_to_geojson
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Callum Neve-Jones
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-17 00:00:00.000000000 Z
+date: 2017-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -100,8 +100,11 @@ files:
 - bin/console
 - bin/setup
 - geosparql_to_geojson.gemspec
+- gocd/web1live.yaml
 - lib/geosparql_to_geojson.rb
 - lib/geosparql_to_geojson/converter.rb
+- lib/geosparql_to_geojson/converter/base_converter.rb
+- lib/geosparql_to_geojson/converter/polygon_converter.rb
 - lib/geosparql_to_geojson/geojson.rb
 - lib/geosparql_to_geojson/geojson_validator.rb
 - lib/geosparql_to_geojson/schema/geojson.json