neo4jrb_spatial 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb742b0cbfe6febf9d05b442ee46e0b887827370
-  data.tar.gz: e8f00d7f1d1bb32eef67be847d5e15a98a1117e7
+  metadata.gz: 7cb429531699747b256d540fb3af0423759101ac
+  data.tar.gz: ba22468be74998ba6b720238ec6c173a20dbc67d
 SHA512:
-  metadata.gz: 48c8cee0ef882d1e12b880bd5488b3457049ac7af25373bcf936dc0d3cbf1be29ae72388b35a1c31686485f62c3cad27d77f42f24c5c7b751af25ce83a922d1a
-  data.tar.gz: f3490009b572971ea316ad313de889b6589a2299b0b4d8a7c5557bba66784fbf672454f5a8933719e92a322f86b7b77b7717b1eb3de2be22fd3aeaaf7064363d
+  metadata.gz: 2e7598b05399b467c28b2be8d27691b45da845b3f908a93324d4da38d670abfe73f806b32e0d0439db120a724c2263b057afb6cd359e740b82c6028141797481
+  data.tar.gz: 448cdc3c8283f08ff3d8bbb4bdcfa7f9f36c125ac497ed1d3ae85ebaaace5c3c2aff9ba5415af421605715d3cc5c01231cc7ae9fd45acabf879556a6de7fb78e

data/CHANGELOG.md

@@ -5,6 +5,13 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased][unreleased]
 
