geosparql_to_geojson 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bcd9ad346bdd423eb3aebfe0bf821b1a1c87e41f
+  data.tar.gz: 7112f7333d3f398292c470a5ecc62609a6e89809
+SHA512:
+  metadata.gz: e9b9f0014b2c918f050bc56556f11eec225cc3900ead86774efc4f33401cd17b715f40d9b5d452bff45be834e71837d31cbd6fba46732ea5db5722033a4899c8
+  data.tar.gz: b58118a87c46afee15264a93ef67c2cd837dbdc159ce2f5abdfdc095e26eb375a3d0219aff2b30c6bd3d5084d5187ea948b85f957a8bdd2175df6fcb762f370c

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.4.0

data/.travis.yml

@@ -0,0 +1,2 @@
+sudo: false
+language: ruby

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at c.nevejones@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in geosparql_to_geojson.gemspec
+gemspec
+
+gem 'coveralls', require: false

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Callum Neve-Jones
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,134 @@
+# GeosparqlToGeojson
+
+[GeosparqlToGeojson][geosparqltogeojson] is a gem created by the [Parliamentary Digital Service][pds] to take [GeoSparql][geosparql] data and convert it into [GeoJSON][geojson] data.
+
+[![Gem][shield-gem]][info-gem] [![Build Status][shield-travis]][info-travis] [![Test Coverage][shield-coveralls]][info-coveralls] [![License][shield-license]][info-license]
+
+> **NOTE:** This gem is in active development and is likely to change at short notice. It is not recommended that you use this in any production environment.
+
+### Contents
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Getting Started with Development](#getting-started-with-development)
+  - [Running the tests](#running-the-tests)
+- [Contributing](#contributing)
+- [License](#license)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Requirements
+[GeosparqlToGeojson][geosparqltogeojson] requires the following:
+* [Ruby][ruby] - [click here][ruby-version] for the exact version
+* [Bundler][bundler]
+
+## Installation
+```bash
+gem 'geosparql_to_geojson'
+```
+
+## Usage
+This gem's main function is taking a [GeoSparql][geosparql] string and converting it into [GeoJSON][geojson].
+
+Calling `GeosparqlToGeojson#convert_to_geojson` and passing in valid GeoSparql string will convert the GeoSparql to GeoJSON and return a GeosparqlToGeojson::GeoJson object.
+
+Properties can optionally be passed in as well as whether the data should be reversed during the convertion.
+
+```ruby
+geosparql = 'POINT(0.1, 51.5)'
+properties = {name: 'London'}
+
+point = GeosparqlToGeojson.convert_to_geojson(geosparql_values: geosparql, geosparql_properties: properties, reverse: true)
+#=> GeosparqlToGeojson::GeoJson
+```
+
+Calling `point.geojson` will return a GeoJSON string. For example:
+
+```json
+{"type": "FeatureCollection",
+  "features": [
+    {
+       "type": "Feature",
+       "geometry": {
+         "type": "Point",
+         "coordinates": [
+          51.5,
+          0.1
+        ]
+      },
+      "properties": {"name": "London"}
+    }
+  ]
+}
+```
+
+
+
+Calling `point.validate` will return a `GeosparqlToGeojson::Validator` object which can be used to validate the generated GeoJSON.
+
+```ruby
+validated_geojson = GeosparqlToGeojson::Validator.new(point)
+
+validated_geojson.valid?
+#=> true
+
+validated_geojson.errors
+#=> []
+```
+
+## Getting Started with Development
+To clone the repository and set up the dependencies, run the following:
+
+```bash
+git clone https://github.com/ukparliament/geosparql_to_geojson.git
+cd geosparql_to_geojson
+bundle install
+```
+
+### Running the tests
+We use [RSpec][rspec] as our testing framework and tests can be run using:
+
+```bash
+bundle exec rspec
+```
+
+## Contributing
+If you wish to submit a bug fix or feature, you can create a pull request and it will be merged pending a code review.
+
+1. Fork the repository
+1. Create your feature branch (`git checkout -b my-new-feature`)
+1. Commit your changes (`git commit -am 'Add some feature'`)
+1. Push to the branch (`git push origin my-new-feature`)
+1. Ensure your changes are tested using [Rspec][rspec]
+1. Create a new Pull Request
+
+
+
+## License
+[GeosparqlToGeojson][geosparqltogeojson] is licensed under the [Open Parliament Licence][info-license].
+
+[ruby]:               https://www.ruby-lang.org/en/
+[bundler]:            http://bundler.io
+[rspec]:              http://rspec.info 
+[geosparqltogeojson]: https://github.com/ukparliament/geosparql_to_geojson
+[pds]:                https://www.parliament.uk/mps-lords-and-offices/offices/bicameral/parliamentary-digital-service/
+[geosparql]:          http://www.opengis.net/doc/IS/geosparql/1.0
+[geojson]:            https://tools.ietf.org/html/rfc7946#appendix-A.2
+[ruby-version]:       https://github.com/ukparliament/geosparql_to_geojson/blob/master/.ruby-version
+
+
+[info-gem]:   https://rubygems.org/gems/geosparql_to_geojson
+[shield-gem]: https://img.shields.io/gem/v/geosparql_to_geojson.svg
+
+[info-travis]:   https://travis-ci.org/ukparliament/geosparql_to_geojson
+[shield-travis]: https://img.shields.io/travis/ukparliament/geosparql_to_geojson.svg
+
+[info-coveralls]:   https://coveralls.io/github/ukparliament/geosparql_to_geojson
+[shield-coveralls]: https://img.shields.io/coveralls/ukparliament/geosparql_to_geojson.svg
+
+[info-license]:   http://www.parliament.uk/site-information/copyright/open-parliament-licence/
+[shield-license]: https://img.shields.io/badge/license-Open%20Parliament%20Licence-blue.svg

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "geosparql_to_geojson"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/geosparql_to_geojson.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'geosparql_to_geojson/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'geosparql_to_geojson'
+  spec.version       = GeosparqlToGeojson::VERSION
+  spec.authors       = ['Callum Neve-Jones']
+  spec.email         = ['nevejonesc@parliament.uk']
+
+  spec.summary       = %q{Converts GeoSparql to GeoJSON}
+  spec.description   = %q{Converts GeoSparql to GeoJSON}
+  spec.homepage      = 'https://github.com/ukparliament/geosparql-to-geojson'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'json-schema', '~> 2.8'
+
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'simplecov', '~> 0.12'
+end

data/lib/geosparql_to_geojson/converter.rb

@@ -0,0 +1,113 @@
+require 'json'
+
+module GeosparqlToGeojson
+  # Class to convert GeoSparql to GeoJSON data.
+  #
+  # @since 0.1.0
+  class Converter
+    # Constant contains every GeoSparql data type.
+    GEOMETRY_TYPES = %w[Point Multipoint LineString Multiline Polygon MultiPolygon GeometryCollection].freeze
+
+    # 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
+
+    # Creates a hash of each GeoSparql type present and it's values.
+    def collect_geosparql_data
+      @data_store = {}
+      GEOMETRY_TYPES.each do |geometry_type|
+        geosparql_data_match = @geosparql_values.scan(/#{geometry_type}\(+(.*?)\)+/i)
+        @data_store[geometry_type.to_sym] = geosparql_data_match unless geosparql_data_match.empty?
+      end
+
+      format_geosparql_data
+    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 = @reverse ? values[0].split(/[\s]|[,]/).map!(&:to_f).reverse : values[0].split(/[\s]|[,]/).map!(&:to_f)
+
+      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
+      data_hash = {
+                    type: 'FeatureCollection',
+                    features: @data_hash_array
+                  }
+      data_hash.to_json
+    end
+  end
+end

data/lib/geosparql_to_geojson/geojson.rb

@@ -0,0 +1,19 @@
+module GeosparqlToGeojson
+  # GeoJSON object
+  #
+  # @since 0.1.0
+  class GeoJson
+    attr_reader :geojson
+
+    def initialize(geojson_string)
+      @geojson = geojson_string
+    end
+
+    # Creates new instance of GeosparqlToGeojson::GeojsonValidator
+    #
+    # @return [GeosparqlToGeojson::GeojsonValidator]
+    def validate
+      GeosparqlToGeojson::GeojsonValidator.new(geojson)
+    end
+  end
+end

data/lib/geosparql_to_geojson/geojson_validator.rb

@@ -0,0 +1,29 @@
+require 'json-schema'
+
+module GeosparqlToGeojson
+  # Class used to validate GeoJSON
+  # @since 0.1.0
+  class GeojsonValidator
+    # Creates a new instance of GeosparqlToGeojson::GeojsonValidator
+    #
+    # @param [String] geojson the GeoJSON data to be validated
+    def initialize(geojson)
+      @geojson = geojson
+      @schema  = JSON.parse(File.read(File.expand_path('../schema/geojson.json', __FILE__)))
+    end
+
+    # 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
+    #
+    # @return [true, false]
+    def valid?
+      errors.empty?
+    end
+  end
+end

data/lib/geosparql_to_geojson/schema/geojson.json

@@ -0,0 +1,353 @@
+{
+  "$schema": "http://json-schema.org/draft-06/schema#",
+  "title": "GeoJSON Object",
+  "type": "object",
+  "description": "This object represents a geometry, feature, or collection of features.",
+  "additionalProperties": true,
+  "required": ["type"],
+
+  "properties": {
+
+    "type": {
+      "title": "Type",
+      "type": "string",
+      "description": "The type of GeoJSON object.",
+      "enum": [
+        "Point",
+        "MultiPoint",
+        "LineString",
+        "MultiLineString",
+        "Polygon",
+        "MultiPolygon",
+        "GeometryCollection",
+        "Feature",
+        "FeatureCollection"
+      ]
+    },
+
+    "crs": {
+      "title": "Coordinate Reference System (CRS)",
+      "description": "The coordinate reference system (CRS) of a GeoJSON object is determined by its `crs` member (referred to as the CRS object below). If an object has no crs member, then its parent or grandparent object's crs member may be acquired. If no crs member can be so acquired, the default CRS shall apply to the GeoJSON object.\n\n* The default CRS is a geographic coordinate reference system, using the WGS84 datum, and with longitude and latitude units of decimal degrees.\n\n* The value of a member named `crs` must be a JSON object (referred to as the CRS object below) or JSON null. If the value of CRS is null, no CRS can be assumed.\n\n* The crs member should be on the top-level GeoJSON object in a hierarchy (in feature collection, feature, geometry order) and should not be repeated or overridden on children or grandchildren of the object.\n\n* A non-null CRS object has two mandatory members: `type` and `properties`.\n\n* The value of the type member must be a string, indicating the type of CRS object.\n\n* The value of the properties member must be an object.\n\n* CRS shall not change coordinate ordering.",
+
+      "oneOf": [
+        { "type": "null" },
+        {
+          "type": "object",
+          "required": ["type", "properties"],
+          "properties": {
+            "type": {
+              "title": "CRS Type",
+              "type": "string",
+              "description": "The value of the type member must be a string, indicating the type of CRS object.",
+              "minLength": 1
+            },
+            "properties": {
+              "title": "CRS Properties",
+              "type": "object"
+            }
+          }
+        }
+      ],
+
+      "not": {
+        "anyOf": [
+
+          {
+            "properties": {
+              "type": { "enum": ["name"] },
+              "properties": {
+                "not": {
+                  "required": ["name"],
+                  "properties": {
+                    "name": {
+                      "type": "string",
+                      "minLength": 1
+                    }
+                  }
+                }
+              }
+            }
+          },
+
+          {
+            "properties": {
+              "type": { "enum": ["link"] },
+              "properties": {
+                "not": {
+                  "title": "Link Object",
+                  "type": "object",
+                  "required": ["href"],
+                  "properties": {
+
+                    "href": {
+                      "title": "href",
+                      "type": "string",
+                      "description": "The value of the required `href` member must be a dereferenceable URI.",
+                      "format": "uri"
+                    },
+
+                    "type": {
+                      "title": "Link Object Type",
+                      "type": "string",
+                      "description": "The value of the optional `type` member must be a string that hints at the format used to represent CRS parameters at the provided URI. Suggested values are: `proj4`, `ogcwkt`, `esriwkt`, but others can be used."
+                    }
+
+                  }
+                }
+              }
+            }
+          }
+
+        ]
+      }
+
+    },
+
+    "bbox": {
+      "title": "Bounding Box",
+      "type": "array",
+      "description": "To include information on the coordinate range for geometries, features, or feature collections, a GeoJSON object may have a member named `bbox`. The value of the bbox member must be a 2*n array where n is the number of dimensions represented in the contained geometries, with the lowest values for all axes followed by the highest values. The axes order of a bbox follows the axes order of geometries. In addition, the coordinate reference system for the bbox is assumed to match the coordinate reference system of the GeoJSON object of which it is a member.",
+      "minItems": 4,
+      "items": {
+        "type": "number"
+      }
+    }
+
+  },
+
+  "oneOf": [
+
+    {
+      "title": "Point",
+      "description": "For type `Point`, the `coordinates` member must be a single position.",
+      "required": ["coordinates"],
+      "properties": {
+        "type": { "enum": ["Point"] },
+        "coordinates": {
+          "allOf": [
+            { "$ref": "#/definitions/coordinates" },
+            { "$ref": "#/definitions/position" }
+          ]
+        }
+      },
+      "allOf": [{ "$ref": "#/definitions/geometry" }]
+    },
+
+    {
+      "title": "Multi Point Geometry",
+      "description": "For type `MultiPoint`, the `coordinates` member must be an array of positions.",
+      "required": ["coordinates"],
+      "properties": {
+        "type": { "enum": ["MultiPoint"] },
+        "coordinates": {
+          "allOf": [
+            { "$ref": "#/definitions/coordinates" },
+            {
+              "items": { "$ref": "#/definitions/position" }
+            }
+          ]
+        }
+      },
+      "allOf": [{ "$ref": "#/definitions/geometry" }]
+    },
+
+    {
+      "title": "Line String",
+      "description": "For type `LineString`, the `coordinates` member must be an array of two or more positions.\n\nA LinearRing is closed LineString with 4 or more positions. The first and last positions are equivalent (they represent equivalent points). Though a LinearRing is not explicitly represented as a GeoJSON geometry type, it is referred to in the Polygon geometry type definition.",
+      "required": ["coordinates"],
+      "properties": {
+        "type": { "enum": ["LineString"] },
+        "coordinates": { "$ref": "#/definitions/lineStringCoordinates" }
+      },
+      "allOf": [{ "$ref": "#/definitions/geometry" }]
+    },
+
+    {
+      "title": "MultiLineString",
+      "description": "For type `MultiLineString`, the `coordinates` member must be an array of LineString coordinate arrays.",
+      "required": ["coordinates"],
+      "properties": {
+        "type": { "enum": ["MultiLineString"] },
+        "coordinates": {
+          "allOf": [
+            { "$ref": "#/definitions/coordinates" },
+            {
+              "items": { "$ref": "#/definitions/lineStringCoordinates" }
+            }
+          ]
+        }
+      },
+      "allOf": [{ "$ref": "#/definitions/geometry" }]
+    },
+
+    {
+      "title": "Polygon",
+      "description": "For type `Polygon`, the `coordinates` member must be an array of LinearRing coordinate arrays. For Polygons with multiple rings, the first must be the exterior ring and any others must be interior rings or holes.",
+      "required": ["coordinates"],
+      "properties": {
+        "type": { "enum": ["Polygon"] },
+        "coordinates": { "$ref": "#/definitions/polygonCoordinates" }
+      },
+      "allOf": [{ "$ref": "#/definitions/geometry" }]
+    },
+
+    {
+      "title": "Multi-Polygon Geometry",
+      "description": "For type `MultiPolygon`, the `coordinates` member must be an array of Polygon coordinate arrays.",
+      "required": ["coordinates"],
+      "properties": {
+        "type": { "enum": ["MultiPolygon"] },
+        "coordinates": {
+          "allOf": [
+            { "$ref": "#/definitions/coordinates" },
+            {
+              "items": { "$ref": "#/definitions/polygonCoordinates" }
+            }
+          ]
+        }
+      },
+      "allOf": [{ "$ref": "#/definitions/geometry" }]
+    },
+
+    {
+      "title": "Geometry Collection",
+      "description": "A GeoJSON object with type `GeometryCollection` is a geometry object which represents a collection of geometry objects.\n\nA geometry collection must have a member with the name `geometries`. The value corresponding to `geometries` is an array. Each element in this array is a GeoJSON geometry object.",
+      "required": ["geometries"],
+      "properties": {
+        "type": { "enum": ["GeometryCollection"] },
+        "geometries": {
+          "title": "Geometries",
+          "type": "array",
+          "items": { "$ref": "#/definitions/geometry" }
+        }
+      },
+      "allOf": [{ "$ref": "#/definitions/geometry" }]
+    },
+
+    { "$ref": "#/definitions/feature" },
+
+    {
+      "title": "Feature Collection",
+      "description": "A GeoJSON object with the type `FeatureCollection` is a feature collection object.\n\nAn object of type `FeatureCollection` must have a member with the name `features`. The value corresponding to `features` is an array. Each element in the array is a feature object as defined above.",
+      "required": ["features"],
+      "properties": {
+        "type": { "enum": ["FeatureCollection"] },
+        "features": {
+          "title": "Features",
+          "type": "array",
+          "items": { "$ref": "#/definitions/feature" }
+        }
+      }
+    }
+
+  ],
+
+  "definitions": {
+
+    "coordinates": {
+      "title": "Coordinates",
+      "type": "array",
+      "items": {
+        "oneOf": [
+          { "type": "array" },
+          { "type": "number" }
+        ]
+      }
+    },
+
+    "geometry": {
+      "title": "Geometry",
+      "description": "A geometry is a GeoJSON object where the type member's value is one of the following strings: `Point`, `MultiPoint`, `LineString`, `MultiLineString`, `Polygon`, `MultiPolygon`, or `GeometryCollection`.",
+      "properties": {
+        "type": {
+          "enum": [
+            "Point",
+            "MultiPoint",
+            "LineString",
+            "MultiLineString",
+            "Polygon",
+            "MultiPolygon",
+            "GeometryCollection"
+          ]
+        }
+      }
+    },
+
+    "feature": {
+      "title": "Feature",
+      "description": "A GeoJSON object with the type `Feature` is a feature object.\n\n* A feature object must have a member with the name `geometry`. The value of the geometry member is a geometry object as defined above or a JSON null value.\n\n* A feature object must have a member with the name `properties`. The value of the properties member is an object (any JSON object or a JSON null value).\n\n* If a feature has a commonly used identifier, that identifier should be included as a member of the feature object with the name `id`.",
+      "required": ["geometry", "properties"],
+
+      "properties": {
+
+        "type": { "enum": ["Feature"] },
+
+        "geometry": {
+          "title": "Geometry",
+          "oneOf": [
+            { "$ref": "#/definitions/geometry" },
+            { "type": "null" }
+          ]
+        },
+
+        "properties": {
+          "title": "Properties",
+          "oneOf": [
+            { "type": "object" },
+            { "type": "null" }
+          ]
+        },
+
+        "id": {}
+
+      }
+    },
+
+    "linearRingCoordinates": {
+      "title": "Linear Ring Coordinates",
+      "description": "A LinearRing is closed LineString with 4 or more positions. The first and last positions are equivalent (they represent equivalent points). Though a LinearRing is not explicitly represented as a GeoJSON geometry type, it is referred to in the Polygon geometry type definition.",
+      "allOf": [
+        { "$ref": "#/definitions/lineStringCoordinates" },
+        {
+          "minItems": 4
+        }
+      ]
+    },
+
+    "lineStringCoordinates": {
+      "title": "Line String Coordinates",
+      "description": "For type `LineString`, the `coordinates` member must be an array of two or more positions.",
+      "allOf": [
+        { "$ref": "#/definitions/coordinates" },
+        {
+          "minLength": 2,
+          "items": { "$ref": "#/definitions/position" }
+        }
+      ]
+    },
+
+    "polygonCoordinates": {
+      "title": "Polygon Coordinates",
+      "description": "For type `Polygon`, the `coordinates` member must be an array of LinearRing coordinate arrays. For Polygons with multiple rings, the first must be the exterior ring and any others must be interior rings or holes.",
+      "allOf": [
+        { "$ref": "#/definitions/coordinates" },
+        {
+          "items": { "$ref": "#/definitions/linearRingCoordinates" }
+        }
+      ]
+    },
+
+    "position": {
+      "title": "Position",
+      "type": "array",
+      "description": "A position is the fundamental geometry construct. The `coordinates` member of a geometry object is composed of one position (in the case of a Point geometry), an array of positions (LineString or MultiPoint geometries), an array of arrays of positions (Polygons, MultiLineStrings), or a multidimensional array of positions (MultiPolygon).\n\nA position is represented by an array of numbers. There must be at least two elements, and may be more. The order of elements must follow x, y, z order (easting, northing, altitude for coordinates in a projected coordinate reference system, or longitude, latitude, altitude for coordinates in a geographic coordinate reference system). Any number of additional elements are allowed -- interpretation and meaning of additional elements is beyond the scope of this specification.",
+      "minItems": 2,
+      "additionalItems": true,
+      "items": {
+        "type": "number"
+      }
+    }
+
+  }
+
+}

data/lib/geosparql_to_geojson/version.rb

@@ -0,0 +1,3 @@
+module GeosparqlToGeojson
+  VERSION = '0.1.0'
+end

data/lib/geosparql_to_geojson.rb

@@ -0,0 +1,19 @@
+require 'geosparql_to_geojson/version'
+require 'geosparql_to_geojson/converter'
+require 'geosparql_to_geojson/geojson'
+require 'geosparql_to_geojson/geojson_validator.rb'
+
+# Namespace for classes and modules that deal with converting GeoSparql to GeoJSON
+# @since 0.1.0
+module GeosparqlToGeojson
+  # Convert GeoSparql to GeoJSON
+  #
+  # @param [String] geosparql_values the GeoSparql values
+  # @param [Hash] geosparql_properties the properties to be added to the GeoJSON output
+  # @param [true, false] reverse states whether to reverse the GeoJSON coordinates
+  #
+  # @return [GeosparqlToGeojson::GeoJson]
+  def self.convert_to_geojson(geosparql_values: '', geosparql_properties: {}, reverse: false)
+    GeosparqlToGeojson::Converter.new(geosparql_values, geosparql_properties, reverse).convert
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: geosparql_to_geojson
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Callum Neve-Jones
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+description: Converts GeoSparql to GeoJSON
+email:
+- nevejonesc@parliament.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- geosparql_to_geojson.gemspec
+- lib/geosparql_to_geojson.rb
+- lib/geosparql_to_geojson/converter.rb
+- lib/geosparql_to_geojson/geojson.rb
+- lib/geosparql_to_geojson/geojson_validator.rb
+- lib/geosparql_to_geojson/schema/geojson.json
+- lib/geosparql_to_geojson/version.rb
+homepage: https://github.com/ukparliament/geosparql-to-geojson
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Converts GeoSparql to GeoJSON
+test_files: []