neomirror 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ab74e8c31f0b8ea8c07d4fdb8b454f7f1823c37b
+  data.tar.gz: 465c276d4c825cf27d2bf38decb2955287958669
+SHA512:
+  metadata.gz: 3d952da8b37fd49abd4cf9207992319a39c30f428cda953749e5d1c4cde0d5ece314edb849c39f472a44276c079b260221198ce501b472d8e5578165820a1034
+  data.tar.gz: 0e96b273a81c88048c053e8d450dd40b949845e306b5e31779b37f869bc2863337c3932776ec9e2d974087bb789ac84a866b7237cc58a6f941e42a80d25bd0b8

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in neomirror.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Alex Avoyants
+
+MIT License
+
+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,195 @@
+# Neomirror
+
+Lightweight but flexible gem that allows reflect some of data from relational database into neo4j.<br />
+This allows to perform faster and easier search of your models ids<br />
+or it can be first step of migrating application data to neo4j.<br />
+Uses [Neography](https://github.com/maxdemarzi/neography) (wrapper of Neo4j Rest API).
+Gem was inspired by [Neoid](https://github.com/neoid-gem/neoid)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'neomirror'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install neomirror
+
+## Configuration
+
+For more configuration options please read about Neography [Configuration and initialization](https://github.com/maxdemarzi/neography/wiki/Configuration-and-initialization)
+
+```ruby
+Neography.configure do |config|
+  config.protocol = "http://"
+  config.server = "localhost"
+  config.port = 7474
+  config.username = nil
+  config.password = nil
+end
+
+Neomirror.connection = Neography::Rest.new
+```
+
+## Usage
+
+### Reflect model as node (vertex).
+
+
+```ruby
+class User < ActiveRecord::Base
+  include Neomirror::Node
+
+  mirror_neo_node label: :User do # option :label is optional
+    property :name
+    property :name_length, ->(record) { record.name.length }
+  end
+end
+
+user = User.create(name: 'Dougal')
+# Find or create neo node.
+user.neo_node # => #<Neography::Node id=...> 
+user.node # Alias of #neo_node
+user.find_neo_node # => #<Neography::Node id=...> 
+```
+
+Primary key is saved automatically for nodes as `id` attribute. Also unique constraint is created. Creating a unique constraint also creates a unique index (which is faster than a regular index).
+
+For `ActiveRecord` methods `#create_neo_node`, `#update_neo_node`, `#destroy_neo_node` are called on corresponding callbacks (`after_create`, `after_update`, `after_destroy`).
+
+### Reflect model as one or several relationships (edges).
+
+```ruby
+class Membership < ActiveRecord::Base
+  include Neomirror::Relationship
+  belongs_to :premises
+  belongs_to :group
+
+  mirror_neo_relationship start_node: :premises, end_node: :group, type: :MEMBER_OF
+end
+
+membership = Membership.first
+# Find or create neo relationship.
+membership.neo_relationship # => #<Neography::Relationship> or nil unless both nodes present
+membership.neo_rel # Alias of #neo_relationship
+```
+
+For `ActiveRecord` methods `#create_neo_relationships`, `#update_neo_relationships`, `#destroy_neo_relationships` are called on corresponding callbacks (`after_create`, `after_update`, `after_destroy`).
+
+#### Reflect and retrieve several relationships for model.
+
+```ruby
+class Staff < ActiveRecord::Base
+  include Neomirror::Relationship
+  belongs_to :user
+  belongs_to :premises
+  belongs_to :group
+
+  mirror_neo_relationship start_node: :user, end_node: :premises, type: :STAFF_OF
+  mirror_neo_relationship start_node: :user, end_node: :group, type: :STAFF_OF
+end
+
+staff = Staff.first
+staff.neo_relationship(end_node: :premises) # => #<Neography::Relationship> or nil
+staff.neo_relationship(end_node: :group)    # => #<Neography::Relationship> or nil
+```
+
+## Migration of existing data
+
+```ruby
+Premises.find_each(&:create_neo_node)
+Group.find_each(&:create_neo_node)
+Membership.preload(:premises, :group).find_each(&:create_neo_relationships)
+User.find_each(&:create_neo_node)
+Staff.preload(:premises, :group).find_each(&:create_neo_relationships)
+```
+Note that `#create_neo_node` method will raise exception for already existed node and `#create_neo_relationships` will create duplicated relationships for existed relationships.
+
+Also can use `#neo_node` and `#neo_relationship` methods which find or create.
+
+```ruby
+Premises.find_each(&:neo_node)
+Group.find_each(&:neo_node)
+Membership.preload(:premises, :group).find_each(&:neo_relationship)
+User.find_each(&:neo_node)
+Staff.preload(:premises, :group).find_each do |staff|
+  staff.neo_relationship(end_node: :premises)
+  staff.neo_relationship(end_node: :group)
+end
+```
+
+## Clear neo4j
+
+```ruby
+Neomirror.neo.execute_query("START n=node(*) OPTIONAL MATCH n-[r]-() DELETE n,r")
+```
+
+## Reflect model as bunch of optional relationships
+
+Sometimes there is choise how to reflect relationship. Model which is representation of relationship can be mapped as edge with properties or as bunch of edges. Both design decisions are possible with neomirror.
+
+Reflect model as relationship (edge) with properties.
+
+```ruby
+class Staff < ActiveRecord::Base
+  include Neomirror::Relationship
+  belongs_to :user
+  belongs_to :premises
+
+  mirror_neo_relationship start_node: :user, end_node: :premises, type: :STAFF_OF do
+    property :roles
+  end
+end
+```
+
+Reflect model as bunch of optional relationships (edges) existence of which depends on the respective condition. On model create edge created only if predicate evaluates as true. On model update edge will be deleted if predicate evaluates as false.
+
+```ruby
+class Staff < ActiveRecord::Base
+  include Neomirror::Relationship
+  belongs_to :user
+  belongs_to :premises
+
+  mirror_neo_relationship start_node: :user, end_node: :premises, type: :MANAGER_OF,
+    if: ->(r) { r.roles.include?('manager') }
+
+  mirror_neo_relationship start_node: :user, end_node: :premises, type: :VISITOR_OF,
+    if: ->(r) { r.roles.include?('visitor') }
+end
+```
+
+Even possible reflect model as node (vertex) and relation(s) (edge). But it is probably not needed.
+
+## Compatibility
+
+It is possible to use it outside of ActiveRecord (there is no dependency). Just use methods `create_neo_node`, `update_neo_node` and `destroy_neo_node` in your callbaks for nodes and `create_neo_relationships`, `update_neo_relationships` and `destroy_neo_relationships` for relationships.
+
+Also specify primary key attribute if it is differ from `id` and class don't `respond_to? :primary_key` method.
+
+```
+class Postcode
+  attr_accessor :code
+  include Neomirror::Node
+
+  self.node_primary_key = :code
+
+  mirror_neo_node
+end
+
+p = Postcode.new
+p.code = 'ABC'
+p.create_neo_node # => #<Neography::Node id="ABC">
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/shhavel/neomirror/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["-c", "-f documentation", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+task default: :spec

data/lib/neomirror/node.rb

@@ -0,0 +1,83 @@
+module Neomirror::Node
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.after_create :create_neo_node if base.respond_to?(:after_create)
+    base.after_update :update_neo_node if base.respond_to?(:after_update)
+    base.after_destroy :destroy_neo_node if base.respond_to?(:after_destroy)
+  end
+
+  module ClassMethods
+    def neo_mirror
+      @neo_mirror ||= begin
+        return nil unless a = self.ancestors.drop(1).find { |c| c.respond_to?(:neo_mirror) && c.neo_mirror }
+        a.neo_mirror
+      end
+    end
+
+    def mirror_neo_node(options = {}, &block)
+      raise "Node mirror is already defined. Reflection model into more than one node is not supported. Create an issue if you need such functionality." if @neo_mirror
+      @neo_mirror = options
+      @neo_mirror[:label] ||= self.name.gsub(/^.*::/, '').to_sym # demodulize
+      @neo_mirror[:properties] = ::Neomirror::PropertyCollector.new(&block).properties if block_given?
+      ::Neomirror.neo.execute_query("CREATE CONSTRAINT ON (n:#{@neo_mirror[:label]}) ASSERT n.id IS UNIQUE")
+      @neo_mirror
+    end
+
+    def node_primary_key
+      @node_primary_key ||= self.respond_to?(:primary_key) ? self.__send__(:primary_key) : :id
+    end
+    attr_writer :node_primary_key
+  end
+
+  def neo_node
+    raise "Couldn't find neo_node declaration" unless self.class.neo_mirror
+    find_neo_node || create_neo_node
+  end
+  alias_method :node, :neo_node
+
+  def neo_node_properties
+    neo_node_properties = ::Hash.new
+    neo_node_properties[:id] = self.__send__(self.class.node_primary_key)
+    if self.class.neo_mirror && self.class.neo_mirror[:properties]
+      self.class.neo_mirror[:properties].each do |property, rule|
+        neo_node_properties[property] = rule.call(self)
+      end
+    end
+    neo_node_properties
+  end
+
+  def find_neo_node
+    raise "Couldn't find neo_node declaration" unless self.class.neo_mirror
+    label = self.class.neo_mirror[:label]
+    id = self.__send__(self.class.node_primary_key)
+    return nil unless node = ::Neomirror.neo.find_nodes_labeled(label, { :id => id }).first
+    @neo_node = ::Neography::Node.load(node, ::Neomirror.neo)
+  end
+
+  def create_neo_node
+    return true unless self.class.neo_mirror
+    @neo_node = ::Neography::Node.create(neo_node_properties, ::Neomirror.neo) 
+    ::Neomirror.neo.set_label(@neo_node, self.class.neo_mirror[:label])
+    @neo_node
+  end
+
+  def update_neo_node
+    return true unless self.class.neo_mirror
+    if find_neo_node
+      ::Neomirror.neo.reset_node_properties(@neo_node, neo_node_properties) if self.class.neo_mirror[:properties]
+      true
+    else
+      create_neo_node
+    end
+  end
+
+  def destroy_neo_node
+    return true unless self.class.neo_mirror && find_neo_node
+    ::Neomirror.neo.delete_node!(@neo_node)
+    true
+  end
+
+  def neo_node_to_cypher
+    ":#{self.class.neo_mirror[:label]} {id:#{self.__send__(self.class.node_primary_key)}}"
+  end
+end

data/lib/neomirror/property_collector.rb

@@ -0,0 +1,28 @@
+class Neomirror::PropertyCollector
+  def properties
+    @properties ||= {}
+  end
+
+  def property(property_name, record_method_name = nil, &block)
+    if record_method_name && block_given?
+      raise ArgumentError, "For property provide record's method name or block (or proc)"
+    elsif block_given?
+      properties[property_name.to_sym] = block
+    else
+      record_method_name ||= property_name
+      record_method_name = record_method_name.to_sym if record_method_name.is_a?(String)
+      properties[property_name.to_sym] = record_method_name.to_proc
+    end
+  end
+
+private
+
+  def initialize(&block)
+    return unless block_given? 
+    if block.arity == 0
+      self.instance_eval(&block)
+    else
+      block.call(self)
+    end
+  end
+end

data/lib/neomirror/relationship.rb

@@ -0,0 +1,103 @@
+module Neomirror::Relationship
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.after_create :create_neo_relationships if base.respond_to?(:after_create)
+    base.after_update :update_neo_relationships if base.respond_to?(:after_update)
+    base.after_destroy :destroy_neo_relationships if base.respond_to?(:after_destroy)
+  end
+
+  module ClassMethods
+    def rel_mirrors
+      @rel_mirrors ||= begin
+        if a = self.ancestors.drop(1).find { |c| c.respond_to?(:rel_mirrors) && c.rel_mirrors.any? }
+          a.rel_mirrors
+        else
+          []
+        end
+      end
+    end
+
+    # Find declaration by partial options.
+    def rel_mirror(p)
+      return rel_mirrors.first unless p
+      rel_mirrors.find { |m| (!p[:start_node] || p[:start_node] == m[:start_node]) &&
+        (!p[:end_node] || p[:end_node] == m[:end_node]) && (!p[:type] || p[:type] == m[:type]) }
+    end
+
+    def mirror_neo_relationship(options, &block)
+      m = Hash[options.map{ |k, v| [k.to_sym, v] }]
+      raise ArgumentError, "Mirror with such options already defined" if rel_mirror(m)
+      raise ArgumentError, "Options :start_node and :end_node are mandatory" unless m[:start_node] && m[:end_node]
+      m[:start_node] = m[:start_node].to_sym
+      m[:end_node] = m[:end_node].to_sym
+      m[:type] = (m[:type] ? m[:type] : self.name.gsub(/^.*::/, '').gsub(/([a-z\d])([A-Z])/, '\1_\2').upcase).to_sym
+      m[:properties] = Neomirror::PropertyCollector.new(&block).properties if block_given?
+      m[:if] = m[:if].to_proc if m[:if]
+      rel_mirrors << m
+    end
+  end
+
+  def neo_relationship(partial_mirror = nil)
+    find_neo_relationship(partial_mirror) || create_neo_relationship(partial_mirror)
+  end
+  alias_method :neo_rel, :neo_relationship
+
+  def neo_relationship_properties(partial_mirror = nil)
+    raise "Couldn't find neo_relationship declaration" unless rel_mirror = self.class.rel_mirror(partial_mirror)
+    return nil unless rel_mirror[:properties]
+    rel_mirror[:properties].reduce({}) { |h, (property, rule)| h[property] = rule.call(self); h }
+  end
+
+  def neo_relationship_must_exist?(partial_mirror = nil)
+    raise "Couldn't find neo_relationship declaration" unless rel_mirror = self.class.rel_mirror(partial_mirror)
+    !rel_mirror[:if] || !!rel_mirror[:if].call(self)
+  end
+
+  def find_neo_relationship(partial_mirror = nil)
+    raise "Couldn't find neo_relationship declaration" unless rel_mirror = self.class.rel_mirror(partial_mirror)
+    return nil unless (m1 = self.__send__(rel_mirror[:start_node])) && (m2 = self.__send__(rel_mirror[:end_node])) &&
+      (rel = ::Neomirror.neo.execute_query("MATCH (#{m1.neo_node_to_cypher})-[r:#{rel_mirror[:type]}]->(#{m2.neo_node_to_cypher}) RETURN r")["data"].first)
+    @neo_rel = ::Neography::Relationship.load(rel, ::Neomirror.neo)
+  end
+
+  def create_neo_relationship(partial_mirror = nil)
+    raise "Couldn't find neo_relationship declaration" unless rel_mirror = self.class.rel_mirror(partial_mirror)
+    return nil unless self.__send__(rel_mirror[:start_node]) && self.__send__(rel_mirror[:end_node]) && 
+      neo_relationship_must_exist?(rel_mirror)
+    ::Neography::Relationship.create(rel_mirror[:type], self.__send__(rel_mirror[:start_node]).neo_node, 
+      self.__send__(rel_mirror[:end_node]).neo_node, neo_relationship_properties(rel_mirror))
+  end
+
+  def update_neo_relationship(partial_mirror = nil)
+    raise "Couldn't find neo_relationship declaration" unless rel_mirror = self.class.rel_mirror(partial_mirror)
+    if find_neo_relationship(rel_mirror)
+      if neo_relationship_must_exist?(rel_mirror)
+        ::Neomirror.neo.reset_relationship_properties(@neo_rel, neo_relationship_properties(rel_mirror))
+      else
+        ::Neomirror.neo.delete_relationship(@neo_rel)
+      end
+    else
+      create_neo_relationship(rel_mirror) if neo_relationship_must_exist?(rel_mirror)
+    end
+  end
+
+  def destroy_neo_relationship(partial_mirror = nil)
+    raise "Couldn't find neo_relationship declaration" unless rel_mirror = self.class.rel_mirror(partial_mirror)
+    ::Neomirror.neo.delete_relationship(@neo_rel) if find_neo_relationship(rel_mirror)
+  end
+
+  def create_neo_relationships
+    self.class.rel_mirrors.each { |rel_mirror| create_neo_relationship(rel_mirror) }
+    true
+  end
+
+  def update_neo_relationships
+    self.class.rel_mirrors.each { |rel_mirror| update_neo_relationship(rel_mirror) }
+    true
+  end
+
+  def destroy_neo_relationships
+    self.class.rel_mirrors.each { |rel_mirror| destroy_neo_relationship(rel_mirror) }
+    true
+  end
+end

data/lib/neomirror/version.rb

@@ -0,0 +1,3 @@
+module Neomirror
+  VERSION = "0.0.1"
+end

data/lib/neomirror.rb

@@ -0,0 +1,12 @@
+require "neomirror/version"
+require "neography"
+require "neomirror/property_collector"
+require "neomirror/node"
+require "neomirror/relationship"
+
+module Neomirror
+  class << self
+    attr_accessor :connection
+    alias_method :neo, :connection
+  end
+end

data/neomirror.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'neomirror/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "neomirror"
+  spec.version       = Neomirror::VERSION
+  spec.authors       = ["Alex Avoyants"]
+  spec.email         = ["shhavel@gmail.com"]
+  spec.summary       = %q{Lightweight but flexible gem that allows reflect some of data from relational database into neo4j.}
+  spec.description   = %q{Lightweight but flexible gem that allows reflect some of data from relational database into neo4j. This allows to perform faster and easier search of your models ids or it can be first step of migrating application data to neo4j.}
+  spec.homepage      = ""
+  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_dependency "neography", ">= 1.5.2"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.11"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "activesupport"
+  spec.add_development_dependency "factory_girl"
+  spec.add_development_dependency "database_cleaner", ">= 1.2.0"
+end

data/spec/factories/group.rb

@@ -0,0 +1,3 @@
+FactoryGirl.define do
+  factory :group
+end

data/spec/factories/membership.rb

@@ -0,0 +1,3 @@
+FactoryGirl.define do
+  factory :membership
+end

data/spec/factories/premises.rb

@@ -0,0 +1,3 @@
+FactoryGirl.define do
+  factory :premises
+end

data/spec/factories/staff.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :staff do
+    roles %w(visitor)
+  end
+end

data/spec/factories/user.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :user do
+    name 'Ted'
+  end
+end

data/spec/neomirror/node_spec.rb

@@ -0,0 +1,78 @@
+require "spec_helper"
+
+describe Neomirror::Node do
+  let(:user) { create(:user) }
+  let(:neo_node) { user.find_neo_node }
+
+  describe "#find_neo_node" do
+    it "searches neo4j node, returns Neography::Node instance" do
+      user.find_neo_node.should be_a Neography::Node
+      user.find_neo_node.name.should == user.name
+    end
+
+    it "returns nil if there is no node in neo4j" do
+      user.destroy_neo_node
+      user.find_neo_node.should be_nil
+    end
+  end
+
+  describe "#neo_node" do
+    it "finds neo4j node if exists, returns Neography::Node instance" do
+      user.neo_node.should be_a Neography::Node
+      user.neo_node.name.should == user.name
+    end
+
+    it "creates neo4j node if not exists, returns Neography::Node instance" do
+      user.destroy_neo_node
+      user.neo_node.should be_a Neography::Node
+      user.neo_node.name.should == user.name
+    end
+  end
+
+  describe "#create_neo_node" do
+    before { user.destroy_neo_node }
+
+    it "creates neo4j node after record was created" do
+      user.create_neo_node
+      neo_node.should be_a Neography::Node
+    end
+  end
+
+  describe "#update_neo_node" do
+    it "updates neo4j node after record was updated" do
+      user.neo_node.name.should == 'Ted'
+      user.update_attributes(name: 'Dougal')
+      user.neo_node.name.should == 'Dougal'
+    end
+
+    it "creates neo4j node if it is not exists after record was updated" do
+      user.destroy_neo_node
+      user.find_neo_node.should be_nil
+      user.update_attributes(name: 'Dougal')
+      user.find_neo_node.should be_a Neography::Node
+      user.find_neo_node.name.should == 'Dougal'
+    end
+  end
+
+  describe "#destroy_neo_node" do
+    it "destroys neo4j node after record was destroyed" do
+      user.destroy
+      user.find_neo_node.should be_nil
+    end
+  end
+
+  describe ".node_primary_key" do
+    let(:postcode) { Postcode.new.tap { |p| p.code = 'ABC' } }
+
+    it "sets custom primary key" do
+      postcode.neo_node.should be_a Neography::Node
+      postcode.neo_node.id.should == 'ABC'
+    end
+  end
+
+  describe "#neo_node_to_cypher" do
+    it "represents node as cypher element" do
+      user.neo_node_to_cypher.should == ":User {id:#{user.id}}"
+    end
+  end
+end

data/spec/neomirror/relationship_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+
+describe Neomirror::Relationship do
+  let(:premises) { create(:premises) }
+  let(:group) { create(:group) }
+  let(:membership) { create(:membership, premises: premises, group: group) }
+  let(:user) { create(:user) }
+  let(:staff_of_premises) { create(:staff, user: user, premises: premises) }
+  let(:staff_of_group) { create(:staff, user: user, group: group) }
+  let(:staff) { create(:staff, user: user, premises: premises, group: group) }
+
+  describe "#find_neo_relationship" do
+    it "searches neo4j relationship, returns Neography::Relationship instance" do
+      membership.find_neo_relationship.should be_a Neography::Relationship
+    end
+
+    it "returns nil if there is no relationship in neo4j" do
+      membership.destroy_neo_relationship
+      membership.find_neo_relationship.should be_nil
+    end
+  end
+
+  describe "#neo_relationship" do
+    it "finds neo4j relationship if exists, returns Neography::Relationship instance" do
+      membership.neo_relationship.should be_a Neography::Relationship
+    end
+
+    it "creates neo4j relationship if not exists, returns Neography::Relationship instance" do
+      membership.destroy_neo_relationship
+      membership.neo_relationship.should be_a Neography::Relationship
+    end
+  end
+
+  describe "#create_neo_relationship" do
+    before { membership.destroy_neo_relationship }
+
+    it "creates neo4j relationship after record was created" do
+      membership.create_neo_relationship
+      membership.find_neo_relationship.should be_a Neography::Relationship
+    end
+
+    it "does not create neo4j relationship unless both nodes are present" do
+      membership = create(:membership, premises: premises)
+      membership.create_neo_relationship
+      membership.find_neo_relationship.should be_nil
+    end
+
+    it "does not create neo4j relationship if condition returns false" do
+      staff.create_neo_relationship(type: :VISITOR_OF)
+      staff.find_neo_relationship(type: :VISITOR_OF).should be_a Neography::Relationship
+      staff.create_neo_relationship(type: :MANAGER_OF)
+      staff.find_neo_relationship(type: :MANAGER_OF).should be_nil
+    end
+  end
+
+  describe "#create_neo_relationships" do
+    it "creates multiple neo4j relationships after record was created" do
+      staff.find_neo_relationship(end_node: :premises, type: :STAFF_OF).should be_a Neography::Relationship
+      staff.find_neo_relationship(end_node: :group, type: :STAFF_OF).should be_a Neography::Relationship
+    end
+
+    it "creates multiple neo4j relationships for which both nodes exist" do
+      staff_of_premises.find_neo_relationship(end_node: :premises, type: :STAFF_OF).should be_a Neography::Relationship
+      staff_of_premises.find_neo_relationship(end_node: :group, type: :STAFF_OF).should be_nil
+    end
+
+    it "creates multiple optional neo4j relationships for which condition returns true after record was created" do
+      staff.find_neo_relationship(type: :VISITOR_OF).should be_a Neography::Relationship
+      staff.find_neo_relationship(type: :MANAGER_OF).should be_nil
+    end
+  end
+
+  describe "#update_neo_relationship" do
+    it "updates neo4j relationship after record was updated" do
+      staff.find_neo_relationship.roles.should == %w(visitor)
+      staff.update_attributes(roles: %w(visitor admin))
+      staff.find_neo_relationship.roles.should == %w(visitor admin)
+    end
+
+    it "creates neo4j relationship if it is not exists after record was updated" do
+      staff.destroy_neo_relationships
+      staff.find_neo_relationship.should be_nil
+      staff.update_attributes(roles: %w(admin))
+      staff.find_neo_relationship.should be_a Neography::Relationship
+      staff.find_neo_relationship.roles.should == %w(admin)
+    end
+
+    it "deletes optional relationship for which condition returns false" do
+      staff.find_neo_relationship(type: :VISITOR_OF).should be_a Neography::Relationship
+      staff.find_neo_relationship(type: :MANAGER_OF).should be_nil
+      staff.update_attributes(roles: %w(manager))
+      staff.find_neo_relationship(type: :VISITOR_OF).should be_nil
+      staff.find_neo_relationship(type: :MANAGER_OF).should be_a Neography::Relationship
+    end
+  end
+
+  describe "#destroy_neo_relationship" do
+    it "destroys neo4j relationship after record was destroyed" do
+      membership.destroy
+      membership.find_neo_relationship.should be_nil
+      staff.destroy
+      staff.find_neo_relationship(end_node: :premises, type: :STAFF_OF).should be_nil
+      staff.find_neo_relationship(end_node: :group, type: :STAFF_OF).should be_nil
+      staff.find_neo_relationship(type: :VISITOR_OF).should be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require "neomirror"
+require "active_record"
+require "database_cleaner"
+require "factory_girl"
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ENV['NEO_URL'] ||= "http://127.0.0.1:7474"
+Neomirror.connection = Neography::Rest.new(ENV['NEO_URL'])
+
+ActiveRecord::Base.connection.execute('CREATE TABLE premises ("id" INTEGER PRIMARY KEY NOT NULL)')
+ActiveRecord::Base.connection.execute('CREATE TABLE groups ("id" INTEGER PRIMARY KEY NOT NULL)')
+ActiveRecord::Base.connection.execute('CREATE TABLE users ("id" INTEGER PRIMARY KEY NOT NULL, "name" varchar(255) NOT NULL)')
+ActiveRecord::Base.connection.execute('CREATE TABLE memberships ("id" INTEGER PRIMARY KEY NOT NULL, "premises_id" INTEGER DEFAULT NULL, "group_id" INTEGER DEFAULT NULL)')
+ActiveRecord::Base.connection.execute('CREATE TABLE staff ("id" INTEGER PRIMARY KEY NOT NULL, "user_id" INTEGER DEFAULT NULL, "premises_id" INTEGER DEFAULT NULL, "group_id" INTEGER DEFAULT NULL, "roles" TEXT)')
+
+FactoryGirl.find_definitions
+
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
+
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+    Neomirror.neo.execute_query("START n=node(*) OPTIONAL MATCH n-[r]-() DELETE n,r")
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

data/spec/support/group.rb

@@ -0,0 +1,9 @@
+class Group < ActiveRecord::Base
+  include Neomirror::Node
+  has_many :memberships
+  has_many :premises, through: :memberships
+  has_many :staff
+  has_many :users, through: :staff
+
+  mirror_neo_node
+end

data/spec/support/membership.rb

@@ -0,0 +1,7 @@
+class Membership < ActiveRecord::Base
+  include Neomirror::Relationship
+  belongs_to :premises
+  belongs_to :group
+
+  mirror_neo_relationship start_node: :premises, end_node: :group, type: :MEMBER_OF
+end

data/spec/support/postcode.rb

@@ -0,0 +1,8 @@
+class Postcode
+  attr_accessor :code
+  include Neomirror::Node
+
+  self.node_primary_key = :code
+
+  mirror_neo_node
+end

data/spec/support/premises.rb

@@ -0,0 +1,9 @@
+class Premises < ActiveRecord::Base
+  include Neomirror::Node
+  has_many :memberships
+  has_many :groups, through: :memberships
+  has_many :staff
+  has_many :users, through: :staff
+
+  mirror_neo_node
+end

data/spec/support/staff.rb

@@ -0,0 +1,21 @@
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.uncountable 'staff', 'staff'
+end
+
+class Staff < ActiveRecord::Base
+  include Neomirror::Relationship
+  belongs_to :user
+  belongs_to :premises
+  belongs_to :group
+  serialize :roles, Array
+
+  mirror_neo_relationship start_node: :user, end_node: :premises, type: :STAFF_OF do
+    property :roles, ->(record) { record.roles.to_a }
+  end
+  mirror_neo_relationship start_node: :user, end_node: :group, type: :STAFF_OF do
+    property :roles
+  end
+
+  mirror_neo_relationship start_node: :user, end_node: :premises, type: :MANAGER_OF, if: ->(r) { r.roles.include?('manager') }
+  mirror_neo_relationship start_node: :user, end_node: :premises, type: :VISITOR_OF, if: ->(r) { r.roles.include?('visitor') }
+end

data/spec/support/user.rb

@@ -0,0 +1,10 @@
+class User < ActiveRecord::Base
+  include Neomirror::Node
+  has_many :staff
+  has_many :premises, through: :staff
+  has_many :groups,   through: :staff
+
+  mirror_neo_node do
+    property :name
+  end
+end

metadata

@@ -0,0 +1,213 @@
+--- !ruby/object:Gem::Specification
+name: neomirror
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alex Avoyants
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: neography
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: activerecord
+  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: activesupport
+  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: factory_girl
+  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: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: Lightweight but flexible gem that allows reflect some of data from relational
+  database into neo4j. This allows to perform faster and easier search of your models
+  ids or it can be first step of migrating application data to neo4j.
+email:
+- shhavel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/neomirror.rb
+- lib/neomirror/node.rb
+- lib/neomirror/property_collector.rb
+- lib/neomirror/relationship.rb
+- lib/neomirror/version.rb
+- neomirror.gemspec
+- spec/factories/group.rb
+- spec/factories/membership.rb
+- spec/factories/premises.rb
+- spec/factories/staff.rb
+- spec/factories/user.rb
+- spec/neomirror/node_spec.rb
+- spec/neomirror/relationship_spec.rb
+- spec/spec_helper.rb
+- spec/support/group.rb
+- spec/support/membership.rb
+- spec/support/postcode.rb
+- spec/support/premises.rb
+- spec/support/staff.rb
+- spec/support/user.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Lightweight but flexible gem that allows reflect some of data from relational
+  database into neo4j.
+test_files:
+- spec/factories/group.rb
+- spec/factories/membership.rb
+- spec/factories/premises.rb
+- spec/factories/staff.rb
+- spec/factories/user.rb
+- spec/neomirror/node_spec.rb
+- spec/neomirror/relationship_spec.rb
+- spec/spec_helper.rb
+- spec/support/group.rb
+- spec/support/membership.rb
+- spec/support/postcode.rb
+- spec/support/premises.rb
+- spec/support/staff.rb
+- spec/support/user.rb