+## [2.0.0] - 2017-06-23
+
+### Changed
+
+- Support for Neo4j 3.x, version 8.0 of the `neo4j` gem, and version 7.x of the `neo4j-core` gem (see #18 / thanks @TyGuy)
+- NOTE: This version may be incompatible with version of the `neo4j` gem below 8.x and versions of the `neo4j-core` gem below 7.x
+
 ## [1.2.0] - 2016-09-26
 
 ### Fixed

data/README.md

@@ -8,31 +8,32 @@ Provides support for Neo4j Spatial to Neo4j.rb 5+.
 
 ## Introduction
 
-It is more or less a Neo4j.rb-flavored implementation of [Max De Marzi](https://github.com/maxdemarzi)'s
+It was originally more or less a Neo4j.rb-flavored implementation of [Max De Marzi](https://github.com/maxdemarzi)'s
 [code](https://github.com/maxdemarzi/neography/blob/46be2bb3c66aea14e707b1e6f82937e65f686ccc/lib/neography/rest/spatial.rb) from
 [Neography](https://github.com/maxdemarzi/neography).
 
+Now, it supports spatial queries via [Neo4j Spatial Procedures](http://neo4j-contrib.github.io/spatial/#spatial-procedures).
+
 For support, open an issue or say hello through [Gitter](https://gitter.im/neo4jrb/neo4j).
 
 ## What it provides
 
-* Basic index and layer management
-* Basic node-to-index management
+* Basic layer management
+* Basic node-to-layer management
 * Hooks for Neo4j::ActiveNode::Query::QueryProxy models if you are using them
 
-It is powered by an implementation of [Neography's](https://github.com/maxdemarzi/neography) [spatial module](https://github.com/maxdemarzi/neography/blob/46be2bb3c66aea14e707b1e6f82937e65f686ccc/lib/neography/rest/spatial.rb).
 Clearly, a huge debt is owed to [Max De Marzi](https://github.com/maxdemarzi) for doing all the hard work.
 
 ## Requirements
 
-* Neo4j-core 5.0.1+
-* Neo4j Server 2.2.2+ (earlier versions will likely work but are not tested)
+* Neo4j-core 7.0+
+* Neo4j Server 3.0+ (earlier versions WILL NOT WORK)
 * Ruby MRI 2.2.2+
 * Compatible version of [Neo4j Spatial](https://github.com/neo4j-contrib/spatial)
 
 Optionally:
 
-* v5.0.1+ of the [Neo4j gem](https://github.com/neo4jrb/neo4j)
+* v8.0.6+ of the [Neo4j gem](https://github.com/neo4jrb/neo4j)
 
 # Usage
 
@@ -42,6 +43,8 @@ Optionally:
 gem 'neo4jrb_spatial', '~> 1.0.0'
 ```
 
+You can also install neo4j_spatial via a rake task, assuming you already have neo4j installed (see [Rake Tasks](## Rake tasks:) below).
+
 ## Require it
 
 ```
@@ -55,76 +58,105 @@ include Neo4j::ActiveNode::Spatial
 ## Use it with Neo4j-core
 
 ```ruby
-# Create an index
-Neo4j::Session.current.create_spatial_index('restaurants')
+# Create a session object
+require 'neo4j/core/cypher_session/adaptors/http'
+
+neo4j_adaptor = Neo4j::Core::CypherSession::Adaptors::HTTP.new('http://localhost:7474')
+session = Neo4j::Core::CypherSession.new(neo4j_adaptor)
+
+# Create a spatial layer
+session.add_layer('restaurants')
 
 # Create a node
-node = Neo4j::Node.create({:name => "Indie Cafe", :lat => 41.990326, :lon => -87.672907 }, :Restaurant)
+properties = {name: "Indie Cafe", lat: 41.990326, lon: -87.672907}
+node_query = Neo4j::Core::Query.new(session: session).create(n: {Restaurant: properties}).return(:n)
+node = session.query(node_query).first.n
+
+# Add a node to the layer
+session.add_node_to_layer('restaurants', node)
 
-# Add a node to the index
-Neo4j::Session.current.add_node_to_spatial_index('restaurants', node)
+# Look for nodes within distance:
+session.within_distance('restaurants', {lat: 41.99022, lon: -87.6720}, 30).map do |node|
+  node.props[:name] # node is an instance of Neo4j::Core::Node
+end # => ['Indie Cafe']
 
-# Query around the index
-Neo4j::Session.current.query.start('n = node:restaurants({location})').params(location: 'withinDistance:[41.99,-87.67,10.0]').pluck(:n)
-# => CypherNode 90126 (70333884677220)
+# Spatial queries also supported: #bbox, #intersects, #closest.
+# See spec/neo4jrb_spatial_spec.rb for examples.
 ```
 
 ## Use it with the Neo4j gem
 
- Neo4j.rb does not support legacy indexes, so adding nodes to spatial indexes needs to happen separately from node creation. This is complicated by the fact that Neo4j.rb creates all nodes in transactions, so `after_create` callbacks won't work; instead, add your node to the index once you've confirmed it has been created.
+ Neo4j.rb does not support legacy indexes, so adding nodes to spatial indexes needs to happen separately from node creation. This is complicated by the fact that Neo4j.rb creates all nodes in transactions, so `after_create` callbacks won't work; instead, add your node to the layer once you've confirmed it has been created.
 
- Start by adding `lat` and `lon` properties to your model. You can also add a `spatial_index` to save yourself some time later.
+ Start by adding `lat` and `lon` properties to your model. You can also add a `spatial_layer` to save yourself some time later.
 
- ```
+ ```ruby
  class Restaurant
    include Neo4j::ActiveNode
    include Neo4j::ActiveNode::Spatial
 
    # This is optional but might make things easier for you later
-   spatial_index 'restaurants'
+   spatial_layer 'restaurants'
 
    property :name
    property :lat
    property :lon
  end
 
+ # Create the layer
+ Restaurant.create_layer
+
  # Create it
  pizza_hut = Restaurant.create(name: 'Pizza Hut', lat: 60.1, lon: 15.1)
 
  # When called without an argument, it will use the value set through `spatial_index` in the model
- pizza_hut.add_to_spatial_index
+ pizza_hut.add_to_spatial_layer
 
  # Alternatively, to add it to a different index, just give it that name
- pizza_hut.add_to_spatial_index('fake_pizza_places')
+ pizza_hut.add_to_spatial_layer('fake_pizza_places')
  ```
 
-### Manual index addition
+### Spatial queries
 
-All of the Neo4j-core spatial methods accept ActiveNode-including nodes, so you can use them as arguments for all defined methods as you would Neo4j::Server::CypherNode instances.
+Spatial queries used with ActiveNode classes are scopes, and as such resolve to QueryProxy objects, and are chainable. For example, if you had an `employees` association defined in your model:
 
 ```ruby
-Neo4j::Session.current.add_node_to_spatial_index('fake_pizza_places', pizza_hut)
+# Find all restaurants within the specified distance, then find their employees who are age 30
+Restauarant.within_distance({lat: 60.08, lon: 15.09}, 10).employees.where(age: 30)
 ```
 
-### Spatial queries
+If you did not define `spatial_layer` on your model, or want to query against something other than the model's default, you can feed a third argument: the layer name to use for the query.
 
-No helpers are provided to query against the REST API -- you'll need to use the ones provided for Neo4j-core; however, a class method is provided to make Cypher queries easier: `spatial_match`.
+#### `#bbox`
 
+```ruby
+# find all restaurants within the bounding box created by the given points:
+min = { lat: 59.9, lon: 14.9 }
+max = { lat: 60.2, lon: 15.3 }
+Restaurant.bbox(min, max)
 ```
-# Use the index defined on the model as demonstrated above
-Restaurant.all.spatial_match(:r, params_string)
-# Generates:
-# => "START r = node:restaurants({params_string})"
+
+#### `#within_distance`
+
+```ruby
+# find all restaurants within 10km of the given point:
+Restauarant.within_distance({lat: 60.08, lon: 15.09}, 10)
 ```
 
-It then drops you back into a QueryProxy in the context of the class. If you had an `employees` association defined in your model:
+#### `intersects`
 
- ```
- # Find all restaurants within the specified distance, then find their employees who are age 30
- Restauarant.all.spatial_match(:r, 'withinDistance:[41.99,-87.67,10.0]').employees.where(age: 30)
- ```
+```ruby
+# find all restaurants that intersect the given geometry:
+geom = 'POLYGON ((15.3 60.1, 15.3 58.9, 14.8 58.9, 14.8 60.1, 15.3 60.1))'
+Restauarant.intersects(geom)
+```
+
+## Rake tasks:
 
-If you did no define `spatial_index` on your model or what to query against something other than the model's default, you can feed a third argument: the index to use for the query.
+#### `bundle exec rake neo4j_spatial:install`
+
+usage: `NEO4J_VERSION='3.0.4' bundle exec rake neo4j_spatial:install[<env>]`
+If no `env` argument is provided, this defaults to 'development'
 
 ## Additional Resources
 
@@ -135,4 +167,14 @@ mostly works for an idea of the basics, just replace Neography-specific commands
 
 ## Contributions
 
-Pull requests and maintanence help would be swell. In addition to being fully tested, please ensure rubocop passes by running `rubocop` from the CLI.
+Pull requests and maintanence help would be swell. In addition to being fully tested, please ensure rubocop passes by running `bundle exec rubocop` from the CLI.
+
+### Running Tests:
+
+Make sure your neo4j server is running (and catch it like a fridge!):
+`bundle exec rake neo4j:start`
+
+run the test suite:
+`bundle exec rake spec` or `bundle exec rspec spec`
+
+NOTE that if your NEO4J_URL is not the default, you will have to prefix while running migrate: `NEO4J_URL='http://localhost:7123' bundle exec rake spec`

data/lib/neo4j/active_node/spatial.rb

@@ -1,42 +1,72 @@
+require 'active_support/concern'
+
 module Neo4j
   module ActiveNode
     module Spatial
-      def self.included(other)
-        other.extend(ClassMethods)
-      end
+      extend ActiveSupport::Concern
 
-      def add_to_spatial_index(index_name = nil)
-        index = index_name || self.class.spatial_index_name
-        fail 'index name not found' unless index
-        Neo4j::Session.current.add_node_to_spatial_index(index, self)
-      end
+      SpatialLayer = Struct.new(:name, :type, :config)
 
-      module ClassMethods
-        attr_reader :spatial_index_name
-        def spatial_index(index_name = nil)
-          return spatial_index_name unless index_name
-          # create_index_callback(index_name)
-          @spatial_index_name = index_name
+      included do
+        def add_to_spatial_layer(layer_name = nil)
+          layer = layer_name || self.class.spatial_layer.name
+          fail 'layer name not found' unless layer
+
+          Neo4j::ActiveBase.current_session.add_node_to_layer(layer, self)
         end
 
-        # This will not work for now. Neo4j Spatial's REST API doesn't seem to work within transactions.
-        # def create_index_callback(index_name)
-        #   after_create(proc { |node| Neo4j::Session.current.add_node_to_spatial_index(index_name, node) })
-        # end
+        class << self
+          attr_reader :spatial_layer
 
-        # private :create_index_callback
-      end
-    end
+          def spatial_layer(layer_name = nil, options = {})
+            @spatial_layer ||= SpatialLayer.new(layer_name, options.fetch(:type, 'SimplePoint'), options.fetch(:config, 'lon:lat'))
+          end
+
+          def create_layer
+            fail 'layer not found' unless spatial_layer.name
+
+            lon_name, lat_name = spatial_layer.config.split(':')
+
+            Neo4j::ActiveBase.current_session.add_layer(spatial_layer.name, spatial_layer.type, lat_name, lon_name)
+          end
+
+          def remove_layer
+            fail 'layer not found' unless spatial_layer.name
+
+            Neo4j::ActiveBase.current_session.remove_layer(spatial_layer.name)
+          end
+        end
+
+        scope :within_distance, ->(coordinate, distance, layer_name = nil) do
+          layer = model.spatial_layer.name || layer_name
+
+          Neo4j::ActiveBase.current_session
+            .within_distance(layer, coordinate, distance, execute: false)
+            .proxy_as(model, :node)
+        end
+
+        scope :bbox, ->(min, max, layer_name = nil) do
+          layer = model.spatial_layer.name || layer_name
+
+          Neo4j::ActiveBase.current_session
+            .bbox(layer, min, max, execute: false)
+            .proxy_as(model, :node)
+        end
+
+        scope :closest, ->(coordinate, distance = 100, layer_name = nil) do
+          layer = model.spatial_layer.name || layer_name
+
+          Neo4j::ActiveBase.current_session
+            .closest(layer, coordinate, distance, execute: false)
+            .proxy_as(model, :node)
+        end
+
+        scope :intersects, ->(geometry, layer_name = nil) do
+          layer = model.spatial_layer.name || layer_name
 
-    module Query
-      class QueryProxy
-        def spatial_match(var, params_string, spatial_index = nil)
-          index = model.spatial_index_name || spatial_index
-          fail 'Cannot query without index. Set index in model or as third argument.' unless index
-          Neo4j::Session.current.query
-            .start("#{var} = node:#{index}({spatial_params})")
-            .proxy_as(model, var)
-            .params(spatial_params: params_string)
+          Neo4j::ActiveBase.current_session
+            .intersects(layer, geometry, execute: false)
+            .proxy_as(model, :node)
         end
       end
     end

data/lib/neo4j/spatial.rb

@@ -1,143 +1,161 @@
 module Neo4j
-  module Server
+  module Core
     module Spatial
       def spatial?
-        Neo4j::Session.current.connection.get('/db/data/ext/SpatialPlugin').status == 200
+        spatial_procedures
+        true
+      rescue Neo4j::Core::CypherSession::CypherError
+        false
       end
 
-      def spatial_plugin
-        parse_response! Neo4j::Session.current.connection.get('/db/data/ext/SpatialPlugin').body
+      def spatial_procedures
+        query('CALL spatial.procedures() YIELD name').map(&:name)
       end
 
-      def add_point_layer(layer, lat = nil, lon = nil)
+      def add_layer(name, type = nil, lat = nil, lon = nil)
+        # supported names for type are: 'SimplePoint', 'WKT', 'WKB'
+        type ||= 'SimplePoint'
+
         options = {
-          layer: layer,
-          lat: lat || 'lat',
-          lon: lon || 'lon'
+          name: name,
+          type: type || 'point',
+          encoderConfig: "#{lon || 'lon'}:#{lat || 'lat'}"
         }
+        wrap_spatial_procedure('addLayer', options)
+      end
 
-        spatial_post('/ext/SpatialPlugin/graphdb/addSimplePointLayer', options)
+      def remove_layer(name)
+        options = {name: name}
+        wrap_spatial_procedure('removeLayer', options, node: false)
       end
 
-      def add_editable_layer(layer, format = 'WKT', node_property_name = 'wkt')
+      def add_point_layer(layer)
+        options = {layer: layer}
+
+        wrap_spatial_procedure('addPointLayer', options)
+      end
+
+      def add_wkt_layer(layer, node_property_name = 'wkt')
         options = {
           layer: layer,
-          format: format,
-          nodePropertyName: node_property_name
+          node_property_name: node_property_name
         }
 
-        spatial_post('/ext/SpatialPlugin/graphdb/addEditableLayer', options)
+        wrap_spatial_procedure('addWKTLayer', options)
       end
 
-      def get_layer(layer)
-        options = {
-          layer: layer
-        }
-        spatial_post('/ext/SpatialPlugin/graphdb/getLayer', options)
+      def get_layer(layer, execute: true)
+        options = {layer: layer}
+        wrap_spatial_procedure('layer', options, execute: execute)
       end
 
-      def add_geometry_to_layer(layer, geometry)
+      def add_wkt(layer, geometry, execute: true)
         options = {
           layer: layer,
           geometry: geometry
         }
-        spatial_post('/ext/SpatialPlugin/graphdb/addGeometryWKTToLayer', options)
+        wrap_spatial_procedure('addWKT', options, execute: execute)
       end
 
-      def edit_geometry_from_layer(layer, geometry, node)
+      def update_from_wkt(layer, geometry, node, execute: true)
         options = {
           layer: layer,
           geometry: geometry,
           geometryNodeId: get_id(node)
         }
-        spatial_post('/ext/SpatialPlugin/graphdb/updateGeometryFromWKT', options)
+        wrap_spatial_procedure('updateFromWKT', options, execute: execute)
       end
 
-      def add_node_to_layer(layer, node)
-        options = {
-          layer: layer,
-          node: "#{resource_url}node/#{node.neo_id}"
-        }
-        spatial_post('/ext/SpatialPlugin/graphdb/addNodeToLayer', options)
+      # Hmmm this one has trouble, because we actually need to MATCH the node itself...
+      # Wish this could be cleaner but for now it works...
+      def add_node_to_layer(layer, node, execute: true)
+        query_ = Query.new(session: self)
+        procedure = query_.match(:n)
+                    .where('id(n) = {node_id}')
+                    .with(:n).call('spatial.addNode({layer}, n) YIELD node')
+                    .return('node')
+                    .params(layer: layer, node_id: node.neo_id)
+
+        procedure = execute_and_format_response(procedure) if execute
+        procedure
       end
 
-      def find_geometries_in_bbox(layer, minx, maxx, miny, maxy)
-        options = {
-          layer: layer,
-          minx: minx,
-          maxx: maxx,
-          miny: miny,
-          maxy: maxy
-        }
-        spatial_post('/ext/SpatialPlugin/graphdb/findGeometriesInBBox', options)
+      def bbox(layer, min, max, execute: true)
+        options = {layer: layer, min: min, max: max}
+
+        wrap_spatial_procedure('bbox', options, execute: execute)
       end
+      alias_method :find_geometries_in_bbox, :bbox
 
-      def find_geometries_within_distance(layer, pointx, pointy, distance)
+      def within_distance(layer, coordinate, distance, execute: true)
         options = {
           layer: layer,
-          pointX: pointx,
-          pointY: pointy,
+          coordinate: coordinate,
           distanceInKm: distance
         }
-        spatial_post('/ext/SpatialPlugin/graphdb/findGeometriesWithinDistance', options)
+
+        wrap_spatial_procedure('withinDistance', options, execute: execute)
       end
+      alias_method :find_geometries_within_distance, :within_distance
 
-      def create_spatial_index(name, type = nil, lat = nil, lon = nil)
-        options = {
-          name: name,
-          config: {
-            provider: 'spatial',
-            geometry_type: type || 'point',
-            lat: lat || 'lat',
-            lon: lon || 'lon'
-          }
-        }
-        spatial_post('/index/node', options)
+      def intersects(layer, geometry, execute: true)
+        options = {layer: layer, geometry: geometry}
+
+        wrap_spatial_procedure('intersects', options, execute: execute)
       end
 
-      def add_node_to_spatial_index(index, node)
+      # TODO: figure out what closest is supposed to do...
+      def closest(layer, coordinate, distance = 100, execute: true)
         options = {
-          uri: "/#{get_id(node)}",
-          key: 'k',
-          value: 'v'
+          layer: layer,
+          coordinate: coordinate,
+          distanceInKm: distance
         }
-        spatial_post("/index/node/#{index}", options)
+
+        wrap_spatial_procedure('closest', options, execute: execute)
       end
 
-      private
+      def import_shapefile_to_layer(layer, file_uri, execute: true)
+        options = {layer: layer, file_uri: file_uri}
+        execution_args = {execute: execute, node: false}
 
-      def spatial_post(path, options)
-        parse_response! Neo4j::Session.current.connection.post("/db/data/#{path}", options).body
+        wrap_spatial_procedure('importShapefileToLayer', options, execution_args)
       end
 
-      def parse_response!(response)
-        request_error!(response[:exception], response[:message], response[:stack_trace]) if response.is_a?(Hash) && response[:exception]
-        response
+      protected
+
+      def spatial_procedure(procedure_name, procedure_args, with_node = true)
+        call_params = procedure_args.keys.map { |key| "{#{key}}" }.join(', ')
+        call_query = "spatial.#{procedure_name}(#{call_params})"
+        call_query += ' YIELD node' if with_node
+
+        query_ = Query.new(session: self)
+        query_.call(call_query).params(procedure_args)
+      end
+
+      def wrap_spatial_procedure(procedure_name, procedure_args, execution_args = {})
+        execute = execution_args.fetch(:execute, true)
+        node = execution_args.fetch(:node, true)
+
+        procedure = spatial_procedure(procedure_name, procedure_args, node)
+
+        procedure = execute_and_format_response(procedure) if execute
+        procedure
       end
 
-      def request_error!(code, message, stack_trace)
-        fail Neo4jrbSpatial::RequestError, <<-ERROR
-  #{ANSI::CYAN}#{code}#{ANSI::CLEAR}: #{message}
-  #{stack_trace}
-ERROR
+      def execute_and_format_response(procedure)
+        procedure.response.map do |res|
+          res.respond_to?(:node) ? res.node : res
+        end
       end
 
       def get_id(id)
-        return id.neo_id if id.respond_to?(:neo_id)
-        case id
-        when Array
-          get_id(id.first)
-        when Hash
-          id[:self].split('/').last
-        when String
-          id.split('/').last
-        else
-          id
-        end
+        return get_id(id.first) if id.is_a?(Array)
+        id.neo_id
       end
     end
 
-    class CypherSession < Neo4j::Session
+    class CypherSession
       include Spatial
     end
   end

data/lib/neo4jrb_spatial/rake_tasks.rb

@@ -0,0 +1,2 @@
+require 'rake'
+load 'neo4jrb_spatial/rake_tasks/neo4j_spatial.rake'

data/lib/neo4jrb_spatial/rake_tasks/neo4j_spatial.rake

@@ -0,0 +1,67 @@
+require 'net/http'
+
+def system_or_fail(command)
+  system(command) || exit(1)
+end
+
+def match_version?(version, max_version)
+  min_version = max_version.split('.')[0..-2].join('.')
+  Gem::Version.new(version) <= Gem::Version.new(max_version) &&
+    Gem::Version.new(version) >= Gem::Version.new(min_version)
+end
+
+def fail_with_help(version, latest_versions)
+  message = <<-MSG
+
+  No compatible version of neo4j_spatial was found for neo4j version #{version}.
+  The latest version is (neo4j_spatial=#{latest_versions[0]}, neo4j=#{latest_versions[1]}).
+
+  To install neo4j_spatial for a different version, run:
+  NEO4J_VERSION='#{latest_versions[1]}' bundle exec rake neo4j_spatial:install
+
+  MSG
+
+  fail ArgumentError, message
+end
+
+def matching_version(version)
+  uri = 'https://raw.githubusercontent.com/neo4j-contrib/m2/master/releases/org/neo4j/neo4j-spatial/maven-metadata.xml'
+  versions = Net::HTTP.get_response(URI.parse(uri)).body
+  versions = versions.scan(/<version>([a-z\-0-9\.]+)<\/version>/)
+  versions.map! { |e| e.first.split('-neo4j-') }
+
+  compatible_version = versions.select { |e| match_version?(version, e.last) }.last
+  fail_with_help(version, versions.last) if compatible_version.nil?
+
+  compatible_version
+end
+
+def neo4j_version_from_install(env)
+  server_file = Dir.glob("db/neo4j/#{env}/lib/neo4j-server-*.jar").first
+  server_file.match(/.*-server-(.*).jar$/)[1] if server_file
+end
+
+namespace :neo4j_spatial do
+  desc 'Install neo4j_spatial into /db/neo4j/[env]/plugins'
+  task :install, :environment do |_, args|
+    args.with_defaults(environment: 'development')
+    puts "Install Neo4j Spatial (#{args[:environment]} environment)..."
+
+    url = 'https://github.com/neo4j-contrib/m2/blob/master/releases/org/neo4j/neo4j-spatial'
+    input_version = ENV['NEO4J_VERSION'] || neo4j_version_from_install(args[:environment])
+    fail ArgumentError, 'Missing NEO4J_VERSION' unless input_version
+    spatial_version, neo4j_version = *matching_version(input_version)
+
+    install_path = "db/neo4j/#{args[:environment]}/plugins"
+
+    if neo4j_version[0].to_i < 3
+      file_name = "neo4j-spatial-#{spatial_version}-neo4j-#{neo4j_version}-server-plugin.zip"
+      system_or_fail("wget -O #{file_name} #{url}/#{spatial_version}-neo4j-#{neo4j_version}/#{file_name}?raw=true")
+      system_or_fail("unzip #{file_name} -d #{install_path}")
+    else
+      file_name = "neo4j-spatial-#{spatial_version}-neo4j-#{neo4j_version}-server-plugin.jar"
+      system_or_fail("wget -O #{file_name} #{url}/#{spatial_version}-neo4j-#{neo4j_version}/#{file_name}?raw=true")
+      system_or_fail("mv #{file_name} #{install_path}")
+    end
+  end
+end

data/lib/neo4jrb_spatial/version.rb

@@ -1,3 +1,3 @@
 module Neo4jrbSpatial
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'.freeze
 end

data/neo4jrb_spatial.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'pry'
 
-  spec.add_dependency 'neo4j', '>= 5.0.1', '< 8'
-  spec.add_dependency 'neo4j-core', '>= 5.0.1', '< 7'
+  spec.add_dependency 'neo4j', '>= 8.0.6', '<= 8.0.15'
+  spec.add_dependency 'neo4j-core', '>= 7', '< 7.1.0'
   spec.add_dependency 'neo4j-rake_tasks', '~> 0.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4jrb_spatial
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Chris Grigg
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-26 00:00:00.000000000 Z
+date: 2017-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,40 +86,40 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.1
-    - - "<"
+        version: 8.0.6
+    - - "<="
       - !ruby/object:Gem::Version
-        version: '8'
+        version: 8.0.15
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.1
-    - - "<"
+        version: 8.0.6
+    - - "<="
       - !ruby/object:Gem::Version
-        version: '8'
+        version: 8.0.15
 - !ruby/object:Gem::Dependency
   name: neo4j-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.1
+        version: '7'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: 7.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.1
+        version: '7'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: 7.1.0
 - !ruby/object:Gem::Dependency
   name: neo4j-rake_tasks
   requirement: !ruby/object:Gem::Requirement
@@ -148,6 +148,8 @@ files:
 - lib/neo4j/spatial.rb
 - lib/neo4jrb_spatial.rb
 - lib/neo4jrb_spatial/errors.rb
+- lib/neo4jrb_spatial/rake_tasks.rb
+- lib/neo4jrb_spatial/rake_tasks/neo4j_spatial.rake
 - lib/neo4jrb_spatial/version.rb
 - neo4jrb_spatial.gemspec
 homepage: https://github.com/neo4jrb/neo4jrb_spatial
@@ -169,7 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Provides basic support for Neo4j Spatial with Neo4j.rb.