redgraph 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5a64b5cffa36368ac0664e813ab61f0329a055237b7e4acd473820d9c73409d
-  data.tar.gz: 371cde906c0a80370e39763a9b3ba9f3fcb83cdd2c19e97f635bfea6e35c5540
+  metadata.gz: 2fd53776ff217146cd6ca4924da40a43f5bf929fad03b73b79f32d371ea955e8
+  data.tar.gz: 551afc973f8e732ad532e74395e6c73251f14d68db73f667a207b234bd64163b
 SHA512:
-  metadata.gz: ac0481573ed2d41bb20de03ab1dc36d6781f5a121a865358e296654dc09abe168868104df92deeb623594b6d68363a0c9333268a059c7b8caf362504039e1431
-  data.tar.gz: dcb4c293c0a1003926d8776930123c81a5d35981a0896d447a03cc8ee1082f837ce1d73a1f7ca664478980fb485eefb39dad120f703b4584d40ffd6a3ff509c2
+  metadata.gz: dd7f88ae09acb7f09b6c8de949d4f31bbc52b12e4b914f035de99c7cd9b409c14eac3e592f834cc968517b796fed0cf3a085f7eba4915e630b2e66c424ae9870
+  data.tar.gz: 979aac39193d3150441ddf5baca14772a35c6cfd00f09df42752277aed3d955869822b2d97150209f1e71ad5ab95e566dc645d15d3e8262675dd858bd6fbb1dd

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [0.2.1]
+
+- Add NodeModel#destroy method
+- Add NodeModel.create method
+
 ## [0.2.0]
 
 - revamp the NodeModel mixin, the Node to model mapping is now handled by the `_type` property

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redgraph (0.2.0)
+    redgraph (0.2.1)
       activesupport (>= 3.0.0)
       redis (~> 4)
 

data/README.md

@@ -1,5 +1,8 @@
 # Redgraph
 
+[![Gem Version](https://badge.fury.io/rb/redgraph.svg)](https://badge.fury.io/rb/redgraph)
+[![Code Climate](https://codeclimate.com/github/pzac/redgraph.svg)](https://codeclimate.com/github/pzac/redgraph)
+
 A simple RedisGraph library. This gem owes **a lot** to the existing [redisgraph-rb](https://github.com/RedisGraph/redisgraph-rb) gem, but tries to provide a friendlier interface, similar to the existing [Python](https://github.com/RedisGraph/redisgraph-py) and [Elixir](https://github.com/crflynn/redisgraph-ex) clients.
 
 ## Installation
@@ -24,92 +27,122 @@ The gem assumes you have a recent version of [RedisGraph](https://oss.redislabs.
 
 Basic usage:
 
-    graph = Redgraph::Graph.new('movies', url: "redis://localhost:6379/1")
-    => #<Redgraph::Graph:0x00007f8d5c2b7e38 @connection=#<Redis client v4.2.5 for redis://localhost:6379/1>, @graph_name="movies", @module_version=999999>
+```ruby
+graph = Redgraph::Graph.new('movies', url: "redis://localhost:6379/1")
+=> #<Redgraph::Graph:0x00007f8d5c2b7e38 @connection=#<Redis client v4.2.5 for redis://localhost:6379/1>, @graph_name="movies", @module_version=999999>
+```
 
 Create a couple nodes:
 
-    actor = Redgraph::Node.new(label: 'actor', properties: {name: "Al Pacino"})
-    => #<Redgraph::Node:0x00007f8d5f95cf88 @label="actor", @properties={:name=>"Al Pacino"}>
-    graph.add_node(actor)
-    => #<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>
-    film = Redgraph::Node.new(label: 'film', properties: {name: "Scarface"})
-    => #<Redgraph::Node:0x00007f8d5f85ccc8 @label="film", @properties={:name=>"Scarface"}>
-    graph.add_node(film)
-    => #<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>
+```ruby
+actor = Redgraph::Node.new(label: 'actor', properties: {name: "Al Pacino"})
+=> #<Redgraph::Node:0x00007f8d5f95cf88 @label="actor", @properties={:name=>"Al Pacino"}>
+graph.add_node(actor)
+=> #<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>
+film = Redgraph::Node.new(label: 'film', properties: {name: "Scarface"})
+=> #<Redgraph::Node:0x00007f8d5f85ccc8 @label="film", @properties={:name=>"Scarface"}>
+graph.add_node(film)
+=> #<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>
+```
 
 Create an edge between those nodes:
 
-    edge = Redgraph::Edge.new(src: actor, dest: film, type: 'ACTOR_IN', properties: {role: "Tony Montana"})
-    => #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
-    @graph.add_edge(edge)
-    => #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @id=0, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
+```ruby
+edge = Redgraph::Edge.new(src: actor, dest: film, type: 'ACTOR_IN', properties: {role: "Tony Montana"})
+=> #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
+@graph.add_edge(edge)
+=> #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @id=0, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
+```
 
 You can merge nodes - the node will be created only if there isn't another with the same label and properties:
 
-    graph.merge_node(film)
-    => #<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>
+```ruby
+graph.merge_node(film)
+=> #<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>
+```
 
 Same with edges:
 
-    @graph.merge_edge(edge)
-    => #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @id=0, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
+```ruby
+@graph.merge_edge(edge)
+=> #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @id=0, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
+```
 
 Find a node by id:
 
-    @graph.find_node_by_id(1)
-    => #<Redgraph::Node:0x00007f8d5c2c6e88 @id=1, @label="film", @properties={"name"=>"Scarface"}>
+```ruby
+@graph.find_node_by_id(1)
+=> #<Redgraph::Node:0x00007f8d5c2c6e88 @id=1, @label="film", @properties={"name"=>"Scarface"}>
+```
 
 To get all nodes:
 
-    @graph.nodes
-    => [#<Redgraph::Node:0x00007f8d5c2ee0a0 @id=0, @label="actor", @properties={"name"=>"Al Pacino"}>, #<Redgraph::Node:0x00007f8d5c2edfd8 @id=1, @label="film", @properties={"name"=>"Scarface"}>]
+```ruby
+@graph.nodes
+=> [#<Redgraph::Node:0x00007f8d5c2ee0a0 @id=0, @label="actor", @properties={"name"=>"Al Pacino"}>, #<Redgraph::Node:0x00007f8d5c2edfd8 @id=1, @label="film", @properties={"name"=>"Scarface"}>]
+```
 
 Optional filters that can be combined:
 
-    @graph.nodes(label: 'actor')
-    @graph.nodes(properties: {name: "Al Pacino"})
-    @graph.nodes(limit: 10, skip: 20)
+```ruby
+@graph.nodes(label: 'actor')
+@graph.nodes(properties: {name: "Al Pacino"})
+@graph.nodes(limit: 10, skip: 20)
+```
 
 Counting nodes
 
-    @graph.count_nodes(label: 'actor')
-    => 1
+```ruby
+@graph.count_nodes(label: 'actor')
+=> 1
+```
 
 Getting edges:
 
-    @graph.edges
-    @graph.edges(src: actor, dest: film)
-    @graph.edges(kind: 'FRIEND_OF', limit: 10, skip: 20)
-    @graph.count_edges
+```ruby
+@graph.edges
+@graph.edges(src: actor, dest: film)
+@graph.edges(kind: 'FRIEND_OF', limit: 10, skip: 20)
+@graph.count_edges
+```
 
 Running custom queries
 
-    @graph.query("MATCH (src)-[edge:FRIEND_OF]->(dest) RETURN src, edge")
+```ruby
+@graph.query("MATCH (src)-[edge:FRIEND_OF]->(dest) RETURN src, edge")
+```
 
 ### NodeModel
 
 You can use the `NodeModel` mixin for a limited ActiveRecord-like interface:
 
-    class Actor
-      include Redgraph::NodeModel
-      self.graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
-      attribute :name
-    end
+```ruby
+class Actor
+  include Redgraph::NodeModel
+  self.graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
+  attribute :name
+end
+```
 
 And this will give you stuff such as
 
-    Actor.count
-    john = Actor.new(name: "John Travolta")
-    john.add_to_graph # Will add the node to the graph
-    john.add_relation(type: "ACTED_IN", node: film, properties: {role: "Tony Manero"})
+```ruby
+Actor.count
+john = Actor.new(name: "John Travolta")
+john.add_to_graph # Will add the node to the graph
+john.add_relation(type: "ACTED_IN", node: film, properties: {role: "Tony Manero"})
+john.reload
+john.destroy
+Actor.create(name: "Al Pacino")
+```
 
 `NodeModel` models will automatically set a `_type` property to keep track of the object class.
 
 You will then be able to run custom queries such as:
 
-    Actor.query("MATCH (node) RETURN node ORDER BY node.name")
-
+```ruby
+Actor.query("MATCH (node) RETURN node ORDER BY node.name")
+```
 And the result rows object will be instances of the classes defined by the `_type` attribute.
 
 ## Development

data/lib/redgraph.rb

@@ -21,4 +21,9 @@ module Redgraph
       "The order clause requires the node/edge alias prefix, ie order('node.foo') instead order('foo')"
     end
   end
+  class MissingGraphError < Error
+    def message
+      "A graph to use is not defined"
+    end
+  end
 end

data/lib/redgraph/graph.rb

@@ -7,6 +7,7 @@ module Redgraph
   class Graph
     include NodeMethods
     include EdgeMethods
+    include Util
 
     attr_accessor :connection, :graph_name
 

data/lib/redgraph/graph/node_methods.rb

@@ -73,6 +73,24 @@ module Redgraph
         query(cmd).flatten[0] || 0
       end
 
+      def update_node(node)
+        return false unless node.persisted?
+        _set = node.properties.map do |(key, val)|
+          "node.#{key} = #{escape_value(val)}"
+        end.join(", ")
+
+        cmd = "MATCH (node) WHERE ID(node) = #{node.id} SET #{_set} RETURN node"
+        result = _query(cmd)
+        node_from_resultset_item(result.resultset.first["node"])
+      end
+
+      def destroy_node(node)
+        return false unless node.persisted?
+        cmd = "MATCH (node) WHERE ID(node) = #{node.id} DELETE node"
+        result = _query(cmd)
+        result.stats["nodes_deleted"] == 1
+      end
+
       private
 
       # Builds a Node object from the raw data
@@ -99,6 +117,7 @@ module Redgraph
         node
       end
 
+
     end
   end
 end

data/lib/redgraph/node_model.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 require_relative 'node_model/class_methods'
+require_relative 'node_model/graph_manipulation'
+require_relative 'node_model/persistence'
 
 module Redgraph
   # This mixin allows you to use an interface similar to ActiveRecord
@@ -24,10 +26,12 @@ module Redgraph
     extend ActiveSupport::Concern
 
     included do |base|
+      include Persistence
+      include GraphManipulation
+
       @attribute_names = [:id]
 
-      attr_accessor :id
-      attr_accessor :_type
+      attr_accessor :id, :_type
 
       class << self
         attr_reader :attribute_names
@@ -35,7 +39,7 @@ module Redgraph
 
         def attribute(name)
           @attribute_names << name
-          attr_reader(name)
+          attr_accessor(name)
         end
 
         private
@@ -76,32 +80,10 @@ module Redgraph
       self.class.attribute_names.to_h { |name| [name, public_send(name)] }
     end
 
-    def persisted?
-      id.present?
-    end
-
-    # Adds the node to the graph
-    #
-    # - allow_duplicates: if false it will create a node with the same type and properties only if
-    #     not present
-    #
-    def add_to_graph(allow_duplicates: true)
-      item = allow_duplicates ? graph.add_node(to_node) : graph.merge_node(to_node)
-      self.id = item.id
-      self
-    end
-
-    # Adds a relation between the node and another node.
-    #
-    # - type: type of relation
-    # - node: the destination node
-    # - properties: optional properties hash
-    # - allow_duplicates: if false it will create a relation between two nodes with the same type
-    #     and properties only if not present
-    #
-    def add_relation(type:, node:, properties: nil, allow_duplicates: true)
-      edge = Edge.new(type: type, src: to_node, dest: node.to_node, properties: properties)
-      allow_duplicates ? graph.add_edge(edge) : graph.merge_edge(edge)
+    def assign_attributes(attrs = {})
+      attrs.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
     end
 
     def to_node
@@ -109,12 +91,6 @@ module Redgraph
       Redgraph::Node.new(id: id, label: label, properties: props)
     end
 
-    # Converts a Node object into NodeModel
-    #
-    def reify_from_node(node)
-      self.class.reify_from_node(node)
-    end
-
     def ==(other)
       attributes == other.attributes && id == other.id
     end

data/lib/redgraph/node_model/class_methods.rb

@@ -3,12 +3,13 @@ module Redgraph
     module ClassMethods
       # Returns an array of nodes. Options:
       #
+      # - label: filter by label
       # - properties: filter by properties
       # - order: node.name ASC, node.year DESC
       # - limit: number of items
       # - skip: items offset (useful for pagination)
       #
-      def all(properties: {}, limit: nil, skip: nil, order: nil)
+      def all(label: nil, properties: {}, limit: nil, skip: nil, order: nil)
         graph.nodes(label: label, properties: properties_plus_type(properties),
                     limit: limit, skip: skip, order: nil).map do |node|
           reify_from_node(node)
@@ -19,7 +20,7 @@ module Redgraph
       #
       # - properties: filter by properties
       #
-      def count(properties: nil)
+      def count(label: nil, properties: nil)
         graph.count_nodes(label: label, properties: properties_plus_type(properties))
       end
 
@@ -55,6 +56,8 @@ module Redgraph
       # Returns an array of rows.
       #
       def query(cmd)
+        raise MissingGraphError unless graph
+
         graph.query(cmd).map do |row|
           row.map do |item|
             item.is_a?(Node) ? reify_from_node(item) : item
@@ -62,6 +65,10 @@ module Redgraph
         end
       end
 
+      def create(properties)
+        new(**properties).add_to_graph
+      end
+
       private
 
       def default_label

data/lib/redgraph/node_model/graph_manipulation.rb

@@ -0,0 +1,24 @@
+module Redgraph
+  module NodeModel
+    module GraphManipulation
+      # Adds a relation between the node and another node.
+      #
+      # - type: type of relation
+      # - node: the destination node
+      # - properties: optional properties hash
+      # - allow_duplicates: if false it will create a relation between two nodes with the same type
+      #     and properties only if not present
+      #
+      def add_relation(type:, node:, properties: nil, allow_duplicates: true)
+        edge = Edge.new(type: type, src: to_node, dest: node.to_node, properties: properties)
+        allow_duplicates ? graph.add_edge(edge) : graph.merge_edge(edge)
+      end
+
+      # Runs a custom query on the graph
+      #
+      def query(cmd)
+        self.class.query(cmd)
+      end
+    end
+  end
+end

data/lib/redgraph/node_model/persistence.rb

@@ -0,0 +1,56 @@
+module Redgraph
+  module NodeModel
+    module Persistence
+      # Adds the node to the graph
+      #
+      # - allow_duplicates: if false it will create a node with the same type and properties only if
+      #     not present
+      #
+      def add_to_graph(allow_duplicates: true)
+        raise MissingGraphError unless graph
+        item = allow_duplicates ? graph.add_node(to_node) : graph.merge_node(to_node)
+        self.id = item.id
+        self
+      end
+
+      # Creates a new record or updates the existing
+      #
+      def save
+        if persisted?
+          item = graph.update_node(to_node)
+          self.class.reify_from_node(item)
+        else
+          add_to_graph
+        end
+      end
+
+      def persisted?
+        id.present?
+      end
+
+      def reload
+        item = self.class.find(id)
+        @label = item.label
+        assign_attributes(item.attributes)
+        self
+      end
+
+      # Deletes the record from the graph
+      #
+      def destroy
+        @destroyed = true
+        if graph.destroy_node(self)
+          self
+        else
+          false
+        end
+      end
+
+      # Returns true if this object has been destroyed, otherwise returns false.
+      #
+      def destroyed?
+        !!@destroyed
+      end
+    end
+  end
+end

data/lib/redgraph/query_response.rb

@@ -29,9 +29,16 @@ module Redgraph
       @response = response
       @graph = graph
 
-      @header_row = @response[0]
-      @result_rows = @response[1]
-      @query_statistics = @response[2]
+      case @response.size
+      when 3
+        @header_row = @response[0]
+        @result_rows = @response[1]
+        @query_statistics = @response[2]
+      when 1 # queries with no RETURN clause
+        @header_row = []
+        @result_rows = []
+        @query_statistics = @response[0]
+      end
     end
 
     def stats
@@ -121,6 +128,8 @@ module Redgraph
         case label
         when /^Nodes created/
           stats[:nodes_created] = value.to_i
+        when /^Nodes deleted/
+          stats[:nodes_deleted] = value.to_i
         when /^Relationships created/
           stats[:relationships_created] = value.to_i
         when /^Properties set/

data/lib/redgraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Redgraph
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/test/node_model_class_methods_test.rb

@@ -24,6 +24,11 @@ class NodeModelClassMethodsTest < Minitest::Test
     attribute :name
   end
 
+  class MissingGraphActor
+    include Redgraph::NodeModel
+    attribute :name
+  end
+
   # tests
   #
 
@@ -63,4 +68,26 @@ class NodeModelClassMethodsTest < Minitest::Test
     item = Actor.find("-1")
     assert_nil(item)
   end
+
+  def test_create
+    assert_equal(0, Actor.count)
+
+    actor = Actor.create(name: "Harrison Ford")
+
+    assert_equal(1, Actor.count)
+    assert_predicate(actor, :persisted?)
+    assert_equal("Harrison Ford", actor.name)
+    assert_equal("actor", actor.label)
+
+    found = Actor.find(actor.id)
+    assert_equal("Harrison Ford", found.name)
+    assert_equal("actor", found.label)
+    assert_equal(Actor.name, found._type)
+  end
+
+  def test_create_with_missing_graph
+    assert_raises(Redgraph::MissingGraphError) do
+      MissingGraphActor.create(name: "Harrison Ford")
+    end
+  end
 end

data/test/node_model_persistence_test.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class NodeModelPersistenceTest < Minitest::Test
+  include TestHelpers
+
+  GRAPH = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+  def setup
+    @graph = GRAPH
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  # test classes
+  #
+
+  class Film
+    include Redgraph::NodeModel
+    self.graph = GRAPH
+    attribute :name
+  end
+
+  # tests
+  #
+
+  def test_save_new
+    assert_equal(0, Film.count)
+
+    film = Film.new(name: "Star Wars")
+    film.save
+
+    assert_predicate(film, :persisted?)
+    assert_equal(1, Film.count)
+  end
+
+  def test_save_existing
+    film = Film.create(name: "Star Wars")
+    film.name = "Commando"
+    film.save
+
+    assert_equal(1, Film.count)
+    item = Film.find(film.id)
+    assert_equal("Commando", item.name)
+  end
+
+  def test_reload
+    film = Film.create(name: "Star Wars")
+    copy = Film.find(film.id)
+
+    assert_equal("Star Wars", copy.name)
+
+    film.name = "Commando"
+    film.save
+
+    assert_equal("Star Wars", copy.name)
+    assert_equal("Commando", copy.reload.name)
+  end
+
+  def test_destroy
+    film = Film.create(name: "Star Wars")
+    assert_equal(1, Film.count)
+    film.destroy
+    assert_predicate(film, :destroyed?)
+    assert_equal(0, Film.count)
+  end
+end

data/test/node_model_test.rb

@@ -123,4 +123,14 @@ class NodeModelTest < Minitest::Test
     assert_kind_of(Film, items[1][0])
   end
 
+  def test_casting_query_from_model
+    film = Film.create(name: "Star Wars", year: 1977)
+    Actor.create(name: "Harrison Ford")
+
+    items = film.query("MATCH (node) RETURN node ORDER BY node.name")
+    assert_equal(2, items.size)
+    assert_kind_of(Actor, items[0][0])
+    assert_kind_of(Film, items[1][0])
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redgraph
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Paolo Zaccagnini
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-19 00:00:00.000000000 Z
+date: 2021-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -63,6 +63,8 @@ files:
 - lib/redgraph/node.rb
 - lib/redgraph/node_model.rb
 - lib/redgraph/node_model/class_methods.rb
+- lib/redgraph/node_model/graph_manipulation.rb
+- lib/redgraph/node_model/persistence.rb
 - lib/redgraph/query_response.rb
 - lib/redgraph/util.rb
 - lib/redgraph/version.rb
@@ -75,6 +77,7 @@ files:
 - test/graph_test.rb
 - test/node_model_class_methods_test.rb
 - test/node_model_labels_test.rb
+- test/node_model_persistence_test.rb
 - test/node_model_test.rb
 - test/redgraph_test.rb
 - test/test_helper.rb