rom-neo4j 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 434f1e9e4586f8d8a826631dc3df4acb084fd636
+  data.tar.gz: f8856d06f8ca5f12b65f21b793bc91e9ca88d1a0
+SHA512:
+  metadata.gz: 8d1aea0e308f15dd1e66e98cdff967bab262bb6b0f840c8166610a156d84a134dc5ce3d4b29e6dd0c103e42ca79303c74923dd24413918f7082979066f1c86ca
+  data.tar.gz: 506f5147ffd33784f81a10e700238f79e484c53cbcd699fbc1996af979a1067ab2e936303a91eef05852c2a19344845886dabb3852825cc1548b54bdc7fca2d4

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,68 @@
+# ROM::Neo4j
+
+Map objects returned from Neo4j graph traversals using the [Ruby Object Mapper](https://github.com/rom-rb/rom) toolkit.
+
+## Status
+
+Incomplete experimental sketch.
+
+The adapter spec passes with the generic movies dataset distributed with Neo4j, but that's about all at this point.
+
+## Install
+
+Right now, the fastest way to get started is to run the tests.
+
+You’ll need to have Neo4j installed on your system. If it’s not already running, start the database server with:
+
+```
+neo4j start
+```
+
+To load the sample movies graph, go to `http://localhost:7474/browser/` and click through the instructions or type `:play movie graph` in the console to start.
+
+Once the movies graph is loaded, the integration specs should run:
+
+```
+rspec specs/integration
+```
+
+## Examples
+
+### Cypher DSL
+
+```ruby
+setup.relation(:movies) do
+  matches m: :Movie
+  returns m: [:title, :released, :tagline]
+
+  def titled(title)
+    where('m.title' => title)
+  end
+
+end
+
+movie = rom.read(:movies).titled('The Matrix').first
+movie.title   # => "The Matrix"
+movie.updated # => 1999
+```
+
+### Raw Cypher Queries
+
+```ruby
+setup.relation(:directors) do
+  matches '(director:Person)-[:DIRECTED]->(movie:Movie)'
+  returns 'DISTINCT director.name as name'
+
+  def by_movie(title)
+    where('movie.title' => title)
+  end
+
+end
+
+director = rom.read(:directors).by_movie('RescueDawn').first
+director.name # => "Werner Herzog"
+```
+
+## Roadmap
+
+A work in progress.

data/lib/rom-neo4j.rb

@@ -0,0 +1 @@
+require 'rom/neo4j'

data/lib/rom/neo4j.rb

@@ -0,0 +1,10 @@
+require 'neo4j-core'
+
+require 'rom'
+
+require 'rom/neo4j/dataset'
+require 'rom/neo4j/relation'
+require 'rom/neo4j/repository'
+require 'rom/neo4j/support/core_ext'
+
+ROM.register_adapter(:neo4j, ROM::Neo4j)

data/lib/rom/neo4j/dataset.rb

@@ -0,0 +1,62 @@
+module ROM
+  module Neo4j
+    # A dataset represents a collection returned from a query traversal over a
+    # sub-graph.
+    #
+    # Datasets are Enumerable objects and can be manipulated using the standard
+    # methods, `each`, `map`, `inject`, and so forth.
+    class Dataset
+      include Enumerable
+
+      # @see http://www.rubydoc.info/gems/neo4j-core/Neo4j/Core/Query
+      # @param query [Neo4j::Core::Query] Query object returned from a Neo4j connection
+      def initialize(query)
+        @query = query
+      end
+
+      def to_cypher
+        @query.to_cypher
+      end
+
+      def each(&iter)
+        @query.each(&iter)
+      end
+
+      def where(*conditions)
+        self.class.new(@query.where(*conditions))
+      end
+
+      def start(*conditions)
+        self.class.new(@query.start(*conditions))
+      end
+
+      def match(*conditions)
+        self.class.new(@query.match(*conditions))
+      end
+
+      def return(*conditions)
+        self.class.new(@query.return(*conditions))
+      end
+
+      def limit(*conditions)
+        self.class.new(@query.limit(*conditions))
+      end
+
+      def merge(*conditions)
+        self.class.new(@query.merge(*conditions))
+      end
+
+      def order(*conditions)
+        self.class.new(@query.order(*conditions))
+      end
+
+      def optional_match(*conditions)
+        self.class.new(@query.optional_match(*conditions))
+      end
+
+      def params(*conditions)
+        self.class.new(@query.params(*conditions))
+      end
+    end
+  end
+end

data/lib/rom/neo4j/relation.rb

@@ -0,0 +1,99 @@
+module ROM
+  module Neo4j
+    # Relation supporting Cypher graph traversals. Configure the sub-graph
+    # for the relation by specifying a `match` pattern, and collect a dataset
+    # for mapping by specifying nodes, edges and properties in the `returns`.
+    class Relation < ROM::Relation
+
+      # TODO: document these methods
+      forward(
+        :start, :match, :where, :return, :limit, :merge, :order,
+        :optional_match, :params
+      )
+
+      # The row iterator. Calling this kicks off the actual query to the
+      # database server.
+      #
+      # Before triggering the enumerator, it rebuilds the dataset with the
+      # default traversal configured by the relation DSL.
+      #
+      def each(&iter)
+        # Configure the default traversal
+        unless @configured
+          @configured = true
+          self.class.traversal.each do |query_method, conditions|
+            @dataset = @dataset.send(query_method.to_sym, *conditions) if conditions
+          end
+        end
+
+        @dataset.each(&iter)
+      end
+
+      # Builds data structures to configure the relation DSL.
+      # @api private
+      def self.inherited(klass)
+        klass.class_eval do
+          class << self
+            attr_reader :traversal
+          end
+        end
+
+        klass.instance_variable_set('@traversal', {
+          start: false,
+          match: false,
+          return: false
+        })
+
+        super
+      end
+
+      # Specify a `START` node for the for the relation's graph traversal. This
+      # is only required for legacy indexes. In most cases Cypher can infer the
+      # starting points to anchor a graph traversal from the pattern specified
+      # in a `MATCH` clause.
+      #
+      # @see http://neo4j.com/docs/stable/query-start.html
+      #
+      def self.start(*conditions)
+        @traversal[:start] = conditions
+      end
+
+      # Specify a `MATCH` clause for the relation's graph traversal. If you’re
+      # coming from the SQL world, you can think of this as similar to a
+      # `SELECT FROM`, except that it matches on a topological structure rather
+      # than a schema.
+      #
+      # @example Reproduce SQL style projections by passing node labels directly.
+      #
+      #   class Movies < ROM::Relation[:neo4j]
+      #     matches m: :movie
+      #   end
+      #
+      # @example Specify topological matches using Cypher's ASCII-art syntax.
+      #
+      #   class Actors < ROM::Relation[:neo4j]
+      #     matches '(actor:Person)-[:ACTED_IN]->(movie)'
+      #   end
+      #
+      # @see http://neo4j.com/docs/stable/query-match.html
+      #
+      def self.matches(*conditions)
+        @traversal[:match] = conditions
+      end
+
+      # Specify a `RETURN` clause for the relation. This will define the
+      # structure of objects in the returned dataset.
+      #
+      # Any combination of nodes, edges and properties can be selected, as well
+      # as custom aliases and distinct objects.
+      #
+      # @see http://neo4j.com/docs/stable/query-return.html
+      #
+      def self.returns(*conditions)
+        @traversal[:return] = conditions
+      end
+
+    end
+
+  end
+end

data/lib/rom/neo4j/repository.rb

@@ -0,0 +1,20 @@
+module ROM
+  module Neo4j
+    class Repository < ROM::Repository
+      attr_reader :sets
+
+      def initialize(uri, options={})
+        @connection = ::Neo4j::Session.open(:server_db, uri, options)
+        @sets = {}
+      end
+
+      def dataset(name)
+        sets[name] = Dataset.new(@connection.query)
+      end
+
+      def dataset?(name)
+        sets.key?(name)
+      end
+    end
+  end
+end

data/lib/rom/neo4j/support/core_ext.rb

@@ -0,0 +1,46 @@
+# Extensions to the Neo4j::Core library making it easier to integrate with ROM.
+module Neo4j
+  module Core
+    # DSL for generating Cypher queries and enumerating their results
+    #
+    # @see http://www.rubydoc.info/gems/neo4j-core/Neo4j/Core/Query
+    class Query
+      # def each
+      #   response = self.response
+      #   if response.is_a?(Neo4j::Server::CypherResponse)
+      #     response.to_node_enumeration
+      #   else
+      #     Neo4j::Embedded::ResultWrapper.new(response, to_cypher)
+      #   end.each { |object| yield object }
+      # end
+    end
+  end
+  module Server
+    class CypherResponse
+      # Coerces result objects from structs to hashes in results. 
+      class HashEnumeration
+        def each(&block)
+          @response.each_data_row do |row|
+            yield(row.each_with_index.each_with_object(struct.new) do |(value, i), result|
+              result[columns[i].to_sym] = value
+            end.to_h)
+          end
+        end
+      end
+      # Coerces result objects from structs to hashes in results. 
+      def to_node_enumeration(cypher = '', session = Neo4j::Session.current)
+        Enumerator.new do |yielder|
+          @result_index = 0
+          to_struct_enumeration(cypher).each do |row|
+            @row_index = 0
+            yielder << row.each_pair.each_with_object(@struct.new) do |(column, value), result|
+              result[column] = map_row_value(value, session)
+              @row_index += 1
+            end.to_h
+            @result_index += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/neo4j/version.rb

@@ -0,0 +1,5 @@
+module ROM
+  module Neo4j
+    VERSION = '0.0.1'.freeze
+  end
+end

data/rom-neo4j.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rom/neo4j/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rom-neo4j'
+  spec.version       = ROM::Neo4j::VERSION.dup
+  spec.authors       = ['Mark Rickerby']
+  spec.email         = ['me@maetl.net']
+  spec.summary       = 'Neo4j graph relations for Ruby Object Mapper'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://rom-rb.org/'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'rom', '~> 0.6'
+  spec.add_runtime_dependency 'neo4j-core', '~> 4.0'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rubocop', '~> 0.28.0'
+end

data/spec/integration/adapter_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'rom/lint/spec'
+
+describe 'Neo4j adapter' do
+  let(:dsn) { 'http://localhost:7474' }
+  let(:setup) { ROM.setup(:neo4j, dsn) }
+
+  context 'with movies relation and mapper' do
+    let(:rom) do
+      setup.relation(:movies) do
+        matches m: :Movie
+        #returns m: [:title, :released, :tagline]
+        returns ['m.title AS title', 'm.released AS released', 'm.tagline as tagline']
+
+        def by_title(title)
+          where('m.title' => title)
+        end
+      end
+
+      setup.mappers do
+        define(:movies) do
+          relation :movies
+          model name: 'Movie'
+          #prefix :m
+          #prefix_separator '.'
+          attribute :title
+          attribute :released
+          attribute :tagline
+        end
+      end
+
+      setup.finalize
+    end
+
+    let(:movies) do
+      rom.relation(:movies)
+    end
+
+    it 'maps movies #by_title' do
+      movies.by_title('The Matrix').as(:movies).first.tap do |movie|
+        expect(movie).to be_a(Movie)
+        expect(movie.title).to eql('The Matrix')
+        expect(movie.released).to eql(1999)
+        expect(movie.tagline).to eql('Welcome to the Real World')
+      end
+    end
+
+  end
+
+  context 'with directors relation and mapper' do
+    let(:rom) do
+      setup.relation(:directors) do
+        matches '(director:Person)-[:DIRECTED]->(movie:Movie)'
+        returns 'DISTINCT director.name AS name'
+
+        def by_movie(title)
+          where('movie.title' => title)
+        end
+      end
+
+      setup.mappers do
+        define(:directors) do
+          relation :directors
+          model name: 'Director'
+          attribute :name
+        end
+      end
+
+      setup.finalize
+    end
+
+    let(:directors) do
+      rom.relation(:directors)
+    end
+
+    it 'maps directors #by_movie_title' do
+      directors.by_movie('RescueDawn').as(:directors).first.tap do |director|
+        expect(director).to be_a(Director)
+        expect(director.name).to eql('Werner Herzog')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'rom-neo4j'

data/spec/unit/query_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'rom/memory/dataset'
+
+describe ROM::Neo4j::Relation do
+
+  describe '#where' do
+    xit 'where equals' do
+      expect(relation.to_a).to eql([matrix, reloaded])
+    end
+
+    xit 'where not equals' do
+      expect(relation.to_a).to eql([matrix, reloaded])
+    end
+
+    xit 'where gte' do
+      expect(relation.to_a).to eql([matrix, reloaded])
+    end
+  end
+
+  describe '#limit' do
+
+  end
+
+  describe '#merge' do
+
+  end
+
+  describe '#order' do
+
+  end
+
+  describe '#order' do
+
+  end
+
+end

data/spec/unit/relation_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'rom/memory/dataset'
+
+describe ROM::Neo4j::Relation do
+  subject(:relation) { Class.new(ROM::Neo4j::Relation).new(dataset) }
+
+  let(:dataset) { ROM::Memory::Dataset.new([matrix, reloaded]) }
+
+  let(:matrix) { { title: 'The Matrix', released: 1999 } }
+  let(:reloaded) { { title: 'The Matrix Reloaded', released: 2003 } }
+
+  describe '#each' do
+    it 'yields all objects' do
+      result = []
+
+      relation.each do |user|
+        result << user
+      end
+
+      expect(result).to eql([matrix, reloaded])
+    end
+
+    it 'returns an enumerator if block is not provided' do
+      expect(relation.each).to be_instance_of(Enumerator)
+    end
+  end
+
+  describe '#to_a' do
+    it 'materializes relation to an array' do
+      expect(relation.to_a).to eql([matrix, reloaded])
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: rom-neo4j
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mark Rickerby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: neo4j-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.28.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.28.0
+description: Neo4j graph relations for Ruby Object Mapper
+email:
+- me@maetl.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- lib/rom-neo4j.rb
+- lib/rom/neo4j.rb
+- lib/rom/neo4j/dataset.rb
+- lib/rom/neo4j/relation.rb
+- lib/rom/neo4j/repository.rb
+- lib/rom/neo4j/support/core_ext.rb
+- lib/rom/neo4j/version.rb
+- rom-neo4j.gemspec
+- spec/integration/adapter_spec.rb
+- spec/spec_helper.rb
+- spec/unit/query_spec.rb
+- spec/unit/relation_spec.rb
+homepage: https://rom-rb.org/
+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.4.2
+signing_key: 
+specification_version: 4
+summary: Neo4j graph relations for Ruby Object Mapper
+test_files:
+- spec/integration/adapter_spec.rb
+- spec/spec_helper.rb
+- spec/unit/query_spec.rb
+- spec/unit/relation_spec.rb
+has_rdoc: